// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package test

import (
	"encoding/xml"
	"fmt"
	"io/ioutil"
	"os"
	"reflect"
	"testing"

	"v.io/jiri/jiritest"
	"v.io/x/devtools/internal/test"
	"v.io/x/devtools/internal/xunit"
	"v.io/x/devtools/tooldata"
)

func TestProjectTests(t *testing.T) {
	config := tooldata.NewConfig(tooldata.ProjectTestsOpt(map[string][]string{
		"vanadium": []string{"vanadium-go-build", "vanadium-go-test"},
		"default":  []string{"tools-go-build", "tools-go-test"},
	}))

	// Get tests for a project that is in the config file.
	got := config.ProjectTests([]string{"vanadium"})
	expected := []string{
		"vanadium-go-build",
		"vanadium-go-test",
	}
	if !reflect.DeepEqual(expected, got) {
		t.Errorf("want: %v, got: %v", expected, got)
	}

	// Get tests for a project that is NOT in the config file.
	// This should return empty tests.
	got, expected = config.ProjectTests([]string{"non-exist-project"}), nil
	if !reflect.DeepEqual(expected, got) {
		t.Errorf("want: %#v, got: %#v", expected, got)
	}
}

func TestGenXUnitReportForError(t *testing.T) {
	jirix, cleanup := jiritest.NewX(t)
	defer cleanup()

	// Set WORKSPACE to a tmp dir.
	workspaceDir, err := jirix.NewSeq().TempDir("", "")
	if err != nil {
		t.Fatalf("%v", err)
	}
	defer jirix.NewSeq().RemoveAll(workspaceDir)
	oldWorkspaceDir := os.Getenv("WORKSPACE")
	if err := os.Setenv("WORKSPACE", workspaceDir); err != nil {
		t.Fatalf("%v", err)
	}
	defer os.Setenv("WORKSPACE", oldWorkspaceDir)

	expectedGenSuite := xunit.TestSuite{
		Name: "vanadium-go-test",
		Cases: []xunit.TestCase{
			xunit.TestCase{
				Name:      "Init",
				Classname: "vanadium-go-test",
				Failures: []xunit.Failure{
					xunit.Failure{
						Message: "Init",
						Data:    "Error message:\nInit:\nsomething is wrong\n\n\nConsole output:\n......\noutput message\n",
					},
				},
				Time: "0.00",
			},
		},
		Tests:    1,
		Failures: 1,
	}
	aFailedTestSuite := xunit.TestSuite{
		Name: "name1",
		Cases: []xunit.TestCase{
			xunit.TestCase{
				Name:      "test1",
				Classname: "class1",
				Failures: []xunit.Failure{
					xunit.Failure{
						Message: "failure",
						Data:    "test failed",
					},
				},
				Time: "0.10",
			},
		},
		Tests:    1,
		Failures: 1,
	}

	// Tests.
	testCases := []struct {
		createXUnitFile bool
		existingSuites  *xunit.TestSuites
		expectedSuites  *xunit.TestSuites
	}{
		// No xUnit file exists.
		{
			createXUnitFile: false,
			expectedSuites: &xunit.TestSuites{
				Suites: []xunit.TestSuite{expectedGenSuite},
				XMLName: xml.Name{
					Local: "testsuites",
				},
			},
		},
		// xUnit file exists but empty (invalid).
		{
			createXUnitFile: true,
			existingSuites:  &xunit.TestSuites{},
			expectedSuites: &xunit.TestSuites{
				Suites: []xunit.TestSuite{expectedGenSuite},
				XMLName: xml.Name{
					Local: "testsuites",
				},
			},
		},
		// xUnit file exists but doesn't contain failed test cases.
		{
			createXUnitFile: true,
			existingSuites: &xunit.TestSuites{
				Suites: []xunit.TestSuite{
					xunit.TestSuite{
						Name: "name1",
						Cases: []xunit.TestCase{
							xunit.TestCase{
								Name:      "test1",
								Classname: "class1",
								Time:      "0.10",
							},
						},
						Tests:    1,
						Failures: 0,
					},
				},
			},
			expectedSuites: &xunit.TestSuites{
				Suites: []xunit.TestSuite{expectedGenSuite},
				XMLName: xml.Name{
					Local: "testsuites",
				},
			},
		},
		// xUnit file exists and contains failed test cases.
		{
			createXUnitFile: true,
			existingSuites: &xunit.TestSuites{
				Suites: []xunit.TestSuite{aFailedTestSuite},
			},
			expectedSuites: &xunit.TestSuites{
				Suites: []xunit.TestSuite{aFailedTestSuite},
				XMLName: xml.Name{
					Local: "testsuites",
				},
			},
		},
	}

	xUnitFileName := xunit.ReportPath("vanadium-go-test")
	internalErr := newInternalError(fmt.Errorf("something is wrong"), "Init")
	for _, testCase := range testCases {
		if err := os.RemoveAll(xUnitFileName); err != nil {
			t.Fatalf("RemoveAll(%s) failed: %v", xUnitFileName, err)
		}
		if testCase.createXUnitFile && testCase.existingSuites != nil {
			bytes, err := xml.MarshalIndent(testCase.existingSuites, "", "  ")
			if err != nil {
				t.Fatalf("MarshalIndent(%v) failed: %v", testCase.existingSuites, err)
			}
			if err := ioutil.WriteFile(xUnitFileName, bytes, os.FileMode(0644)); err != nil {
				t.Fatalf("WriteFile(%v) failed: %v", xUnitFileName, err)
			}
		}
		testResult, err := generateXUnitReportForError(jirix, "vanadium-go-test", internalErr, "output message")
		if err != nil {
			t.Fatalf("want no errors, got %v", err)
		}
		gotSuites, err := parseXUnitFile(xUnitFileName)
		if err != nil {
			t.Fatalf("%v", err)
		}
		if !reflect.DeepEqual(gotSuites, testCase.expectedSuites) {
			t.Fatalf("want\n%#v\n\ngot\n%#v", testCase.expectedSuites, gotSuites)
		}
		if got, expected := testResult.Status, test.Failed; got != expected {
			t.Fatalf("want %v, got %v", expected, got)
		}
	}
}

