@knpkv/atlassian-common 1.5.0 → 1.7.0

package/test/cliAuth.authCommand.test.ts

@@ -0,0 +1,153 @@
+/** @effect-diagnostics strictEffectProvide:skip-file */
+/**
+ * The shared `auth` command group: its setup text lists exactly the scopes the service logs in
+ * with, a browser that never opens fails the command after the URL is printed, and the profile
+ * commands read the same store for every product.
+ */
+import { NodeServices } from "@effect/platform-node"
+import { describe, expect, it } from "@effect/vitest"
+import { Command } from "effect/cli"
+import * as Console from "effect/Console"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as PlatformError from "effect/PlatformError"
+import { ChildProcessSpawner } from "effect/process"
+import * as Sink from "effect/Sink"
+import * as Stream from "effect/Stream"
+import { type AuthCommandService, makeAuthCommand, scopeInstructions } from "../src/cli-auth/index.js"
+import type { AuthProfile } from "../src/config/index.js"
+
+class TestAuth extends Context.Service<TestAuth, AuthCommandService>()("test/TestAuth") {}
+
+const SCOPES = [
+  "read:jira-work",
+  "write:jira-work",
+  "manage:jira-project",
+  "read:jira-user",
+  "read:me",
+  "offline_access"
+]
+
+const descriptor = { commandName: "jira", productName: "Jira", scopes: SCOPES }
+
+const profile: AuthProfile = {
+  id: "cloud-1:account-1",
+  name: "User 1 @ site-1",
+  token: {
+    access_token: "access-1",
+    refresh_token: "refresh-1",
+    expires_at: 0,
+    scope: "read:me",
+    cloud_id: "cloud-1",
+    site_url: "https://site-1.atlassian.net",
+    user: { account_id: "account-1", name: "User 1", email: "user-1@example.com" }
+  },
+  created_at: "2026-10-05T00:00:00.000Z",
+  updated_at: "2026-10-05T00:00:00.000Z"
+}
+
+const fakeAuth = (active: AuthProfile | null): AuthCommandService => ({
+  configure: () => Effect.void,
+  login: () => Effect.void,
+  logout: () => Effect.void,
+  getActiveProfile: () => Effect.succeed(active),
+  listProfiles: () => Effect.succeed(active === null ? [] : [active]),
+  switchProfile: () => Effect.succeed(null),
+  removeProfile: () => Effect.succeed(null)
+})
+
+// `opens` decides whether `open` exits 0; every other launcher is missing.
+const launchers = (opens: boolean) =>
+  Layer.succeed(
+    ChildProcessSpawner.ChildProcessSpawner,
+    ChildProcessSpawner.make((command) =>
+      command._tag === "StandardCommand" && command.command === "open"
+        ? Effect.succeed(ChildProcessSpawner.makeHandle({
+          all: Stream.empty,
+          exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(opens ? 0 : 1)),
+          getInputFd: () => Sink.drain,
+          getOutputFd: () => Stream.empty,
+          isRunning: Effect.succeed(false),
+          kill: () => Effect.void,
+          pid: ChildProcessSpawner.ProcessId(1),
+          reref: Effect.void,
+          stderr: Stream.empty,
+          stdin: Sink.drain,
+          stdout: Stream.empty,
+          unref: Effect.succeed(Effect.void)
+        }))
+        : Effect.fail(PlatformError.systemError({ _tag: "NotFound", module: "ChildProcess", method: "spawn" }))
+    )
+  )
+
+const run = (
+  args: ReadonlyArray<string>,
+  options: { readonly active?: AuthProfile | null; readonly opens?: boolean }
+) =>
+  Effect.gen(function*() {
+    const lines: Array<string> = []
+    const capture: Console.Console = Object.assign(Object.create(console), {
+      log: (...parts: ReadonlyArray<unknown>) => lines.push(parts.join(" "))
+    })
+    const cli = Command.runWith(
+      Command.make("jira").pipe(
+        Command.withSubcommands([makeAuthCommand(TestAuth, descriptor, { apiSection: "Jira API" })])
+      ),
+      { version: "0.0.0-test" }
+    )
+    const exit = yield* cli(["auth", ...args]).pipe(
+      Effect.provideService(Console.Console, capture),
+      Effect.provide(Layer.mergeAll(
+        NodeServices.layer,
+        launchers(options.opens ?? true),
+        Layer.succeed(TestAuth, fakeAuth(options.active ?? null))
+      )),
+      Effect.exit
+    )
+    return { exit, output: lines.join("\n") }
+  })
+
+describe("makeAuthCommand", () => {
+  it("lists every login scope except offline_access, read:me under User Identity", () => {
+    const text = scopeInstructions(descriptor, "Jira API")
+    for (const scope of SCOPES.filter((scope) => scope !== "offline_access")) expect(text).toContain(scope)
+    expect(text).not.toContain("offline_access")
+    expect(text.indexOf("User Identity API")).toBeLessThan(text.indexOf("read:me"))
+    expect(text.indexOf("Jira API")).toBeLessThan(text.indexOf("read:jira-work"))
+  })
+
+  it.effect("create prints the service's scopes and its own command name, then opens the console", () =>
+    Effect.gen(function*() {
+      const { exit, output } = yield* run(["create"], {})
+      expect(exit._tag).toBe("Success")
+      for (const scope of ["write:jira-work", "manage:jira-project"]) expect(output).toContain(scope)
+      expect(output).toContain("jira auth configure --client-id")
+      expect(output).toContain("Opening https://developer.atlassian.com/console/myapps/create-3lo-app/")
+    }))
+
+  it.effect("create and manage fail when no browser opens, after printing the URL", () =>
+    Effect.gen(function*() {
+      for (const subcommand of ["create", "manage"]) {
+        const { exit, output } = yield* run([subcommand], { opens: false })
+        expect(exit._tag, subcommand).toBe("Failure")
+        expect(output, subcommand).toContain("Opening https://developer.atlassian.com/console/myapps/")
+      }
+    }))
+
+  it.effect("status prints the active profile, or how to log in", () =>
+    Effect.gen(function*() {
+      const active = yield* run(["status"], { active: profile })
+      expect(active.output).toContain("Active profile: User 1 @ site-1")
+      expect(active.output).toContain("Account: User 1 (user-1@example.com)")
+      expect(active.output).toContain("Site: https://site-1.atlassian.net")
+      expect((yield* run(["status"], {})).output).toContain("Not logged in. Use 'jira auth login' to authenticate.")
+    }))
+
+  it.effect("profiles marks the active one; use and remove report an unknown selector", () =>
+    Effect.gen(function*() {
+      expect((yield* run(["profiles"], { active: profile })).output).toContain("* cloud-1:account-1")
+      expect((yield* run(["use", "nope"], {})).output).toContain("Profile not found: nope")
+      expect((yield* run(["remove", "nope"], {})).output).toContain("Profile not found: nope")
+    }))
+})

