feat: add support for ignoring teams, repositories and users (#172)

* chore: extract locals out of state

* feat: add support for ignoring teams, repositories and users

* test: test ignoring entities via locals

* chore: move members filter

Author: galargh

scripts/__tests__/__resources__/terraform/locals_override.tf

@@ -10,4 +10,9 @@ locals {
     "github_repository_file",
     "github_issue_label"
   ]
+  ignore = {
+    "repositories" = ["ignored"]
+    "teams" = ["ignored"]
+    "users" = ["ignored"]
+  }
 }

scripts/__tests__/github.test.ts

@@ -0,0 +1,235 @@
+import 'reflect-metadata'
+
+import {before, describe, it} from 'node:test'
+import assert from 'node:assert'
+import {mockGitHub} from './github.js'
+import {GitHub} from '../src/github.js'
+
+describe('github', () => {
+  let github: GitHub
+
+  before(async () => {
+    mockGitHub({
+      invitations: [
+        {
+          login: 'ignored'
+        },
+        {
+          login: 'unignored'
+        }
+      ],
+      members: [
+        {
+          login: 'ignored'
+        },
+        {
+          login: 'unignored'
+        }
+      ],
+      repositories: [
+        {
+          name: 'ignored',
+          branchProtectionRules: [
+            {
+              pattern: 'ignored'
+            },
+            {
+              pattern: 'unignored'
+            }
+          ],
+          collaborators: [
+            {
+              login: 'ignored'
+            },
+            {
+              login: 'unignored'
+            }
+          ],
+          invitations: [
+            {
+              login: 'ignored'
+            },
+            {
+              login: 'unignored'
+            }
+          ],
+          labels: [
+            {
+              name: 'ignored'
+            },
+            {
+              name: 'unignored'
+            }
+          ]
+        },
+        {
+          name: 'unignored',
+          branchProtectionRules: [
+            {
+              pattern: 'ignored'
+            },
+            {
+              pattern: 'unignored'
+            }
+          ],
+          collaborators: [
+            {
+              login: 'ignored'
+            },
+            {
+              login: 'unignored'
+            }
+          ],
+          invitations: [
+            {
+              login: 'ignored'
+            },
+            {
+              login: 'unignored'
+            }
+          ],
+          labels: [
+            {
+              name: 'ignored'
+            },
+            {
+              name: 'unignored'
+            }
+          ]
+        }
+      ],
+      teams: [
+        {
+          name: 'ignored',
+          members: [
+            {
+              login: 'ignored'
+            },
+            {
+              login: 'unignored'
+            }
+          ],
+          invitations: [
+            {
+              login: 'ignored'
+            },
+            {
+              login: 'unignored'
+            }
+          ],
+          repositories: [
+            {
+              name: 'ignored'
+            },
+            {
+              name: 'unignored'
+            }
+          ]
+        },
+        {
+          name: 'unignored',
+          members: [
+            {
+              login: 'ignored'
+            },
+            {
+              login: 'unignored'
+            }
+          ],
+          invitations: [
+            {
+              login: 'ignored'
+            },
+            {
+              login: 'unignored'
+            }
+          ],
+          repositories: [
+            {
+              name: 'ignored'
+            },
+            {
+              name: 'unignored'
+            }
+          ]
+        }
+      ]
+    })
+    github = await GitHub.getGitHub()
+  })
+
+  it('listInvitations', async () => {
+    const invitations = await github.listInvitations()
+    assert.ok(invitations.length > 0)
+    assert.ok(!invitations.some(i => i.login === 'ignored'))
+  })
+
+  it('listMembers', async () => {
+    const members = await github.listMembers()
+    assert.ok(members.length > 0)
+    assert.ok(!members.some(m => m.user?.login === 'ignored'))
+  })
+
+  it('listRepositories', async () => {
+    const repositories = await github.listRepositories()
+    assert.ok(repositories.length > 0)
+    assert.ok(!repositories.some(r => r.name === 'ignored'))
+  })
+
+  it('listRepositoryBranchProtectionRules', async () => {
+    const rules = await github.listRepositoryBranchProtectionRules()
+    assert.ok(rules.length > 0)
+    assert.ok(!rules.some(r => r.repository.name === 'ignored'))
+    // NOTE: Ignoring rules by pattern is not supported yet
+    assert.ok(rules.some(r => r.branchProtectionRule.pattern === 'ignored'))
+  })
+
+  it('listRepositoryCollaborators', async () => {
+    const collaborators = await github.listRepositoryCollaborators()
+    assert.ok(collaborators.length > 0)
+    assert.ok(!collaborators.some(c => c.repository.name === 'ignored'))
+    assert.ok(!collaborators.some(c => c.collaborator.login === 'ignored'))
+  })
+
+  it('listRepositoryInvitations', async () => {
+    const invitations = await github.listRepositoryInvitations()
+    assert.ok(invitations.length > 0)
+    assert.ok(!invitations.some(i => i.repository.name === 'ignored'))
+    assert.ok(!invitations.some(i => i.invitee?.login === 'ignored'))
+  })
+
+  it('listRepositoryLabels', async () => {
+    const labels = await github.listRepositoryLabels()
+    assert.ok(labels.length > 0)
+    assert.ok(!labels.some(l => l.repository.name === 'ignored'))
+    // NOTE: Ignoring labels by name is not supported yet
+    assert.ok(labels.some(l => l.label.name === 'ignored'))
+  })
+
+  it('listTeams', async () => {
+    const teams = await github.listTeams()
+    assert.ok(teams.length > 0)
+    assert.ok(!teams.some(t => t.name === 'ignored'))
+  })
+
+  it('listTeamInvitations', async () => {
+    const invitations = await github.listTeamInvitations()
+    assert.ok(invitations.length > 0)
+    assert.ok(!invitations.some(i => i.team.name === 'ignored'))
+    assert.ok(!invitations.some(i => i.invitation.login === 'ignored'))
+  })
+
+  it('listTeamMembers', async () => {
+    const members = await github.listTeamMembers()
+    assert.ok(members.length > 0)
+    assert.ok(!members.some(m => m.team.name === 'ignored'))
+    assert.ok(!members.some(m => m.member.login === 'ignored'))
+  })
+
+  it('listTeamRepositories', async () => {
+    const repositories = await github.listTeamRepositories()
+    assert.ok(repositories.length > 0)
+    assert.ok(!repositories.some(r => r.team.name === 'ignored'))
+    assert.ok(!repositories.some(r => r.repository.name === 'ignored'))
+  })
+})

