mirror of
https://gitlab.com/mbugroup/lti-api.git
synced 2026-05-20 13:31:56 +00:00
Hafizh A. Y
411 lines
16 KiB
Go
411 lines
16 KiB
Go
package test
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
"gorm.io/gorm"
|
|
|
|
"gitlab.com/mbugroup/lti-api.git/internal/entities"
|
|
"gitlab.com/mbugroup/lti-api.git/internal/utils"
|
|
)
|
|
|
|
func TestProductIntegration(t *testing.T) {
|
|
app, db := setupIntegrationApp(t)
|
|
|
|
uomID := createUom(t, app, "Kilogram")
|
|
categoryID := createProductCategory(t, app, "Feed", "FED")
|
|
|
|
sapSupplier1 := createSupplier(t, app, "Feed Supplier One", "fs1", string(utils.SupplierCategorySapronak))
|
|
sapSupplier2 := createSupplier(t, app, "Feed Supplier Two", "fs2", string(utils.SupplierCategorySapronak))
|
|
bopSupplier := createSupplier(t, app, "BOP Supplier", "bop1", string(utils.SupplierCategoryBOP))
|
|
|
|
productFlags := []string{string(utils.FlagDOC), string(utils.FlagPakan)}
|
|
updatedProductFlags := []string{string(utils.FlagFinisher), string(utils.FlagObat)}
|
|
|
|
t.Run("create product without suppliers succeeds with empty relations", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPost, "/api/master-data/products", map[string]any{
|
|
"name": "Supplierless Product",
|
|
"brand": "Brand A",
|
|
"uom_id": uomID,
|
|
"product_category_id": categoryID,
|
|
"product_price": 12000,
|
|
})
|
|
if resp.StatusCode != fiber.StatusCreated {
|
|
t.Fatalf("expected 201 when suppliers omitted, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
id := parseID(t, body)
|
|
product := fetchProduct(t, db, id)
|
|
if len(product.Suppliers) != 0 {
|
|
t.Fatalf("expected no suppliers persisted, found %d", len(product.Suppliers))
|
|
}
|
|
if len(product.Flags) != 0 {
|
|
t.Fatalf("expected no flags persisted, found %d", len(product.Flags))
|
|
}
|
|
resp, _ = doJSONRequest(t, app, http.MethodDelete, fmt.Sprintf("/api/master-data/products/%d", id), nil)
|
|
if resp.StatusCode != fiber.StatusOK {
|
|
t.Fatalf("expected cleanup delete to succeed, got %d", resp.StatusCode)
|
|
}
|
|
})
|
|
|
|
t.Run("create product with invalid uom fails", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPost, "/api/master-data/products", map[string]any{
|
|
"name": "Layer Feed Invalid UOM",
|
|
"brand": "Brand A",
|
|
"uom_id": 9999,
|
|
"product_category_id": categoryID,
|
|
"product_price": 12000,
|
|
"supplier_ids": []uint{sapSupplier1},
|
|
})
|
|
if resp.StatusCode != fiber.StatusNotFound {
|
|
t.Fatalf("expected 404 when uom missing, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
|
|
t.Run("create product with invalid category fails", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPost, "/api/master-data/products", map[string]any{
|
|
"name": "Layer Feed Invalid Category",
|
|
"brand": "Brand A",
|
|
"uom_id": uomID,
|
|
"product_category_id": 9999,
|
|
"product_price": 12000,
|
|
"supplier_ids": []uint{sapSupplier1},
|
|
})
|
|
if resp.StatusCode != fiber.StatusNotFound {
|
|
t.Fatalf("expected 404 when category missing, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
|
|
t.Run("create product with invalid supplier fails", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPost, "/api/master-data/products", map[string]any{
|
|
"name": "Layer Feed Missing Supplier",
|
|
"brand": "Brand A",
|
|
"uom_id": uomID,
|
|
"product_category_id": categoryID,
|
|
"product_price": 12000,
|
|
"supplier_ids": []uint{99999},
|
|
})
|
|
if resp.StatusCode != fiber.StatusNotFound {
|
|
t.Fatalf("expected 404 when supplier missing, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
|
|
t.Run("create product with BOP supplier fails", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPost, "/api/master-data/products", map[string]any{
|
|
"name": "Layer Feed Wrong Supplier",
|
|
"brand": "Brand A",
|
|
"uom_id": uomID,
|
|
"product_category_id": categoryID,
|
|
"product_price": 12000,
|
|
"supplier_ids": []uint{bopSupplier},
|
|
})
|
|
if resp.StatusCode != fiber.StatusBadRequest {
|
|
t.Fatalf("expected 400 when supplier category invalid, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
|
|
t.Run("create product with invalid flags fails", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPost, "/api/master-data/products", map[string]any{
|
|
"name": "Layer Feed Invalid Flags",
|
|
"brand": "Brand A",
|
|
"uom_id": uomID,
|
|
"product_category_id": categoryID,
|
|
"product_price": 12000,
|
|
"supplier_ids": []uint{sapSupplier1},
|
|
"flags": []string{"INVALID"},
|
|
})
|
|
if resp.StatusCode != fiber.StatusBadRequest {
|
|
t.Fatalf("expected 400 when flags invalid, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
|
|
var productID uint
|
|
|
|
t.Run("create product succeeds", func(t *testing.T) {
|
|
sku := "lfd-001"
|
|
productID = createProduct(t, app, "Layer Feed", "Brand A", &sku, uomID, categoryID, 15000, []uint{sapSupplier1, sapSupplier2}, productFlags)
|
|
product := fetchProduct(t, db, productID)
|
|
if product.Name != "Layer Feed" {
|
|
t.Fatalf("expected name Layer Feed, got %q", product.Name)
|
|
}
|
|
if product.Brand != "Brand A" {
|
|
t.Fatalf("expected brand Brand A, got %q", product.Brand)
|
|
}
|
|
if product.Sku == nil || *product.Sku != strings.ToUpper(sku) {
|
|
t.Fatalf("expected sku %q, got %+v", strings.ToUpper(sku), product.Sku)
|
|
}
|
|
if product.UomId != uomID {
|
|
t.Fatalf("expected uom_id %d, got %d", uomID, product.UomId)
|
|
}
|
|
if product.ProductCategoryId != categoryID {
|
|
t.Fatalf("expected product_category_id %d, got %d", categoryID, product.ProductCategoryId)
|
|
}
|
|
if product.CreatedBy != 1 {
|
|
t.Fatalf("expected created_by 1, got %d", product.CreatedBy)
|
|
}
|
|
if len(product.Suppliers) != 2 {
|
|
t.Fatalf("expected 2 suppliers, got %d", len(product.Suppliers))
|
|
}
|
|
if len(product.Flags) != len(productFlags) {
|
|
t.Fatalf("expected %d flags, got %d", len(productFlags), len(product.Flags))
|
|
}
|
|
expectedFlags := make(map[string]struct{}, len(productFlags))
|
|
for _, flag := range productFlags {
|
|
expectedFlags[strings.ToUpper(flag)] = struct{}{}
|
|
}
|
|
for _, flag := range product.Flags {
|
|
if _, ok := expectedFlags[strings.ToUpper(flag.Name)]; !ok {
|
|
t.Fatalf("unexpected flag %s present", flag.Name)
|
|
}
|
|
delete(expectedFlags, strings.ToUpper(flag.Name))
|
|
}
|
|
if len(expectedFlags) != 0 {
|
|
t.Fatalf("missing expected flags: %v", expectedFlags)
|
|
}
|
|
})
|
|
|
|
t.Run("creating duplicate name fails", func(t *testing.T) {
|
|
sku := "lfd-002"
|
|
resp, body := doJSONRequest(t, app, http.MethodPost, "/api/master-data/products", map[string]any{
|
|
"name": "Layer Feed",
|
|
"brand": "Brand B",
|
|
"sku": sku,
|
|
"uom_id": uomID,
|
|
"product_category_id": categoryID,
|
|
"product_price": 16000,
|
|
"supplier_ids": []uint{sapSupplier1},
|
|
})
|
|
if resp.StatusCode != fiber.StatusConflict {
|
|
t.Fatalf("expected 409 when creating duplicate name, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
|
|
t.Run("creating duplicate sku fails", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPost, "/api/master-data/products", map[string]any{
|
|
"name": "Layer Feed Premium",
|
|
"brand": "Brand B",
|
|
"sku": "LFD-001",
|
|
"uom_id": uomID,
|
|
"product_category_id": categoryID,
|
|
"product_price": 17000,
|
|
"supplier_ids": []uint{sapSupplier1},
|
|
})
|
|
if resp.StatusCode != fiber.StatusConflict {
|
|
t.Fatalf("expected 409 when creating duplicate sku, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
|
|
t.Run("get product detail returns nested data", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodGet, fmt.Sprintf("/api/master-data/products/%d", productID), nil)
|
|
if resp.StatusCode != fiber.StatusOK {
|
|
t.Fatalf("expected 200 when fetching product, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
var payload struct {
|
|
Data struct {
|
|
Id uint `json:"id"`
|
|
Name string `json:"name"`
|
|
Brand string `json:"brand"`
|
|
Uom *struct {
|
|
Id uint `json:"id"`
|
|
} `json:"uom"`
|
|
Suppliers []map[string]any `json:"suppliers"`
|
|
Flags []string `json:"flags"`
|
|
} `json:"data"`
|
|
}
|
|
if err := json.Unmarshal(body, &payload); err != nil {
|
|
t.Fatalf("failed to parse product detail: %v", err)
|
|
}
|
|
if payload.Data.Id != productID {
|
|
t.Fatalf("expected id %d, got %d", productID, payload.Data.Id)
|
|
}
|
|
if payload.Data.Uom == nil || payload.Data.Uom.Id != uomID {
|
|
t.Fatalf("expected uom id %d, got %+v", uomID, payload.Data.Uom)
|
|
}
|
|
if len(payload.Data.Suppliers) != 2 {
|
|
t.Fatalf("expected 2 suppliers in response, got %d", len(payload.Data.Suppliers))
|
|
}
|
|
if len(payload.Data.Flags) != len(productFlags) {
|
|
t.Fatalf("expected %d flags in response, got %d", len(productFlags), len(payload.Data.Flags))
|
|
}
|
|
expected := make(map[string]struct{}, len(productFlags))
|
|
for _, flag := range productFlags {
|
|
expected[strings.ToUpper(flag)] = struct{}{}
|
|
}
|
|
for _, flag := range payload.Data.Flags {
|
|
flag = strings.ToUpper(flag)
|
|
if _, ok := expected[flag]; !ok {
|
|
t.Fatalf("unexpected flag %s returned", flag)
|
|
}
|
|
delete(expected, flag)
|
|
}
|
|
if len(expected) != 0 {
|
|
t.Fatalf("missing expected flags in response: %v", expected)
|
|
}
|
|
})
|
|
|
|
t.Run("update product with invalid supplier category fails", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPatch, fmt.Sprintf("/api/master-data/products/%d", productID), map[string]any{
|
|
"supplier_ids": []uint{bopSupplier},
|
|
})
|
|
if resp.StatusCode != fiber.StatusBadRequest {
|
|
t.Fatalf("expected 400 when updating with non SAPRONAK supplier, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
|
|
t.Run("update product with invalid flags fails", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPatch, fmt.Sprintf("/api/master-data/products/%d", productID), map[string]any{
|
|
"flags": []string{"UNKNOWN"},
|
|
})
|
|
if resp.StatusCode != fiber.StatusBadRequest {
|
|
t.Fatalf("expected 400 when updating with invalid flags, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
|
|
t.Run("update product succeeds", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPatch, fmt.Sprintf("/api/master-data/products/%d", productID), map[string]any{
|
|
"name": "Layer Feed Updated",
|
|
"brand": "Brand C",
|
|
"sku": "lfd-100",
|
|
"product_price": 18000,
|
|
"selling_price": 19000,
|
|
"tax": 1000,
|
|
"expiry_period": 30,
|
|
"supplier_ids": []uint{sapSupplier1},
|
|
"flags": updatedProductFlags,
|
|
})
|
|
if resp.StatusCode != fiber.StatusOK {
|
|
t.Fatalf("expected 200 when updating product, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
var payload struct {
|
|
Data struct {
|
|
Name string `json:"name"`
|
|
Brand string `json:"brand"`
|
|
Sku *string `json:"sku"`
|
|
ProductPrice float64 `json:"product_price"`
|
|
SupplierIds []map[string]any `json:"suppliers"`
|
|
Flags []string `json:"flags"`
|
|
} `json:"data"`
|
|
}
|
|
if err := json.Unmarshal(body, &payload); err != nil {
|
|
t.Fatalf("failed to parse update response: %v", err)
|
|
}
|
|
if payload.Data.Name != "Layer Feed Updated" {
|
|
t.Fatalf("expected updated name, got %q", payload.Data.Name)
|
|
}
|
|
if len(payload.Data.Flags) != len(updatedProductFlags) {
|
|
t.Fatalf("expected %d flags in response, got %d", len(updatedProductFlags), len(payload.Data.Flags))
|
|
}
|
|
respFlags := make(map[string]struct{}, len(payload.Data.Flags))
|
|
for _, flag := range payload.Data.Flags {
|
|
respFlags[strings.ToUpper(flag)] = struct{}{}
|
|
}
|
|
for _, flag := range updatedProductFlags {
|
|
if _, ok := respFlags[strings.ToUpper(flag)]; !ok {
|
|
t.Fatalf("missing flag %s in response", flag)
|
|
}
|
|
}
|
|
product := fetchProduct(t, db, productID)
|
|
if product.Brand != "Brand C" {
|
|
t.Fatalf("expected persisted brand Brand C, got %q", product.Brand)
|
|
}
|
|
if product.Sku == nil || *product.Sku != "LFD-100" {
|
|
t.Fatalf("expected persisted sku LFD-100, got %+v", product.Sku)
|
|
}
|
|
if len(product.Suppliers) != 1 || product.Suppliers[0].Id != sapSupplier1 {
|
|
t.Fatalf("expected supplier to be %d", sapSupplier1)
|
|
}
|
|
if len(product.Flags) != len(updatedProductFlags) {
|
|
t.Fatalf("expected %d flags after update, got %d", len(updatedProductFlags), len(product.Flags))
|
|
}
|
|
expectedFlags := make(map[string]struct{}, len(updatedProductFlags))
|
|
for _, flag := range updatedProductFlags {
|
|
expectedFlags[strings.ToUpper(flag)] = struct{}{}
|
|
}
|
|
for _, flag := range product.Flags {
|
|
upper := strings.ToUpper(flag.Name)
|
|
if _, ok := expectedFlags[upper]; !ok {
|
|
t.Fatalf("unexpected flag after update: %s", upper)
|
|
}
|
|
delete(expectedFlags, upper)
|
|
}
|
|
if len(expectedFlags) != 0 {
|
|
t.Fatalf("missing flags after update: %v", expectedFlags)
|
|
}
|
|
})
|
|
|
|
t.Run("clear suppliers succeeds", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPatch, fmt.Sprintf("/api/master-data/products/%d", productID), map[string]any{
|
|
"supplier_ids": []uint{},
|
|
})
|
|
if resp.StatusCode != fiber.StatusOK {
|
|
t.Fatalf("expected 200 when clearing suppliers, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
product := fetchProduct(t, db, productID)
|
|
if len(product.Suppliers) != 0 {
|
|
t.Fatalf("expected no suppliers after clearing, got %d", len(product.Suppliers))
|
|
}
|
|
if len(product.Flags) != len(updatedProductFlags) {
|
|
t.Fatalf("expected flags untouched after clearing suppliers, got %d", len(product.Flags))
|
|
}
|
|
})
|
|
|
|
t.Run("clear flags succeeds", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodPatch, fmt.Sprintf("/api/master-data/products/%d", productID), map[string]any{
|
|
"flags": []string{},
|
|
})
|
|
if resp.StatusCode != fiber.StatusOK {
|
|
t.Fatalf("expected 200 when clearing flags, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
product := fetchProduct(t, db, productID)
|
|
if len(product.Flags) != 0 {
|
|
t.Fatalf("expected all flags cleared, got %d", len(product.Flags))
|
|
}
|
|
})
|
|
|
|
t.Run("delete product succeeds", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodDelete, fmt.Sprintf("/api/master-data/products/%d", productID), nil)
|
|
if resp.StatusCode != fiber.StatusOK {
|
|
t.Fatalf("expected 200 when deleting product, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
var product entities.Product
|
|
if err := db.First(&product, productID).Error; !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
t.Fatalf("expected product deleted, got error %v", err)
|
|
}
|
|
var links int64
|
|
if err := db.Model(&entities.ProductSupplier{}).Where("product_id = ?", productID).Count(&links).Error; err != nil {
|
|
t.Fatalf("failed counting product suppliers: %v", err)
|
|
}
|
|
if links != 0 {
|
|
t.Fatalf("expected pivot cleared, found %d rows", links)
|
|
}
|
|
var flagCount int64
|
|
if err := db.Model(&entities.Flag{}).
|
|
Where("flagable_id = ? AND flagable_type = ?", productID, entities.FlagableTypeProduct).
|
|
Count(&flagCount).Error; err != nil {
|
|
t.Fatalf("failed counting product flags: %v", err)
|
|
}
|
|
if flagCount != 0 {
|
|
t.Fatalf("expected flags removed, found %d", flagCount)
|
|
}
|
|
})
|
|
|
|
t.Run("delete missing product returns 404", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodDelete, fmt.Sprintf("/api/master-data/products/%d", productID), nil)
|
|
if resp.StatusCode != fiber.StatusNotFound {
|
|
t.Fatalf("expected 404 when deleting missing product, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
|
|
t.Run("get deleted product returns 404", func(t *testing.T) {
|
|
resp, body := doJSONRequest(t, app, http.MethodGet, fmt.Sprintf("/api/master-data/products/%d", productID), nil)
|
|
if resp.StatusCode != fiber.StatusNotFound {
|
|
t.Fatalf("expected 404 when fetching deleted product, got %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
})
|
|
}
|