709 lines
18 KiB
Go
709 lines
18 KiB
Go
/*
|
|
Copyright 2020 The Flux authors
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package libgit2
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/fluxcd/pkg/gittestserver"
|
|
git2go "github.com/libgit2/git2go/v33"
|
|
. "github.com/onsi/gomega"
|
|
|
|
"github.com/fluxcd/source-controller/pkg/git"
|
|
)
|
|
|
|
func TestCheckoutBranch_unmanaged(t *testing.T) {
|
|
checkoutBranch(t, false)
|
|
}
|
|
|
|
// checkoutBranch is a test helper function which runs the tests for checking out
|
|
// via CheckoutBranch.
|
|
func checkoutBranch(t *testing.T, managed bool) {
|
|
// we use a HTTP Git server instead of a bare repo (for all tests in this
|
|
// package), because our managed transports don't support the file protocol,
|
|
// so we wouldn't actually be using our custom transports, if we used a bare
|
|
// repo.
|
|
server, err := gittestserver.NewTempGitServer()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(server.Root())
|
|
|
|
err = server.StartHTTP()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer server.StopHTTP()
|
|
|
|
repoPath := "test.git"
|
|
err = server.InitRepo("../testdata/git/repo", git.DefaultBranch, repoPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
repo, err := git2go.OpenRepository(filepath.Join(server.Root(), repoPath))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer repo.Free()
|
|
|
|
defaultBranch := "master"
|
|
|
|
firstCommit, err := commitFile(repo, "branch", "init", time.Now())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Branch off on first commit
|
|
if err = createBranch(repo, "test", nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Create second commit on default branch
|
|
secondCommit, err := commitFile(repo, "branch", "second", time.Now())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
repoURL := server.HTTPAddress() + "/" + repoPath
|
|
|
|
tests := []struct {
|
|
name string
|
|
branch string
|
|
filesCreated map[string]string
|
|
lastRevision string
|
|
expectedCommit string
|
|
expectedConcreteCommit bool
|
|
expectedErr string
|
|
}{
|
|
{
|
|
name: "Default branch",
|
|
branch: defaultBranch,
|
|
filesCreated: map[string]string{"branch": "second"},
|
|
expectedCommit: secondCommit.String(),
|
|
expectedConcreteCommit: true,
|
|
},
|
|
{
|
|
name: "Other branch",
|
|
branch: "test",
|
|
filesCreated: map[string]string{"branch": "init"},
|
|
expectedCommit: firstCommit.String(),
|
|
expectedConcreteCommit: true,
|
|
},
|
|
{
|
|
name: "Non existing branch",
|
|
branch: "invalid",
|
|
expectedErr: "reference 'refs/remotes/origin/invalid' not found",
|
|
expectedConcreteCommit: true,
|
|
},
|
|
{
|
|
name: "skip clone - lastRevision hasn't changed",
|
|
branch: defaultBranch,
|
|
filesCreated: map[string]string{"branch": "second"},
|
|
lastRevision: fmt.Sprintf("%s/%s", defaultBranch, secondCommit.String()),
|
|
expectedCommit: secondCommit.String(),
|
|
expectedConcreteCommit: false,
|
|
},
|
|
{
|
|
name: "lastRevision is different",
|
|
branch: defaultBranch,
|
|
filesCreated: map[string]string{"branch": "second"},
|
|
lastRevision: fmt.Sprintf("%s/%s", defaultBranch, firstCommit.String()),
|
|
expectedCommit: secondCommit.String(),
|
|
expectedConcreteCommit: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
g := NewWithT(t)
|
|
|
|
branch := CheckoutBranch{
|
|
Branch: tt.branch,
|
|
LastRevision: tt.lastRevision,
|
|
}
|
|
|
|
tmpDir := t.TempDir()
|
|
authOpts := git.AuthOptions{
|
|
TransportOptionsURL: getTransportOptionsURL(git.HTTP),
|
|
}
|
|
|
|
cc, err := branch.Checkout(context.TODO(), tmpDir, repoURL, &authOpts)
|
|
if tt.expectedErr != "" {
|
|
g.Expect(err).To(HaveOccurred())
|
|
g.Expect(err.Error()).To(ContainSubstring(tt.expectedErr))
|
|
g.Expect(cc).To(BeNil())
|
|
return
|
|
}
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(cc.String()).To(Equal(tt.branch + "/" + tt.expectedCommit))
|
|
if managed {
|
|
g.Expect(git.IsConcreteCommit(*cc)).To(Equal(tt.expectedConcreteCommit))
|
|
}
|
|
|
|
if tt.expectedConcreteCommit {
|
|
for k, v := range tt.filesCreated {
|
|
g.Expect(filepath.Join(tmpDir, k)).To(BeARegularFile())
|
|
g.Expect(os.ReadFile(filepath.Join(tmpDir, k))).To(BeEquivalentTo(v))
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheckoutTag_unmanaged(t *testing.T) {
|
|
checkoutTag(t, false)
|
|
}
|
|
|
|
// checkoutTag is a test helper function which runs the tests for checking out
|
|
// via CheckoutTag.
|
|
func checkoutTag(t *testing.T, managed bool) {
|
|
type testTag struct {
|
|
name string
|
|
annotated bool
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
tagsInRepo []testTag
|
|
checkoutTag string
|
|
lastRevTag string
|
|
expectErr string
|
|
expectConcreteCommit bool
|
|
}{
|
|
{
|
|
name: "Tag",
|
|
tagsInRepo: []testTag{{"tag-1", false}},
|
|
checkoutTag: "tag-1",
|
|
expectConcreteCommit: true,
|
|
},
|
|
{
|
|
name: "Annotated",
|
|
tagsInRepo: []testTag{{"annotated", true}},
|
|
checkoutTag: "annotated",
|
|
expectConcreteCommit: true,
|
|
},
|
|
{
|
|
name: "Non existing tag",
|
|
checkoutTag: "invalid",
|
|
expectErr: "unable to find 'invalid': no reference found for shorthand 'invalid'",
|
|
},
|
|
{
|
|
name: "Skip clone - last revision unchanged",
|
|
tagsInRepo: []testTag{{"tag-1", false}},
|
|
checkoutTag: "tag-1",
|
|
lastRevTag: "tag-1",
|
|
expectConcreteCommit: false,
|
|
},
|
|
{
|
|
name: "Last revision changed",
|
|
tagsInRepo: []testTag{{"tag-1", false}, {"tag-2", false}},
|
|
checkoutTag: "tag-2",
|
|
lastRevTag: "tag-1",
|
|
expectConcreteCommit: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
g := NewWithT(t)
|
|
|
|
server, err := gittestserver.NewTempGitServer()
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
defer os.RemoveAll(server.Root())
|
|
|
|
err = server.StartHTTP()
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
defer server.StopHTTP()
|
|
|
|
repoPath := "test.git"
|
|
err = server.InitRepo("../testdata/git/repo", git.DefaultBranch, repoPath)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
|
|
repo, err := git2go.OpenRepository(filepath.Join(server.Root(), repoPath))
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
defer repo.Free()
|
|
|
|
// Collect tags and their associated commit for later reference.
|
|
tagCommits := map[string]*git2go.Commit{}
|
|
|
|
repoURL := server.HTTPAddress() + "/" + repoPath
|
|
|
|
// Populate the repo with commits and tags.
|
|
if tt.tagsInRepo != nil {
|
|
for _, tr := range tt.tagsInRepo {
|
|
var commit *git2go.Commit
|
|
c, err := commitFile(repo, "tag", tr.name, time.Now())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if commit, err = repo.LookupCommit(c); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = tag(repo, commit.Id(), tr.annotated, tr.name, time.Now())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tagCommits[tr.name] = commit
|
|
}
|
|
}
|
|
|
|
checkoutTag := CheckoutTag{
|
|
Tag: tt.checkoutTag,
|
|
}
|
|
// If last revision is provided, configure it.
|
|
if tt.lastRevTag != "" {
|
|
lc := tagCommits[tt.lastRevTag]
|
|
checkoutTag.LastRevision = fmt.Sprintf("%s/%s", tt.lastRevTag, lc.Id().String())
|
|
}
|
|
|
|
tmpDir := t.TempDir()
|
|
|
|
authOpts := git.AuthOptions{
|
|
TransportOptionsURL: getTransportOptionsURL(git.HTTP),
|
|
}
|
|
cc, err := checkoutTag.Checkout(context.TODO(), tmpDir, repoURL, &authOpts)
|
|
if tt.expectErr != "" {
|
|
g.Expect(err).To(HaveOccurred())
|
|
g.Expect(err.Error()).To(ContainSubstring(tt.expectErr))
|
|
g.Expect(cc).To(BeNil())
|
|
return
|
|
}
|
|
|
|
// Check successful checkout results.
|
|
targetTagCommit := tagCommits[tt.checkoutTag]
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(cc.String()).To(Equal(tt.checkoutTag + "/" + targetTagCommit.Id().String()))
|
|
if managed {
|
|
g.Expect(git.IsConcreteCommit(*cc)).To(Equal(tt.expectConcreteCommit))
|
|
|
|
}
|
|
|
|
// Check file content only when there's an actual checkout.
|
|
if tt.lastRevTag != tt.checkoutTag {
|
|
g.Expect(filepath.Join(tmpDir, "tag")).To(BeARegularFile())
|
|
g.Expect(os.ReadFile(filepath.Join(tmpDir, "tag"))).To(BeEquivalentTo(tt.checkoutTag))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheckoutCommit_unmanaged(t *testing.T) {
|
|
checkoutCommit(t, false)
|
|
}
|
|
|
|
// checkoutCommit is a test helper function which runs the tests for checking out
|
|
// via CheckoutCommit.
|
|
func checkoutCommit(t *testing.T, managed bool) {
|
|
g := NewWithT(t)
|
|
|
|
server, err := gittestserver.NewTempGitServer()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(server.Root())
|
|
|
|
err = server.StartHTTP()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer server.StopHTTP()
|
|
|
|
repoPath := "test.git"
|
|
err = server.InitRepo("../testdata/git/repo", git.DefaultBranch, repoPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
repo, err := git2go.OpenRepository(filepath.Join(server.Root(), repoPath))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer repo.Free()
|
|
|
|
c, err := commitFile(repo, "commit", "init", time.Now())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = commitFile(repo, "commit", "second", time.Now()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tmpDir := t.TempDir()
|
|
authOpts := git.AuthOptions{
|
|
TransportOptionsURL: getTransportOptionsURL(git.HTTP),
|
|
}
|
|
repoURL := server.HTTPAddress() + "/" + repoPath
|
|
|
|
commit := CheckoutCommit{
|
|
Commit: c.String(),
|
|
}
|
|
|
|
cc, err := commit.Checkout(context.TODO(), tmpDir, repoURL, &authOpts)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(cc).ToNot(BeNil())
|
|
g.Expect(cc.String()).To(Equal("HEAD/" + c.String()))
|
|
g.Expect(filepath.Join(tmpDir, "commit")).To(BeARegularFile())
|
|
g.Expect(os.ReadFile(filepath.Join(tmpDir, "commit"))).To(BeEquivalentTo("init"))
|
|
|
|
commit = CheckoutCommit{
|
|
Commit: "4dc3185c5fc94eb75048376edeb44571cece25f4",
|
|
}
|
|
tmpDir2 := t.TempDir()
|
|
|
|
cc, err = commit.Checkout(context.TODO(), tmpDir2, repoURL, &authOpts)
|
|
g.Expect(err).To(HaveOccurred())
|
|
g.Expect(err.Error()).To(HavePrefix("git checkout error: git commit '4dc3185c5fc94eb75048376edeb44571cece25f4' not found:"))
|
|
g.Expect(cc).To(BeNil())
|
|
}
|
|
|
|
func TestCheckoutTagSemVer_unmanaged(t *testing.T) {
|
|
checkoutSemVer(t, false)
|
|
}
|
|
|
|
// checkoutSemVer is a test helper function which runs the tests for checking out
|
|
// via CheckoutSemVer.
|
|
func checkoutSemVer(t *testing.T, managed bool) {
|
|
g := NewWithT(t)
|
|
now := time.Now()
|
|
|
|
tags := []struct {
|
|
tag string
|
|
annotated bool
|
|
commitTime time.Time
|
|
tagTime time.Time
|
|
}{
|
|
{
|
|
tag: "v0.0.1",
|
|
annotated: false,
|
|
commitTime: now,
|
|
},
|
|
{
|
|
tag: "v0.1.0+build-1",
|
|
annotated: true,
|
|
commitTime: now.Add(10 * time.Minute),
|
|
tagTime: now.Add(2 * time.Hour), // This should be ignored during TS comparisons
|
|
},
|
|
{
|
|
tag: "v0.1.0+build-2",
|
|
annotated: false,
|
|
commitTime: now.Add(30 * time.Minute),
|
|
},
|
|
{
|
|
tag: "v0.1.0+build-3",
|
|
annotated: true,
|
|
commitTime: now.Add(1 * time.Hour),
|
|
tagTime: now.Add(1 * time.Hour), // This should be ignored during TS comparisons
|
|
},
|
|
{
|
|
tag: "0.2.0",
|
|
annotated: true,
|
|
commitTime: now,
|
|
tagTime: now,
|
|
},
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
constraint string
|
|
expectErr error
|
|
expectTag string
|
|
}{
|
|
{
|
|
name: "Orders by SemVer",
|
|
constraint: ">0.1.0",
|
|
expectTag: "0.2.0",
|
|
},
|
|
{
|
|
name: "Orders by SemVer and timestamp",
|
|
constraint: "<0.2.0",
|
|
expectTag: "v0.1.0+build-3",
|
|
},
|
|
{
|
|
name: "Errors without match",
|
|
constraint: ">=1.0.0",
|
|
expectErr: errors.New("no match found for semver: >=1.0.0"),
|
|
},
|
|
}
|
|
|
|
server, err := gittestserver.NewTempGitServer()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(server.Root())
|
|
|
|
err = server.StartHTTP()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer server.StopHTTP()
|
|
|
|
repoPath := "test.git"
|
|
err = server.InitRepo("../testdata/git/repo", git.DefaultBranch, repoPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
repo, err := git2go.OpenRepository(filepath.Join(server.Root(), repoPath))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer repo.Free()
|
|
repoURL := server.HTTPAddress() + "/" + repoPath
|
|
|
|
refs := make(map[string]string, len(tags))
|
|
for _, tt := range tags {
|
|
ref, err := commitFile(repo, "tag", tt.tag, tt.commitTime)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
commit, err := repo.LookupCommit(ref)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer commit.Free()
|
|
refs[tt.tag] = commit.Id().String()
|
|
_, err = tag(repo, ref, tt.annotated, tt.tag, tt.tagTime)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
c, err := repo.Tags.List()
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(c).To(HaveLen(len(tags)))
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
g := NewWithT(t)
|
|
|
|
semVer := CheckoutSemVer{
|
|
SemVer: tt.constraint,
|
|
}
|
|
|
|
tmpDir := t.TempDir()
|
|
authOpts := git.AuthOptions{
|
|
TransportOptionsURL: getTransportOptionsURL(git.HTTP),
|
|
}
|
|
|
|
cc, err := semVer.Checkout(context.TODO(), tmpDir, repoURL, &authOpts)
|
|
if tt.expectErr != nil {
|
|
g.Expect(err).To(Equal(tt.expectErr))
|
|
g.Expect(cc).To(BeNil())
|
|
return
|
|
}
|
|
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(cc.String()).To(Equal(tt.expectTag + "/" + refs[tt.expectTag]))
|
|
g.Expect(filepath.Join(tmpDir, "tag")).To(BeARegularFile())
|
|
g.Expect(os.ReadFile(filepath.Join(tmpDir, "tag"))).To(BeEquivalentTo(tt.expectTag))
|
|
})
|
|
}
|
|
}
|
|
|
|
func initBareRepo(t *testing.T) (*git2go.Repository, error) {
|
|
tmpDir := t.TempDir()
|
|
repo, err := git2go.InitRepository(tmpDir, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return repo, nil
|
|
}
|
|
|
|
func createBranch(repo *git2go.Repository, branch string, commit *git2go.Commit) error {
|
|
if commit == nil {
|
|
var err error
|
|
commit, err = headCommit(repo)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer commit.Free()
|
|
}
|
|
_, err := repo.CreateBranch(branch, commit, false)
|
|
return err
|
|
}
|
|
|
|
func commitFile(repo *git2go.Repository, path, content string, time time.Time) (*git2go.Oid, error) {
|
|
var parentC []*git2go.Commit
|
|
head, err := headCommit(repo)
|
|
if err == nil {
|
|
defer head.Free()
|
|
parentC = append(parentC, head)
|
|
}
|
|
|
|
index, err := repo.Index()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer index.Free()
|
|
|
|
blobOID, err := repo.CreateBlobFromBuffer([]byte(content))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
entry := &git2go.IndexEntry{
|
|
Mode: git2go.FilemodeBlob,
|
|
Id: blobOID,
|
|
Path: path,
|
|
}
|
|
|
|
if err := index.Add(entry); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := index.Write(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
treeID, err := index.WriteTree()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tree, err := repo.LookupTree(treeID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer tree.Free()
|
|
|
|
c, err := repo.CreateCommit("HEAD", mockSignature(time), mockSignature(time), "Committing "+path, tree, parentC...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return c, nil
|
|
}
|
|
|
|
func tag(repo *git2go.Repository, cId *git2go.Oid, annotated bool, tag string, time time.Time) (*git2go.Oid, error) {
|
|
commit, err := repo.LookupCommit(cId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if annotated {
|
|
return repo.Tags.Create(tag, commit, mockSignature(time), fmt.Sprintf("Annotated tag for %s", tag))
|
|
}
|
|
return repo.Tags.CreateLightweight(tag, commit, false)
|
|
}
|
|
|
|
func mockSignature(time time.Time) *git2go.Signature {
|
|
return &git2go.Signature{
|
|
Name: "Jane Doe",
|
|
Email: "author@example.com",
|
|
When: time,
|
|
}
|
|
}
|
|
|
|
func TestInitializeRepoWithRemote(t *testing.T) {
|
|
g := NewWithT(t)
|
|
tmp := t.TempDir()
|
|
ctx := context.TODO()
|
|
testRepoURL := "https://example.com/foo/bar"
|
|
testRepoURL2 := "https://example.com/foo/baz"
|
|
authOpts, err := git.AuthOptionsWithoutSecret(testRepoURL)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
authOpts2, err := git.AuthOptionsWithoutSecret(testRepoURL2)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
|
|
// Fresh initialization.
|
|
repo, remote, err := initializeRepoWithRemote(ctx, tmp, testRepoURL, authOpts)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(repo.IsBare()).To(BeFalse())
|
|
g.Expect(remote.Name()).To(Equal(defaultRemoteName))
|
|
g.Expect(remote.Url()).To(Equal(testRepoURL))
|
|
remote.Free()
|
|
repo.Free()
|
|
|
|
// Reinitialize to ensure it reuses the existing origin.
|
|
repo, remote, err = initializeRepoWithRemote(ctx, tmp, testRepoURL, authOpts)
|
|
g.Expect(err).ToNot(HaveOccurred())
|
|
g.Expect(repo.IsBare()).To(BeFalse())
|
|
g.Expect(remote.Name()).To(Equal(defaultRemoteName))
|
|
g.Expect(remote.Url()).To(Equal(testRepoURL))
|
|
remote.Free()
|
|
repo.Free()
|
|
|
|
// Reinitialize with a different remote URL for existing origin.
|
|
_, _, err = initializeRepoWithRemote(ctx, tmp, testRepoURL2, authOpts2)
|
|
g.Expect(err).To(HaveOccurred())
|
|
}
|
|
|
|
func TestCheckoutStrategyForOptions(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
opts git.CheckoutOptions
|
|
expectedStrat git.CheckoutStrategy
|
|
}{
|
|
{
|
|
name: "commit works",
|
|
opts: git.CheckoutOptions{
|
|
Commit: "commit",
|
|
},
|
|
expectedStrat: &CheckoutCommit{
|
|
Commit: "commit",
|
|
},
|
|
},
|
|
{
|
|
name: "semver works",
|
|
opts: git.CheckoutOptions{
|
|
SemVer: ">= 1.0.0",
|
|
},
|
|
expectedStrat: &CheckoutSemVer{
|
|
SemVer: ">= 1.0.0",
|
|
},
|
|
},
|
|
{
|
|
name: "tag with latest revision works",
|
|
opts: git.CheckoutOptions{
|
|
Tag: "v0.1.0",
|
|
LastRevision: "ar34oi2njrngjrng",
|
|
},
|
|
expectedStrat: &CheckoutTag{
|
|
Tag: "v0.1.0",
|
|
LastRevision: "ar34oi2njrngjrng",
|
|
},
|
|
},
|
|
{
|
|
name: "branch with latest revision works",
|
|
opts: git.CheckoutOptions{
|
|
Branch: "main",
|
|
LastRevision: "rrgij20mkmrg",
|
|
},
|
|
expectedStrat: &CheckoutBranch{
|
|
Branch: "main",
|
|
LastRevision: "rrgij20mkmrg",
|
|
},
|
|
},
|
|
{
|
|
name: "empty branch falls back to default",
|
|
opts: git.CheckoutOptions{},
|
|
expectedStrat: &CheckoutBranch{
|
|
Branch: git.DefaultBranch,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
g := NewWithT(t)
|
|
strat := CheckoutStrategyForOptions(context.TODO(), tt.opts)
|
|
g.Expect(strat).To(Equal(tt.expectedStrat))
|
|
})
|
|
}
|
|
}
|