github.com/golang/dep@v0.5.4/internal/feedback/lockdiff_test.go

// Copyright 2017 The Go 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 feedback

import (
	"bytes"
	"testing"

	"github.com/golang/dep/gps"
)

// mkPI creates a ProjectIdentifier with the ProjectRoot as the provided
// string, and the Source unset.
//
// Call normalize() on the returned value if you need the Source to be be
// equal to the ProjectRoot.
func mkPI(root string) gps.ProjectIdentifier {
	return gps.ProjectIdentifier{
		ProjectRoot: gps.ProjectRoot(root),
	}
}

func TestStringDiff_NoChange(t *testing.T) {
	diff := StringDiff{Previous: "foo", Current: "foo"}
	want := "foo"
	got := diff.String()
	if got != want {
		t.Fatalf("Expected '%s', got '%s'", want, got)
	}
}

func TestStringDiff_Add(t *testing.T) {
	diff := StringDiff{Current: "foo"}
	got := diff.String()
	if got != "+ foo" {
		t.Fatalf("Expected '+ foo', got '%s'", got)
	}
}

func TestStringDiff_Remove(t *testing.T) {
	diff := StringDiff{Previous: "foo"}
	want := "- foo"
	got := diff.String()
	if got != want {
		t.Fatalf("Expected '%s', got '%s'", want, got)
	}
}

func TestStringDiff_Modify(t *testing.T) {
	diff := StringDiff{Previous: "foo", Current: "bar"}
	want := "foo -> bar"
	got := diff.String()
	if got != want {
		t.Fatalf("Expected '%s', got '%s'", want, got)
	}
}

func TestDiffProjects_NoChange(t *testing.T) {
	p1 := gps.NewLockedProject(mkPI("github.com/golang/dep/gps"), gps.NewVersion("v0.10.0"), []string{"gps"})
	p2 := gps.NewLockedProject(mkPI("github.com/golang/dep/gps"), gps.NewVersion("v0.10.0"), []string{"gps"})

	diff := DiffProjects(p1, p2)
	if diff != nil {
		t.Fatal("Expected the diff to be nil")
	}
}

func TestDiffProjects_Modify(t *testing.T) {
	p1 := gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewBranch("master").Pair("abc123"), []string{"baz", "qux"})
	p2 := gps.NewLockedProject(gps.ProjectIdentifier{ProjectRoot: "github.com/foo/bar", Source: "https://github.com/mcfork/gps.git"},
		gps.NewVersion("v1.0.0").Pair("def456"), []string{"baz", "derp"})

	diff := DiffProjects(p1, p2)
	if diff == nil {
		t.Fatal("Expected the diff to be populated")
	}

	wantSource := "+ https://github.com/mcfork/gps.git"
	gotSource := diff.Source.String()
	if gotSource != wantSource {
		t.Fatalf("Expected diff.Source to be '%s', got '%s'", wantSource, diff.Source)
	}

	wantVersion := "+ v1.0.0"
	gotVersion := diff.Version.String()
	if gotVersion != wantVersion {
		t.Fatalf("Expected diff.Version to be '%s', got '%s'", wantVersion, gotVersion)
	}

	wantRevision := "abc123 -> def456"
	gotRevision := diff.Revision.String()
	if gotRevision != wantRevision {
		t.Fatalf("Expected diff.Revision to be '%s', got '%s'", wantRevision, gotRevision)
	}

	wantBranch := "- master"
	gotBranch := diff.Branch.String()
	if gotBranch != wantBranch {
		t.Fatalf("Expected diff.Branch to be '%s', got '%s'", wantBranch, gotBranch)
	}

	fmtPkgs := func(pkgs []StringDiff) string {
		b := bytes.NewBufferString("[")
		for _, pkg := range pkgs {
			b.WriteString(pkg.String())
			b.WriteString(",")
		}
		b.WriteString("]")
		return b.String()
	}

	wantPackages := "[+ derp,- qux,]"
	gotPackages := fmtPkgs(diff.Packages)
	if gotPackages != wantPackages {
		t.Fatalf("Expected diff.Packages to be '%s', got '%s'", wantPackages, gotPackages)
	}
}

func TestDiffProjects_AddPackages(t *testing.T) {
	p1 := gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewBranch("master").Pair("abc123"), []string{"foobar"})
	p2 := gps.NewLockedProject(gps.ProjectIdentifier{ProjectRoot: "github.com/foo/bar", Source: "https://github.com/mcfork/gps.git"},
		gps.NewVersion("v1.0.0").Pair("def456"), []string{"bazqux", "foobar", "zugzug"})

	diff := DiffProjects(p1, p2)
	if diff == nil {
		t.Fatal("Expected the diff to be populated")
	}

	if len(diff.Packages) != 2 {
		t.Fatalf("Expected diff.Packages to have 2 packages, got %d", len(diff.Packages))
	}

	want0 := "+ bazqux"
	got0 := diff.Packages[0].String()
	if got0 != want0 {
		t.Fatalf("Expected diff.Packages[0] to contain %s, got %s", want0, got0)
	}

	want1 := "+ zugzug"
	got1 := diff.Packages[1].String()
	if got1 != want1 {
		t.Fatalf("Expected diff.Packages[1] to contain %s, got %s", want1, got1)
	}
}

