go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/sdk/copyright/copyright_test.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package copyright

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"io/fs"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"text/template"
	"time"

	"go.charczuk.com/sdk/assert"
)

func Test_Copyright_GetStdout(t *testing.T) {
	c := new(Copyright)
	assert.ItsEqual(t, os.Stdout, c.GetStdout())
	buf := new(bytes.Buffer)
	c.Stdout = buf
	assert.ItsEqual(t, c.Stdout, c.GetStdout())
	c.Quiet = true
	assert.ItsEqual(t, io.Discard, c.GetStdout())
}

func Test_Copyright_GetStderr(t *testing.T) {
	c := new(Copyright)
	assert.ItsEqual(t, os.Stderr, c.GetStderr())
	buf := new(bytes.Buffer)
	c.Stderr = buf
	assert.ItsEqual(t, buf, c.GetStderr())
	c.Quiet = true
	assert.ItsEqual(t, io.Discard, c.GetStderr())
}

func Test_Copyright_mergeFileSections(t *testing.T) {
	merged := new(Copyright).mergeFileSections([]byte("foo"), []byte("bar"), []byte("baz"))
	assert.ItsEqual(t, "foobarbaz", string(merged))
}

func Test_Copyright_fileHasCopyrightHeader(t *testing.T) {
	var goodCorpus = []byte(`foo
bar
baz
`)

	notice, err := generateGoNotice(withYear(2021))
	assert.ItsNil(t, err)

	goodCorpusWithNotice := Copyright{}.mergeFileSections([]byte(notice), goodCorpus)
	assert.ItContains(t, string(goodCorpusWithNotice), "Copyright (c) 2021")
	assert.ItsTrue(t, (Copyright{}).fileHasCopyrightHeader(goodCorpusWithNotice, []byte(notice)))
}

func Test_Copyright_fileHasCopyrightHeader_invalid(t *testing.T) {
	c := new(Copyright)

	var invalidCorpus = []byte(`foo
bar
baz
`)
	expectedNotice, err := generateGoNotice(withYear(2021))
	assert.ItsNil(t, err)

	assert.ItsFalse(t, c.fileHasCopyrightHeader(invalidCorpus, []byte(expectedNotice)), "we haven't added the notice")
}

func Test_Copyright_fileHasCopyrightHeader_differentYear(t *testing.T) {
	c := new(Copyright)

	var goodCorpus = []byte(`foo
bar
baz
`)

	notice, err := generateGoNotice(withYear(2020))
	assert.ItsNil(t, err)

	goodCorpusWithNotice := c.mergeFileSections(notice, goodCorpus)
	assert.ItContains(t, string(goodCorpusWithNotice), "Copyright (c) 2020")

	newNotice, err := generateGoNotice(withYear(2021))
	assert.ItsNil(t, err)

	assert.ItsTrue(t, c.fileHasCopyrightHeader(goodCorpusWithNotice, []byte(newNotice)))
}

func Test_Copyright_fileHasCopyrightHeader_leadingWhitespace(t *testing.T) {
	c := Copyright{}

	var goodCorpus = []byte(`foo
bar
baz
`)

	notice, err := generateGoNotice(withYear(2021))
	assert.ItsNil(t, err)

	goodCorpusWithNotice := c.mergeFileSections([]byte("\n\n"), notice, goodCorpus)
	assert.ItHasPrefix(t, string(goodCorpusWithNotice), "\n\n")
	assert.ItContains(t, string(goodCorpusWithNotice), "Copyright (c) 2021")

	assert.ItsTrue(t, c.fileHasCopyrightHeader(goodCorpusWithNotice, []byte(notice)))
}

func Test_Copyright_goBuildTagMatch(t *testing.T) {

	c := Copyright{}

	buildTag := []byte(`// +build foo

`)
	corpus := []byte(`foo
bar
baz
`)

	file := (Copyright{}).mergeFileSections(buildTag, corpus)

	assert.ItsFalse(t, goBuildTagMatch.Match(corpus))
	assert.ItsTrue(t, goBuildTagMatch.Match(c.mergeFileSections(buildTag)))

	found := goBuildTagMatch.FindAll(file, -1)
	assert.ItsNotEmpty(t, found)
	assert.ItsTrue(t, goBuildTagMatch.Match(file))
}

