diff --git a/core-service/examples/api_test.go b/core-service/examples/api_test.go new file mode 100644 index 0000000..726d4b6 --- /dev/null +++ b/core-service/examples/api_test.go @@ -0,0 +1,348 @@ +package examples + +import ( + "bytes" + "context" + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/gin-gonic/gin" + "github.com/google/uuid" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + + "erp-mvp/core-service/internal/api/handlers" + "erp-mvp/core-service/internal/api/middleware" + "erp-mvp/core-service/internal/auth" + "erp-mvp/core-service/internal/models" +) + +// MockAuthService мок для AuthService +type MockAuthService struct { + mock.Mock +} + +func (m *MockAuthService) Register(ctx context.Context, req *models.RegisterRequest) (*models.LoginResponse, error) { + args := m.Called(ctx, req) + return args.Get(0).(*models.LoginResponse), args.Error(1) +} + +func (m *MockAuthService) Login(ctx context.Context, req *models.LoginRequest) (*models.LoginResponse, error) { + args := m.Called(ctx, req) + return args.Get(0).(*models.LoginResponse), args.Error(1) +} + +// TestAuthHandler_Register тестирует endpoint регистрации +func TestAuthHandler_Register(t *testing.T) { + // Arrange + gin.SetMode(gin.TestMode) + + mockAuthService := &MockAuthService{} + handler := handlers.NewAuthHandler(mockAuthService) + + router := gin.New() + router.POST("/register", handler.Register) + + registerReq := &models.RegisterRequest{ + OrganizationName: "Test Workshop", + UserEmail: "admin@test.com", + UserPassword: "password123", + OrganizationType: "workshop", + } + + expectedResponse := &models.LoginResponse{ + Token: "test_token", + User: models.UserResponse{ + ID: uuid.New(), + Email: "admin@test.com", + Role: "admin", + }, + Organization: models.OrganizationResponse{ + ID: uuid.New(), + Name: "Test Workshop", + Type: "workshop", + }, + } + + mockAuthService.On("Register", mock.Anything, registerReq).Return(expectedResponse, nil) + + reqBody, _ := json.Marshal(registerReq) + + // Act + w := httptest.NewRecorder() + req, _ := http.NewRequest("POST", "/register", bytes.NewBuffer(reqBody)) + req.Header.Set("Content-Type", "application/json") + router.ServeHTTP(w, req) + + // Assert + assert.Equal(t, http.StatusCreated, w.Code) + + var response models.LoginResponse + err := json.Unmarshal(w.Body.Bytes(), &response) + assert.NoError(t, err) + assert.Equal(t, expectedResponse.Token, response.Token) + assert.Equal(t, expectedResponse.User.Email, response.User.Email) + assert.Equal(t, expectedResponse.Organization.Name, response.Organization.Name) + + mockAuthService.AssertExpectations(t) +} + +// TestAuthHandler_Login тестирует endpoint входа +func TestAuthHandler_Login(t *testing.T) { + // Arrange + gin.SetMode(gin.TestMode) + + mockAuthService := &MockAuthService{} + handler := handlers.NewAuthHandler(mockAuthService) + + router := gin.New() + router.POST("/login", handler.Login) + + loginReq := &models.LoginRequest{ + Email: "admin@test.com", + Password: "password123", + } + + expectedResponse := &models.LoginResponse{ + Token: "test_token", + User: models.UserResponse{ + ID: uuid.New(), + Email: "admin@test.com", + Role: "admin", + }, + Organization: models.OrganizationResponse{ + ID: uuid.New(), + Name: "Test Workshop", + Type: "workshop", + }, + } + + mockAuthService.On("Login", mock.Anything, loginReq).Return(expectedResponse, nil) + + reqBody, _ := json.Marshal(loginReq) + + // Act + w := httptest.NewRecorder() + req, _ := http.NewRequest("POST", "/login", bytes.NewBuffer(reqBody)) + req.Header.Set("Content-Type", "application/json") + router.ServeHTTP(w, req) + + // Assert + assert.Equal(t, http.StatusOK, w.Code) + + var response models.LoginResponse + err := json.Unmarshal(w.Body.Bytes(), &response) + assert.NoError(t, err) + assert.Equal(t, expectedResponse.Token, response.Token) + + mockAuthService.AssertExpectations(t) +} + +// TestAuthHandler_Register_ValidationError тестирует валидацию при регистрации +func TestAuthHandler_Register_ValidationError(t *testing.T) { + // Arrange + gin.SetMode(gin.TestMode) + + mockAuthService := &MockAuthService{} + handler := handlers.NewAuthHandler(mockAuthService) + + router := gin.New() + router.POST("/register", handler.Register) + + // Неверный запрос - отсутствует email + registerReq := map[string]interface{}{ + "organization_name": "Test Workshop", + "user_password": "password123", + "organization_type": "workshop", + } + + reqBody, _ := json.Marshal(registerReq) + + // Act + w := httptest.NewRecorder() + req, _ := http.NewRequest("POST", "/register", bytes.NewBuffer(reqBody)) + req.Header.Set("Content-Type", "application/json") + router.ServeHTTP(w, req) + + // Assert + assert.Equal(t, http.StatusBadRequest, w.Code) + + var errorResponse map[string]interface{} + err := json.Unmarshal(w.Body.Bytes(), &errorResponse) + assert.NoError(t, err) + assert.Contains(t, errorResponse["error"], "Validation failed") +} + +// TestAuthMiddleware тестирует middleware аутентификации +func TestAuthMiddleware(t *testing.T) { + // Arrange + gin.SetMode(gin.TestMode) + + secret := "test_secret_key" + ttl := 24 * time.Hour + jwtService := auth.NewJWTService(secret, ttl) + authMiddleware := middleware.NewAuthMiddleware(jwtService) + + router := gin.New() + router.Use(authMiddleware.AuthRequired()) + + router.GET("/protected", func(c *gin.Context) { + claims := middleware.GetClaims(c) + c.JSON(http.StatusOK, gin.H{ + "user_id": claims.UserID.String(), + "organization_id": claims.OrganizationID.String(), + "email": claims.Email, + "role": claims.Role, + }) + }) + + // Создаем валидный JWT токен + userID := uuid.New() + orgID := uuid.New() + validToken, err := jwtService.GenerateToken(userID, orgID, "test@example.com", "admin") + assert.NoError(t, err) + + // Act - тест с валидным токеном + w := httptest.NewRecorder() + req, _ := http.NewRequest("GET", "/protected", nil) + req.Header.Set("Authorization", "Bearer "+validToken) + router.ServeHTTP(w, req) + + // Assert + assert.Equal(t, http.StatusOK, w.Code) + + var response map[string]interface{} + err = json.Unmarshal(w.Body.Bytes(), &response) + assert.NoError(t, err) + assert.Equal(t, userID.String(), response["user_id"]) + assert.Equal(t, "test@example.com", response["email"]) + + // Act - тест без токена + w = httptest.NewRecorder() + req, _ = http.NewRequest("GET", "/protected", nil) + router.ServeHTTP(w, req) + + // Assert + assert.Equal(t, http.StatusUnauthorized, w.Code) + + // Act - тест с неверным токеном + w = httptest.NewRecorder() + req, _ = http.NewRequest("GET", "/protected", nil) + req.Header.Set("Authorization", "Bearer invalid_token") + router.ServeHTTP(w, req) + + // Assert + assert.Equal(t, http.StatusUnauthorized, w.Code) +} + +// TestLocationHandler_CreateLocation тестирует создание места хранения +func TestLocationHandler_CreateLocation(t *testing.T) { + // Arrange + gin.SetMode(gin.TestMode) + + mockLocationService := &MockLocationService{} + handler := handlers.NewLocationHandler(mockLocationService) + + router := gin.New() + router.Use(mockAuthMiddleware()) + router.POST("/locations", handler.CreateLocation) + + locationReq := &models.CreateLocationRequest{ + Name: "Test Location", + Address: "Test Address", + Type: "warehouse", + Coordinates: models.JSON{ + "lat": 55.7558, + "lng": 37.6176, + }, + } + + expectedLocation := &models.StorageLocation{ + ID: uuid.New(), + Name: "Test Location", + Address: "Test Address", + Type: "warehouse", + Coordinates: models.JSON{ + "lat": 55.7558, + "lng": 37.6176, + }, + } + + mockLocationService.On("CreateLocation", mock.Anything, mock.Anything, locationReq).Return(expectedLocation, nil) + + reqBody, _ := json.Marshal(locationReq) + + // Act + w := httptest.NewRecorder() + req, _ := http.NewRequest("POST", "/locations", bytes.NewBuffer(reqBody)) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Authorization", "Bearer test_token") + router.ServeHTTP(w, req) + + // Assert + assert.Equal(t, http.StatusCreated, w.Code) + + var response models.StorageLocation + err := json.Unmarshal(w.Body.Bytes(), &response) + assert.NoError(t, err) + assert.Equal(t, expectedLocation.Name, response.Name) + assert.Equal(t, expectedLocation.Type, response.Type) + + mockLocationService.AssertExpectations(t) +} + +// MockLocationService мок для LocationService +type MockLocationService struct { + mock.Mock +} + +func (m *MockLocationService) CreateLocation(ctx context.Context, orgID uuid.UUID, req *models.CreateLocationRequest) (*models.StorageLocation, error) { + args := m.Called(ctx, orgID, req) + return args.Get(0).(*models.StorageLocation), args.Error(1) +} + +func (m *MockLocationService) GetLocations(ctx context.Context, orgID uuid.UUID) ([]*models.StorageLocation, error) { + args := m.Called(ctx, orgID) + return args.Get(0).([]*models.StorageLocation), args.Error(1) +} + +func (m *MockLocationService) GetLocation(ctx context.Context, id, orgID uuid.UUID) (*models.StorageLocation, error) { + args := m.Called(ctx, id, orgID) + return args.Get(0).(*models.StorageLocation), args.Error(1) +} + +func (m *MockLocationService) UpdateLocation(ctx context.Context, id, orgID uuid.UUID, req *models.CreateLocationRequest) (*models.StorageLocation, error) { + args := m.Called(ctx, id, orgID, req) + return args.Get(0).(*models.StorageLocation), args.Error(1) +} + +func (m *MockLocationService) DeleteLocation(ctx context.Context, id, orgID uuid.UUID) error { + args := m.Called(ctx, id, orgID) + return args.Error(0) +} + +func (m *MockLocationService) GetChildren(ctx context.Context, parentID, orgID uuid.UUID) ([]*models.StorageLocation, error) { + args := m.Called(ctx, parentID, orgID) + return args.Get(0).([]*models.StorageLocation), args.Error(1) +} + +// mockAuthMiddleware создает middleware для тестов +func mockAuthMiddleware() gin.HandlerFunc { + return func(c *gin.Context) { + // Устанавливаем тестовые claims + claims := &auth.Claims{ + UserID: uuid.New(), + OrganizationID: uuid.New(), + Email: "test@example.com", + Role: "admin", + } + c.Set("user_id", claims.UserID) + c.Set("organization_id", claims.OrganizationID) + c.Set("email", claims.Email) + c.Set("role", claims.Role) + c.Next() + } +} diff --git a/core-service/examples/auth_test.go b/core-service/examples/auth_test.go new file mode 100644 index 0000000..a40504b --- /dev/null +++ b/core-service/examples/auth_test.go @@ -0,0 +1,183 @@ +package examples + +import ( + "testing" + "time" + + "github.com/golang-jwt/jwt/v5" + "github.com/google/uuid" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "erp-mvp/core-service/internal/auth" +) + +// TestJWTService_GenerateToken тестирует генерацию JWT токенов +func TestJWTService_GenerateToken(t *testing.T) { + // Arrange + secret := "test_secret_key" + ttl := 24 * time.Hour + jwtService := auth.NewJWTService(secret, ttl) + userID := uuid.New() + orgID := uuid.New() + email := "test@example.com" + role := "admin" + + // Act + token, err := jwtService.GenerateToken(userID, orgID, email, role) + + // Assert + require.NoError(t, err) + assert.NotEmpty(t, token) + + // Проверяем, что токен можно декодировать + parsedToken, err := jwt.Parse(token, func(token *jwt.Token) (interface{}, error) { + return []byte(secret), nil + }) + require.NoError(t, err) + assert.True(t, parsedToken.Valid) + + // Проверяем claims + claims, ok := parsedToken.Claims.(jwt.MapClaims) + require.True(t, ok) + assert.Equal(t, userID.String(), claims["user_id"]) + assert.Equal(t, orgID.String(), claims["organization_id"]) + assert.Equal(t, email, claims["email"]) + assert.Equal(t, role, claims["role"]) +} + +// TestJWTService_ValidateToken тестирует валидацию JWT токенов +func TestJWTService_ValidateToken(t *testing.T) { + // Arrange + secret := "test_secret_key" + ttl := 24 * time.Hour + jwtService := auth.NewJWTService(secret, ttl) + + // Создаем валидный токен для тестирования + userID := uuid.New() + orgID := uuid.New() + validToken, err := jwtService.GenerateToken(userID, orgID, "test@example.com", "admin") + require.NoError(t, err) + + tests := []struct { + name string + secret string + token string + wantErr bool + }{ + { + name: "valid token", + secret: secret, + token: validToken, + wantErr: false, + }, + { + name: "invalid signature", + secret: "wrong_secret", + token: validToken, + wantErr: true, + }, + { + name: "invalid token format", + secret: secret, + token: "invalid_token_format", + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Arrange + testJWTService := auth.NewJWTService(tt.secret, ttl) + + // Act + claims, err := testJWTService.ValidateToken(tt.token) + + // Assert + if tt.wantErr { + assert.Error(t, err) + assert.Nil(t, claims) + } else { + assert.NoError(t, err) + assert.NotNil(t, claims) + assert.Equal(t, userID, claims.UserID) + assert.Equal(t, orgID, claims.OrganizationID) + } + }) + } +} + +// TestPasswordHashing тестирует хеширование и проверку паролей +func TestPasswordHashing(t *testing.T) { + // Arrange + password := "mySecurePassword123" + + // Act - хешируем пароль + hashedPassword, err := auth.HashPassword(password) + + // Assert + require.NoError(t, err) + assert.NotEmpty(t, hashedPassword) + assert.NotEqual(t, password, hashedPassword) + + // Act - проверяем правильный пароль + isValid := auth.CheckPassword(password, hashedPassword) + + // Assert + assert.True(t, isValid) + + // Act - проверяем неправильный пароль + isValid = auth.CheckPassword("wrongPassword", hashedPassword) + + // Assert + assert.False(t, isValid) +} + +// TestPasswordHashing_EmptyPassword тестирует обработку пустого пароля +func TestPasswordHashing_EmptyPassword(t *testing.T) { + // Arrange + password := "" + + // Act + hashedPassword, err := auth.HashPassword(password) + + // Assert + assert.NoError(t, err) + assert.NotEmpty(t, hashedPassword) + + // Проверяем, что пустой пароль работает + isValid := auth.CheckPassword(password, hashedPassword) + assert.True(t, isValid) +} + +// BenchmarkPasswordHashing тестирует производительность хеширования +func BenchmarkPasswordHashing(b *testing.B) { + password := "benchmarkPassword123" + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := auth.HashPassword(password) + if err != nil { + b.Fatal(err) + } + } +} + +// BenchmarkJWTGeneration тестирует производительность генерации JWT +func BenchmarkJWTGeneration(b *testing.B) { + secret := "benchmark_secret_key" + ttl := 24 * time.Hour + jwtService := auth.NewJWTService(secret, ttl) + userID := uuid.New() + orgID := uuid.New() + email := "benchmark@example.com" + role := "admin" + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := jwtService.GenerateToken(userID, orgID, email, role) + if err != nil { + b.Fatal(err) + } + } +} diff --git a/core-service/examples/repository_test.go b/core-service/examples/repository_test.go new file mode 100644 index 0000000..c870074 --- /dev/null +++ b/core-service/examples/repository_test.go @@ -0,0 +1,373 @@ +package examples + +import ( + "context" + "database/sql" + "testing" + "time" + + "github.com/DATA-DOG/go-sqlmock" + "github.com/google/uuid" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "erp-mvp/core-service/internal/models" + "erp-mvp/core-service/internal/repository" +) + +// TestOrganizationRepository_Create тестирует создание организации +func TestOrganizationRepository_Create(t *testing.T) { + // Arrange + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer db.Close() + + repo := repository.NewOrganizationRepository(db) + + orgID := uuid.New() + org := &models.Organization{ + ID: orgID, + Name: "Test Organization", + Type: "workshop", + Settings: models.JSON{ + "created_at": 1234567890, + }, + CreatedAt: time.Now(), + } + + // Ожидаем SQL запрос + mock.ExpectExec("INSERT INTO organizations"). + WithArgs(orgID, org.Name, org.Type, sqlmock.AnyArg(), sqlmock.AnyArg()). + WillReturnResult(sqlmock.NewResult(1, 1)) + + // Act + err = repo.Create(context.Background(), org) + + // Assert + assert.NoError(t, err) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +// TestOrganizationRepository_GetByID тестирует получение организации по ID +func TestOrganizationRepository_GetByID(t *testing.T) { + // Arrange + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer db.Close() + + repo := repository.NewOrganizationRepository(db) + + orgID := uuid.New() + expectedOrg := &models.Organization{ + ID: orgID, + Name: "Test Organization", + Type: "workshop", + Settings: models.JSON{ + "created_at": 1234567890, + }, + } + + // Ожидаем SQL запрос + rows := sqlmock.NewRows([]string{"id", "name", "type", "settings", "created_at"}). + AddRow(orgID, expectedOrg.Name, expectedOrg.Type, `{"created_at":1234567890}`, time.Now()) + + mock.ExpectQuery("SELECT (.+) FROM organizations"). + WithArgs(orgID). + WillReturnRows(rows) + + // Act + org, err := repo.GetByID(context.Background(), orgID) + + // Assert + assert.NoError(t, err) + assert.NotNil(t, org) + assert.Equal(t, expectedOrg.ID, org.ID) + assert.Equal(t, expectedOrg.Name, org.Name) + assert.Equal(t, expectedOrg.Type, org.Type) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +// TestOrganizationRepository_GetByID_NotFound тестирует случай, когда организация не найдена +func TestOrganizationRepository_GetByID_NotFound(t *testing.T) { + // Arrange + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer db.Close() + + repo := repository.NewOrganizationRepository(db) + orgID := uuid.New() + + // Ожидаем SQL запрос с пустым результатом + mock.ExpectQuery("SELECT (.+) FROM organizations"). + WithArgs(orgID). + WillReturnError(sql.ErrNoRows) + + // Act + org, err := repo.GetByID(context.Background(), orgID) + + // Assert + assert.Error(t, err) + assert.Nil(t, org) + assert.Equal(t, "organization not found", err.Error()) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +// TestUserRepository_Create тестирует создание пользователя +func TestUserRepository_Create(t *testing.T) { + // Arrange + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer db.Close() + + repo := repository.NewUserRepository(db) + + userID := uuid.New() + orgID := uuid.New() + user := &models.User{ + ID: userID, + OrganizationID: orgID, + Email: "test@example.com", + PasswordHash: "hashed_password", + Role: "admin", + CreatedAt: time.Now(), + } + password := "hashed_password" + + // Ожидаем SQL запрос + mock.ExpectExec("INSERT INTO users"). + WithArgs(userID, orgID, user.Email, password, user.Role, sqlmock.AnyArg()). + WillReturnResult(sqlmock.NewResult(1, 1)) + + // Act + err = repo.Create(context.Background(), user, password) + + // Assert + assert.NoError(t, err) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +// TestUserRepository_GetByEmail тестирует получение пользователя по email +func TestUserRepository_GetByEmail(t *testing.T) { + // Arrange + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer db.Close() + + repo := repository.NewUserRepository(db) + + userID := uuid.New() + orgID := uuid.New() + email := "test@example.com" + expectedUser := &models.User{ + ID: userID, + OrganizationID: orgID, + Email: email, + PasswordHash: "hashed_password", + Role: "admin", + } + + // Ожидаем SQL запрос + rows := sqlmock.NewRows([]string{"id", "organization_id", "email", "password_hash", "role", "created_at"}). + AddRow(userID, orgID, email, "hashed_password", "admin", time.Now()) + + mock.ExpectQuery("SELECT (.+) FROM users"). + WithArgs(email). + WillReturnRows(rows) + + // Act + user, err := repo.GetByEmail(context.Background(), email) + + // Assert + assert.NoError(t, err) + assert.NotNil(t, user) + assert.Equal(t, expectedUser.ID, user.ID) + assert.Equal(t, expectedUser.Email, user.Email) + assert.Equal(t, expectedUser.Role, user.Role) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +// TestLocationRepository_Create тестирует создание места хранения +func TestLocationRepository_Create(t *testing.T) { + // Arrange + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer db.Close() + + repo := repository.NewLocationRepository(db) + + locationID := uuid.New() + orgID := uuid.New() + location := &models.StorageLocation{ + ID: locationID, + OrganizationID: orgID, + Name: "Test Location", + Address: "Test Address", + Type: "warehouse", + Coordinates: models.JSON{ + "lat": 55.7558, + "lng": 37.6176, + }, + CreatedAt: time.Now(), + } + + // Ожидаем SQL запрос + mock.ExpectExec("INSERT INTO storage_locations"). + WithArgs(locationID, orgID, sqlmock.AnyArg(), location.Name, location.Address, location.Type, sqlmock.AnyArg(), sqlmock.AnyArg()). + WillReturnResult(sqlmock.NewResult(1, 1)) + + // Act + err = repo.Create(context.Background(), location) + + // Assert + assert.NoError(t, err) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +// TestLocationRepository_GetByID тестирует получение места хранения по ID +func TestLocationRepository_GetByID(t *testing.T) { + // Arrange + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer db.Close() + + repo := repository.NewLocationRepository(db) + + locationID := uuid.New() + orgID := uuid.New() + expectedLocation := &models.StorageLocation{ + ID: locationID, + OrganizationID: orgID, + Name: "Test Location", + Address: "Test Address", + Type: "warehouse", + Coordinates: models.JSON{ + "lat": 55.7558, + "lng": 37.6176, + }, + } + + // Ожидаем SQL запрос + rows := sqlmock.NewRows([]string{"id", "organization_id", "parent_id", "name", "address", "type", "coordinates", "created_at"}). + AddRow(locationID, orgID, nil, expectedLocation.Name, expectedLocation.Address, expectedLocation.Type, `{"lat":55.7558,"lng":37.6176}`, time.Now()) + + mock.ExpectQuery("SELECT (.+) FROM storage_locations"). + WithArgs(locationID, orgID). + WillReturnRows(rows) + + // Act + location, err := repo.GetByID(context.Background(), locationID, orgID) + + // Assert + assert.NoError(t, err) + assert.NotNil(t, location) + assert.Equal(t, expectedLocation.ID, location.ID) + assert.Equal(t, expectedLocation.Name, location.Name) + assert.Equal(t, expectedLocation.Type, location.Type) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +// TestItemRepository_Create тестирует создание товара +func TestItemRepository_Create(t *testing.T) { + // Arrange + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer db.Close() + + repo := repository.NewItemRepository(db) + + itemID := uuid.New() + orgID := uuid.New() + item := &models.Item{ + ID: itemID, + OrganizationID: orgID, + Name: "Test Item", + Description: "Test Description", + Category: "Test Category", + CreatedAt: time.Now(), + } + + // Ожидаем SQL запрос + mock.ExpectExec("INSERT INTO items"). + WithArgs(itemID, orgID, item.Name, item.Description, item.Category, sqlmock.AnyArg()). + WillReturnResult(sqlmock.NewResult(1, 1)) + + // Act + err = repo.Create(context.Background(), item) + + // Assert + assert.NoError(t, err) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +// TestOperationsRepository_PlaceItem тестирует размещение товара +func TestOperationsRepository_PlaceItem(t *testing.T) { + // Arrange + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer db.Close() + + repo := repository.NewOperationsRepository(db) + + placementID := uuid.New() + orgID := uuid.New() + itemID := uuid.New() + locationID := uuid.New() + placement := &models.ItemPlacement{ + ID: placementID, + OrganizationID: orgID, + ItemID: itemID, + LocationID: locationID, + Quantity: 5, + CreatedAt: time.Now(), + } + + // Ожидаем SQL запрос + mock.ExpectExec("INSERT INTO item_placements"). + WithArgs(placementID, orgID, itemID, locationID, placement.Quantity, sqlmock.AnyArg()). + WillReturnResult(sqlmock.NewResult(1, 1)) + + // Act + err = repo.PlaceItem(context.Background(), placement) + + // Assert + assert.NoError(t, err) + assert.NoError(t, mock.ExpectationsWereMet()) +} + +// TestOperationsRepository_Search тестирует поиск товаров с местами размещения +func TestOperationsRepository_Search(t *testing.T) { + // Arrange + db, mock, err := sqlmock.New() + require.NoError(t, err) + defer db.Close() + + repo := repository.NewOperationsRepository(db) + + orgID := uuid.New() + itemID := uuid.New() + locationID := uuid.New() + + // Ожидаем SQL запрос с JOIN + rows := sqlmock.NewRows([]string{ + "i.id", "i.organization_id", "i.name", "i.description", "i.category", "i.created_at", + "sl.id", "sl.organization_id", "sl.parent_id", "sl.name", "sl.address", "sl.type", "sl.coordinates", "sl.created_at", + "ip.quantity", + }).AddRow( + itemID, orgID, "Test Item", "Test Description", "Test Category", time.Now(), + locationID, orgID, nil, "Test Location", "Test Address", "warehouse", `{"lat":55.7558,"lng":37.6176}`, time.Now(), + 5, + ) + + mock.ExpectQuery("SELECT (.+) FROM items i"). + WithArgs(orgID, "%test%"). + WillReturnRows(rows) + + // Act + results, err := repo.Search(context.Background(), orgID, "test", "", "") + + // Assert + assert.NoError(t, err) + assert.NotNil(t, results) + assert.Len(t, results, 1) + assert.NoError(t, mock.ExpectationsWereMet()) +} diff --git a/core-service/go.mod b/core-service/go.mod index 4c38970..f49f9c2 100644 --- a/core-service/go.mod +++ b/core-service/go.mod @@ -14,10 +14,12 @@ require ( ) require ( + github.com/DATA-DOG/go-sqlmock v1.5.2 // indirect github.com/bytedance/sonic v1.11.6 // indirect github.com/bytedance/sonic/loader v0.1.1 // indirect github.com/cloudwego/base64x v0.1.4 // indirect github.com/cloudwego/iasm v0.2.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect github.com/gabriel-vasile/mimetype v1.4.3 // indirect github.com/gin-contrib/sse v0.1.0 // indirect github.com/go-playground/locales v0.14.1 // indirect @@ -30,6 +32,9 @@ require ( github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.2 // indirect github.com/pelletier/go-toml/v2 v2.2.2 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/stretchr/objx v0.5.2 // indirect + github.com/stretchr/testify v1.11.1 // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect github.com/ugorji/go/codec v1.2.12 // indirect golang.org/x/arch v0.8.0 // indirect diff --git a/core-service/go.sum b/core-service/go.sum index e021caa..065ab4c 100644 --- a/core-service/go.sum +++ b/core-service/go.sum @@ -1,3 +1,5 @@ +github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU= +github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0= github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4= github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM= @@ -36,6 +38,7 @@ github.com/joho/godotenv v1.4.0 h1:3l4+N6zfMWnkbPEXKng2o2/MR5mSwTrBih4ZEkkz1lg= github.com/joho/godotenv v1.4.0/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE= github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM= github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= @@ -60,6 +63,7 @@ github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVs github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= @@ -69,6 +73,8 @@ github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=