package/test/cliAuth.guardrails.test.ts

@@ -0,0 +1,76 @@
+/** @effect-diagnostics strictEffectProvide:skip-file */
+import { NodeServices } from "@effect/platform-node"
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as FileSystem from "effect/FileSystem"
+import * as Path from "effect/Path"
+import { ChildProcess, ChildProcessSpawner } from "effect/process"
+import * as Schema from "effect/Schema"
+import * as Stream from "effect/Stream"
+import confluenceIntegration from "../../confluence-to-markdown/vitest.config.integration.js"
+import confluence from "../../confluence-to-markdown/vitest.config.js"
+import jiraIntegration from "../../jira-cli/vitest.config.integration.js"
+import jira from "../../jira-cli/vitest.config.js"
+import clockify from "../../jira-clockify/vitest.config.js"
+
+const configs = { jira, jiraIntegration, confluence, confluenceIntegration, clockify }
+const Findings = Schema.fromJsonString(Schema.Array(Schema.Struct({ file: Schema.String })))
+
+describe("CLI auth guardrails", () => {
+  for (const [name, config] of Object.entries(configs)) {
+    it(`${name} resolves CLI auth from source rather than stale build output`, () => {
+      expect(config.resolve?.alias).toHaveProperty(
+        "@knpkv/atlassian-common/cli-auth",
+        new URL("../src/cli-auth/index.ts", import.meta.url).pathname
+      )
+    })
+  }
+
+  it.effect("limits the reimplementation guard to the Jira and Confluence CLIs", () =>
+    Effect.gen(function*() {
+      const fs = yield* FileSystem.FileSystem
+      const path = yield* Path.Path
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+      const root = yield* path.fromFileUrl(new URL("../../../", import.meta.url))
+      const fixture = yield* fs.makeTempDirectoryScoped({ prefix: "cli-auth-guard-" })
+      yield* fs.writeFileString(
+        path.join(fixture, "sgconfig.yml"),
+        "ruleDirs: []\nlanguageGlobs:\n  tsx:\n    - \"**/*.ts\"\n"
+      )
+      // The same callback-server name and endpoint namespace are legitimate in
+      // another integration. Only the two delegated CLI implementations are banned.
+      const source = [
+        "import * as Auth from \"@knpkv/atlassian-common/auth\"",
+        "import { refreshToken } from \"@knpkv/atlassian-common/auth\"",
+        "const authUrl = Auth.buildAuthUrl({ clientId: \"client\" })",
+        "function startCallbackServer(state: string) { return state }"
+      ].join("\n")
+      for (const name of ["jira-cli", "confluence-to-markdown", "other-oauth"]) {
+        const directory = path.join(fixture, "packages", name, "src")
+        yield* fs.makeDirectory(directory, { recursive: true })
+        yield* fs.writeFileString(path.join(directory, "auth.ts"), source)
+      }
+      const handle = yield* spawner.spawn(ChildProcess.make(
+        path.join(root, "node_modules", ".bin", "ast-grep"),
+        [
+          "scan",
+          "--rule",
+          path.join(root, "ast-grep", "rules", "packaging", "no-atlassian-cli-auth-reimplementation.yml"),
+          "--json=compact",
+          "packages"
+        ],
+        { cwd: fixture }
+      ))
+      const { exitCode, stderr, stdout } = yield* Effect.all({
+        exitCode: handle.exitCode,
+        stdout: Stream.decodeText(handle.stdout).pipe(Stream.mkString),
+        stderr: Stream.decodeText(handle.stderr).pipe(Stream.mkString)
+      }, { concurrency: "unbounded" })
+      expect(exitCode, `${fixture}: ${stdout} ${stderr}`).toBe(1)
+      const findings = yield* Schema.decodeUnknownEffect(Findings)(stdout)
+      expect(findings.map(({ file }) => file).sort()).toEqual([
+        ...Array<string>(3).fill("packages/confluence-to-markdown/src/auth.ts"),
+        ...Array<string>(3).fill("packages/jira-cli/src/auth.ts")
+      ])
+    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)))
+})

