git-module

  1package git
  2
  3import (
  4	"context"
  5	"os"
  6	"testing"
  7
  8	"github.com/stretchr/testify/assert"
  9)
 10
 11func TestLsRemote(t *testing.T) {
 12	ctx := context.Background()
 13	tests := []struct {
 14		url     string
 15		opt     LsRemoteOptions
 16		expRefs []*Reference
 17	}{
 18		{
 19			url: testrepo.Path(),
 20			opt: LsRemoteOptions{
 21				Heads:    true,
 22				Patterns: []string{"release-1.0"},
 23			},
 24			expRefs: []*Reference{
 25				{
 26					ID:      testrepoMarks[30].String(),
 27					Refspec: "refs/heads/release-1.0",
 28				},
 29			},
 30		}, {
 31			url: testrepo.Path(),
 32			opt: LsRemoteOptions{
 33				Tags:     true,
 34				Patterns: []string{"v1.0.0"},
 35			},
 36			expRefs: []*Reference{
 37				{
 38					ID:      testrepoMarks[30].String(),
 39					Refspec: "refs/tags/v1.0.0",
 40				},
 41			},
 42		}, {
 43			url: testrepo.Path(),
 44			opt: LsRemoteOptions{
 45				Refs:     true,
 46				Patterns: []string{"v1.0.0"},
 47			},
 48			expRefs: []*Reference{
 49				{
 50					ID:      testrepoMarks[30].String(),
 51					Refspec: "refs/tags/v1.0.0",
 52				},
 53			},
 54		},
 55	}
 56	for _, test := range tests {
 57		t.Run("", func(t *testing.T) {
 58			refs, err := LsRemote(ctx, test.url, test.opt)
 59			if err != nil {
 60				t.Fatal(err)
 61			}
 62
 63			assert.Equal(t, test.expRefs, refs)
 64		})
 65	}
 66}
 67
 68func TestIsURLAccessible(t *testing.T) {
 69	ctx := context.Background()
 70	tests := []struct {
 71		url    string
 72		expVal bool
 73	}{
 74		{
 75			url:    testrepo.Path(),
 76			expVal: true,
 77		}, {
 78			url:    os.TempDir(),
 79			expVal: false,
 80		},
 81	}
 82	for _, test := range tests {
 83		t.Run("", func(t *testing.T) {
 84			assert.Equal(t, test.expVal, IsURLAccessible(ctx, test.url))
 85		})
 86	}
 87}
 88
 89func TestRepository_RemoteAdd(t *testing.T) {
 90	ctx := context.Background()
 91	path := tempPath()
 92	defer func() {
 93		_ = os.RemoveAll(path)
 94	}()
 95	objfmt, err := testrepo.ObjectFormat(ctx)
 96	if err != nil {
 97		t.Fatal(err)
 98	}
 99	err = Init(ctx, path, InitOptions{
100		Bare:         true,
101		ObjectFormat: objfmt,
102	})
103	if err != nil {
104		t.Fatal(err)
105	}
106
107	r, err := Open(path)
108	if err != nil {
109		t.Fatal(err)
110	}
111
112	// Add testrepo as the mirror remote and fetch right away
113	err = r.RemoteAdd(ctx, "origin", testrepo.Path(), RemoteAddOptions{
114		Fetch:       true,
115		MirrorFetch: true,
116	})
117	if err != nil {
118		t.Fatal(err)
119	}
120
121	// Check a non-default branch: release-1.0
122	assert.True(t, r.HasReference(ctx, RefsHeads+"release-1.0"))
123}
124
125func TestRepository_RemoteRemove(t *testing.T) {
126	ctx := context.Background()
127	r, cleanup, err := setupTempRepo()
128	if err != nil {
129		t.Fatal(err)
130	}
131	defer cleanup()
132
133	err = r.RemoteRemove(ctx, "origin", RemoteRemoveOptions{})
134	assert.Nil(t, err)
135
136	err = r.RemoteRemove(ctx, "origin", RemoteRemoveOptions{})
137	assert.Equal(t, ErrRemoteNotExist, err)
138}
139
140func TestRepository_Remotes(t *testing.T) {
141	ctx := context.Background()
142	r, cleanup, err := setupTempRepo()
143	if err != nil {
144		t.Fatal(err)
145	}
146	defer cleanup()
147
148	// 1 remote
149	remotes, err := r.Remotes(ctx)
150	assert.Nil(t, err)
151	assert.Equal(t, []string{"origin"}, remotes)
152
153	// 2 remotes
154	err = r.RemoteAdd(ctx, "t", "t")
155	assert.Nil(t, err)
156
157	remotes, err = r.Remotes(ctx)
158	assert.Nil(t, err)
159	assert.Equal(t, []string{"origin", "t"}, remotes)
160	assert.Len(t, remotes, 2)
161
162	// 0 remotes
163	err = r.RemoteRemove(ctx, "t")
164	assert.Nil(t, err)
165	err = r.RemoteRemove(ctx, "origin")
166	assert.Nil(t, err)
167
168	remotes, err = r.Remotes(ctx)
169	assert.Nil(t, err)
170	assert.Equal(t, []string{}, remotes)
171	assert.Len(t, remotes, 0)
172}
173
174func TestRepository_RemoteURLFamily(t *testing.T) {
175	ctx := context.Background()
176	r, cleanup, err := setupTempRepo()
177	if err != nil {
178		t.Fatal(err)
179	}
180	defer cleanup()
181
182	err = r.RemoteSetURLDelete(ctx, "origin", ".*")
183	assert.Equal(t, ErrNotDeleteNonPushURLs, err)
184
185	err = r.RemoteSetURL(ctx, "notexist", "t")
186	assert.Equal(t, ErrRemoteNotExist, err)
187
188	err = r.RemoteSetURL(ctx, "notexist", "t", RemoteSetURLOptions{Regex: "t"})
189	assert.Equal(t, ErrRemoteNotExist, err)
190
191	// Default origin URL is not easily testable
192	err = r.RemoteSetURL(ctx, "origin", "t")
193	assert.Nil(t, err)
194	urls, err := r.RemoteGetURL(ctx, "origin")
195	assert.Nil(t, err)
196	assert.Equal(t, []string{"t"}, urls)
197
198	err = r.RemoteSetURLAdd(ctx, "origin", "e")
199	assert.Nil(t, err)
200	urls, err = r.RemoteGetURL(ctx, "origin", RemoteGetURLOptions{All: true})
201	assert.Nil(t, err)
202	assert.Equal(t, []string{"t", "e"}, urls)
203
204	err = r.RemoteSetURL(ctx, "origin", "s", RemoteSetURLOptions{Regex: "e"})
205	assert.Nil(t, err)
206	urls, err = r.RemoteGetURL(ctx, "origin", RemoteGetURLOptions{All: true})
207	assert.Nil(t, err)
208	assert.Equal(t, []string{"t", "s"}, urls)
209
210	err = r.RemoteSetURLDelete(ctx, "origin", "t")
211	assert.Nil(t, err)
212	urls, err = r.RemoteGetURL(ctx, "origin", RemoteGetURLOptions{All: true})
213	assert.Nil(t, err)
214	assert.Equal(t, []string{"s"}, urls)
215}