smart-search-back/tests/user_handler_test.go

package tests

import (
	"context"

	authpb "git.techease.ru/Smart-search/smart-search-back/pkg/pb/auth"
	userpb "git.techease.ru/Smart-search/smart-search-back/pkg/pb/user"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

func (s *IntegrationSuite) TestUserHandler_GetInfoWithNonExistentUser() {
	req := &userpb.GetInfoRequest{
		UserId: 999999,
	}

	resp, err := s.userClient.GetInfo(context.Background(), req)

	s.Error(err)
	s.Nil(resp)

	st, ok := status.FromError(err)
	s.True(ok)
	s.Equal(codes.NotFound, st.Code())
}

func (s *IntegrationSuite) TestUserHandler_GetBalanceWithNonExistentUser() {
	req := &userpb.GetBalanceRequest{
		UserId: 999999,
	}

	resp, err := s.userClient.GetBalance(context.Background(), req)

	s.Error(err)
	s.Nil(resp)

	st, ok := status.FromError(err)
	s.True(ok)
	s.Equal(codes.NotFound, st.Code())
}

func (s *IntegrationSuite) TestUserHandler_GetStatisticsWithNonExistentUser() {
	req := &userpb.GetStatisticsRequest{
		UserId: 999999,
	}

	resp, err := s.userClient.GetStatistics(context.Background(), req)

	if err != nil {
		st, ok := status.FromError(err)
		s.True(ok)
		s.Equal(codes.NotFound, st.Code())
		return
	}

	s.NotNil(resp)
	s.Equal(int32(0), resp.TotalRequests)
}

func (s *IntegrationSuite) TestUserHandler_GetBalanceStatistics() {
	req := &userpb.GetBalanceStatisticsRequest{
		UserId: 1,
	}

	resp, err := s.userClient.GetBalanceStatistics(context.Background(), req)

	if err != nil {
		st, ok := status.FromError(err)
		s.True(ok)
		s.Equal(codes.NotFound, st.Code())
		return
	}

	s.NotNil(resp)
	s.GreaterOrEqual(resp.AverageCost, 0.0)
}

func (s *IntegrationSuite) TestUserHandler_GetInfoWithValidUser() {
	ctx := context.Background()

	loginReq := &authpb.LoginRequest{
		Email:     "test@example.com",
		Password:  "testpassword",
		Ip:        "127.0.0.1",
		UserAgent: "integration-test",
	}

	loginResp, err := s.authClient.Login(ctx, loginReq)
	s.NoError(err)

	validateReq := &authpb.ValidateRequest{
		AccessToken: loginResp.AccessToken,
	}

	validateResp, err := s.authClient.Validate(ctx, validateReq)
	s.NoError(err)

	req := &userpb.GetInfoRequest{
		UserId: validateResp.UserId,
	}

	resp, err := s.userClient.GetInfo(ctx, req)
	s.NoError(err)
	s.NotNil(resp)
	s.Equal("test@example.com", resp.Email)
	s.Equal("Test User", resp.Name)
	s.Equal("+1234567890", resp.Phone)
	s.Equal("Test Company", resp.CompanyName)
	s.Equal("active", resp.PaymentStatus)
}

func (s *IntegrationSuite) TestUserHandler_GetBalanceWithValidUser() {
	ctx := context.Background()

	loginReq := &authpb.LoginRequest{
		Email:     "test@example.com",
		Password:  "testpassword",
		Ip:        "127.0.0.1",
		UserAgent: "integration-test",
	}

	loginResp, err := s.authClient.Login(ctx, loginReq)
	s.NoError(err)

	validateReq := &authpb.ValidateRequest{
		AccessToken: loginResp.AccessToken,
	}

	validateResp, err := s.authClient.Validate(ctx, validateReq)
	s.NoError(err)

	req := &userpb.GetBalanceRequest{
		UserId: validateResp.UserId,
	}

	resp, err := s.userClient.GetBalance(ctx, req)
	s.NoError(err)
	s.NotNil(resp)
	s.GreaterOrEqual(resp.Balance, 0.0)
}

func (s *IntegrationSuite) TestUserHandler_GetStatisticsWithValidUser() {
	ctx := context.Background()

	loginReq := &authpb.LoginRequest{
		Email:     "test@example.com",
		Password:  "testpassword",
		Ip:        "127.0.0.1",
		UserAgent: "integration-test",
	}

	loginResp, err := s.authClient.Login(ctx, loginReq)
	s.NoError(err)

	validateReq := &authpb.ValidateRequest{
		AccessToken: loginResp.AccessToken,
	}

	validateResp, err := s.authClient.Validate(ctx, validateReq)
	s.NoError(err)

	req := &userpb.GetStatisticsRequest{
		UserId: validateResp.UserId,
	}

	resp, err := s.userClient.GetStatistics(ctx, req)
	s.NoError(err)
	s.NotNil(resp)
	s.GreaterOrEqual(resp.TotalRequests, int32(0))
	s.GreaterOrEqual(resp.SuccessfulRequests, int32(0))
	s.GreaterOrEqual(resp.FailedRequests, int32(0))
	s.GreaterOrEqual(resp.TotalSpent, 0.0)
}