293 lines
9.1 KiB
Go
293 lines
9.1 KiB
Go
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"regexp"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/DATA-DOG/go-sqlmock"
|
|
"github.com/gofrs/uuid/v5"
|
|
"github.com/jmoiron/sqlx"
|
|
"github.com/saveinmed/backend-go/internal/domain"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func newMockRepo(t *testing.T) (*Repository, sqlmock.Sqlmock) {
|
|
db, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
|
|
}
|
|
sqlxDB := sqlx.NewDb(db, "sqlmock")
|
|
repo := New(sqlxDB)
|
|
return repo, mock
|
|
}
|
|
|
|
func TestCreateCompany(t *testing.T) {
|
|
repo, mock := newMockRepo(t)
|
|
defer repo.db.Close()
|
|
|
|
company := &domain.Company{
|
|
ID: uuid.Must(uuid.NewV7()),
|
|
CNPJ: "12345678901234",
|
|
CorporateName: "Test Pharmacy",
|
|
Category: "farmacia",
|
|
LicenseNumber: "123",
|
|
IsVerified: false,
|
|
Latitude: -10.0,
|
|
Longitude: -20.0,
|
|
City: "Test City",
|
|
State: "TS",
|
|
Phone: "(11) 99999-9999",
|
|
OperatingHours: "08:00-18:00",
|
|
Is24Hours: false,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
|
|
query := `INSERT INTO companies`
|
|
mock.ExpectExec(regexp.QuoteMeta(query)).
|
|
WithArgs(
|
|
company.ID,
|
|
company.CNPJ,
|
|
company.CorporateName,
|
|
company.Category,
|
|
company.LicenseNumber,
|
|
company.IsVerified,
|
|
company.Latitude,
|
|
company.Longitude,
|
|
company.City,
|
|
company.State,
|
|
company.Phone,
|
|
company.OperatingHours,
|
|
company.Is24Hours,
|
|
sqlmock.AnyArg(),
|
|
sqlmock.AnyArg(),
|
|
).
|
|
WillReturnResult(sqlmock.NewResult(1, 1))
|
|
|
|
err := repo.CreateCompany(context.Background(), company)
|
|
assert.NoError(t, err)
|
|
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Errorf("there were unfulfilled expectations: %s", err)
|
|
}
|
|
}
|
|
|
|
func TestGetCompany(t *testing.T) {
|
|
repo, mock := newMockRepo(t)
|
|
defer repo.db.Close()
|
|
|
|
id := uuid.Must(uuid.NewV7())
|
|
rows := sqlmock.NewRows([]string{"id", "cnpj", "corporate_name", "category", "license_number", "is_verified", "latitude", "longitude", "city", "state", "created_at", "updated_at"}).
|
|
AddRow(id, "123", "Test", "farmacia", "123", false, 0.0, 0.0, "City", "ST", time.Now(), time.Now())
|
|
|
|
mock.ExpectQuery(`SELECT .* FROM companies WHERE id = \$1`).
|
|
WithArgs(id).
|
|
WillReturnRows(rows)
|
|
|
|
company, err := repo.GetCompany(context.Background(), id)
|
|
assert.NoError(t, err)
|
|
if company != nil {
|
|
assert.Equal(t, id, company.ID)
|
|
} else {
|
|
t.Error("expected company to not be nil")
|
|
}
|
|
}
|
|
|
|
func TestCreateProduct(t *testing.T) {
|
|
repo, mock := newMockRepo(t)
|
|
defer repo.db.Close()
|
|
|
|
product := &domain.Product{
|
|
ID: uuid.Must(uuid.NewV7()),
|
|
SellerID: uuid.Must(uuid.NewV7()),
|
|
EANCode: "7891234567890",
|
|
Name: "Test Product",
|
|
Description: "Desc",
|
|
Manufacturer: "Test Manufacturer",
|
|
Category: "medicamento",
|
|
Subcategory: "analgesico",
|
|
PriceCents: 1000,
|
|
Observations: "Test observations",
|
|
InternalCode: "INT-001",
|
|
FactoryPriceCents: 800,
|
|
PMCCents: 1100,
|
|
CommercialDiscountCents: 50,
|
|
TaxSubstitutionCents: 25,
|
|
InvoicePriceCents: 900,
|
|
}
|
|
|
|
query := `INSERT INTO products`
|
|
rows := sqlmock.NewRows([]string{"created_at", "updated_at"}).
|
|
AddRow(time.Now(), time.Now())
|
|
mock.ExpectQuery(regexp.QuoteMeta(query)).
|
|
WithArgs(
|
|
product.ID,
|
|
product.SellerID,
|
|
product.EANCode,
|
|
product.Name,
|
|
product.Description,
|
|
product.Manufacturer,
|
|
product.Category,
|
|
product.Subcategory,
|
|
product.PriceCents,
|
|
product.Observations,
|
|
product.InternalCode,
|
|
product.FactoryPriceCents,
|
|
product.PMCCents,
|
|
product.CommercialDiscountCents,
|
|
product.TaxSubstitutionCents,
|
|
product.InvoicePriceCents,
|
|
).
|
|
WillReturnRows(rows)
|
|
|
|
err := repo.CreateProduct(context.Background(), product)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestListProducts(t *testing.T) {
|
|
repo, mock := newMockRepo(t)
|
|
defer repo.db.Close()
|
|
|
|
rows := sqlmock.NewRows([]string{"id", "seller_id", "ean_code", "name", "description", "manufacturer", "category", "subcategory", "price_cents", "observations", "created_at", "updated_at"}).
|
|
AddRow(uuid.Must(uuid.NewV7()), uuid.Must(uuid.NewV7()), "789", "P1", "Desc", "Lab", "cat", "sub", 1000, "obs", time.Now(), time.Now())
|
|
|
|
mock.ExpectQuery(`SELECT count\(\*\) FROM products`).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
|
|
mock.ExpectQuery(`SELECT .* FROM products`).WithArgs(10, 0).WillReturnRows(rows)
|
|
|
|
list, count, err := repo.ListProducts(context.Background(), domain.ProductFilter{Limit: 10})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, int64(1), count)
|
|
assert.Len(t, list, 1)
|
|
}
|
|
|
|
func TestCreateUser(t *testing.T) {
|
|
repo, mock := newMockRepo(t)
|
|
defer repo.db.Close()
|
|
|
|
user := &domain.User{
|
|
ID: uuid.Must(uuid.NewV7()),
|
|
CompanyID: uuid.Must(uuid.NewV7()),
|
|
Role: domain.RoleEmployee,
|
|
Name: "Test User",
|
|
Username: "testuser",
|
|
Email: "test@example.com",
|
|
PasswordHash: "hashed_password",
|
|
}
|
|
|
|
query := `INSERT INTO users`
|
|
mock.ExpectExec(regexp.QuoteMeta(query)).
|
|
WithArgs(
|
|
user.ID,
|
|
user.CompanyID,
|
|
user.Role,
|
|
user.Name,
|
|
user.Username,
|
|
user.Email,
|
|
user.EmailVerified,
|
|
user.PasswordHash,
|
|
user.Superadmin,
|
|
user.NomeSocial,
|
|
user.CPF,
|
|
sqlmock.AnyArg(),
|
|
sqlmock.AnyArg(),
|
|
).
|
|
WillReturnResult(sqlmock.NewResult(1, 1))
|
|
|
|
err := repo.CreateUser(context.Background(), user)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestListUsers(t *testing.T) {
|
|
repo, mock := newMockRepo(t)
|
|
defer repo.db.Close()
|
|
|
|
companyID := uuid.Must(uuid.NewV7())
|
|
userID := uuid.Must(uuid.NewV7())
|
|
|
|
rows := sqlmock.NewRows([]string{
|
|
"id", "company_id", "role", "name", "username", "email",
|
|
"email_verified", "password_hash", "created_at", "updated_at",
|
|
}).AddRow(
|
|
userID, companyID, domain.RoleOwner, "Test", "test", "test@test.com",
|
|
true, "hash", time.Now(), time.Now(),
|
|
)
|
|
|
|
mock.ExpectQuery(`SELECT count\(\*\) FROM users`).
|
|
WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
|
|
mock.ExpectQuery(`SELECT .* FROM users`).
|
|
WithArgs(20, 0).
|
|
WillReturnRows(rows)
|
|
mock.ExpectQuery(`SELECT \* FROM addresses WHERE entity_id = ANY`).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "entity_id", "title", "zip_code", "street", "number", "complement", "district", "city", "state", "latitude", "longitude", "created_at", "updated_at"}))
|
|
mock.ExpectQuery(`SELECT \* FROM companies WHERE id = ANY`).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "cnpj", "corporate_name", "category", "license_number", "is_verified", "latitude", "longitude", "city", "state", "phone", "operating_hours", "is_24_hours", "created_at", "updated_at"}).
|
|
AddRow(companyID, "123", "Company", "farmacia", "123", true, 0.0, 0.0, "City", "ST", "", "", false, time.Now(), time.Now()))
|
|
|
|
list, count, err := repo.ListUsers(context.Background(), domain.UserFilter{Limit: 20})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, int64(1), count)
|
|
assert.Len(t, list, 1)
|
|
}
|
|
|
|
func TestListOrders(t *testing.T) {
|
|
repo, mock := newMockRepo(t)
|
|
defer repo.db.Close()
|
|
|
|
orderID := uuid.Must(uuid.NewV7())
|
|
buyerID := uuid.Must(uuid.NewV7())
|
|
sellerID := uuid.Must(uuid.NewV7())
|
|
|
|
rows := sqlmock.NewRows([]string{
|
|
"id", "buyer_id", "seller_id", "status", "total_cents", "payment_method",
|
|
"shipping_recipient_name", "shipping_street", "shipping_number", "shipping_complement",
|
|
"shipping_district", "shipping_city", "shipping_state", "shipping_zip_code",
|
|
"shipping_country", "created_at", "updated_at",
|
|
}).AddRow(
|
|
orderID, buyerID, sellerID, "Pendente", 10000, "pix",
|
|
"Test User", "Test Street", "123", "", "Centro", "City", "ST", "12345-678", "Brasil",
|
|
time.Now(), time.Now(),
|
|
)
|
|
|
|
mock.ExpectQuery(`SELECT count\(\*\) FROM orders`).
|
|
WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
|
|
mock.ExpectQuery(`SELECT .* FROM orders`).
|
|
WithArgs(20, 0).
|
|
WillReturnRows(rows)
|
|
mock.ExpectQuery(`SELECT .* FROM order_items WHERE order_id`).
|
|
WithArgs(orderID).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "order_id", "product_id", "quantity", "unit_cents", "batch", "expires_at"}))
|
|
|
|
list, count, err := repo.ListOrders(context.Background(), domain.OrderFilter{Limit: 20})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, int64(1), count)
|
|
assert.Len(t, list, 1)
|
|
}
|
|
|
|
func TestGetShippingSettings(t *testing.T) {
|
|
repo, mock := newMockRepo(t)
|
|
defer repo.db.Close()
|
|
|
|
vendorID := uuid.Must(uuid.NewV7())
|
|
|
|
rows := sqlmock.NewRows([]string{
|
|
"vendor_id", "active", "max_radius_km", "price_per_km_cents", "min_fee_cents",
|
|
"free_shipping_threshold_cents", "pickup_active", "pickup_address", "pickup_hours",
|
|
"latitude", "longitude", "created_at", "updated_at",
|
|
}).AddRow(
|
|
vendorID, true, 50.0, 150, 1000, nil, true, "Rua Test, 123", "08:00-18:00",
|
|
-23.55, -46.63, time.Now(), time.Now(),
|
|
)
|
|
|
|
mock.ExpectQuery(`SELECT \* FROM shipping_settings WHERE vendor_id`).
|
|
WithArgs(vendorID).
|
|
WillReturnRows(rows)
|
|
|
|
settings, err := repo.GetShippingSettings(context.Background(), vendorID)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, settings)
|
|
assert.Equal(t, vendorID, settings.VendorID)
|
|
assert.True(t, settings.Active)
|
|
}
|
|
|