func TestDiffProjects_RemovePackages(t *testing.T) {
	p1 := gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewBranch("master").Pair("abc123"), []string{"athing", "foobar"})
	p2 := gps.NewLockedProject(gps.ProjectIdentifier{ProjectRoot: "github.com/foo/bar", Source: "https://github.com/mcfork/gps.git"},
		gps.NewVersion("v1.0.0").Pair("def456"), []string{"bazqux"})

	diff := DiffProjects(p1, p2)
	if diff == nil {
		t.Fatal("Expected the diff to be populated")
	}

	if len(diff.Packages) > 3 {
		t.Fatalf("Expected diff.Packages to have 3 packages, got %d", len(diff.Packages))
	}

	want0 := "- athing"
	got0 := diff.Packages[0].String()
	if got0 != want0 {
		t.Fatalf("Expected diff.Packages[0] to contain %s, got %s", want0, got0)
	}

	// diff.Packages[1] is '+ bazqux'

	want2 := "- foobar"
	got2 := diff.Packages[2].String()
	if got2 != want2 {
		t.Fatalf("Expected diff.Packages[2] to contain %s, got %s", want2, got2)
	}
}

func TestDiffLocks_NoChange(t *testing.T) {
	l1 := gps.SimpleLock{
		gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewVersion("v1.0.0"), nil),
	}
	l2 := gps.SimpleLock{
		gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewVersion("v1.0.0"), nil),
	}

	diff := DiffLocks(l1, l2)
	if diff != nil {
		t.Fatal("Expected the diff to be nil")
	}
}

func TestDiffLocks_AddProjects(t *testing.T) {
	l1 := gps.SimpleLock{
		gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewVersion("v1.0.0"), nil),
	}
	l2 := gps.SimpleLock{
		gps.NewLockedProject(gps.ProjectIdentifier{ProjectRoot: "github.com/baz/qux", Source: "https://github.com/mcfork/bazqux.git"},
			gps.NewVersion("v0.5.0").Pair("def456"), []string{"p1", "p2"}),
		gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewVersion("v1.0.0"), nil),
		gps.NewLockedProject(mkPI("github.com/zug/zug"), gps.NewVersion("v1.0.0"), nil),
	}

	diff := DiffLocks(l1, l2)
	if diff == nil {
		t.Fatal("Expected the diff to be populated")
	}

	if len(diff.Add) != 2 {
		t.Fatalf("Expected diff.Add to have 2 projects, got %d", len(diff.Add))
	}

	want0 := "github.com/baz/qux"
	got0 := string(diff.Add[0].Name)
	if got0 != want0 {
		t.Fatalf("Expected diff.Add[0] to contain %s, got %s", want0, got0)
	}

	want1 := "github.com/zug/zug"
	got1 := string(diff.Add[1].Name)
	if got1 != want1 {
		t.Fatalf("Expected diff.Add[1] to contain %s, got %s", want1, got1)
	}

	add0 := diff.Add[0]
	wantSource := "https://github.com/mcfork/bazqux.git"
	gotSource := add0.Source.String()
	if gotSource != wantSource {
		t.Fatalf("Expected diff.Add[0].Source to be '%s', got '%s'", wantSource, add0.Source)
	}

	wantVersion := "v0.5.0"
	gotVersion := add0.Version.String()
	if gotVersion != wantVersion {
		t.Fatalf("Expected diff.Add[0].Version to be '%s', got '%s'", wantVersion, gotVersion)
	}

	wantRevision := "def456"
	gotRevision := add0.Revision.String()
	if gotRevision != wantRevision {
		t.Fatalf("Expected diff.Add[0].Revision to be '%s', got '%s'", wantRevision, gotRevision)
	}

	wantBranch := ""
	gotBranch := add0.Branch.String()
	if gotBranch != wantBranch {
		t.Fatalf("Expected diff.Add[0].Branch to be '%s', got '%s'", wantBranch, gotBranch)
	}

	fmtPkgs := func(pkgs []StringDiff) string {
		b := bytes.NewBufferString("[")
		for _, pkg := range pkgs {
			b.WriteString(pkg.String())
			b.WriteString(",")
		}
		b.WriteString("]")
		return b.String()
	}

	wantPackages := "[p1,p2,]"
	gotPackages := fmtPkgs(add0.Packages)
	if gotPackages != wantPackages {
		t.Fatalf("Expected diff.Add[0].Packages to be '%s', got '%s'", wantPackages, gotPackages)
	}
}

