@effect-app/infra 4.0.0-beta.99 → 4.0.1

package/test/cluster-servicebus.test.ts

@@ -0,0 +1,180 @@
+import type { ServiceBusMessage, ServiceBusReceiverOptions } from "@azure/service-bus"
+import { assert, describe, it } from "@effect/vitest"
+import { Context, Effect, Layer, Option, Schema, Stream } from "effect"
+import { ClusterSchema, EntityAddress, EntityId, EntityType, Envelope, Message, MessageStorage, Runners, ShardId, Sharding, ShardingConfig, Snowflake } from "effect/cluster"
+import { Headers } from "effect/http"
+import { Rpc } from "effect/rpc"
+import { type ClusterServiceBusClient, layerClientFrom, layerRunners, makeStoragePoller } from "../src/ClusterServiceBus.js"
+
+describe("ClusterServiceBus", () => {
+  it.effect("wakes storage polling from topic notifications", () =>
+    Effect.gen(function*() {
+      let processMessage: (() => Promise<void>) | undefined
+      let polls = 0
+      let receiverClosed = false
+      let subscriptionClosed = false
+
+      const client: ClusterServiceBusClient = {
+        createSender() {
+          throw new Error("unused")
+        },
+        createReceiver(topicName: string, subscriptionName: string, options?: ServiceBusReceiverOptions) {
+          assert.strictEqual(topicName, "cluster-notifications")
+          assert.strictEqual(subscriptionName, "runner-a")
+          assert.strictEqual(options?.receiveMode, "receiveAndDelete")
+          return {
+            subscribe(handlers) {
+              processMessage = handlers.processMessage
+              return {
+                close() {
+                  subscriptionClosed = true
+                  return Promise.resolve()
+                }
+              }
+            },
+            close() {
+              receiverClosed = true
+              return Promise.resolve()
+            }
+          }
+        },
+        close() {
+          return Promise.resolve()
+        }
+      }
+
+      const sharding = Sharding.Sharding.of({
+        activeEntityCount: Effect.succeed(0),
+        getRegistrationEvents: Stream.empty,
+        getShardId: () => ShardId.make("cluster-servicebus", 0),
+        getSnowflake: Effect.succeed(Snowflake.Snowflake(1n)),
+        hasShardId: () => false,
+        isShutdown: Effect.succeed(false),
+        makeClient: () => Effect.die("unused"),
+        notify: () => Effect.void,
+        pollStorage: Effect.sync(() => {
+          polls++
+        }),
+        registerEntity: () => Effect.void,
+        registerSingleton: () => Effect.void,
+        reset: () => Effect.succeed(false),
+        send: () => Effect.void,
+        sendOutgoing: () => Effect.void
+      })
+
+      yield* Effect
+        .scoped(
+          makeStoragePoller({
+            topicName: "cluster-notifications",
+            subscriptionName: "runner-a"
+          })
+            .pipe(
+              Effect.andThen(
+                Effect.gen(function*() {
+                  if (processMessage === undefined) {
+                    return yield* Effect.die("missing Service Bus subscription")
+                  }
+                  const runProcessMessage = processMessage
+                  yield* Effect.promise(() => runProcessMessage())
+                  assert.strictEqual(polls, 1)
+                })
+              )
+            )
+        )
+        .pipe(
+          Effect.provide(layerClientFrom(client)),
+          Effect.provide(Layer.succeed(Sharding.Sharding)(sharding))
+        )
+
+      assert.strictEqual(subscriptionClosed, true)
+      assert.strictEqual(receiverClosed, true)
+    }))
+
+  it.effect("publishes persisted storage notifications", () =>
+    Effect.gen(function*() {
+      const sent: Array<ServiceBusMessage> = []
+      let senderClosed = false
+
+      const client: ClusterServiceBusClient = {
+        createSender(topicName) {
+          assert.strictEqual(topicName, "cluster-notifications")
+          return {
+            sendMessages(message) {
+              sent.push(message)
+              return Promise.resolve()
+            },
+            close() {
+              senderClosed = true
+              return Promise.resolve()
+            }
+          }
+        },
+        createReceiver() {
+          throw new Error("unused")
+        },
+        close() {
+          return Promise.resolve()
+        }
+      }
+
+      yield* Effect.scoped(
+        Effect
+          .gen(function*() {
+            const runners = yield* Runners.Runners
+            yield* runners.notify({
+              address: Option.none(),
+              discard: true,
+              message: yield* makeOutgoingRequest
+            })
+          })
+          .pipe(
+            Effect.provide(layerRunners({ topicName: "cluster-notifications" })),
+            Effect.provide(layerClientFrom(client)),
+            Effect.provide(MessageStorage.layerNoop),
+            Effect.provide(ShardingConfig.layerDefaults)
+          )
+      )
+
+      assert.strictEqual(senderClosed, true)
+      assert.strictEqual(sent.length, 1)
+      assert.deepStrictEqual(sent[0]?.body, {
+        _tag: "EffectClusterStorageNotification",
+        envelopeId: "1",
+        requestId: "1",
+        shardId: "cluster-servicebus:1",
+        entityType: "TestEntity",
+        entityId: "entity-1"
+      })
+      assert.strictEqual(sent[0]?.contentType, "application/json")
+      assert.strictEqual(sent[0]?.correlationId, "1")
+      assert.strictEqual(sent[0]?.messageId, "1")
+      assert.strictEqual(sent[0]?.subject, "EffectClusterStorageNotification")
+    }))
+})
+
+const TestRpc = Rpc
+  .make("TestRpc", {
+    payload: { id: Schema.Number }
+  })
+  .annotate(ClusterSchema.Persisted, true)
+
+const makeOutgoingRequest = Effect.sync(() =>
+  new Message.OutgoingRequest({
+    annotations: TestRpc.annotations,
+    context: Context.empty(),
+    envelope: Envelope.makeRequest<typeof TestRpc>({
+      address: EntityAddress.make({
+        entityId: EntityId.make("entity-1"),
+        entityType: EntityType.make("TestEntity"),
+        shardId: ShardId.make("cluster-servicebus", 1)
+      }),
+      headers: Headers.empty,
+      payload: { id: 1 },
+      requestId: Snowflake.Snowflake(1n),
+      tag: TestRpc._tag
+    }),
+    lastReceivedReply: Option.none(),
+    respond: () => Effect.void,
+    rpc: TestRpc
+  })
+)

