map_test.go

package struct2

import (
	"reflect"
	"testing"
)

type stringerValue int

func (s stringerValue) String() string {
	return "stringerValue"
}

func str2Ptr(s string) *string {
	return &s
}

func int2Ptr(i int) *int {
	return &i
}

func TestDecoder_Map(t *testing.T) {
	type Train struct {
		Wagon *int `struct:"wagon,ptr2"`
	}
	type TrainNoPtr2 struct {
		Wagon *int `struct:"wagon"`
	}

	type TrainStringTags struct {
		Wagon    *int          `struct:"wagon,string"`
		Stringer stringerValue `struct:"stringer,string"`
	}

	train := Train{
		Wagon: int2Ptr(5),
	}

	type args struct {
		s any
	}
	tests := []struct {
		name    string
		decoder Decoder
		args    args
		want    map[string]any
	}{

		{
			name: "unexported test",
			args: args{
				s: struct {
					Name       string `struct:"name"`
					unexported string
				}{
					Name:       "abc",
					unexported: "unexported",
				},
			},
			want: map[string]any{
				"name": "abc",
			},
		},
		{
			name: "simple test",
			args: args{
				s: struct {
					Name string `struct:"name"`
					Ptr  *string
				}{
					Name: "abc",
					Ptr:  str2Ptr("pointer"),
				},
			},
			want: map[string]any{
				"name": "abc",
				"Ptr":  str2Ptr("pointer"),
			},
		},
		{
			name: "nil test",
			args: args{
				s: (*struct {
					Name string  `struct:"name"`
					Ptr  *string `struct:"ptr,ptr2"`
				})(nil),
			},
			want: nil,
		},
		{
			name: "ptr2 test",
			args: args{
				s: struct {
					Name string  `struct:"name"`
					Ptr  *string `struct:"ptr,ptr2"`
				}{
					Name: "abc",
					Ptr:  str2Ptr("pointer"),
				},
			},
			want: map[string]any{
				"name": "abc",
				"ptr":  "pointer",
			},
		},
		{
			name: "deep test",
			args: args{
				s: struct {
					Name  string  `struct:"name"`
					Ptr   *string `struct:"ptr,ptr2"`
					Train struct {
						Wagon *int `struct:"wagon,ptr2"`
					} `struct:"train"`
				}{
					Name: "abc",
					Ptr:  str2Ptr("pointer"),
					Train: struct {
						Wagon *int `struct:"wagon,ptr2"`
					}{Wagon: int2Ptr(5)},
				},
			},
			want: map[string]any{
				"name": "abc",
				"ptr":  "pointer",
				"train": map[string]any{
					"wagon": 5,
				},
			},
		},
		{
			name: "deep test with omitnested",
			args: args{
				s: struct {
					Name  string  `struct:"name"`
					Ptr   *string `struct:"ptr,ptr2"`
					Train *Train  `struct:"train,omitnested,ptr2"`
				}{
					Name:  "abc",
					Ptr:   str2Ptr("pointer"),
					Train: &train,
				},
			},
			want: map[string]any{
				"name":  "abc",
				"ptr":   "pointer",
				"train": train,
			},
		},
		{
			name: "slice pointer of struct",
			args: args{
				s: struct {
					Name  string   `struct:"name"`
					Ptr   *string  `struct:"ptr,ptr2"`
					Train *[]Train `struct:"train"`
				}{
					Name:  "abc",
					Ptr:   str2Ptr("pointer"),
					Train: &[]Train{train},
				},
			},
			want: map[string]any{
				"name":  "abc",
				"ptr":   "pointer",
				"train": []any{map[string]any{"wagon": 5}},
			},
		},
		{
			name:    "pointer with ForcePtr2",
			decoder: Decoder{ForcePtr2: true},
			args: args{
				s: struct {
					Name  string      `struct:"name"`
					Ptr   *string     `struct:"ptr"`
					Train TrainNoPtr2 `struct:"train"`
				}{
					Name:  "abc",
					Ptr:   str2Ptr("pointer"),
					Train: TrainNoPtr2{},
				},
			},
			want: map[string]any{
				"name": "abc",
				"ptr":  "pointer",
				"train": map[string]any{
					"wagon": 0,
				},
			},
		},
		{
			name:    "pointer with OmitNilPtr",
			decoder: Decoder{OmitNilPtr: true},
			args: args{
				s: struct {
					Name     string   `struct:"name"`
					Ptr      *string  `struct:"ptr,ptr2"`
					Train    Train    `struct:"train"`
					TrainPtr *Train   `struct:"trainPtr"`
					Trains   *[]Train `struct:"trains"`
				}{
					Name:     "abc",
					Ptr:      nil,
					Train:    Train{},
					TrainPtr: &Train{},
					Trains: &[]Train{
						{},
					},
				},
			},
			want: map[string]any{
				"name":     "abc",
				"train":    map[string]any{},
				"trainPtr": map[string]any{},
				"trains": []any{
					map[string]any{},
				},
			},
		},
		{
			name: "ouput with OuputCamelCase",
			decoder: Decoder{
				OuputCamelCase: true,
			},
			args: args{
				s: struct {
					Name     string
					Name2    string `struct:"Name2"`
					Train    Train
					TrainPtr *Train
					Trains   []Train
				}{
					Name:  "abc",
					Name2: "def",
					Train: Train{
						Wagon: int2Ptr(5),
					},
					TrainPtr: &Train{
						Wagon: int2Ptr(5),
					},
					Trains: []Train{
						{
							Wagon: int2Ptr(5),
						},
					},
				},
			},
			want: map[string]any{
				"name":  "abc",
				"Name2": "def",
				"train": map[string]any{
					"wagon": 5,
				},
				"trainPtr": map[string]any{
					"wagon": 5,
				},
				"trains": []any{
					map[string]any{
						"wagon": 5,
					},
				},
			},
		},
		{
			name: "string tags",
			args: args{
				s: struct {
					Train TrainStringTags `struct:"train"`
				}{
					Train: TrainStringTags{
						Wagon:    int2Ptr(5),
						Stringer: 1,
					},
				},
			},
			want: map[string]any{
				"train": map[string]any{
					"wagon":    "5",
					"stringer": "stringerValue",
				},
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.decoder.Map(tt.args.s); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Decoder.Map() = %#v, want %#v", got, tt.want)
			}
		})
	}
}