func Test_Copyright_goBuildTagsMatch(t *testing.T) {

	file := []byte(goBuildTags1) // testutil.GetTestFixture(its, "buildtags1.go")
	assert.ItsTrue(t, goBuildTagMatch.Match(file))
	found := goBuildTagMatch.Find(file)
	assert.ItsEqual(t, "//go:build tag1\n// +build tag1\n\n", string(found))

	file2 := []byte(goBuildTags2) // testutil.GetTestFixture(its, "buildtags2.go")
	assert.ItsTrue(t, goBuildTagMatch.Match(file2))
	found2 := goBuildTagMatch.Find(file2)

	expected := `// +build tag5
//go:build tag1 && tag2 && tag3
// +build tag1,tag2,tag3
// +build tag6

`
	assert.ItsEqual(t, expected, string(found2))

	file3 := []byte(goBuildTags3) // testutil.GetTestFixture(its, "buildtags3.go")
	assert.ItsTrue(t, goBuildTagMatch.Match(file3))
	found3 := goBuildTagMatch.Find(file3)
	assert.ItsEqual(t, "//go:build tag1 & tag2\n\n", string(found3))
}

func Test_Copyright_goInjectNotice(t *testing.T) {

	c := Copyright{}

	file := []byte(`foo
bar
baz
`)

	notice, err := generateGoNotice(withYear(2021))
	assert.ItsNil(t, err)

	output := c.goInjectNotice("foo.go", file, notice)
	assert.ItContains(t, string(output), "Copyright (c) 2021")
	assert.ItHasSuffix(t, string(output), string(file))
}

func Test_Copyright_goInjectNotice_buildTag(t *testing.T) {

	c := Copyright{}

	buildTag := []byte(`// +build foo`)
	corpus := []byte(`foo
bar
baz
`)

	file := c.mergeFileSections(buildTag, []byte("\n\n"), corpus)

	notice, err := generateGoNotice(withYear(2021))
	assert.ItsNil(t, err)

	output := c.goInjectNotice("foo.go", file, notice)
	assert.ItContains(t, string(output), "Copyright (c) 2021")
	assert.ItHasPrefix(t, string(output), string(buildTag)+"\n")
	assert.ItHasSuffix(t, string(output), string(corpus))

	outputRepeat := c.goInjectNotice("foo.go", output, notice)
	assert.ItsEmpty(t, outputRepeat, "inject notice functions should return an empty slice if the header already exists")
}

func Test_Copyright_goInjectNotice_goBuildTags(t *testing.T) {
	type testCase struct {
		Name   string
		Input  string
		Expect string
	}

	cases := []testCase{
		{
			Name:   "standard build tags",
			Input:  goBuildTags1, // "buildtags1.go",
			Expect: goldenGoBuildTags1,
		},
		{
			Name:   "multiple build tags",
			Input:  goBuildTags2, // "buildtags2.go",
			Expect: goldenGoBuildTags2,
		},
		{
			Name:   "build tags split across file",
			Input:  goBuildTags3, // "buildtags3.go",
			Expect: goldenGoBuildTags3,
		},
	}

	for _, tc := range cases {
		tc := tc
		t.Run(tc.Name, func(t *testing.T) {
			c := new(Copyright)

			notice, err := generateGoNotice(withYear(2001))
			assert.ItsNil(t, err)

			output := c.goInjectNotice("foo.go", []byte(tc.Input), notice)
			assert.ItsEqual(t, string(output), tc.Expect) // testutil.AssertGoldenFile(it, output, tc.TestFile)

			outputRepeat := c.goInjectNotice("foo.go", output, notice)
			assert.ItsEmpty(t, outputRepeat)
		})
	}
}