scripts/__tests__/github.ts

@@ -1,6 +1,42 @@
 import {mock} from 'node:test'
 
-export function mockGitHub(): void {
+export interface GitHubConfig {
+  repositories?: {
+    name: string
+    collaborators?: {
+      login: string
+    }[]
+    branchProtectionRules?: {
+      pattern: string
+    }[]
+    invitations?: {
+      login: string
+    }[]
+    labels?: {
+      name: string
+    }[]
+  }[]
+  teams?: {
+    name: string
+    members?: {
+      login: string
+    }[]
+    invitations?: {
+      login: string
+    }[]
+    repositories?: {
+      name: string
+    }[]
+  }[]
+  invitations?: {
+    login: string
+  }[]
+  members?: {
+    login: string
+  }[]
+}
+
+export function mockGitHub(config: GitHubConfig = {}): void {
   mock.module('@octokit/auth-app', {
     namedExports: {
       createAppAuth: () => () => ({token: undefined})
@@ -16,13 +52,16 @@ export function mockGitHub(): void {
             issues = {
               listCommentsForRepo: async () => [],
               listForRepo: async () => [],
-              listLabelsForRepo: async () => []
+              listLabelsForRepo: async (opts: {repo: string}) =>
+                config?.repositories?.find(r => r.name === opts.repo)?.labels ??
+                []
             }
             orgs = {
-              getMembershipForUser: async () => {},
-              listInvitationTeams: async () => [],
-              listMembers: async () => [],
-              listPendingInvitations: async () => []
+              getMembershipForUser: async () => ({
+                data: {}
+              }),
+              listMembers: async () => config?.members ?? [],
+              listPendingInvitations: async () => config?.invitations ?? []
             }
             pulls = {
               listReviewCommentsForRepo: async () => []
@@ -50,24 +89,64 @@ export function mockGitHub(): void {
                 }
               }),
               listActivities: async () => [],
-              listCollaborators: async () => [],
+              listCollaborators: async (opts: {repo: string}) =>
+                config?.repositories?.find(r => r.name === opts.repo)
+                  ?.collaborators ?? [],
               listCommitCommentsForRepo: async () => [],
-              listForOrg: async () => [],
-              listInvitations: async () => []
+              listForOrg: async () => config?.repositories ?? [],
+              listInvitations: async (opts: {repo: string}) => {
+                const repository = config?.repositories?.find(
+                  r => r.name === opts.repo
+                )
+
+                return repository?.invitations?.map(invitee => ({
+                  repository,
+                  invitee
+                }))
+              }
             }
             teams = {
-              getMembershipForUserInOrg: async () => {},
-              list: async () => [],
-              listMembersInOrg: async () => [],
-              listPendingInvitationsInOrg: async () => [],
-              listReposInOrg: async () => []
+              getMembershipForUserInOrg: async () => ({
+                data: {}
+              }),
+              list: async () =>
+                config?.teams?.map(t => ({slug: t.name, ...t})) ?? [],
+              listMembersInOrg: async (opts: {team_slug: string}) =>
+                config?.teams?.find(t => t.name === opts.team_slug)?.members ??
+                [],
+              listPendingInvitationsInOrg: async (opts: {team_slug: string}) =>
+                config?.teams?.find(t => t.name === opts.team_slug)
+                  ?.invitations ?? [],
+              listReposInOrg: async (opts: {team_slug: string}) =>
+                config?.teams?.find(t => t.name === opts.team_slug)
+                  ?.repositories ?? []
             }
             async paginate<T, K>(
               f: (opts: K) => Promise<T>,
               opts: K
             ): Promise<T> {
               return f(opts)
             }
+            async graphql(query: string): Promise<unknown> {
+              // extract owner and repo from query using repository\(owner: \"([^\"]+)\", name: \"([^\"]+)\"\)
+              const match = query.match(
+                /repository\(owner: "([^"]+)", name: "([^"]+)"\)/
+              )
+              if (match === null) {
+                throw new Error(`Could not find repository in query: ${query}`)
+              }
+              const [, , repo] = match
+              const nodes =
+                config.repositories?.find(r => r.name === repo)
+                  ?.branchProtectionRules ?? []
+              return {
+                repository: {
+                  branchProtectionRules: {
+                    nodes
+                  }
+                }
+              }
+            }
           }
         }
       }