Merge branch 'test'

# Conflicts:
#	Dockerfile

Dockerfile

@@ -20,7 +20,7 @@ WORKDIR /root/
 
 COPY --from=builder /app/server .
 COPY --from=builder /app/migrations ./migrations
-RUN mkdir -p ./config
+COPY --from=builder /app/config/boot.yaml ./config/boot.yaml
 
 EXPOSE 9091
 

tests/repository_test.go

@@ -0,0 +1,274 @@
+package tests
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"git.techease.ru/Smart-search/smart-search-back/internal/model"
+	"git.techease.ru/Smart-search/smart-search-back/internal/repository"
+	"git.techease.ru/Smart-search/smart-search-back/pkg/crypto"
+	"github.com/google/uuid"
+)
+
+func (s *IntegrationSuite) TestRepository_InviteIncrementUsedCount() {
+	inviteRepo := repository.NewInviteRepository(s.pool)
+	ctx := context.Background()
+
+	var userID int
+	err := s.pool.QueryRow(ctx, "SELECT id FROM users LIMIT 1").Scan(&userID)
+	s.Require().NoError(err)
+
+	invite := &model.InviteCode{
+		UserID:         userID,
+		Code:           time.Now().UnixNano(),
+		CanBeUsedCount: 10,
+		ExpiresAt:      time.Now().Add(24 * time.Hour),
+	}
+	err = inviteRepo.Create(ctx, invite)
+	s.Require().NoError(err)
+
+	err = inviteRepo.IncrementUsedCount(ctx, invite.Code)
+	s.NoError(err)
+
+	found, err := inviteRepo.FindByCode(ctx, invite.Code)
+	s.NoError(err)
+	s.Equal(1, found.UsedCount)
+}
+
+func (s *IntegrationSuite) TestRepository_InviteDeactivateExpired() {
+	inviteRepo := repository.NewInviteRepository(s.pool)
+	ctx := context.Background()
+
+	var userID int
+	err := s.pool.QueryRow(ctx, "SELECT id FROM users LIMIT 1").Scan(&userID)
+	s.Require().NoError(err)
+
+	expiredCode := time.Now().UnixNano()
+	_, err = s.pool.Exec(ctx, `
+		INSERT INTO invite_codes (user_id, code, can_be_used_count, expires_at, is_active)
+		VALUES ($1, $2, 10, now() - interval '1 hour', true)
+	`, userID, expiredCode)
+	s.Require().NoError(err)
+
+	count, err := inviteRepo.DeactivateExpired(ctx)
+	s.NoError(err)
+	s.GreaterOrEqual(count, 1)
+}
+
+func (s *IntegrationSuite) TestRepository_InviteGetUserInvites() {
+	inviteRepo := repository.NewInviteRepository(s.pool)
+	ctx := context.Background()
+
+	var userID int
+	err := s.pool.QueryRow(ctx, "SELECT id FROM users LIMIT 1").Scan(&userID)
+	s.Require().NoError(err)
+
+	invite := &model.InviteCode{
+		UserID:         userID,
+		Code:           time.Now().UnixNano(),
+		CanBeUsedCount: 10,
+		ExpiresAt:      time.Now().Add(24 * time.Hour),
+	}
+	err = inviteRepo.Create(ctx, invite)
+	s.Require().NoError(err)
+
+	invites, err := inviteRepo.GetUserInvites(ctx, userID)
+	s.NoError(err)
+	s.GreaterOrEqual(len(invites), 1)
+}
+
+func (s *IntegrationSuite) TestRepository_SessionRevoke() {
+	sessionRepo := repository.NewSessionRepository(s.pool)
+	ctx := context.Background()
+
+	var userID int
+	err := s.pool.QueryRow(ctx, "SELECT id FROM users LIMIT 1").Scan(&userID)
+	s.Require().NoError(err)
+
+	session := &model.Session{
+		UserID:       userID,
+		AccessToken:  "test-access-token-" + uuid.New().String(),
+		RefreshToken: "test-refresh-token-" + uuid.New().String(),
+		IP:           "127.0.0.1",
+		UserAgent:    "test-agent",
+		ExpiresAt:    time.Now().Add(24 * time.Hour),
+	}
+	err = sessionRepo.Create(ctx, session)
+	s.Require().NoError(err)
+
+	err = sessionRepo.Revoke(ctx, session.RefreshToken)
+	s.NoError(err)
+
+	_, err = sessionRepo.FindByRefreshToken(ctx, session.RefreshToken)
+	s.Error(err)
+}
+
+func (s *IntegrationSuite) TestRepository_SessionDeleteExpired() {
+	sessionRepo := repository.NewSessionRepository(s.pool)
+	ctx := context.Background()
+
+	var userID int
+	err := s.pool.QueryRow(ctx, "SELECT id FROM users LIMIT 1").Scan(&userID)
+	s.Require().NoError(err)
+
+	_, err = s.pool.Exec(ctx, `
+		INSERT INTO sessions (user_id, access_token, refresh_token, ip, user_agent, expires_at)
+		VALUES ($1, $2, $3, '127.0.0.1', 'test', now() - interval '1 hour')
+	`, userID, "expired-access-"+uuid.New().String(), "expired-refresh-"+uuid.New().String())
+	s.Require().NoError(err)
+
+	count, err := sessionRepo.DeleteExpired(ctx)
+	s.NoError(err)
+	s.GreaterOrEqual(count, 1)
+}
+
+func (s *IntegrationSuite) TestRepository_RequestUpdateWithTZ() {
+	requestRepo := repository.NewRequestRepository(s.pool)
+	ctx := context.Background()
+
+	var userID int
+	err := s.pool.QueryRow(ctx, "SELECT id FROM users LIMIT 1").Scan(&userID)
+	s.Require().NoError(err)
+
+	req := &model.Request{
+		UserID:     userID,
+		RequestTxt: "Test request for TZ update",
+	}
+	err = requestRepo.Create(ctx, req)
+	s.Require().NoError(err)
+
+	err = requestRepo.UpdateWithTZ(ctx, req.ID, "Generated TZ text", true)
+	s.NoError(err)
+}
+
+func (s *IntegrationSuite) TestRepository_RequestGetByID() {
+	requestRepo := repository.NewRequestRepository(s.pool)
+	ctx := context.Background()
+
+	var userID int
+	err := s.pool.QueryRow(ctx, "SELECT id FROM users LIMIT 1").Scan(&userID)
+	s.Require().NoError(err)
+
+	var reqID uuid.UUID
+	err = s.pool.QueryRow(ctx, `
+		INSERT INTO requests_for_suppliers (user_id, request_txt, final_tz, final_update_tz, mailling_status_id)
+		VALUES ($1, 'Test request', 'TZ text', 'Final TZ', 1)
+		RETURNING id
+	`, userID).Scan(&reqID)
+	s.Require().NoError(err)
+
+	found, err := requestRepo.GetByID(ctx, reqID)
+	s.NoError(err)
+	s.Equal(reqID, found.ID)
+	s.Equal("Test request", found.RequestTxt)
+}
+
+func (s *IntegrationSuite) TestRepository_SupplierBulkInsertAndDelete() {
+	supplierRepo := repository.NewSupplierRepository(s.pool)
+	requestRepo := repository.NewRequestRepository(s.pool)
+	ctx := context.Background()
+
+	var userID int
+	err := s.pool.QueryRow(ctx, "SELECT id FROM users LIMIT 1").Scan(&userID)
+	s.Require().NoError(err)
+
+	req := &model.Request{
+		UserID:     userID,
+		RequestTxt: "Test request for suppliers",
+	}
+	err = requestRepo.Create(ctx, req)
+	s.Require().NoError(err)
+
+	suppliers := []*model.Supplier{
+		{Name: "Supplier 1", Email: "s1@test.com"},
+		{Name: "Supplier 2", Email: "s2@test.com"},
+	}
+	err = supplierRepo.BulkInsert(ctx, req.ID, suppliers)
+	s.NoError(err)
+
+	found, err := supplierRepo.GetByRequestID(ctx, req.ID)
+	s.NoError(err)
+	s.Equal(2, len(found))
+
+	err = supplierRepo.DeleteByRequestID(ctx, req.ID)
+	s.NoError(err)
+
+	found, err = supplierRepo.GetByRequestID(ctx, req.ID)
+	s.NoError(err)
+	s.Equal(0, len(found))
+}
+
+func (s *IntegrationSuite) TestRepository_TokenUsageCreate() {
+	tokenRepo := repository.NewTokenUsageRepository(s.pool)
+	requestRepo := repository.NewRequestRepository(s.pool)
+	ctx := context.Background()
+
+	var userID int
+	err := s.pool.QueryRow(ctx, "SELECT id FROM users LIMIT 1").Scan(&userID)
+	s.Require().NoError(err)
+
+	req := &model.Request{
+		UserID:     userID,
+		RequestTxt: "Test request for token usage",
+	}
+	err = requestRepo.Create(ctx, req)
+	s.Require().NoError(err)
+
+	usage := &model.TokenUsage{
+		RequestID:          req.ID,
+		RequestTokenCount:  100,
+		ResponseTokenCount: 50,
+		TokenCost:          0.005,
+		Type:               "openai",
+	}
+	err = tokenRepo.Create(ctx, usage)
+	s.NoError(err)
+}
+
+func (s *IntegrationSuite) TestRepository_UserCreate() {
+	userRepo := repository.NewUserRepository(s.pool, testCryptoSecret)
+	ctx := context.Background()
+
+	cryptoHelper := crypto.NewCrypto(testCryptoSecret)
+	email := fmt.Sprintf("newuser_%d@test.com", time.Now().UnixNano())
+
+	user := &model.User{
+		Email:         email,
+		EmailHash:     cryptoHelper.EmailHash(email),
+		PasswordHash:  crypto.PasswordHash("password123"),
+		Phone:         "+1234567890",
+		UserName:      "New User",
+		CompanyName:   "Test Company",
+		Balance:       100.0,
+		PaymentStatus: "active",
+	}
+
+	err := userRepo.Create(ctx, user)
+	s.NoError(err)
+	s.NotZero(user.ID)
+
+	_, err = s.pool.Exec(ctx, "DELETE FROM users WHERE id = $1", user.ID)
+	s.NoError(err)
+}
+
+func (s *IntegrationSuite) TestRepository_UserCheckInviteLimit() {
+	userRepo := repository.NewUserRepository(s.pool, testCryptoSecret)
+	ctx := context.Background()
+
+	var userID int
+	err := s.pool.QueryRow(ctx, "SELECT id FROM users LIMIT 1").Scan(&userID)
+	s.Require().NoError(err)
+
+	canInvite, err := userRepo.CheckInviteLimit(ctx, userID)
+	s.NoError(err)
+	s.True(canInvite)
+}
+
+func (s *IntegrationSuite) TestRepository_TxManagerPool() {
+	txManager := repository.NewTxManager(s.pool)
+
+	pool := txManager.Pool()
+	s.NotNil(pool)
+	s.Equal(s.pool, pool)
+}