Изменен метода Schema.IsEqual - добавлена очистка состояния схемы перед...

Изменен метода Schema.IsEqual - добавлена очистка состояния схемы перед сравнением и метод для сравнения метаданных схемы

pkg/schema/schema.go

@@ -56,6 +56,8 @@ func (s *Schema) Equal(other *Schema) bool {
 	return s.IsEqual(other)
 }
 
+// IsEqual сравнивает две схемы на равенство.
+// Поле Loaded и метаданные не учитываются при сравнении.
 func (s *Schema) IsEqual(other *Schema) bool {
 	if s == other {
 		return true
@@ -63,13 +65,37 @@ func (s *Schema) IsEqual(other *Schema) bool {
 	if s == nil || other == nil {
 		return false
 	}
-	return reflect.DeepEqual(s.Field, other.Field)
+
+	// Клонируем схемы и очищаем состояние для корректного сравнения и не меняет исходные схемы
+	s1Clone := s.Clone(false).ClearState()
+	s2Clone := other.Clone(false).ClearState()
+
+	return reflect.DeepEqual(s1Clone.Field, s2Clone.Field)
+}
+
+// IsMetadataEqual сравнивает метаданные двух схем на равенство.
+func (s *Schema) IsMetadataEqual(other *Schema) bool {
+	if s == other {
+		return true
+	}
+	if s == nil || other == nil {
+		return false
+	}
+
+	return reflect.DeepEqual(s.Metadata, other.Metadata)
 }
 
 func IsEqual(s1, s2 *Schema) bool {
 	return s1.IsEqual(s2)
 }
 
+func IsMetadataEqual(s1, s2 *Schema) bool {
+	if s1 == nil {
+		return s2 == nil
+	}
+	return s1.IsMetadataEqual(s2)
+}
+
 func (s Schema) WithIncludes(includes ...interface{}) *Schema {
 	s.Field.SetIncludes(includes...)
 	return &s

pkg/schema/schema_test.go

@@ -116,3 +116,263 @@ func TestFromMap(t *testing.T) {
 		})
 	}
 }