func parseXUnitFile(fileName string) (*xunit.TestSuites, error) {
	bytes, err := ioutil.ReadFile(fileName)
	if err != nil {
		return nil, fmt.Errorf("ReadFile(%s) failed: %v", fileName, err)
	}
	var s xunit.TestSuites
	if err := xml.Unmarshal(bytes, &s); err != nil {
		return nil, fmt.Errorf("Unmarshal() failed: %v\n%v", err, string(bytes))
	}
	return &s, nil
}

func TestCreateDepGraph(t *testing.T) {
	type testCase struct {
		config        *tooldata.Config
		tests         []string
		expectedTests testDepGraph
		expectDepLoop bool
	}
	testCases := []testCase{
		// A single test without any dependencies.
		testCase{
			config: tooldata.NewConfig(tooldata.TestDependenciesOpt(map[string][]string{"A": []string{}})),
			tests:  []string{"A"},
			expectedTests: testDepGraph{
				"A": &testNode{
					deps:    []string{},
					visited: true,
				},
			},
		},
		// A -> B
		testCase{
			config: tooldata.NewConfig(tooldata.TestDependenciesOpt(map[string][]string{"A": []string{"B"}})),
			tests:  []string{"A", "B"},
			expectedTests: testDepGraph{
				"A": &testNode{
					deps:    []string{"B"},
					visited: true,
				},
				"B": &testNode{
					deps:    []string{},
					visited: true,
				},
			},
		},
		// A -> {B, C, D}
		testCase{
			config: tooldata.NewConfig(tooldata.TestDependenciesOpt(map[string][]string{"A": []string{"B", "C", "D"}})),
			tests:  []string{"A", "B", "C", "D"},
			expectedTests: testDepGraph{
				"A": &testNode{
					deps:    []string{"B", "C", "D"},
					visited: true,
				},
				"B": &testNode{
					deps:    []string{},
					visited: true,
				},
				"C": &testNode{
					deps:    []string{},
					visited: true,
				},
				"D": &testNode{
					deps:    []string{},
					visited: true,
				},
			},
		},
		// Same as above, but "dep" has no data.
		testCase{
			config: tooldata.NewConfig(),
			tests:  []string{"A", "B", "C", "D"},
			expectedTests: testDepGraph{
				"A": &testNode{
					deps:    []string{},
					visited: true,
				},
				"B": &testNode{
					deps:    []string{},
					visited: true,
				},
				"C": &testNode{
					deps:    []string{},
					visited: true,
				},
				"D": &testNode{
					deps:    []string{},
					visited: true,
				},
			},
		},
		// A -> {B, C, D}, but A is the only given test to resolve dependency for.
		testCase{
			config: tooldata.NewConfig(tooldata.TestDependenciesOpt(map[string][]string{"A": []string{"B", "C", "D"}})),
			tests:  []string{"A"},
			expectedTests: testDepGraph{
				"A": &testNode{
					deps:    []string{},
					visited: true,
				},
			},
		},
		// A -> {B, C, D} -> E
		testCase{
			config: tooldata.NewConfig(tooldata.TestDependenciesOpt(map[string][]string{
				"A": []string{"B", "C", "D"},
				"B": []string{"E"},
				"C": []string{"E"},
				"D": []string{"E"},
			})),
			tests: []string{"A", "B", "C", "D", "E"},
			expectedTests: testDepGraph{
				"A": &testNode{
					deps:    []string{"B", "C", "D"},
					visited: true,
				},
				"B": &testNode{
					deps:    []string{"E"},
					visited: true,
				},
				"C": &testNode{
					deps:    []string{"E"},
					visited: true,
				},
				"D": &testNode{
					deps:    []string{"E"},
					visited: true,
				},
				"E": &testNode{
					deps:    []string{},
					visited: true,
				},
			},
		},
		// Dependency loop:
		// A -> B
		// B -> C, C -> B
		testCase{
			config: tooldata.NewConfig(tooldata.TestDependenciesOpt(map[string][]string{
				"A": []string{"B"},
				"B": []string{"C"},
				"C": []string{"B"},
			})),
			tests:         []string{"A", "B", "C"},
			expectDepLoop: true,
		},
	}
	for index, test := range testCases {
		got, err := createTestDepGraph(test.config, test.tests)
		if test.expectDepLoop {
			if err == nil {
				t.Fatalf("test case %d: want errors, got: %v", index, err)
			}
		} else {
			if err != nil {
				t.Fatalf("test case %d: want no errors, got: %v", index, err)
			}
			if !reflect.DeepEqual(test.expectedTests, got) {
				t.Fatalf("test case %d: want %v, got %v", index, test.expectedTests, got)
			}
		}
	}
}