Add tests for Azure DevOps components and ProjectMapper

Add comprehensive tests for ProjectMapper, Azure DevOps client, blob
providers, and repository data sources. Fix AzureDevOpsError prototype
chain to ensure instanceof checks work correctly.

Author: ulrikandersen

__test__/common/azure-devops/AzureDevOpsClient.test.ts

@@ -0,0 +1,72 @@
+import { AzureDevOpsError } from "@/common/azure-devops/AzureDevOpsError"
+
+test("It sets the error name to AzureDevOpsError", () => {
+  const error = new AzureDevOpsError("Test error", 400, false)
+  expect(error.name).toEqual("AzureDevOpsError")
+})
+
+test("It stores the error message", () => {
+  const error = new AzureDevOpsError("Something went wrong", 500, false)
+  expect(error.message).toEqual("Something went wrong")
+})
+
+test("It stores the HTTP status code", () => {
+  const error = new AzureDevOpsError("Unauthorized", 401, true)
+  expect(error.status).toEqual(401)
+})
+
+test("It stores the isAuthError flag when true", () => {
+  const error = new AzureDevOpsError("Auth failed", 401, true)
+  expect(error.isAuthError).toBe(true)
+})
+
+test("It stores the isAuthError flag when false", () => {
+  const error = new AzureDevOpsError("Not found", 404, false)
+  expect(error.isAuthError).toBe(false)
+})
+
+test("It is an instance of Error", () => {
+  const error = new AzureDevOpsError("Test error", 400, false)
+  expect(error).toBeInstanceOf(Error)
+})
+
+test("It is an instance of AzureDevOpsError", () => {
+  const error = new AzureDevOpsError("Test error", 400, false)
+  expect(error).toBeInstanceOf(AzureDevOpsError)
+})
+
+test("It can be caught as an Error", () => {
+  let caught: Error | undefined
+  try {
+    throw new AzureDevOpsError("Test", 500, false)
+  } catch (e) {
+    caught = e as Error
+  }
+  expect(caught).toBeDefined()
+  expect(caught?.message).toEqual("Test")
+})
+
+test("It works correctly with instanceof after being thrown", () => {
+  let isAzureDevOpsError = false
+  try {
+    throw new AzureDevOpsError("Test", 401, true)
+  } catch (e) {
+    isAzureDevOpsError = e instanceof AzureDevOpsError
+  }
+  expect(isAzureDevOpsError).toBe(true)
+})
+
+test("It preserves status and isAuthError after being thrown", () => {
+  let status: number | undefined
+  let isAuthError: boolean | undefined
+  try {
+    throw new AzureDevOpsError("Unauthorized", 401, true)
+  } catch (e) {
+    if (e instanceof AzureDevOpsError) {
+      status = e.status
+      isAuthError = e.isAuthError
+    }
+  }
+  expect(status).toEqual(401)
+  expect(isAuthError).toBe(true)
+})

__test__/common/azure-devops/AzureDevOpsError.test.ts

