create-qpq-app 0.1.25 → 0.1.27

package/template/apps/qpqjs/services/test/service/src/smoke/{logic → harness/logic}/smokeRun/summarizeSmokeRun.ts

@@ -12,14 +12,18 @@ export const summarizeSmokeRun = (smokeRun: SmokeRun): SmokeRunWithSummary => {
   const failed = smokeRun.tests.filter(
     (t) => t.status === SmokeTestStatus.failed
   ).length;
+  const skipped = smokeRun.tests.filter(
+    (t) => t.status === SmokeTestStatus.skipped
+  ).length;
 
   return {
     ...smokeRun,
     summary: {
       total: smokeRun.tests.length,
-      completed: passed + failed,
+      completed: passed + failed + skipped,
       passed,
       failed,
+      skipped,
     },
   };
 };

package/template/apps/qpqjs/services/test/service/src/smoke/{models → harness/models}/SmokeTestRequestedQueueEvent.ts

@@ -1,6 +1,6 @@
 import { QueueEvent, QueueMessage } from 'quidproquo';
 
-// One registered test of one run. `testName` is the registry's stable key,
+// One registered test of one run. `testName` is the test's stable key,
 // never the positional id.
 export type SmokeTestRequestedPayload = {
   runId: string;

package/template/apps/qpqjs/services/test/service/src/smoke/harness/models/index.ts

@@ -0,0 +1,2 @@
+export * from './GithubOidcClaims';
+export * from './SmokeTestRequestedQueueEvent';

package/template/apps/qpqjs/services/test/service/src/smoke/harness/queue/index.ts

@@ -0,0 +1 @@
+export * from './onSmokeTestRequested';

package/template/apps/qpqjs/services/test/service/src/smoke/harness/types/SmokeSuite.ts

@@ -0,0 +1,13 @@
+import { QPQConfig } from 'quidproquo';
+
+import { SmokeTestDefinition } from './SmokeTestDefinition';
+
+/**
+ * One folder under suites/: its tests plus the resources and handlers only
+ * they use. Tests that share a resource belong in the same suite, so deleting
+ * a suite's folder and its line in smokeSuites removes it completely.
+ */
+export type SmokeSuite = {
+  tests: SmokeTestDefinition[];
+  defineConfig?: () => QPQConfig;
+};

package/template/apps/qpqjs/services/test/service/src/smoke/{tests → harness/types}/SmokeTestDefinition.ts

@@ -11,4 +11,7 @@ import { AskResponse } from 'quidproquo';
 export type SmokeTestDefinition = {
   name: string;
   askRun: (runId: string) => AskResponse<void>;
+  // The test exercises something only a deployed platform has (inbound email,
+  // say). On the dev server it is recorded as skipped and never queued.
+  deployedOnly?: boolean;
 };

package/template/apps/qpqjs/services/test/service/src/smoke/harness/types/index.ts

@@ -0,0 +1,2 @@
+export * from './SmokeSuite';
+export * from './SmokeTestDefinition';

package/template/apps/qpqjs/services/test/service/src/smoke/index.ts

@@ -1,10 +1,3 @@
 export * from './config';
-export * from './constants';
-export * from './controller';
-export * from './data';
-export * from './eventDoc';
-export * from './logic';
-export * from './models';
-export * from './processors';
-export * from './queue';
-export * from './tests';
+export * from './harness';
+export * from './suites';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/config/defineEmailReceiveSmoke.ts

@@ -0,0 +1,20 @@
+import { defineEmailReceiver, defineEmailSender, QPQConfig } from 'quidproquo';
+
+import { SMOKE_EMAIL_RECEIVER } from '../constants/SMOKE_EMAIL_RECEIVER';
+
+/**
+ * The test sends to its own receiving domain, the receiver hands the parsed
+ * message to onSmokeEmailReceived, which writes a marker into the probe store,
+ * and the test polls for it. The sender is what lets the test send; the
+ * receiving domain is a verified identity, so the SES sandbox allows it.
+ */
+export const defineEmailReceiveSmoke = (): QPQConfig => [
+  defineEmailSender(),
+  defineEmailReceiver(SMOKE_EMAIL_RECEIVER, {
+    onEmail: {
+      basePath: __dirname,
+      relativePath: '../entry/email/onSmokeEmailReceived',
+      functionName: 'onSmokeEmailReceived',
+    },
+  }),
+];

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/config/index.ts

@@ -0,0 +1 @@
+export * from './defineEmailReceiveSmoke';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/constants/SMOKE_EMAIL_RECEIVER.ts

@@ -0,0 +1,2 @@
+/** The inbound email receiver; its onEmail writes the marker the email test polls for. */
+export const SMOKE_EMAIL_RECEIVER = 'smoke';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/constants/index.ts

@@ -0,0 +1 @@
+export * from './SMOKE_EMAIL_RECEIVER';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/emailReceiveSmokeSuite.ts

@@ -0,0 +1,15 @@
+import { SmokeSuite } from '../../harness/types/SmokeSuite';
+import { defineEmailReceiveSmoke } from './config/defineEmailReceiveSmoke';
+import { askRunEmailReceiveTest } from './logic/askRunEmailReceiveTest';
+
+/** Inbound email to our own receiving domain. Deployed only. */
+export const emailReceiveSmokeSuite: SmokeSuite = {
+  defineConfig: defineEmailReceiveSmoke,
+  tests: [
+    {
+      name: 'emailReceive',
+      askRun: askRunEmailReceiveTest,
+      deployedOnly: true,
+    },
+  ],
+};

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/entry/email/index.ts

@@ -0,0 +1 @@
+export * from './onSmokeEmailReceived';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/entry/email/onSmokeEmailReceived.ts

@@ -0,0 +1,33 @@
+import {
+  askKeyValueStoreUpsert,
+  AskResponse,
+  EmailReceivedEvent,
+  EmailReceivedEventResponse,
+} from 'quidproquo';
+
+import { SMOKE_PROBE_STORE } from '@qpqjs/constants';
+import { SmokeProbeRecord } from '@qpqjs/test-models';
+
+import { smokeEmailMarkerId } from '../../logic/smokeEmailMarkerId';
+
+// The smoke receiver's onEmail: one marker per delivered recipient, carrying
+// the subject and the provider's SPF/DKIM verdicts so the test can check the
+// message came through intact and authenticated.
+export function* onSmokeEmailReceived({
+  message,
+}: EmailReceivedEvent): AskResponse<EmailReceivedEventResponse> {
+  for (const recipient of message.recipients) {
+    const marker: SmokeProbeRecord = {
+      probeId: smokeEmailMarkerId(recipient),
+      category: 'email',
+      value: 1,
+      path: message.subject,
+      authentication: [
+        message.authentication.spf,
+        message.authentication.dkim,
+      ].join('/'),
+    };
+
+    yield* askKeyValueStoreUpsert<SmokeProbeRecord>(SMOKE_PROBE_STORE, marker);
+  }
+}

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/entry/index.ts

@@ -0,0 +1 @@
+export * from './email';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/index.ts

@@ -0,0 +1,5 @@
+export * from './config';
+export * from './constants';
+export * from './emailReceiveSmokeSuite';
+export * from './entry';
+export * from './logic';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/logic/askRunEmailReceiveTest.ts

@@ -0,0 +1,41 @@
+import { askDnsResolveHosts, askEmailSendEmail, AskResponse } from 'quidproquo';
+
+import { askSmokeAssert } from '../../../harness/assert/askSmokeAssert';
+import { askSmokePollForMarker } from '../../../harness/assert/askSmokePollForMarker';
+import { smokeEmailMarkerId } from './smokeEmailMarkerId';
+
+// The inbound email path end to end: send to this app's own receiving domain
+// with its own sender, SES receives it through the account rule set and the
+// app's rule, the receiver parses it and hands it to onSmokeEmailReceived,
+// which writes the marker. Deployed only: nothing receives mail locally.
+export function* askRunEmailReceiveTest(runId: string): AskResponse<void> {
+  const [receivingHost] = yield* askDnsResolveHosts({ subdomain: 'inbox' });
+  const [siteHost] = yield* askDnsResolveHosts();
+
+  const recipient = `${runId}@${receivingHost}`;
+  const subject = `smoke ${runId}`;
+
+  yield* askEmailSendEmail({
+    from: `smoke@${siteHost}`,
+    to: [recipient],
+    subject,
+    bodyText: `smoke probe ${runId}`,
+  });
+
+  // Mail delivery is the slowest path in the suite: SES receives, scans and
+  // writes to S3 before the drive event fires.
+  const marker = yield* askSmokePollForMarker(
+    smokeEmailMarkerId(recipient),
+    'the inbound email path',
+    45
+  );
+
+  yield* askSmokeAssert(
+    marker.path === subject,
+    `received subject [${marker.path}] did not match [${subject}]`
+  );
+  yield* askSmokeAssert(
+    marker.authentication === 'pass/pass',
+    `received message was not authenticated: spf/dkim [${marker.authentication}]`
+  );
+}

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/logic/index.ts

@@ -0,0 +1,2 @@
+export * from './askRunEmailReceiveTest';
+export * from './smokeEmailMarkerId';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/emailReceive/logic/smokeEmailMarkerId.ts

@@ -0,0 +1,4 @@
+// The marker row id for one received message: the recipient's local part, which the email
+// test sets to its own run id so the marker it polls for is provably its own.
+export const smokeEmailMarkerId = (recipient: string): string =>
+  `email-${recipient.split('@')[0]}`;

package/template/apps/qpqjs/services/test/service/src/smoke/suites/encryptedResources/config/defineEncryptedResourcesSmoke.ts

@@ -0,0 +1,29 @@
+import {
+  defineCryptoKey,
+  defineKeyValueStore,
+  defineStorageDrive,
+  QPQConfig,
+} from 'quidproquo';
+
+import { SmokeProbeRecord } from '@qpqjs/test-models';
+
+import { SMOKE_CRYPTO_KEY } from '../constants/SMOKE_CRYPTO_KEY';
+import { SMOKE_ENCRYPTED_PROBE_DRIVE } from '../constants/SMOKE_ENCRYPTED_PROBE_DRIVE';
+import { SMOKE_ENCRYPTED_PROBE_STORE } from '../constants/SMOKE_ENCRYPTED_PROBE_STORE';
+
+/**
+ * A drive and a store encrypted with an owned crypto key, so the test proves
+ * the role's KMS grant covers data at rest.
+ */
+export const defineEncryptedResourcesSmoke = (): QPQConfig => [
+  defineCryptoKey(SMOKE_CRYPTO_KEY),
+  defineKeyValueStore<SmokeProbeRecord>(
+    SMOKE_ENCRYPTED_PROBE_STORE,
+    'probeId',
+    [],
+    { cryptoKeyName: SMOKE_CRYPTO_KEY }
+  ),
+  defineStorageDrive(SMOKE_ENCRYPTED_PROBE_DRIVE, {
+    cryptoKeyName: SMOKE_CRYPTO_KEY,
+  }),
+];

package/template/apps/qpqjs/services/test/service/src/smoke/suites/encryptedResources/config/index.ts

@@ -0,0 +1 @@
+export * from './defineEncryptedResourcesSmoke';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/encryptedResources/constants/SMOKE_CRYPTO_KEY.ts

@@ -0,0 +1,5 @@
+/**
+ * The crypto key the encrypted probe drive and store name. Not 'smokeProbe':
+ * the signing key of that name is a KMS alias too, and the two would collide.
+ */
+export const SMOKE_CRYPTO_KEY = 'smokeCrypto';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/encryptedResources/constants/SMOKE_ENCRYPTED_PROBE_DRIVE.ts

@@ -0,0 +1,2 @@
+/** A probe drive encrypted at rest with SMOKE_CRYPTO_KEY. */
+export const SMOKE_ENCRYPTED_PROBE_DRIVE = 'smoke-encrypted-probe';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/encryptedResources/constants/SMOKE_ENCRYPTED_PROBE_STORE.ts

@@ -0,0 +1,2 @@
+/** A probe store encrypted at rest with SMOKE_CRYPTO_KEY. */
+export const SMOKE_ENCRYPTED_PROBE_STORE = 'smokeEncryptedProbe';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/encryptedResources/constants/index.ts

@@ -0,0 +1,3 @@
+export * from './SMOKE_CRYPTO_KEY';
+export * from './SMOKE_ENCRYPTED_PROBE_DRIVE';
+export * from './SMOKE_ENCRYPTED_PROBE_STORE';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/encryptedResources/encryptedResourcesSmokeSuite.ts

@@ -0,0 +1,9 @@
+import { SmokeSuite } from '../../harness/types/SmokeSuite';
+import { defineEncryptedResourcesSmoke } from './config/defineEncryptedResourcesSmoke';
+import { askRunEncryptedResourcesTest } from './logic/askRunEncryptedResourcesTest';
+
+/** Round trips through a drive and a store encrypted with an owned crypto key. */
+export const encryptedResourcesSmokeSuite: SmokeSuite = {
+  defineConfig: defineEncryptedResourcesSmoke,
+  tests: [{ name: 'encryptedResources', askRun: askRunEncryptedResourcesTest }],
+};

package/template/apps/qpqjs/services/test/service/src/smoke/suites/encryptedResources/index.ts

@@ -0,0 +1,4 @@
+export * from './config';
+export * from './constants';
+export * from './encryptedResourcesSmokeSuite';
+export * from './logic';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/encryptedResources/logic/askRunEncryptedResourcesTest.ts

@@ -0,0 +1,61 @@
+import {
+  askFileDelete,
+  askFileReadTextContents,
+  askFileWriteTextContents,
+  askKeyValueStoreDelete,
+  askKeyValueStoreGet,
+  askKeyValueStoreUpsert,
+  askNewGuid,
+  AskResponse,
+} from 'quidproquo';
+
+import { SmokeProbeRecord } from '@qpqjs/test-models';
+
+import { askSmokeAssert } from '../../../harness/assert/askSmokeAssert';
+import { SMOKE_ENCRYPTED_PROBE_DRIVE } from '../constants/SMOKE_ENCRYPTED_PROBE_DRIVE';
+import { SMOKE_ENCRYPTED_PROBE_STORE } from '../constants/SMOKE_ENCRYPTED_PROBE_STORE';
+
+// A drive and a store encrypted with a defineCryptoKey. Deployed, every write
+// needs kms:GenerateDataKey and every read kms:Decrypt on that key through
+// the alias-conditioned grant, so a plain round trip on each is the proof.
+// Locally there is no encryption at rest and this is a plain round trip.
+export function* askRunEncryptedResourcesTest(): AskResponse<void> {
+  const probeId = yield* askNewGuid();
+
+  const record: SmokeProbeRecord = { probeId, category: 'encrypted', value: 1 };
+  yield* askKeyValueStoreUpsert<SmokeProbeRecord>(
+    SMOKE_ENCRYPTED_PROBE_STORE,
+    record
+  );
+
+  const written = yield* askKeyValueStoreGet<SmokeProbeRecord>(
+    SMOKE_ENCRYPTED_PROBE_STORE,
+    probeId
+  );
+  yield* askSmokeAssert(
+    written?.value === 1,
+    'get after upsert on the encrypted store did not return the record'
+  );
+
+  yield* askKeyValueStoreDelete(SMOKE_ENCRYPTED_PROBE_STORE, probeId);
+
+  const filepath = `encrypted/${probeId}.txt`;
+  const contents = `encrypted smoke probe ${probeId}`;
+
+  yield* askFileWriteTextContents(
+    SMOKE_ENCRYPTED_PROBE_DRIVE,
+    filepath,
+    contents
+  );
+
+  const readBack = yield* askFileReadTextContents(
+    SMOKE_ENCRYPTED_PROBE_DRIVE,
+    filepath
+  );
+  yield* askSmokeAssert(
+    readBack === contents,
+    'file on the encrypted drive did not read back as written'
+  );
+
+  yield* askFileDelete(SMOKE_ENCRYPTED_PROBE_DRIVE, [filepath]);
+}

package/template/apps/qpqjs/services/test/service/src/smoke/suites/encryptedResources/logic/index.ts

@@ -0,0 +1 @@
+export * from './askRunEncryptedResourcesTest';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/config/defineEventBusSmoke.ts

@@ -0,0 +1,21 @@
+import { defineEventBus, defineQueue, QPQConfig } from 'quidproquo';
+
+import { SMOKE_PROBE_EVENT_BUS } from '../constants/SMOKE_PROBE_EVENT_BUS';
+import { SMOKE_PROBE_EVENT_QUEUE } from '../constants/SMOKE_PROBE_EVENT_QUEUE';
+import { SMOKE_PROBE_EVENT_TYPE } from '../constants/SMOKE_PROBE_EVENT_TYPE';
+
+/** Publish to the bus, the subscribed queue's entry writes a marker into the probe store, the test polls for it. */
+export const defineEventBusSmoke = (): QPQConfig => [
+  defineEventBus(SMOKE_PROBE_EVENT_BUS),
+  defineQueue(
+    SMOKE_PROBE_EVENT_QUEUE,
+    {
+      [SMOKE_PROBE_EVENT_TYPE]: {
+        basePath: __dirname,
+        relativePath: '../entry/queue/onSmokeProbeEvent',
+        functionName: 'onSmokeProbeEvent',
+      },
+    },
+    { eventBusSubscriptions: [SMOKE_PROBE_EVENT_BUS] }
+  ),
+];

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/config/index.ts

@@ -0,0 +1 @@
+export * from './defineEventBusSmoke';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/constants/SMOKE_PROBE_EVENT_BUS.ts

@@ -0,0 +1,2 @@
+/** The owned event bus the eventBus test publishes to. */
+export const SMOKE_PROBE_EVENT_BUS = 'smokeProbe';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/constants/SMOKE_PROBE_EVENT_QUEUE.ts

@@ -0,0 +1,2 @@
+/** The queue subscribed to the probe event bus; its entry writes the marker the test polls for. */
+export const SMOKE_PROBE_EVENT_QUEUE = 'smokeProbeEvents';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/constants/SMOKE_PROBE_EVENT_TYPE.ts

@@ -0,0 +1,2 @@
+/** The one message type that flows bus -> queue -> store marker. */
+export const SMOKE_PROBE_EVENT_TYPE = 'smokeProbeEvent';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/constants/index.ts

@@ -0,0 +1,3 @@
+export * from './SMOKE_PROBE_EVENT_BUS';
+export * from './SMOKE_PROBE_EVENT_QUEUE';
+export * from './SMOKE_PROBE_EVENT_TYPE';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/entry/index.ts

@@ -0,0 +1 @@
+export * from './queue';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/entry/queue/index.ts

@@ -0,0 +1 @@
+export * from './onSmokeProbeEvent';

package/template/apps/qpqjs/services/test/service/src/smoke/{queue → suites/eventBus/entry/queue}/onSmokeProbeEvent.ts

@@ -7,7 +7,7 @@ import {
 import { SMOKE_PROBE_STORE } from '@qpqjs/constants';
 import { SmokeProbeRecord } from '@qpqjs/test-models';
 
-import { SmokeProbeEventQueueEvent } from '../models/SmokeProbeEventQueueEvent';
+import { SmokeProbeEventQueueEvent } from '../../models/SmokeProbeEventQueueEvent';
 
 // Fan-in for the event bus test: the message published to the probe bus
 // lands here via the subscribed queue, and the marker row it writes is what

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/eventBusSmokeSuite.ts

@@ -0,0 +1,9 @@
+import { SmokeSuite } from '../../harness/types/SmokeSuite';
+import { defineEventBusSmoke } from './config/defineEventBusSmoke';
+import { askRunEventBusTest } from './logic/askRunEventBusTest';
+
+/** Publish to an owned event bus and wait for the subscribed queue's marker. */
+export const eventBusSmokeSuite: SmokeSuite = {
+  defineConfig: defineEventBusSmoke,
+  tests: [{ name: 'eventBus', askRun: askRunEventBusTest }],
+};

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/index.ts

@@ -0,0 +1,6 @@
+export * from './config';
+export * from './constants';
+export * from './entry';
+export * from './eventBusSmokeSuite';
+export * from './logic';
+export * from './models';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/logic/askRunEventBusTest.ts

@@ -0,0 +1,31 @@
+import {
+  askEventBusSendMessages,
+  askNewGuid,
+  AskResponse,
+  EventBusMessage,
+} from 'quidproquo';
+
+import { askSmokePollForMarker } from '../../../harness/assert/askSmokePollForMarker';
+import { SMOKE_PROBE_EVENT_BUS } from '../constants/SMOKE_PROBE_EVENT_BUS';
+import { SMOKE_PROBE_EVENT_TYPE } from '../constants/SMOKE_PROBE_EVENT_TYPE';
+import { SmokeProbeEventPayload } from '../models/SmokeProbeEventQueueEvent';
+
+// The full async fan-out / fan-in path: publish to the owned event bus, the
+// subscribed queue's entry (onSmokeProbeEvent) writes a marker row, and this
+// polls the store for it. Covers sns:Publish, the bus -> queue subscription,
+// and the queue lambda's own store access, in one round trip.
+export function* askRunEventBusTest(): AskResponse<void> {
+  const markerId = yield* askNewGuid();
+
+  const message: EventBusMessage<SmokeProbeEventPayload> = {
+    type: SMOKE_PROBE_EVENT_TYPE,
+    payload: { markerId },
+  };
+
+  yield* askEventBusSendMessages<SmokeProbeEventPayload>({
+    eventBusName: SMOKE_PROBE_EVENT_BUS,
+    eventBusMessages: [message],
+  });
+
+  yield* askSmokePollForMarker(markerId, 'the event bus and queue');
+}

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventBus/models/index.ts

@@ -0,0 +1 @@
+export * from './SmokeProbeEventQueueEvent';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventDoc/config/defineEventDocSmoke.ts

@@ -0,0 +1,44 @@
+import { defineQueue, QPQConfig } from 'quidproquo';
+import { defineEventDoc } from 'quidproquo-features';
+
+import {
+  SMOKE_EVENT_DOC_APPEND_MESSAGE_TYPE,
+  SMOKE_EVENT_DOC_APPEND_QUEUE,
+  SMOKE_EVENT_DOC_BASE_PATH,
+} from '../constants/smokeEventDoc';
+import { smokeProbeDocDefinition } from '../definition/smokeProbeDocDefinition';
+
+/**
+ * A full registered event-doc collection (stores, stream projector, dynamic
+ * functions, routes) so the tests exercise event docs the way a real service
+ * does, plus the queue that fans a test's writers out one invocation each so
+ * their appends race across lambdas.
+ */
+export const defineEventDocSmoke = (): QPQConfig => [
+  // NOTE the routes mount with no auth (the test service has no user
+  // directory), so the collection is world-writable; it holds nothing but
+  // throwaway probe docs.
+  defineEventDoc(
+    smokeProbeDocDefinition,
+    {
+      basePath: __dirname,
+      relativePath: '../definition/smokeProbeDocDefinition',
+      functionName: 'smokeProbeDocDefinition',
+    },
+    { basePath: SMOKE_EVENT_DOC_BASE_PATH }
+  ),
+  // A writer that loses the slot race past the append retry cap fails its
+  // message; a quick redelivery lets it land instead of vanishing, as a
+  // production queue should.
+  defineQueue(
+    SMOKE_EVENT_DOC_APPEND_QUEUE,
+    {
+      [SMOKE_EVENT_DOC_APPEND_MESSAGE_TYPE]: {
+        basePath: __dirname,
+        relativePath: '../entry/queue/onSmokeEventDocAppend',
+        functionName: 'onSmokeEventDocAppend',
+      },
+    },
+    { maxTries: 3, ttRetryInSeconds: 10 }
+  ),
+];

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventDoc/config/index.ts

@@ -0,0 +1 @@
+export * from './defineEventDocSmoke';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventDoc/constants/index.ts

@@ -0,0 +1 @@
+export * from './smokeEventDoc';

package/template/apps/qpqjs/services/test/service/src/smoke/{constants → suites/eventDoc/constants}/smokeEventDoc.ts

@@ -1,7 +1,7 @@
 import { EventDocEventActor, EventDocStoreOptions } from 'quidproquo-features';
 
 // The throwaway event-doc collection the smoke tests write to, registered in full via
-// defineEventDoc (see ../eventDoc/smokeProbeDocDefinition): stores, stream projector,
+// defineEventDoc (see ../definition/smokeProbeDocDefinition): stores, stream projector,
 // dynamic functions and routes, exactly as a real service's collection.
 export const SMOKE_EVENT_DOC_STORE = 'smokeEventDocs';
 export const SMOKE_EVENT_DOC_TYPE = 'smokeProbeDoc';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventDoc/entry/index.ts

@@ -0,0 +1 @@
+export * from './queue';

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventDoc/entry/queue/index.ts

@@ -0,0 +1 @@
+export * from './onSmokeEventDocAppend';

package/template/apps/qpqjs/services/test/service/src/smoke/{queue → suites/eventDoc/entry/queue}/onSmokeEventDocAppend.ts

@@ -11,9 +11,9 @@ import {
   SMOKE_EVENT_DOC_MARK_EVENT,
   SMOKE_EVENT_DOC_SCHEMA_VERSION,
   SMOKE_EVENT_DOC_STORE_OPTIONS,
-} from '../constants/smokeEventDoc';
-import { SmokeEventDocAppendQueueEvent } from '../models/SmokeEventDocAppendQueueEvent';
-import { SmokeEventDocMark } from '../models/SmokeEventDocMark';
+} from '../../constants/smokeEventDoc';
+import { SmokeEventDocAppendQueueEvent } from '../../models/SmokeEventDocAppendQueueEvent';
+import { SmokeEventDocMark } from '../../models/SmokeEventDocMark';
 
 // One writer in the event-doc concurrency tests. Every message is its own invocation,
 // so the writers of a test race each other for the log's next slots for real - the

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventDoc/eventDocSmokeSuite.ts

@@ -0,0 +1,19 @@
+import { SmokeSuite } from '../../harness/types/SmokeSuite';
+import { defineEventDocSmoke } from './config/defineEventDocSmoke';
+import { askRunEventDocConcurrentAppendTest } from './logic/askRunEventDocConcurrentAppendTest';
+import { askRunEventDocInterleavedBatchAppendTest } from './logic/askRunEventDocInterleavedBatchAppendTest';
+
+/** Racing appends onto one event doc across lambdas must stay contiguous. */
+export const eventDocSmokeSuite: SmokeSuite = {
+  defineConfig: defineEventDocSmoke,
+  tests: [
+    {
+      name: 'eventDocConcurrentAppend',
+      askRun: askRunEventDocConcurrentAppendTest,
+    },
+    {
+      name: 'eventDocInterleavedBatchAppend',
+      askRun: askRunEventDocInterleavedBatchAppendTest,
+    },
+  ],
+};

package/template/apps/qpqjs/services/test/service/src/smoke/suites/eventDoc/index.ts

@@ -0,0 +1,7 @@
+export * from './config';
+export * from './constants';
+export * from './definition';
+export * from './entry';
+export * from './eventDocSmokeSuite';
+export * from './logic';
+export * from './models';

package/template/apps/qpqjs/services/test/service/src/smoke/{tests/eventDoc → suites/eventDoc/logic}/askAssertContiguousEventIds.ts

@@ -1,7 +1,7 @@
 import { AskResponse } from 'quidproquo';
 import { EventDocEvent } from 'quidproquo-features';
 
-import { askSmokeAssert } from '../askSmokeAssert';
+import { askSmokeAssert } from '../../../harness/assert/askSmokeAssert';
 
 // The whole point of numeric event ids: an ascending list read of the log is exactly
 // 0, 1, 2, ... with no hole and no repeat, whatever order the writers raced in.

package/template/apps/qpqjs/services/test/service/src/smoke/{tests/eventDoc → suites/eventDoc/logic}/askAssertSmokeProbeDocState.ts

@@ -1,8 +1,8 @@
 import { AskResponse } from 'quidproquo';
 import { askEventDocDocumentStateLatest } from 'quidproquo-features';
 
-import { SmokeProbeDocState } from '../../eventDoc/smokeProbeDocDefinition';
-import { askSmokeAssert } from '../askSmokeAssert';
+import { askSmokeAssert } from '../../../harness/assert/askSmokeAssert';
+import { SmokeProbeDocState } from '../definition/smokeProbeDocDefinition';
 
 // The folded document, read the way the render/references routes read it: snapshot
 // seeded (whatever the stream projector has stored so far) plus the gap, through the

package/template/apps/qpqjs/services/test/service/src/smoke/{tests/eventDoc → suites/eventDoc/logic}/askAwaitSmokeEventDocLog.ts

@@ -1,9 +1,10 @@
 import { askDelay, AskResponse } from 'quidproquo';
 import { askEventDocEventListAll, EventDocEvent } from 'quidproquo-features';
 
-import { askSmokeAssert } from '../askSmokeAssert';
+import { askSmokeAssert } from '../../../harness/assert/askSmokeAssert';
 
-const POLL_ATTEMPTS = 20;
+// Long enough to cover a writer's retry laps plus one queue redelivery.
+const POLL_ATTEMPTS = 45;
 const POLL_INTERVAL_MS = 2000;
 
 // Poll a probe doc's log until it holds `expectedLength` events (INIT_STATE included),