1package github
  2
  3import (
  4	"bytes"
  5	"context"
  6	"encoding/json"
  7	"fmt"
  8	"log/slog"
  9	"math/rand"
 10	"net/http"
 11	"os"
 12	"testing"
 13	"time"
 14
 15	"github.com/stretchr/testify/require"
 16
 17	"github.com/git-bug/git-bug/bridge/core"
 18	"github.com/git-bug/git-bug/bridge/core/auth"
 19	"github.com/git-bug/git-bug/cache"
 20	"github.com/git-bug/git-bug/entity"
 21	"github.com/git-bug/git-bug/entity/dag"
 22	"github.com/git-bug/git-bug/repository"
 23	"github.com/git-bug/git-bug/util/interrupt"
 24)
 25
 26const (
 27	testRepoBaseName = "git-bug-test-github-exporter"
 28)
 29
 30type testCase struct {
 31	name    string
 32	bug     *cache.BugCache
 33	numOrOp int // number of original operations
 34}
 35
 36func testCases(t *testing.T, repo *cache.RepoCache) []*testCase {
 37	// simple bug
 38	simpleBug, _, err := repo.Bugs().New("simple bug", "new bug")
 39	require.NoError(t, err)
 40
 41	// bug with comments
 42	bugWithComments, _, err := repo.Bugs().New("bug with comments", "new bug")
 43	require.NoError(t, err)
 44
 45	_, _, err = bugWithComments.AddComment("new comment")
 46	require.NoError(t, err)
 47
 48	// bug with label changes
 49	bugLabelChange, _, err := repo.Bugs().New("bug label change", "new bug")
 50	require.NoError(t, err)
 51
 52	_, _, err = bugLabelChange.ChangeLabels([]string{"bug"}, nil)
 53	require.NoError(t, err)
 54
 55	_, _, err = bugLabelChange.ChangeLabels([]string{"core"}, nil)
 56	require.NoError(t, err)
 57
 58	_, _, err = bugLabelChange.ChangeLabels(nil, []string{"bug"})
 59	require.NoError(t, err)
 60
 61	_, _, err = bugLabelChange.ChangeLabels([]string{"InVaLiD"}, nil)
 62	require.NoError(t, err)
 63
 64	_, _, err = bugLabelChange.ChangeLabels([]string{"bUG"}, nil)
 65	require.NoError(t, err)
 66
 67	// bug with comments editions
 68	bugWithCommentEditions, createOp, err := repo.Bugs().New("bug with comments editions", "new bug")
 69	require.NoError(t, err)
 70
 71	_, err = bugWithCommentEditions.EditComment(
 72		entity.CombineIds(bugWithCommentEditions.Id(), createOp.Id()), "first comment edited")
 73	require.NoError(t, err)
 74
 75	commentId, _, err := bugWithCommentEditions.AddComment("first comment")
 76	require.NoError(t, err)
 77
 78	_, err = bugWithCommentEditions.EditComment(commentId, "first comment edited")
 79	require.NoError(t, err)
 80
 81	// bug status changed
 82	bugStatusChanged, _, err := repo.Bugs().New("bug status changed", "new bug")
 83	require.NoError(t, err)
 84
 85	_, err = bugStatusChanged.Close()
 86	require.NoError(t, err)
 87
 88	_, err = bugStatusChanged.Open()
 89	require.NoError(t, err)
 90
 91	// bug title changed
 92	bugTitleEdited, _, err := repo.Bugs().New("bug title edited", "new bug")
 93	require.NoError(t, err)
 94
 95	_, err = bugTitleEdited.SetTitle("bug title edited again")
 96	require.NoError(t, err)
 97
 98	return []*testCase{
 99		{
100			name:    "simple bug",
101			bug:     simpleBug,
102			numOrOp: 1,
103		},
104		{
105			name:    "bug with comments",
106			bug:     bugWithComments,
107			numOrOp: 2,
108		},
109		{
110			name:    "bug label change",
111			bug:     bugLabelChange,
112			numOrOp: 6,
113		},
114		{
115			name:    "bug with comment editions",
116			bug:     bugWithCommentEditions,
117			numOrOp: 4,
118		},
119		{
120			name:    "bug changed status",
121			bug:     bugStatusChanged,
122			numOrOp: 3,
123		},
124		{
125			name:    "bug title edited",
126			bug:     bugTitleEdited,
127			numOrOp: 2,
128		},
129	}
130}
131
132func TestGithubPushPull(t *testing.T) {
133	// repo owner
134	envUser := os.Getenv("GITHUB_USER")
135	if envUser == "" {
136		t.Skip("missing required environment variable: GITHUB_USER")
137	}
138
139	// token must have 'repo' and 'delete_repo' scopes
140	envToken := os.Getenv("GITHUB_TOKEN")
141	if envToken == "" {
142		t.Skip("missing required environment variable: GITHUB_TOKEN")
143	}
144
145	// create repo backend
146	repo := repository.CreateGoGitTestRepo(t, false)
147
148	backend, err := cache.NewRepoCacheNoEvents(repo)
149	require.NoError(t, err)
150
151	// set author identity
152	login := "identity-test"
153	author, err := backend.Identities().New("test identity", "test@test.org")
154	require.NoError(t, err)
155	author.SetMetadata(metaKeyGithubLogin, login)
156	err = author.Commit()
157	require.NoError(t, err)
158
159	err = backend.SetUserIdentity(author)
160	require.NoError(t, err)
161
162	defer backend.Close()
163	interrupt.RegisterCleaner(backend.Close)
164
165	// Setup token + cleanup
166	token := auth.NewToken(target, envToken)
167	token.SetMetadata(auth.MetaKeyLogin, login)
168	err = auth.Store(repo, token)
169	require.NoError(t, err)
170
171	cleanToken := func() error {
172		return auth.Remove(repo, token.ID())
173	}
174	defer cleanToken()
175	interrupt.RegisterCleaner(cleanToken)
176
177	tests := testCases(t, backend)
178
179	// generate project name
180	projectName := generateRepoName()
181
182	// create target Github repository
183	err = createRepository(projectName, envToken)
184	require.NoError(t, err)
185
186	slog.Info("created github repository", "name", projectName)
187
188	// Let Github handle the repo creation and update all their internal caches.
189	// Avoid HTTP error 404 retrieving repository node id
190	time.Sleep(10 * time.Second)
191
192	// Make sure to remove the Github repository when the test end
193	defer func(t *testing.T) {
194		if err := deleteRepository(projectName, envUser, envToken); err != nil {
195			t.Fatal(err)
196		}
197		fmt.Println("deleted repository:", projectName)
198	}(t)
199
200	interrupt.RegisterCleaner(func() error {
201		return deleteRepository(projectName, envUser, envToken)
202	})
203
204	ctx := context.Background()
205
206	// initialize exporter
207	exporter := &githubExporter{}
208	err = exporter.Init(ctx, backend, core.Configuration{
209		confKeyOwner:        envUser,
210		confKeyProject:      projectName,
211		confKeyDefaultLogin: login,
212	})
213	require.NoError(t, err)
214
215	start := time.Now()
216
217	// export all bugs
218	exportEvents, err := exporter.ExportAll(ctx, backend, time.Time{})
219	require.NoError(t, err)
220
221	for result := range exportEvents {
222		require.NoError(t, result.Err)
223	}
224	require.NoError(t, err)
225
226	fmt.Printf("test repository exported in %f seconds\n", time.Since(start).Seconds())
227
228	repoTwo := repository.CreateGoGitTestRepo(t, false)
229
230	// create a second backend
231	backendTwo, err := cache.NewRepoCacheNoEvents(repoTwo)
232	require.NoError(t, err)
233
234	importer := &githubImporter{}
235	err = importer.Init(ctx, backend, core.Configuration{
236		confKeyOwner:        envUser,
237		confKeyProject:      projectName,
238		confKeyDefaultLogin: login,
239	})
240	require.NoError(t, err)
241
242	// import all exported bugs to the second backend
243	importEvents, err := importer.ImportAll(ctx, backendTwo, time.Time{})
244	require.NoError(t, err)
245
246	for result := range importEvents {
247		require.NoError(t, result.Err)
248	}
249
250	require.Len(t, backendTwo.Bugs().AllIds(), len(tests))
251
252	for _, tt := range tests {
253		t.Run(tt.name, func(t *testing.T) {
254			// for each operation a SetMetadataOperation will be added
255			// so number of operations should double
256			require.Len(t, tt.bug.Snapshot().Operations, tt.numOrOp*2)
257
258			// verify operation have correct metadata
259			for _, op := range tt.bug.Snapshot().Operations {
260				// Check if the originals operations (*not* SetMetadata) are tagged properly
261				if _, ok := op.(dag.OperationDoesntChangeSnapshot); !ok {
262					_, haveIDMetadata := op.GetMetadata(metaKeyGithubId)
263					require.True(t, haveIDMetadata)
264
265					_, haveURLMetada := op.GetMetadata(metaKeyGithubUrl)
266					require.True(t, haveURLMetada)
267				}
268			}
269
270			// get bug github ID
271			bugGithubID, ok := tt.bug.Snapshot().GetCreateMetadata(metaKeyGithubId)
272			require.True(t, ok)
273
274			// retrieve bug from backendTwo
275			importedBug, err := backendTwo.Bugs().ResolveBugCreateMetadata(metaKeyGithubId, bugGithubID)
276			require.NoError(t, err)
277
278			// verify bug have same number of original operations
279			require.Len(t, importedBug.Snapshot().Operations, tt.numOrOp)
280
281			// verify bugs are tagged with origin=github
282			issueOrigin, ok := importedBug.Snapshot().GetCreateMetadata(core.MetaKeyOrigin)
283			require.True(t, ok)
284			require.Equal(t, issueOrigin, target)
285
286			// TODO: maybe more tests to ensure bug final state
287		})
288	}
289}
290
291func generateRepoName() string {
292	rand.Seed(time.Now().UnixNano())
293	var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
294	b := make([]rune, 8)
295	for i := range b {
296		b[i] = letterRunes[rand.Intn(len(letterRunes))]
297	}
298	return fmt.Sprintf("%s-%s", testRepoBaseName, string(b))
299}
300
301// create repository need a token with scope 'repo'
302func createRepository(project, token string) error {
303	// This function use the V3 Github API because repository creation is not supported yet on the V4 API.
304	url := fmt.Sprintf("%s/user/repos", githubV3Url)
305
306	params := struct {
307		Name        string `json:"name"`
308		Description string `json:"description"`
309		Private     bool   `json:"private"`
310		HasIssues   bool   `json:"has_issues"`
311	}{
312		Name:        project,
313		Description: "git-bug exporter temporary test repository",
314		Private:     true,
315		HasIssues:   true,
316	}
317
318	data, err := json.Marshal(params)
319	if err != nil {
320		return err
321	}
322
323	req, err := http.NewRequest("POST", url, bytes.NewBuffer(data))
324	if err != nil {
325		return err
326	}
327
328	// need the token for private repositories
329	req.Header.Set("Authorization", fmt.Sprintf("token %s", token))
330
331	client := &http.Client{
332		Timeout: defaultTimeout,
333	}
334
335	resp, err := client.Do(req)
336	if err != nil {
337		return err
338	}
339
340	return resp.Body.Close()
341}
342
343// delete repository need a token with scope 'delete_repo'
344func deleteRepository(project, owner, token string) error {
345	// This function use the V3 Github API because repository removal is not supported yet on the V4 API.
346	url := fmt.Sprintf("%s/repos/%s/%s", githubV3Url, owner, project)
347
348	req, err := http.NewRequest("DELETE", url, nil)
349	if err != nil {
350		return err
351	}
352
353	// need the token for private repositories
354	req.Header.Set("Authorization", fmt.Sprintf("token %s", token))
355
356	client := &http.Client{
357		Timeout: defaultTimeout,
358	}
359
360	resp, err := client.Do(req)
361	if err != nil {
362		return err
363	}
364
365	defer resp.Body.Close()
366
367	if resp.StatusCode != http.StatusNoContent {
368		return fmt.Errorf("error deleting repository")
369	}
370
371	return nil
372}