@truenas/api-client 6.0.1 → 6.0.2

package/dist/testing/index.js

@@ -0,0 +1,716 @@
+import { SUPPORTED_API_VERSIONS, TrueNasConnection, noopLogger, TrueNasAuthenticator, parseApiVersion, clientClassFor } from '../chunk-7QVRLQIZ.js';
+export { AuthResponseType } from '../chunk-7QVRLQIZ.js';
+import { Subject, distinctUntilChanged, takeUntil, filter, map, Subscription } from 'rxjs';
+
+// src/testing/unmocked-call-error.ts
+var UnmockedCallError = class extends Error {
+  constructor(method, params) {
+    super(
+      `Unmocked call: nothing is scripted to answer '${method}'${params === void 0 ? "" : ` with ${JSON.stringify(params)}`}. Script it with mock.call / mock.query / mock.job, answer the frame with connection.reply, or build the client without { strict: true }.`
+    );
+    this.method = method;
+    this.params = params;
+    this.name = "UnmockedCallError";
+  }
+};
+
+// src/testing/fake-connection.ts
+var CLIENT_HOUSEKEEPING = /* @__PURE__ */ new Set(["core.subscribe"]);
+var FakeConnection = class extends TrueNasConnection {
+  constructor(options = {}) {
+    super(
+      // Disabled: `connection$` derives from this, so no socket is ever built
+      // and none of the retry machinery runs.
+      false,
+      [],
+      options.uuid ?? "fake-uuid",
+      options.websocketPath ?? "/api/current",
+      void 0,
+      0,
+      0,
+      noopLogger
+    );
+    this.incoming = new Subject();
+    this.frames = [];
+    /** Frames handed to `send` while closed, waiting for the socket. */
+    this.queued = [];
+    this.autoReplies = /* @__PURE__ */ new Map();
+    /** Set by `close()`. Latched, because the real connection cannot come back. */
+    this.terminated = false;
+    /**
+     * The canonical streams, re-pointed at what this class actually drives.
+     *
+     * The base derives all three from `connection$`, which on a disabled
+     * connection reports one state and then nothing: `{ state: 'closed' }`. So
+     * they describe the connection that never connects, not the one the test is
+     * driving — `messages$` stayed silent while `receive` delivered, `opened$`
+     * stayed `[false]` through every simulated open, and `closed$` reported a
+     * connection that had never been up. `messages()` is a shim over `messages$`;
+     * leaving them disagreeing puts the divergence in the members a consumer is
+     * most likely to reach for.
+     */
+    this.messages$ = this.incoming.asObservable();
+    this.opened$ = this.opened.pipe(
+      distinctUntilChanged(),
+      takeUntil(this.closeConnection)
+    );
+    this.closed$ = this.opened.pipe(
+      distinctUntilChanged(),
+      filter((isOpen) => !isOpen),
+      map(() => void 0),
+      takeUntil(this.closeConnection)
+    );
+    this.strict = options.strict ?? false;
+    if (options.opened ?? true) this.simulateOpen();
+  }
+  /** Every frame handed to `send`, in order. */
+  get sent() {
+    return this.frames;
+  }
+  /**
+   * Records the frame, or queues it until the connection opens.
+   *
+   * The real `send` queues on `ws$` until a socket exists and returns the
+   * subscription holding that queue open; a caller who gives up unsubscribes
+   * it and the frame never goes out. Both halves are reproduced, because
+   * "records everything regardless of `opened`" is precisely the divergence
+   * the hand-rolled double had — it forwarded straight through — and moving it
+   * in here would have been the same bug in a better-looking place.
+   */
+  send(message) {
+    if (this.strict && message.method !== void 0 && !this.autoReplies.has(message.method) && !CLIENT_HOUSEKEEPING.has(message.method)) {
+      throw new UnmockedCallError(message.method, message.params);
+    }
+    if (this.terminated) {
+      const dropped = new Subscription();
+      dropped.unsubscribe();
+      return dropped;
+    }
+    if (!this.opened.getValue()) {
+      this.queued.push(message);
+      return new Subscription(() => {
+        const at = this.queued.indexOf(message);
+        if (at >= 0) this.queued.splice(at, 1);
+      });
+    }
+    this.write(message);
+    const done = new Subscription();
+    done.unsubscribe();
+    return done;
+  }
+  /**
+   * Answer any frame for `method` as soon as it is written.
+   *
+   * The narrow ancestor of `mockCall`: enough to let a collaborator that talks
+   * to the appliance — the authenticator, for one — run its real code against
+   * a scripted answer rather than be replaced by a fake of itself.
+   *
+   * One answer per method, last registration wins. The one it replaced is
+   * returned so a caller that needs to share the method can chain to it rather
+   * than take it over silently.
+   */
+  autoReply(method, answer) {
+    const replaced = this.autoReplies.get(method);
+    this.autoReplies.set(method, answer);
+    return replaced;
+  }
+  write(message) {
+    this.frames.push(message);
+    const answer = this.autoReplies.get(String(message.method));
+    if (!answer) return;
+    queueMicrotask(() => answer(message));
+  }
+  /** Deliver a message as if middleware had sent it. */
+  receive(message) {
+    this.incoming.next(message);
+  }
+  /**
+   * Answer the most recent frame carrying `method`, by its id.
+   *
+   * Ids are what correlate a reply to a request, and a test that had to read
+   * them itself would be asserting on the id generator. Most recent rather
+   * than first: a spec that calls the same method twice is asking about the
+   * second one.
+   */
+  reply(method, result) {
+    this.receive({ jsonrpc: "2.0", id: this.idOf(method), result });
+  }
+  /**
+   * As {@link reply}, with a JSON-RPC error instead of a result.
+   *
+   * Typed as the frame `/api/<version>` sends and nothing else: `code` and
+   * `message` outside, the TrueNAS payload under `data`. The legacy
+   * `/websocket` shape — those payload fields at the top level — is not
+   * accepted, so a spec cannot script an error this client can never receive.
+   * It was accepted until now only because the parameter was the loose
+   * `ApiError` union, which admits both.
+   *
+   * The cast is gone with it: the frame's own type says this is what an error
+   * looks like.
+   */
+  replyError(method, error) {
+    this.receive({ jsonrpc: "2.0", id: this.idOf(method), error });
+  }
+  /**
+   * Raise `opened` and flush whatever was queued, as the socket opening would.
+   *
+   * The queue drains after `opened` goes true, which is the order the real
+   * connection produces: `send` is waiting on `ws$`, and `ws$` emits because a
+   * socket arrived.
+   */
+  simulateOpen() {
+    if (this.terminated || this.opened.getValue()) return;
+    this.opened.next(true);
+    const pending = this.queued.splice(0, this.queued.length);
+    for (const message of pending) this.write(message);
+  }
+  /**
+   * Lower `opened` and fire `closed`, as a socket closing would.
+   *
+   * Named for what it simulates rather than overriding `close()`, which on the
+   * real connection means "stop, and do not retry" — a different verb that
+   * callers already use for teardown.
+   */
+  simulateClose() {
+    if (this.terminated || !this.opened.getValue()) return;
+    this.opened.next(false);
+    this.closed.next();
+  }
+  /**
+   * Terminal, as on the real connection: the streams end and nothing more is
+   * written.
+   *
+   * `simulateClose` is the socket dropping — recoverable, and the client will
+   * try again. This is the caller giving up on the connection for good, so the
+   * message stream completes and `send` has nowhere to put a frame.
+   */
+  close() {
+    if (this.terminated) return;
+    this.terminated = true;
+    this.incoming.complete();
+    super.close();
+  }
+  idOf(method) {
+    const frame = [...this.frames].reverse().find((m) => m.method === method);
+    if (!frame) {
+      throw new Error(
+        `No frame for '${method}' has been sent; sent so far: ${this.frames.map((m) => String(m.method)).join(", ") || "(none)"}`
+      );
+    }
+    return frame.id ?? "";
+  }
+};
+
+// src/testing/fake-authenticator.ts
+var FakeAuthenticator = class extends TrueNasAuthenticator {
+  constructor(fakeConnection, version) {
+    super(fakeConnection, version);
+    this.fakeConnection = fakeConnection;
+    this.attempts = [];
+    /**
+     * Answers waiting for their frames, oldest first.
+     *
+     * Bound when the login is *made*, not when the reply goes out. Reading an
+     * armed answer at reply time meant a second login armed in the meantime
+     * answered the first — two logins in flight is exactly what testing
+     * supersession looks like, so scripting both is the ordinary case, and it
+     * produced the same wrong verdict this class was rewritten to stop
+     * producing.
+     */
+    this.pending = [];
+    this.fakeConnection.autoReply("auth.login_ex", (frame) => {
+      this.fakeConnection.receive({
+        jsonrpc: "2.0",
+        id: frame.id,
+        result: this.pending.shift() ?? this.success()
+      });
+    });
+  }
+  /**
+   * Every login attempt, in order.
+   *
+   * Including the ones the base class makes itself: the auto-relogin runs
+   * through these same methods, and nothing here distinguishes it from a
+   * caller's login. A spec counting logins across a reconnect should expect
+   * that one.
+   */
+  get logins() {
+    return this.attempts;
+  }
+  /** The next login is answered with this response. Defaults to a success. */
+  succeedNextLogin(response = {}) {
+    this.armed = { response_type: "SUCCESS" /* Success */, ...response };
+  }
+  /**
+   * The next login is answered with a rejection.
+   *
+   * A `response_type` rather than an `Error`, so what the caller sees is
+   * whatever the real authenticator makes of it — the `AuthError` codes
+   * included, which a hand-thrown `Error` could not produce.
+   */
+  failNextLogin(responseType = "AUTH_ERR" /* AuthErr */) {
+    this.armed = { response_type: responseType };
+  }
+  /**
+   * Records the attempt and binds its answer, in that order, before the real
+   * method puts a frame on the wire.
+   */
+  record(mechanism, credential) {
+    this.attempts.push({ mechanism, credential });
+    this.pending.push(this.armed ?? this.success());
+    this.armed = void 0;
+  }
+  success() {
+    return { response_type: "SUCCESS" /* Success */ };
+  }
+  loginWithUserPass(username, password) {
+    this.record("PASSWORD_PLAIN" /* Password */, username);
+    return super.loginWithUserPass(username, password);
+  }
+  loginWithToken(token) {
+    this.record("TOKEN_PLAIN" /* Token */, token);
+    return super.loginWithToken(token);
+  }
+  loginWithApiKey(credentials) {
+    this.record("API_KEY_PLAIN" /* ApiKey */, credentials.username);
+    return super.loginWithApiKey(credentials);
+  }
+  loginWithOtp(code) {
+    this.record("OTP_TOKEN" /* Otp */, code);
+    return super.loginWithOtp(code);
+  }
+};
+
+// src/testing/present.ts
+function present(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, v]) => v !== void 0)
+  );
+}
+
+// src/testing/fake-api-error.ts
+var BARE_REPR = /^([A-Za-z_][A-Za-z0-9_]*)\(\)$/;
+var UNPRINTABLE = /[\p{Cc}\p{Cf}\p{Cs}\p{Co}\p{Cn}\p{Zl}\p{Zp}\p{Zs}]/u;
+function escapeCodePoint(character) {
+  if (character === "\n") return "\\n";
+  if (character === "\r") return "\\r";
+  if (character === "	") return "\\t";
+  const code = character.codePointAt(0);
+  if (code < 256) return `\\x${code.toString(16).padStart(2, "0")}`;
+  if (code < 65536) return `\\u${code.toString(16).padStart(4, "0")}`;
+  return `\\U${code.toString(16).padStart(8, "0")}`;
+}
+function pythonRepr(value) {
+  const quote = value.includes("'") && !value.includes('"') ? '"' : "'";
+  let escaped = "";
+  for (const character of value) {
+    if (character === "\\") escaped += "\\\\";
+    else if (character === quote) escaped += `\\${quote}`;
+    else if (character === " " || !UNPRINTABLE.test(character)) escaped += character;
+    else escaped += escapeCodePoint(character);
+  }
+  return `${quote}${escaped}${quote}`;
+}
+function syntheticTrace(reason) {
+  const bare = BARE_REPR.exec(reason);
+  const cls = bare ? bare[1] : "ValueError";
+  const repr = bare ? reason : `ValueError(${pythonRepr(reason)})`;
+  return {
+    class: cls,
+    formatted: `Traceback (most recent call last):
+  <synthetic>
+${repr}
+`,
+    repr
+  };
+}
+function fakeApiError(overrides = {}) {
+  const { code, message, ...data } = overrides;
+  const reason = data.reason ?? "Invalid argument";
+  return {
+    code: code ?? -32001,
+    message: message ?? "Method call error",
+    data: {
+      error: 22,
+      errname: "EINVAL",
+      reason,
+      extra: null,
+      trace: syntheticTrace(reason),
+      ...present(data)
+    }
+  };
+}
+
+// src/testing/fake-job.ts
+function fakeJob(overrides = {}) {
+  const progress = {
+    percent: 0,
+    description: "",
+    extra: null,
+    ...present(overrides.progress ?? {})
+  };
+  return {
+    id: 1,
+    method: "test.job",
+    arguments: [],
+    transient: false,
+    description: null,
+    abortable: false,
+    logs_path: null,
+    logs_excerpt: null,
+    result: null,
+    result_encoding_error: null,
+    error: null,
+    exception: null,
+    exc_info: null,
+    state: "RUNNING" /* Running */,
+    time_started: null,
+    time_finished: null,
+    credentials: null,
+    ...present(overrides),
+    progress
+  };
+}
+
+// src/testing/mock-answers.ts
+function readJobId(read) {
+  const [filters] = read.params ?? [];
+  if (!Array.isArray(filters) || filters.length !== 1) return void 0;
+  const [clause] = filters;
+  if (!Array.isArray(clause) || clause.length !== 3) return void 0;
+  const [field, operator, value] = clause;
+  if (field !== "id" || operator !== "=" || typeof value !== "number") return void 0;
+  return value;
+}
+function createMockAnswers(connection) {
+  let nextJobId = 1;
+  const answer = (frame, result) => {
+    connection.receive({ jsonrpc: "2.0", id: frame.id, result });
+  };
+  const sequences = /* @__PURE__ */ new Map();
+  const position = /* @__PURE__ */ new Map();
+  const walking = /* @__PURE__ */ new Set();
+  const started = /* @__PURE__ */ new Set();
+  const allocateId = () => {
+    while (sequences.has(nextJobId)) nextJobId++;
+    return nextJobId++;
+  };
+  const scriptedMethods = /* @__PURE__ */ new Set();
+  const readOptions = (read) => {
+    const [, options] = read.params ?? [];
+    return options;
+  };
+  const isTracking = (read) => (read.params ?? []).length === 1;
+  const answerRead = (read, job) => {
+    const options = readOptions(read);
+    if (options?.count) return answer(read, job ? 1 : 0);
+    if (options?.get) {
+      return job ? answer(read, job) : notFound(read);
+    }
+    answer(read, job ? [job] : []);
+  };
+  let dispatcher;
+  let fallback;
+  const notFound = (frame) => {
+    errorTo(frame, fakeApiError({ reason: "MatchNotFound()" }));
+  };
+  const errorTo = (frame, error) => {
+    connection.receive({ jsonrpc: "2.0", id: frame.id, error });
+  };
+  const installSnapshotAnswer = () => {
+    if (dispatcher) return;
+    const answerSnapshot = (read) => {
+      const id = readJobId(read);
+      const sequence = id === void 0 ? void 0 : sequences.get(id);
+      if (!sequence || id === void 0) {
+        if (fallback) return fallback(read);
+        return answerRead(read, void 0);
+      }
+      const at = position.get(id) ?? 0;
+      answerRead(read, sequence[at]);
+      if (!isTracking(read) || at >= sequence.length - 1 || walking.has(id)) return;
+      walking.add(id);
+      queueMicrotask(() => {
+        for (let next = at + 1; next < sequence.length; next++) {
+          position.set(id, next);
+          connection.receive(jobEvent(sequence[next]));
+        }
+        walking.delete(id);
+      });
+    };
+    dispatcher = answerSnapshot;
+    fallback = connection.autoReply("core.get_jobs", answerSnapshot);
+  };
+  const refuseJobMethodTakeover = (method) => {
+    if (method !== "core.get_jobs" || sequences.size === 0) return;
+    throw new Error(
+      "mock.query('core.get_jobs', \u2026) cannot be registered after a scripted job: jobs answer that method to report their progress, and taking it over makes them complete with the wrong job. Script it before the job, or drive the frames with connection.reply."
+    );
+  };
+  const jobEvent = (job, messageId) => ({
+    jsonrpc: "2.0",
+    method: "collection_update",
+    params: {
+      collection: "core.get_jobs",
+      msg: "changed",
+      id: job.id,
+      fields: messageId ? { ...job, message_ids: [messageId] } : job
+    }
+  });
+  return {
+    call(method, response) {
+      connection.autoReply(String(method), (frame) => {
+        const params = frame.params ?? [];
+        answer(
+          frame,
+          typeof response === "function" ? response(params) : response
+        );
+      });
+    },
+    query(method, rows) {
+      refuseJobMethodTakeover(method);
+      connection.autoReply(method, (frame) => {
+        const [, options] = frame.params ?? [];
+        if (options?.count) return answer(frame, rows.length);
+        if (options?.get) {
+          if (rows.length === 0) {
+            return notFound(frame);
+          }
+          return answer(frame, rows[0]);
+        }
+        answer(frame, rows);
+      });
+    },
+    job(method, updates) {
+      const given = Array.isArray(updates) ? updates : [updates];
+      if (given.length === 0) {
+        throw new Error(
+          `mock.job('${String(method)}', []) has nothing to answer with. A job needs at least one update; one that never reaches a terminal state is how you script a job that hangs.`
+        );
+      }
+      const chosen = given[0].id;
+      if (chosen !== void 0 && sequences.has(chosen)) {
+        throw new Error(
+          `mock.job('${String(method)}', \u2026) was given id ${String(chosen)}, which another scripted job already holds. Ids are how a spec reaches a job through trackJob, so two jobs cannot share one.`
+        );
+      }
+      const conflicting = given.find(
+        (update) => update.id !== void 0 && update.id !== chosen
+      );
+      if (conflicting) {
+        const first = chosen === void 0 ? "none" : String(chosen);
+        throw new Error(
+          `mock.job('${String(method)}', \u2026) was given updates for different ids: ${first} and ${String(conflicting.id)}. They are updates to one job; script the second separately if it is a second job.`
+        );
+      }
+      if (scriptedMethods.has(String(method))) {
+        throw new Error(
+          `mock.job('${String(method)}', \u2026) is already scripted. Starting the method again would correlate onto one job id, which the appliance cannot produce; script one job per method, or reach the other through trackJob with the id this returned.`
+        );
+      }
+      scriptedMethods.add(String(method));
+      const id = chosen ?? allocateId();
+      const sequence = given.map(
+        (update) => fakeJob({ method: String(method), ...update, id })
+      );
+      sequences.set(id, sequence);
+      installSnapshotAnswer();
+      connection.autoReply(String(method), (frame) => {
+        const fresh = started.has(id) || position.has(id) || walking.has(id);
+        const runId = fresh ? allocateId() : id;
+        started.add(runId);
+        if (fresh) sequences.set(runId, sequence.map((job) => ({ ...job, id: runId })));
+        const run = sequences.get(runId) ?? sequence;
+        connection.receive(jobEvent(run[0], frame.id));
+      });
+      return id;
+    },
+    emit(event, change) {
+      connection.receive({
+        jsonrpc: "2.0",
+        method: "collection_update",
+        params: { collection: event, ...change }
+      });
+    }
+  };
+}
+
+// src/testing/create-fake-client.ts
+function withFakeCollaborators(Base, options) {
+  return class FakeClient extends Base {
+    createConnection() {
+      return new FakeConnection({
+        uuid: this.uuid,
+        websocketPath: this.version.websocketPath,
+        opened: options.opened ?? true,
+        strict: options.strict ?? false
+      });
+    }
+    createAuthenticator() {
+      return new FakeAuthenticator(this.connection, this.version);
+    }
+  };
+}
+function createFakeClient(options = {}) {
+  const versionString = options.version ?? SUPPORTED_API_VERSIONS[0];
+  const version = parseApiVersion(versionString);
+  if (!version) {
+    throw new Error(`'${versionString}' is not a version this package parses.`);
+  }
+  const Base = clientClassFor(version);
+  if (!Base) {
+    throw new Error(
+      `No client implementation for '${versionString}'. The real factory would have refused it too.`
+    );
+  }
+  const FakeClient = withFakeCollaborators(Base, options);
+  const client = new FakeClient(
+    // Deliberately not `FakeConnection`'s own placeholder: if the two defaults
+    // matched, a test asserting the connection was told which appliance it
+    // stands for would pass whether or not it was told.
+    "fake-client-uuid",
+    ["fake.local"],
+    version,
+    // Never enabled: the connection this client builds is a fake and opens
+    // nothing, and leaving the gate shut keeps that true if it ever stops
+    // being one.
+    false
+  );
+  if (options.authenticated ?? true) {
+    client.authenticator.authenticated$.next(true);
+  }
+  const fake = client;
+  fake.mock = createMockAnswers(
+    client.connection
+  );
+  return fake;
+}
+
+// src/testing/with-spies.ts
+var API_VERBS = [
+  "call",
+  "callAndGetJobId",
+  "events",
+  "generateToken",
+  "job",
+  "query",
+  "queryCount",
+  "queryOne",
+  "trackJob"
+];
+var CONNECTION_METHODS = ["send"];
+var AUTHENTICATOR_METHODS = [
+  "loginWithApiKey",
+  "loginWithOtp",
+  "loginWithToken",
+  "loginWithUserPass",
+  "logout",
+  "newApiKey"
+];
+function spyOnMethods(target, names, spy) {
+  for (const name of names) {
+    const original = target[name];
+    if (typeof original !== "function") {
+      throw new Error(
+        `withSpies: '${name}' is not a method on ${target.constructor.name}.`
+      );
+    }
+    const method = original;
+    const forwarded = function(...args) {
+      if (this !== void 0) return method.apply(this, args);
+      try {
+        return method.apply(this, args);
+      } catch (cause) {
+        throw new Error(
+          `withSpies: ${name} was called without its object. Either the verb was detached from the client, or the spy factory does not forward \`this\` to the implementation it was given. An arrow function does not; \`vi.fn\` and \`jest.fn\` do.`,
+          { cause }
+        );
+      }
+    };
+    Object.defineProperty(forwarded, "name", { value: name, configurable: true });
+    Object.defineProperty(forwarded, "length", {
+      value: method.length,
+      configurable: true
+    });
+    target[name] = spy(forwarded);
+  }
+}
+function withSpies(client, spy) {
+  spyOnMethods(client.api, API_VERBS, spy);
+  spyOnMethods(client.connection, CONNECTION_METHODS, spy);
+  spyOnMethods(client.authenticator, AUTHENTICATOR_METHODS, spy);
+  return client;
+}
+
+// src/testing/fake-api-version.ts
+function fakeApiVersion(version = SUPPORTED_API_VERSIONS[0], overrides = {}) {
+  const parsed = parseApiVersion(version);
+  if (!parsed) {
+    throw new Error(
+      `fakeApiVersion('${version}'): not a version this package parses. Expected vYY.MINOR.PATCH \u2014 v25.10.0, v27.0.0. For a version the parser rejects, pass one it accepts and override its fields.`
+    );
+  }
+  return { ...parsed, ...present(overrides) };
+}
+
+// src/testing/fake-auth-response.ts
+var ARMS = {
+  ["SUCCESS" /* Success */]: () => ({
+    authenticator: "LEVEL_1",
+    reconnect_token: null
+  }),
+  ["OTP_REQUIRED" /* OtpRequired */]: () => ({ username: "root" }),
+  ["REDIRECT" /* Redirect */]: () => ({ urls: ["https://truenas.local/sso"] }),
+  ["AUTH_ERR" /* AuthErr */]: () => ({}),
+  ["EXPIRED" /* Expired */]: () => ({})
+};
+function fakeAuthResponse(overrides = {}) {
+  const { user_info: userInfoOverrides, ...rest } = overrides;
+  const responseType = rest.response_type ?? "SUCCESS" /* Success */;
+  const succeeded = responseType === "SUCCESS" /* Success */;
+  const userInfo = succeeded || userInfoOverrides ? {
+    username: "root",
+    fullname: "root",
+    builtin: true,
+    email: null,
+    groups: [0],
+    privilege: { roles: { $set: ["FULL_ADMIN" /* FullAdmin */] } },
+    two_factor_auth_configured: false,
+    immutable: true,
+    sid: "S-1-5-21-0-0-0-1000",
+    id: 1,
+    uid: 0,
+    gid: 0,
+    shell: "/usr/bin/bash",
+    home: "/root",
+    locked: false,
+    sudo: true,
+    sudo_nopasswd: true,
+    sudo_commands: [],
+    smb: false,
+    group: {
+      id: 1,
+      bsdgrp_builtin: true,
+      bsdgrp_gid: 0,
+      bsdgrp_group: "root",
+      bsdgrp_sudo: true,
+      bsdgrp_sudo_nopasswd: true,
+      bsdgrp_sudo_commands: [],
+      bsdgrp_smb: false,
+      bsdgrp_users: []
+    },
+    sshpubkey: null,
+    attributes: { preferences: { language: "en", lifetime: 300 } },
+    ...present(userInfoOverrides ?? {})
+  } : void 0;
+  return {
+    response_type: responseType,
+    ...ARMS[responseType](),
+    ...present(rest),
+    ...userInfo ? { user_info: userInfo } : {}
+  };
+}
+
+export { FakeAuthenticator, FakeConnection, UnmockedCallError, createFakeClient, fakeApiError, fakeApiVersion, fakeAuthResponse, fakeJob, withSpies };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map