Deploy to production

.github/workflows/invite-guest.yml

@@ -16,7 +16,7 @@ on:
         description: E-mail address to send invitation to
         required: true
       roles:
-        description: Comma-separated list of roles
+        description: Comma-separated list of repositories user needs access to
         required: true
 env:
   OP_SERVICE_ACCOUNT_TOKEN: ${{ secrets.OP_SERVICE_ACCOUNT_TOKEN_SHAPE_DOCS }}

__test__/auth/AccessTokenService.test.ts

@@ -1,86 +1,121 @@
 import { AccessTokenService } from "../../src/features/auth/domain"
-import { OAuthToken } from "../../src/features/auth/domain"
 
-test("It gets the access token for the user", async () => {
-  let readUserID: string | undefined
+test("It reads the access token for a guest user", async () => {
+  let didReadAccessToken = false
   const sut = new AccessTokenService({
-    userIdReader: {
-      async getUserId() {
-        return "1234"
+    isGuestReader: {
+      async getIsGuest() {
+        return true
       }
     },
-    repository: {
-      async get(userId) {
-        readUserID = userId
-        return { accessToken: "foo", refreshToken: "bar" }
+    guestAccessTokenService: {
+      async getAccessToken() {
+        didReadAccessToken = true
+        return "oldAccessToken"
       },
-      async set() {},
-      async delete() {},
+      async refreshAccessToken() {
+        return "newAccessToken"
+      }
     },
-    refresher: {
-      async refreshOAuthToken() {
-        return { accessToken: "foo", refreshToken: "bar" }
+    hostAccessTokenService: {
+      async getAccessToken() {
+        return "oldAccessToken"
+      },
+      async refreshAccessToken() {
+        return "newAccessToken"
       }
     }
   })
-  const accessToken = await sut.getAccessToken()
-  expect(readUserID).toBe("1234")
-  expect(accessToken).toBe("foo")
+  await sut.getAccessToken()
+  expect(didReadAccessToken).toBeTruthy()
 })
 
-test("It refreshes OAuth using stored refresh token", async () => {
-  let usedRefreshToken: string | undefined
+test("It refreshes the access token for a guest user", async () => {
+  let didRefreshAccessToken = false
   const sut = new AccessTokenService({
-    userIdReader: {
-      async getUserId() {
-        return "1234"
+    isGuestReader: {
+      async getIsGuest() {
+        return true
       }
     },
-    repository: {
-      async get() {
-        return { accessToken: "oldAccessToken", refreshToken: "oldRefreshToken" }
+    guestAccessTokenService: {
+      async getAccessToken() {
+        return "oldAccessToken"
       },
-      async set() {},
-      async delete() {},
+      async refreshAccessToken() {
+        didRefreshAccessToken = true
+        return "newAccessToken"
+      }
     },
-    refresher: {
-      async refreshOAuthToken(refreshToken) {
-        usedRefreshToken = refreshToken
-        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+    hostAccessTokenService: {
+      async getAccessToken() {
+        return "oldAccessToken"
+      },
+      async refreshAccessToken() {
+        return "newAccessToken"
       }
     }
   })
   await sut.refreshAccessToken("oldAccessToken")
-  expect(usedRefreshToken).toBe("oldRefreshToken")
+  expect(didRefreshAccessToken).toBeTruthy()
 })
 
-test("It stores the new OAuth token for the user", async () => {
-  let storedUserId: string | undefined
-  let storedOAuthToken: OAuthToken | undefined
+test("It reads the access token for a host user", async () => {
+  let didReadAccessToken = false
   const sut = new AccessTokenService({
-    userIdReader: {
-      async getUserId() {
-        return "1234"
+    isGuestReader: {
+      async getIsGuest() {
+        return false
       }
     },
-    repository: {
-      async get() {
-        return { accessToken: "oldAccessToken", refreshToken: "oldRefreshToken" }
+    guestAccessTokenService: {
+      async getAccessToken() {
+        return "oldAccessToken"
       },
-      async set(userId, oAuthToken) {
-        storedUserId = userId
-        storedOAuthToken = oAuthToken
+      async refreshAccessToken() {
+        return "newAccessToken"
+      }
+    },
+    hostAccessTokenService: {
+      async getAccessToken() {
+        didReadAccessToken = true
+        return "oldAccessToken"
+      },
+      async refreshAccessToken() {
+        return "newAccessToken"
+      }
+    }
+  })
+  await sut.getAccessToken()
+  expect(didReadAccessToken).toBeTruthy()
+})
+
+test("It refreshes the access token for a host user", async () => {
+  let didRefreshAccessToken = false
+  const sut = new AccessTokenService({
+    isGuestReader: {
+      async getIsGuest() {
+        return false
+      }
+    },
+    guestAccessTokenService: {
+      async getAccessToken() {
+        return "oldAccessToken"
       },
-      async delete() {},
+      async refreshAccessToken() {
+        return "newAccessToken"
+      }
     },
-    refresher: {
-      async refreshOAuthToken() {
-        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+    hostAccessTokenService: {
+      async getAccessToken() {
+        return "oldAccessToken"
+      },
+      async refreshAccessToken() {
+        didRefreshAccessToken = true
+        return "newAccessToken"
       }
     }
   })
-  await sut.refreshAccessToken("foo")
-  expect(storedUserId).toBe("1234")
-  expect(storedOAuthToken?.accessToken).toBe("newAccessToken")
-  expect(storedOAuthToken?.refreshToken).toBe("newRefreshToken")
+  await sut.refreshAccessToken("oldAccessToken")
+  expect(didRefreshAccessToken).toBeTruthy()
 })

__test__/auth/CachingRepositoryAccessReaderConfig.ts

@@ -0,0 +1,94 @@
+import { CachingRepositoryAccessReaderConfig } from "../../src/features/auth/domain"
+
+test("It fetches repository names for user if they are not cached", async () => {
+  let didFetchRepositoryNames = false
+  let requestedUserId: string | undefined
+  const sut = new CachingRepositoryAccessReaderConfig({
+    repository: {
+      async get() {
+        return null
+      },
+      async set() {},
+      async setExpiring() {},
+      async delete() {}
+    },
+    repositoryAccessReader: {
+      async getRepositoryNames(userId: string) {
+        didFetchRepositoryNames = true
+        requestedUserId = userId
+        return []
+      }
+    }
+  })
+  await sut.getRepositoryNames("1234")
+  expect(didFetchRepositoryNames).toBeTruthy()
+  expect(requestedUserId).toEqual("1234")
+})
+
+test("It does not fetch repository names if they are cached", async () => {
+  let didFetchRepositoryNames = false
+  const sut = new CachingRepositoryAccessReaderConfig({
+    repository: {
+      async get() {
+        return "[\"foo\"]"
+      },
+      async set() {},
+      async setExpiring() {},
+      async delete() {}
+    },
+    repositoryAccessReader: {
+      async getRepositoryNames() {
+        didFetchRepositoryNames = true
+        return []
+      }
+    }
+  })
+  await sut.getRepositoryNames("1234")
+  expect(didFetchRepositoryNames).toBeFalsy()
+})
+
+test("It caches fetched repository names for user", async () => {
+  let cachedUserId: string | undefined
+  let cachedRepositoryNames: string | undefined
+  const sut = new CachingRepositoryAccessReaderConfig({
+    repository: {
+      async get() {
+        return null
+      },
+      async set(userId, value) {
+        cachedUserId = userId
+        cachedRepositoryNames = value
+      },
+      async setExpiring() {},
+      async delete() {}
+    },
+    repositoryAccessReader: {
+      async getRepositoryNames() {
+        return ["foo"]
+      }
+    }
+  })
+  await sut.getRepositoryNames("1234")
+  expect(cachedUserId).toEqual("1234")
+  expect(cachedRepositoryNames).toEqual("[\"foo\"]")
+})
+
+test("It decodes cached repository names", async () => {
+  const sut = new CachingRepositoryAccessReaderConfig({
+    repository: {
+      async get() {
+        return "[\"foo\",\"bar\"]"
+      },
+      async set() {},
+      async setExpiring() {},
+      async delete() {}
+    },
+    repositoryAccessReader: {
+      async getRepositoryNames() {
+        return []
+      }
+    }
+  })
+  const repositoryNames = await sut.getRepositoryNames("1234")
+  expect(repositoryNames).toEqual(["foo", "bar"])
+})

__test__/auth/CachingUserIdentityProviderReader.test.ts

@@ -0,0 +1,63 @@
+import { CachingUserIdentityProviderReader } from "../../src/features/auth/domain"
+import { UserIdentityProvider } from "../../src/features/auth/domain"
+
+test("It fetches user identity provider if it is not cached", async () => {
+  let didFetchUserIdentityProvider = false
+  const sut = new CachingUserIdentityProviderReader({
+    async get() {
+      return null
+    },
+    async set() {},
+    async setExpiring() {},
+    async delete() {}
+  }, {
+    async getUserIdentityProvider() {
+      didFetchUserIdentityProvider = true
+      return UserIdentityProvider.GITHUB
+    },
+  })
+  await sut.getUserIdentityProvider("foo")
+  expect(didFetchUserIdentityProvider).toBeTruthy()
+})
+
+test("It does not fetch user identity provider if it is cached", async () => {
+  let didFetchUserIdentityProvider = false
+  const sut = new CachingUserIdentityProviderReader({
+    async get() {
+      return UserIdentityProvider.GITHUB
+    },
+    async set() {},
+    async setExpiring() {},
+    async delete() {}
+  }, {
+    async getUserIdentityProvider() {
+      didFetchUserIdentityProvider = true
+      return UserIdentityProvider.GITHUB
+    },
+  })
+  await sut.getUserIdentityProvider("foo")
+  expect(didFetchUserIdentityProvider).toBeFalsy()
+})
+
+test("It caches fetched user identity provider for user", async () => {
+  let cachedUserId: string | undefined
+  let cachedUserIdentityProvider: string | undefined
+  const sut = new CachingUserIdentityProviderReader({
+    async get() {
+      return null
+    },
+    async set() {},
+    async setExpiring(userId, userIdentityProvider) {
+      cachedUserId = userId
+      cachedUserIdentityProvider = userIdentityProvider
+    },
+    async delete() {}
+  }, {
+    async getUserIdentityProvider() {
+      return UserIdentityProvider.USERNAME_PASSWORD
+    },
+  })
+  await sut.getUserIdentityProvider("1234")
+  expect(cachedUserId).toBe("1234")
+  expect(cachedUserIdentityProvider).toBe(UserIdentityProvider.USERNAME_PASSWORD.toString())
+})

__test__/auth/CompositeLogInHandler.test.ts

@@ -0,0 +1,24 @@
+import { CompositeLogInHandler } from "../../src/features/auth/domain"
+
+test("It invokes all log in handlers for user", async () => {
+  let userId1: string | undefined
+  let userId2: string | undefined
+  let userId3: string | undefined
+  const sut = new CompositeLogInHandler([{
+    async handleLogIn(userId) {
+      userId1 = userId
+    }
+  }, {
+    async handleLogIn(userId) {
+      userId2 = userId
+    }
+  }, {
+    async handleLogIn(userId) {
+      userId3 = userId
+    }
+  }])
+  await sut.handleLogIn("1234")
+  expect(userId1).toEqual("1234")
+  expect(userId2).toEqual("1234")
+  expect(userId3).toEqual("1234")
+})