func Test_Copyright_tsInjectNotice_tsReferenceTags(t *testing.T) {
	t.Parallel()

	type testCase struct {
		Name   string
		Input  string
		Expect string
	}

	cases := []testCase{
		{
			Name:   "single reference tag",
			Input:  tsReferenceTag,
			Expect: goldenTsReferenceTag,
		},
		{
			Name:   "multiple reference tags",
			Input:  tsReferenceTags,
			Expect: goldenTsReferenceTags,
		},
		{
			Name:   "no reference tags",
			Input:  tsTest, // "buildtags3.go",
			Expect: goldenTs,
		},
	}

	for _, tc := range cases {
		tc := tc
		t.Run(tc.Name, func(t *testing.T) {
			c := new(Copyright)

			notice, err := generateTypescriptNotice(withYear(2022))
			assert.ItsNil(t, err)

			output := c.tsInjectNotice("foo.ts", []byte(tc.Input), notice)
			assert.ItsEqual(t, tc.Expect, string(output))

			outputRepeat := c.tsInjectNotice("foo.ts", output, notice)
			assert.ItsEmpty(t, outputRepeat)
		})
	}
}

func Test_Copyright_injectNotice_typescript(t *testing.T) {
	c := new(Copyright)

	file := []byte(`foo
bar
baz
`)

	notice, err := generateTypescriptNotice(withYear(2001))
	assert.ItsNil(t, err)

	output := c.injectNotice("foo.ts", file, notice)
	assert.ItContains(t, string(output), "Copyright (c) 2001")
	assert.ItHasSuffix(t, string(output), string(file))

	outputRepeat := c.injectNotice("foo.ts", output, notice)
	assert.ItsEmpty(t, outputRepeat, "inject notice functions should return an empty slice if the header already exists")
}

func Test_Copyright_injectNotice_typescript_referenceTags(t *testing.T) {

	c := Copyright{}

	file := []byte(tsReferenceTags)

	notice, err := generateTypescriptNotice(withYear(2001))
	assert.ItsNil(t, err)

	output := c.injectNotice("foo.ts", file, notice)
	assert.ItContains(t, string(output), "Copyright (c) 2001")
	assert.ItHasSuffix(t, string(output), string(file))

	outputRepeat := c.injectNotice("foo.ts", output, notice)
	assert.ItsEmpty(t, outputRepeat, "inject notice functions should return an empty slice if the header already exists")
}

func Test_Copyright_goInjectNotice_openSource(t *testing.T) {
	c := &Copyright{
		Config: Config{
			Year:                 2021,
			License:              "Apache 2.0",
			RestrictionsTemplate: DefaultRestrictionsTemplate,
		},
	}

	file := []byte(`foo
bar
baz
`)

	notice, err := generateGoNotice(c)
	assert.ItsNil(t, err)

	output := c.goInjectNotice("foo.go", file, notice)
	assert.ItContains(t, string(output), "Copyright (c) 2021")
	assert.ItContains(t, string(output), "Use of this source code is governed by a Apache 2.0")
	assert.ItHasSuffix(t, string(output), string(file))
}

func Test_Copyright_GetNoticeTemplate(t *testing.T) {
	c := Copyright{}

	noticeTemplate, ok := c.injectionTemplateByExtension(".js")
	assert.ItsTrue(t, ok)
	assert.ItsEqual(t, jsInjectionTemplate, noticeTemplate)

	// it handles no dot prefix
	noticeTemplate, ok = c.injectionTemplateByExtension("js")
	assert.ItsTrue(t, ok)
	assert.ItsEqual(t, jsInjectionTemplate, noticeTemplate)

	// it handles another file type
	noticeTemplate, ok = c.injectionTemplateByExtension(".go")
	assert.ItsTrue(t, ok)
	assert.ItsEqual(t, goInjectionTemplate, noticeTemplate)

	noticeTemplate, ok = c.injectionTemplateByExtension("not-a-real-extension")
	assert.ItsFalse(t, ok)
	assert.ItsEmpty(t, noticeTemplate)

	noticeTemplate, ok = c.injectionTemplateByExtension("not-a-real-extension")
	assert.ItsFalse(t, ok)
	assert.ItsEmpty(t, noticeTemplate)
}

type mockInfoDir string

