Test Coverage PR-1: Tests added in ./licensecheck and ./repodata subdir

licensecheck/copyright.go

@@ -18,6 +18,10 @@ func HasCopyright(filePath string) (bool, error) {
 	return HasMatchingCopyright(filePath, "copyright", false)
 }
 
+// copyrightHeaderBytes is the number of bytes from the start of a file
+// that are searched for a copyright statement.
+const copyrightHeaderBytes = 300
+
 // HasMatchingCopyright takes an explicit copyright statement and validates that
 // a given file contains that string in the header (first 1k chars)
 func HasMatchingCopyright(filePath string, copyrightStatement string, caseSensitive bool) (bool, error) {
@@ -26,8 +30,8 @@ func HasMatchingCopyright(filePath string, copyrightStatement string, caseSensit
 		return false, err
 	}
 
-	// Check the first 300 characters
-	n := 300
+	// Check the first copyrightHeaderBytes characters
+	n := copyrightHeaderBytes
 	if len(b) < n {
 		n = len(b)
 	}

licensecheck/copyright_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestHasMatchingCopyright(t *testing.T) {
@@ -141,8 +142,10 @@ func TestHasMatchingCopyright(t *testing.T) {
 
 	for _, tt := range cases {
 		t.Run(tt.description, func(t *testing.T) {
-			f, _ := afero.TempFile(AppFs, tempDir, "")
-			_ = afero.WriteFile(AppFs, f.Name(), []byte(tt.fileContents), 0644)
+			f, err := afero.TempFile(AppFs, tempDir, "")
+			require.NoError(t, err)
+			err = afero.WriteFile(AppFs, f.Name(), []byte(tt.fileContents), 0644)
+			require.NoError(t, err)
 			// run test
 			actualValid, err := HasMatchingCopyright(f.Name(), desiredCopyrightString, tt.caseSensitive)
 			assert.ErrorIs(t, err, tt.expectedError, tt.description)
@@ -264,12 +267,108 @@ func TestHasCopyright(t *testing.T) {
 
 	for _, tt := range cases {
 		t.Run(tt.description, func(t *testing.T) {
-			f, _ := afero.TempFile(AppFs, tempDir, "")
-			_ = afero.WriteFile(AppFs, f.Name(), []byte(tt.fileContents), 0644)
+			f, err := afero.TempFile(AppFs, tempDir, "")
+			require.NoError(t, err)
+			err = afero.WriteFile(AppFs, f.Name(), []byte(tt.fileContents), 0644)
+			require.NoError(t, err)
 			// run test
 			actualValid, err := HasCopyright(f.Name())
 			assert.ErrorIs(t, err, tt.expectedError, tt.description)
 			assert.Equal(t, tt.expectedValid, actualValid, tt.description)
 		})
 	}
 }
+
+func TestHasMatchingCopyright_ErrorHandling(t *testing.T) {
+	t.Run("error on non-existent file", func(t *testing.T) {
+		hasCopyright, err := HasMatchingCopyright("/nonexistent/file.txt", "Copyright", false)
+		assert.NotNil(t, err)
+		assert.False(t, hasCopyright)
+	})
+}
+
+func TestHasMatchingCopyright_EdgeCases(t *testing.T) {
+	AppFs := afero.NewOsFs()
+	tempDir := t.TempDir()
+
+	t.Run("file exactly copyrightHeaderBytes bytes with copyright at end", func(t *testing.T) {
+		// Create a file exactly copyrightHeaderBytes bytes where "Copyright" appears near the end
+		padding := make([]byte, copyrightHeaderBytes-10)
+		for i := range padding {
+			padding[i] = 'A'
+		}
+		content := string(padding) + "Copyright!"
+
+		f, err := afero.TempFile(AppFs, tempDir, "")
+		require.NoError(t, err)
+		err = afero.WriteFile(AppFs, f.Name(), []byte(content), 0644)
+		require.NoError(t, err)
+
+		hasCopyright, err := HasMatchingCopyright(f.Name(), "Copyright", false)
+		assert.Nil(t, err)
+		assert.True(t, hasCopyright)
+	})
+
+	t.Run("file less than copyrightHeaderBytes bytes", func(t *testing.T) {
+		content := "Short file with Copyright notice"
+
+		f, err := afero.TempFile(AppFs, tempDir, "")
+		require.NoError(t, err)
+		err = afero.WriteFile(AppFs, f.Name(), []byte(content), 0644)
+		require.NoError(t, err)
+
+		hasCopyright, err := HasMatchingCopyright(f.Name(), "Copyright", false)
+		assert.Nil(t, err)
+		assert.True(t, hasCopyright)
+	})
+
+	t.Run("file larger than copyrightHeaderBytes bytes with copyright after header", func(t *testing.T) {
+		// Create content > copyrightHeaderBytes bytes with copyright appearing after the header
+		header := make([]byte, copyrightHeaderBytes+50)
+		for i := range header {
+			header[i] = 'X'
+		}
+		content := string(header) + "\nCopyright notice here"
+
+		f, err := afero.TempFile(AppFs, tempDir, "")
+		require.NoError(t, err)
+		err = afero.WriteFile(AppFs, f.Name(), []byte(content), 0644)
+		require.NoError(t, err)
+
+		// Should not find copyright since it's after the copyrightHeaderBytes-byte header check
+		hasCopyright, err := HasMatchingCopyright(f.Name(), "Copyright", false)
+		assert.Nil(t, err)
+		assert.False(t, hasCopyright)
+	})
+
+	t.Run("empty search string", func(t *testing.T) {
+		f, err := afero.TempFile(AppFs, tempDir, "")
+		require.NoError(t, err)
+		err = afero.WriteFile(AppFs, f.Name(), []byte("Some content"), 0644)
+		require.NoError(t, err)
+
+		// Empty string should always be found
+		hasCopyright, err := HasMatchingCopyright(f.Name(), "", false)
+		assert.Nil(t, err)
+		assert.True(t, hasCopyright)
+	})
+
+	t.Run("search string longer than file", func(t *testing.T) {
+		f, err := afero.TempFile(AppFs, tempDir, "")
+		require.NoError(t, err)
+		err = afero.WriteFile(AppFs, f.Name(), []byte("Short"), 0644)
+		require.NoError(t, err)
+
+		hasCopyright, err := HasMatchingCopyright(f.Name(), "This is a very long copyright statement that is longer than the file content", false)
+		assert.Nil(t, err)
+		assert.False(t, hasCopyright)
+	})
+}
+
+func TestHasCopyright_ErrorHandling(t *testing.T) {
+	t.Run("error on non-existent file", func(t *testing.T) {
+		hasCopyright, err := HasCopyright("/nonexistent/file.txt")
+		assert.NotNil(t, err)
+		assert.False(t, hasCopyright)
+	})
+}

licensecheck/licensecheck_test.go

@@ -6,11 +6,13 @@ package licensecheck
 import (
 	"path/filepath"
 	"sort"
+	"strings"
 	"testing"
 
 	"github.com/samber/lo"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func createTempFiles(t *testing.T, fileNames []string) (dirPath string, filePaths []string) {
@@ -19,7 +21,10 @@ func createTempFiles(t *testing.T, fileNames []string) (dirPath string, filePath
 	// create file
 	filePaths = lo.Map(fileNames, func(fileName string, i int) string {
 		filePath := filepath.Join(tempDir, fileName)
-		_ = afero.WriteFile(AppFs, filePath, []byte("Bob Loblaw's Law Blog"), 0644)
+		err := AppFs.MkdirAll(filepath.Dir(filePath), 0755)
+		require.NoError(t, err)
+		err = afero.WriteFile(AppFs, filePath, []byte("Bob Loblaw's Law Blog"), 0644)
+		require.NoError(t, err)
 		return filePath
 	})
 
@@ -85,14 +90,151 @@ func TestEnsureCorrectName(t *testing.T) {
 	}
 }
 
+func TestEnsureCorrectName_ErrorHandling(t *testing.T) {
+	t.Run("error when file does not exist", func(t *testing.T) {
+		_, err := EnsureCorrectName("/nonexistent/path/license.txt")
+		assert.NotNil(t, err)
+	})
+}
+
 func TestAddHeader(t *testing.T) {
-	// stub
-	t.Skip()
+	AppFs := afero.NewOsFs()
+
+	t.Run("add header to empty file", func(t *testing.T) {
+		tempDir := t.TempDir()
+		filePath := filepath.Join(tempDir, "test.txt")
+		err := afero.WriteFile(AppFs, filePath, []byte(""), 0644)
+		require.NoError(t, err)
+
+		header := "Copyright (c) 2023 Test Corp"
+		err = AddHeader(filePath, header)
+		require.NoError(t, err)
+
+		// Read file and verify header was added
+		content, err := afero.ReadFile(AppFs, filePath)
+		require.NoError(t, err)
+		assert.Contains(t, string(content), header)
+		// Should have double newline after header, with nothing following it
+		assert.Equal(t, header+"\n\n", string(content), "file should contain only the header followed by a blank line with nothing after")
+	})
+
+	t.Run("add header to file with existing content", func(t *testing.T) {
+		tempDir := t.TempDir()
+		filePath := filepath.Join(tempDir, "test.txt")
+		originalContent := "This is the original file content"
+		err := afero.WriteFile(AppFs, filePath, []byte(originalContent), 0644)
+		require.NoError(t, err)
+
+		header := "Copyright (c) 2023 Test Corp"
+		err = AddHeader(filePath, header)
+		require.NoError(t, err)
+
+		// Read file and verify header was prepended
+		content, err := afero.ReadFile(AppFs, filePath)
+		require.NoError(t, err)
+		// File must start with the exact header followed by a blank line
+		assert.True(t, strings.HasPrefix(string(content), header+"\n\n"),
+			"file should start with the exact header followed by a blank line")
+		assert.True(t, strings.HasSuffix(string(content), originalContent),
+			"original content should follow the header unchanged")
+	})
+
+	t.Run("add multi-line header", func(t *testing.T) {
+		tempDir := t.TempDir()
+		filePath := filepath.Join(tempDir, "test.txt")
+		originalContent := "This is the original file content"
+		err := afero.WriteFile(AppFs, filePath, []byte(originalContent), 0644)
+		require.NoError(t, err)
+
+		header := "Copyright (c) 2023 Test Corp\nSPDX-License-Identifier: MPL-2.0"
+		err = AddHeader(filePath, header)
+		require.NoError(t, err)
+
+		content, err := afero.ReadFile(AppFs, filePath)
+		require.NoError(t, err)
+		expectedPrefix := header + "\n\n"
+		assert.True(t, strings.HasPrefix(string(content), expectedPrefix),
+			"file should start with the multi-line header followed by a blank line")
+		assert.True(t, strings.HasSuffix(string(content), originalContent),
+			"original content should follow the header unchanged")
+		assert.Equal(t, expectedPrefix+originalContent, string(content),
+			"file should contain only the header and original content with nothing in between")
+	})
+
+	t.Run("error on non-existent file", func(t *testing.T) {
+		header := "Copyright (c) 2023 Test Corp"
+		err := AddHeader("/nonexistent/path/file.txt", header)
+		assert.NotNil(t, err)
+	})
 }
 
 func TestAddLicenseFile(t *testing.T) {
-	// stub
-	t.Skip()
+	AppFs := afero.NewOsFs()
+
+	t.Run("create LICENSE file with MPL-2.0", func(t *testing.T) {
+		tempDir := t.TempDir()
+		licensePath, err := AddLicenseFile(tempDir, "MPL-2.0")
+		assert.Nil(t, err)
+		assert.NotEmpty(t, licensePath)
+
+		// Verify file exists
+		fileExists, err := afero.Exists(AppFs, licensePath)
+		require.NoError(t, err)
+		assert.True(t, fileExists)
+
+		// Verify content contains MPL-2.0 license text
+		content, err := afero.ReadFile(AppFs, licensePath)
+		require.NoError(t, err)
+		assert.Contains(t, string(content), "Mozilla Public License")
+	})
+
+	t.Run("create LICENSE file with Apache-2.0", func(t *testing.T) {
+		tempDir := t.TempDir()
+		licensePath, err := AddLicenseFile(tempDir, "Apache-2.0")
+		assert.Nil(t, err)
+
+		content, err := afero.ReadFile(AppFs, licensePath)
+		require.NoError(t, err)
+		assert.Contains(t, string(content), "Apache License")
+	})
+
+	t.Run("create LICENSE file with MIT", func(t *testing.T) {
+		tempDir := t.TempDir()
+		licensePath, err := AddLicenseFile(tempDir, "MIT")
+		assert.Nil(t, err)
+
+		content, err := afero.ReadFile(AppFs, licensePath)
+		require.NoError(t, err)
+		assert.Contains(t, string(content), "Permission is hereby granted")
+	})
+
+	t.Run("error on unknown SPDX ID", func(t *testing.T) {
+		tempDir := t.TempDir()
+		licensePath, err := AddLicenseFile(tempDir, "UNKNOWN-LICENSE-99")
+		assert.NotNil(t, err)
+		assert.Empty(t, licensePath)
+		assert.Contains(t, err.Error(), "unknown SPDX license ID")
+	})
+
+	t.Run("error on invalid directory path", func(t *testing.T) {
+		licensePath, err := AddLicenseFile("/nonexistent/invalid/path", "MPL-2.0")
+		assert.NotNil(t, err)
+		assert.Empty(t, licensePath)
+	})
+
+	t.Run("returned path is absolute", func(t *testing.T) {
+		tempDir := t.TempDir()
+		licensePath, err := AddLicenseFile(tempDir, "MPL-2.0")
+		assert.Nil(t, err)
+		assert.True(t, filepath.IsAbs(licensePath))
+	})
+
+	t.Run("file is named LICENSE", func(t *testing.T) {
+		tempDir := t.TempDir()
+		licensePath, err := AddLicenseFile(tempDir, "Apache-2.0")
+		assert.Nil(t, err)
+		assert.Equal(t, "LICENSE", filepath.Base(licensePath))
+	})
 }
 
 func sortSlice(input *[]string) {
@@ -155,7 +297,7 @@ func TestFindLicenseFiles(t *testing.T) {
 		},
 		{
 			description:    "Don't match directories",
-			input:          []string{"LICENSE", "license/blah.txt"},
+			input:          []string{"LICENSE", "subdir/blah.txt"},
 			expectedOutput: []string{"LICENSE"},
 		},
 	}
@@ -165,6 +307,7 @@ func TestFindLicenseFiles(t *testing.T) {
 			tempDir, _ := createTempFiles(t, tt.input)
 			// run test
 			actualOutput, err := FindLicenseFiles(tempDir)
+			require.NoError(t, err)
 			// validate file was renamed successfully
 			expectedOutputPaths := lo.Map(tt.expectedOutput, func(p string, _ int) string {
 				return filepath.Join(tempDir, p)
@@ -179,3 +322,29 @@ func TestFindLicenseFiles(t *testing.T) {
 		})
 	}
 }
+
+func TestFindLicenseFiles_ErrorHandling(t *testing.T) {
+	t.Run("returns empty slice when directory doesn't exist", func(t *testing.T) {
+		// When the directory doesn't exist, glob returns empty without error
+		result, err := FindLicenseFiles("/nonexistent/directory/path")
+		assert.Nil(t, err)
+		assert.Equal(t, []string{}, result)
+	})
+
+	t.Run("handles subdirectories correctly", func(t *testing.T) {
+		AppFs := afero.NewOsFs()
+		tempDir := t.TempDir()
+
+		// Create a subdirectory with a LICENSE file
+		subDir := filepath.Join(tempDir, "subdir")
+		err := AppFs.MkdirAll(subDir, 0755)
+		require.NoError(t, err)
+		err = afero.WriteFile(AppFs, filepath.Join(subDir, "LICENSE"), []byte("sublicense"), 0644)
+		require.NoError(t, err)
+
+		// FindLicenseFiles should only find files in the top-level directory, not subdirs
+		result, err := FindLicenseFiles(tempDir)
+		require.NoError(t, err)
+		assert.Equal(t, []string{}, result)
+	})
+}