updates on the otp updates on the customer app

controllers/cxOtpFieldAlias_test.go

@@ -0,0 +1,88 @@
+package controllers
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// DM-01: the customer app posts the verification code as "otp"; the server was
+// written to read "code". req.Code was therefore always empty and EVERY
+// sign-in failed with a 400 — a correct code failed exactly like a wrong one.
+//
+// These pin the alias. The struct is re-declared here to match the handler's
+// anonymous one; what is under test is that both wire names reach the same
+// value and that the precedence is stable.
+type cxVerifyBody struct {
+	Identifier string `json:"identifier"`
+	Code       string `json:"code"`
+	Otp        string `json:"otp"`
+	Name       string `json:"name"`
+}
+
+// codeFrom mirrors the handler's selection: Code wins, Otp is the fallback.
+func codeFrom(b cxVerifyBody) string {
+	code := strings.TrimSpace(b.Code)
+	if code == "" {
+		code = strings.TrimSpace(b.Otp)
+	}
+	return code
+}
+
+func parseVerify(t *testing.T, raw string) cxVerifyBody {
+	t.Helper()
+	var b cxVerifyBody
+	if err := json.Unmarshal([]byte(raw), &b); err != nil {
+		t.Fatalf("unmarshal %s: %v", raw, err)
+	}
+	return b
+}
+
+// The shape the app actually sends. This is the regression that locked every
+// customer out of production.
+func TestVerifyAcceptsTheAppsOtpField(t *testing.T) {
+	body := parseVerify(t, `{"identifier":"+919000000001","otp":"123456"}`)
+	if got := codeFrom(body); got != "123456" {
+		t.Errorf(`{"otp":"123456"} yielded %q — the app's field is being dropped again`, got)
+	}
+}
+
+// The documented field keeps working unchanged.
+func TestVerifyStillAcceptsCode(t *testing.T) {
+	body := parseVerify(t, `{"identifier":"+919000000001","code":"123456"}`)
+	if got := codeFrom(body); got != "123456" {
+		t.Errorf(`{"code":"123456"} yielded %q, want "123456"`, got)
+	}
+}
+
+// When a client sends both, the documented field wins — so "code" stays the
+// contract and "otp" can be removed later without changing behaviour for
+// anyone who migrated.
+func TestCodeWinsOverOtpWhenBothArePresent(t *testing.T) {
+	body := parseVerify(t, `{"identifier":"+919000000001","code":"111111","otp":"222222"}`)
+	if got := codeFrom(body); got != "111111" {
+		t.Errorf("got %q, want the documented `code` value 111111", got)
+	}
+}
+
+// Neither field, or whitespace only, is still the empty-code rejection. The
+// alias must not turn a missing code into an accepted one.
+func TestMissingOrBlankCodeIsStillRejected(t *testing.T) {
+	for _, raw := range []string{
+		`{"identifier":"+919000000001"}`,
+		`{"identifier":"+919000000001","code":"","otp":""}`,
+		`{"identifier":"+919000000001","code":"   "}`,
+		`{"identifier":"+919000000001","otp":"  "}`,
+	} {
+		if got := codeFrom(parseVerify(t, raw)); got != "" {
+			t.Errorf("%s yielded %q, want empty so the handler rejects it", raw, got)
+		}
+	}
+}
+
+// A code arriving with padding must still match the stored one.
+func TestPaddedOtpIsTrimmed(t *testing.T) {
+	if got := codeFrom(parseVerify(t, `{"identifier":"x","otp":" 123456 "}`)); got != "123456" {
+		t.Errorf("got %q, want the trimmed 123456", got)
+	}
+}