func (mid mockInfoDir) Name() string       { return string(mid) }
func (mid mockInfoDir) Size() int64        { return 1 << 8 }
func (mid mockInfoDir) Mode() fs.FileMode  { return fs.FileMode(0755) }
func (mid mockInfoDir) ModTime() time.Time { return time.Now().UTC() }
func (mid mockInfoDir) IsDir() bool        { return true }
func (mid mockInfoDir) Sys() interface{}   { return nil }

type mockInfoFile string

func (mif mockInfoFile) Name() string       { return string(mif) }
func (mif mockInfoFile) Size() int64        { return 1 << 8 }
func (mif mockInfoFile) Mode() fs.FileMode  { return fs.FileMode(0755) }
func (mif mockInfoFile) ModTime() time.Time { return time.Now().UTC() }
func (mif mockInfoFile) IsDir() bool        { return false }
func (mif mockInfoFile) Sys() interface{}   { return nil }

func Test_Copyright_includeOrExclude(t *testing.T) {
	t.Parallel()

	testCases := [...]struct {
		Config   Config
		Path     string
		Info     fs.FileInfo
		Expected error
	}{
		/*0*/ {Config: Config{}, Path: ".", Info: mockInfoDir("."), Expected: ErrWalkSkip},
		/*1*/ {Config: Config{Excludes: []string{"/foo/**"}}, Path: "/foo/bar", Info: mockInfoDir("bar"), Expected: filepath.SkipDir},
		/*2*/ {Config: Config{Excludes: []string{"/foo/**"}}, Path: "/foo/bar/baz.jpg", Info: mockInfoFile("baz.jpg"), Expected: ErrWalkSkip},
		/*3*/ {Config: Config{Includes: []string{"/foo/bar/*.jpg"}}, Path: "/foo/bar/baz.jpg", Info: mockInfoFile("baz.jpg"), Expected: nil},
		/*4*/ {Config: Config{Excludes: []string{}, Includes: []string{}}, Path: "/foo/bar/baz.jpg", Info: mockInfoFile("baz.jpg"), Expected: ErrWalkSkip},
		/*5*/ {Config: Config{}, Path: "/foo/bar/baz.jpg", Info: mockInfoFile("baz.jpg"), Expected: nil},
		/*6*/ {Config: Config{}, Path: "/foo/bar/baz.jpg", Info: mockInfoDir("baz"), Expected: ErrWalkSkip},
	}

	for index, tc := range testCases {
		c := Copyright{Config: tc.Config}
		assert.ItsEqual(t, tc.Expected, c.includeOrExclude(".", tc.Path, tc.Info), fmt.Sprintf("test %d", index))
	}
}

const (
	tsFile0 = `import * as axios from 'axios';`
	tsFile1 = `/// <reference path="../types/testing.d.ts" />
/// <reference path="../types/something.d.ts" />
/// <reference path="../types/somethingElse.d.ts" />
/// <reference path="../types/somethingMore.d.ts" />
/// <reference path="../types/somethingLess.d.ts" />

	import * as axios from 'axios';
`

	pyFile0 = `from __future__ import print_function
	
		import logging
		import os
		import shutil
		import sys
		import requests
		import uuid
		import json`

	goFile0 = `// +build tools
		package tools
		
		import (
			// goimports organizes imports for us
			_ "golang.org/x/tools/cmd/goimports"
		
			// golint is an opinionated linter
			_ "golang.org/x/lint/golint"
		
			// ineffassign is an opinionated linter
			_ "github.com/gordonklaus/ineffassign"
		
			// staticcheck is ineffassign but better
			_ "honnef.co/go/tools/cmd/staticcheck"
		)
		`
)

func Test_Copyright_Walk(t *testing.T) {
	tempDir, revert := createTestFS(t)
	defer revert()

	c := &Copyright{
		Config: Config{
			CopyrightHolder: string(testCopyrightHolder),
			Includes:        []string{"*.py", "*.ts"},
			Excludes:        []string{"*/not-bar/*", "*/not-foo/*"},
		},
	}

	var err error
	var seen []string
	err = c.Walk(context.TODO(), func(path string, info os.FileInfo, file, notice []byte) error {
		seen = append(seen, path)
		return nil
	}, tempDir)
	assert.ItsNil(t, err)
	expected := []string{
		filepath.Join(tempDir, "bar", "foo", "file0.py"),
		filepath.Join(tempDir, "bar", "foo", "file0.ts"),
		filepath.Join(tempDir, "bar", "foo", "file1.ts"),
		filepath.Join(tempDir, "file0.py"),
		filepath.Join(tempDir, "file0.ts"),
		filepath.Join(tempDir, "file1.ts"),
		filepath.Join(tempDir, "foo", "bar", "file0.py"),
		filepath.Join(tempDir, "foo", "bar", "file0.ts"),
		filepath.Join(tempDir, "foo", "bar", "file1.ts"),
	}
	assert.ItsEqual(t, expected, seen)
}

func Test_Copyright_Walk_noExitFirst(t *testing.T) {
	tempDir, revert := createTestFS(t)
	defer revert()

	c := &Copyright{
		Config: Config{
			CopyrightHolder: string(testCopyrightHolder),
			Includes:        []string{"*.py", "*.ts"},
			Excludes:        []string{"*/not-bar/*", "*/not-foo/*"},
			ExitFirst:       false,
		},
	}

	var err error
	var seen []string
	err = c.Walk(context.TODO(), func(path string, info os.FileInfo, file, notice []byte) error {
		seen = append(seen, path)
		if len(seen) > 0 {
			return ErrFailure
		}
		return nil
	}, tempDir)
	assert.ItsNotNil(t, err)
	expected := []string{
		filepath.Join(tempDir, "bar", "foo", "file0.py"),
		filepath.Join(tempDir, "bar", "foo", "file0.ts"),
		filepath.Join(tempDir, "bar", "foo", "file1.ts"),
		filepath.Join(tempDir, "file0.py"),
		filepath.Join(tempDir, "file0.ts"),
		filepath.Join(tempDir, "file1.ts"),
		filepath.Join(tempDir, "foo", "bar", "file0.py"),
		filepath.Join(tempDir, "foo", "bar", "file0.ts"),
		filepath.Join(tempDir, "foo", "bar", "file1.ts"),
	}
	assert.ItsEqual(t, expected, seen)
}

func Test_Copyright_Walk_exitFirst(t *testing.T) {
	tempDir, revert := createTestFS(t)
	defer revert()

	c := &Copyright{
		Config: Config{
			CopyrightHolder: string(testCopyrightHolder),
			Includes:        []string{"*.py", "*.ts"},
			Excludes:        []string{"*/not-bar/*", "*/not-foo/*"},
			ExitFirst:       true,
		},
	}

	var err error
	var seen []string
	err = c.Walk(context.TODO(), func(path string, info os.FileInfo, file, notice []byte) error {
		seen = append(seen, path)
		if len(seen) > 0 {
			return ErrFailure
		}
		return nil
	}, tempDir)
	assert.ItsNotNil(t, err)
	expected := []string{
		filepath.Join(tempDir, "bar", "foo", "file0.py"),
	}
	assert.ItsEqual(t, expected, seen)
}

func Test_Copyright_Inject(t *testing.T) {
	tempDir, revert := createTestFS(t)
	defer revert()

	c := &Copyright{
		Config: Config{
			CopyrightHolder: string(testCopyrightHolder),
			Includes:        []string{"*.py", "*.ts", "*.go"},
			Excludes:        []string{"*/not-bar/*", "*/not-foo/*"},
		},
	}

	err := c.Inject(context.TODO(), tempDir)
	assert.ItsNil(t, err)

	contents, err := os.ReadFile(filepath.Join(tempDir, "bar", "foo", "file0.py"))
	assert.ItsNil(t, err)
	assert.ItHasPrefix(t, string(contents), "#\n# Copyright")

	contents, err = os.ReadFile(filepath.Join(tempDir, "bar", "foo", "file0.ts"))
	assert.ItsNil(t, err)
	assert.ItHasPrefix(t, string(contents), "/**\n * Copyright")
}

