smart-search-back/internal/grpc/tests/full_flow_test.go

package tests

import (
	"context"

	authpb "git.techease.ru/Smart-search/smart-search-back/pkg/pb/auth"
	invitepb "git.techease.ru/Smart-search/smart-search-back/pkg/pb/invite"
	requestpb "git.techease.ru/Smart-search/smart-search-back/pkg/pb/request"
	supplierpb "git.techease.ru/Smart-search/smart-search-back/pkg/pb/supplier"
	userpb "git.techease.ru/Smart-search/smart-search-back/pkg/pb/user"
)

func (s *IntegrationSuite) TestFullFlow_CompleteRequestLifecycle() {
	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)
	s.NotEmpty(loginResp.AccessToken)
	s.NotEmpty(loginResp.RefreshToken)

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

	validateResp, err := s.authClient.Validate(ctx, validateReq)
	s.NoError(err)
	s.True(validateResp.Valid)
	userID := validateResp.UserId

	getUserInfoReq := &userpb.GetInfoRequest{
		UserId: userID,
	}

	userInfoResp, err := s.userClient.GetInfo(ctx, getUserInfoReq)
	s.NoError(err)
	s.NotNil(userInfoResp)
	s.Equal("test@example.com", userInfoResp.Email)

	getBalanceReq := &userpb.GetBalanceRequest{
		UserId: userID,
	}

	balanceResp, err := s.userClient.GetBalance(ctx, getBalanceReq)
	s.NoError(err)
	s.GreaterOrEqual(balanceResp.Balance, 0.0)

	createTZReq := &requestpb.CreateTZRequest{
		UserId:     userID,
		RequestTxt: "Нужны поставщики металлоконструкций",
	}

	createTZResp, err := s.requestClient.CreateTZ(ctx, createTZReq)
	if err != nil {
		s.T().Logf("CreateTZ failed: %v", err)
		return
	}
	s.NotEmpty(createTZResp.RequestId)
	s.NotEmpty(createTZResp.TzText)
	requestID := createTZResp.RequestId

	approveTZReq := &requestpb.ApproveTZRequest{
		RequestId: requestID,
		FinalTz:   "Утвержденное ТЗ для поставщиков металлоконструкций",
		UserId:    userID,
	}

	approveTZResp, err := s.requestClient.ApproveTZ(ctx, approveTZReq)
	if err != nil {
		s.T().Logf("ApproveTZ failed: %v", err)
		return
	}
	s.True(approveTZResp.Success)

	getMailingListReq := &requestpb.GetMailingListRequest{
		UserId: userID,
	}

	mailingListResp, err := s.requestClient.GetMailingList(ctx, getMailingListReq)
	s.NoError(err)
	s.NotNil(mailingListResp.Items)
	s.GreaterOrEqual(len(mailingListResp.Items), 1)

	getMailingListByIDReq := &requestpb.GetMailingListByIDRequest{
		RequestId: requestID,
		UserId:    userID,
	}

	mailingListByIDResp, err := s.requestClient.GetMailingListByID(ctx, getMailingListByIDReq)
	if err != nil {
		s.T().Logf("GetMailingListByID failed: %v", err)
		return
	}
	s.NotNil(mailingListByIDResp.Item)
	s.Equal(requestID, mailingListByIDResp.Item.RequestId)

	exportExcelReq := &supplierpb.ExportExcelRequest{
		RequestId: requestID,
		UserId:    userID,
	}

	exportExcelResp, err := s.supplierClient.ExportExcel(ctx, exportExcelReq)
	if err != nil {
		s.T().Logf("ExportExcel failed (expected if no suppliers): %v", err)
	} else {
		s.NotNil(exportExcelResp)
		s.NotEmpty(exportExcelResp.FileName)
	}

	getStatisticsReq := &userpb.GetStatisticsRequest{
		UserId: userID,
	}

	statisticsResp, err := s.userClient.GetStatistics(ctx, getStatisticsReq)
	s.NoError(err)
	s.GreaterOrEqual(statisticsResp.TotalRequests, int32(0))

	logoutReq := &authpb.LogoutRequest{
		AccessToken: loginResp.AccessToken,
	}

	logoutResp, err := s.authClient.Logout(ctx, logoutReq)
	s.NoError(err)
	s.True(logoutResp.Success)
}

func (s *IntegrationSuite) TestFullFlow_InviteCodeLifecycle() {
	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)
	userID := validateResp.UserId

	generateInviteReq := &invitepb.GenerateRequest{
		UserId:  userID,
		TtlDays: 7,
		MaxUses: 5,
	}

	generateInviteResp, err := s.inviteClient.Generate(ctx, generateInviteReq)
	s.NoError(err)
	s.NotEmpty(generateInviteResp.Code)
	s.Greater(generateInviteResp.MaxUses, int32(0))
	inviteCode := generateInviteResp.Code

	getInviteInfoReq := &invitepb.GetInfoRequest{
		Code: inviteCode,
	}

	inviteInfoResp, err := s.inviteClient.GetInfo(ctx, getInviteInfoReq)
	s.NoError(err)
	s.Equal(inviteCode, inviteInfoResp.Code)
	s.Equal(userID, inviteInfoResp.UserId)
	s.Equal(generateInviteResp.MaxUses, inviteInfoResp.CanBeUsedCount)
	s.Equal(int32(0), inviteInfoResp.UsedCount)
	s.True(inviteInfoResp.IsActive)

	logoutReq := &authpb.LogoutRequest{
		AccessToken: loginResp.AccessToken,
	}

	logoutResp, err := s.authClient.Logout(ctx, logoutReq)
	s.NoError(err)
	s.True(logoutResp.Success)
}

func (s *IntegrationSuite) TestFullFlow_MultipleRefresh() {
	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)
	s.NotEmpty(loginResp.AccessToken)
	s.NotEmpty(loginResp.RefreshToken)

	refreshToken := loginResp.RefreshToken

	refreshReq1 := &authpb.RefreshRequest{
		RefreshToken: refreshToken,
		Ip:           "127.0.0.1",
		UserAgent:    "integration-test",
	}

	refreshResp1, err := s.authClient.Refresh(ctx, refreshReq1)
	s.NoError(err)
	s.NotEmpty(refreshResp1.AccessToken)

	refreshReq2 := &authpb.RefreshRequest{
		RefreshToken: refreshToken,
		Ip:           "127.0.0.1",
		UserAgent:    "integration-test",
	}

	refreshResp2, err := s.authClient.Refresh(ctx, refreshReq2)
	s.NoError(err)
	s.NotEmpty(refreshResp2.AccessToken)

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

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

	logoutReq := &authpb.LogoutRequest{
		AccessToken: refreshResp2.AccessToken,
	}

	logoutResp, err := s.authClient.Logout(ctx, logoutReq)
	s.NoError(err)
	s.True(logoutResp.Success)
}