join_test.go

package simplecsv

import (
	"reflect"
	"testing"
)

func TestJoinByField(t *testing.T) {
	people := SimpleCsv{
		{"ID", "Name"},
		{"1", "Ana"},
		{"2", "Bob"},
		{"3", "Cid"},
	}
	ages := SimpleCsv{
		{"Age", "ID"},
		{"30", "1"},
		{"7", "2"},
	}

	joined, ok := people.JoinByField(ages, "ID")
	if !ok {
		t.Fatalf("JoinByField() ok = false, want true")
	}
	want := SimpleCsv{
		{"ID", "Name", "Age"},
		{"1", "Ana", "30"},
		{"2", "Bob", "7"},
	}
	if !reflect.DeepEqual(joined, want) {
		t.Errorf("JoinByField() = %v, want %v", joined, want)
	}
}

func TestLeftJoinByField(t *testing.T) {
	people := SimpleCsv{
		{"ID", "Name"},
		{"1", "Ana"},
		{"2", "Bob"},
		{"3", "Cid"},
	}
	ages := SimpleCsv{
		{"ID", "Age"},
		{"1", "30"},
	}

	joined, ok := people.LeftJoinByField(ages, "ID")
	if !ok {
		t.Fatalf("LeftJoinByField() ok = false, want true")
	}
	want := SimpleCsv{
		{"ID", "Name", "Age"},
		{"1", "Ana", "30"},
		{"2", "Bob", ""},
		{"3", "Cid", ""},
	}
	if !reflect.DeepEqual(joined, want) {
		t.Errorf("LeftJoinByField() = %v, want %v", joined, want)
	}

	// left join against a csv with only headers keeps all the rows of s
	empty := SimpleCsv{{"ID", "Age"}}
	joined, ok = people.LeftJoinByField(empty, "ID")
	if !ok {
		t.Fatalf("LeftJoinByField() ok = false, want true")
	}
	wantAll := SimpleCsv{
		{"ID", "Name", "Age"},
		{"1", "Ana", ""},
		{"2", "Bob", ""},
		{"3", "Cid", ""},
	}
	if !reflect.DeepEqual(joined, wantAll) {
		t.Errorf("LeftJoinByField() = %v, want %v", joined, wantAll)
	}
}

func TestJoinByFieldDuplicateValues(t *testing.T) {
	s := SimpleCsv{
		{"ID", "Name"},
		{"1", "Ana"},
		{"1", "Ann"},
	}
	other := SimpleCsv{
		{"ID", "City"},
		{"1", "Lisbon"},
		{"1", "Madrid"},
	}

	joined, ok := s.JoinByField(other, "ID")
	if !ok {
		t.Fatalf("JoinByField() ok = false, want true")
	}
	want := SimpleCsv{
		{"ID", "Name", "City"},
		{"1", "Ana", "Lisbon"},
		{"1", "Ana", "Madrid"},
		{"1", "Ann", "Lisbon"},
		{"1", "Ann", "Madrid"},
	}
	if !reflect.DeepEqual(joined, want) {
		t.Errorf("JoinByField() = %v, want %v", joined, want)
	}
}

func TestJoinByFieldMissingField(t *testing.T) {
	s := SimpleCsv{{"ID", "Name"}, {"1", "Ana"}}
	other := SimpleCsv{{"ID", "Age"}, {"1", "30"}}

	got, ok := s.JoinByField(other, "NoField")
	if ok {
		t.Errorf("JoinByField() ok = true, want false for a field missing in both csvs")
	}
	if !reflect.DeepEqual(got, s) {
		t.Errorf("JoinByField() = %v, want the unchanged csv %v", got, s)
	}

	got, ok = s.JoinByField(other, "Name")
	if ok {
		t.Errorf("JoinByField() ok = true, want false for a field missing in other")
	}
	if !reflect.DeepEqual(got, s) {
		t.Errorf("JoinByField() = %v, want the unchanged csv %v", got, s)
	}

	got, ok = s.LeftJoinByField(other, "Age")
	if ok {
		t.Errorf("LeftJoinByField() ok = true, want false for a field missing in s")
	}
	if !reflect.DeepEqual(got, s) {
		t.Errorf("LeftJoinByField() = %v, want the unchanged csv %v", got, s)
	}
}

