526 lines
25 KiB
Go
526 lines
25 KiB
Go
package platform
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"regexp"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.apinb.com/bsm-sdk/core/errcode"
|
|
"git.apinb.com/bsm-sdk/core/types"
|
|
"git.apinb.com/heqiapp/platforms/backend/api/internal/impl"
|
|
"git.apinb.com/heqiapp/platforms/backend/api/internal/models"
|
|
"github.com/DATA-DOG/go-sqlmock"
|
|
"github.com/gin-gonic/gin"
|
|
"google.golang.org/grpc/status"
|
|
"gorm.io/driver/postgres"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func TestExpectedResources(t *testing.T) {
|
|
assertContract(t, ExpectedResources(), "gas", "gas_basic", Writable, "list")
|
|
assertContract(t, ExpectedResources(), "safety", "saf_event", Writable, "list")
|
|
assertContract(t, ExpectedResources(), "ec", "ec_order_item", Writable, "list")
|
|
assertContract(t, ExpectedResources(), "wallet", "wallet_ledger", ReadOnly, "list")
|
|
}
|
|
|
|
func TestResourceDefinitionAllowsOnlySupportedMethods(t *testing.T) {
|
|
if (ResourceDefinition{Mode: ReadOnly}).Allows(http.MethodPost) {
|
|
t.Fatal("readonly allows POST")
|
|
}
|
|
if !(ResourceDefinition{Mode: AppendOnly}).Allows(http.MethodPost) {
|
|
t.Fatal("append-only rejects POST")
|
|
}
|
|
if (ResourceDefinition{Mode: AppendOnly}).Allows(http.MethodDelete) {
|
|
t.Fatal("append-only allows DELETE")
|
|
}
|
|
}
|
|
|
|
func TestArchiveValuesOnlyArchives(t *testing.T) {
|
|
got := archiveValues()
|
|
if len(got) != 1 || got["status"] != "archived" {
|
|
t.Fatalf("unexpected archive values: %#v", got)
|
|
}
|
|
}
|
|
|
|
func TestFilterFieldsKeepsOnlyAllowedKeys(t *testing.T) {
|
|
got := filterFields(map[string]any{"name": "n", "password_hash": "x"}, []string{"name"})
|
|
if len(got) != 1 || got["name"] != "n" {
|
|
t.Fatalf("unexpected filtered fields: %#v", got)
|
|
}
|
|
}
|
|
|
|
func TestResourceDefinitionAllowsOnlyMethodsForEachMode(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mode ResourceMode
|
|
method string
|
|
want bool
|
|
}{
|
|
{"readonly GET", ReadOnly, http.MethodGet, true},
|
|
{"readonly POST", ReadOnly, http.MethodPost, false},
|
|
{"append-only GET", AppendOnly, http.MethodGet, true},
|
|
{"append-only POST", AppendOnly, http.MethodPost, true},
|
|
{"append-only PUT", AppendOnly, http.MethodPut, false},
|
|
{"writable GET", Writable, http.MethodGet, true},
|
|
{"writable POST", Writable, http.MethodPost, true},
|
|
{"writable PUT", Writable, http.MethodPut, true},
|
|
{"writable PATCH", Writable, http.MethodPatch, true},
|
|
{"writable DELETE", Writable, http.MethodDelete, true},
|
|
{"writable OPTIONS", Writable, http.MethodOptions, false},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
if got := (ResourceDefinition{Mode: test.mode}).Allows(test.method); got != test.want {
|
|
t.Fatalf("Allows(%s) = %t, want %t", test.method, got, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestUpdateAllowedByIdentityFiltersUnknownFieldsAndUsesIdentity(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectBegin()
|
|
mock.ExpectExec(regexp.QuoteMeta(`UPDATE "platform_role" SET "status"=$1,"updated_at"=$2 WHERE identity = $3`)).
|
|
WithArgs("disabled", sqlmock.AnyArg(), "role-a").
|
|
WillReturnResult(sqlmock.NewResult(0, 1))
|
|
mock.ExpectCommit()
|
|
|
|
ctx, recorder := updateContext(http.MethodPatch, "/roles/role-a", "role-a", nil)
|
|
updateAllowedByIdentity(ctx, &models.PlatformRole{}, gin.H{"status": "disabled", "is_system": true}, []string{"status"})
|
|
assertResponseCode(t, recorder, 0)
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestUpdateAllowedByIdentityReturnsNotFoundForZeroRows(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectBegin()
|
|
mock.ExpectExec(regexp.QuoteMeta(`UPDATE "platform_role" SET "status"=$1,"updated_at"=$2 WHERE identity = $3`)).
|
|
WithArgs("disabled", sqlmock.AnyArg(), "missing").
|
|
WillReturnResult(sqlmock.NewResult(0, 0))
|
|
mock.ExpectCommit()
|
|
ctx, recorder := updateContext(http.MethodPatch, "/roles/missing", "missing", nil)
|
|
|
|
updateAllowedByIdentity(ctx, &models.PlatformRole{}, gin.H{"status": "disabled"}, []string{"status"})
|
|
|
|
assertResponseCode(t, recorder, int32(status.Code(errcode.ErrRecordNotFound)))
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestUpdateAllowedByIdentityReturnsUniformResponseForDatabaseError(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectBegin()
|
|
mock.ExpectExec(regexp.QuoteMeta(`UPDATE "platform_role" SET "status"=$1,"updated_at"=$2 WHERE identity = $3`)).
|
|
WithArgs("disabled", sqlmock.AnyArg(), "role-a").
|
|
WillReturnError(errors.New("database unavailable"))
|
|
mock.ExpectRollback()
|
|
|
|
ctx, recorder := updateContext(http.MethodPatch, "/roles/role-a", "role-a", nil)
|
|
updateAllowedByIdentity(ctx, &models.PlatformRole{}, gin.H{"status": "disabled"}, []string{"status"})
|
|
|
|
var reply responseBody
|
|
if err := json.Unmarshal(recorder.Body.Bytes(), &reply); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if reply.Code != 500 || reply.Message == "" || string(reply.Details) != `""` {
|
|
t.Fatalf("database error did not use uniform response: %s", recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestPlatformRoleStatusAndArchiveReturnNotFoundWhenUpdateAffectsZeroRows(t *testing.T) {
|
|
for _, test := range []struct {
|
|
name string
|
|
handler gin.HandlerFunc
|
|
method string
|
|
body string
|
|
status string
|
|
}{
|
|
{"status", UpdatePlatformRoleStatus, http.MethodPatch, `{"status":"disabled"}`, "disabled"},
|
|
{"archive", ArchivePlatformRole, http.MethodDelete, "", "archived"},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "platform_role" WHERE identity = $1 ORDER BY "platform_role"."id" LIMIT $2`)).
|
|
WithArgs("role-a", 1).
|
|
WillReturnRows(platformRoleRows("role-a"))
|
|
mock.ExpectBegin()
|
|
mock.ExpectExec(regexp.QuoteMeta(`UPDATE "platform_role" SET "status"=$1,"updated_at"=$2 WHERE identity = $3`)).
|
|
WithArgs(test.status, sqlmock.AnyArg(), "role-a").
|
|
WillReturnResult(sqlmock.NewResult(0, 0))
|
|
mock.ExpectCommit()
|
|
|
|
ctx, recorder := updateContext(test.method, "/roles/role-a", "role-a", []byte(test.body))
|
|
test.handler(ctx)
|
|
|
|
assertResponseCode(t, recorder, int32(status.Code(errcode.ErrRecordNotFound)))
|
|
assertMockExpectations(t, mock)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetEcOrderReturnsOrderItems(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "ec_order" WHERE identity = $1 ORDER BY "ec_order"."id" LIMIT $2`)).
|
|
WithArgs("order-a", 1).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "order_no", "user_account_id", "gas_station_id", "delivery_point_id", "total_amount"}).
|
|
AddRow(uint64(1), "order-a", nil, nil, "enabled", 1, "O-1", uint64(2), uint64(3), uint64(4), int64(500)))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "ec_order_item" WHERE ec_order_id = $1 ORDER BY id asc`)).
|
|
WithArgs(uint64(1)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "ec_order_id", "ec_product_id", "product_snapshot", "quantity", "sale_amount"}).
|
|
AddRow(uint64(2), "item-a", nil, nil, "enabled", 1, uint64(1), uint64(5), `{}`, 2, int64(500)))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id","identity" FROM "delivery_basic" WHERE id IN ($1)`)).
|
|
WithArgs(uint64(4)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity"}).AddRow(uint64(4), "delivery-a"))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id","identity" FROM "ec_order" WHERE id IN ($1)`)).
|
|
WithArgs(uint64(1)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity"}).AddRow(uint64(1), "order-a"))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id","identity" FROM "ec_product" WHERE id IN ($1)`)).
|
|
WithArgs(uint64(5)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity"}).AddRow(uint64(5), "product-a"))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id","identity" FROM "gas_basic" WHERE id IN ($1)`)).
|
|
WithArgs(uint64(3)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity"}).AddRow(uint64(3), "gas-a"))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id","identity" FROM "user_account" WHERE id IN ($1)`)).
|
|
WithArgs(uint64(2)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity"}).AddRow(uint64(2), "user-a"))
|
|
|
|
ctx, recorder := updateContext(http.MethodGet, "/ec/ec_order/order-a", "order-a", nil)
|
|
GetEcOrder(ctx)
|
|
|
|
assertResponseCode(t, recorder, 0)
|
|
if !strings.Contains(recorder.Body.String(), `"items"`) || !strings.Contains(recorder.Body.String(), `"item-a"`) || strings.Contains(recorder.Body.String(), `_id"`) {
|
|
t.Fatalf("order detail omitted its items: %s", recorder.Body.String())
|
|
}
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestPrepareResourceValuesResolvesRequiredIdentityRelationsAndRejectsInvalidPayloads(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id" FROM "ec_order" WHERE identity = $1 ORDER BY "ec_order"."id" LIMIT $2`)).
|
|
WithArgs("order-a", 1).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(uint64(1)))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id" FROM "ec_product" WHERE identity = $1 ORDER BY "ec_product"."id" LIMIT $2`)).
|
|
WithArgs("product-a", 1).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(uint64(2)))
|
|
|
|
ctx, _ := updateContext(http.MethodPost, "/ec/ec_order_item", "", []byte(`{"ec_order_identity":"order-a","ec_product_identity":"product-a","quantity":2}`))
|
|
values, err := prepareResourceValues(ctx, []string{"quantity"}, []ResourceRelation{
|
|
{Input: "ec_order_identity", Column: "ec_order_id", Model: &models.EcOrder{}, Required: true},
|
|
{Input: "ec_product_identity", Column: "ec_product_id", Model: &models.EcProduct{}, Required: true},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if values["ec_order_id"] != uint64(1) || values["ec_product_id"] != uint64(2) || values["quantity"] != float64(2) {
|
|
t.Fatalf("unexpected resolved values: %#v", values)
|
|
}
|
|
assertMockExpectations(t, mock)
|
|
|
|
for _, body := range []string{`{}`, `{"ec_order_id":1}`, `{"quantity":2}`} {
|
|
ctx, _ := updateContext(http.MethodPost, "/ec/ec_order_item", "", []byte(body))
|
|
if _, err := prepareResourceValues(ctx, []string{"quantity"}, []ResourceRelation{{Input: "ec_order_identity", Column: "ec_order_id", Model: &models.EcOrder{}, Required: true}}); err == nil {
|
|
t.Fatalf("payload %s was accepted", body)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCreateGasAccountResolvesGasBasicIdentityBeforePersisting(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id" FROM "gas_basic" WHERE identity = $1 ORDER BY "gas_basic"."id" LIMIT $2`)).
|
|
WithArgs("gas-a", 1).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(uint64(8)))
|
|
mock.ExpectBegin()
|
|
mock.ExpectQuery(`INSERT INTO "gas_account"`).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(uint64(1)))
|
|
mock.ExpectCommit()
|
|
|
|
ctx, recorder := updateContext(http.MethodPost, "/gas/gas_account", "", []byte(`{"username":"operator","password":"password-123","gas_basic_identity":"gas-a"}`))
|
|
CreateGasAccount(ctx)
|
|
|
|
assertResponseCode(t, recorder, 0)
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestListPlatformMenuReturnsParentIdentityWithoutParentID(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "platform_menu" ORDER BY sort_no asc, id asc`)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "parent_id", "menu_code", "name", "icon", "path", "sort_no"}).
|
|
AddRow(uint64(1), "root-a", nil, nil, "enabled", 1, uint64(0), "root", "Root", "", "", 1).
|
|
AddRow(uint64(2), "child-a", nil, nil, "enabled", 1, uint64(1), "child", "Child", "", "/child", 2))
|
|
|
|
ctx, recorder := updateContext(http.MethodGet, "/platform/platform_menu", "", nil)
|
|
ListPlatformMenu(ctx)
|
|
|
|
assertResponseCode(t, recorder, 0)
|
|
if !strings.Contains(recorder.Body.String(), `"parent_identity":"root-a"`) || strings.Contains(recorder.Body.String(), `"parent_id"`) {
|
|
t.Fatalf("menu response leaked parent_id or omitted identity: %s", recorder.Body.String())
|
|
}
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestResourceResponseDoesNotExposeAutoIncrementRelationIDs(t *testing.T) {
|
|
response := resourceResponse(map[string]any{"identity": "item-a", "id": uint64(1), "ec_order_id": uint64(2), "ec_product_id": uint64(3), "items": []any{map[string]any{"identity": "child-a", "delivery_task_id": uint64(4)}}})
|
|
encoded, err := json.Marshal(response)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, forbidden := range []string{`"id"`, `"ec_order_id"`, `"ec_product_id"`, `"delivery_task_id"`} {
|
|
if strings.Contains(string(encoded), forbidden) {
|
|
t.Fatalf("response exposed internal relation key %s: %s", forbidden, encoded)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestListSafetyEventDisposalsReturnsOnlyTheRequestedEventHistory(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT count(*) FROM "saf_event_disposal" WHERE saf_event_identity = $1`)).
|
|
WithArgs("event-a").
|
|
WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "saf_event_disposal" WHERE saf_event_identity = $1 ORDER BY created_at asc LIMIT $2`)).
|
|
WithArgs("event-a", 20).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "saf_event_identity", "action", "reason", "operator_identity"}).
|
|
AddRow(uint64(9), "disposal-a", nil, nil, "enabled", 1, "event-a", "close", "resolved", "operator-a"))
|
|
|
|
ctx, recorder := updateContext(http.MethodGet, "/safety/saf_event/event-a/disposals", "event-a", nil)
|
|
ListSafetyEventDisposals(ctx)
|
|
|
|
assertResponseCode(t, recorder, 0)
|
|
if !strings.Contains(recorder.Body.String(), `"saf_event_identity":"event-a"`) || strings.Contains(recorder.Body.String(), `"id":`) {
|
|
t.Fatalf("disposal history did not keep the event identity-only shape: %s", recorder.Body.String())
|
|
}
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestListGasAccountProjectsGasBasicIdentityAndNeverReturnsRelationID(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT count(*) FROM "gas_account"`)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "gas_account" ORDER BY created_at desc LIMIT $1`)).
|
|
WithArgs(20).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "gas_basic_id", "username", "display_name", "password_hash", "role_code"}).
|
|
AddRow(uint64(9), "account-a", nil, nil, "enabled", 1, uint64(7), "operator", "Operator", "hash", "admin"))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id","identity" FROM "gas_basic" WHERE id IN ($1)`)).
|
|
WithArgs(uint64(7)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity"}).AddRow(uint64(7), "gas-a"))
|
|
|
|
ctx, recorder := updateContext(http.MethodGet, "/gas/gas_account", "", nil)
|
|
ListGasAccount(ctx)
|
|
|
|
assertResponseCode(t, recorder, 0)
|
|
body := recorder.Body.String()
|
|
if !strings.Contains(body, `"gas_basic_identity":"gas-a"`) || strings.Contains(body, `"gas_basic_id"`) || strings.Contains(body, `"id":`) {
|
|
t.Fatalf("account list did not return the public relation shape: %s", body)
|
|
}
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestListGasAccountPreloadsRelationIdentitiesInOneQuery(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT count(*) FROM "gas_account"`)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(2))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "gas_account" ORDER BY created_at desc LIMIT $1`)).
|
|
WithArgs(20).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "gas_basic_id", "username", "display_name", "password_hash", "role_code"}).
|
|
AddRow(uint64(9), "account-a", nil, nil, "enabled", 1, uint64(7), "operator-a", "Operator A", "hash", "admin").
|
|
AddRow(uint64(10), "account-b", nil, nil, "enabled", 1, uint64(8), "operator-b", "Operator B", "hash", "admin"))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id","identity" FROM "gas_basic" WHERE id IN ($1,$2)`)).
|
|
WithArgs(uint64(7), uint64(8)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity"}).AddRow(uint64(7), "gas-a").AddRow(uint64(8), "gas-b"))
|
|
|
|
ctx, recorder := updateContext(http.MethodGet, "/gas/gas_account", "", nil)
|
|
ListGasAccount(ctx)
|
|
|
|
assertResponseCode(t, recorder, 0)
|
|
body := recorder.Body.String()
|
|
if !strings.Contains(body, `"gas_basic_identity":"gas-a"`) || !strings.Contains(body, `"gas_basic_identity":"gas-b"`) {
|
|
t.Fatalf("account list omitted preloaded relation identities: %s", body)
|
|
}
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestListGasAccountFailsWhenRelationIdentityProjectionCannotLoad(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT count(*) FROM "gas_account"`)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "gas_account" ORDER BY created_at desc LIMIT $1`)).
|
|
WithArgs(20).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "gas_basic_id", "username", "display_name", "password_hash", "role_code"}).
|
|
AddRow(uint64(9), "account-a", nil, nil, "enabled", 1, uint64(7), "operator", "Operator", "hash", "admin"))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id","identity" FROM "gas_basic" WHERE id IN ($1)`)).
|
|
WithArgs(uint64(7)).
|
|
WillReturnError(errors.New("relation lookup unavailable"))
|
|
|
|
ctx, recorder := updateContext(http.MethodGet, "/gas/gas_account", "", nil)
|
|
ListGasAccount(ctx)
|
|
|
|
if strings.Contains(recorder.Body.String(), `"code":0`) {
|
|
t.Fatalf("relation projection failure was returned as success: %s", recorder.Body.String())
|
|
}
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestGetDeliveryTrackOrdersAndMasksPointsWithoutPreciseLocationScope(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
now := time.Now().UTC()
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "delivery_track" WHERE identity = $1 ORDER BY "delivery_track"."id" LIMIT $2`)).
|
|
WithArgs("track-a", 1).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "delivery_task_id", "started_at", "completed_at"}).
|
|
AddRow(uint64(7), "track-a", nil, nil, "enabled", 1, uint64(8), now, nil))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "delivery_track_point" WHERE delivery_track_id = $1 ORDER BY occurred_at asc`)).
|
|
WithArgs(uint64(7)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "delivery_track_id", "point_type", "occurred_at", "longitude", "latitude"}).
|
|
AddRow(uint64(9), "point-a", nil, nil, "enabled", 1, uint64(7), "arrival", now, "120.123", "30.456"))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id","identity" FROM "delivery_task" WHERE id IN ($1)`)).
|
|
WithArgs(uint64(8)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity"}).AddRow(uint64(8), "task-a"))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT "id","identity" FROM "delivery_track" WHERE id IN ($1)`)).
|
|
WithArgs(uint64(7)).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity"}).AddRow(uint64(7), "track-a"))
|
|
|
|
ctx, recorder := updateContext(http.MethodGet, "/delivery/delivery_track/track-a", "track-a", nil)
|
|
GetDeliveryTrack(ctx)
|
|
|
|
assertResponseCode(t, recorder, 0)
|
|
if strings.Contains(recorder.Body.String(), "120.123") || strings.Contains(recorder.Body.String(), "30.456") {
|
|
t.Fatalf("unauthorized response exposed precise coordinates: %s", recorder.Body.String())
|
|
}
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestDisposeSafetyEventUpdatesEventAndAppendsOperatorActionTransactionally(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
now := time.Now().UTC()
|
|
mock.ExpectBegin()
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "saf_event" WHERE identity = $1 ORDER BY "saf_event"."id" LIMIT $2`)).
|
|
WithArgs("event-a", 1).
|
|
WillReturnRows(sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "event_code", "level", "title", "smart_cylinder_valve_identity", "sla_at"}).
|
|
AddRow(uint64(3), "event-a", now, now, "open", 1, "E-1", 2, "alarm", "valve-a", nil))
|
|
mock.ExpectExec(regexp.QuoteMeta(`UPDATE "saf_event" SET "status"=$1,"updated_at"=$2 WHERE identity = $3`)).
|
|
WithArgs("disposed", sqlmock.AnyArg(), "event-a").
|
|
WillReturnResult(sqlmock.NewResult(0, 1))
|
|
mock.ExpectQuery(regexp.QuoteMeta(`INSERT INTO "saf_event_disposal" ("identity","created_at","updated_at","status","version","saf_event_identity","action","reason","operator_identity") VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9) RETURNING "id"`)).
|
|
WithArgs(sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), "enabled", 1, "event-a", "close", "resolved", "operator-a").
|
|
WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(uint64(1)))
|
|
mock.ExpectCommit()
|
|
|
|
ctx, recorder := updateContext(http.MethodPost, "/safety/saf_event/event-a/disposals", "event-a", []byte(`{"action":"close","reason":"resolved"}`))
|
|
ctx.Set("Auth", &types.JwtClaims{Identity: "operator-a"})
|
|
DisposeSafetyEvent(ctx)
|
|
|
|
assertResponseCode(t, recorder, 0)
|
|
if !strings.Contains(recorder.Body.String(), `"operator_identity":"operator-a"`) {
|
|
t.Fatalf("disposal omitted its operator: %s", recorder.Body.String())
|
|
}
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestReplacePlatformRoleMenusAllowsAnEmptySetToClearAssignmentsTransactionally(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectBegin()
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "platform_role" WHERE identity = $1 ORDER BY "platform_role"."id" LIMIT $2`)).
|
|
WithArgs("role-a", 1).
|
|
WillReturnRows(platformRoleRows("role-a"))
|
|
mock.ExpectExec(regexp.QuoteMeta(`DELETE FROM "platform_role_menu_relation" WHERE platform_role_id = $1`)).
|
|
WithArgs(uint64(1)).
|
|
WillReturnResult(sqlmock.NewResult(0, 2))
|
|
mock.ExpectCommit()
|
|
|
|
ctx, recorder := updateContext(http.MethodPut, "/roles/role-a/menus", "role-a", []byte(`{"menu_identities":[]}`))
|
|
ReplacePlatformRoleMenus(ctx)
|
|
|
|
assertResponseCode(t, recorder, 0)
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
func TestReplacePlatformRoleMenusRejectsSystemRoleBeforeChangingRelations(t *testing.T) {
|
|
_, mock := setupPlatformRoleDatabase(t)
|
|
mock.ExpectBegin()
|
|
mock.ExpectQuery(regexp.QuoteMeta(`SELECT * FROM "platform_role" WHERE identity = $1 ORDER BY "platform_role"."id" LIMIT $2`)).
|
|
WithArgs("root-role", 1).
|
|
WillReturnRows(platformSystemRoleRows("root-role"))
|
|
mock.ExpectRollback()
|
|
|
|
ctx, recorder := updateContext(http.MethodPut, "/roles/root-role/menus", "root-role", []byte(`{"menu_identities":[]}`))
|
|
ReplacePlatformRoleMenus(ctx)
|
|
|
|
assertResponseCode(t, recorder, int32(status.Code(errcode.ErrInvalidArgument)))
|
|
assertMockExpectations(t, mock)
|
|
}
|
|
|
|
type responseBody struct {
|
|
Code int32 `json:"code"`
|
|
Message string `json:"message"`
|
|
Details json.RawMessage `json:"details"`
|
|
}
|
|
|
|
func setupPlatformRoleDatabase(t *testing.T) (*gorm.DB, sqlmock.Sqlmock) {
|
|
t.Helper()
|
|
previous := impl.DBService
|
|
sqlDatabase, mock, err := sqlmock.New()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
database, err := gorm.Open(postgres.New(postgres.Config{Conn: sqlDatabase}), &gorm.Config{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
impl.DBService = database
|
|
t.Cleanup(func() {
|
|
impl.DBService = previous
|
|
_ = sqlDatabase.Close()
|
|
})
|
|
return database, mock
|
|
}
|
|
|
|
func platformRoleRows(identity string) *sqlmock.Rows {
|
|
return sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "role_code", "name", "data_scope", "is_system"}).
|
|
AddRow(uint64(1), identity, nil, nil, "enabled", 1, identity, identity, "global", false)
|
|
}
|
|
|
|
func platformSystemRoleRows(identity string) *sqlmock.Rows {
|
|
return sqlmock.NewRows([]string{"id", "identity", "created_at", "updated_at", "status", "version", "role_code", "name", "data_scope", "is_system"}).
|
|
AddRow(uint64(1), identity, nil, nil, "enabled", 1, identity, identity, "global", true)
|
|
}
|
|
|
|
func updateContext(method, target, identity string, body []byte) (*gin.Context, *httptest.ResponseRecorder) {
|
|
recorder := httptest.NewRecorder()
|
|
ctx, _ := gin.CreateTestContext(recorder)
|
|
ctx.Request = httptest.NewRequest(method, target, bytes.NewReader(body))
|
|
ctx.Request.Header.Set("Content-Type", "application/json")
|
|
ctx.Params = gin.Params{{Key: "identity", Value: identity}}
|
|
return ctx, recorder
|
|
}
|
|
|
|
func assertResponseCode(t *testing.T, recorder *httptest.ResponseRecorder, want int32) {
|
|
t.Helper()
|
|
var reply responseBody
|
|
if err := json.Unmarshal(recorder.Body.Bytes(), &reply); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if reply.Code != want {
|
|
t.Fatalf("response code = %d, want %d: %s", reply.Code, want, recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func assertMockExpectations(t *testing.T, mock sqlmock.Sqlmock) {
|
|
t.Helper()
|
|
if err := mock.ExpectationsWereMet(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func assertContract(t *testing.T, contracts []ResourceContract, domain, name string, mode ResourceMode, pageKind string) {
|
|
t.Helper()
|
|
for _, contract := range contracts {
|
|
if contract.Domain == domain && contract.Name == name && contract.Mode == mode && contract.PageKind == pageKind {
|
|
return
|
|
}
|
|
}
|
|
t.Fatalf("missing resource contract %s/%s with mode %q and page kind %q", domain, name, mode, pageKind)
|
|
}
|