git-bug/bridge/github/import_integration_test.go

package github

import (
	"context"
	"net/url"
	"testing"
	"time"

	"github.com/pkg/errors"
	"github.com/shurcooL/githubv4"
	m "github.com/stretchr/testify/mock"
	"github.com/stretchr/testify/require"

	"github.com/MichaelMure/git-bug/bridge/github/mocks"
	"github.com/MichaelMure/git-bug/cache"
	"github.com/MichaelMure/git-bug/entities/bug"
	"github.com/MichaelMure/git-bug/repository"
	"github.com/MichaelMure/git-bug/util/interrupt"
)

// using testify/mock and mockery

var userName = githubv4.String("marcus")
var userEmail = githubv4.String("marcus@rom.com")
var unedited = githubv4.String("unedited")
var edited = githubv4.String("edited")

func TestGithubImporterIntegration(t *testing.T) {
	// mock
	clientMock := &mocks.Client{}
	setupExpectations(t, clientMock)
	importer := githubImporter{}
	importer.client = &rateLimitHandlerClient{sc: clientMock}

	// arrange
	repo := repository.CreateGoGitTestRepo(t, false)
	backend, err := cache.NewRepoCacheNoEvents(repo)
	require.NoError(t, err)

	defer backend.Close()
	interrupt.RegisterCleaner(backend.Close)
	require.NoError(t, err)

	// act
	events, err := importer.ImportAll(context.Background(), backend, time.Time{})

	// assert
	require.NoError(t, err)
	for e := range events {
		require.NoError(t, e.Err)
	}
	require.Len(t, backend.Bugs().AllIds(), 5)
	require.Len(t, backend.Identities().AllIds(), 2)

	b1, err := backend.Bugs().ResolveBugCreateMetadata(metaKeyGithubUrl, "https://github.com/marcus/to-himself/issues/1")
	require.NoError(t, err)
	ops1 := b1.Snapshot().Operations
	require.Equal(t, "marcus", ops1[0].Author().Name())
	require.Equal(t, "title 1", ops1[0].(*bug.CreateOperation).Title)
	require.Equal(t, "body text 1", ops1[0].(*bug.CreateOperation).Message)

	b3, err := backend.Bugs().ResolveBugCreateMetadata(metaKeyGithubUrl, "https://github.com/marcus/to-himself/issues/3")
	require.NoError(t, err)
	ops3 := b3.Snapshot().Operations
	require.Equal(t, "issue 3 comment 1", ops3[1].(*bug.AddCommentOperation).Message)
	require.Equal(t, "issue 3 comment 2", ops3[2].(*bug.AddCommentOperation).Message)
	require.Equal(t, []bug.Label{"bug"}, ops3[3].(*bug.LabelChangeOperation).Added)
	require.Equal(t, "title 3, edit 1", ops3[4].(*bug.SetTitleOperation).Title)

	b4, err := backend.Bugs().ResolveBugCreateMetadata(metaKeyGithubUrl, "https://github.com/marcus/to-himself/issues/4")
	require.NoError(t, err)
	ops4 := b4.Snapshot().Operations
	require.Equal(t, "edited", ops4[1].(*bug.EditCommentOperation).Message)

}

func setupExpectations(t *testing.T, mock *mocks.Client) {
	rateLimitingError(mock)
	expectIssueQuery1(mock)
	expectIssueQuery2(mock)
	expectIssueQuery3(mock)
	expectUserQuery(t, mock)
}

func rateLimitingError(mock *mocks.Client) {
	mock.On("Query", m.Anything, m.AnythingOfType("*github.issueQuery"), m.Anything).Return(errors.New("API rate limit exceeded")).Once()
	mock.On("Query", m.Anything, m.AnythingOfType("*github.rateLimitQuery"), m.Anything).Return(nil).Run(
		func(args m.Arguments) {
			retVal := args.Get(1).(*rateLimitQuery)
			retVal.RateLimit.ResetAt.Time = time.Now().Add(time.Millisecond * 200)
		},
	).Once()
}

func expectIssueQuery1(mock *mocks.Client) {
	mock.On("Query", m.Anything, m.AnythingOfType("*github.issueQuery"), m.Anything).Return(nil).Run(
		func(args m.Arguments) {
			retVal := args.Get(1).(*issueQuery)
			retVal.Repository.Issues.Nodes = []issueNode{
				{
					issue: issue{
						authorEvent: authorEvent{
							Id: 1,
							Author: &actor{
								Typename: "User",
								User: userActor{
									Name:  &userName,
									Email: userEmail,
								},
							},
						},
						Title:  "title 1",
						Number: 1,
						Body:   "body text 1",
						Url: githubv4.URI{
							URL: &url.URL{
								Scheme: "https",
								Host:   "github.com",
								Path:   "marcus/to-himself/issues/1",
							},
						},
					},
					UserContentEdits: userContentEditConnection{},
					TimelineItems:    timelineItemsConnection{},
				},
				{
					issue: issue{
						authorEvent: authorEvent{
							Id: 2,
							Author: &actor{
								Typename: "User",
								User: userActor{
									Name:  &userName,
									Email: userEmail,
								},
							},
						},
						Title:  "title 2",
						Number: 2,
						Body:   "body text 2",
						Url: githubv4.URI{
							URL: &url.URL{
								Scheme: "https",
								Host:   "github.com",
								Path:   "marcus/to-himself/issues/2",
							},
						},
					},
					UserContentEdits: userContentEditConnection{},
					TimelineItems:    timelineItemsConnection{},
				},
			}
			retVal.Repository.Issues.PageInfo = pageInfo{
				EndCursor:   "end-cursor-1",
				HasNextPage: true,
			}
		},
	).Once()
}

