mirror of
https://github.com/SamyRai/turash.git
synced 2025-12-26 23:01:33 +00:00
000eab4740
Repository Structure:
- Move files from cluttered root directory into organized structure
- Create archive/ for archived data and scraper results
- Create bugulma/ for the complete application (frontend + backend)
- Create data/ for sample datasets and reference materials
- Create docs/ for comprehensive documentation structure
- Create scripts/ for utility scripts and API tools
Backend Implementation:
- Implement 3 missing backend endpoints identified in gap analysis:
* GET /api/v1/organizations/{id}/matching/direct - Direct symbiosis matches
* GET /api/v1/users/me/organizations - User organizations
* POST /api/v1/proposals/{id}/status - Update proposal status
- Add complete proposal domain model, repository, and service layers
- Create database migration for proposals table
- Fix CLI server command registration issue
API Documentation:
- Add comprehensive proposals.md API documentation
- Update README.md with Users and Proposals API sections
- Document all request/response formats, error codes, and business rules
Code Quality:
- Follow existing Go backend architecture patterns
- Add proper error handling and validation
- Match frontend expected response schemas
- Maintain clean separation of concerns (handler -> service -> repository)
247 lines
8.0 KiB
Go
247 lines
8.0 KiB
Go
package service_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"testing"
|
|
|
|
"bugulma/backend/internal/testutils"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/suite"
|
|
"gorm.io/gorm"
|
|
|
|
"bugulma/backend/internal/domain"
|
|
"bugulma/backend/internal/repository"
|
|
"bugulma/backend/internal/service"
|
|
)
|
|
|
|
type SiteServiceTestSuite struct {
|
|
suite.Suite
|
|
db *gorm.DB
|
|
repo domain.SiteRepository
|
|
orgRepo domain.OrganizationRepository
|
|
svc *service.SiteService
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) SetupTest() {
|
|
// Setup PostgreSQL test database using pgtestdb
|
|
suite.db = testutils.SetupTestDB(suite.T())
|
|
suite.repo = repository.NewSiteRepository(suite.db)
|
|
suite.orgRepo = repository.NewOrganizationRepository(suite.db)
|
|
suite.svc = service.NewSiteService(suite.repo)
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TearDownTest() {
|
|
// pgtestdb automatically cleans up the database after each test
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TestCreate() {
|
|
// Create organization first (required for foreign key constraint)
|
|
org := &domain.Organization{ID: "org-1", Name: "Test Organization"}
|
|
suite.Require().NoError(suite.orgRepo.Create(context.Background(), org))
|
|
|
|
req := service.CreateSiteRequest{
|
|
Name: "Test Site",
|
|
Latitude: 52.52,
|
|
Longitude: 13.405,
|
|
SiteType: domain.SiteTypeIndustrial,
|
|
FloorAreaM2: 1000.0,
|
|
Ownership: domain.OwnershipOwned,
|
|
OwnerOrganizationID: "org-1",
|
|
AvailableUtilities: []string{"electricity", "water"},
|
|
ParkingSpaces: 50,
|
|
LoadingDocks: 5,
|
|
CraneCapacityTonnes: 10.0,
|
|
EnergyRating: "A",
|
|
}
|
|
|
|
site, err := suite.svc.Create(context.Background(), req)
|
|
assert.NoError(suite.T(), err)
|
|
assert.NotEmpty(suite.T(), site.ID)
|
|
assert.Equal(suite.T(), "Test Site", site.Name)
|
|
assert.Equal(suite.T(), domain.SiteTypeIndustrial, site.SiteType)
|
|
assert.Equal(suite.T(), 1000.0, site.FloorAreaM2)
|
|
assert.Equal(suite.T(), 50, site.ParkingSpaces)
|
|
|
|
var utilities []string
|
|
err = json.Unmarshal(site.AvailableUtilities, &utilities)
|
|
assert.NoError(suite.T(), err)
|
|
assert.Equal(suite.T(), []string{"electricity", "water"}, utilities)
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TestGetByID() {
|
|
// Create organization first
|
|
org := &domain.Organization{ID: "org-1", Name: "Test Organization"}
|
|
suite.Require().NoError(suite.orgRepo.Create(context.Background(), org))
|
|
|
|
req := service.CreateSiteRequest{
|
|
Name: "Test Site",
|
|
Latitude: 52.52,
|
|
Longitude: 13.405,
|
|
SiteType: domain.SiteTypeIndustrial,
|
|
OwnerOrganizationID: "org-1",
|
|
}
|
|
created, err := suite.svc.Create(context.Background(), req)
|
|
suite.Require().NoError(err)
|
|
|
|
found, err := suite.svc.GetByID(context.Background(), created.ID)
|
|
assert.NoError(suite.T(), err)
|
|
assert.Equal(suite.T(), created.ID, found.ID)
|
|
assert.Equal(suite.T(), "Test Site", found.Name)
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TestGetByIDNotFound() {
|
|
_, err := suite.svc.GetByID(context.Background(), "non-existent-id")
|
|
assert.Error(suite.T(), err)
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TestGetAll() {
|
|
// Create organizations first
|
|
org1 := &domain.Organization{ID: "org-1", Name: "Test Organization 1"}
|
|
org2 := &domain.Organization{ID: "org-2", Name: "Test Organization 2"}
|
|
suite.Require().NoError(suite.orgRepo.Create(context.Background(), org1))
|
|
suite.Require().NoError(suite.orgRepo.Create(context.Background(), org2))
|
|
|
|
req1 := service.CreateSiteRequest{
|
|
Name: "Site 1",
|
|
Latitude: 52.52,
|
|
Longitude: 13.405,
|
|
SiteType: domain.SiteTypeIndustrial,
|
|
OwnerOrganizationID: "org-1",
|
|
}
|
|
req2 := service.CreateSiteRequest{
|
|
Name: "Site 2",
|
|
Latitude: 52.53,
|
|
Longitude: 13.406,
|
|
SiteType: domain.SiteTypeRetail,
|
|
OwnerOrganizationID: "org-2",
|
|
}
|
|
_, err := suite.svc.Create(context.Background(), req1)
|
|
suite.Require().NoError(err)
|
|
_, err = suite.svc.Create(context.Background(), req2)
|
|
suite.Require().NoError(err)
|
|
|
|
sites, err := suite.svc.GetAll(context.Background())
|
|
assert.NoError(suite.T(), err)
|
|
assert.Len(suite.T(), sites, 2)
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TestGetByOrganizationID() {
|
|
// Create organizations first
|
|
org1 := &domain.Organization{ID: "org-1", Name: "Test Organization 1"}
|
|
org2 := &domain.Organization{ID: "org-2", Name: "Test Organization 2"}
|
|
suite.Require().NoError(suite.orgRepo.Create(context.Background(), org1))
|
|
suite.Require().NoError(suite.orgRepo.Create(context.Background(), org2))
|
|
|
|
req1 := service.CreateSiteRequest{
|
|
Name: "Site 1",
|
|
Latitude: 52.52,
|
|
Longitude: 13.405,
|
|
SiteType: domain.SiteTypeIndustrial,
|
|
OwnerOrganizationID: "org-1",
|
|
}
|
|
req2 := service.CreateSiteRequest{
|
|
Name: "Site 2",
|
|
Latitude: 52.53,
|
|
Longitude: 13.406,
|
|
SiteType: domain.SiteTypeRetail,
|
|
OwnerOrganizationID: "org-2",
|
|
}
|
|
_, err := suite.svc.Create(context.Background(), req1)
|
|
suite.Require().NoError(err)
|
|
_, err = suite.svc.Create(context.Background(), req2)
|
|
suite.Require().NoError(err)
|
|
|
|
sites, err := suite.svc.GetByOrganizationID(context.Background(), "org-1")
|
|
assert.NoError(suite.T(), err)
|
|
assert.Len(suite.T(), sites, 1)
|
|
assert.Equal(suite.T(), "Site 1", sites[0].Name)
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TestGetByOrganizationIDNoSites() {
|
|
sites, err := suite.svc.GetByOrganizationID(context.Background(), "non-existent-org")
|
|
assert.NoError(suite.T(), err)
|
|
assert.Len(suite.T(), sites, 0)
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TestGetNearby() {
|
|
// Create organization first
|
|
org := &domain.Organization{ID: "org-1", Name: "Test Organization"}
|
|
suite.Require().NoError(suite.orgRepo.Create(context.Background(), org))
|
|
|
|
req := service.CreateSiteRequest{
|
|
Name: "Test Site",
|
|
Latitude: 52.52,
|
|
Longitude: 13.405,
|
|
SiteType: domain.SiteTypeIndustrial,
|
|
OwnerOrganizationID: "org-1",
|
|
}
|
|
_, err := suite.svc.Create(context.Background(), req)
|
|
suite.Require().NoError(err)
|
|
|
|
sites, err := suite.svc.GetNearby(context.Background(), 52.52, 13.405, 10)
|
|
assert.NoError(suite.T(), err)
|
|
assert.Len(suite.T(), sites, 1)
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TestGetNearbyNoSites() {
|
|
sites, err := suite.svc.GetNearby(context.Background(), 0, 0, 1)
|
|
assert.NoError(suite.T(), err)
|
|
assert.Len(suite.T(), sites, 0)
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TestUpdate() {
|
|
// Create organization first
|
|
org := &domain.Organization{ID: "org-1", Name: "Test Organization"}
|
|
suite.Require().NoError(suite.orgRepo.Create(context.Background(), org))
|
|
|
|
req := service.CreateSiteRequest{
|
|
Name: "Test Site",
|
|
Latitude: 52.52,
|
|
Longitude: 13.405,
|
|
SiteType: domain.SiteTypeIndustrial,
|
|
OwnerOrganizationID: "org-1",
|
|
}
|
|
site, err := suite.svc.Create(context.Background(), req)
|
|
suite.Require().NoError(err)
|
|
|
|
site.Name = "Updated Site"
|
|
site.FloorAreaM2 = 2000.0
|
|
site.ParkingSpaces = 100
|
|
err = suite.svc.Update(context.Background(), site)
|
|
assert.NoError(suite.T(), err)
|
|
|
|
found, err := suite.svc.GetByID(context.Background(), site.ID)
|
|
assert.NoError(suite.T(), err)
|
|
assert.Equal(suite.T(), "Updated Site", found.Name)
|
|
assert.Equal(suite.T(), 2000.0, found.FloorAreaM2)
|
|
assert.Equal(suite.T(), 100, found.ParkingSpaces)
|
|
}
|
|
|
|
func (suite *SiteServiceTestSuite) TestDelete() {
|
|
// Create organization first
|
|
org := &domain.Organization{ID: "org-1", Name: "Test Organization"}
|
|
suite.Require().NoError(suite.orgRepo.Create(context.Background(), org))
|
|
|
|
req := service.CreateSiteRequest{
|
|
Name: "Test Site",
|
|
Latitude: 52.52,
|
|
Longitude: 13.405,
|
|
SiteType: domain.SiteTypeIndustrial,
|
|
OwnerOrganizationID: "org-1",
|
|
}
|
|
site, err := suite.svc.Create(context.Background(), req)
|
|
suite.Require().NoError(err)
|
|
|
|
err = suite.svc.Delete(context.Background(), site.ID)
|
|
assert.NoError(suite.T(), err)
|
|
|
|
_, err = suite.svc.GetByID(context.Background(), site.ID)
|
|
assert.Error(suite.T(), err)
|
|
}
|
|
|
|
func TestSiteServiceTestSuite(t *testing.T) {
|
|
suite.Run(t, new(SiteServiceTestSuite))
|
|
}
|