dto/validator/common_test.go (1)

236-244: Tests correctly cover IsEmpty for nil, empty slices, and maps; consider renaming for clarity.

The assertions look good and align with the new IsEmpty semantics. Minor nit: the test function is still named Test_IsNil, which can be confusing now that the API is IsEmpty.

Example rename:

func Test_IsEmpty(t *testing.T) {
    t.Parallel()
    assert.True(t, validator.IsEmpty(nil))
    assert.True(t, validator.IsEmpty([]string{}))

    a := []interface{}{}
    assert.True(t, validator.IsEmpty(a))

    b := make(map[string]interface{})
    assert.True(t, validator.IsEmpty(b))
}

dto/validator/scanner_test.go (1)

225-249: Use validate tag key consistently (not validator) to avoid confusion.

The scanner reads the validate struct tag. Here, ContactName uses validator:"isAlphanumeric", which is ignored. While this test still passes because Contact is nil, using a consistent tag key reduces surprises.

 type Contact struct {
-    ContactName  string `json:"name" validator:"isAlphanumeric"`
+    ContactName  string `json:"name" validate:"isAlphanumeric"`
     ContactEmail string `json:"email" validate:"isEmail"`
     ContactPhone string `json:"phone"`
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

dto/validator/common_test.go (1)

236-247: Broaden IsEmpty test coverage (nil slice vs empty slice, primitives, non-empty cases, arrays, interface-typed nils)

To lock in intended semantics and prevent regressions, add assertions for:

• nil slice vs empty slice
• non-empty slice/map (negative cases)
• empty primitives (string/number/bool) and zero time.Time
• non-nil pointer to zero-value struct (should be non-empty per current code)
• typed nil hidden in an interface
• arrays: zero-length vs zero-valued non-zero-length

This also documents the intended behavior difference from reflect.Value.IsZero for arrays.

 func Test_IsEmpty(t *testing.T) {
   t.Parallel()

   assert.True(t, validator.IsEmpty(nil))
   assert.True(t, validator.IsEmpty([]string{}))

   a := []interface{}{}
   assert.True(t, validator.IsEmpty(a))

   b := make(map[string]interface{})
   assert.True(t, validator.IsEmpty(b))

   type Pointer struct{}
   var c *Pointer
   assert.True(t, validator.IsEmpty(c))
+
+  // Nil slice vs empty slice
+  var s []string = nil
+  assert.True(t, validator.IsEmpty(s))
+  s2 := []string{"x"}
+  assert.False(t, validator.IsEmpty(s2))
+
+  // Non-empty map
+  b["k"] = "v"
+  assert.False(t, validator.IsEmpty(b))
+
+  // Empty primitives and zero-values
+  assert.True(t, validator.IsEmpty(""))
+  assert.True(t, validator.IsEmpty(0))
+  assert.True(t, validator.IsEmpty(0.0))
+  assert.True(t, validator.IsEmpty(false))
+  assert.True(t, validator.IsEmpty(time.Time{}))
+
+  // Non-nil pointer should be non-empty per current implementation
+  d := &Pointer{}
+  assert.False(t, validator.IsEmpty(d))
+
+  // Typed nil inside interface
+  var p *int = nil
+  var anyP interface{} = p
+  assert.True(t, validator.IsEmpty(anyP))
+
+  // Arrays: document semantics
+  var arr0 [0]int
+  assert.True(t, validator.IsEmpty(arr0))
+  var arr2 [2]int
+  assert.False(t, validator.IsEmpty(arr2)) // note: reflect.Value.IsZero(arr2) would be true
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

dto/validator/common.go (2)

311-318: Fix compile-time bug and pointer/interface semantics in IsEmpty

• reflect.Kind has Ptr, not Pointer. This won’t compile.
• Non-nil pointers that point to zero values (e.g., *string to "") should be treated as empty for typical “omitempty” semantics.
• Interfaces wrapping nil/pointers need the same handling.

Apply:

 switch val.Kind() {
-	case reflect.Pointer:
-		return val.IsNil()
-	case reflect.Array, reflect.Slice:
-		return val.Len() == 0
-	case reflect.Map:
-		return val.Len() == 0
+	case reflect.Ptr, reflect.Interface:
+		if val.IsNil() {
+			return true
+		}
+		// Recurse into underlying value so pointers/interfaces to zero values are empty.
+		return IsEmpty(val.Elem().Interface())
+	case reflect.Array, reflect.Slice, reflect.Map:
+		return val.Len() == 0
 	default:
 		return val.IsZero()
 }

---

311-312: Replace all reflect.Pointer usages with reflect.Ptr

To avoid build errors and ensure consistency, update the two remaining occurrences of the invalid reflect.Pointer constant:

• dto/validator/common.go (around line 311)

– case reflect.Pointer:
–   return val.IsNil()
+ case reflect.Ptr:
+   return val.IsNil()

• dto/validator/scanner.go (around line 115)

– if field.Type.Kind() == reflect.Pointer {
+ if field.Type.Kind() == reflect.Ptr {
    ptr := ct.Field(i).Interface()
    err := Scanner(ptr)

Ensure any other scanner or validator logic also uses reflect.Ptr consistently.

dto/validator/common.go (1)

305-319: Add tests for non-nil pointers to zero values and interface-wrapped pointers

Your current tests cover nil pointers; add cases for:

• p := new(string) (points to ""), expect IsEmpty(p) == true
• var v any = p, expect IsEmpty(v) == true
• Non-empty pointer, e.g., s := "x"; p := &s, expect IsEmpty(p) == false

Example tests (dto/validator/common_test.go):

func Test_IsEmpty_PointerToZeroString(t *testing.T) {
	var s string
	p := &s
	if !validator.IsEmpty(p) {
		t.Fatalf("expected pointer to zero string to be empty")
	}
}

func Test_IsEmpty_InterfaceWrappingPointer(t *testing.T) {
	var s string
	p := &s
	var v any = p
	if !validator.IsEmpty(v) {
		t.Fatalf("expected interface-wrapped pointer to zero value to be empty")
	}
}

func Test_IsEmpty_PointerToNonZeroString(t *testing.T) {
	s := "x"
	p := &s
	if validator.IsEmpty(p) {
		t.Fatalf("expected pointer to non-zero string to be non-empty")
	}
}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.