+
+func TestSchema_IsEqual(t *testing.T) {
+	tests := []struct {
+		name      string
+		setupFunc func() (*Schema, *Schema)
+		expected  bool
+	}{
+		{
+			name: "identical schemas",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()), New("name", field.String())
+			},
+			expected: true,
+		},
+		{
+			name: "same reference",
+			setupFunc: func() (*Schema, *Schema) {
+				s := New("name", field.String())
+				return s, s
+			},
+			expected: true,
+		},
+		{
+			name: "first schema is nil",
+			setupFunc: func() (*Schema, *Schema) {
+				return nil, New("name", field.String())
+			},
+			expected: false,
+		},
+		{
+			name: "both schemas are nil",
+			setupFunc: func() (*Schema, *Schema) {
+				return nil, nil
+			},
+			expected: true,
+		},
+		{
+			name: "different field types",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()), New("name", field.Number(field.NumberFormatInt))
+			},
+			expected: false,
+		},
+		{
+			name: "different field names",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()), New("email", field.String())
+			},
+			expected: false,
+		},
+		{
+			name: "different number of fields",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()), New("name", field.String(), "email", field.String())
+			},
+			expected: false,
+		},
+		{
+			name: "same fields different metadata - ignored",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()).WithMetadata("key1", "value1"),
+					New("name", field.String()).WithMetadata("key1", "value2")
+			},
+			expected: true,
+		},
+		{
+			name: "same fields different loaded status",
+			setupFunc: func() (*Schema, *Schema) {
+				s1 := New("name", field.String())
+				s2 := New("name", field.String())
+				// при сравнении не учитывается поле Loaded
+				s1.Loaded = true
+				s2.Loaded = false
+				return s1, s2
+			},
+			expected: true,
+		},
+		{
+			name: "schemas with different states",
+			setupFunc: func() (*Schema, *Schema) {
+				s1 := New("name", field.String())
+				s2 := New("name", field.String())
+				s1.EnableState()
+				s2.EnableState()
+				if s1.Field.State != nil {
+					s1.Field.State.Name = "different1"
+				}
+				if s2.Field.State != nil {
+					s2.Field.State.Name = "different2"
+				}
+				return s1, s2
+			},
+			expected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s1, s2 := tt.setupFunc()
+			result := s1.IsEqual(s2)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestSchema_IsMetadataEqual(t *testing.T) {
+	tests := []struct {
+		name      string
+		setupFunc func() (*Schema, *Schema)
+		expected  bool
+	}{
+		{
+			name: "identical schemas with same metadata",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()).WithMetadata("key1", "value1"),
+					New("name", field.String()).WithMetadata("key1", "value1")
+			},
+			expected: true,
+		},
+		{
+			name: "same reference",
+			setupFunc: func() (*Schema, *Schema) {
+				s := New("name", field.String()).WithMetadata("key1", "value1")
+				return s, s
+			},
+			expected: true,
+		},
+		{
+			name: "first schema is nil",
+			setupFunc: func() (*Schema, *Schema) {
+				return nil, New("name", field.String()).WithMetadata("key1", "value1")
+			},
+			expected: false,
+		},
+		{
+			name: "second schema is nil",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()).WithMetadata("key1", "value1"), nil
+			},
+			expected: false,
+		},
+		{
+			name: "both schemas are nil",
+			setupFunc: func() (*Schema, *Schema) {
+				return nil, nil
+			},
+			expected: true,
+		},
+		{
+			name: "no metadata in both schemas",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()), New("name", field.String())
+			},
+			expected: true,
+		},
+		{
+			name: "different metadata values",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()).WithMetadata("key1", "value1"),
+					New("name", field.String()).WithMetadata("key1", "value2")
+			},
+			expected: false,
+		},
+		{
+			name: "different metadata keys",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()).WithMetadata("key1", "value1"),
+					New("name", field.String()).WithMetadata("key2", "value1")
+			},
+			expected: false,
+		},
+		{
+			name: "one schema has metadata, other doesn't",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()).WithMetadata("key1", "value1"),
+					New("name", field.String())
+			},
+			expected: false,
+		},
+		{
+			name: "multiple metadata keys - same",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()).WithMetadata("key1", "value1", "key2", "value2"),
+					New("name", field.String()).WithMetadata("key1", "value1", "key2", "value2")
+			},
+			expected: true,
+		},
+		{
+			name: "multiple metadata keys - different order but same content",
+			setupFunc: func() (*Schema, *Schema) {
+				s1 := New("name", field.String()).WithMetadata("key1", "value1", "key2", "value2")
+				s2 := New("name", field.String()).WithMetadata("key2", "value2", "key1", "value1")
+				return s1, s2
+			},
+			expected: true,
+		},
+		{
+			name: "same fields different metadata - should detect difference",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()).WithMetadata("key1", "value1"),
+					New("name", field.String()).WithMetadata("key1", "value2")
+			},
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s1, s2 := tt.setupFunc()
+			result := s1.IsMetadataEqual(s2)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestIsMetadataEqual(t *testing.T) {
+	tests := []struct {
+		name      string
+		setupFunc func() (*Schema, *Schema)
+		expected  bool
+	}{
+		{
+			name: "both schemas nil",
+			setupFunc: func() (*Schema, *Schema) {
+				return nil, nil
+			},
+			expected: true,
+		},
+		{
+			name: "first schema nil",
+			setupFunc: func() (*Schema, *Schema) {
+				return nil, New("name", field.String())
+			},
+			expected: false,
+		},
+		{
+			name: "second schema nil",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()), nil
+			},
+			expected: false,
+		},
+		{
+			name: "same metadata",
+			setupFunc: func() (*Schema, *Schema) {
+				return New("name", field.String()).WithMetadata("key1", "value1"),
+					New("name", field.String()).WithMetadata("key1", "value1")
+			},
+			expected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s1, s2 := tt.setupFunc()
+			result := IsMetadataEqual(s1, s2)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}