Restructures authentication logic

.eslintrc.json

@@ -16,7 +16,8 @@
     "no-unmodified-loop-condition": ["error"],
     "no-unreachable-loop": ["error"],
     "no-unused-private-class-members": ["error"],
-    "require-atomic-updates": ["error"]
+    "require-atomic-updates": ["error"],
+    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }]
   },
   "parser": "@typescript-eslint/parser",
   "plugins": [

__test__/auth/AccessTokenService.test.ts

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

__test__/auth/InitialOAuthTokenService.test.ts

@@ -1,5 +1,5 @@
-import InitialOAuthTokenService from "../../src/features/auth/domain/InitialOAuthTokenService"
-import OAuthToken from "../../src/features/auth/domain/OAuthToken"
+import InitialOAuthTokenService from "../../src/features/auth/domain/oAuthToken/InitialOAuthTokenService"
+import OAuthToken from "../../src/features/auth/domain/oAuthToken/OAuthToken"
 
 test("It fetches refresh token for specified user", async () => {
   let fetchedUserId: string | undefined
@@ -16,11 +16,11 @@ test("It fetches refresh token for specified user", async () => {
       }
     },
     oAuthTokenRepository: {
-      async getOAuthToken() {
+      async get() {
         return { accessToken: "foo", refreshToken: "bar" }
       },
-      async storeOAuthToken() {},
-      async deleteOAuthToken() {}
+      async set() {},
+      async delete() {}
     }
   })
   await sut.fetchInitialAuthTokenForUser("123")
@@ -42,11 +42,11 @@ test("It refreshes the fetched refresh token", async () => {
       }
     },
     oAuthTokenRepository: {
-      async getOAuthToken() {
+      async get() {
         return { accessToken: "foo", refreshToken: "bar" }
       },
-      async storeOAuthToken() {},
-      async deleteOAuthToken() {}
+      async set() {},
+      async delete() {}
     }
   })
   await sut.fetchInitialAuthTokenForUser("123")
@@ -68,18 +68,18 @@ test("It stores the refreshed auth token for the correct user ID", async () => {
       }
     },
     oAuthTokenRepository: {
-      async getOAuthToken() {
+      async get() {
         return { accessToken: "foo", refreshToken: "bar" }
       },
-      async storeOAuthToken(userId, token) {
+      async set(userId, token) {
         storedAuthToken = token
         storedUserId = userId
       },
-      async deleteOAuthToken() {}
+      async delete() {}
     }
   })
   await sut.fetchInitialAuthTokenForUser("123")
   expect(storedAuthToken?.accessToken).toBe("foo")
   expect(storedAuthToken?.refreshToken).toBe("bar")
   expect(storedUserId).toBe("123")
-})
+})

__test__/auth/LockingAccessTokenService.test.ts

@@ -0,0 +1,91 @@
+import LockingAccessTokenService from "../../src/features/auth/domain/accessToken/LockingAccessTokenService"
+
+test("It reads access token", async () => {
+  let didReadAccessToken = false
+  const sut = new LockingAccessTokenService({
+    async makeMutex() {
+      return {
+        async acquire() {},
+        async release() {}
+      }
+    }
+  }, {
+    async getAccessToken() {
+      didReadAccessToken = true
+      return "foo"
+    },
+    async refreshAccessToken() {
+      return "foo"
+    }
+  })
+  await sut.getAccessToken()
+  expect(didReadAccessToken).toBeTruthy()
+})
+
+test("It acquires a lock", async () => {
+  let didAcquireLock = false
+  const sut = new LockingAccessTokenService({
+    async makeMutex() {
+      return {
+        async acquire() {
+          didAcquireLock = true
+        },
+        async release() {}
+      }
+    }
+  }, {
+    async getAccessToken() {
+      return "foo"
+    },
+    async refreshAccessToken() {
+      return "foo"
+    }
+  })
+  await sut.refreshAccessToken("bar")
+  expect(didAcquireLock).toBeTruthy()
+})
+
+test("It releases the acquired lock", async () => {
+  let didReleaseLock = false
+  const sut = new LockingAccessTokenService({
+    async makeMutex() {
+      return {
+        async acquire() {},
+        async release() {
+          didReleaseLock = true
+        }
+      }
+    }
+  }, {
+    async getAccessToken() {
+      return "foo"
+    },
+    async refreshAccessToken() {
+      return "foo"
+    }
+  })
+  await sut.refreshAccessToken("bar")
+  expect(didReleaseLock).toBeTruthy()
+})
+
+test("It refreshes access token", async () => {
+  let didRefreshAccessToken = false
+  const sut = new LockingAccessTokenService({
+    async makeMutex() {
+      return {
+        async acquire() {},
+        async release() {}
+      }
+    }
+  }, {
+    async getAccessToken() {
+      return "foo"
+    },
+    async refreshAccessToken() {
+      didRefreshAccessToken = true
+      return "foo"
+    }
+  })
+  await sut.refreshAccessToken("foo")
+  expect(didRefreshAccessToken).toBeTruthy()
+})