package/test/cliAuth.login.test.ts

@@ -0,0 +1,319 @@
+/** @effect-diagnostics strictEffectProvide:skip-file */
+/**
+ * Browser login through the shared Atlassian CLI auth.
+ *
+ * The login prints the authorization URL before it tries to open a browser, so
+ * a browser that will not open must not end the login: the user can still visit
+ * the URL. A callback server that cannot bind, on the other hand, must end it
+ * before any URL is advertised, and the server must stop whenever the login's
+ * scope closes.
+ */
+import { NodeFileSystem, NodePath, NodeServices } from "@effect/platform-node"
+import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient"
+import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer"
+import { describe, expect, it } from "@effect/vitest"
+import { ConfigProvider } from "effect"
+import * as Console from "effect/Console"
+import * as Data from "effect/Data"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as FileSystem from "effect/FileSystem"
+import { HttpClient, HttpClientRequest, HttpClientResponse, HttpServer, HttpServerError } from "effect/http"
+import * as Layer from "effect/Layer"
+import { ChildProcessSpawner } from "effect/process"
+import * as Ref from "effect/Ref"
+import type * as Schema from "effect/Schema"
+import * as Sink from "effect/Sink"
+import * as Stream from "effect/Stream"
+import { TestClock } from "effect/testing"
+import { createServer } from "node:http"
+import { makeAtlassianCliAuth, makeHttpServerFactory } from "../src/cli-auth/index.js"
+import { loadActiveProfileToken } from "../src/config/AuthProfiles.js"
+import { HomeDirectoryLive } from "../src/config/ConfigPaths.js"
+import { saveOAuthConfig } from "../src/config/TokenStorage.js"
+
+const TOOL = "test-cli"
+
+class TestAuthMissing extends Data.TaggedError("TestAuthMissing") {}
+
+const authOptions = {
+  toolName: TOOL,
+  commandName: "test",
+  productName: "Test",
+  scopes: ["read:me", "offline_access"],
+  authMissing: () => new TestAuthMissing()
+}
+
+const storage = Layer.mergeAll(NodeFileSystem.layer, NodePath.layer, HomeDirectoryLive)
+
+const withHome = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const home = yield* fs.makeTempDirectoryScoped({ prefix: "atlassian-cli-login-" })
+    return yield* effect.pipe(
+      Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env: { HOME: home } })))
+    )
+  }).pipe(Effect.scoped, Effect.provide(NodeFileSystem.layer))
+
+const seedConfig = saveOAuthConfig(TOOL, { clientId: "client-1", clientSecret: "secret-1" }).pipe(
+  Effect.provide(storage)
+)
+
+const json = (request: HttpClientRequest.HttpClientRequest, body: Schema.Json) =>
+  HttpClientResponse.fromWeb(
+    request,
+    new Response(JSON.stringify(body), { status: 200, headers: { "content-type": "application/json" } })
+  )
+
+// Atlassian's side of a successful login: token exchange, one site, the user.
+interface FakeSite {
+  readonly id: string
+  readonly name: string
+  readonly url: string
+}
+
+const firstSite: FakeSite = { id: "cloud-1", name: "Site", url: "https://site.atlassian.net" }
+const secondSite: FakeSite = { id: "cloud-2", name: "Other", url: "https://other.atlassian.net" }
+
+const atlassianClientWith = (sites: ReadonlyArray<FakeSite>) =>
+  Layer.succeed(
+    HttpClient.HttpClient,
+    HttpClient.make((request) => {
+      if (request.url.endsWith("/oauth/token")) {
+        return Effect.succeed(json(request, {
+          access_token: "access-1",
+          refresh_token: "refresh-1",
+          expires_in: 3600,
+          scope: "read:me offline_access",
+          token_type: "Bearer"
+        }))
+      }
+      if (request.url.endsWith("/accessible-resources")) {
+        return Effect.succeed(json(request, sites.map((site) => ({ ...site, scopes: [] }))))
+      }
+      return Effect.succeed(json(request, { account_id: "acc-1", name: "Ada", email: "ada@example.com" }))
+    })
+  )
+
+const atlassianClient = atlassianClientWith([firstSite])
+
+// Every launcher runs and reports failure — merged after NodeServices so it
+// replaces the real spawner rather than being replaced by it, the way `xdg-open` does on a host
+// with no browser. The first launch hands its URL to the test.
+const failingLaunchers = (launched: Deferred.Deferred<string>, attempts: Ref.Ref<ReadonlyArray<string>>) =>
+  Layer.succeed(
+    ChildProcessSpawner.ChildProcessSpawner,
+    ChildProcessSpawner.make((command) =>
+      Effect.gen(function*() {
+        if (command._tag === "StandardCommand") {
+          yield* Ref.update(attempts, (all) => [...all, command.command])
+          yield* Deferred.succeed(launched, command.args[command.args.length - 1] ?? "")
+        }
+        return ChildProcessSpawner.makeHandle({
+          all: Stream.empty,
+          exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(1)),
+          getInputFd: () => Sink.drain,
+          getOutputFd: () => Stream.empty,
+          isRunning: Effect.succeed(false),
+          kill: () => Effect.void,
+          pid: ChildProcessSpawner.ProcessId(1),
+          reref: Effect.void,
+          stderr: Stream.empty,
+          stdin: Sink.drain,
+          stdout: Stream.empty,
+          unref: Effect.succeed(Effect.void)
+        })
+      })
+    )
+  )
+
+// An ephemeral real server whose shutdown the test can observe.
+const observedServerFactory = (stopped: Ref.Ref<boolean>) =>
+  makeHttpServerFactory(() =>
+    Layer.merge(
+      NodeHttpServer.layerServer(createServer, { port: 0 }),
+      Layer.effectDiscard(Effect.addFinalizer(() => Ref.set(stopped, true)))
+    )
+  )
+
+const captureConsole = (lines: Array<string>): Console.Console =>
+  Object.assign(Object.create(console), {
+    log: (...args: ReadonlyArray<unknown>) => lines.push(args.join(" ")),
+    error: (...args: ReadonlyArray<unknown>) => lines.push(`stderr: ${args.join(" ")}`)
+  })
+
+const deliverCallback = (authUrl: string) =>
+  Effect.gen(function*() {
+    const url = new URL(authUrl)
+    const redirect = url.searchParams.get("redirect_uri") ?? ""
+    const state = url.searchParams.get("state") ?? ""
+    const port = new URL(redirect).port
+    const client = yield* HttpClient.HttpClient
+    yield* client.execute(
+      HttpClientRequest.get(`http://127.0.0.1:${port}/callback`).pipe(
+        HttpClientRequest.setUrlParam("code", "code-1"),
+        HttpClientRequest.setUrlParam("state", state)
+      )
+    )
+  }).pipe(Effect.provide(NodeHttpClient.layerUndici))
+
+describe("Atlassian CLI login", () => {
+  it.live("keeps waiting for the callback when no browser launcher succeeds", () =>
+    withHome(Effect.gen(function*() {
+      yield* seedConfig
+      const launched = yield* Deferred.make<string>()
+      const attempts = yield* Ref.make<ReadonlyArray<string>>([])
+      const lines: Array<string> = []
+      const stopped = yield* Ref.make(false)
+
+      const login = yield* makeAtlassianCliAuth(authOptions).pipe(
+        Effect.flatMap((auth) => auth.login()),
+        Effect.provide(Layer.mergeAll(
+          NodeServices.layer,
+          HomeDirectoryLive,
+          atlassianClient,
+          failingLaunchers(launched, attempts),
+          observedServerFactory(stopped)
+        )),
+        Effect.provideService(Console.Console, captureConsole(lines)),
+        Effect.forkChild({ startImmediately: true })
+      )
+
+      const authUrl = yield* Deferred.await(launched)
+      yield* deliverCallback(authUrl)
+      const result = yield* Fiber.join(login)
+
+      expect(result).toBeUndefined()
+      expect(yield* Ref.get(attempts)).toEqual(["open", "xdg-open", "rundll32.exe"])
+      const printed = lines
+      expect(printed.some((line) => line.includes(`visit: ${authUrl}`))).toBe(true)
+      expect(printed).toContain("stderr: Could not open a browser (rundll32.exe exited 1); visit the URL above.")
+      expect(printed).toContain("Logged in as Ada (ada@example.com)")
+      expect(yield* Ref.get(stopped)).toBe(true)
+      const stored = yield* loadActiveProfileToken(TOOL).pipe(Effect.provide(storage))
+      expect(stored?.cloud_id).toBe("cloud-1")
+    })))
+
+  it.effect("fails before advertising a URL when the callback server cannot bind", () =>
+    withHome(Effect.gen(function*() {
+      yield* seedConfig
+      const launched = yield* Deferred.make<string>()
+      const attempts = yield* Ref.make<ReadonlyArray<string>>([])
+      const lines: Array<string> = []
+      const refused = makeHttpServerFactory(() =>
+        Layer.effect(
+          HttpServer.HttpServer,
+          Effect.fail(new HttpServerError.ServeError({ cause: { code: "EACCES" } }))
+        )
+      )
+
+      const error = yield* makeAtlassianCliAuth(authOptions).pipe(
+        Effect.flatMap((auth) => auth.login()),
+        Effect.provide(
+          Layer.mergeAll(
+            NodeServices.layer,
+            HomeDirectoryLive,
+            atlassianClient,
+            failingLaunchers(launched, attempts),
+            refused
+          )
+        ),
+        Effect.provideService(Console.Console, captureConsole(lines)),
+        Effect.flip
+      )
+
+      expect(error._tag).toBe("OAuthError")
+      expect(yield* Ref.get(attempts)).toEqual([])
+      expect(lines).toEqual([])
+    })))
+
+  it.effect("stops the callback server when authorization times out", () =>
+    withHome(Effect.gen(function*() {
+      yield* seedConfig
+      const launched = yield* Deferred.make<string>()
+      const attempts = yield* Ref.make<ReadonlyArray<string>>([])
+      const lines: Array<string> = []
+      const stopped = yield* Ref.make(false)
+
+      const login = yield* makeAtlassianCliAuth(authOptions).pipe(
+        Effect.flatMap((auth) => auth.login()),
+        Effect.provide(Layer.mergeAll(
+          NodeServices.layer,
+          HomeDirectoryLive,
+          atlassianClient,
+          failingLaunchers(launched, attempts),
+          observedServerFactory(stopped)
+        )),
+        Effect.provideService(Console.Console, captureConsole(lines)),
+        Effect.flip,
+        Effect.forkChild({ startImmediately: true })
+      )
+
+      yield* Deferred.await(launched)
+      // The deadline is registered just after the launch; step the clock past it
+      // in increments so it fires wherever in that window it was set.
+      for (let minute = 0; minute < 10; minute++) {
+        yield* TestClock.adjust("1 minute")
+        yield* Effect.yieldNow
+      }
+      const error = yield* Fiber.join(login)
+
+      expect(error._tag).toBe("OAuthError")
+      expect(String(error.cause)).toBe("Authorization timed out")
+      expect(yield* Ref.get(stopped)).toBe(true)
+    })))
+  // With several sites, the login either lists them for the user to pick from
+  // or uses the one named by --site; an unknown --site fails and lists them.
+  const loginWithSites = (siteUrl: string | undefined) =>
+    Effect.gen(function*() {
+      yield* seedConfig
+      const launched = yield* Deferred.make<string>()
+      const attempts = yield* Ref.make<ReadonlyArray<string>>([])
+      const stopped = yield* Ref.make(false)
+      const lines: Array<string> = []
+      const login = yield* makeAtlassianCliAuth(authOptions).pipe(
+        Effect.flatMap((auth) => auth.login(siteUrl === undefined ? undefined : { siteUrl })),
+        Effect.provide(Layer.mergeAll(
+          NodeServices.layer,
+          HomeDirectoryLive,
+          atlassianClientWith([firstSite, secondSite]),
+          failingLaunchers(launched, attempts),
+          observedServerFactory(stopped)
+        )),
+        Effect.provideService(Console.Console, captureConsole(lines)),
+        Effect.result,
+        Effect.forkChild({ startImmediately: true })
+      )
+      yield* deliverCallback(yield* Deferred.await(launched))
+      const result = yield* Fiber.join(login)
+      const stored = yield* loadActiveProfileToken(TOOL).pipe(Effect.provide(storage))
+      return { result, stored }
+    })
+
+  it.live("lists the sites when several are available and none was chosen", () =>
+    withHome(Effect.gen(function*() {
+      const { result, stored } = yield* loginWithSites(undefined)
+      expect(result).toMatchObject({
+        success: [
+          { id: "cloud-1", name: "Site", url: "https://site.atlassian.net" },
+          { id: "cloud-2", name: "Other", url: "https://other.atlassian.net" }
+        ]
+      })
+      expect(stored).toBeNull()
+    })))
+
+  it.live("logs into the site chosen with --site", () =>
+    withHome(Effect.gen(function*() {
+      const { stored } = yield* loginWithSites("https://other.atlassian.net")
+      expect(stored?.cloud_id).toBe("cloud-2")
+    })))
+
+  it.live("fails and lists the sites when --site names none of them", () =>
+    withHome(Effect.gen(function*() {
+      const { result, stored } = yield* loginWithSites("https://missing.atlassian.net")
+      expect(result).toMatchObject({ failure: { _tag: "OAuthError", step: "authorize" } })
+      expect(String(result._tag === "Failure" ? result.failure.cause : "")).toContain("https://other.atlassian.net")
+      expect(stored).toBeNull()
+    })))
+})