func TestDecoder_MapOmitNested(t *testing.T) {
	type Train struct {
		Wagon *int `struct:"wagon,ptr2"`
	}

	train := Train{
		Wagon: int2Ptr(5),
	}

	type args struct {
		s any
	}
	tests := []struct {
		name    string
		decoder Decoder
		args    args
		want    map[string]any
	}{
		{
			name: "deep test with omitnested",
			args: args{
				s: struct {
					Name  string  `struct:"name"`
					Ptr   *string `struct:"ptr,ptr2"`
					Train *Train  `struct:"train,ptr2"`
				}{
					Name:  "abc",
					Ptr:   str2Ptr("pointer"),
					Train: &train,
				},
			},
			want: map[string]any{
				"name":  "abc",
				"ptr":   "pointer",
				"train": train,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.decoder.Map(tt.args.s, WithOmitNested()); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Decoder.Map() = %#v, want %#v", got, tt.want)
			}
		})
	}
}

func TestDecoder_CustomHook(t *testing.T) {
	type args struct {
		s any
	}
	tests := []struct {
		name    string
		decoder Decoder
		args    args
		want    map[string]any
	}{
		{
			name: "simple test",
			decoder: Decoder{
				Hooks: []HookFunc{func(v reflect.Value) (any, error) {
					if v.Kind() == reflect.String {
						return "str_" + v.Interface().(string), nil
					}
					return nil, ErrContinueHook
				}},
			},
			args: args{
				s: struct {
					Name string `struct:"name"`
				}{
					Name: "abc",
				},
			},
			want: map[string]any{
				"name": "str_abc",
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.decoder.Map(tt.args.s); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Decoder.Map() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDecoder_MapWithSlice(t *testing.T) {
	type Train struct {
		Wagon *int `struct:"wagon,ptr2"`
	}

	tests := []struct {
		name string // description of this test case
		// Named input parameters for target function.
		input any
		opts  []optionMap
		want  []map[string]any
	}{
		{
			name:  "empty slice",
			input: []struct{}{},
			want:  []map[string]any{},
		},
		{
			name: "simple slice",
			input: []struct {
				Name string `struct:"name"`
			}{
				{Name: "a"},
				{Name: "b"},
			},
			want: []map[string]any{
				{"name": "a"},
				{"name": "b"},
			},
		},
		{
			name: "slice with nil element",
			input: []*struct {
				Name string `struct:"name"`
			}{
				{Name: "a"},
				nil,
			},
			want: []map[string]any{
				{"name": "a"},
				nil,
			},
		},
		{
			name: "slice with ptr2",
			input: []struct {
				Name string  `struct:"name"`
				Ptr  *string `struct:"ptr,ptr2"`
			}{
				{Name: "abc", Ptr: str2Ptr("pointer")},
			},
			want: []map[string]any{
				{"name": "abc", "ptr": "pointer"},
			},
		},
		{
			name: "slice with omitnested",
			input: []struct {
				Train *Train `struct:"train,ptr2"`
			}{
				{Train: &Train{Wagon: int2Ptr(5)}},
			},
			opts: []optionMap{WithOmitNested()},
			want: []map[string]any{
				{"train": Train{Wagon: int2Ptr(5)}},
			},
		},
		{
			name: "slice of any with structs",
			input: []any{
				struct {
					Name string `struct:"name"`
				}{Name: "test"},
				struct {
					Value int `struct:"value"`
				}{Value: 42},
			},
			want: []map[string]any{
				{"name": "test"},
				{"value": 42},
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var d Decoder
			got := d.MapSlice(tt.input, tt.opts...)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MapWithSlice() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestDecoder_MapWithSlicePanic(t *testing.T) {
	var d Decoder
	defer func() {
		if r := recover(); r == nil {
			t.Error("expected panic")
		}
	}()

	d.MapSlice("not a slice")
}