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

package/src/manager/plugins/types.ts

@@ -1,5 +1,6 @@
 import type { FC } from 'react'
 import type { LoginMethodEmphasis } from '@owlmeans/config'
+import type { LoginMethodContext } from '../../login/types.js'
 import type { AuthenticationControl, AuthenticationRenderer, AuthenticationRendererProps, } from '../components/authentication/types.js'
 
 export interface AuthenticationPlugin extends Pick<
@@ -8,6 +9,15 @@ export interface AuthenticationPlugin extends Pick<
   type: string
   Implementation: PluginImplemnetation
   Renderer?: AuthenticationRenderer
+  /**
+   * This plugin's `Implementation` cannot render without a `Renderer` a UI package supplies.
+   *
+   * It is declared rather than inferred because there is nothing to infer it from: a plugin that
+   * renders its own form and one that throws `Renderer is not defined` are the same object until
+   * the screen mounts. Declaring it is what lets the sign-in screen leave out a method whose
+   * renderer nobody registered, instead of offering a button that crashes the page it opens.
+   */
+  requiresRenderer?: boolean
   /**
    * How this method presents itself on the sign-in screen.
    *
@@ -39,6 +49,18 @@ export interface AuthMethodMeta {
   restricted?: boolean
   /** Registered, but never a choice. */
   hidden?: boolean
