transform_test.go

package simplecsv

import (
	"reflect"
	"testing"
)

func TestSimpleCsv_ReplaceInField(t *testing.T) {
	type args struct {
		columnName string
		old        string
		new        string
	}
	tests := []struct {
		name  string
		s     SimpleCsv
		args  args
		want  SimpleCsv
		want1 bool
	}{
		{
			name: "ReplaceInField1",
			want: SimpleCsv{
				{"Name", "Status"},
				{"Ana", ""},
				{"Bob", "ok"},
				{"Cid", ""},
			},
			want1: true,
			s: SimpleCsv{
				{"Name", "Status"},
				{"Ana", "N/A"},
				{"Bob", "ok"},
				{"Cid", "N/A"},
			},
			args: args{columnName: "Status", old: "N/A", new: ""},
		},
		{
			name: "ReplaceInFieldNoMatch",
			want: SimpleCsv{
				{"Name", "Status"},
				{"Ana", "ok"},
				{"Bob", "ok"},
			},
			want1: true,
			s: SimpleCsv{
				{"Name", "Status"},
				{"Ana", "ok"},
				{"Bob", "ok"},
			},
			args: args{columnName: "Status", old: "N/A", new: ""},
		},
		{
			name: "ReplaceInFieldCaseSensitive",
			want: SimpleCsv{
				{"Name", "Status"},
				{"Ana", "n/a"},
			},
			want1: true,
			s: SimpleCsv{
				{"Name", "Status"},
				{"Ana", "n/a"},
			},
			args: args{columnName: "Status", old: "N/A", new: ""},
		},
		{
			name: "ReplaceInFieldWholeCellOnly",
			want: SimpleCsv{
				{"Name", "Code"},
				{"Ana", "AB"},
				{"Bob", "B"},
			},
			want1: true,
			s: SimpleCsv{
				{"Name", "Code"},
				{"Ana", "AB"},
				{"Bob", "B"},
			},
			args: args{columnName: "Code", old: "A", new: "X"},
		},
		{
			name: "ReplaceInFieldHeaderNotModified",
			want: SimpleCsv{
				{"N/A", "Status"},
				{"Ana", ""},
			},
			want1: true,
			s: SimpleCsv{
				{"N/A", "Status"},
				{"Ana", "N/A"},
			},
			args: args{columnName: "Status", old: "N/A", new: ""},
		},
		{
			name: "ReplaceInFieldMissing",
			want: SimpleCsv{
				{"Name", "Status"},
				{"Ana", "N/A"},
			},
			want1: false,
			s: SimpleCsv{
				{"Name", "Status"},
				{"Ana", "N/A"},
			},
			args: args{columnName: "Book", old: "N/A", new: ""},
		},
		{
			name:  "ReplaceInFieldEmpty",
			want:  SimpleCsv{},
			want1: false,
			s:     SimpleCsv{},
			args:  args{columnName: "Status", old: "N/A", new: ""},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.ReplaceInField(tt.args.columnName, tt.args.old, tt.args.new)
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.ReplaceInField() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.ReplaceInField() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

func TestSimpleCsv_TrimSpace(t *testing.T) {
	tests := []struct {
		name  string
		s     SimpleCsv
		want  SimpleCsv
		want1 bool
	}{
		{
			name: "TrimSpace1",
			want: SimpleCsv{
				{"Name", "Age"},
				{"Ana", "30"},
				{"Bob", "7"},
			},
			want1: true,
			s: SimpleCsv{
				{" Name ", " Age\t"},
				{"\tAna ", " 30"},
				{"Bob\n", "7"},
			},
		},
		{
			name: "TrimSpaceHeaderOnly",
			want: SimpleCsv{
				{"Name", "Age"},
			},
			want1: true,
			s: SimpleCsv{
				{" Name ", " Age "},
			},
		},
		{
			name: "TrimSpaceAlreadyTrimmed",
			want: SimpleCsv{
				{"Name", "Age"},
				{"Ana", "30"},
			},
			want1: true,
			s: SimpleCsv{
				{"Name", "Age"},
				{"Ana", "30"},
			},
		},
		{
			name: "TrimSpaceDuplicateHeaderRejected",
			want: SimpleCsv{
				{" A ", "A"},
				{"1", "2"},
			},
			want1: false,
			s: SimpleCsv{
				{" A ", "A"},
				{"1", "2"},
			},
		},
		{
			name:  "TrimSpaceEmpty",
			want:  SimpleCsv{},
			want1: false,
			s:     SimpleCsv{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, got1 := tt.s.TrimSpace()
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("SimpleCsv.TrimSpace() got = %v, want %v", got, tt.want)
			}
			if got1 != tt.want1 {
				t.Errorf("SimpleCsv.TrimSpace() got1 = %v, want %v", got1, tt.want1)
			}
		})
	}
}

// The original csv is not modified, and a failure path returns an
// independent copy.

func TestTransformOpsDoNotMutateSource(t *testing.T) {
	want := SimpleCsv{
		{" Name ", "Status"},
		{"Ana ", "N/A"},
		{"Bob", " ok "},
	}
	s := SimpleCsv{
		{" Name ", "Status"},
		{"Ana ", "N/A"},
		{"Bob", " ok "},
	}

	got, ok := s.ReplaceInField("Status", "N/A", "")
	if !ok {
		t.Fatalf("ReplaceInField() ok = false, want true")
	}
	if got[1][1] != "" {
		t.Errorf("ReplaceInField() cell = %q, want empty", got[1][1])
	}
	if !reflect.DeepEqual(s, want) {
		t.Errorf("ReplaceInField() modified the original csv: %v", s)
	}
	got[0][0] = "CHANGED"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating ReplaceInField result changed source: %v", s)
	}

	got, ok = s.TrimSpace()
	if !ok {
		t.Fatalf("TrimSpace() ok = false, want true")
	}
	if !reflect.DeepEqual(s, want) {
		t.Errorf("TrimSpace() modified the original csv: %v", s)
	}
	got[0][0] = "CHANGED"
	if !reflect.DeepEqual(s, want) {
		t.Errorf("mutating TrimSpace result changed source: %v", s)
	}

	dup := SimpleCsv{
		{" A ", "A"},
		{"1", "2"},
	}
	dupWant := SimpleCsv{
		{" A ", "A"},
		{"1", "2"},
	}
	failed, ok := dup.TrimSpace()
	if ok || failed[0][0] != " A " {
		t.Fatalf("TrimSpace() = %v, %v, want unchanged copy, false", failed, ok)
	}
	failed[0][0] = "CHANGED"
	if !reflect.DeepEqual(dup, dupWant) {
		t.Errorf("mutating failed TrimSpace result changed source: %v", dup)
	}
}