Self-hosted fitness tracker. Log workouts, track nutrition, and monitor progress. Docker deployment, mobile-friendly.
fix(#37): settings PUT is a true partial update (stop zeroing omitted targets)
Cawlummcfecaf4bda6e
diff --git a/backend/controllers/settings_test.go b/backend/controllers/settings_test.gonew file mode 100644index 0000000..0f74767--- /dev/null+++ b/backend/controllers/settings_test.go@@ -0,0 +1,121 @@+package controllers++import (+ "net/http"+ "net/http/httptest"+ "testing"+)++// settingsData pulls the UserSettings object out of a {"data": ...} envelope.+func settingsData(t *testing.T, w *httptest.ResponseRecorder) map[string]any {+ t.Helper()+ resp := decodeResponse(t, w)+ d, ok := resp["data"].(map[string]any)+ if !ok {+ t.Fatalf("data is not an object: %v", resp["data"])+ }+ return d+}++func assertNum(t *testing.T, d map[string]any, key string, want float64) {+ t.Helper()+ got, ok := d[key].(float64)+ if !ok {+ t.Fatalf("%s is not a number: %v", key, d[key])+ }+ if got != want {+ t.Fatalf("%s = %v, want %v", key, got, want)+ }+}++func TestGetSettings_defaultsWhenNoRow(t *testing.T) {+ setupTestDB(t)+ uid := createTestUser(t)++ c, w := newContext(uid, http.MethodGet, "/api/v1/settings", nil)+ th.GetSettings(c)++ if w.Code != http.StatusOK {+ t.Fatalf("expected 200, got %d", w.Code)+ }+ d := settingsData(t, w)+ assertNum(t, d, "calorie_target", 2000)+ assertNum(t, d, "protein_target", 150)+ assertNum(t, d, "carb_target", 250)+ assertNum(t, d, "fat_target", 65)+ if d["weight_unit"] != "lbs" {+ t.Fatalf("weight_unit = %v, want lbs", d["weight_unit"])+ }+}++// The #37 regression: a weight-unit-only PATCH on a user with no settings row+// must land the targets on their defaults, not zero them.+func TestUpdateSettings_partialUpdateSeedsDefaultsNotZeros(t *testing.T) {+ setupTestDB(t)+ uid := createTestUser(t)++ c, w := newContext(uid, http.MethodPut, "/api/v1/settings", map[string]any{"weight_unit": "kg"})+ th.UpdateSettings(c)++ if w.Code != http.StatusOK {+ t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())+ }+ d := settingsData(t, w)+ if d["weight_unit"] != "kg" {+ t.Fatalf("weight_unit = %v, want kg", d["weight_unit"])+ }+ assertNum(t, d, "calorie_target", 2000)+ assertNum(t, d, "protein_target", 150)+ assertNum(t, d, "carb_target", 250)+ assertNum(t, d, "fat_target", 65)+}++// A partial update over an EXISTING custom row leaves the omitted fields intact.+func TestUpdateSettings_partialUpdatePreservesCustomTargets(t *testing.T) {+ setupTestDB(t)+ uid := createTestUser(t)++ // Set custom targets.+ c, w := newContext(uid, http.MethodPut, "/api/v1/settings", map[string]any{+ "calorie_target": 1800, "protein_target": 200, "carb_target": 100, "fat_target": 50,+ })+ th.UpdateSettings(c)+ if w.Code != http.StatusOK {+ t.Fatalf("setup expected 200, got %d: %s", w.Code, w.Body.String())+ }++ // Change only the weight unit — the custom targets must survive.+ c, w = newContext(uid, http.MethodPut, "/api/v1/settings", map[string]any{"weight_unit": "kg"})+ th.UpdateSettings(c)+ if w.Code != http.StatusOK {+ t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())+ }+ d := settingsData(t, w)+ if d["weight_unit"] != "kg" {+ t.Fatalf("weight_unit = %v, want kg", d["weight_unit"])+ }+ assertNum(t, d, "calorie_target", 1800)+ assertNum(t, d, "protein_target", 200)+ assertNum(t, d, "carb_target", 100)+ assertNum(t, d, "fat_target", 50)+}++// An explicit 0 is a real value (the pointer distinguishes it from "absent"),+// so it must be stored while other omitted fields keep their values.+func TestUpdateSettings_explicitZeroRespected(t *testing.T) {+ setupTestDB(t)+ uid := createTestUser(t)++ c, w := newContext(uid, http.MethodPut, "/api/v1/settings", map[string]any{"protein_target": 0})+ th.UpdateSettings(c)++ if w.Code != http.StatusOK {+ t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())+ }+ d := settingsData(t, w)+ assertNum(t, d, "protein_target", 0)+ // Untouched fields stay on their defaults.+ assertNum(t, d, "calorie_target", 2000)+ assertNum(t, d, "carb_target", 250)+ assertNum(t, d, "fat_target", 65)+}diff --git a/backend/controllers/user.go b/backend/controllers/user.goindex 0e82bf5..ea760b8 100644--- a/backend/controllers/user.go+++ b/backend/controllers/user.go@@ -27,10 +27,7 @@ func (h *Handler) GetSettings(c *gin.Context) {s, err := h.s.User.GetSettings(uid)if err == sql.ErrNoRows {// No row yet — return the defaults.- utils.OK(c, models.UserSettings{- UserID: uid, WeightUnit: "lbs",- CalorieTarget: 2000, ProteinTarget: 150, CarbTarget: 250, FatTarget: 65,- })+ utils.OK(c, models.DefaultUserSettings(uid))return}if utils.DBError(c, err) {diff --git a/backend/models/models.go b/backend/models/models.goindex 5a4e754..93d2a02 100644--- a/backend/models/models.go+++ b/backend/models/models.go@@ -19,6 +19,20 @@ type UserSettings struct {FatTarget int `json:"fat_target" db:"fat_target"`}+// DefaultUserSettings is the single source of truth for a brand-new user's+// settings — returned when no row exists yet and used as the base a partial+// update merges onto. Must stay in sync with the user_settings column defaults.+func DefaultUserSettings(uid int64) UserSettings {+ return UserSettings{+ UserID: uid,+ WeightUnit: "lbs",+ CalorieTarget: 2000,+ ProteinTarget: 150,+ CarbTarget: 250,+ FatTarget: 65,+ }+}+type Exercise struct {ID int64 `json:"id" db:"id"`Name string `json:"name" db:"name"`@@ -209,12 +223,15 @@ type SaveFoodRequest struct {Barcode string `json:"barcode"`}+// UpdateSettingsRequest is a PATCH: every field is a pointer so a nil (absent+// from the JSON) is distinguishable from an intentional 0. Only non-nil fields+// are applied — a partial update never zeroes the fields it omits (#37).type UpdateSettingsRequest struct {- WeightUnit string `json:"weight_unit" validate:"omitempty,oneof=lbs kg"`- CalorieTarget int `json:"calorie_target" validate:"omitempty,gte=0"`- ProteinTarget int `json:"protein_target" validate:"omitempty,gte=0"`- CarbTarget int `json:"carb_target" validate:"omitempty,gte=0"`- FatTarget int `json:"fat_target" validate:"omitempty,gte=0"`+ WeightUnit *string `json:"weight_unit" validate:"omitempty,oneof=lbs kg"`+ CalorieTarget *int `json:"calorie_target" validate:"omitempty,gte=0"`+ ProteinTarget *int `json:"protein_target" validate:"omitempty,gte=0"`+ CarbTarget *int `json:"carb_target" validate:"omitempty,gte=0"`+ FatTarget *int `json:"fat_target" validate:"omitempty,gte=0"`}type Program struct {diff --git a/backend/stores/user.go b/backend/stores/user.goindex 6941117..b7fefd6 100644--- a/backend/stores/user.go+++ b/backend/stores/user.go@@ -38,9 +38,34 @@ func (s *UserStore) GetSettings(uid int64) (models.UserSettings, error) {return st, err}-// UpsertSettings writes the settings and returns the stored row (no controller--// to-controller call to render the response).+// UpsertSettings applies a partial update and returns the stored row. It starts+// from the current row (or the defaults if none exists), overlays only the fields+// the client actually sent, then writes the merged row back — so a partial PUT+// (e.g. weight-unit only) can never zero the targets it omitted (#37).func (s *UserStore) UpsertSettings(uid int64, req models.UpdateSettingsRequest) (models.UserSettings, error) {+ cur, err := s.GetSettings(uid)+ if err == sql.ErrNoRows {+ cur = models.DefaultUserSettings(uid)+ } else if err != nil {+ return models.UserSettings{}, err+ }++ if req.WeightUnit != nil {+ cur.WeightUnit = *req.WeightUnit+ }+ if req.CalorieTarget != nil {+ cur.CalorieTarget = *req.CalorieTarget+ }+ if req.ProteinTarget != nil {+ cur.ProteinTarget = *req.ProteinTarget+ }+ if req.CarbTarget != nil {+ cur.CarbTarget = *req.CarbTarget+ }+ if req.FatTarget != nil {+ cur.FatTarget = *req.FatTarget+ }+if _, err := s.db.Exec(`INSERT INTO user_settings (user_id, weight_unit, calorie_target, protein_target, carb_target, fat_target)VALUES (?, ?, ?, ?, ?, ?)@@ -50,7 +75,7 @@ func (s *UserStore) UpsertSettings(uid int64, req models.UpdateSettingsRequest)protein_target = excluded.protein_target,carb_target = excluded.carb_target,fat_target = excluded.fat_target`,- uid, req.WeightUnit, req.CalorieTarget, req.ProteinTarget, req.CarbTarget, req.FatTarget,+ uid, cur.WeightUnit, cur.CalorieTarget, cur.ProteinTarget, cur.CarbTarget, cur.FatTarget,); err != nil {return models.UserSettings{}, err}