@owlmeans/planning 0.1.18-rc.0

package/tests/schemas.spec.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from 'bun:test'
+import * as schemas from '../src/schemas.js'
+import { TransitionAction, WorkcardKind } from '../src/consts.js'
+import { makeAjv, validateCard } from '../src/helpers/validate.js'
+import { applyTransition } from '../src/helpers/apply.js'
+import { computeChanges } from '../src/helpers/changes.js'
+import { FieldsInvalid } from '../src/errors.js'
+import { AT, STORY_TYPE, makeRegistry, transitionOf } from './fixtures.js'
+
+type Node = Record<string, unknown>
+
+/** Every fault of the two `$jsonSchema` rules, as `path: reason`. */
+const faultsOf = (node: unknown, path: string): string[] => {
+  if (node == null || typeof node !== 'object') {
+    return []
+  }
+  if (Array.isArray(node)) {
+    return node.flatMap((entry, index) => faultsOf(entry, `${path}[${index}]`))
+  }
+  const schema = node as Node
+  const faults: string[] = []
+  const types = Array.isArray(schema.type) ? schema.type : [schema.type]
+  if (types.includes('integer')) {
+    faults.push(`${path}: integer`)
+  }
+  if (schema.properties != null && typeof schema.properties === 'object') {
+    const required = new Set((schema.required as string[] | undefined) ?? [])
+    for (const [key, property] of Object.entries(schema.properties as Record<string, Node>)) {
+      if (!required.has(key) && property.nullable !== true) {
+        faults.push(`${path}.${key}: optional but not nullable`)
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(schema)) {
+    if (key !== 'enum' && key !== 'required') {
+      faults.push(...faultsOf(value, `${path}.${key}`))
+    }
+  }
+
+  return faults
+}
+
+describe('schemas', () => {
+  const exported = Object.entries(schemas).filter(([name]) => name.endsWith('Schema'))
+
+  test('no exported schema uses integer, and every optional property is nullable', () => {
+    expect(exported.length).toBeGreaterThan(40)
+    expect(exported.flatMap(([name, schema]) => faultsOf(schema, name))).toEqual([])
+  })
+
+  test('every exported schema compiles, and a folded record validates against its own schema', () => {
+    const ajv = makeAjv()
+    exported.forEach(([, schema]) => ajv.compile(schema as object))
+
+    const registry = makeRegistry()
+    const { changes } = computeChanges(undefined, {
+      action: TransitionAction.Create,
+      card: { kind: WorkcardKind.Card, type: STORY_TYPE.type, title: 'Story', fields: { area: 'user', primary: true } },
+    }, STORY_TYPE, registry, AT)
+    const card = applyTransition(undefined, transitionOf({ card: 'c1', seq: 1, action: TransitionAction.Create, changes }))!
+
+    expect(() => validateCard(card, registry)).not.toThrow()
+    expect(() => validateCard({ ...card, fields: { area: 'moon', primary: true } }, registry)).toThrow(FieldsInvalid)
+    expect(() => validateCard({ ...card, fields: { 'a.b': 1 } }, registry)).toThrow('keys:a.b')
+  })
+
+  test('an execute request accepts a card id or a create draft, and refuses an unknown action', () => {
+    const validate = makeAjv().compile(schemas.ExecuteRequestSchema)
+
+    expect(validate({ card: 'c1', action: 'transit', transition: 'start', expectSeq: null, wait: true })).toBe(true)
+    expect(validate({ card: { kind: 'card', type: 'test:story', title: 'Story' }, action: 'create' })).toBe(true)
+    expect(validate({ card: 'c1', action: 'explode' })).toBe(false)
+  })
+})

package/tests/status.spec.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from 'bun:test'
+import { IntrinsicStatus } from '../src/consts.js'
+import { UnknownStatusFlow, UnknownWorkcardType } from '../src/errors.js'
+import {
+  canTransit, initialFlowsOf, initialStatusOf, intrinsicOf, resolveIntrinsic, ruleOf, transitionsFrom,
+} from '../src/helpers/status.js'
+import { PROJECT_TYPE, REVIEW_FLOW, STORY_FLOW, STORY_TYPE, TASK_TYPE, makeRegistry } from './fixtures.js'
+
+const registry = makeRegistry()
+
+describe('status flows', () => {
+  test('every status maps onto its intrinsic state; the initial one is the marked one', () => {
+    expect(intrinsicOf(STORY_FLOW, 'failed')).toBe(IntrinsicStatus.Planned)
+    expect(intrinsicOf(STORY_FLOW, 'completed')).toBe(IntrinsicStatus.Closed)
+    expect(intrinsicOf(STORY_FLOW, 'unknown')).toBeUndefined()
+    expect(initialStatusOf(REVIEW_FLOW)).toBe('pending')
+  })
+
+  test('a repeated name picks the rule whose from matches, and a wildcard answers last', () => {
+    expect(ruleOf(STORY_FLOW, 'start', 'failed')?.to).toBe('in-progress')
+    expect(ruleOf(STORY_FLOW, 'start', 'completed')).toBeUndefined()
+    expect(ruleOf(REVIEW_FLOW, 'reopen', 'approved')?.to).toBe('reviewing')
+    expect(ruleOf(REVIEW_FLOW, 'reopen', 'reviewing')?.to).toBe('pending')
+  })
+
+  test('canTransit and transitionsFrom read the same rules, one per name', () => {
+    expect(canTransit(STORY_FLOW, 'reset', 'planned')).toBe(true)
+    expect(canTransit(STORY_FLOW, 'complete', 'planned')).toBe(false)
+    expect(transitionsFrom(STORY_FLOW, 'in-progress').map(rule => rule.name)).toEqual(['complete', 'fail', 'reset'])
+    expect(transitionsFrom(STORY_FLOW, 'failed', { explicit: true }).map(rule => `${rule.name}→${rule.to}`))
+      .toEqual(['start→in-progress', 'reset→planned'])
+  })
+})
+
+describe('intrinsic resolution', () => {
+  test('primary policy reads the primary flow only', () => {
+    expect(resolveIntrinsic(STORY_TYPE, { 'test:story': 'in-progress' }, registry)).toBe(IntrinsicStatus.InProgress)
+    expect(resolveIntrinsic(PROJECT_TYPE, { 'test:story': 'completed' }, registry)).toBe(IntrinsicStatus.Closed)
+  })
+
+  test('IntrinsicPolicy.All takes the least advanced flow', () => {
+    expect(resolveIntrinsic(TASK_TYPE, { 'test:story': 'completed', 'test:review': 'reviewing' }, registry))
+      .toBe(IntrinsicStatus.InProgress)
+    expect(resolveIntrinsic(TASK_TYPE, { 'test:story': 'completed', 'test:review': 'approved' }, registry))
+      .toBe(IntrinsicStatus.Closed)
+    expect(resolveIntrinsic(TASK_TYPE, { 'test:story': 'failed', 'test:review': 'approved' }, registry))
+      .toBe(IntrinsicStatus.Planned)
+  })
+
+  test('initialFlowsOf starts every flow at its initial status, the primary at the draft status', () => {
+    expect(initialFlowsOf(TASK_TYPE, registry)).toEqual({ 'test:story': 'planned', 'test:review': 'pending' })
+    expect(initialFlowsOf(TASK_TYPE, registry, 'failed')).toEqual({ 'test:story': 'failed', 'test:review': 'pending' })
+  })
+})
+
+describe('schema registry', () => {
+  test('answers types and flows, refuses unknown ones, and round-trips a bundle', () => {
+    expect(registry.primaryFlow(TASK_TYPE.type).id).toBe(STORY_FLOW.id)
+    expect(() => registry.type('nope')).toThrow(UnknownWorkcardType)
+    expect(() => registry.flow('nope')).toThrow(UnknownStatusFlow)
+
+    const copy = makeRegistry()
+    copy.load({ version: 1, types: [STORY_TYPE], flows: [STORY_FLOW] })
+    expect(copy.types().map(type => type.type)).toEqual([STORY_TYPE.type])
+    expect(copy.has(TASK_TYPE.type)).toBe(false)
+  })
+
+  test('compiles and caches a validator for a type\'s fields', () => {
+    const validate = registry.validator(STORY_TYPE.type)
+
+    expect(validate({ area: 'user', primary: true })).toBe(true)
+    expect(validate({ area: 'moon', primary: true })).toBe(false)
+    expect(registry.validator(STORY_TYPE.type)).toBe(validate)
+  })
+})

package/tests/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": [
+    "@owlmeans/dep-config/tsconfig.base.json",
+    "@owlmeans/dep-config/tsconfig.node.json"
+  ],
+  "compilerOptions": {
+    "types": [
+      "bun"
+    ],
+    "rootDir": "../",
+    "noEmit": true
+  },
+  "include": [
+    "./**/*",
+    "../src/**/*"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": [
+    "@owlmeans/dep-config/tsconfig.base.json"
+  ],
+  "compilerOptions": {
+    "rootDir": "./src/",
+    "outDir": "./build/"
+  },
+  "exclude": [
+    "./dist/**/*",
+    "./build/**/*",
+    "./tests/**/*",
+    "./*.ts"
+  ]
+}