improve test coverage to >90%

Author: umputun

capture_test.go

@@ -4,8 +4,9 @@ import (
 	"fmt"
 	"os"
 	"strings"
+	"sync"
 	"testing"
-	
+
 	"github.com/stretchr/testify/require"
 )
 
@@ -113,6 +114,12 @@ func TestCaptureStdoutAndStderr(t *testing.T) {
 				fmt.Fprintln(os.Stderr, "stderr")
 			},
 		},
+		{
+			name:    "empty function",
+			wantOut: "",
+			wantErr: "",
+			f:       func() {},
+		},
 		{
 			name:    "large output",
 			wantOut: strings.Repeat("a", 100000) + "\n",
@@ -122,13 +129,79 @@ func TestCaptureStdoutAndStderr(t *testing.T) {
 				fmt.Fprintln(os.Stderr, strings.Repeat("b", 100000))
 			},
 		},
+		{
+			name:    "binary data",
+			wantOut: string([]byte{0, 1, 2, 3}),
+			wantErr: string([]byte{4, 5, 6, 7}),
+			f: func() {
+				os.Stdout.Write([]byte{0, 1, 2, 3})
+				os.Stderr.Write([]byte{4, 5, 6, 7})
+			},
+		},
+		{
+			name:    "concurrent writes",
+			wantOut: "out1\nout2\nout3\n",
+			wantErr: "err1\nerr2\nerr3\n",
+			f: func() {
+				var wg sync.WaitGroup
+				wg.Add(6)
+
+				go func() { defer wg.Done(); fmt.Fprintln(os.Stdout, "out1") }()
+				go func() { defer wg.Done(); fmt.Fprintln(os.Stderr, "err1") }()
+				go func() { defer wg.Done(); fmt.Fprintln(os.Stdout, "out2") }()
+				go func() { defer wg.Done(); fmt.Fprintln(os.Stderr, "err2") }()
+				go func() { defer wg.Done(); fmt.Fprintln(os.Stdout, "out3") }()
+				go func() { defer wg.Done(); fmt.Fprintln(os.Stderr, "err3") }()
+
+				wg.Wait()
+			},
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			gotOut, gotErr := CaptureStdoutAndStderr(t, tt.f)
-			require.Equal(t, tt.wantOut, gotOut, "CaptureStdoutAndStderr() stdout returned unexpected output")
-			require.Equal(t, tt.wantErr, gotErr, "CaptureStdoutAndStderr() stderr returned unexpected output")
+
+			// for concurrent writes, we can't guarantee order
+			if tt.name == "concurrent writes" {
+				// check that all expected lines are present, ignoring order
+				for _, line := range []string{"out1", "out2", "out3"} {
+					require.Contains(t, gotOut, line)
+				}
+				for _, line := range []string{"err1", "err2", "err3"} {
+					require.Contains(t, gotErr, line)
+				}
+			} else {
+				require.Equal(t, tt.wantOut, gotOut, "CaptureStdoutAndStderr() stdout returned unexpected output")
+				require.Equal(t, tt.wantErr, gotErr, "CaptureStdoutAndStderr() stderr returned unexpected output")
+			}
 		})
 	}
 }
+
+// TestCaptureFunctionErrors tests edge cases for the capture functions
+func TestCaptureFunctionErrors(t *testing.T) {
+	t.Run("panic in function", func(t *testing.T) {
+		defer func() {
+			if r := recover(); r == nil {
+				t.Errorf("Expected panic")
+			}
+		}()
+
+		CaptureStdout(t, func() {
+			panic("test panic")
+		})
+	})
+
+	t.Run("stderr with panic", func(t *testing.T) {
+		defer func() {
+			if r := recover(); r == nil {
+				t.Errorf("Expected panic")
+			}
+		}()
+
+		CaptureStderr(t, func() {
+			panic("test panic")
+		})
+	})
+}

containers/mongo_test.go

@@ -2,6 +2,7 @@ package containers
 
 import (
 	"context"
+	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -54,4 +55,47 @@ func TestMongoTestContainer(t *testing.T) {
 
 		assert.NotEqual(t, coll1.Name(), coll2.Name())
 	})
