containerized-testing-tool: Save the test results in Junit format

- Add support for saving the test results in Junit format
- Fix documentation
- Add .gitignore

Signed-off-by: Ankita Pareek <ankitapareek@microsoft.com>

Author: Ankita13-code

tests/kata-containerized-test-tool/.gitignore

@@ -0,0 +1,4 @@
+kata-containerized-test-tool
+results/
+*.tar
+*.tar.gz

tests/kata-containerized-test-tool/Dockerfile

@@ -10,8 +10,5 @@ RUN tdnf update -y && tdnf install -y \
     iproute \
     && tdnf clean all
 
-# Default environment variables
-ENV ENABLED_TESTS=""
-
 ENTRYPOINT ["/app/kata-containerized-test-tool"]
 CMD ["--output", "/results"]

tests/kata-containerized-test-tool/cmd/katatest/main.go

@@ -73,7 +73,7 @@ func getTestsToRun(availableTests map[string]core.Test) []core.Test {
 	return testsToRun
 }
 
-// Retrieve the expected values for a specific test from environment variables
+// getExpectedValues retrieves the expected values for a specific test from environment variables
 func getExpectedValues(testName string) map[string]interface{} {
 	expectedValues := map[string]interface{}{}
 

tests/kata-containerized-test-tool/internal/core/framework.go

@@ -2,7 +2,7 @@ package core
 
 import (
 	"context"
-	"encoding/json"
+	"encoding/xml"
 	"fmt"
 	"os"
 	"strings"
@@ -15,25 +15,25 @@ type Framework struct {
 	outputDir string
 }
 
-// Create a new testing framework
+// NewFrameworkCreate a new testing framework
 func NewFramework(outputDir string) *Framework {
 	return &Framework{
 		tests:     make(map[string]Test),
 		outputDir: outputDir,
 	}
 }
 
-// Add a test to the framework
+// RegisterTest adds a test to the framework
 func (f *Framework) RegisterTest(test Test) {
 	f.tests[test.Name()] = test
 }
 
-// Return all registered tests
+// GetAvailableTests returns all registered tests
 func (f *Framework) GetAvailableTests() map[string]Test {
 	return f.tests
 }
 
-// Check if the provided test configurations are valid
+// ValidateConfiguration checks if the provided test configurations are valid
 func (f *Framework) ValidateConfiguration(testsToRun []Test,
 	getExpectedValuesFunc func(string) map[string]interface{}) []string {
 
@@ -84,12 +84,12 @@ func (f *Framework) ValidateConfiguration(testsToRun []Test,
 	return warnings
 }
 
-// Execute a single test with the given expected values
+// RunTest executes a single test with the given expected values
 func (f *Framework) RunTest(ctx context.Context, test Test, expectedValues map[string]interface{}) TestResult {
 	return test.Run(ctx, expectedValues)
 }
 
-// Execute the given tests with their expected values
+// RunTests executes the given tests with their expected values
 func (f *Framework) RunTests(ctx context.Context, testsToRun []Test,
 	getExpectedValuesFunc func(string) map[string]interface{}) ([]TestResult, error) {
 
@@ -112,21 +112,104 @@ func (f *Framework) RunTests(ctx context.Context, testsToRun []Test,
 	return results, nil
 }
 
-// Write test results to a JSON file
+// saveResults saves test results in JUnit XML format
 func (f *Framework) saveResults(results []TestResult) error {
-	filename := fmt.Sprintf("%s/results_%s.json",
+	// Create the root element
+	testSuites := JUnitTestSuites{}
+
+	// Create a test suite
+	testSuite := JUnitTestSuite{
+		Name:     "KataContainerTests",
+		Tests:    len(results),
+		Failures: 0,
+		Time:     0,
+	}
+
+	// Process each test result
+	for _, result := range results {
+		// Calculate test duration
+		duration := result.EndTime.Sub(result.StartTime)
+
+		// Create test case
+		testCase := JUnitTestCase{
+			Name:      result.Name,
+			ClassName: "KataContainerTest",
+			Time:      duration.Seconds(),
+		}
+
+		// Store metrics and expected values as properties
+		var properties []JUnitProperty
+
+		// Add metrics properties
+		for key, value := range result.Metrics {
+			properties = append(properties, JUnitProperty{
+				Name:  fmt.Sprintf("metric.%s", key),
+				Value: fmt.Sprintf("%v", value),
+			})
+		}
+
+		// Add expected value properties (if any)
+		for key, value := range result.ExpectedValues {
+			properties = append(properties, JUnitProperty{
+				Name:  fmt.Sprintf("expected.%s", key),
+				Value: fmt.Sprintf("%v", value),
+			})
+		}
+
+		// Only add properties if we have any
+		if len(properties) > 0 {
+			testCase.Properties = JUnitProperties{
+				Properties: properties,
+			}
+		}
+
+		// Add failure information if test failed
+		if !result.Success {
+			testSuite.Failures++
+			testCase.Failure = &JUnitFailure{
+				Message: result.Error,
+				Type:    "AssertionFailure",
+				Value:   fmt.Sprintf("Test failed: %s", result.Error),
+			}
+		}
+
+		// Add test case to suite
+		testSuite.TestCases = append(testSuite.TestCases, testCase)
+
+		// Add to total time
+		testSuite.Time += duration.Seconds()
+	}
+
+	// Add suite to root element
+	testSuites.Suites = append(testSuites.Suites, testSuite)
+
+	// Create the XML file
+	filename := fmt.Sprintf("%s/results_%s.xml",
 		f.outputDir,
 		time.Now().Format("20060102_150405"))
 
-	data, err := json.MarshalIndent(results, "", "    ")
+	file, err := os.Create(filename)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to create JUnit XML file: %v", err)
+	}
+	defer file.Close()
+
+	// Write XML header
+	file.WriteString(xml.Header)
+
+	// Create encoder with indentation for readability
+	encoder := xml.NewEncoder(file)
+	encoder.Indent("", "  ")
+
+	// Encode and write
+	if err := encoder.Encode(testSuites); err != nil {
+		return fmt.Errorf("failed to encode JUnit XML: %v", err)
 	}
 
-	return os.WriteFile(filename, data, 0644)
+	return nil
 }
 
-// Helper function to get a human-readable result string
+// getResultString is a helper function to get a human-readable result string
 func getResultString(result TestResult) string {
 	if result.Success {
 		return "PASSED"

tests/kata-containerized-test-tool/internal/core/types.go

@@ -2,20 +2,58 @@ package core
 
 import (
 	"context"
+	"encoding/xml"
 	"time"
 )
 
 type TestResult struct {
-	Name           string                 `json:"name"`
-	StartTime      time.Time              `json:"start_time"`
-	EndTime        time.Time              `json:"end_time"`
-	Success        bool                   `json:"success"`
-	Metrics        map[string]interface{} `json:"metrics"`
-	ExpectedValues map[string]interface{} `json:"expected_values"`
-	Error          string                 `json:"error,omitempty"`
+	Name           string
+	StartTime      time.Time
+	EndTime        time.Time
+	Success        bool
+	Metrics        map[string]interface{}
+	ExpectedValues map[string]interface{}
+	Error          string
 }
 
 type Test interface {
 	Name() string
 	Run(ctx context.Context, expectedValues map[string]interface{}) TestResult
 }
+
+type JUnitTestSuites struct {
+	XMLName xml.Name         `xml:"testsuites"`
+	Suites  []JUnitTestSuite `xml:"testsuite"`
+}
+
+type JUnitTestSuite struct {
+	XMLName   xml.Name        `xml:"testsuite"`
+	Tests     int             `xml:"tests,attr"`
+	Failures  int             `xml:"failures,attr"`
+	Time      float64         `xml:"time,attr"`
+	Name      string          `xml:"name,attr"`
+	TestCases []JUnitTestCase `xml:"testcase"`
+}
+
+type JUnitTestCase struct {
+	Name       string          `xml:"name,attr"`
+	ClassName  string          `xml:"classname,attr"`
+	Time       float64         `xml:"time,attr"`
+	Failure    *JUnitFailure   `xml:"failure,omitempty"`
+	Properties JUnitProperties `xml:"properties,omitempty"`
+}
+
+type JUnitProperties struct {
+	Properties []JUnitProperty `xml:"property"`
+}
+
+type JUnitProperty struct {
+	Name  string `xml:"name,attr"`
+	Value string `xml:"value,attr"`
+}
+
+type JUnitFailure struct {
+	Message string `xml:"message,attr"`
+	Type    string `xml:"type,attr"`
+	Value   string `xml:",chardata"`
+}