package/test/cluster-sqlite.test.ts

@@ -0,0 +1,207 @@
+import { NodeCrypto } from "@effect/platform-node"
+import { SqliteClient } from "@effect/sql-sqlite-node"
+import { assert, describe, it } from "@effect/vitest"
+import { Context, Duration, Effect, Exit, Fiber, Layer, Option, Schema } from "effect"
+import { ClusterSchema, ClusterWorkflowEngine, RunnerAddress, RunnerHealth, Runners, Sharding, ShardingConfig, SqlMessageStorage, SqlRunnerStorage } from "effect/cluster"
+import { DurableDeferred, Workflow } from "effect/workflow"
+
+const testRunId = `${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}`
+const runnerPortBase = 10000 + Date.now() % 40000
+
+describe("ClusterSqlite Workflow", () => {
+  it.live("resumes a running workflow suspended on a durable deferred", () =>
+    Effect
+      .gen(function*() {
+        const sharding = yield* Sharding.Sharding
+        const payload = { id: `deferred-${testRunId}` }
+        const executionId = yield* SqliteDeferredWorkflow.executionId(payload)
+
+        const fiber = yield* SqliteDeferredWorkflow.execute(payload).pipe(Effect.forkScoped)
+        yield* waitForDeferredWorkflowSuspended(executionId)
+
+        const token = yield* DurableDeferred.tokenFromPayload(SqliteDeferred, {
+          workflow: SqliteDeferredWorkflow,
+          payload
+        })
+        yield* DurableDeferred.done(SqliteDeferred, { token, exit: Exit.succeed("resolved") })
+        yield* sharding.pollStorage
+
+        const value = yield* Fiber.join(fiber).pipe(Effect.timeout(Duration.seconds(15)))
+        assert.strictEqual(value, `${payload.id}:resolved`)
+        assert.strictEqual(yield* waitForDeferredWorkflowComplete(executionId), `${payload.id}:resolved`)
+      })
+      .pipe(Effect.provide(clusterWorkflowLayer())), 30000)
+
+  it.live("progresses through sequential durable deferred steps", () =>
+    Effect
+      .gen(function*() {
+        const log = yield* StepLog
+        const sharding = yield* Sharding.Sharding
+        const payload = { id: `steps-${testRunId}` }
+        const executionId = yield* SequentialDeferredWorkflow.executionId(payload)
+
+        const fiber = yield* SequentialDeferredWorkflow.execute(payload).pipe(Effect.forkScoped)
+        yield* waitForSequentialWorkflowSuspended(executionId)
+
+        yield* completeStep(SequentialStep1, payload, "one")
+        yield* sharding.pollStorage
+        yield* waitForStep(log, "step-1")
+
+        yield* completeStep(SequentialStep2, payload, "two")
+        yield* sharding.pollStorage
+        yield* waitForStep(log, "step-2")
+
+        yield* completeStep(SequentialStep3, payload, "three")
+        yield* sharding.pollStorage
+
+        const value = yield* Fiber.join(fiber).pipe(Effect.timeout(Duration.seconds(15)))
+        assert.strictEqual(value, "one:two:three")
+        assert(log.steps.includes("step-3"))
+      })
+      .pipe(Effect.provide(clusterWorkflowLayer())), 30000)
+})
+
+class StepLog extends Context.Service<StepLog, { readonly steps: Array<string> }>()("StepLog") {
+  static readonly layer = Layer.effect(StepLog, Effect.sync(() => ({ steps: [] })))
+}
+
+const SqliteDeferred = DurableDeferred.make("ClusterSqlite/Deferred", { success: Schema.String })
+
+const SqliteDeferredWorkflow = Workflow
+  .make("ClusterSqlite/DeferredWorkflow", {
+    payload: { id: Schema.String },
+    success: Schema.String,
+    idempotencyKey: ({ id }) => id
+  })
+  .annotate(ClusterSchema.ShardGroup, () => testShardGroup("workflow"))
+
+const SqliteDeferredWorkflowLayer = SqliteDeferredWorkflow.toLayer(Effect.fnUntraced(function*({ id }) {
+  const value = yield* DurableDeferred.await(SqliteDeferred)
+  return `${id}:${value}`
+}))
+
+const SequentialStep1 = DurableDeferred.make("ClusterSqlite/SequentialStep1", { success: Schema.String })
+const SequentialStep2 = DurableDeferred.make("ClusterSqlite/SequentialStep2", { success: Schema.String })
+const SequentialStep3 = DurableDeferred.make("ClusterSqlite/SequentialStep3", { success: Schema.String })
+
+const SequentialDeferredWorkflow = Workflow
+  .make("ClusterSqlite/SequentialDeferredWorkflow", {
+    payload: { id: Schema.String },
+    success: Schema.String,
+    idempotencyKey: ({ id }) => id
+  })
+  .annotate(ClusterSchema.ShardGroup, () => testShardGroup("workflow"))
+
+const SequentialDeferredWorkflowLayer = SequentialDeferredWorkflow.toLayer(Effect.fnUntraced(function*() {
+  const log = yield* StepLog
+  const step1 = yield* DurableDeferred.await(SequentialStep1)
+  log.steps.push("step-1")
+  const step2 = yield* DurableDeferred.await(SequentialStep2)
+  log.steps.push("step-2")
+  const step3 = yield* DurableDeferred.await(SequentialStep3)
+  log.steps.push("step-3")
+  return `${step1}:${step2}:${step3}`
+}))
+
+const clusterWorkflowLayer = () => {
+  const prefix = "test_cluster_sqlite"
+  const config = ShardingConfig.layer({
+    runnerAddress: Option.some(testRunnerAddress(20)),
+    shardsPerGroup: 1,
+    availableShardGroups: [testShardGroup("workflow")],
+    assignedShardGroups: [testShardGroup("workflow")],
+    entityTerminationTimeout: 0,
+    entityMessagePollInterval: 50,
+    entityReplyPollInterval: 50,
+    refreshAssignmentsInterval: 0,
+    sendRetryInterval: 50
+  })
+  const storage = Layer
+    .merge(
+      SqlMessageStorage.layerWith({ prefix }),
+      Layer.orDie(SqlRunnerStorage.layerWith({ prefix }))
+    )
+    .pipe(Layer.provide(SqliteClient.layer({ filename: ":memory:" })))
+
+  return Layer
+    .merge(SqliteDeferredWorkflowLayer, SequentialDeferredWorkflowLayer)
+    .pipe(
+      Layer.provideMerge(StepLog.layer),
+      Layer.provideMerge(
+        ClusterWorkflowEngine.layer.pipe(
+          Layer.provideMerge(Sharding.layer),
+          Layer.provide(Runners.layerNoop),
+          Layer.provide(RunnerHealth.layerNoop),
+          Layer.provide(storage),
+          Layer.provide(config),
+          Layer.provide(NodeCrypto.layer)
+        )
+      )
+    )
+}
+
+const completeStep = <Success extends Schema.Top>(
+  deferred: DurableDeferred.DurableDeferred<Success, Schema.Never>,
+  payload: { readonly id: string },
+  value: Success["Type"]
+) =>
+  Effect.gen(function*() {
+    const token = yield* DurableDeferred.tokenFromPayload(deferred, {
+      workflow: SequentialDeferredWorkflow,
+      payload
+    })
+    yield* DurableDeferred.done(deferred, { token, exit: Exit.succeed(value) })
+  })
+
+const waitForDeferredWorkflowSuspended = (executionId: string) => waitForSuspended(SqliteDeferredWorkflow, executionId)
+
+const waitForSequentialWorkflowSuspended = (executionId: string) =>
+  waitForSuspended(SequentialDeferredWorkflow, executionId)
+
+const waitForSuspended = <A, E, R>(
+  workflow: {
+    readonly poll: (
+      executionId: string
+    ) => Effect.Effect<Option.Option<Workflow.Result<A, E>>, never, R>
+  },
+  executionId: string
+) =>
+  Effect.gen(function*() {
+    const sharding = yield* Sharding.Sharding
+    for (let i = 0; i < 100; i++) {
+      yield* sharding.pollStorage
+      const polled = yield* workflow.poll(executionId)
+      if (Option.isSome(polled) && polled.value._tag === "Suspended") return
+      yield* Effect.sleep(Duration.millis(100))
+    }
+    return yield* Effect.fail(new Error(`Workflow ${executionId} did not suspend`))
+  })
+
+const waitForDeferredWorkflowComplete = (executionId: string) =>
+  Effect.gen(function*() {
+    const sharding = yield* Sharding.Sharding
+    for (let i = 0; i < 100; i++) {
+      yield* sharding.pollStorage
+      const polled = yield* SqliteDeferredWorkflow.poll(executionId)
+      if (Option.isSome(polled) && polled.value._tag === "Complete") {
+        const exit = polled.value.exit
+        assert(Exit.isSuccess(exit))
+        return exit.value
+      }
+      yield* Effect.sleep(Duration.millis(100))
+    }
+    return yield* Effect.fail(new Error(`Workflow ${executionId} did not complete`))
+  })
+
+const waitForStep = (log: StepLog["Service"], step: string) =>
+  Effect.gen(function*() {
+    for (let i = 0; i < 100; i++) {
+      if (log.steps.includes(step)) return
+      yield* Effect.sleep(Duration.millis(100))
+    }
+    return yield* Effect.fail(new Error(`Workflow did not reach ${step}`))
+  })
+
+const testShardGroup = (label: string) => `cluster-sqlite-${testRunId}-${label}`
+
+const testRunnerAddress = (offset: number) => RunnerAddress.make("localhost", runnerPortBase + offset)