func expectIssueQuery2(mock *mocks.Client) {
	mock.On("Query", m.Anything, m.AnythingOfType("*github.issueQuery"), m.Anything).Return(nil).Run(
		func(args m.Arguments) {
			retVal := args.Get(1).(*issueQuery)
			retVal.Repository.Issues.Nodes = []issueNode{
				{
					issue: issue{
						authorEvent: authorEvent{
							Id: 3,
							Author: &actor{
								Typename: "User",
								User: userActor{
									Name:  &userName,
									Email: userEmail,
								},
							},
						},
						Title:  "title 3",
						Number: 3,
						Body:   "body text 3",
						Url: githubv4.URI{
							URL: &url.URL{
								Scheme: "https",
								Host:   "github.com",
								Path:   "marcus/to-himself/issues/3",
							},
						},
					},
					UserContentEdits: userContentEditConnection{},
					TimelineItems: timelineItemsConnection{
						Nodes: []timelineItem{
							{
								Typename: "IssueComment",
								IssueComment: issueComment{
									authorEvent: authorEvent{
										Id: 301,
										Author: &actor{
											Typename: "User",
											User: userActor{
												Name:  &userName,
												Email: userEmail,
											},
										},
									},
									Body: "issue 3 comment 1",
									Url: githubv4.URI{
										URL: &url.URL{
											Scheme: "https",
											Host:   "github.com",
											Path:   "marcus/to-himself/issues/3#issuecomment-1",
										},
									},
									UserContentEdits: userContentEditConnection{},
								},
							},
							{
								Typename: "IssueComment",
								IssueComment: issueComment{
									authorEvent: authorEvent{
										Id: 302,
										Author: &actor{
											Typename: "User",
											User: userActor{
												Name:  &userName,
												Email: userEmail,
											},
										},
									},
									Body: "issue 3 comment 2",
									Url: githubv4.URI{
										URL: &url.URL{
											Scheme: "https",
											Host:   "github.com",
											Path:   "marcus/to-himself/issues/3#issuecomment-2",
										},
									},
									UserContentEdits: userContentEditConnection{},
								},
							},
							{
								Typename: "LabeledEvent",
								LabeledEvent: labeledEvent{
									actorEvent: actorEvent{
										Id: 303,
										Actor: &actor{
											Typename: "User",
											User: userActor{
												Name:  &userName,
												Email: userEmail,
											},
										},
									},
									Label: label{
										Name: "bug",
									},
								},
							},
							{
								Typename: "RenamedTitleEvent",
								RenamedTitleEvent: renamedTitleEvent{
									actorEvent: actorEvent{
										Id: 304,
										Actor: &actor{
											Typename: "User",
											User: userActor{
												Name:  &userName,
												Email: userEmail,
											},
										},
									},
									CurrentTitle: "title 3, edit 1",
								},
							},
						},
						PageInfo: pageInfo{},
					},
				},
				{
					issue: issue{
						authorEvent: authorEvent{
							Id: 4,
							Author: &actor{
								Typename: "User",
								User: userActor{
									Name:  &userName,
									Email: userEmail,
								},
							},
						},
						Title:  "title 4",
						Number: 4,
						Body:   unedited,
						Url: githubv4.URI{
							URL: &url.URL{
								Scheme: "https",
								Host:   "github.com",
								Path:   "marcus/to-himself/issues/4",
							},
						},
					},
					UserContentEdits: userContentEditConnection{
						Nodes: []userContentEdit{
							// Github is weird: here the order is reversed chronological
							{
								Id: 402,
								Editor: &actor{
									Typename: "User",
									User: userActor{
										Name:  &userName,
										Email: userEmail,
									},
								},
								Diff: &edited,
							},
							{
								Id: 401,
								Editor: &actor{
									Typename: "User",
									User: userActor{
										Name:  &userName,
										Email: userEmail,
									},
								},
								// Github is weird: whenever an issue has issue edits, then the first item
								// (issue edit) holds the original (unedited) content and the second item
								// (issue edit) holds the (first) edited content.
								Diff: &unedited,
							},
						},
						PageInfo: pageInfo{},
					},
					TimelineItems: timelineItemsConnection{},
				},
			}
			retVal.Repository.Issues.PageInfo = pageInfo{
				EndCursor:   "end-cursor-2",
				HasNextPage: true,
			}
		},
	).Once()
}

func expectIssueQuery3(mock *mocks.Client) {
	mock.On("Query", m.Anything, m.AnythingOfType("*github.issueQuery"), m.Anything).Return(nil).Run(
		func(args m.Arguments) {
			retVal := args.Get(1).(*issueQuery)
			retVal.Repository.Issues.Nodes = []issueNode{
				{
					issue: issue{
						authorEvent: authorEvent{
							Author: nil,
						},
						Title:  "title 5",
						Number: 5,
						Body:   "body text 5",
						Url: githubv4.URI{
							URL: &url.URL{
								Scheme: "https",
								Host:   "github.com",
								Path:   "marcus/to-himself/issues/5",
							},
						},
					},
					UserContentEdits: userContentEditConnection{},
					TimelineItems:    timelineItemsConnection{},
				},
			}
			retVal.Repository.Issues.PageInfo = pageInfo{}
		},
	).Once()
}

func expectUserQuery(t *testing.T, mock *mocks.Client) {
	mock.On("Query", m.Anything, m.AnythingOfType("*github.userQuery"), m.AnythingOfType("map[string]interface {}")).Return(nil).Run(
		func(args m.Arguments) {
			vars := args.Get(2).(map[string]interface{})
			ghost := githubv4.String("ghost")
			require.Equal(t, ghost, vars["login"])

			retVal := args.Get(1).(*userQuery)
			retVal.User.Name = &ghost
			retVal.User.Login = "ghost-login"
		},
	).Once()
}