func Test_Copyright_Inject_Shebang(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "copyright_test")
	assert.ItsNil(t, err)
	t.Cleanup(func() { os.RemoveAll(tempDir) })

	// Write `shift.py` without
	contents := strings.Join([]string{
		"\r\t",
		"  #!/usr/bin/env python",
		"",
		"def main():",
		`    print("Hello world")`,
		"",
		"",
		`if __name__ == "__main__":`,
		"    main()",
		"",
	}, "\n")
	filename := filepath.Join(tempDir, "shift.py")
	err = os.WriteFile(filename, []byte(contents), 0755)
	assert.ItsNil(t, err)

	// Actually inject
	c := &Copyright{
		Config: Config{
			Year:                 2021,
			CopyrightHolder:      string(testCopyrightHolder),
			Includes:             []string{"*shift.py"},
			RestrictionsTemplate: DefaultRestrictionsTemplateInternal,
		},
	}
	err = c.Inject(context.TODO(), tempDir)
	assert.ItsNil(t, err)

	// Verify injected contents are as expected
	contentInjected, err := os.ReadFile(filename)
	assert.ItsNil(t, err)
	expected := strings.Join([]string{
		"\r\t",
		"  #!/usr/bin/env python",
		"#",
		"# " + expectedNoticePrefix(t),
		"# " + mustRenderTemplate(DefaultRestrictionsTemplateInternal, testCopyrightHolder),
		"#",
		"",
		"",
		"def main():",
		`    print("Hello world")`,
		"",
		"",
		`if __name__ == "__main__":`,
		"    main()",
		"",
	}, "\n")
	assert.ItsEqual(t, expected, string(contentInjected))

	// Verify no-op if notice header is already present
	err = c.Inject(context.TODO(), tempDir)
	assert.ItsNil(t, err)
	contentInjected, err = os.ReadFile(filename)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, expected, string(contentInjected))
}

func Test_Copyright_Verify(t *testing.T) {
	tempDir, revert := createTestFS(t)
	defer revert()

	c := &Copyright{
		Config: Config{
			CopyrightHolder: string(testCopyrightHolder),
			Includes:        []string{"*.py", "*.ts", "*.go"},
			Excludes:        []string{"*/not-bar/*", "*/not-foo/*"},
		},
	}
	c.Stdout = new(bytes.Buffer)
	c.Stderr = new(bytes.Buffer)

	err := c.Verify(context.TODO(), tempDir)
	assert.ItsNotNil(t, err, "we must record a failure from walking the test fs")

	err = c.Inject(context.TODO(), tempDir)
	assert.ItsNil(t, err)

	err = c.Verify(context.TODO(), tempDir)
	assert.ItsNil(t, err)
}

func Test_Copyright_Verify_Shebang(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "copyright_test")
	assert.ItsNil(t, err)
	t.Cleanup(func() { os.RemoveAll(tempDir) })

	// Write `shift.py` already injected
	contents := strings.Join([]string{
		"#!/usr/bin/env python",
		"#",
		"# " + expectedNoticePrefix(t),
		"# " + mustRenderTemplate(DefaultRestrictionsTemplateInternal, testCopyrightHolder),
		"#",
		"",
		"",
		"def main():",
		`    print("Hello world")`,
		"",
		"",
		`if __name__ == "__main__":`,
		"    main()",
		"",
	}, "\n")
	filename := filepath.Join(tempDir, "shift.py")
	err = os.WriteFile(filename, []byte(contents), 0755)
	assert.ItsNil(t, err)

	// Verify present
	cfg := Config{
		CopyrightHolder:      string(testCopyrightHolder),
		Includes:             []string{"*shift.py"},
		Quiet:                true,
		RestrictionsTemplate: DefaultRestrictionsTemplateInternal,
		ShowDiff:             false,
		Year:                 2021,
	}
	c := &Copyright{Config: cfg}
	err = c.Verify(context.TODO(), tempDir)
	assert.ItsNil(t, err)

	// Write without and fail
	contents = strings.Join([]string{
		"#!/usr/bin/env python",
		"def main():",
		`    print("Hello world")`,
		"",
		"",
		`if __name__ == "__main__":`,
		"    main()",
		"",
	}, "\n")
	err = os.WriteFile(filename, []byte(contents), 0755)
	assert.ItsNil(t, err)
	err = c.Verify(context.TODO(), tempDir)
	assert.ItsEqual(t, "failure; one or more steps failed", fmt.Sprintf("%v", err))
}

