Merge pull request #11 from kashifkhan0771/feat/compare-structs

added structs comparison support

Author: shahzadhaider1

structs/structs.go

@@ -0,0 +1,62 @@
+package structs
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Result represents the comparison outcome of a field, including its name, old value, and new value.
+type Result struct {
+	FieldName string
+	OldValue  interface{}
+	NewValue  interface{}
+}
+
+/*
+CompareStructs compares two struct instances of the same type
+and returns a list of results with the old and new values of each field tagged with `updateable`.
+*/
+func CompareStructs(old, new interface{}) ([]Result, error) {
+	if reflect.TypeOf(old) != reflect.TypeOf(new) {
+		return nil, fmt.Errorf("both structs must be of the same type")
+	}
+
+	oldValue := reflect.ValueOf(old)
+	newValue := reflect.ValueOf(new)
+
+	if oldValue.Kind() != reflect.Struct || newValue.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("both parameters should be struct")
+	}
+
+	var comparedResults = make([]Result, 0, oldValue.NumField())
+
+	for i := 0; i < oldValue.NumField(); i++ {
+		field := oldValue.Type().Field(i)
+
+		if !field.IsExported() {
+			continue // skip unexported fields
+		}
+
+		oldFieldValue := oldValue.Field(i)
+		newFieldValue := newValue.Field(i)
+
+		// check if the field has the `updateable` tag
+		if tag, ok := field.Tag.Lookup("updateable"); ok && tag != "" {
+			fieldName := field.Name // default to the struct field name
+			if tag != "true" {      // if a custom tag is provided, use that as the field name
+				fieldName = tag
+			}
+
+			if !reflect.DeepEqual(oldFieldValue.Interface(), newFieldValue.Interface()) {
+				comparedResults = append(comparedResults, Result{
+					FieldName: fieldName,
+					OldValue:  oldFieldValue.Interface(),
+					NewValue:  newFieldValue.Interface(),
+				})
+			}
+		}
+
+	}
+
+	return comparedResults, nil
+}

structs/structs_test.go

@@ -0,0 +1,95 @@
+package structs
+
+import (
+	"reflect"
+	"testing"
+	"time"
+)
+
+type Test struct {
+	Name    string `updateable:"name"`
+	Age     int    `updateable:"age"`
+	IsAdult bool   `updateable:"is_adult"`
+}
+
+type ComplexTest struct {
+	Data      Test      `updateable:"data"`
+	UpdatedOn time.Time `updateable:"updated_on"`
+	History   []string  `updateable:"history"`
+}
+
+func TestCompareStructs(t *testing.T) {
+	tests := []struct {
+		name    string
+		old     interface{}
+		new     interface{}
+		want    []Result
+		wantErr bool
+	}{
+		{
+			name: "success - compare two structs",
+			old:  Test{Name: "example", Age: 10, IsAdult: false},
+			new:  Test{Name: "example - updated", Age: 18, IsAdult: true},
+			want: []Result{
+				{
+					FieldName: "name",
+					OldValue:  "example",
+					NewValue:  "example - updated",
+				},
+				{
+					FieldName: "age",
+					OldValue:  10,
+					NewValue:  18,
+				},
+				{
+					FieldName: "is_adult",
+					OldValue:  false,
+					NewValue:  true,
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name: "success - compare two complex structs",
+			old:  ComplexTest{Data: Test{Name: "example1", Age: 25, IsAdult: true}, UpdatedOn: time.Date(2024, 10, 22, 00, 00, 00, 00, time.UTC), History: []string{"user1", "user2"}},
+			new:  ComplexTest{Data: Test{Name: "example1", Age: 26, IsAdult: true}, UpdatedOn: time.Date(2024, 10, 22, 00, 01, 00, 00, time.UTC), History: []string{"user1", "user2", "user3"}},
+			want: []Result{
+				{
+					FieldName: "data",
+					OldValue:  Test{Name: "example1", Age: 25, IsAdult: true},
+					NewValue:  Test{Name: "example1", Age: 26, IsAdult: true},
+				},
+				{
+					FieldName: "updated_on",
+					OldValue:  time.Date(2024, 10, 22, 00, 00, 00, 00, time.UTC),
+					NewValue:  time.Date(2024, 10, 22, 00, 01, 00, 00, time.UTC),
+				},
+				{
+					FieldName: "history",
+					OldValue:  []string{"user1", "user2"},
+					NewValue:  []string{"user1", "user2", "user3"},
+				},
+			},
+			wantErr: false,
+		},
+		{
+			name:    "fail - non struct parameters",
+			old:     map[string]string{"test": "example"},
+			new:     map[string]string{"test": "example-updated"},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := CompareStructs(tt.old, tt.new)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("CompareStructs() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("CompareStructs() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}