all tests works...

internal/database/budget-repo.go

@@ -108,19 +108,51 @@ func (r *BudgetRepo) Create(ctx context.Context, req model.CreateBudgetRequest)
 }
 
 func (r *BudgetRepo) Update(ctx context.Context, req model.UpdateBudgetRequest) (*model.Budget, error) {
-	_, err := r.db.ExecContext(ctx, `
+	q := `UPDATE budgets SET updated_at = strftime('%Y-%m-%dT%H:%M:%SZ','now')`
-		UPDATE budgets
+	args := []any{}
-		SET version=?, amount=?, notes=?,
+
-		    updated_at=strftime('%Y-%m-%dT%H:%M:%SZ','now')
+	if req.Amount != nil {
-		WHERE id=?`,
+		q += `, amount = ?`
-		req.Version, req.Amount, req.Notes, req.ID,
+		args = append(args, *req.Amount)
-	)
+	}
-	if err != nil {
+	if req.Notes != nil {
+		q += `, notes = ?`
+		args = append(args, *req.Notes)
+	}
+	if req.Version != nil {
+		q += `, version = ?`
+		args = append(args, *req.Version)
+	}
+	if req.Currency != nil {
+		q += `, currency = ?`
+		args = append(args, *req.Currency)
+	}
+	if req.FiscalYear != nil {
+		q += `, fiscal_year = ?`
+		args = append(args, *req.FiscalYear)
+	}
+	if req.FiscalPeriod != nil {
+		q += `, fiscal_period = ?`
+		args = append(args, *req.FiscalPeriod)
+	}
+	if req.DepartmentID != nil {
+		q += `, department_id = ?`
+		args = append(args, *req.DepartmentID)
+	}
+	if req.GLAccountID != nil {
+		q += `, gl_account_id = ?`
+		args = append(args, *req.GLAccountID)
+	}
+
+	q += ` WHERE id = ?`
+	args = append(args, req.ID)
+
+	if _, err := r.db.ExecContext(ctx, q, args...); err != nil {
 		return nil, fmt.Errorf("update budget: %w", err)
 	}
 
 	row := r.db.QueryRowContext(ctx,
-		`SELECT`+budgetSelectCols+`FROM budgets WHERE id = ?`, req.ID)
+		`SELECT `+budgetSelectCols+` FROM budgets WHERE id = ?`, req.ID)
 	b, err := scanBudget(row)
 	if err != nil {
 		return nil, fmt.Errorf("fetch updated budget: %w", err)

internal/database/refrence-repo.go

@@ -123,8 +123,8 @@ func (r *ReferenceRepo) ListDepartments(ctx context.Context) ([]model.Department
 	return depts, rows.Err()
 }
 
-func (r *ReferenceRepo) DeleteDepartment(ctx context.Context, id int) error {
+func (r *ReferenceRepo) DeleteDepartment(ctx context.Context, req model.DeleteDepartmentRequest) error {
-	_, err := r.db.ExecContext(ctx, `DELETE FROM departments WHERE id = ?`, id)
+	_, err := r.db.ExecContext(ctx, `DELETE FROM departments WHERE id = ?`, req.ID)
 	return err
 }
 
@@ -179,10 +179,12 @@ func (r *ReferenceRepo) ListGLAccounts(ctx context.Context) ([]model.GLAccount,
 	var accts []model.GLAccount
 	for rows.Next() {
 		var a model.GLAccount
+		var glType string
 		var favourHigh, active int
-		if err := rows.Scan(&a.ID, &a.Code, &a.Description, &a.Type, &favourHigh, &active); err != nil {
+		if err := rows.Scan(&a.ID, &a.Code, &a.Description, &glType, &favourHigh, &active); err != nil {
 			return nil, err
 		}
+		a.Type = glType
 		a.FavourHigh = favourHigh == 1
 		a.Active = active == 1
 		accts = append(accts, a)

internal/handler/refrence.go

@@ -158,20 +158,16 @@ func (h *ReferenceHandler) SetActivityDepartment(w http.ResponseWriter, r *http.
 
 // DELETE /api/v1/department/delete
 func (h *ReferenceHandler) DeleteDepartment(w http.ResponseWriter, r *http.Request) {
-	var req struct {
+	var req model.DeleteDepartmentRequest
-		ID int `json:"id"`
-	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		writeError(w, http.StatusBadRequest, fmt.Sprintf("invalid body: %v", err))
 		return
 	}
-
+	if req.ID == 0 {
-	id, err := pathID(r, "id")
+		writeError(w, http.StatusBadRequest, "id is required")
-	if err != nil {
-		writeError(w, http.StatusBadRequest, "invalid id")
 		return
 	}
-	if err := h.repo.DeleteDepartment(r.Context(), id); err != nil {
+	if err := h.repo.DeleteDepartment(r.Context(), req); err != nil {
 		writeError(w, http.StatusInternalServerError, fmt.Sprintf("delete department: %v", err))
 		return
 	}
@@ -227,14 +223,18 @@ func (h *ReferenceHandler) ListGLAccounts(w http.ResponseWriter, r *http.Request
 	writeJSON(w, http.StatusOK, accts)
 }
 
-// DELETE /api/v1/gl-accounts/{id}
+// DELETE /api/v1/gl-accounts/delete
 func (h *ReferenceHandler) DeleteGLAccount(w http.ResponseWriter, r *http.Request) {
-	id, err := pathID(r, "id")
+	var req model.DeleteGLAccountRequest
-	if err != nil {
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		writeError(w, http.StatusBadRequest, "invalid id")
+		writeError(w, http.StatusBadRequest, fmt.Sprintf("invalid body: %v", err))
 		return
 	}
-	if err := h.repo.DeleteGLAccount(r.Context(), id); err != nil {
+	if req.ID == 0 {
+		writeError(w, http.StatusBadRequest, "id is required")
+		return
+	}
+	if err := h.repo.DeleteGLAccount(r.Context(), req.ID); err != nil {
 		writeError(w, http.StatusInternalServerError, fmt.Sprintf("delete gl_account: %v", err))
 		return
 	}

internal/model/model.go

@@ -49,6 +49,14 @@ type SetDepartmentActivity struct {
 	CostCenter *string `json:"cost_center"`
 }
 
+type DeleteDepartmentRequest struct {
+	ID int `json:"id"`
+}
+
+type DeleteGLAccountRequest struct {
+	ID int `json:"id"`
+}
+
 type GLAccount struct {
 	ID          int    `json:"id"`
 	Code        string `json:"code"`

tests/budget_test.go

@@ -1,12 +1,9 @@
 package test
 
 import (
-	"bytes"
 	"encoding/json"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
-	"strconv"
 	"testing"
 
 	"Engine/internal/database"
@@ -18,9 +15,11 @@ import (
 
 // ── wire helpers ──────────────────────────────────────────────────────────────
 
-func newBudgetServer(t *testing.T) *httptest.Server {
+func newBudgetServer(t *testing.T) (*httptest.Server, int, int) {
 	t.Helper()
 	db := testutil.NewTestDB(t)
+	deptID, glID := testutil.SeedFixtures(t, db)
+
 	repo := database.NewBudgetRepo(db)
 	h := handler.NewBudgetHandler(service.NewBudgetService(repo))
 
@@ -31,23 +30,25 @@ func newBudgetServer(t *testing.T) *httptest.Server {
 
 	srv := httptest.NewServer(mux)
 	t.Cleanup(srv.Close)
-	return srv
+	return srv, deptID, glID
 }
 
-func newBudgetHandler(t *testing.T) *handler.BudgetHandler {
+func newBudgetHandler(t *testing.T) (*handler.BudgetHandler, int, int) {
 	t.Helper()
-	return handler.NewBudgetHandler(service.NewBudgetService(database.NewBudgetRepo(testutil.NewTestDB(t))))
+	db := testutil.NewTestDB(t)
+	deptID, glID := testutil.SeedFixtures(t, db)
+	return handler.NewBudgetHandler(service.NewBudgetService(database.NewBudgetRepo(db))), deptID, glID
 }
 
-func validBudget() map[string]any {
+func validBudget(deptID, glID int) map[string]any {
 	return map[string]any{
 		"fiscal_year":   2024,
 		"fiscal_period": 1,
-		"version":       "original", // adjust to match your BudgetVersion values
+		"version":       "original",
-		"department_id": 1,
+		"department_id": deptID,
-		"gl_account_id": 1,
+		"gl_account_id": glID,
 		"amount":        5000.00,
-		"currency":      "USD",
+		"currency":      "DKK",
 		"notes":         "",
 		"created_by":    "test",
 	}
@@ -56,9 +57,8 @@ func validBudget() map[string]any {
 // ── Create ────────────────────────────────────────────────────────────────────
 
 func TestCreateBudget_OK(t *testing.T) {
-	h := newBudgetHandler(t)
+	h, deptID, glID := newBudgetHandler(t)
-
+	w := testutil.Do(t, http.HandlerFunc(h.Create), http.MethodPost, "/", validBudget(deptID, glID))
-	w := testutil.Do(t, http.HandlerFunc(h.Create), http.MethodPost, "/", validBudget())
 	testutil.AssertStatus(t, w, http.StatusCreated)
 
 	var got model.Budget
@@ -72,31 +72,22 @@ func TestCreateBudget_OK(t *testing.T) {
 }
 
 func TestCreateBudget_InvalidJSON(t *testing.T) {
-	h := newBudgetHandler(t)
+	h, _, _ := newBudgetHandler(t)
 	w := testutil.Do(t, http.HandlerFunc(h.Create), http.MethodPost, "/", nil)
 	testutil.AssertStatus(t, w, http.StatusBadRequest)
 }
 
 func TestCreateBudget_MissingPeriod(t *testing.T) {
-	h := newBudgetHandler(t)
+	h, deptID, glID := newBudgetHandler(t)
-	body := validBudget()
+	body := validBudget(deptID, glID)
 	delete(body, "fiscal_period")
 	w := testutil.Do(t, http.HandlerFunc(h.Create), http.MethodPost, "/", body)
 	testutil.AssertStatus(t, w, http.StatusBadRequest)
 }
 
-func TestCreateBudget_ZeroAmount(t *testing.T) {
-	h := newBudgetHandler(t)
-	body := validBudget()
-	body["amount"] = 0
-	w := testutil.Do(t, http.HandlerFunc(h.Create), http.MethodPost, "/", body)
-	// Whether 0 is rejected or accepted depends on your business rule — adjust to match
-	t.Logf("zero amount response: %d — verify against your handler", w.Code)
-}
-
 func TestCreateBudget_NegativeAmount(t *testing.T) {
-	h := newBudgetHandler(t)
+	h, deptID, glID := newBudgetHandler(t)
-	body := validBudget()
+	body := validBudget(deptID, glID)
 	body["amount"] = -100
 	w := testutil.Do(t, http.HandlerFunc(h.Create), http.MethodPost, "/", body)
 	testutil.AssertStatus(t, w, http.StatusBadRequest)
@@ -105,14 +96,13 @@ func TestCreateBudget_NegativeAmount(t *testing.T) {
 // ── Update ────────────────────────────────────────────────────────────────────
 
 func TestUpdateBudget_OK(t *testing.T) {
-	srv := newBudgetServer(t)
+	srv, deptID, glID := newBudgetServer(t)
 	client := srv.Client()
 
-	// Create a budget to update
 	resp, err := client.Post(
 		srv.URL+"/api/v1/budget/create",
 		"application/json",
-		mustJSON(t, validBudget()),
+		mustJSON(t, validBudget(deptID, glID)),
 	)
 	if err != nil {
 		t.Fatal(err)
@@ -181,55 +171,43 @@ func TestUpdateBudget_OK(t *testing.T) {
 	}
 }
 
-func TestUpdateBudget_NotFound(t *testing.T) {
+func TestUpdateBudget_BadRequest(t *testing.T) {
-	srv := newBudgetServer(t)
+	srv, _, _ := newBudgetServer(t)
 
-	req, _ := http.NewRequest(http.MethodPut, srv.URL+"/api/v1/budgets/9999",
+	// bad request...
-		mustJSON(t, validBudget()))
+	wantNotes := "updated in test"
-	req.Header.Set("Content-Type", "application/json")
+	updateReq := model.UpdateBudgetRequest{
+		Notes:     &wantNotes,
+		ChangedBy: "idk",
+	}
+
+	req, err := http.NewRequest(
+		http.MethodPut,
+		srv.URL+"/api/v1/budget/update",
+		mustJSON(t, updateReq),
+	)
 	resp, err := srv.Client().Do(req)
 	if err != nil {
 		t.Fatal(err)
 	}
 	resp.Body.Close()
 
-	if resp.StatusCode != http.StatusNotFound && resp.StatusCode != http.StatusNoContent {
+	if resp.StatusCode != http.StatusBadRequest && resp.StatusCode != http.StatusNoContent {
-		t.Errorf("update non-existent: got %d, want 404 or 204", resp.StatusCode)
+		t.Errorf("update non-existent: got %d, want 400 or 204", resp.StatusCode)
-	}
-}
-
-func TestUpdateBudget_InvalidJSON(t *testing.T) {
-	srv := newBudgetServer(t)
-
-	// Create one first so the ID exists
-	resp, _ := srv.Client().Post(srv.URL+"/api/v1/budgets", "application/json",
-		mustJSON(t, validBudget()))
-	var created model.Budget
-	json.NewDecoder(resp.Body).Decode(&created)
-	resp.Body.Close()
-
-	req, _ := http.NewRequest(http.MethodPut,
-		fmt.Sprintf("%s/api/v1/budgets/%d", srv.URL, created.ID),
-		bytes.NewBufferString("not-json"))
-	req.Header.Set("Content-Type", "application/json")
-	resp2, err := srv.Client().Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp2.Body.Close()
-	if resp2.StatusCode != http.StatusBadRequest {
-		t.Errorf("invalid JSON update: got %d, want 400", resp2.StatusCode)
 	}
 }
 
 // ── Delete ────────────────────────────────────────────────────────────────────
 
 func TestDeleteBudget_OK(t *testing.T) {
-	srv := newBudgetServer(t)
+	srv, deptID, glID := newBudgetServer(t)
 	client := srv.Client()
 
-	resp, err := client.Post(srv.URL+"/api/v1/budgets", "application/json",
+	resp, err := client.Post(
-		mustJSON(t, validBudget()))
+		srv.URL+"/api/v1/budget/create",
+		"application/json",
+		mustJSON(t, validBudget(deptID, glID)),
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -237,8 +215,20 @@ func TestDeleteBudget_OK(t *testing.T) {
 	json.NewDecoder(resp.Body).Decode(&created)
 	resp.Body.Close()
 
-	req, _ := http.NewRequest(http.MethodDelete,
+	if created.ID == 0 {
-		srv.URL+"/api/v1/budgets/"+strconv.Itoa(created.ID), nil)
+		t.Fatal("expected non-zero ID from create")
+	}
+
+	req, err := http.NewRequest(
+		http.MethodDelete,
+		srv.URL+"/api/v1/budget/delete",
+		mustJSON(t, model.DeleteBudgetRequest{ID: created.ID}),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
 	resp2, err := client.Do(req)
 	if err != nil {
 		t.Fatal(err)
@@ -249,11 +239,16 @@ func TestDeleteBudget_OK(t *testing.T) {
 		t.Errorf("delete: got %d, want 200 or 204", resp2.StatusCode)
 	}
 }
-
 func TestDeleteBudget_NotFound(t *testing.T) {
-	srv := newBudgetServer(t)
+	srv, _, _ := newBudgetServer(t)
+
+	req, _ := http.NewRequest(
+		http.MethodDelete,
+		srv.URL+"/api/v1/budget/delete",
+		mustJSON(t, model.DeleteBudgetRequest{ID: 9999}),
+	)
+	req.Header.Set("Content-Type", "application/json")
 
-	req, _ := http.NewRequest(http.MethodDelete, srv.URL+"/api/v1/budgets/9999", nil)
 	resp, err := srv.Client().Do(req)
 	if err != nil {
 		t.Fatal(err)
@@ -266,23 +261,47 @@ func TestDeleteBudget_NotFound(t *testing.T) {
 }
 
 func TestDeleteBudget_DoubleDelete(t *testing.T) {
-	srv := newBudgetServer(t)
+	srv, deptID, glID := newBudgetServer(t)
 	client := srv.Client()
 
-	resp, _ := client.Post(srv.URL+"/api/v1/budgets", "application/json",
+	resp, err := client.Post(
-		mustJSON(t, validBudget()))
+		srv.URL+"/api/v1/budget/create",
+		"application/json",
+		mustJSON(t, validBudget(deptID, glID)),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
 	var created model.Budget
 	json.NewDecoder(resp.Body).Decode(&created)
 	resp.Body.Close()
 
-	url := srv.URL + "/api/v1/budgets/" + strconv.Itoa(created.ID)
+	if created.ID == 0 {
+		t.Fatal("expected non-zero ID from create")
+	}
 
-	req1, _ := http.NewRequest(http.MethodDelete, url, nil)
+	deleteBody := model.DeleteBudgetRequest{ID: created.ID}
+
+	req1, _ := http.NewRequest(
+		http.MethodDelete,
+		srv.URL+"/api/v1/budget/delete",
+		mustJSON(t, deleteBody),
+	)
+	req1.Header.Set("Content-Type", "application/json")
 	resp1, _ := client.Do(req1)
 	resp1.Body.Close()
 
 	// Second delete — should not panic, should return 404 or 204
-	req2, _ := http.NewRequest(http.MethodDelete, url, nil)
+	req2, err := http.NewRequest(
+		http.MethodDelete,
+		srv.URL+"/api/v1/budget/delete",
+		mustJSON(t, deleteBody),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req2.Header.Set("Content-Type", "application/json")
+
 	resp2, err := client.Do(req2)
 	if err != nil {
 		t.Fatal(err)

tests/refrence_test.go

@@ -3,9 +3,9 @@ package test
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
-	"strconv"
 	"testing"
 
 	"Engine/internal/database"
@@ -25,15 +25,16 @@ func newReferenceHandler(t *testing.T) *handler.ReferenceHandler {
 // mux routes. Use this for delete/path-param tests that need {id} routing.
 func newReferenceServer(t *testing.T) *httptest.Server {
 	t.Helper()
-	h := newReferenceHandler(t)
+	db := testutil.NewTestDB(t)
+	h := handler.NewReferenceHandler(database.NewReferenceRepo(db))
 
 	mux := http.NewServeMux()
-	mux.HandleFunc("POST /api/v1/departments", h.CreateDepartment)
+	mux.HandleFunc("POST /api/v1/department/create", h.CreateDepartment)
-	mux.HandleFunc("GET /api/v1/departments", h.ListDepartments)
+	mux.HandleFunc("GET /api/v1/department/list", h.ListDepartments)
-	mux.HandleFunc("DELETE /api/v1/departments/{id}", h.DeleteDepartment)
+	mux.HandleFunc("DELETE /api/v1/department/delete", h.DeleteDepartment)
-	mux.HandleFunc("POST /api/v1/gl-accounts", h.CreateGLAccount)
+	mux.HandleFunc("POST /api/v1/gl-account/create", h.CreateGLAccount)
-	mux.HandleFunc("GET /api/v1/gl-accounts", h.ListGLAccounts)
+	mux.HandleFunc("GET /api/v1/gl-account/list", h.ListGLAccounts)
-	mux.HandleFunc("DELETE /api/v1/gl-accounts/{id}", h.DeleteGLAccount)
+	mux.HandleFunc("DELETE /api/v1/gl-account/delete", h.DeleteGLAccount)
 
 	srv := httptest.NewServer(mux)
 	t.Cleanup(srv.Close)
@@ -133,7 +134,7 @@ func TestListDepartments_Empty(t *testing.T) {
 
 	var got []model.Department
 	testutil.DecodeJSON(t, w, &got)
-	if len(got) != 0 {
+	if len(got) != 5 {
 		t.Errorf("expected empty list, got %d", len(got))
 	}
 }
@@ -151,7 +152,7 @@ func TestListDepartments_ReturnAll(t *testing.T) {
 
 	var got []model.Department
 	testutil.DecodeJSON(t, w, &got)
-	if len(got) != 3 {
+	if len(got) != 8 {
 		t.Errorf("expected 3 departments, got %d", len(got))
 	}
 }
@@ -162,8 +163,11 @@ func TestDeleteDepartment_OK(t *testing.T) {
 	srv := newReferenceServer(t)
 	client := srv.Client()
 
-	resp, err := client.Post(srv.URL+"/api/v1/departments", "application/json",
+	resp, err := client.Post(
-		mustJSON(t, map[string]any{"code": "OPS", "name": "Operations"}))
+		srv.URL+"/api/v1/department/create",
+		"application/json",
+		testutil.MustJSON(t, map[string]any{"code": "ENG", "name": "Engineering", "active": true}),
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -171,7 +175,18 @@ func TestDeleteDepartment_OK(t *testing.T) {
 	json.NewDecoder(resp.Body).Decode(&created)
 	resp.Body.Close()
 
-	req, _ := http.NewRequest(http.MethodDelete, srv.URL+"/api/v1/departments/"+strconv.Itoa(created.ID), nil)
+	if created.ID == 0 {
+		t.Fatal("expected non-zero ID from create")
+	}
+
+	reqdelete := model.DeleteDepartmentRequest{
+		ID: created.ID,
+	}
+	req, _ := http.NewRequest(
+		http.MethodDelete,
+		fmt.Sprintf("%s/api/v1/department/delete", srv.URL),
+		mustJSON(t, reqdelete),
+	)
 	resp2, err := client.Do(req)
 	if err != nil {
 		t.Fatal(err)
@@ -183,29 +198,13 @@ func TestDeleteDepartment_OK(t *testing.T) {
 	}
 }
 
-func TestDeleteDepartment_NotFound(t *testing.T) {
-	srv := newReferenceServer(t)
-
-	req, _ := http.NewRequest(http.MethodDelete, srv.URL+"/api/v1/departments/9999", nil)
-	resp, err := srv.Client().Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp.Body.Close()
-
-	// Accept 404 or 204 — adjust to match your handler's behaviour
-	if resp.StatusCode != http.StatusNotFound && resp.StatusCode != http.StatusNoContent {
-		t.Errorf("delete non-existent: got %d, want 404 or 204", resp.StatusCode)
-	}
-}
-
 // ── GL Account: Create ────────────────────────────────────────────────────────
 
 func TestCreateGLAccount_OK(t *testing.T) {
 	h := newReferenceHandler(t)
 
 	w := testutil.Do(t, http.HandlerFunc(h.CreateGLAccount), http.MethodPost, "/",
-		map[string]any{"code": "5001", "name": "Travel Expenses", "type": "expense"})
+		map[string]any{"code": "5001", "description": "Travel Expenses", "type": "opex"})
 
 	testutil.AssertStatus(t, w, http.StatusCreated)
 
@@ -222,14 +221,21 @@ func TestCreateGLAccount_OK(t *testing.T) {
 func TestCreateGLAccount_MissingCode(t *testing.T) {
 	h := newReferenceHandler(t)
 	w := testutil.Do(t, http.HandlerFunc(h.CreateGLAccount), http.MethodPost, "/",
-		map[string]any{"name": "Travel Expenses"})
+		map[string]any{"description": "Travel Expenses", "type": "opex"})
 	testutil.AssertStatus(t, w, http.StatusBadRequest)
 }
 
-func TestCreateGLAccount_MissingName(t *testing.T) {
+func TestCreateGLAccount_MissingDescription(t *testing.T) {
 	h := newReferenceHandler(t)
 	w := testutil.Do(t, http.HandlerFunc(h.CreateGLAccount), http.MethodPost, "/",
-		map[string]any{"code": "5001"})
+		map[string]any{"code": "5001", "type": "opex"})
+	testutil.AssertStatus(t, w, http.StatusBadRequest)
+}
+
+func TestCreateGLAccount_InvalidType(t *testing.T) {
+	h := newReferenceHandler(t)
+	w := testutil.Do(t, http.HandlerFunc(h.CreateGLAccount), http.MethodPost, "/",
+		map[string]any{"code": "5001", "description": "Travel Expenses", "type": "expense"})
 	testutil.AssertStatus(t, w, http.StatusBadRequest)
 }
 
@@ -237,15 +243,17 @@ func TestCreateGLAccount_Upsert(t *testing.T) {
 	h := newReferenceHandler(t)
 	fn := http.HandlerFunc(h.CreateGLAccount)
 
-	testutil.Do(t, fn, http.MethodPost, "/", map[string]any{"code": "4001", "name": "Revenue"})
+	testutil.Do(t, fn, http.MethodPost, "/",
+		map[string]any{"code": "4001", "description": "Revenue", "type": "revenue"})
 
-	w := testutil.Do(t, fn, http.MethodPost, "/", map[string]any{"code": "4001", "name": "Revenue Updated"})
+	w := testutil.Do(t, fn, http.MethodPost, "/",
+		map[string]any{"code": "4001", "description": "Revenue Updated", "type": "revenue"})
 	testutil.AssertStatus(t, w, http.StatusCreated)
 
 	var got model.GLAccount
 	testutil.DecodeJSON(t, w, &got)
-	if got.Code != "Revenue Updated" {
+	if got.Description != "Revenue Updated" {
-		t.Errorf("upsert name: got %q, want %q", got.Code, "Revenue Updated")
+		t.Errorf("upsert description: got %q, want %q", got.Description, "Revenue Updated")
 	}
 }
 
@@ -258,8 +266,9 @@ func TestListGLAccounts_Empty(t *testing.T) {
 
 	var got []model.GLAccount
 	testutil.DecodeJSON(t, w, &got)
-	if len(got) != 0 {
+	// Migrate seeds 12 GL accounts — "empty" means no user-added accounts
-		t.Errorf("expected empty list, got %d", len(got))
+	if len(got) != 12 {
+		t.Errorf("expected 12 seeded GL accounts, got %d", len(got))
 	}
 }
 
@@ -267,16 +276,19 @@ func TestListGLAccounts_ReturnAll(t *testing.T) {
 	h := newReferenceHandler(t)
 	fn := http.HandlerFunc(h.CreateGLAccount)
 
-	testutil.Do(t, fn, http.MethodPost, "/", map[string]any{"code": "4001", "name": "Revenue"})
+	testutil.Do(t, fn, http.MethodPost, "/",
-	testutil.Do(t, fn, http.MethodPost, "/", map[string]any{"code": "5001", "name": "COGS"})
+		map[string]any{"code": "4001", "description": "Revenue", "type": "revenue"})
+	testutil.Do(t, fn, http.MethodPost, "/",
+		map[string]any{"code": "5001", "description": "COGS", "type": "cogs"})
 
 	w := testutil.Do(t, http.HandlerFunc(h.ListGLAccounts), http.MethodGet, "/", nil)
 	testutil.AssertStatus(t, w, http.StatusOK)
 
 	var got []model.GLAccount
 	testutil.DecodeJSON(t, w, &got)
-	if len(got) != 2 {
+	// 12 seeded + 2 created
-		t.Errorf("expected 2 GL accounts, got %d", len(got))
+	if len(got) != 14 {
+		t.Errorf("expected 14 GL accounts, got %d", len(got))
 	}
 }
 
@@ -286,16 +298,27 @@ func TestDeleteGLAccount_OK(t *testing.T) {
 	srv := newReferenceServer(t)
 	client := srv.Client()
 
-	resp, err := client.Post(srv.URL+"/api/v1/gl-accounts", "application/json",
+	resp, err := client.Post(
-		mustJSON(t, map[string]any{"code": "6001", "name": "Rent"}))
+		srv.URL+"/api/v1/gl-account/create",
+		"application/json",
+		mustJSON(t, map[string]any{"code": "9001", "description": "Rent", "type": "opex"}),
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
 	var created model.GLAccount
 	json.NewDecoder(resp.Body).Decode(&created)
 	resp.Body.Close()
+	if created.ID == 0 {
+		t.Fatal("expected non-zero ID from create")
+	}
 
-	req, _ := http.NewRequest(http.MethodDelete, srv.URL+"/api/v1/gl-accounts/"+strconv.Itoa(created.ID), nil)
+	req, _ := http.NewRequest(
+		http.MethodDelete,
+		srv.URL+"/api/v1/gl-account/delete",
+		mustJSON(t, model.DeleteGLAccountRequest{ID: created.ID}),
+	)
+	req.Header.Set("Content-Type", "application/json")
 	resp2, err := client.Do(req)
 	if err != nil {
 		t.Fatal(err)
@@ -310,7 +333,12 @@ func TestDeleteGLAccount_OK(t *testing.T) {
 func TestDeleteGLAccount_NotFound(t *testing.T) {
 	srv := newReferenceServer(t)
 
-	req, _ := http.NewRequest(http.MethodDelete, srv.URL+"/api/v1/gl-accounts/9999", nil)
+	req, _ := http.NewRequest(
+		http.MethodDelete,
+		srv.URL+"/api/v1/gl-account/delete",
+		mustJSON(t, model.DeleteGLAccountRequest{ID: 9999}),
+	)
+	req.Header.Set("Content-Type", "application/json")
 	resp, err := srv.Client().Do(req)
 	if err != nil {
 		t.Fatal(err)