+
+	t.Run("close with original environment variable", func(t *testing.T) {
+		// save current MONGO_TEST value
+		origEnv := os.Getenv("MONGO_TEST")
+		testValue := "mongodb://original-value:27017"
+		os.Setenv("MONGO_TEST", testValue)
+		defer func() {
+			// restore original value
+			if origEnv == "" {
+				os.Unsetenv("MONGO_TEST")
+			} else {
+				os.Setenv("MONGO_TEST", origEnv)
+			}
+		}()
+
+		mongo := NewMongoTestContainer(ctx, t, 7)
+		err := mongo.Close(ctx)
+		require.NoError(t, err)
+
+		// verify environment restored
+		restoredValue := os.Getenv("MONGO_TEST")
+		assert.Equal(t, testValue, restoredValue, "Original environment value should be restored")
+	})
+
+	t.Run("close with no original environment variable", func(t *testing.T) {
+		// save current MONGO_TEST value
+		origEnv := os.Getenv("MONGO_TEST")
+		os.Unsetenv("MONGO_TEST")
+		defer func() {
+			// restore original value
+			if origEnv != "" {
+				os.Setenv("MONGO_TEST", origEnv)
+			}
+		}()
+
+		mongo := NewMongoTestContainer(ctx, t, 7)
+		err := mongo.Close(ctx)
+		require.NoError(t, err)
+
+		// verify environment is unset
+		_, exists := os.LookupEnv("MONGO_TEST")
+		assert.False(t, exists, "MONGO_TEST environment variable should be unset")
+	})
 }

file_utils_test.go

@@ -2,24 +2,70 @@ package testutils
 
 import (
 	"os"
+	"path/filepath"
 	"testing"
-	
+
 	"github.com/stretchr/testify/require"
 )
 
 func TestWriteTestFile(t *testing.T) {
-	// test creating a file with content
-	content := "test content"
-	filePath := WriteTestFile(t, content)
-
-	// check if file exists
-	_, err := os.Stat(filePath)
-	require.False(t, os.IsNotExist(err), "WriteTestFile did not create file at %s", filePath)
-	
-	// check content
-	data, err := os.ReadFile(filePath)
-	require.NoError(t, err, "Failed to read test file")
-	require.Equal(t, content, string(data), "File content doesn't match expected")
-	
-	// file should be cleaned up automatically at the end of the test
+	t.Run("standard file creation", func(t *testing.T) {
+		// test creating a file with content
+		content := "test content"
+		filePath := WriteTestFile(t, content)
+
+		// check if file exists
+		_, err := os.Stat(filePath)
+		require.False(t, os.IsNotExist(err), "WriteTestFile did not create file at %s", filePath)
+
+		// check content
+		data, err := os.ReadFile(filePath)
+		require.NoError(t, err, "Failed to read test file")
+		require.Equal(t, content, string(data), "File content doesn't match expected")
+
+		// verify directory structure
+		dir := filepath.Dir(filePath)
+		require.Contains(t, dir, "testutils-", "Temp directory should contain expected prefix")
+
+		// file should be cleaned up automatically at the end of the test
+	})
+
+	t.Run("with empty content", func(t *testing.T) {
+		filePath := WriteTestFile(t, "")
+
+		// check empty file was created
+		info, err := os.Stat(filePath)
+		require.NoError(t, err, "File should exist")
+		require.Zero(t, info.Size(), "File should be empty")
+	})
+
+	t.Run("with multi-line content", func(t *testing.T) {
+		content := "line 1\nline 2\nline 3"
+		filePath := WriteTestFile(t, content)
+
+		data, err := os.ReadFile(filePath)
+		require.NoError(t, err)
+		require.Equal(t, content, string(data))
+	})
+
+	t.Run("cleanup by direct call", func(t *testing.T) {
+		// create a test file
+		content := "test cleanup"
+		filePath := WriteTestFile(t, content)
+
+		// get the directory to be cleaned up
+		dir := filepath.Dir(filePath)
+
+		// verify directory and file exist
+		require.DirExists(t, dir)
+		require.FileExists(t, filePath)
+
+		// manually clean up (simulating what t.Cleanup would do)
+		err := os.RemoveAll(dir)
+		require.NoError(t, err)
+
+		// after manual cleanup, the file should no longer exist
+		_, err = os.Stat(filePath)
+		require.True(t, os.IsNotExist(err), "File should be removed after cleanup")
+	})
 }

http_utils_test.go

@@ -41,6 +41,29 @@ func TestMockHTTPServer(t *testing.T) {
 	require.Equal(t, expectedBody, string(body), "Wrong response body")
 }
 
+func TestRequestCaptorGetRequest(t *testing.T) {
+	// test the edge cases of GetRequest
+	captor := &RequestCaptor{}
+
+	// test with empty requests
+	_, ok := captor.GetRequest(0)
+	require.False(t, ok, "GetRequest should return false for empty requests")
+
+	// test with index out of bounds
+	_, ok = captor.GetRequest(-1)
+	require.False(t, ok, "GetRequest should return false for negative index")
+
+	// test with index out of bounds (positive)
+	_, ok = captor.GetRequest(5)
+	require.False(t, ok, "GetRequest should return false for index beyond length")
+
+	// add a sample request to test valid access
+	captor.add(RequestRecord{Method: "GET", Path: "/test"})
+	req, ok := captor.GetRequest(0)
+	require.True(t, ok, "GetRequest should return true for valid index")
+	require.Equal(t, "GET", req.Method, "Request method should match")
+}
+
 func TestHTTPRequestCaptor(t *testing.T) {
 	// create a test handler that will receive forwarded requests
 	testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {