go.fuchsia.dev/infra@v0.0.0-20240507153436-9b593402251b/cmd/submodule_update/submodule/submodule_test.go

// Copyright 2024 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package submodule

import (
	"fmt"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	"testing"

	"github.com/google/go-cmp/cmp"
	"go.fuchsia.dev/infra/cmd/submodule_update/gitutil"
)

// createTestdataTemp copies the testdata to a temp folder compatible with git.
func createTestdataTemp(t *testing.T) (string, error) {
	t.Helper()
	uniqTempDir := t.TempDir()
	fromPath := "../testdata"
	if err := exec.Command("cp", "-R", fromPath, uniqTempDir).Run(); err != nil {
		t.Fatalf("Error copying from %s to %s (%q)", fromPath, uniqTempDir, err)
		return "", err
	}
	return uniqTempDir, nil
}

// createSuperproject clones the testdata superproject to a temp directory.
func createSuperproject(t *testing.T, recurseSubmodules bool) (g *gitutil.Git, err error) {
	t.Helper()
	superprojectRemoteTemp, err := createTestdataTemp(t)
	if err != nil {
		t.Fatalf("Failed to create superproject remote temp dir: %s", err)
		return nil, err
	}

	superprojectRoot := t.TempDir()
	scm := gitutil.New(gitutil.RootDirOpt(superprojectRoot))
	repo := filepath.Join(superprojectRemoteTemp, "testdata", "remote", "super")
	if err := scm.Clone(repo, superprojectRoot, gitutil.RecurseSubmodulesOpt(recurseSubmodules)); err != nil {
		t.Fatalf("Failed to clone superproject: %s", err)
		return nil, err
	}

	gitConfig := map[string]string{
		// Allow cloning local repos, since this is required for tests that use
		// this mock data.
		"protocol.file.allow": "always",
	}
	t.Setenv("GIT_CONFIG_COUNT", strconv.Itoa(len(gitConfig)))
	i := 0
	for k, v := range gitConfig {
		t.Setenv(fmt.Sprintf("GIT_CONFIG_KEY_%d", i), k)
		t.Setenv(fmt.Sprintf("GIT_CONFIG_VALUE_%d", i), v)
		i++
	}

	return scm, nil
}

func createSubmodules(t *testing.T, submodules map[string]string) Submodules {
	t.Helper()
	var subModules = Submodules{}
	for subPath, rev := range submodules {
		subM := Submodule{
			Name:     subPath,
			Path:     subPath,
			Revision: rev,
			// For testing, fake the remote
			Remote: filepath.Join("remote", subPath),
		}
		subModules[subM.Key()] = subM
	}
	return subModules
}

func getSubmodules(t *testing.T, g *gitutil.Git, cached bool) Submodules {
	t.Helper()
	gitSubmodules, err := gitSubmodules(g, cached)
	if err != nil {
		t.Fatalf("Git submodules creation failed: %s", err)
	}
	return gitSubmodules
}

func TestSubmoduleDiff(t *testing.T) {
	initialSub := createSubmodules(t, map[string]string{"sub1": "12345a", "sub2": "12345b"})
	// Change remote for "sub1" to "sub1_new_remote"
	remoteChangeSub := createSubmodules(t, map[string]string{"sub1": "12345a", "sub2": "12345b"})
	remoteSub1 := remoteChangeSub[Key("sub1")]
	remoteSub1.Remote = path.Join("new", "remote", "sub1")
	remoteChangeSub[Key("sub1")] = remoteSub1

	type diffTest struct {
		name           string
		gitSubmodules  Submodules
		jiriSubmodules Submodules
		want           Diff
	}
	testCases := []diffTest{
		{
			name:           "no diff",
			gitSubmodules:  initialSub,
			jiriSubmodules: initialSub,
			want:           Diff{},
		},
		{
			name:          "add sub3",
			gitSubmodules: initialSub,
			jiriSubmodules: createSubmodules(t, map[string]string{
				"sub1": "12345a",
				"sub2": "12345b",
				"sub3": "12345c",
			}),
			want: Diff{
				NewSubmodules: []DiffSubmodule{{
					Name:     "sub3",
					Path:     "sub3",
					Revision: "12345c",
					Remote:   path.Join("remote", "sub3"),
				}},
			},
		},
		{
			name:          "delete sub1",
			gitSubmodules: initialSub,
			jiriSubmodules: createSubmodules(t, map[string]string{
				"sub2": "12345b",
			}),
			want: Diff{
				DeletedSubmodules: []DiffSubmodule{{
					Path:     "sub1",
					Revision: "12345a",
					Remote:   path.Join("remote", "sub1")}},
			},
		},
		{
			name: "don't delete nameless submodule",
			gitSubmodules: func() Submodules {
				submodules := createSubmodules(t, map[string]string{
					"sub1":     "12345a",
					"nameless": "12345b",
				})
				subm := submodules[Key("nameless")]
				subm.Name = ""
				submodules[Key("nameless")] = subm
				return submodules
			}(),
			jiriSubmodules: createSubmodules(t, map[string]string{
				"sub1": "12345a",
			}),
			want: Diff{},
		},
		{
			name:          "update sub1 (new revision)",
			gitSubmodules: initialSub,
			jiriSubmodules: createSubmodules(t, map[string]string{
				"sub1": "12346a",
				"sub2": "12345b",
			}),
			want: Diff{
				UpdatedSubmodules: []DiffSubmodule{{
					Name:        "sub1",
					Path:        "sub1",
					Revision:    "12346a",
					OldRevision: "12345a",
				}},
			},
		},
		{
			// Processed as a delete (old path) and a new submodule (new path).
			name:          "move sub1 (change path)",
			gitSubmodules: initialSub,
			jiriSubmodules: createSubmodules(t, map[string]string{
				"sub3": "12345a",
				"sub2": "12345b",
			}),
			want: Diff{
				NewSubmodules: []DiffSubmodule{{
					Name:     "sub3",
					Path:     "sub3",
					Revision: "12345a",
					Remote:   path.Join("remote", "sub3")}},
				DeletedSubmodules: []DiffSubmodule{{
					Path:     "sub1",
					Revision: "12345a",
					Remote:   path.Join("remote", "sub1")}},
			},
		},
		{
			// Processed as a delete (old remote) and a new submodule (new remote)
			name:           "move sub1 (change remote)",
			gitSubmodules:  initialSub,
			jiriSubmodules: remoteChangeSub,
			want: Diff{
				NewSubmodules: []DiffSubmodule{{
					Name:     "sub1",
					Path:     "sub1",
					Revision: "12345a",
					Remote:   path.Join("new", "remote", "sub1")}},
				DeletedSubmodules: []DiffSubmodule{{
					Path:     "sub1",
					Revision: "12345a",
					Remote:   path.Join("remote", "sub1")}},
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			got, err := getDiff(tc.gitSubmodules, tc.jiriSubmodules)
			if err != nil {
				t.Fatalf("GetDiff failed with: %s", err)
			}

			if diff := cmp.Diff(tc.want, got); diff != "" {
				t.Errorf("GetDiff failed (-want +got):\n%s", diff)
			}
		})
	}
}

func TestUpdateCommitMessage(t *testing.T) {
	type msgTest struct {
		message string
		want    string
	}
	testCases := []msgTest{
		// No [roll]
		{
			message: "Hello\nworld",
			want:    "Hello\nworld",
		},
		// [roll] not at start
		{
			message: "Hello\nworld [roll] ",
			want:    "Hello\nworld [roll] ",
		},
		// [roll] at start
		{
			message: "[roll] Hello\nworld",
			want:    "[superproject] Hello\nworld",
		},
	}
	for _, tc := range testCases {
		got := updateCommitMessage(tc.message)
		if diff := cmp.Diff(tc.want, got); diff != "" {
			t.Errorf("updateCommitMessage failed (-want +got):\n%s", diff)
		}
	}
}

var gitSHA1Re = regexp.MustCompile(`^[0-9a-f]{40}$`)

func TestSubmoduleStatusParsing(t *testing.T) {
	gitSuperproject, err := createSuperproject(t, false)
	if err != nil {
		t.Fatalf("Git superproject creation failed: %s", err)
	}

	gitSubmodules := getSubmodules(t, gitSuperproject, true)

	expected := []Submodule{
		{
			Name:     "sub1",
			Revision: "rev1",
			Path:     "sub1",
			Remote:   "../sub1/",
		},
		{
			Name:     "sub2",
			Revision: "rev2",
			Path:     "sub2",
			Remote:   "../sub2/",
		},
	}
	for _, subM := range expected {
		if submodule, ok := gitSubmodules[Key(subM.Path)]; ok {
			if subM.Remote != submodule.Remote {
				t.Errorf("Remote (%s) didn't match expected %s", submodule.Remote, subM.Remote)
			}
			if !gitSHA1Re.MatchString(submodule.Revision) {
				t.Errorf("Revision (%s) didn't match SHA1 regex", submodule.Revision)
			}
		} else {
			t.Errorf("Expected submodule %s missing", subM.Path)
		}
	}
}

func TestJiriProjectParsing(t *testing.T) {
	jiriProjectsPath := filepath.Join("..", "testdata", "jiri_projects_public.json")

	jiriSubmodules, err := jiriProjectsToSubmodule(jiriProjectsPath)
	if err != nil {
		t.Fatalf("Jiri project parsing failed: %s", err)
	}
	expectedPaths := []string{"sub1", "sub2"}
	for _, path := range expectedPaths {
		if submodule, ok := jiriSubmodules[Key(path)]; ok {
			if !gitSHA1Re.MatchString(submodule.Revision) {
				t.Errorf("Revision (%s) didn't match SHA1 regex", submodule.Revision)
			}
			if submodule.Remote == "" {
				t.Errorf("Expected remote for submodule %s not present", submodule.Path)
			}
		} else {
			t.Errorf("Expected submodule %s missing", path)
		}
	}
}

func TestUpdateSubmodules(t *testing.T) {
	subPath := "sub1"
	wantRev := "4c473777b21946176bc7d157d195a29c108da6c6"
	gitSuperproject, err := createSuperproject(t, false)
	if err != nil {
		t.Fatalf("Failed to create superproject: %s", err)
	}
	diff := []DiffSubmodule{{
		Path:     subPath,
		Revision: wantRev,
	}}
	if err := updateSubmodules(gitSuperproject, diff, gitSuperproject.RootDir()); err != nil {
		cmd := exec.Command("tree", gitSuperproject.RootDir())
		cmd.Stdout = os.Stdout
		if e := cmd.Run(); e != nil {
			t.Fatal(e)
		}
		t.Fatalf("Failed to update submodules: %s", err)
	}
	gitSubmodules := getSubmodules(t, gitSuperproject, false)
	gotRev := gitSubmodules[Key(subPath)].Revision
	if gotRev != wantRev {
		t.Errorf("Expected %s for submodule revision, got %s", wantRev, gotRev)
	}
}

func TestUpdateSubmodulesEmpty(t *testing.T) {
	gitSuperproject, err := createSuperproject(t, false)
	if err != nil {
		t.Fatalf("Failed to create superproject: %s", err)
	}
	want := getSubmodules(t, gitSuperproject, false)
	diff := Diff{}
	if err := updateSubmodules(gitSuperproject, diff.UpdatedSubmodules, "tmp/superproject"); err != nil {
		t.Fatalf("Failed to update submodules: %s", err)
	}
	got := getSubmodules(t, gitSuperproject, false)
	if diff := cmp.Diff(want, got); diff != "" {
		t.Errorf("Submodule status changed (-want +got):\n%s", diff)
	}
}

func TestDeleteSubmodules(t *testing.T) {
	subPath := "sub1"
	gitSuperproject, err := createSuperproject(t, false)
	if err != nil {
		t.Fatalf("Failed to create superproject: %s", err)
	}
	diff := []DiffSubmodule{{
		Path: subPath,
	}}
	if err := deleteSubmodules(gitSuperproject, diff); err != nil {
		t.Fatalf("Failed to delete submodules: %s", err)
	}
	gitSubmodules := getSubmodules(t, gitSuperproject, false)
	if _, ok := gitSubmodules[Key(subPath)]; ok {
		t.Errorf("Submodule %s still present, expected it to be removed", subPath)
	}
}

func TestDeleteSubmodulesEmpty(t *testing.T) {
	gitSuperproject, err := createSuperproject(t, false)
	if err != nil {
		t.Fatalf("Failed to create superproject: %s", err)
	}
	want := getSubmodules(t, gitSuperproject, false)
	diff := Diff{}
	if err := deleteSubmodules(gitSuperproject, diff.DeletedSubmodules); err != nil {
		t.Fatalf("Failed to delete submodules: %s", err)
	}
	got := getSubmodules(t, gitSuperproject, false)
	if diff := cmp.Diff(want, got); diff != "" {
		t.Errorf("Submodule status changed (-want +got):\n%s", diff)
	}
}

func TestAddSubmodules(t *testing.T) {
	subPath := "sub3"
	gitSuperproject, err := createSuperproject(t, false)
	if err != nil {
		t.Fatalf("Failed to create superproject: %s", err)
	}
	testdataTemp, err := createTestdataTemp(t)
	if err != nil {
		t.Fatalf("Failed to create temp testdata dir: %s", err)
	}
	remotePath := filepath.Join(testdataTemp, "testdata", "remote", "sub3")
	diff := []DiffSubmodule{{
		Path:     subPath,
		Remote:   remotePath,
		Revision: "b6c817cd8a01b209f3b4f89cb55816f4173bbf4e",
	}}
	if err := addSubmodules(gitSuperproject, diff); err != nil {
		t.Fatalf("Failed to add submodules: %s", err)
	}
	gitSubmodules := getSubmodules(t, gitSuperproject, false)
	if _, ok := gitSubmodules[Key(subPath)]; !ok {
		t.Errorf("Submodule %s not present, expected it to be added", subPath)
	}
}

func TestAddSubmodulesEmpty(t *testing.T) {
	gitSuperproject, err := createSuperproject(t, false)
	if err != nil {
		t.Fatalf("Failed to create superproject: %s", err)
	}
	want := getSubmodules(t, gitSuperproject, false)
	diff := Diff{}
	if err := addSubmodules(gitSuperproject, diff.NewSubmodules); err != nil {
		t.Fatalf("Failed to add submodules: %s", err)
	}
	got := getSubmodules(t, gitSuperproject, false)
	if diff := cmp.Diff(want, got); diff != "" {
		t.Errorf("Submodule status changed (-want +got):\n%s", diff)
	}
}

func TestCopyFile(t *testing.T) {
	srcPath := "../testdata/ensure/cipd.ensure"
	tempDir := t.TempDir()
	dstPath := filepath.Join(tempDir, "copytest")

	// Test new file creation
	if err := copyFile(srcPath, dstPath); err != nil {
		t.Fatalf("Failed to copy file: %s", err)
	}
	srcData, err := os.ReadFile(srcPath)
	if err != nil {
		t.Fatalf("Failed to read source file: %s", err)
	}
	dstData, err := os.ReadFile(dstPath)
	if err != nil {
		t.Fatalf("Failed to read destination file: %s", err)
	}
	if diff := cmp.Diff(string(srcData), string(dstData)); diff != "" {
		t.Errorf("CopyFile to new file failed (-want +got):\n%s", diff)
	}

	// Test truncate/overwrite existing file
	srcPath = "../testdata/ensure/cipd_internal.ensure"
	if err = copyFile(srcPath, dstPath); err != nil {
		t.Fatalf("Failed to copy file: %s", err)
	}
	srcData, err = os.ReadFile(srcPath)
	if err != nil {
		t.Fatalf("Failed to read source file: %s", err)
	}
	dstData, err = os.ReadFile(dstPath)
	if err != nil {
		t.Fatalf("Failed to read destination file: %s", err)
	}
	if diff := cmp.Diff(string(srcData), string(dstData)); diff != "" {
		t.Errorf("CopyFile overwrite file failed (-want +got):\n%s", diff)
	}
}

func TestCopyCIPDEnsure(t *testing.T) {
	ensurePath := "../testdata/ensure/"
	cipdPaths := map[string]string{
		"ensure":          filepath.Join(ensurePath, "cipd.ensure"),
		"internalEnsure":  filepath.Join(ensurePath, "cipd_internal.ensure"),
		"internalVersion": filepath.Join(ensurePath, "cipd_internal.version"),
		"version":         filepath.Join(ensurePath, "cipd.version"),
	}
	gitSuperproject, err := createSuperproject(t, false)
	if err != nil {
		t.Fatalf("Failed to create superproject: %s", err)
	}
	cipdPath := filepath.Join(gitSuperproject.RootDir(), "tools", "superproject")
	err = copyCIPDEnsureToSuperproject(cipdPaths, cipdPath)
	if err != nil {
		t.Fatalf("Failed to copy ensure files: %s", err)
	}
	ensureFileList := []string{filepath.Join(cipdPath, path.Base(cipdPaths["ensure"])), filepath.Join(cipdPath, path.Base(cipdPaths["internalEnsure"]))}
	versionFileList := []string{filepath.Join(cipdPath, path.Base(cipdPaths["version"])), filepath.Join(cipdPath, path.Base(cipdPaths["internalVersion"]))}
	for _, dstPath := range ensureFileList {
		dstDataBytes, err := os.ReadFile(dstPath)
		if err != nil {
			t.Fatalf("Failed to read destination file: %s", err)
		}
		dstData := string(dstDataBytes)
		if !strings.HasSuffix(dstData, "Ensure updated\n") {
			t.Fatalf("Ensure file not updated.")
		}
	}
	for _, dstPath := range versionFileList {
		dstDataBytes, err := os.ReadFile(dstPath)
		if err != nil {
			t.Fatalf("Failed to read destination file: %s", err)
		}
		dstData := string(dstDataBytes)
		if !strings.HasSuffix(dstData, "Version updated\n") {
			t.Fatalf("Version file not updated.")
		}
	}

}

// TODO(olivernewman): Re-enable these tests (or find another way to provide test-coverage)
// This would require generating a jiri projects input file to match the remotes to the superproject temp directory
// because remotes are considered in determining new/deleted/updated submodules.

/*
func TestUpdateSuperprojectRunsNoRecurse(t *testing.T) {
	gitSuperproject, err := createSuperproject(t, false)
	if err != nil {
		t.Fatalf("Failed to create superproject: %s", err)
	}
	jiriProjectsPath := "../testdata/jiri_projects_public.json"
	outputPath := t.TempDir()
	outputJSONPath := filepath.Join(outputPath, "json_output.json")
	message := "Commit Message"
	UpdateSuperproject(gitSuperproject, message, jiriProjectsPath, outputJSONPath)
}

func TestUpdateSuperprojectRunsWithRecurse(t *testing.T) {
	gitSuperproject, err := createSuperproject(t, true)
	if err != nil {
		t.Fatalf("Failed to create superproject: %s", err)
	}
	jiriProjectsPath := "../testdata/jiri_projects_public.json"
	outputPath := t.TempDir()
	outputJSONPath := filepath.Join(outputPath, "json_output.json")
	message := "Commit Message"
	UpdateSuperproject(gitSuperproject, message, jiriProjectsPath, outputJSONPath)
}
*/