func Test_Copyright_Remove(t *testing.T) {
	tempDir, revert := createTestFS(t)
	defer revert()

	c := &Copyright{
		Config: Config{
			CopyrightHolder: string(testCopyrightHolder),
			Includes:        []string{"*.py", "*.ts", "*.go"},
			Excludes:        []string{"*/not-bar/*", "*/not-foo/*"},
		},
	}
	c.Stdout = new(bytes.Buffer)
	c.Stderr = new(bytes.Buffer)

	err := c.Inject(context.TODO(), tempDir)
	assert.ItsNil(t, err)

	err = c.Verify(context.TODO(), tempDir)
	assert.ItsNil(t, err)

	err = c.Remove(context.TODO(), tempDir)
	assert.ItsNil(t, err)

	err = c.Verify(context.TODO(), tempDir)
	assert.ItsNotNil(t, err)
}

func Test_Copyright_Remove_Shebang(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "copyright_test")
	assert.ItsNil(t, err)
	t.Cleanup(func() { os.RemoveAll(tempDir) })

	// Write `shift.py` already injected
	contents := strings.Join([]string{
		"#!/usr/bin/env python",
		"#",
		"# " + expectedNoticePrefix(t),
		"# " + mustRenderTemplate(DefaultRestrictionsTemplateInternal, testCopyrightHolder),
		"#",
		"",
		"",
		"def main():",
		`    print("Hello world")`,
		"",
		"",
		`if __name__ == "__main__":`,
		"    main()",
		"",
	}, "\n")
	filename := filepath.Join(tempDir, "shift.py")
	err = os.WriteFile(filename, []byte(contents), 0755)
	assert.ItsNil(t, err)

	// Actually remove
	c := &Copyright{
		Config: Config{
			Year:                 2021,
			CopyrightHolder:      string(testCopyrightHolder),
			Includes:             []string{"*shift.py"},
			RestrictionsTemplate: DefaultRestrictionsTemplateInternal,
		},
	}
	err = c.Remove(context.TODO(), tempDir)
	assert.ItsNil(t, err)

	// Verify removed contents are as expected
	contentRemoved, err := os.ReadFile(filename)
	assert.ItsNil(t, err)
	expected := strings.Join([]string{
		"#!/usr/bin/env python",
		"def main():",
		`    print("Hello world")`,
		"",
		"",
		`if __name__ == "__main__":`,
		"    main()",
		"",
	}, "\n")
	assert.ItsEqual(t, expected, string(contentRemoved))

	// Verify no-op if notice header is already removed
	err = c.Remove(context.TODO(), tempDir)
	assert.ItsNil(t, err)
	contentRemoved, err = os.ReadFile(filename)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, expected, string(contentRemoved))
}

func Test_Copyright_Walk_singleFileRoot(t *testing.T) {
	tempDir, revert := createTestFS(t)
	defer revert()

	c := Copyright{
		Config: Config{
			CopyrightHolder: string(testCopyrightHolder),
			Includes:        []string{"*.py", "*.ts"},
			Excludes:        []string{"*/not-bar/*", "*/not-foo/*"},
		},
	}

	var err error
	var seen []string
	err = c.Walk(context.TODO(), func(path string, info os.FileInfo, file, notice []byte) error {
		seen = append(seen, path)
		return nil
	}, filepath.Join(tempDir, "file0.py"))
	assert.ItsNil(t, err)
	expected := []string{
		filepath.Join(tempDir, "file0.py"),
	}
	assert.ItsEqual(t, expected, seen)
}

func expectedNoticePrefix(t *testing.T) string {
	vars := map[string]string{
		"Year":            "2021",
		"CopyrightHolder": string(testCopyrightHolder),
	}
	tmpl := template.New("output")
	_, err := tmpl.Parse(DefaultNoticeTemplate)
	assert.ItsNil(t, err)
	prefixBuffer := new(bytes.Buffer)
	err = tmpl.Execute(prefixBuffer, vars)
	assert.ItsNil(t, err)
	return strings.TrimRight(prefixBuffer.String(), "\n")
}