github.com/XML-Comp/XML-Comp@v0.0.42-0.20180719122048-292fe466b944/comparer/comparer_test.go

package comparer

import (
	"bufio"
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"testing"
)

var wd, _ = os.Getwd()

func TestCompareFolder(t *testing.T) {
	tests := []struct {
		name    string
		PathA   string
		PathB   string
		wantErr bool
	}{
		{
			name:    "no dir",
			PathA:   "fakeDir1",
			PathB:   "fakeDir2",
			wantErr: true,
		},
		{
			name:    "valid paths",
			PathA:   filepath.Join(wd, "testPaths", "Original"),
			PathB:   filepath.Join(wd, "testPaths", "Translation"),
			wantErr: false,
		},
		{
			name:    "valid Dirs should add new dirs",
			PathA:   filepath.Join(wd, "testPaths", "English"),
			PathB:   filepath.Join(wd, "testPaths", "Translation"),
			wantErr: false,
		},
	}
	for _, test := range tests {
		err := Compare(test.PathA, test.PathB)
		if (err != nil) != test.wantErr {
			t.Errorf("Compare() error = %v, want error %v", err, test.wantErr)
		}
	}
	defer os.Remove(filepath.Join(wd, "testPaths", "Translation", "Dir1"))
	defer os.Remove(filepath.Join(wd, "testPaths", "Translation", "dir"))
}