func TestJoinByFieldRaggedRows(t *testing.T) {
	s := SimpleCsv{
		{"ID", "Name"},
		{},                    // join value treated as ""
		{"1"},                 // Name missing
		{"2", "Bob", "extra"}, // cell beyond the header width
	}
	other := SimpleCsv{
		{"ID", "Age"},
		{"", "99"}, // matches the empty join value
		{"1"},      // Age missing
		{"2", "7"},
	}

	joined, ok := s.JoinByField(other, "ID")
	if !ok {
		t.Fatalf("JoinByField() ok = false, want true")
	}
	want := SimpleCsv{
		{"ID", "Name", "Age"},
		{"", "", "99"},
		{"1", "", ""},
		{"2", "Bob", "7"},
	}
	if !reflect.DeepEqual(joined, want) {
		t.Errorf("JoinByField() = %v, want %v", joined, want)
	}
}

func TestJoinByFieldCaseMatters(t *testing.T) {
	s := SimpleCsv{{"ID", "Name"}, {"ana", "Ana"}}
	other := SimpleCsv{{"ID", "Age"}, {"ANA", "30"}}

	joined, ok := s.JoinByField(other, "ID")
	if !ok {
		t.Fatalf("JoinByField() ok = false, want true")
	}
	want := SimpleCsv{{"ID", "Name", "Age"}}
	if !reflect.DeepEqual(joined, want) {
		t.Errorf("JoinByField() = %v, want only the headers %v", joined, want)
	}
}

func TestJoinByFieldHeaderCollision(t *testing.T) {
	s := SimpleCsv{{"ID", "Name"}, {"1", "Ana"}}
	other := SimpleCsv{{"ID", "Name"}, {"1", "Ana Again"}}
	want := SimpleCsv{{"ID", "Name"}, {"1", "Ana"}}

	joined, ok := s.JoinByField(other, "ID")
	if ok {
		t.Fatalf("JoinByField() ok = true, want false for colliding non-join headers")
	}
	if !reflect.DeepEqual(joined, want) {
		t.Errorf("JoinByField() = %v, want unchanged %v", joined, want)
	}
	joined[0][0] = "CHANGED"
	if s[0][0] != "ID" {
		t.Errorf("mutating failed join result changed source: %v", s)
	}

	_, ok = s.LeftJoinByField(other, "ID")
	if ok {
		t.Fatalf("LeftJoinByField() ok = true, want false for colliding non-join headers")
	}
}

func TestJoinByFieldSourcesUnchanged(t *testing.T) {
	s := SimpleCsv{{"ID", "Name"}, {"1", "Ana"}}
	other := SimpleCsv{{"ID", "Age"}, {"1", "30"}}
	sCopy := SimpleCsv{{"ID", "Name"}, {"1", "Ana"}}
	otherCopy := SimpleCsv{{"ID", "Age"}, {"1", "30"}}

	joined, ok := s.JoinByField(other, "ID")
	if !ok {
		t.Fatalf("JoinByField() ok = false, want true")
	}
	if !reflect.DeepEqual(s, sCopy) {
		t.Errorf("JoinByField() modified the source csv: %v", s)
	}
	if !reflect.DeepEqual(other, otherCopy) {
		t.Errorf("JoinByField() modified the other csv: %v", other)
	}

	// mutating the result must not change the sources
	joined[0][0] = "CHANGED"
	joined[1][0] = "CHANGED"
	joined[1][2] = "CHANGED"
	if !reflect.DeepEqual(s, sCopy) {
		t.Errorf("mutating the join result changed the source csv: %v", s)
	}
	if !reflect.DeepEqual(other, otherCopy) {
		t.Errorf("mutating the join result changed the other csv: %v", other)
	}
}

