| package unittest_test |
| |
| import ( |
| "encoding/xml" |
| "fmt" |
| "io/ioutil" |
| "path" |
| "testing" |
| |
| . "github.com/lrills/helm-unittest/unittest" |
| "github.com/stretchr/testify/assert" |
| ) |
| |
| var tmpXunitTestDir, _ = ioutil.TempDir("", testSuiteTests) |
| |
| func createXUnitTestCase(name, description, failureContent string, isError bool) XUnitTestCase { |
| testCase := XUnitTestCase{ |
| Name: name, |
| Type: description, |
| Method: XUnitValidationMethod, |
| Result: "Pass", |
| } |
| |
| if len(failureContent) > 0 { |
| testCase.Failure = &XUnitFailure{ |
| ExceptionType: XUnitValidationMethod, |
| Message: &XUnitFailureMessage{ |
| Data: "Failed", |
| }, |
| StackTrace: &XUnitFailureStackTrace{ |
| Data: failureContent, |
| }, |
| } |
| testCase.Result = "Fail" |
| } |
| |
| if isError { |
| testCase.Failure.ExceptionType = fmt.Sprintf("%s-%s", XUnitValidationMethod, "Error") |
| } |
| |
| return testCase |
| } |
| |
| func assertXUnitTestAssemblies(assert *assert.Assertions, expected, actual []XUnitAssembly) { |
| |
| if expected != nil && actual != nil { |
| actualLength := len(actual) |
| assert.Equal(len(expected), actualLength) |
| |
| for i := 0; i < actualLength; i++ { |
| assert.Equal(expected[i].Name, actual[i].Name) |
| assert.Equal(expected[i].ConfigFile, actual[i].ConfigFile) |
| assert.Equal(expected[i].TotalTests, actual[i].TotalTests) |
| assert.Equal(expected[i].PassedTests, actual[i].PassedTests) |
| assert.Equal(expected[i].FailedTests, actual[i].FailedTests) |
| assert.Equal(expected[i].SkippedTests, actual[i].SkippedTests) |
| assert.Equal(expected[i].ErrorsTests, actual[i].ErrorsTests) |
| |
| // Validate the tesruns |
| assertXUnitTestRun(assert, expected[i].TestRuns, actual[i].TestRuns) |
| } |
| } else { |
| // Verify if both are nil, otherwise it's still a failure. |
| assert.True(expected == nil && actual == nil) |
| } |
| } |
| |
| func assertXUnitTestRun(assert *assert.Assertions, expected, actual []XUnitTestRun) { |
| |
| if expected != nil && actual != nil { |
| actualLength := len(actual) |
| assert.Equal(len(expected), actualLength) |
| |
| for i := 0; i < actualLength; i++ { |
| assert.Equal(expected[i].Name, actual[i].Name) |
| assert.Equal(expected[i].TotalTests, actual[i].TotalTests) |
| assert.Equal(expected[i].PassedTests, actual[i].PassedTests) |
| assert.Equal(expected[i].FailedTests, actual[i].FailedTests) |
| assert.Equal(expected[i].SkippedTests, actual[i].SkippedTests) |
| |
| // Validate the testcases |
| assertXUnitTestCase(assert, expected[i].TestCases, actual[i].TestCases) |
| } |
| } else { |
| // Verify if both are nil, otherwise it's still a failure. |
| assert.True(expected == nil && actual == nil) |
| } |
| } |
| |
| func assertXUnitTestCase(assert *assert.Assertions, expected, actual []XUnitTestCase) { |
| |
| if expected != nil && actual != nil { |
| actualLength := len(actual) |
| assert.Equal(len(expected), actualLength) |
| |
| for i := 0; i < actualLength; i++ { |
| assert.Equal(expected[i].Name, actual[i].Name) |
| assert.Equal(expected[i].Type, actual[i].Type) |
| assert.Equal(expected[i].Method, actual[i].Method) |
| assert.Equal(expected[i].Result, actual[i].Result) |
| |
| if expected[i].Failure != nil || actual[i].Failure != nil { |
| assert.Equal(expected[i].Failure.ExceptionType, actual[i].Failure.ExceptionType) |
| assert.Equal(expected[i].Failure.Message.Data, actual[i].Failure.Message.Data) |
| assert.Equal(expected[i].Failure.StackTrace.Data, actual[i].Failure.StackTrace.Data) |
| } else { |
| // Verify if both are nil, otherwise it's still a failure. |
| assert.True(expected[i].Failure == nil && actual[i].Failure == nil) |
| } |
| } |
| } else { |
| // Verify if both are nil, otherwise it's still a failure. |
| assert.True(expected == nil && actual == nil) |
| } |
| } |
| |
| func TestWriteTestOutputAsXUnitMinimalSuccess(t *testing.T) { |
| assert := assert.New(t) |
| outputFile := path.Join(tmpXunitTestDir, "XUnit_Test_Output.xml") |
| testSuiteDisplayName := "TestingSuite" |
| testCaseDisplayName := "TestCaseSucces" |
| totalTests := 1 |
| totalPassed := 1 |
| totalFailed := 0 |
| totalErrors := 0 |
| totalSkipped := 0 |
| |
| expected := XUnitAssemblies{ |
| Assembly: []XUnitAssembly{ |
| { |
| Name: outputFile, |
| ConfigFile: outputFile, |
| TotalTests: totalTests, |
| PassedTests: totalPassed, |
| FailedTests: totalFailed, |
| SkippedTests: totalSkipped, |
| ErrorsTests: totalErrors, |
| TestRuns: []XUnitTestRun{ |
| { |
| Name: testSuiteDisplayName, |
| TotalTests: totalTests, |
| PassedTests: totalPassed, |
| FailedTests: totalFailed, |
| SkippedTests: totalSkipped, |
| TestCases: []XUnitTestCase{ |
| createXUnitTestCase(testCaseDisplayName, testSuiteDisplayName, "", false), |
| }, |
| }, |
| }, |
| }, |
| }, |
| } |
| |
| given := []*TestSuiteResult{ |
| { |
| DisplayName: testSuiteDisplayName, |
| FilePath: outputFile, |
| Passed: true, |
| TestsResult: []*TestJobResult{ |
| createTestJobResult(testCaseDisplayName, "", true, nil), |
| }, |
| }, |
| } |
| |
| sut := NewXUnitReportXML() |
| bytevalue := loadFormatterTestcase(assert, outputFile, given, sut) |
| |
| var actual XUnitAssemblies |
| xml.Unmarshal(bytevalue, &actual) |
| |
| assertXUnitTestAssemblies(assert, expected.Assembly, actual.Assembly) |
| } |
| |
| func TestWriteTestOutputAsXUnitWithFailures(t *testing.T) { |
| assert := assert.New(t) |
| outputFile := path.Join(tmpXunitTestDir, "XUnit_Test_Failure_Output.xml") |
| testSuiteDisplayName := "TestingSuite" |
| testCaseSuccessDisplayName := "TestCaseSuccess" |
| testCaseFailureDisplayName := "TestCaseFailure" |
| assertionFailure := "AssertionFailure" |
| assertionType := "equal" |
| assertIndex := 0 |
| failureContent := fmt.Sprintf("\t\t - asserts[%d]%s `%s` fail \n\t\t\t %s \n", assertIndex, "", assertionType, assertionFailure) |
| totalTests := 2 |
| totalPassed := 1 |
| totalFailed := 1 |
| totalErrors := 0 |
| totalSkipped := 0 |
| |
| expected := XUnitAssemblies{ |
| Assembly: []XUnitAssembly{ |
| { |
| Name: outputFile, |
| ConfigFile: outputFile, |
| TotalTests: totalTests, |
| PassedTests: totalPassed, |
| SkippedTests: totalSkipped, |
| FailedTests: totalFailed, |
| ErrorsTests: totalErrors, |
| TestRuns: []XUnitTestRun{ |
| { |
| Name: testSuiteDisplayName, |
| TotalTests: totalTests, |
| PassedTests: totalPassed, |
| FailedTests: totalFailed, |
| SkippedTests: totalSkipped, |
| TestCases: []XUnitTestCase{ |
| createXUnitTestCase(testCaseSuccessDisplayName, testSuiteDisplayName, "", false), |
| createXUnitTestCase(testCaseFailureDisplayName, testSuiteDisplayName, failureContent, false), |
| }, |
| }, |
| }, |
| }, |
| }, |
| } |
| |
| assertionResults := []*AssertionResult{ |
| createAssertionResult(0, false, false, assertionType, assertionFailure, ""), |
| } |
| |
| given := []*TestSuiteResult{ |
| { |
| DisplayName: testSuiteDisplayName, |
| FilePath: outputFile, |
| Passed: false, |
| TestsResult: []*TestJobResult{ |
| createTestJobResult(testCaseSuccessDisplayName, "", true, nil), |
| createTestJobResult(testCaseFailureDisplayName, "", false, assertionResults), |
| }, |
| }, |
| } |
| |
| sut := NewXUnitReportXML() |
| bytevalue := loadFormatterTestcase(assert, outputFile, given, sut) |
| |
| var actual XUnitAssemblies |
| xml.Unmarshal(bytevalue, &actual) |
| |
| assertXUnitTestAssemblies(assert, expected.Assembly, actual.Assembly) |
| } |
| |
| func TestWriteTestOutputAsXUnitWithFailuresAndErrors(t *testing.T) { |
| assert := assert.New(t) |
| outputFile := path.Join(tmpXunitTestDir, "XUnit_Test_Failure_And_Error_Output.xml") |
| testSuiteDisplayName := "TestingSuite" |
| testCaseSuccessDisplayName := "TestCaseSuccess" |
| testCaseFailureDisplayName := "TestCaseFailure" |
| testCaseErrorDisplayName := "TestCaseError" |
| assertionFailure := "AssertionFailure" |
| assertionType := "equal" |
| assertIndex := 0 |
| failureContent := fmt.Sprintf("\t\t - asserts[%d]%s `%s` fail \n\t\t\t %s \n", assertIndex, "", assertionType, assertionFailure) |
| errorMessage := "An Error Occurred." |
| failureErrorContent := fmt.Sprintf("%s\n%s", errorMessage, failureContent) |
| totalTests := 3 |
| totalPassed := 1 |
| totalFailed := 1 |
| totalErrors := 1 |
| totalSkipped := 0 |
| |
| expected := XUnitAssemblies{ |
| Assembly: []XUnitAssembly{ |
| { |
| Name: outputFile, |
| ConfigFile: outputFile, |
| TotalTests: totalTests, |
| PassedTests: totalPassed, |
| SkippedTests: totalSkipped, |
| FailedTests: totalFailed, |
| ErrorsTests: totalErrors, |
| TestRuns: []XUnitTestRun{ |
| { |
| Name: testSuiteDisplayName, |
| TotalTests: totalTests, |
| PassedTests: totalPassed, |
| FailedTests: totalFailed, |
| SkippedTests: totalSkipped, |
| TestCases: []XUnitTestCase{ |
| createXUnitTestCase(testCaseSuccessDisplayName, testSuiteDisplayName, "", false), |
| createXUnitTestCase(testCaseFailureDisplayName, testSuiteDisplayName, failureContent, false), |
| createXUnitTestCase(testCaseErrorDisplayName, testSuiteDisplayName, failureErrorContent, true), |
| }, |
| }, |
| }, |
| }, |
| }, |
| } |
| |
| assertionResults := []*AssertionResult{ |
| createAssertionResult(0, false, false, assertionType, assertionFailure, ""), |
| } |
| |
| given := []*TestSuiteResult{ |
| { |
| DisplayName: testSuiteDisplayName, |
| FilePath: outputFile, |
| Passed: false, |
| TestsResult: []*TestJobResult{ |
| createTestJobResult(testCaseSuccessDisplayName, "", true, nil), |
| createTestJobResult(testCaseFailureDisplayName, "", false, assertionResults), |
| createTestJobResult(testCaseErrorDisplayName, errorMessage, false, assertionResults), |
| }, |
| }, |
| } |
| |
| sut := NewXUnitReportXML() |
| bytevalue := loadFormatterTestcase(assert, outputFile, given, sut) |
| |
| var actual XUnitAssemblies |
| xml.Unmarshal(bytevalue, &actual) |
| |
| assertXUnitTestAssemblies(assert, expected.Assembly, actual.Assembly) |
| } |
| |
| func TestWriteTestOutputAsXUnitWithErrors(t *testing.T) { |
| assert := assert.New(t) |
| outputFile := path.Join(tmpXunitTestDir, "XUnit_Test_Error_Output.xml") |
| testSuiteDisplayName := "TestingSuite" |
| errorMessage := "An Error Occurred." |
| totalTests := 1 |
| totalPassed := 0 |
| totalFailed := 0 |
| totalErrors := 1 |
| totalSkipped := 0 |
| |
| expected := XUnitAssemblies{ |
| Assembly: []XUnitAssembly{ |
| { |
| Name: outputFile, |
| ConfigFile: outputFile, |
| TotalTests: totalTests, |
| PassedTests: totalPassed, |
| SkippedTests: totalSkipped, |
| FailedTests: totalFailed, |
| ErrorsTests: totalErrors, |
| Errors: []XUnitError{ |
| { |
| Type: "Error", |
| Name: "Error", |
| Failure: &XUnitFailure{ |
| ExceptionType: fmt.Sprintf("%s-%s", XUnitValidationMethod, "Error"), |
| Message: &XUnitFailureMessage{ |
| Data: "Failed", |
| }, |
| StackTrace: &XUnitFailureStackTrace{ |
| Data: errorMessage, |
| }, |
| }, |
| }, |
| }, |
| }, |
| }, |
| } |
| |
| given := []*TestSuiteResult{ |
| { |
| DisplayName: testSuiteDisplayName, |
| FilePath: outputFile, |
| Passed: false, |
| ExecError: fmt.Errorf("%s", errorMessage), |
| }, |
| } |
| |
| sut := NewXUnitReportXML() |
| bytevalue := loadFormatterTestcase(assert, outputFile, given, sut) |
| |
| var actual XUnitAssemblies |
| xml.Unmarshal(bytevalue, &actual) |
| |
| assertXUnitTestAssemblies(assert, expected.Assembly, actual.Assembly) |
| } |