split_test.go

package simplecsv

import (
	"reflect"
	"testing"
)

func TestSimpleCsv_SplitField(t *testing.T) {
	type args struct {
		name     string
		sep      string
		newNames []string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{
			name: "SplitFieldInMiddle",
			want: SimpleCsv{
				{"id", "lat", "lon", "city"},
				{"1", "40.1", "-3.2", "Madrid"},
				{"2", "41.3", "2.1", "Barcelona"},
			},
			want1: true,
			s: SimpleCsv{
				{"id", "coord", "city"},
				{"1", "40.1,-3.2", "Madrid"},
				{"2", "41.3,2.1", "Barcelona"},
			},
			args: args{name: "coord", sep: ",", newNames: []string{"lat", "lon"}},
		},
		{
			name: "SplitFieldPadShortCells",
			want: SimpleCsv{
				{"last", "first", "city"},
				{"Lopez", "Ana", "Madrid"},
				{"Smith", "", "London"},
			},
			want1: true,
			s: SimpleCsv{
				{"last;first", "city"},
				{"Lopez;Ana", "Madrid"},
				{"Smith", "London"},
			},
			args: args{name: "last;first", sep: ";", newNames: []string{"last", "first"}},
		},
		{
			name: "SplitFieldTruncateExtraParts",
			want: SimpleCsv{
				{"a", "b", "c"},
				{"1", "2", "3"},
			},
			want1: true,
			s: SimpleCsv{
				{"full"},
				{"1,2,3,4,5"},
			},
			args: args{name: "full", sep: ",", newNames: []string{"a", "b", "c"}},
		},
		{
			name: "SplitFieldAtStart",
			want: SimpleCsv{
				{"lat", "lon", "city"},
				{"40.1", "-3.2", "Madrid"},
			},
			want1: true,
			s: SimpleCsv{
				{"coord", "city"},
				{"40.1,-3.2", "Madrid"},
			},
			args: args{name: "coord", sep: ",", newNames: []string{"lat", "lon"}},
		},
		{
			name: "SplitFieldAtEnd",
			want: SimpleCsv{
				{"city", "lat", "lon"},
				{"Madrid", "40.1", "-3.2"},
			},
			want1: true,
			s: SimpleCsv{
				{"city", "coord"},
				{"Madrid", "40.1,-3.2"},
			},
			args: args{name: "coord", sep: ",", newNames: []string{"lat", "lon"}},
		},
		{
			name: "SplitFieldNewNameReusesOriginal",
			want: SimpleCsv{
				{"full", "extra"},
				{"a", "b"},
			},
			want1: true,
			s: SimpleCsv{
				{"full"},
				{"a,b"},
			},
			args: args{name: "full", sep: ",", newNames: []string{"full", "extra"}},
		},
		{
			name: "SplitFieldHeaderOnly",
			want: SimpleCsv{
				{"lat", "lon"},
			},
			want1: true,
			s: SimpleCsv{
				{"coord"},
			},
			args: args{name: "coord", sep: ",", newNames: []string{"lat", "lon"}},
		},
		{
			name:  "SplitFieldEmptyCsv",
			want:  SimpleCsv{},
			s:     SimpleCsv{},
			args:  args{name: "coord", sep: ",", newNames: []string{"lat", "lon"}},
			want1: false,
		},
		{
			name: "SplitFieldMissingName",
			want: SimpleCsv{
				{"coord"},
				{"1,2"},
			},
			want1: false,
			s: SimpleCsv{
				{"coord"},
				{"1,2"},
			},
			args: args{name: "no", sep: ",", newNames: []string{"lat", "lon"}},
		},
		{
			name: "SplitFieldEmptyNewNames",
			want: SimpleCsv{
				{"coord"},
				{"1,2"},
			},
			want1: false,
			s: SimpleCsv{
				{"coord"},
				{"1,2"},
			},
			args: args{name: "coord", sep: ",", newNames: []string{}},
		},
		{
			name: "SplitFieldDuplicateNewNames",
			want: SimpleCsv{
				{"coord"},
				{"1,2"},
			},
			want1: false,
			s: SimpleCsv{
				{"coord"},
				{"1,2"},
			},
			args: args{name: "coord", sep: ",", newNames: []string{"lat", "lat"}},
		},
		{
			name: "SplitFieldNewNameCollidesWithOtherHeader",
			want: SimpleCsv{
				{"city", "coord"},
				{"Madrid", "1,2"},
			},
			want1: false,
			s: SimpleCsv{
				{"city", "coord"},
				{"Madrid", "1,2"},
			},
			args: args{name: "coord", sep: ",", newNames: []string{"city", "lon"}},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.SplitField(tt.args.name, tt.args.sep, tt.args.newNames)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.SplitField() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.SplitField() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_CombineFields(t *testing.T) {
	type args struct {
		names []string
		sep   string
		as    string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{
			name: "CombineFieldsTwoSources",
			want: SimpleCsv{
				{"first", "last", "full_name"},
				{"Ana", "Lopez", "Ana Lopez"},
				{"Bob", "Smith", "Bob Smith"},
			},
			want1: true,
			s: SimpleCsv{
				{"first", "last"},
				{"Ana", "Lopez"},
				{"Bob", "Smith"},
			},
			args: args{names: []string{"first", "last"}, sep: " ", as: "full_name"},
		},
		{
			name: "CombineFieldsKeepsSources",
			want: SimpleCsv{
				{"country", "sku", "country_sku"},
				{"es", "A1", "es-A1"},
				{"fr", "B2", "fr-B2"},
			},
			want1: true,
			s: SimpleCsv{
				{"country", "sku"},
				{"es", "A1"},
				{"fr", "B2"},
			},
			args: args{names: []string{"country", "sku"}, sep: "-", as: "country_sku"},
		},
		{
			name: "CombineFieldsSingleSource",
			want: SimpleCsv{
				{"id", "copy"},
				{"7", "7"},
			},
			want1: true,
			s: SimpleCsv{
				{"id"},
				{"7"},
			},
			args: args{names: []string{"id"}, sep: "-", as: "copy"},
		},
		{
			name: "CombineFieldsEmptyCells",
			want: SimpleCsv{
				{"first", "last", "full_name"},
				{"Ana", "", "Ana-"},
				{"", "Lopez", "-Lopez"},
			},
			want1: true,
			s: SimpleCsv{
				{"first", "last"},
				{"Ana", ""},
				{"", "Lopez"},
			},
			args: args{names: []string{"first", "last"}, sep: "-", as: "full_name"},
		},
		{
			name: "CombineFieldsHeaderOnly",
			want: SimpleCsv{
				{"first", "last", "full_name"},
			},
			want1: true,
			s: SimpleCsv{
				{"first", "last"},
			},
			args: args{names: []string{"first", "last"}, sep: " ", as: "full_name"},
		},
		{
			name:  "CombineFieldsEmptyCsv",
			want:  SimpleCsv{},
			s:     SimpleCsv{},
			args:  args{names: []string{"first", "last"}, sep: " ", as: "full_name"},
			want1: false,
		},
		{
			name: "CombineFieldsEmptyNames",
			want: SimpleCsv{
				{"first", "last"},
				{"Ana", "Lopez"},
			},
			want1: false,
			s: SimpleCsv{
				{"first", "last"},
				{"Ana", "Lopez"},
			},
			args: args{names: []string{}, sep: " ", as: "full_name"},
		},
		{
			name: "CombineFieldsMissingName",
			want: SimpleCsv{
				{"first", "last"},
				{"Ana", "Lopez"},
			},
			want1: false,
			s: SimpleCsv{
				{"first", "last"},
				{"Ana", "Lopez"},
			},
			args: args{names: []string{"first", "no"}, sep: " ", as: "full_name"},
		},
		{
			name: "CombineFieldsDuplicateNames",
			want: SimpleCsv{
				{"first", "last"},
				{"Ana", "Lopez"},
			},
			want1: false,
			s: SimpleCsv{
				{"first", "last"},
				{"Ana", "Lopez"},
			},
			args: args{names: []string{"first", "first"}, sep: " ", as: "full_name"},
		},
		{
			name: "CombineFieldsDuplicateAs",
			want: SimpleCsv{
				{"first", "last"},
				{"Ana", "Lopez"},
			},
			want1: false,
			s: SimpleCsv{
				{"first", "last"},
				{"Ana", "Lopez"},
			},
			args: args{names: []string{"first", "last"}, sep: " ", as: "first"},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.CombineFields(tt.args.names, tt.args.sep, tt.args.as)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.CombineFields() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.CombineFields() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

// The original csv is not modified, the results share no data with it, and
// the failure paths return an independent copy.

func TestSplitOpsResultsAreIndependent(t *testing.T) {
	want := SimpleCsv{
		{"id", "coord", "city"},
		{"1", "40.1,-3.2", "Madrid"},
		{"2", "41.3,2.1", "Barcelona"},
	}
	s := SimpleCsv{
		{"id", "coord", "city"},
		{"1", "40.1,-3.2", "Madrid"},
		{"2", "41.3,2.1", "Barcelona"},
	}

	got, ok := s.SplitField("coord", ",", []string{"lat", "lon"})
	if !ok {
		t.Fatalf("SplitField() ok = false, want true")
	}
	got[0][0] = "CHANGED"
	got[1][0] = "CHANGED"
	got[1][2] = "CHANGED"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating SplitField result changed source: %v", s)
	}

	got, ok = s.CombineFields([]string{"id", "city"}, " ", "id_city")
	if !ok {
		t.Fatalf("CombineFields() ok = false, want true")
	}
	got[0][0] = "CHANGED"
	got[1][0] = "CHANGED"
	got[1][3] = "CHANGED"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating CombineFields result changed source: %v", s)
	}

	failed, ok := s.SplitField("no", ",", []string{"lat", "lon"})
	if ok || !reflect.DeepEqual(failed, want) {
		t.Fatalf("SplitField() = %v, %v, want unchanged copy, false", failed, ok)
	}
	failed[0][0] = "CHANGED"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating failed SplitField result changed source: %v", s)
	}

	failed, ok = s.CombineFields([]string{"no"}, " ", "x")
	if ok || !reflect.DeepEqual(failed, want) {
		t.Fatalf("CombineFields() = %v, %v, want unchanged copy, false", failed, ok)
	}
	failed[0][0] = "CHANGED"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating failed CombineFields result changed source: %v", s)
	}
}