Function TestGetRequirementSlices

parser_test.go:1396–1500

Verifies: SYS-REQ-016 [boundary] MCDC SYS-REQ-016: N/A Verifies: SYS-REQ-017 [boundary] MCDC SYS-REQ-017: N/A Verifies: SYS-REQ-018 [boundary] MCDC SYS-REQ-018: N/A Verifies: SYS-REQ-019 [boundary] MCDC SYS-REQ-019: N/A Verifies: SYS-REQ-020 [boundary] MCDC SYS-REQ-020: N/A Verifies: SYS-REQ-021 [bo

(t *testing.T)

// Verifies: SYS-REQ-027 [boundary]
// MCDC SYS-REQ-027: N/A
func TestGetRequirementSlices(t *testing.T) {
	t.Run("well formed missing path returns not found", func(t *testing.T) {
		value, dataType, offset, err := Get([]byte(`{"a":"b"}`), "missing")
		if !errors.Is(err, KeyPathNotFoundError) {
			t.Fatalf("expected KeyPathNotFoundError, got %v", err)
		}
		if dataType != NotExist || offset != -1 || value != nil {
			t.Fatalf("expected not-found tuple, got value=%v type=%v offset=%d", value, dataType, offset)
		}
	})

	t.Run("incomplete input returns parse error", func(t *testing.T) {
		if _, _, _, err := Get([]byte(`{"a":`), "a"); err == nil {
			t.Fatal("expected parse-related error for incomplete input")
		}
	})

	t.Run("no key path returns closest root value", func(t *testing.T) {
		value, dataType, _, err := Get([]byte(`{"a":1}`))
		if err != nil {
			t.Fatalf("Get without key path returned error: %v", err)
		}
		if dataType != Object || string(value) != `{"a":1}` {
			t.Fatalf("unexpected root value result: value=%s type=%v", string(value), dataType)
		}
	})

	t.Run("empty input with key path returns not found", func(t *testing.T) {
		_, dataType, offset, err := Get([]byte(""), "a")
		if !errors.Is(err, KeyPathNotFoundError) {
			t.Fatalf("expected KeyPathNotFoundError, got %v", err)
		}
		if dataType != NotExist || offset != -1 {
			t.Fatalf("expected empty-input not-found tuple, got type=%v offset=%d", dataType, offset)
		}
	})

	t.Run("object key lookup respects current scope", func(t *testing.T) {
		value, dataType, _, err := Get([]byte(`{"a":{"b":1},"b":2}`), "a", "b")
		if err != nil {
			t.Fatalf("nested object lookup returned error: %v", err)
		}
		if dataType != Number || string(value) != "1" {
			t.Fatalf("unexpected nested object lookup result: value=%s type=%v", string(value), dataType)
		}
	})

	t.Run("array index lookup returns in-bounds element", func(t *testing.T) {
		value, dataType, _, err := Get([]byte(`{"a":[{"b":1},"foo",3]}`), "a", "[1]")
		if err != nil {
			t.Fatalf("array index lookup returned error: %v", err)
		}
		if dataType != String || string(value) != "foo" {
			t.Fatalf("unexpected array lookup result: value=%s type=%v", string(value), dataType)
		}
	})

	t.Run("invalid array index syntax returns not found", func(t *testing.T) {