package/test/contextProvider.test.ts

@@ -1,8 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { expectTypeOf, it } from "@effect/vitest"
-import { Effect, Layer, Scope, Context } from "effect-app"
-import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/ContextProvider.js"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import * as Scope from "effect/Scope"
+import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/ContextProvider.js"
 import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
@@ -20,7 +23,7 @@ class MyContextProvider extends Context.Service<MyContextProvider>()(
         yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
         yield* Effect.succeed("this is a generator")
 
-        return Some.serviceMap({ a: 1 }) 
+        return Some.context({ a: 1 })
       })
     })
   }
@@ -37,7 +40,7 @@ class MyContextProvider2 extends Context.Service<MyContextProvider2>()(
       return Effect.gen(function*() {
         // we test without dependencies, so that we end up with an R of never.
 
-        return SomeElse.serviceMap({ b: 2 })
+        return SomeElse.context({ b: 2 })
       })
     })
   }
@@ -54,7 +57,7 @@ class MyContextProvider2Gen extends Context.Service<MyContextProvider2Gen>()(
       return function*() {
         // we test without dependencies, so that we end up with an R of never
 
-        return SomeElse.serviceMap({ b: 2 })
+        return SomeElse.context({ b: 2 })
       }
     })
   }
@@ -77,7 +80,7 @@ class MyContextProviderGen extends Context.Service<MyContextProviderGen>()(
         yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
         yield* Effect.succeed("this is a generator")
 
-        return Some.serviceMap({ a: 1 })
+        return Some.context({ a: 1 })
       }
     })
   }