func TestDiffLocks_RemoveProjects(t *testing.T) {
	l1 := gps.SimpleLock{
		gps.NewLockedProject(gps.ProjectIdentifier{ProjectRoot: "github.com/a/thing", Source: "https://github.com/mcfork/athing.git"},
			gps.NewBranch("master").Pair("def456"), []string{"p1", "p2"}),
		gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewVersion("v1.0.0"), nil),
	}
	l2 := gps.SimpleLock{
		gps.NewLockedProject(mkPI("github.com/baz/qux"), gps.NewVersion("v1.0.0"), nil),
	}

	diff := DiffLocks(l1, l2)
	if diff == nil {
		t.Fatal("Expected the diff to be populated")
	}

	if len(diff.Remove) != 2 {
		t.Fatalf("Expected diff.Remove to have 2 projects, got %d", len(diff.Remove))
	}

	want0 := "github.com/a/thing"
	got0 := string(diff.Remove[0].Name)
	if got0 != want0 {
		t.Fatalf("Expected diff.Remove[0] to contain %s, got %s", want0, got0)
	}

	want1 := "github.com/foo/bar"
	got1 := string(diff.Remove[1].Name)
	if got1 != want1 {
		t.Fatalf("Expected diff.Remove[1] to contain %s, got %s", want1, got1)
	}

	remove0 := diff.Remove[0]
	wantSource := "https://github.com/mcfork/athing.git"
	gotSource := remove0.Source.String()
	if gotSource != wantSource {
		t.Fatalf("Expected diff.Remove[0].Source to be '%s', got '%s'", wantSource, remove0.Source)
	}

	wantVersion := ""
	gotVersion := remove0.Version.String()
	if gotVersion != wantVersion {
		t.Fatalf("Expected diff.Remove[0].Version to be '%s', got '%s'", wantVersion, gotVersion)
	}

	wantRevision := "def456"
	gotRevision := remove0.Revision.String()
	if gotRevision != wantRevision {
		t.Fatalf("Expected diff.Remove[0].Revision to be '%s', got '%s'", wantRevision, gotRevision)
	}

	wantBranch := "master"
	gotBranch := remove0.Branch.String()
	if gotBranch != wantBranch {
		t.Fatalf("Expected diff.Remove[0].Branch to be '%s', got '%s'", wantBranch, gotBranch)
	}

	fmtPkgs := func(pkgs []StringDiff) string {
		b := bytes.NewBufferString("[")
		for _, pkg := range pkgs {
			b.WriteString(pkg.String())
			b.WriteString(",")
		}
		b.WriteString("]")
		return b.String()
	}

	wantPackages := "[p1,p2,]"
	gotPackages := fmtPkgs(remove0.Packages)
	if gotPackages != wantPackages {
		t.Fatalf("Expected diff.Remove[0].Packages to be '%s', got '%s'", wantPackages, gotPackages)
	}
}

func TestDiffLocks_ModifyProjects(t *testing.T) {
	l1 := gps.SimpleLock{
		gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewVersion("v1.0.0"), nil),
		gps.NewLockedProject(mkPI("github.com/foo/bu"), gps.NewVersion("v1.0.0"), nil),
		gps.NewLockedProject(mkPI("github.com/zig/zag"), gps.NewVersion("v1.0.0"), nil),
	}
	l2 := gps.SimpleLock{
		gps.NewLockedProject(mkPI("github.com/baz/qux"), gps.NewVersion("v1.0.0"), nil),
		gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewVersion("v2.0.0"), nil),
		gps.NewLockedProject(mkPI("github.com/zig/zag"), gps.NewVersion("v2.0.0"), nil),
		gps.NewLockedProject(mkPI("github.com/zug/zug"), gps.NewVersion("v1.0.0"), nil),
	}

	diff := DiffLocks(l1, l2)
	if diff == nil {
		t.Fatal("Expected the diff to be populated")
	}

	if len(diff.Modify) != 2 {
		t.Fatalf("Expected diff.Remove to have 2 projects, got %d", len(diff.Remove))
	}

	want0 := "github.com/foo/bar"
	got0 := string(diff.Modify[0].Name)
	if got0 != want0 {
		t.Fatalf("Expected diff.Modify[0] to contain %s, got %s", want0, got0)
	}

	want1 := "github.com/zig/zag"
	got1 := string(diff.Modify[1].Name)
	if got1 != want1 {
		t.Fatalf("Expected diff.Modify[1] to contain %s, got %s", want1, got1)
	}
}

func TestDiffLocks_EmptyInitialLock(t *testing.T) {
	l2 := gps.SimpleLock{
		gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewVersion("v1.0.0"), nil),
	}

	diff := DiffLocks(nil, l2)

	if len(diff.Add) != 1 {
		t.Fatalf("Expected diff.Add to contain 1 project, got %d", len(diff.Add))
	}
}

func TestDiffLocks_EmptyFinalLock(t *testing.T) {
	l1 := gps.SimpleLock{
		gps.NewLockedProject(mkPI("github.com/foo/bar"), gps.NewVersion("v1.0.0"), nil),
	}

	diff := DiffLocks(l1, nil)

	if len(diff.Remove) != 1 {
		t.Fatalf("Expected diff.Remove to contain 1 project, got %d", len(diff.Remove))
	}
}

func TestDiffLocks_EmptyLocks(t *testing.T) {
	diff := DiffLocks(nil, nil)
	if diff != nil {
		t.Fatal("Expected the diff to be empty")
	}
}