@@ -0,0 +1,246 @@
+import OAuthTokenRefreshingAzureDevOpsClient from "@/common/azure-devops/OAuthTokenRefreshingAzureDevOpsClient"
+import { AzureDevOpsError } from "@/common/azure-devops/AzureDevOpsError"
+import IAzureDevOpsClient from "@/common/azure-devops/IAzureDevOpsClient"
+
+function createMockClient(overrides: Partial<IAzureDevOpsClient> = {}): IAzureDevOpsClient {
+  return {
+    async getRepositories() {
+      return []
+    },
+    async getRefs() {
+      return []
+    },
+    async getItems() {
+      return []
+    },
+    async getFileContent() {
+      return null
+    },
+    ...overrides
+  }
+}
+
+test("It forwards a request to getRepositories", async () => {
+  let didForwardRequest = false
+  const sut = new OAuthTokenRefreshingAzureDevOpsClient({
+    oauthTokenDataSource: {
+      async getOAuthToken() {
+        return { accessToken: "foo", refreshToken: "bar" }
+      }
+    },
+    oauthTokenRefresher: {
+      async refreshOAuthToken() {
+        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+      }
+    },
+    client: createMockClient({
+      async getRepositories() {
+        didForwardRequest = true
+        return [{ id: "1", name: "test", webUrl: "https://test", project: { id: "1", name: "proj" } }]
+      }
+    })
+  })
+  await sut.getRepositories()
+  expect(didForwardRequest).toBeTruthy()
+})
+
+test("It forwards a request to getRefs", async () => {
+  let forwardedRepoId: string | undefined
+  const sut = new OAuthTokenRefreshingAzureDevOpsClient({
+    oauthTokenDataSource: {
+      async getOAuthToken() {
+        return { accessToken: "foo", refreshToken: "bar" }
+      }
+    },
+    oauthTokenRefresher: {
+      async refreshOAuthToken() {
+        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+      }
+    },
+    client: createMockClient({
+      async getRefs(repositoryId) {
+        forwardedRepoId = repositoryId
+        return [{ name: "refs/heads/main", objectId: "abc123" }]
+      }
+    })
+  })
+  await sut.getRefs("repo-123")
+  expect(forwardedRepoId).toEqual("repo-123")
+})
+
+test("It forwards a request to getItems", async () => {
+  let forwardedParams: { repoId?: string, path?: string, version?: string } = {}
+  const sut = new OAuthTokenRefreshingAzureDevOpsClient({
+    oauthTokenDataSource: {
+      async getOAuthToken() {
+        return { accessToken: "foo", refreshToken: "bar" }
+      }
+    },
+    oauthTokenRefresher: {
+      async refreshOAuthToken() {
+        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+      }
+    },
+    client: createMockClient({
+      async getItems(repositoryId, scopePath, version) {
+        forwardedParams = { repoId: repositoryId, path: scopePath, version }
+        return []
+      }
+    })
+  })
+  await sut.getItems("repo-123", "/", "main")
+  expect(forwardedParams).toEqual({ repoId: "repo-123", path: "/", version: "main" })
+})
+
+test("It forwards a request to getFileContent", async () => {
+  let forwardedParams: { repoId?: string, path?: string, version?: string } = {}
+  const sut = new OAuthTokenRefreshingAzureDevOpsClient({
+    oauthTokenDataSource: {
+      async getOAuthToken() {
+        return { accessToken: "foo", refreshToken: "bar" }
+      }
+    },
+    oauthTokenRefresher: {
+      async refreshOAuthToken() {
+        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+      }
+    },
+    client: createMockClient({
+      async getFileContent(repositoryId, path, version) {
+        forwardedParams = { repoId: repositoryId, path, version }
+        return "file content"
+      }
+    })
+  })
+  await sut.getFileContent("repo-123", "openapi.yml", "main")
+  expect(forwardedParams).toEqual({ repoId: "repo-123", path: "openapi.yml", version: "main" })
+})
+
+test("It retries with a refreshed OAuth token when receiving an auth error", async () => {
+  let didRefreshOAuthToken = false
+  let didRespondWithAuthError = false
+  const sut = new OAuthTokenRefreshingAzureDevOpsClient({
+    oauthTokenDataSource: {
+      async getOAuthToken() {
+        return { accessToken: "foo", refreshToken: "bar" }
+      }
+    },
+    oauthTokenRefresher: {
+      async refreshOAuthToken() {
+        didRefreshOAuthToken = true
+        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+      }
+    },
+    client: createMockClient({
+      async getRepositories() {
+        if (!didRespondWithAuthError) {
+          didRespondWithAuthError = true
+          throw new AzureDevOpsError("Unauthorized", 401, true)
+        }
+        return []
+      }
+    })
+  })
+  await sut.getRepositories()
+  expect(didRefreshOAuthToken).toBeTruthy()
+})
+
+test("It only retries a request once when receiving auth errors", async () => {
+  let requestCount = 0
+  const sut = new OAuthTokenRefreshingAzureDevOpsClient({
+    oauthTokenDataSource: {
+      async getOAuthToken() {
+        return { accessToken: "foo", refreshToken: "bar" }
+      }
+    },
+    oauthTokenRefresher: {
+      async refreshOAuthToken() {
+        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+      }
+    },
+    client: createMockClient({
+      async getRepositories() {
+        requestCount += 1
+        throw new AzureDevOpsError("Unauthorized", 401, true)
+      }
+    })
+  })
+  // When receiving the second auth error the call should fail.
+  await expect(sut.getRepositories()).rejects.toThrow("Unauthorized")
+  // We expect two requests:
+  // 1. The initial request that failed after which we refreshed the OAuth token.
+  // 2. The second request that failed after which we gave up.
+  expect(requestCount).toEqual(2)
+})
+
+test("It does not refresh an OAuth token when the initial request was successful", async () => {
+  let didRefreshOAuthToken = false
+  const sut = new OAuthTokenRefreshingAzureDevOpsClient({
+    oauthTokenDataSource: {
+      async getOAuthToken() {
+        return { accessToken: "foo", refreshToken: "bar" }
+      }
+    },
+    oauthTokenRefresher: {
+      async refreshOAuthToken() {
+        didRefreshOAuthToken = true
+        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+      }
+    },
+    client: createMockClient({
+      async getRepositories() {
+        return []
+      }
+    })
+  })
+  await sut.getRepositories()
+  expect(didRefreshOAuthToken).toBeFalsy()
+})
+
+test("It does not refresh OAuth token for non-auth errors", async () => {
+  let didRefreshOAuthToken = false
+  const sut = new OAuthTokenRefreshingAzureDevOpsClient({
+    oauthTokenDataSource: {
+      async getOAuthToken() {
+        return { accessToken: "foo", refreshToken: "bar" }
+      }
+    },
+    oauthTokenRefresher: {
+      async refreshOAuthToken() {
+        didRefreshOAuthToken = true
+        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+      }
+    },
+    client: createMockClient({
+      async getRepositories() {
+        throw new AzureDevOpsError("Not Found", 404, false)
+      }
+    })
+  })
+  await expect(sut.getRepositories()).rejects.toThrow("Not Found")
+  expect(didRefreshOAuthToken).toBeFalsy()
+})
+
+test("It does not refresh OAuth token for non-AzureDevOpsError errors", async () => {
+  let didRefreshOAuthToken = false
+  const sut = new OAuthTokenRefreshingAzureDevOpsClient({
+    oauthTokenDataSource: {
+      async getOAuthToken() {
+        return { accessToken: "foo", refreshToken: "bar" }
+      }
+    },
+    oauthTokenRefresher: {
+      async refreshOAuthToken() {
+        didRefreshOAuthToken = true
+        return { accessToken: "newAccessToken", refreshToken: "newRefreshToken" }
+      }
+    },
+    client: createMockClient({
+      async getRepositories() {
+        throw new Error("Some random error")
+      }
+    })
+  })
+  await expect(sut.getRepositories()).rejects.toThrow("Some random error")
+  expect(didRefreshOAuthToken).toBeFalsy()
+})