check_test.go

package resource_test

import (
	"testing"

	"github.com/shurcooL/githubv4"
	"github.com/stretchr/testify/assert"
	resource "github.com/telia-oss/github-pr-resource"
	"github.com/telia-oss/github-pr-resource/fakes"
)

var (
	standardTestPRs = []*resource.PullRequest{
		createTestPR(0, "master", "anonymous", true, false, 0, nil, false, githubv4.PullRequestStateOpen),
		createTestPR(1, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
		createTestPR(2, "master", "anonymous", false, false, 0, nil, true, githubv4.PullRequestStateOpen),
		createTestPR(3, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
		createTestPR(4, "master", "anonymous", false, true, 0, nil, false, githubv4.PullRequestStateOpen),
		createTestPR(5, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
		createTestPR(6, "develop", "anonymous", false, false, 0, []string{"enhancement"}, false, githubv4.PullRequestStateOpen),
		createTestPR(7, "master", "anonymous", false, false, 1, []string{"wontfix"}, false, githubv4.PullRequestStateOpen),
		createTestPR(8, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
		createTestPR(9, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateClosed),
		createTestPR(10, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateMerged),
		createTestPR(11, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
	}
	multiTeamTestPRs = []*resource.PullRequest{
		createTestPR(0, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
		createTestPR(1, "master", "foo-member", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
		createTestPR(2, "master", "bar-member", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
	}
)

func TestCheck(t *testing.T) {
	tests := []struct {
		description     string
		source          resource.Source
		version         resource.Version
		files           [][]string
		pullRequests    []*resource.PullRequest
		expectedIndexes []int
	}{
		{
			description: "check returns the latest version if there is no previous",
			source: resource.Source{
				Repository:  "itsdalmo/test-repository",
				AccessToken: "oauthtoken",
			},
			pullRequests:    standardTestPRs,
			files:           [][]string{},
			expectedIndexes: []int{1},
		},

		{
			description: "check returns all open PRs if there is a previous",
			source: resource.Source{
				Repository:  "itsdalmo/test-repository",
				AccessToken: "oauthtoken",
			},
			version:         resource.NewVersion(standardTestPRs[1]),
			pullRequests:    standardTestPRs,
			files:           [][]string{},
			expectedIndexes: []int{11, 8, 7, 6, 5, 4, 3, 2, 1},
		},

		{
			description: "check will only return versions that match the specified paths",
			source: resource.Source{
				Repository:  "itsdalmo/test-repository",
				AccessToken: "oauthtoken",
				Paths:       []string{"terraform/*/*.tf", "terraform/*/*/*.tf"},
			},
			version:      resource.NewVersion(standardTestPRs[3]),
			pullRequests: standardTestPRs,
			files: [][]string{
				{"README.md", "travis.yml"},
				{"terraform/modules/ecs/main.tf", "README.md"},
				{"terraform/modules/variables.tf", "travis.yml"},
			},
			expectedIndexes: []int{3, 2},
		},

		{
			description: "check will skip versions which only match the ignore paths",
			source: resource.Source{
				Repository:  "itsdalmo/test-repository",
				AccessToken: "oauthtoken",
				IgnorePaths: []string{"*.md", "*.yml"},
			},
			version:      resource.NewVersion(standardTestPRs[3]),
			pullRequests: standardTestPRs,
			files: [][]string{
				{"README.md", "travis.yml"},
				{"terraform/modules/ecs/main.tf", "README.md"},
				{"terraform/modules/variables.tf", "travis.yml"},
			},
			expectedIndexes: []int{3, 2},
		},

		{
			description: "check correctly ignores [skip ci] when specified",
			source: resource.Source{
				Repository:    "itsdalmo/test-repository",
				AccessToken:   "oauthtoken",
				DisableCISkip: true,
			},
			version:         resource.NewVersion(standardTestPRs[1]),
			pullRequests:    standardTestPRs,
			expectedIndexes: []int{11, 8, 7, 6, 5, 4, 3, 2, 1, 0},
		},

		{
			description: "check correctly ignores drafts when drafts are ignored",
			source: resource.Source{
				Repository:   "itsdalmo/test-repository",
				AccessToken:  "oauthtoken",
				IgnoreDrafts: true,
			},
			version:         resource.NewVersion(standardTestPRs[3]),
			pullRequests:    standardTestPRs,
			expectedIndexes: []int{11, 8, 7, 6, 5, 4, 3, 1},
		},

		{
			description: "check does not ignore drafts when drafts are not ignored",
			source: resource.Source{
				Repository:   "itsdalmo/test-repository",
				AccessToken:  "oauthtoken",
				IgnoreDrafts: false,
			},
			version:         resource.NewVersion(standardTestPRs[3]),
			pullRequests:    standardTestPRs,
			expectedIndexes: []int{11, 8, 7, 6, 5, 4, 3, 2, 1},
		},

		{
			description: "check correctly ignores cross repo pull requests",
			source: resource.Source{
				Repository:   "itsdalmo/test-repository",
				AccessToken:  "oauthtoken",
				DisableForks: true,
			},
			version:         resource.NewVersion(standardTestPRs[5]),
			pullRequests:    standardTestPRs,
			expectedIndexes: []int{11, 8, 7, 6, 5, 3, 2, 1},
		},

		{
			description: "check supports specifying base branch",
			source: resource.Source{
				Repository:  "itsdalmo/test-repository",
				AccessToken: "oauthtoken",
				BaseBranch:  "develop",
			},
			pullRequests:    standardTestPRs,
			files:           [][]string{},
			expectedIndexes: []int{6},
		},

		{
			description: "check always allows prs from team members",
			pullRequests: []*resource.PullRequest{
				createTestPR(0, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
				createTestPR(1, "master", "foo-member", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
			},
			source: resource.Source{
				Repository:              "itsdalmo/test-repository",
				AccessToken:             "oauthtoken",
				RequiredReviewApprovals: 1,
				TrustedTeams:            []string{"foo"},
			},
			expectedIndexes: []int{1},
		},

		{
			description:  "check always allows prs from team members from more than one team",
			pullRequests: multiTeamTestPRs,
			source: resource.Source{
				Repository:              "itsdalmo/test-repository",
				AccessToken:             "oauthtoken",
				RequiredReviewApprovals: 1,
				TrustedTeams:            []string{"foo", "bar"},
			},
			version:         resource.NewVersion(multiTeamTestPRs[1]),
			expectedIndexes: []int{2, 1},
		},

		{
			description: "check does not allow prs from non-members",
			pullRequests: []*resource.PullRequest{
				createTestPR(0, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
			},
			source: resource.Source{
				Repository:              "itsdalmo/test-repository",
				AccessToken:             "oauthtoken",
				RequiredReviewApprovals: 1,
				TrustedTeams:            []string{"foo"},
			},
			expectedIndexes: nil,
		},

		{
			description: "check allows approved prs from non-members",
			pullRequests: []*resource.PullRequest{
				createTestPR(0, "master", "anonymous", false, false, 1, nil, false, githubv4.PullRequestStateOpen),
			},
			source: resource.Source{
				Repository:              "itsdalmo/test-repository",
				AccessToken:             "oauthtoken",
				RequiredReviewApprovals: 1,
				TrustedTeams:            []string{"foo"},
			},
			expectedIndexes: []int{0},
		},

		{
			description: "check always allows approved prs from team members",
			pullRequests: []*resource.PullRequest{
				createTestPR(0, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
				createTestPR(1, "master", "foo-member", false, false, 1, nil, false, githubv4.PullRequestStateOpen),
			},
			source: resource.Source{
				Repository:              "itsdalmo/test-repository",
				AccessToken:             "oauthtoken",
				RequiredReviewApprovals: 1,
				TrustedTeams:            []string{"foo"},
			},
			expectedIndexes: []int{1},
		},

		{
			description: "check always allows prs from trusted users",
			pullRequests: []*resource.PullRequest{
				createTestPR(0, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
				createTestPR(1, "master", "dependabot[bot]", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
			},
			source: resource.Source{
				Repository:              "itsdalmo/test-repository",
				AccessToken:             "oauthtoken",
				RequiredReviewApprovals: 1,
				TrustedUsers:            []string{"dependabot[bot]"},
			},
			expectedIndexes: []int{1},
		},

		{
			description: "check always allows approved prs from dependabot",
			pullRequests: []*resource.PullRequest{
				createTestPR(0, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
				createTestPR(1, "master", "dependabot[bot]", false, false, 1, nil, false, githubv4.PullRequestStateOpen),
			},
			source: resource.Source{
				Repository:              "itsdalmo/test-repository",
				AccessToken:             "oauthtoken",
				RequiredReviewApprovals: 1,
				TrustedUsers:            []string{"dependabot[bot]"},
			},
			expectedIndexes: []int{1},
		},

		{
			description: "check returns latest version from a PR with at least one of the desired labels on it",
			source: resource.Source{
				Repository:  "itsdalmo/test-repository",
				AccessToken: "oauthtoken",
				Labels:      []string{"enhancement"},
			},
			pullRequests:    standardTestPRs,
			files:           [][]string{},
			expectedIndexes: []int{6},
		},

		{
			description: "check returns latest version from a PR with a single state filter",
			source: resource.Source{
				Repository:  "itsdalmo/test-repository",
				AccessToken: "oauthtoken",
				States:      []githubv4.PullRequestState{githubv4.PullRequestStateClosed},
			},
			pullRequests:    standardTestPRs,
			files:           [][]string{},
			expectedIndexes: []int{9},
		},

		{
			description: "check filters out versions from a PR which do not match the state filter",
			source: resource.Source{
				Repository:  "itsdalmo/test-repository",
				AccessToken: "oauthtoken",
				States:      []githubv4.PullRequestState{githubv4.PullRequestStateOpen},
			},
			pullRequests:    standardTestPRs[9:11],
			files:           [][]string{},
			expectedIndexes: nil,
		},

		{
			description: "check returns versions from a PR with multiple state filters",
			source: resource.Source{
				Repository:  "itsdalmo/test-repository",
				AccessToken: "oauthtoken",
				States:      []githubv4.PullRequestState{githubv4.PullRequestStateClosed, githubv4.PullRequestStateMerged},
			},
			version:         resource.NewVersion(standardTestPRs[11]),
			pullRequests:    standardTestPRs,
			files:           [][]string{},
			expectedIndexes: []int{9, 10},
		},
	}

	for _, tc := range tests {
		t.Run(tc.description, func(t *testing.T) {
			github := new(fakes.FakeGithub)
			pullRequests := []*resource.PullRequest{}
			filterStates := []githubv4.PullRequestState{githubv4.PullRequestStateOpen}
			if len(tc.source.States) > 0 {
				filterStates = tc.source.States
			}
			for i := range tc.pullRequests {
				for j := range filterStates {
					if filterStates[j] == tc.pullRequests[i].State {
						pullRequests = append(pullRequests, tc.pullRequests[i])
						break
					}
				}
			}
			github.ListPullRequestsReturns(pullRequests, nil)

			for i, file := range tc.files {
				github.ListModifiedFilesReturnsOnCall(i, file, nil)
			}

			github.ListTeamMembersStub = func(teamName string) ([]string, error) {
				switch teamName {
				case "foo":
					return []string{"foo-member"}, nil
				case "bar":
					return []string{"bar-member"}, nil
				}
				return []string{}, nil
			}

			input := resource.CheckRequest{Source: tc.source, Version: tc.version}
			output, err := resource.Check(input, github)

			var expectedOutput resource.CheckResponse
			for _, idx := range tc.expectedIndexes {
				expectedOutput = append(expectedOutput, resource.NewVersion(tc.pullRequests[idx]))
			}

			if assert.NoError(t, err) {
				assert.Equal(t, expectedOutput, output)
			}
			assert.Equal(t, 1, github.ListPullRequestsCallCount())
		})
	}
}

func TestContainsSkipCI(t *testing.T) {
	tests := []struct {
		description string
		message     string
		want        bool
	}{
		{
			description: "does not just match any symbol in the regexp",
			message:     "(",
			want:        false,
		},
		{
			description: "does not match when it should not",
			message:     "test",
			want:        false,
		},
		{
			description: "matches [ci skip]",
			message:     "[ci skip]",
			want:        true,
		},
		{
			description: "matches [skip ci]",
			message:     "[skip ci]",
			want:        true,
		},
		{
			description: "matches trailing skip ci",
			message:     "trailing [skip ci]",
			want:        true,
		},
		{
			description: "matches leading skip ci",
			message:     "[skip ci] leading",
			want:        true,
		},
		{
			description: "is case insensitive",
			message:     "case[Skip CI]insensitive",
			want:        true,
		},
	}

	for _, tc := range tests {
		t.Run(tc.description, func(t *testing.T) {
			got := resource.ContainsSkipCI(tc.message)
			assert.Equal(t, tc.want, got)
		})
	}
}

func TestFilterPath(t *testing.T) {
	cases := []struct {
		description string
		pattern     string
		files       []string
		want        []string
	}{
		{
			description: "returns all matching files",
			pattern:     "*.txt",
			files: []string{
				"file1.txt",
				"test/file2.txt",
			},
			want: []string{
				"file1.txt",
			},
		},
		{
			description: "works with wildcard",
			pattern:     "test/*",
			files: []string{
				"file1.txt",
				"test/file2.txt",
			},
			want: []string{
				"test/file2.txt",
			},
		},
		{
			description: "excludes unmatched files",
			pattern:     "*/*.txt",
			files: []string{
				"test/file1.go",
				"test/file2.txt",
			},
			want: []string{
				"test/file2.txt",
			},
		},
		{
			description: "handles prefix matches",
			pattern:     "foo/",
			files: []string{
				"foo/a",
				"foo/a.txt",
				"foo/a/b/c/d.txt",
				"foo",
				"bar",
				"bar/a.txt",
			},
			want: []string{
				"foo/a",
				"foo/a.txt",
				"foo/a/b/c/d.txt",
			},
		},
	}
	for _, tc := range cases {
		t.Run(tc.description, func(t *testing.T) {
			got, err := resource.FilterPath(tc.files, tc.pattern)
			if assert.NoError(t, err) {
				assert.Equal(t, tc.want, got)
			}
		})
	}
}

func TestFilterIgnorePath(t *testing.T) {
	cases := []struct {
		description string
		pattern     string
		files       []string
		want        []string
	}{
		{
			description: "excludes all matching files",
			pattern:     "*.txt",
			files: []string{
				"file1.txt",
				"test/file2.txt",
			},
			want: []string{
				"test/file2.txt",
			},
		},
		{
			description: "works with wildcard",
			pattern:     "test/*",
			files: []string{
				"file1.txt",
				"test/file2.txt",
			},
			want: []string{
				"file1.txt",
			},
		},
		{
			description: "includes unmatched files",
			pattern:     "*/*.txt",
			files: []string{
				"test/file1.go",
				"test/file2.txt",
			},
			want: []string{
				"test/file1.go",
			},
		},
		{
			description: "handles prefix matches",
			pattern:     "foo/",
			files: []string{
				"foo/a",
				"foo/a.txt",
				"foo/a/b/c/d.txt",
				"foo",
				"bar",
				"bar/a.txt",
			},
			want: []string{
				"foo",
				"bar",
				"bar/a.txt",
			},
		},
	}
	for _, tc := range cases {
		t.Run(tc.description, func(t *testing.T) {
			got, err := resource.FilterIgnorePath(tc.files, tc.pattern)
			if assert.NoError(t, err) {
				assert.Equal(t, tc.want, got)
			}
		})
	}
}

func TestIsInsidePath(t *testing.T) {
	cases := []struct {
		description string
		parent      string

		expectChildren    []string
		expectNotChildren []string

		want bool
	}{
		{
			description: "basic test",
			parent:      "foo/bar",
			expectChildren: []string{
				"foo/bar",
				"foo/bar/baz",
			},
			expectNotChildren: []string{
				"foo/barbar",
				"foo/baz/bar",
			},
		},
		{
			description: "does not match parent directories against child files",
			parent:      "foo/",
			expectChildren: []string{
				"foo/bar",
			},
			expectNotChildren: []string{
				"foo",
			},
		},
		{
			description: "matches parents without trailing slash",
			parent:      "foo/bar",
			expectChildren: []string{
				"foo/bar",
				"foo/bar/baz",
			},
		},
		{
			description: "handles children that are shorter than the parent",
			parent:      "foo/bar/baz",
			expectNotChildren: []string{
				"foo",
				"foo/bar",
			},
		},
	}

	for _, tc := range cases {
		t.Run(tc.description, func(t *testing.T) {
			for _, expectedChild := range tc.expectChildren {
				if !resource.IsInsidePath(tc.parent, expectedChild) {
					t.Errorf("Expected \"%s\" to be inside \"%s\"", expectedChild, tc.parent)
				}
			}

			for _, expectedNotChild := range tc.expectNotChildren {
				if resource.IsInsidePath(tc.parent, expectedNotChild) {
					t.Errorf("Expected \"%s\" to not be inside \"%s\"", expectedNotChild, tc.parent)
				}
			}
		})
	}
}

func TestCheckTeamMemberCache(t *testing.T) {
	t.Run("foo", func(t *testing.T) {
		github := new(fakes.FakeGithub)

		github.ListTeamMembersReturns([]string{"member"}, nil)

		prs := []*resource.PullRequest{
			createTestPR(0, "master", "anonymous", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
			createTestPR(1, "master", "member", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
			createTestPR(2, "master", "member", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
			createTestPR(3, "master", "member", false, false, 0, nil, false, githubv4.PullRequestStateOpen),
		}
		github.ListPullRequestsReturns(prs, nil)

		input := resource.CheckRequest{
			Source: resource.Source{
				Repository:   "itsdalmo/test-repository",
				AccessToken:  "oauthtoken",
				TrustedTeams: []string{"team"},
			},
			Version: resource.NewVersion(prs[0]),
		}
		_, err := resource.Check(input, github)
		assert.Equal(t, nil, err)
		assert.Equal(t, 1, github.ListTeamMembersCallCount())
	})
}