@owlmeans/client-auth 0.1.18-rc.12 → 0.1.18-rc.13

package/tests/login.spec.ts

@@ -0,0 +1,202 @@
+import { describe, test, expect } from 'bun:test'
+import { makeTestContext } from './context.js'
+import { appendLogin, makeLoginService } from '../src/login/service.js'
+import { resolveLoginMethods, primaryLoginMethod, registerMethodSource } from '../src/login/methods.js'
+import { resolveCredit } from '../src/login/credit.js'
+import { resumeAction, ResumeAction } from '../src/login/resume.js'
+import { LoginOutcome } from '../src/login/types.js'
+import type {
+  LoginEnv, LoginMethod, LoginMethodContext, LoginPlugin, LoginService,
+} from '../src/login/types.js'
+import type { BasicContext, BasicConfig } from '@owlmeans/context'
+
+/**
+ * A hand-written environment descriptor.
+ *
+ * `LoginEnv` exists precisely so a plugin's decisions can be exercised without a DOM — a stubbed
+ * `window` would prove that the stub behaves, not that the cascade does.
+ */
+const env = (over?: Partial<LoginEnv>): LoginEnv => ({
+  hasWindow: true, embedded: false, surrogate: false, hasOpener: false, ...over,
+})
+
+const stubPlugin = (over: Partial<LoginPlugin> & { alias: string }): LoginPlugin => ({
+  begin: async () => LoginOutcome.Passed,
+  authorize: async () => LoginOutcome.Passed,
+  complete: async () => LoginOutcome.Passed,
+  ...over,
+})
+
+const bootstrap = (): [BasicContext<BasicConfig>, LoginService] => {
+  const context = makeTestContext()
+  const contextual = appendLogin(context)
+
+  return [context, contextual.login()]
+}
+
+const methodCtx = (context: BasicContext<BasicConfig>, over?: Partial<LoginEnv>): LoginMethodContext =>
+  ({ context, env: env(over) })
+
+const method = (over: Partial<LoginMethod> & { id: string }): LoginMethod => ({
+  start: async () => LoginOutcome.Passed, ...over,
+})
+
+describe('login plugin host', () => {
+  test('the cascade picks the highest-priority plugin whose match holds', () => {
+    const service = makeLoginService()
+    service.registerPlugin(stubPlugin({ alias: 'default', priority: 0, match: () => true }))
+    service.registerPlugin(stubPlugin({
+      alias: 'framed', priority: 100, match: candidate => candidate.embedded,
+    }))
+
+    expect(service.plugin(env()).alias).toBe('default')
+    expect(service.plugin(env({ embedded: true })).alias).toBe('framed')
+  })
+
+  test('a plugin with no resume yields Passed, so an ordinary tab is untouched', async () => {
+    const [, service] = bootstrap()
+    service.registerPlugin(stubPlugin({ alias: 'plain', match: () => true }))
+
+    expect(await service.resume('a-token')).toBe(LoginOutcome.Passed)
+  })
+
+  test('a plugin with a resume is asked instead', async () => {
+    const [, service] = bootstrap()
+    service.registerPlugin(stubPlugin({
+      alias: 'framed', match: () => true, resume: async () => LoginOutcome.Handled,
+    }))
+
+    expect(await service.resume('a-token')).toBe(LoginOutcome.Handled)
+  })
+
+  test('a refusing precondition stops the flow before any plugin runs', async () => {
+    const [, service] = bootstrap()
+    let started = false
+    service.registerPlugin(stubPlugin({
+      alias: 'plain', match: () => true,
+      begin: async () => { started = true; return LoginOutcome.Handled },
+    }))
+    service.registerPrecondition({ alias: 'refuse', check: () => false })
+
+    expect(await service.begin({ url: '/dispatcher' })).toBe(LoginOutcome.Gesture)
+    expect(started).toBe(false)
+  })
+
+  test('a passing precondition lets the plugin run', async () => {
+    const [, service] = bootstrap()
+    service.registerPlugin(stubPlugin({
+      alias: 'plain', match: () => true, begin: async () => LoginOutcome.Handled,
+    }))
+    service.registerPrecondition({ alias: 'allow', check: () => true })
+
+    expect(await service.begin({ url: '/dispatcher' })).toBe(LoginOutcome.Handled)
+  })
+
+  test('a plugin with no logout still ends the session it was asked to end', async () => {
+    const [context, service] = bootstrap()
+    context.configure()
+    await context.init()
+    service.registerPlugin(stubPlugin({ alias: 'plain', match: () => true }))
+    const auth = context.service<{ token?: string, update: (t?: string) => Promise<void> }>('auth')
+
+    expect(await service.logout({ url: '' })).toBe(LoginOutcome.Passed)
+    expect(auth.token == null || auth.token === '').toBe(true)
+  })
+})
+
+describe('login method resolution', () => {
+  test('methods sort by declared order, ties by id', () => {
+    const context = makeTestContext()
+    const source = {
+      alias: 'test', list: () => [
+        method({ id: 'b', order: 10 }), method({ id: 'a', order: 10 }), method({ id: 'z', order: 1 }),
+      ],
+    }
+
+    const resolved = resolveLoginMethods(methodCtx(context), undefined, [source])
+
+    expect(resolved.map(item => item.id)).toEqual(['z', 'a', 'b'])
+  })
+
+  test('a restricted method is not offered until the configuration asks for it', () => {
+    const context = makeTestContext()
+    const source = {
+      alias: 'test', list: () => [method({ id: 'ordinary' }), method({ id: 'operator', restricted: true })],
+    }
+
+    expect(resolveLoginMethods(methodCtx(context), undefined, [source]).map(m => m.id))
+      .toEqual(['ordinary'])
+    expect(resolveLoginMethods(
+      methodCtx(context), { overrides: { operator: { enabled: true } } }, [source]
+    ).map(m => m.id).sort()).toEqual(['operator', 'ordinary'])
+    expect(resolveLoginMethods(
+      methodCtx(context), { methods: ['operator'] }, [source]
+    ).map(m => m.id)).toEqual(['operator'])
+  })
+
+  test('an explicit list is both the filter and the order', () => {
+    const context = makeTestContext()
+    const source = {
+      alias: 'test', list: () => [method({ id: 'a' }), method({ id: 'b' }), method({ id: 'c' })],
+    }
+
+    expect(resolveLoginMethods(methodCtx(context), { methods: ['c', 'a'] }, [source]).map(m => m.id))
+      .toEqual(['c', 'a'])
+  })
+
+  test('a source that throws is skipped rather than taking the screen down', () => {
+    const context = makeTestContext()
+    const broken = { alias: 'broken', list: () => { throw new Error('misconfigured') } }
+    const working = { alias: 'working', list: () => [method({ id: 'ok' })] }
+
+    expect(resolveLoginMethods(methodCtx(context), undefined, [broken, working]).map(m => m.id))
+      .toEqual(['ok'])
+  })
+
+  test('the primary method is the first emphasised one, else the first', () => {
+    expect(primaryLoginMethod([
+      method({ id: 'a' }), method({ id: 'b', emphasis: 'primary' }),
+    ])?.id).toBe('b')
+    expect(primaryLoginMethod([method({ id: 'a' })])?.id).toBe('a')
+    expect(primaryLoginMethod([])).toBeNull()
+  })
+
+  test('a globally registered source reaches the resolver', () => {
+    const context = makeTestContext()
+    registerMethodSource({ alias: 'global-test', list: () => [method({ id: 'global' })] })
+
+    expect(resolveLoginMethods(methodCtx(context)).map(m => m.id)).toContain('global')
+  })
+})
+
+describe('the credit line', () => {
+  test('pairs the product with the organization', () => {
+    expect(resolveCredit({ product: 'Taskly', organization: 'Acme' }).line).toBe('Taskly — Acme')
+  })
+
+  test('falls back to the entity slug when the organization has no name', () => {
+    expect(resolveCredit({ product: 'Taskly', entity: 'acme-7f2' }).line).toBe('Taskly — acme-7f2')
+  })
+
+  test('a literal line replaces the composition entirely', () => {
+    expect(resolveCredit({ product: 'Taskly', organization: 'Acme', line: '© Acme' }).line)
+      .toBe('© Acme')
+  })
+
+  test('the platform credit is on unless it is switched off', () => {
+    expect(resolveCredit().poweredBy).toBe(true)
+    expect(resolveCredit({ poweredBy: false }).poweredBy).toBe(false)
+  })
+})
+
+describe('resume outcomes', () => {
+  test('map to exactly one action each', () => {
+    expect(resumeAction(LoginOutcome.Handled)).toBe(ResumeAction.Stop)
+    expect(resumeAction(LoginOutcome.Redirected)).toBe(ResumeAction.Stop)
+    expect(resumeAction(LoginOutcome.Orphaned)).toBe(ResumeAction.Render)
+    expect(resumeAction(LoginOutcome.Failed)).toBe(ResumeAction.Render)
+    expect(resumeAction(LoginOutcome.Gesture)).toBe(ResumeAction.Render)
+    // The ordinary tab: keep the session and carry on. This is the one that must never change.
+    expect(resumeAction(LoginOutcome.Passed)).toBe(ResumeAction.Navigate)
+  })
+})