+  /**
+   * Whether the application this method is about to be offered in actually wired it.
+   *
+   * The plugin registry is global and is written to by side-effect imports, so being registered
+   * says only that some bundle pulled the module in — and modules arrive in groups. An app that
+   * wanted one method out of a package gets every method that package registers, including ones
+   * whose first act is to look up a service its context never appended. This is where a plugin
+   * says so, per context, at render time; `false` leaves it off the screen.
+   *
+   * Absent means "always", which is right for a plugin that needs nothing but itself.
+   */
+  available?: (ctx: LoginMethodContext) => boolean
 }
 
 export interface PluginImplemnetation {

package/tests/login.spec.ts

@@ -3,7 +3,10 @@ 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 { pluginMethodSource } from '../src/manager/plugins/methods.js'
+import { registerAuthPlugin } from '../src/manager/plugins/registry.js'
+import type { AuthenticationPlugin } from '../src/manager/plugins/types.js'
+import { resumeAction, ResumeAction, loginAttemptError } from '../src/login/resume.js'
 import { LoginOutcome } from '../src/login/types.js'
 import type {
   LoginEnv, LoginMethod, LoginMethodContext, LoginPlugin, LoginService,
@@ -170,12 +173,44 @@ describe('login method resolution', () => {
 })
 
 describe('the credit line', () => {
-  test('pairs the product with the organization', () => {
-    expect(resolveCredit({ product: 'Taskly', organization: 'Acme' }).line).toBe('Taskly — Acme')
+  const year = new Date().getFullYear()
+
+  test('is a copyright NOTICE — the mark and the year, not a bare name', () => {
+    expect(resolveCredit({ product: 'OwlMeans', organization: 'OwlMeans' }).line)
+      .toBe(`© ${year} OwlMeans`)
+  })
+
+  test('pairs the product with the notice when the product is not the holder', () => {
+    expect(resolveCredit({ product: 'Taskly', organization: 'Acme' }).line)
+      .toBe(`Taskly — © ${year} 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')
+    expect(resolveCredit({ product: 'Taskly', entity: 'acme-7f2' }).line)
+      .toBe(`Taskly — © ${year} acme-7f2`)
+  })
+
+  test('a first year in the past makes the notice a range', () => {
+    expect(resolveCredit({ organization: 'Acme', since: 2019 }).line).toBe(`© 2019–${year} Acme`)
+    // The current year is not a range, and neither is one a skewed clock puts ahead of it.
+    expect(resolveCredit({ organization: 'Acme', since: year }).line).toBe(`© ${year} Acme`)
+    expect(resolveCredit({ organization: 'Acme', since: year + 5 }).line).toBe(`© ${year} Acme`)
+  })
+
+  test('an explicit holder is who the notice names', () => {
+    expect(resolveCredit({ product: 'Taskly', organization: 'Taskly', holder: 'Acme Inc.' }).line)
+      .toBe(`Taskly — © ${year} Acme Inc.`)
+  })
+
+  test('an owner\'s own wording is used verbatim', () => {
+    expect(resolveCredit({ organization: 'Acme', copyright: '© Acme. All rights reserved.' }).line)
+      .toBe('© Acme. All rights reserved.')
+  })
+
+  test('switching the notice off leaves the bare pairing it used to be', () => {
+    expect(resolveCredit({ product: 'Taskly', organization: 'Acme', copyright: false }).line)
+      .toBe('Taskly — Acme')
+    expect(resolveCredit({ product: 'Taskly', copyright: false }).line).toBe('Taskly')
   })
 
   test('a literal line replaces the composition entirely', () => {
@@ -183,12 +218,88 @@ describe('the credit line', () => {
       .toBe('© Acme')
   })
 
+  test('nobody to name is nothing to render', () => {
+    expect(resolveCredit().line).toBeNull()
+  })
+
+  test('an EMPTY value is unset, not a value', () => {
+    // Exactly what a platform delivers for branding it does not have: every key present, the
+    // undelivered ones empty. `??` does not fall through an empty string, so the organization
+    // used to win the chain and compose "pisteva — " with nothing after the dash.
+    expect(resolveCredit({}, { name: 'pisteva', organization: '', entity: '' }).line)
+      .toBe(`© ${year} pisteva`)
+    expect(resolveCredit({ line: '', product: '', organization: '' }, { name: 'Taskly' }).line)
+      .toBe(`© ${year} Taskly`)
+    expect(resolveCredit({ copyright: '  ' }, { name: 'Taskly' }).line).toBe(`© ${year} Taskly`)
+    expect(resolveCredit({}, {}, '').line).toBeNull()
+  })
+
   test('the platform credit is on unless it is switched off', () => {
     expect(resolveCredit().poweredBy).toBe(true)
     expect(resolveCredit({ poweredBy: false }).poweredBy).toBe(false)
   })
 })
 
+describe('the authentication-plugin method source', () => {
+  const plugin = (
+    over: Partial<AuthenticationPlugin> & { type: string }
+  ): AuthenticationPlugin => ({ Implementation: () => () => null, ...over })
+
+  const offered = (context: BasicContext<BasicConfig>): string[] =>
+    pluginMethodSource.list(methodCtx(context)).map(item => item.id)
+
+  test('a plugin that declares no method is not a way to sign in', () => {
+    const context = makeTestContext()
+    registerAuthPlugin(plugin({ type: 'step-in-a-flow' }))
+    registerAuthPlugin(plugin({ type: 'offerable', method: {} }))
+
+    expect(offered(context)).toContain('offerable')
+    expect(offered(context)).not.toContain('step-in-a-flow')
+  })
+
+  test('a plugin that needs a renderer nobody assigned is left off the screen', () => {
+    const context = makeTestContext()
+    // Exactly the state an app is in when it imported the plugin host but not a panel package:
+    // the plugin is registered, and mounting its screen throws.
+    registerAuthPlugin(plugin({ type: 'needs-ui', method: {}, requiresRenderer: true }))
+
+    expect(offered(context)).not.toContain('needs-ui')
+
+    registerAuthPlugin(plugin({
+      type: 'needs-ui', method: {}, requiresRenderer: true, Renderer: () => null,
+    }))
+
+    expect(offered(context)).toContain('needs-ui')
+  })
+
+  test('a plugin whose own wiring is absent says so and is left off', () => {
+    const context = makeTestContext()
+    registerAuthPlugin(plugin({
+      type: 'needs-wiring', method: { available: ctx => ctx.context.hasService('never-appended') },
+    }))
+
+    expect(offered(context)).not.toContain('needs-wiring')
+  })
+})
+
+describe('a finished sign-in attempt', () => {
+  test('reports every outcome that leaves the user on the screen', () => {
+    // The regression: a method that could not build an authorization URL returned `Passed`, the
+    // screen rendered nothing, and the button read as broken. `Passed` is a valid answer TO A
+    // DISPATCHER, which has a continuation; a screen does not.
+    expect(loginAttemptError(LoginOutcome.Passed)).toBe('login.error.failed')
+    expect(loginAttemptError(LoginOutcome.Failed)).toBe('login.error.failed')
+    expect(loginAttemptError(LoginOutcome.Gesture)).toBe('login.error.blocked')
+  })
+
+  test('says nothing when the attempt actually went somewhere', () => {
+    expect(loginAttemptError(LoginOutcome.Handled)).toBeNull()
+    expect(loginAttemptError(LoginOutcome.Redirected)).toBeNull()
+    expect(loginAttemptError(LoginOutcome.Orphaned)).toBeNull()
+    expect(loginAttemptError(null)).toBeNull()
+  })
+})
+
 describe('resume outcomes', () => {
   test('map to exactly one action each', () => {
     expect(resumeAction(LoginOutcome.Handled)).toBe(ResumeAction.Stop)