func TestSimpleCsv_Join(t *testing.T) {
	type args struct {
		other      SimpleCsv
		leftField  string
		rightField string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{
			name: "JoinDifferentKeyNames",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
				{"2", "Bob"},
				{"3", "Cid"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"1", "30"},
					{"2", "7"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"1", "Ana", "30"},
				{"2", "Bob", "7"},
			},
			want1: true,
		},
		{
			name: "JoinRightKeyColumnDropped",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"CustomerID", "City", "Region"},
					{"1", "Lisbon", "West"},
				},
				leftField:  "ID",
				rightField: "CustomerID",
			},
			want: SimpleCsv{
				{"ID", "Name", "City", "Region"},
				{"1", "Ana", "Lisbon", "West"},
			},
			want1: true,
		},
		{
			name: "JoinNoMatchKeepsHeadersOnly",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
				{"2", "Bob"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"9", "30"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
			},
			want1: true,
		},
		{
			name: "JoinDuplicateValuesCartesian",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
				{"1", "Ann"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "City"},
					{"1", "Lisbon"},
					{"1", "Madrid"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "City"},
				{"1", "Ana", "Lisbon"},
				{"1", "Ana", "Madrid"},
				{"1", "Ann", "Lisbon"},
				{"1", "Ann", "Madrid"},
			},
			want1: true,
		},
		{
			name: "JoinCaseMatters",
			s: SimpleCsv{
				{"ID", "Name"},
				{"ana", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"ANA", "30"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
			},
			want1: true,
		},
		{
			name: "JoinMissingLeftField",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"1", "30"},
				},
				leftField:  "NoField",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
		{
			name: "JoinMissingRightField",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"1", "30"},
				},
				leftField:  "ID",
				rightField: "NoField",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
		{
			name: "JoinHeaderCollision",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Name"},
					{"1", "Ana Again"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
		{
			name: "JoinRaggedRows",
			s: SimpleCsv{
				{"ID", "Name"},
				{},
				{"2", "Bob"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"", "99"},
					{"2"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"", "", "99"},
				{"2", "Bob", ""},
			},
			want1: true,
		},
		{
			name:  "JoinEmptyReceiver",
			s:     SimpleCsv{},
			args:  args{other: SimpleCsv{{"ID", "Age"}, {"1", "30"}}, leftField: "ID", rightField: "ID"},
			want:  SimpleCsv{},
			want1: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.Join(tt.args.other, tt.args.leftField, tt.args.rightField)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.Join() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.Join() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_LeftJoin(t *testing.T) {
	type args struct {
		other      SimpleCsv
		leftField  string
		rightField string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{
			name: "LeftJoinDifferentKeyNames",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
				{"2", "Bob"},
				{"3", "Cid"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"1", "30"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"1", "Ana", "30"},
				{"2", "Bob", ""},
				{"3", "Cid", ""},
			},
			want1: true,
		},
		{
			name: "LeftJoinHeaderOnlyOther",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"1", "Ana", ""},
			},
			want1: true,
		},
		{
			name: "LeftJoinMissingRightField",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"1", "30"},
				},
				leftField:  "ID",
				rightField: "NoField",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
		{
			name: "LeftJoinHeaderCollision",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Name"},
					{"1", "Ana Again"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.LeftJoin(tt.args.other, tt.args.leftField, tt.args.rightField)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.LeftJoin() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.LeftJoin() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestJoinSameNamesEquivalentToJoinByField(t *testing.T) {
	s := SimpleCsv{
		{"ID", "Name"},
		{"1", "Ana"},
		{"2", "Bob"},
		{"3", "Cid"},
	}
	other := SimpleCsv{
		{"ID", "Age"},
		{"1", "30"},
		{"3", "40"},
	}

	viaJoin, okJoin := s.Join(other, "ID", "ID")
	viaJoinByField, okByField := s.JoinByField(other, "ID")
	if !okJoin || !okByField {
		t.Fatalf("Join/JoinByField ok = %v/%v, want true/true", okJoin, okByField)
	}
	if !reflect.DeepEqual(viaJoin, viaJoinByField) {
		t.Errorf("Join() = %v, want equal to JoinByField() = %v", viaJoin, viaJoinByField)
	}

	viaLeft, okLeft := s.LeftJoin(other, "ID", "ID")
	viaLeftByField, okLeftByField := s.LeftJoinByField(other, "ID")
	if !okLeft || !okLeftByField {
		t.Fatalf("LeftJoin/LeftJoinByField ok = %v/%v, want true/true", okLeft, okLeftByField)
	}
	if !reflect.DeepEqual(viaLeft, viaLeftByField) {
		t.Errorf("LeftJoin() = %v, want equal to LeftJoinByField() = %v", viaLeft, viaLeftByField)
	}
}

func TestJoinSourcesUnchanged(t *testing.T) {
	s := SimpleCsv{{"ID", "Name"}, {"1", "Ana"}}
	other := SimpleCsv{{"PersonID", "Age"}, {"1", "30"}}
	sCopy := SimpleCsv{{"ID", "Name"}, {"1", "Ana"}}
	otherCopy := SimpleCsv{{"PersonID", "Age"}, {"1", "30"}}

	joined, ok := s.Join(other, "ID", "PersonID")
	if !ok {
		t.Fatalf("Join() ok = false, want true")
	}
	if !reflect.DeepEqual(s, sCopy) {
		t.Errorf("Join() modified the source csv: %v", s)
	}
	if !reflect.DeepEqual(other, otherCopy) {
		t.Errorf("Join() modified the other csv: %v", other)
	}

	// mutating the result must not change the sources
	joined[0][0] = "CHANGED"
	joined[1][0] = "CHANGED"
	joined[1][2] = "CHANGED"
	if !reflect.DeepEqual(s, sCopy) {
		t.Errorf("mutating the join result changed the source csv: %v", s)
	}
	if !reflect.DeepEqual(other, otherCopy) {
		t.Errorf("mutating the join result changed the other csv: %v", other)
	}

	failed, ok := s.Join(other, "NoField", "PersonID")
	if ok {
		t.Fatalf("Join() ok = true, want false for a missing field")
	}
	if !reflect.DeepEqual(failed, sCopy) {
		t.Errorf("Join() = %v, want the unchanged csv %v", failed, sCopy)
	}
	failed[0][0] = "CHANGED"
	if !reflect.DeepEqual(s, sCopy) {
		t.Errorf("mutating failed Join result changed source: %v", s)
	}
}

func TestSimpleCsv_RightJoin(t *testing.T) {
	type args struct {
		other      SimpleCsv
		leftField  string
		rightField string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{
			name: "RightJoinKeepsAllRightRows",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
				{"2", "Bob"},
				{"3", "Cid"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"2", "7"},
					{"4", "40"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"2", "Bob", "7"},
				{"", "", "40"},
			},
			want1: true,
		},
		{
			name: "RightJoinNoLeftMatches",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"2", "7"},
					{"3", "30"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"", "", "7"},
				{"", "", "30"},
			},
			want1: true,
		},
		{
			name: "RightJoinDuplicateValues",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
				{"1", "Ann"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "City"},
					{"1", "Lisbon"},
					{"1", "Madrid"},
					{"2", "Porto"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "City"},
				{"1", "Ana", "Lisbon"},
				{"1", "Ana", "Madrid"},
				{"1", "Ann", "Lisbon"},
				{"1", "Ann", "Madrid"},
				{"", "", "Porto"},
			},
			want1: true,
		},
		{
			name: "RightJoinHeaderOnlyLeft",
			s: SimpleCsv{
				{"ID", "Name"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"2", "7"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"", "", "7"},
			},
			want1: true,
		},
		{
			name: "RightJoinHeaderOnlyOther",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
			},
			want1: true,
		},
		{
			name: "RightJoinCaseMatters",
			s: SimpleCsv{
				{"ID", "Name"},
				{"ana", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"ANA", "30"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"", "", "30"},
			},
			want1: true,
		},
		{
			name: "RightJoinRaggedRows",
			s: SimpleCsv{
				{"ID", "Name"},
				{},
				{"2", "Bob"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"", "99"},
					{"3", "30"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"", "", "99"},
				{"", "", "30"},
			},
			want1: true,
		},
		{
			name: "RightJoinMissingLeftField",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"1", "30"},
				},
				leftField:  "NoField",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
		{
			name: "RightJoinMissingRightField",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"1", "30"},
				},
				leftField:  "ID",
				rightField: "NoField",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
		{
			name: "RightJoinHeaderCollision",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Name"},
					{"1", "Ana Again"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
		{
			name:  "RightJoinEmptyReceiver",
			s:     SimpleCsv{},
			args:  args{other: SimpleCsv{{"ID", "Age"}, {"1", "30"}}, leftField: "ID", rightField: "ID"},
			want:  SimpleCsv{},
			want1: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.RightJoin(tt.args.other, tt.args.leftField, tt.args.rightField)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.RightJoin() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.RightJoin() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_FullJoin(t *testing.T) {
	type args struct {
		other      SimpleCsv
		leftField  string
		rightField string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{
			name: "FullJoinMixed",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
				{"2", "Bob"},
				{"3", "Cid"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"2", "7"},
					{"4", "40"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"1", "Ana", ""},
				{"2", "Bob", "7"},
				{"3", "Cid", ""},
				{"", "", "40"},
			},
			want1: true,
		},
		{
			name: "FullJoinDuplicateValues",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
				{"1", "Ann"},
				{"2", "Bob"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "City"},
					{"1", "Lisbon"},
					{"1", "Madrid"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "City"},
				{"1", "Ana", "Lisbon"},
				{"1", "Ana", "Madrid"},
				{"1", "Ann", "Lisbon"},
				{"1", "Ann", "Madrid"},
				{"2", "Bob", ""},
			},
			want1: true,
		},
		{
			name: "FullJoinHeaderOnlyOther",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"1", "Ana", ""},
			},
			want1: true,
		},
		{
			name: "FullJoinHeaderOnlyReceiver",
			s: SimpleCsv{
				{"ID", "Name"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"2", "7"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"", "", "7"},
			},
			want1: true,
		},
		{
			name: "FullJoinCaseMatters",
			s: SimpleCsv{
				{"ID", "Name"},
				{"ana", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"ANA", "30"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name", "Age"},
				{"ana", "Ana", ""},
				{"", "", "30"},
			},
			want1: true,
		},
		{
			name: "FullJoinMissingLeftField",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"1", "30"},
				},
				leftField:  "NoField",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
		{
			name: "FullJoinMissingRightField",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Age"},
					{"1", "30"},
				},
				leftField:  "ID",
				rightField: "NoField",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
		{
			name: "FullJoinHeaderCollision",
			s: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			args: args{
				other: SimpleCsv{
					{"PersonID", "Name"},
					{"1", "Ana Again"},
				},
				leftField:  "ID",
				rightField: "PersonID",
			},
			want: SimpleCsv{
				{"ID", "Name"},
				{"1", "Ana"},
			},
			want1: false,
		},
		{
			name:  "FullJoinEmptyReceiver",
			s:     SimpleCsv{},
			args:  args{other: SimpleCsv{{"ID", "Age"}, {"1", "30"}}, leftField: "ID", rightField: "ID"},
			want:  SimpleCsv{},
			want1: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.FullJoin(tt.args.other, tt.args.leftField, tt.args.rightField)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.FullJoin() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.FullJoin() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestJoinByFieldAliasesEquivalent(t *testing.T) {
	s := SimpleCsv{
		{"ID", "Name"},
		{"1", "Ana"},
		{"2", "Bob"},
		{"3", "Cid"},
	}
	other := SimpleCsv{
		{"ID", "Age"},
		{"2", "7"},
		{"4", "40"},
	}

	viaRight, okRight := s.RightJoin(other, "ID", "ID")
	viaRightByField, okRightByField := s.RightJoinByField(other, "ID")
	if !okRight || !okRightByField {
		t.Fatalf("RightJoin/RightJoinByField ok = %v/%v, want true/true", okRight, okRightByField)
	}
	if !reflect.DeepEqual(viaRight, viaRightByField) {
		t.Errorf("RightJoin() = %v, want equal to RightJoinByField() = %v", viaRight, viaRightByField)
	}

	viaFull, okFull := s.FullJoin(other, "ID", "ID")
	viaFullByField, okFullByField := s.FullJoinByField(other, "ID")
	if !okFull || !okFullByField {
		t.Fatalf("FullJoin/FullJoinByField ok = %v/%v, want true/true", okFull, okFullByField)
	}
	if !reflect.DeepEqual(viaFull, viaFullByField) {
		t.Errorf("FullJoin() = %v, want equal to FullJoinByField() = %v", viaFull, viaFullByField)
	}
}

func TestRightJoinSourcesUnchanged(t *testing.T) {
	s := SimpleCsv{{"ID", "Name"}, {"1", "Ana"}}
	other := SimpleCsv{{"PersonID", "Age"}, {"1", "30"}, {"2", "40"}}
	sCopy := SimpleCsv{{"ID", "Name"}, {"1", "Ana"}}
	otherCopy := SimpleCsv{{"PersonID", "Age"}, {"1", "30"}, {"2", "40"}}

	joined, ok := s.RightJoin(other, "ID", "PersonID")
	if !ok {
		t.Fatalf("RightJoin() ok = false, want true")
	}
	if !reflect.DeepEqual(s, sCopy) {
		t.Errorf("RightJoin() modified the source csv: %v", s)
	}
	if !reflect.DeepEqual(other, otherCopy) {
		t.Errorf("RightJoin() modified the other csv: %v", other)
	}

	// mutating the result must not change the sources
	joined[0][0] = "CHANGED"
	joined[1][0] = "CHANGED"
	joined[1][2] = "CHANGED"
	if !reflect.DeepEqual(s, sCopy) {
		t.Errorf("mutating the right join result changed the source csv: %v", s)
	}
	if !reflect.DeepEqual(other, otherCopy) {
		t.Errorf("mutating the right join result changed the other csv: %v", other)
	}

	full, ok := s.FullJoin(other, "ID", "PersonID")
	if !ok {
		t.Fatalf("FullJoin() ok = false, want true")
	}
	full[0][0] = "CHANGED"
	full[2][0] = "CHANGED"
	full[2][2] = "CHANGED"
	if !reflect.DeepEqual(s, sCopy) {
		t.Errorf("mutating the full join result changed the source csv: %v", s)
	}
	if !reflect.DeepEqual(other, otherCopy) {
		t.Errorf("mutating the full join result changed the other csv: %v", other)
	}

	failed, ok := s.RightJoin(other, "NoField", "PersonID")
	if ok {
		t.Fatalf("RightJoin() ok = true, want false for a missing field")
	}
	if !reflect.DeepEqual(failed, sCopy) {
		t.Errorf("RightJoin() = %v, want the unchanged csv %v", failed, sCopy)
	}
	failed[0][0] = "CHANGED"
	if !reflect.DeepEqual(s, sCopy) {
		t.Errorf("mutating failed RightJoin result changed source: %v", s)
	}
}