func TestReadFile(t *testing.T) {
	DocType = "xml"
	type args struct {
		file string
		path string
	}
	tests := []struct {
		name    string
		args    args
		want    map[string]string
		wantErr bool
	}{
		{
			name: "read file",
			args: args{
				file: "File01.xml",
				path: filepath.Join(wd, "testPaths", "Original"),
			},
			want:    map[string]string{"<linha1>": "TEste", "<linha2>": "teste", "<linha3>": "teste"},
			wantErr: false,
		},
		{
			name: "cant read invalid file",
			args: args{
				file: "inexistant.xml",
				path: filepath.Join(wd, "testPaths", "Original"),
			},
			wantErr: true,
		},
		{
			name:    "cant read empty file name/path",
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := readFile(tt.args.file, tt.args.path)
			if (err != nil) != tt.wantErr {
				t.Errorf("readFile() error = %v, wantErr %v", err, tt.wantErr)
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("readFile() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestFindMissing(t *testing.T) {
	type args struct {
		original    map[string]string
		translation map[string]string
	}
	tests := []struct {
		name string
		args args
		want map[string]string
	}{
		{
			name: "find missing Tags",
			args: args{
				original:    map[string]string{"<linha 1>": "", "<linha 2>": "", "<linha 3>": "teste"},
				translation: map[string]string{"<linha 1>": "", "<linha 2>": ""},
			},
			want: map[string]string{"<linha 3>": "teste"},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := findMissing(tt.args.original, tt.args.translation); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("findMissing() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestReadFiles(t *testing.T) {
	tests := []struct {
		name    string
		orgF    string
		trltF   string
		wantErr bool
	}{
		{
			name:    "testing equal files",
			orgF:    filepath.Join("testPaths", "Original", "File01.xml"),
			trltF:   filepath.Join("testPaths", "Translation", "File01.xml"),
			wantErr: false,
		},
		{
			name:    "testing no such original file",
			orgF:    filepath.Join("testPaths", "Original", "invalid.xml"),
			wantErr: true,
		},
		{
			name:    "invalid translation path",
			orgF:    filepath.Join("xayah", "fake"),
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := readFiles(filepath.Join(wd, tt.orgF), filepath.Join(wd, tt.trltF)); (err != nil) != tt.wantErr {
				t.Errorf("name: %s\nreadFiles() error = %v, wantErr %v", tt.name, err, tt.wantErr)
			}
		})
	}
}

func TestReadFilesWithOutdatedTags(t *testing.T) {
	tests := []struct {
		name    string
		orgF    string
		trltF   string
		wantErr bool
	}{
		{
			name:    "testing equal files",
			orgF:    filepath.Join("testPaths", "Original", "File03.xml"),
			trltF:   filepath.Join("testPaths", "Translation", "File03.xml"),
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := readFiles(filepath.Join(wd, tt.orgF), filepath.Join(wd, tt.trltF)); (err != nil) != tt.wantErr {
				t.Errorf("readFiles() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
	f, err := os.Open(filepath.Join(wd, tests[0].trltF))
	if err != nil {
		t.Error(err)
	}
	defer f.Close()
	scanner := bufio.NewScanner(f)
	var outdated bool
	for scanner.Scan() {
		if strings.Contains(scanner.Text(), "OUTDATED") {
			outdated = true
		}
	}
	if !outdated {
		t.Error("File File03.xml should have a outdated tag")
	}
	err = ioutil.WriteFile(filepath.Join(wd, "testPaths", "Translation", "File03.xml"), []byte("<linha4></linha4>"), 0644)
	if err != nil {
		t.Error(err)
	}
}

func TestCheckTransDir(t *testing.T) {
	os.Chdir("..")
	wd, _ := os.Getwd()
	tests := []struct {
		name           string
		originalDir    string
		translationDir string
		wantErr        bool
	}{
		{
			name:           "test translation has no dir1",
			originalDir:    filepath.Join(wd, "English", "Dir1"),
			translationDir: filepath.Join(wd, "Translation"),
			wantErr:        false,
		},
		// local: shows no err
		// had to remove this, bc it should return nil
		// but on CI when it calls os.Open(...), somehow it
		// shows an error of "no such file or directory"
		// and tests return another after that: (on mkdir call)
		// "checkTransDir() error = mkdir Dir1: file exists, wantErr false"
		// {
		// 	name:           "test same name dirs should pass",
		// 	originalDir:    filepath.Join(wd, "English", "Dir1"),
		// 	translationDir: filepath.Join(wd, "English"),
		// 	wantErr:        true,
		// },
		{
			name:           "test fake dirs should err",
			originalDir:    filepath.Join(wd, "English", "Dir1"),
			translationDir: filepath.Join(wd, "kai'sa"),
			wantErr:        true,
		},
	}
	for _, tt := range tests {
		if err := checkTransDirExists(tt.originalDir, tt.translationDir); (err != nil) != tt.wantErr {
			t.Errorf("\nname: %s\ndir: %s\ncheckTransDir() error = %v, wantErr %v", tt.name, tt.translationDir, err, tt.wantErr)
		}
	}
	err := os.Remove(filepath.Join(wd, "Translation", "Dir1"))
	if err != nil {
		t.Errorf("Error = %v", err)
	}
}

func Test_writeToFileMissingTags(t *testing.T) {
	type args struct {
		trltF       string
		missingTags map[string]string
		outdated    bool
	}
	f, err := ioutil.TempFile("", "")
	if err != nil {
		t.Error(err)
	}
	defer os.Remove(f.Name())
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "cant open invalid translation file",
			args: args{
				trltF: filepath.Join("testPaths", "Translation", "garen.txt"),
			},
			wantErr: true,
		},
		{
			name: "writes correctly tags and ignores if it's a commentary or doctype description",
			args: args{
				trltF: f.Name(),
				missingTags: map[string]string{
					fmt.Sprintf("<%v", pathSep): "",
					"<!-":       "",
					"<ezreal>":  "",
					"<minerva>": "",
					"<robo>":    "",
				},
			},
			wantErr: false,
		},
		{
			name: "should pass on empty element in map",
			args: args{
				trltF:       f.Name(),
				missingTags: map[string]string{"": ""},
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err = writeToFileMissingTags(tt.args.trltF, tt.args.missingTags, tt.args.outdated); (err != nil) != tt.wantErr {
				t.Errorf("name: %s\n writeToFileMissingTags() error = %v, wantErr %v", tt.name, err, tt.wantErr)
			}
			err = ioutil.WriteFile(f.Name(), []byte(""), 0644)
			if err != nil {
				t.Error(err)
			}
		})
	}
}

func Test_ReadFiles(t *testing.T) {
	tests := []struct {
		name    string
		orgF    string
		trltF   string
		wantErr bool
	}{
		{
			name:    "test inexistant translation file",
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := readFiles(tt.orgF, tt.trltF); (err != nil) != tt.wantErr {
				t.Errorf("readFiles() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}