@@ -100,7 +103,7 @@ export const someContextProvider = ContextProvider({
       // currently the effectful context provider cannot trigger an error when building the per request context
       // if (Math.random() > 0.5) return yield* new CustomError2()
 
-      return Some.serviceMap({ a: 1 })
+      return Some.context({ a: 1 })
     })
   })
 })
@@ -119,7 +122,7 @@ export const someContextProviderGen = ContextProvider({
       // currently the effectful context provider cannot trigger an error when building the per request context
       // if (Math.random() > 0.5) return yield* new CustomError2()
 
-      return Some.serviceMap({ a: 1 })
+      return Some.context({ a: 1 })
     }
   })
 })

package/test/controller.test.ts

@@ -1,16 +1,20 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
+import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/routing"
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { Context, Effect, Layer, S, Scope } from "effect-app"
 import { InvalidStateError, makeRpcClient, UnauthorizedError } from "effect-app/client"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
 import { DefaultGenericMiddlewares } from "effect-app/middleware"
 import * as RpcX from "effect-app/rpc"
 import { MiddlewareMaker } from "effect-app/rpc"
+import * as S from "effect-app/Schema"
 import { TypeTestId } from "effect-app/TypeTest"
-import { type RpcSerialization } from "effect/unstable/rpc"
-import { DefaultGenericMiddlewaresLive, DevModeMiddlewareLive } from "../src/api/routing/middleware.js"
-import { sort } from "../src/api/routing/tsort.js"
+import { type RpcSerialization } from "effect/rpc"
+import * as Scope from "effect/Scope"
+import { DefaultGenericMiddlewaresLive, DevModeMiddlewareLive } from "../src/routing/middleware.js"
+import { sort } from "../src/routing/tsort.js"
 import { AllowAnonymous, AllowAnonymousLive, CustomError1, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElse, SomeService, Test, TestLive } from "./fixtures.js"
 
 class MyContextProvider extends RpcX.RpcMiddleware.Tag<MyContextProvider, {
@@ -188,13 +192,6 @@ const middlewareQuater = MiddlewareMaker
 
 expectTypeOf(middleware["Service"]).toEqualTypeOf<typeof middlewareQuater["Service"]>()
 
-const middleware2 = MiddlewareMaker
-  .Tag()("middleware", RequestContextMap)
-  .middleware(MyContextProvider)
-  .middleware(RequireRoles, Test)
-  .middleware(AllowAnonymous)
-  .middleware(...DefaultGenericMiddlewares, BogusMiddleware, MyContextProvider2)
-
 export const middleware3 = MiddlewareMaker
   .Tag()("middleware", RequestContextMap)
   .middleware(...genericMiddlewares)
@@ -202,15 +199,17 @@ export const middleware3 = MiddlewareMaker
   .middleware(Test)
   .middleware(BogusMiddleware)
 
-export const { TaggedRequestFor } = makeRpcClient(RequestContextMap)
+export const { TaggedRequestFor } = makeRpcClient(middleware)
 const Req = TaggedRequestFor("Something")
+const Command = Req.Command
+const Query = Req.Query
 
-export class Eff extends Req<Eff>()("Eff", {}, { success: S.Void }) {}
-export class Gen extends Req<Gen>()("Gen", {}) {}
+export class Eff extends Command<Eff>()("Eff", {}, { success: S.Void }) {}
+export class Gen extends Command<Gen>()("Gen", {}) {}
 
 expectTypeOf(Eff.error).toEqualTypeOf<typeof Gen.error>()
 
-export class DoSomething extends Req<DoSomething>()("DoSomething", {
+export class DoSomething extends Command<DoSomething>()("DoSomething", {
   id: S.String
 }, { success: S.Void }) {}
 
@@ -228,11 +227,11 @@ export class DoSomething extends Req<DoSomething>()("DoSomething", {
 //   )
 // )
 
-export class GetSomething extends Req<GetSomething>()("GetSomething", {
+export class GetSomething extends Query<GetSomething>()("GetSomething", {
   id: S.String
-}, { success: S.String }) {}
+}, { success: S.String, error: UnauthorizedError }) {}
 
-export class GetSomething2 extends Req<GetSomething2>()("GetSomething2", {
+export class GetSomething2 extends Query<GetSomething2>()("GetSomething2", {
   id: S.String
 }, { success: S.FiniteFromString }) {}
 
@@ -254,7 +253,7 @@ export class SomethingService extends Context.Service<SomethingService>()(
   static Default = Layer.effect(this, this.make)
 }
 
-declare const a: {
+declare const _a: {
   (opt: { a: 1 }): void
   (opt: { a: 2 }): void
   (opt: { b: 3 }): void
@@ -285,13 +284,9 @@ export class SomethingService2 extends Context.Service<SomethingService2>()(
   static Default = Layer.effect(this, this.make)
 }
 
-export const { Router, matchAll } = makeRouter(
-  middleware
-)
+export const { Router, matchAll } = makeRouter(middleware.Default)
 
-export const r2 = makeRouter(
-  Object.assign(middleware2, { Default: middleware2.layer.pipe(Layer.provide([...MiddlewaresLive])) })
-)
+export const r2 = makeRouter(middleware.Default)
 
 const router = Router(Something)({
   dependencies: [
@@ -349,7 +344,7 @@ const router = Router(Something)({
         }
       },
       GetSomething2: {
-        raw: Some.use(() => Effect.succeed("12"))
+        raw: () => Some.use(() => Effect.succeed("12"))
       }
     })
   }
@@ -414,7 +409,7 @@ const router2 = r2.Router(Something)({
         }
       },
       GetSomething2: {
-        raw: Some.use(() => Effect.succeed("12"))
+        raw: () => Some.use(() => Effect.succeed("12"))
       }
     })
   }

package/test/cosmos-container-throughput.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "@effect/vitest"
+import { type ContainerDb, createContainerIfNotExists } from "../src/cosmos-client.js"
+
+const body = { id: "prefix-Orders", partitionKey: { paths: ["/_partitionKey"], version: 2 } }
+
+const fakeDb = (opts: {
+  readonly read: () => Promise<unknown>
+  readonly sharedOffer: boolean
+  readonly offerError?: unknown
+}) => {
+  const calls = { created: [] as Array<unknown>, offerReads: 0 }
+  const db: ContainerDb = {
+    container: () => ({ read: opts.read }),
+    containers: {
+      createIfNotExists: (req) => {
+        calls.created.push(req)
+        return Promise.resolve({})
+      }
+    },
+    readOffer: () => {
+      calls.offerReads++
+      if (opts.offerError !== undefined) return Promise.reject(opts.offerError)
+      return Promise.resolve({ resource: opts.sharedOffer ? { id: "offer" } : undefined })
+    }
+  }
+  return { calls, db }
+}
+
+const existing = () => Promise.resolve({})
+const missing = () => Promise.reject({ code: 404 })
+
+describe("createContainerIfNotExists", () => {
+  it("keeps the Cosmos default when no autoscale max is configured", async () => {
+    const { calls, db } = fakeDb({ read: missing, sharedOffer: false })
+    await createContainerIfNotExists(db, body)
+    expect(calls.created).toEqual([body])
+    expect(calls.offerReads).toBe(0)
+  })
+
+  it("creates a missing container with autoscale in a database without shared throughput", async () => {
+    const { calls, db } = fakeDb({ read: missing, sharedOffer: false })
+    await createContainerIfNotExists(db, body, { autoscaleMaxThroughput: 1000 })
+    expect(calls.created).toEqual([{ ...body, maxThroughput: 1000 }])
+  })
+
+  it("lets a missing container share the database throughput when the database has an offer", async () => {
+    const { calls, db } = fakeDb({ read: missing, sharedOffer: true })
+    await createContainerIfNotExists(db, body, { autoscaleMaxThroughput: 1000 })
+    expect(calls.created).toEqual([body])
+  })
+
+  it("leaves existing containers untouched", async () => {
+    const { calls, db } = fakeDb({ read: existing, sharedOffer: false })
+    await createContainerIfNotExists(db, body, { autoscaleMaxThroughput: 1000 })
+    expect(calls.created).toEqual([])
+    expect(calls.offerReads).toBe(0)
+  })
+
+  it("propagates container read errors other than not found", async () => {
+    const { calls, db } = fakeDb({ read: () => Promise.reject({ code: 403 }), sharedOffer: false })
+    await expect(createContainerIfNotExists(db, body, { autoscaleMaxThroughput: 1000 })).rejects.toEqual({
+      code: 403
+    })
+    expect(calls.created).toEqual([])
+  })
+
+  it("creates without throughput when offer reads are rejected as serverless", async () => {
+    const { calls, db } = fakeDb({
+      read: missing,
+      sharedOffer: false,
+      offerError: {
+        code: 400,
+        message: "Reading or replacing offers is not supported for serverless accounts."
+      }
+    })
+    await createContainerIfNotExists(db, body, { autoscaleMaxThroughput: 1000 })
+    expect(calls.created).toEqual([body])
+    expect(calls.offerReads).toBe(1)
+  })
+})