@goodfellow-cms/github 0.1.0 → 0.3.0

package/dist/testing.d.ts

@@ -4,8 +4,56 @@ import { FakeRepo } from "@goodfellow-cms/core/testing";
 export interface FakeGitHubUser {
   login: string;
   name?: string;
+  /** GitHub's number for the account. Defaults to one worked out from the login. */
+  id?: number;
   /** Whether the user may publish. Defaults to true. */
   push?: boolean;
+  /** Whether the token may write `.github/workflows/`. Defaults to true. */
+  workflow?: boolean;
+  /** Whether the token may change GitHub Pages settings. Defaults to true. */
+  pages?: boolean;
+  /** Whether the user is an owner (admin) of the site's repository. Defaults to false. */
+  admin?: boolean;
+  /** Whether the token has GitHub's Administration permission, which changing collaborators needs. Defaults to false. */
+  administration?: boolean;
+  /** Whether the token may read GitHub Actions. Defaults to true. */
+  actions?: boolean;
+  /** Whether the token may run workflows, as owner tokens can. Defaults to the `administration` setting. */
+  actionsWrite?: boolean;
+}
+/** A GitHub Actions workflow run, with its jobs and their steps. */
+export interface FakeRun {
+  id: number;
+  sha: string;
+  /** What started it: `push` (the default), `schedule` or `workflow_dispatch`. */
+  event?: string;
+  /** For `workflow_dispatch`, the inputs it was given. */
+  inputs?: Record<string, string>;
+  createdAt?: string;
+  status: "queued" | "in_progress" | "completed";
+  conclusion: "success" | "failure" | "startup_failure" | "cancelled" | null;
+  jobs: Array<{
+    name: string;
+    conclusion: string | null;
+    steps: Array<{
+      name: string;
+      conclusion: string | null;
+    }>;
+  }>;
+}
+/** A repository invitation that hasn't been accepted yet. */
+export interface FakeInvitation {
+  id: number;
+  login: string;
+  permission: "admin" | "write";
+}
+/** The site's GitHub Pages settings, as `GET /repos/{repo}/pages` reports them. */
+export interface FakePages {
+  html_url: string;
+  cname: string | null;
+  https_enforced: boolean;
+  /** The certificate's state, such as `new` while it's being issued and `approved` once it's ready. */
+  certificate?: string;
 }
 export interface FakeDeploymentStatus {
   state: "queued" | "in_progress" | "success" | "failure" | "error" | "inactive";
@@ -22,6 +70,63 @@ export interface FakeGitHubOptions {
    * reports success after being checked this many times. Off by default.
    */
   deployAfterChecks?: number;
+  /** Organizations the users belong to, which new repositories can be created in. */
+  orgs?: string[];
+  /** The default branch of repositories created through the API, as an account's settings choose. Defaults to `main`. */
+  newRepoBranch?: string;
+  /** Whether private repositories can have GitHub Pages and rules, as on paid plans. Off by default, as on the free plan. */
+  paidPlan?: boolean;
+  /** Publishes the site with GitHub Pages, at `https://<owner>.github.io/<name>/`. Off by default. */
+  pages?: boolean;
+  /** Domains another GitHub Pages site already uses. */
+  takenDomains?: string[];
+  /** Other GitHub accounts that exist, which can be invited. Every token's user exists too. */
+  accounts?: string[];
+  /** GitHub Apps, which the sign-in worker signs people in with. */
+  apps?: FakeGitHubApp[];
+}
+/** A GitHub App, as the sign-in worker uses one: its JWTs, installations, OAuth sign-in and tokens. */
+export interface FakeGitHubApp {
+  id: string;
+  slug: string;
+  clientId: string;
+  clientSecret: string;
+  /** The app's public key, which its JWTs are checked against. Without it, any JWT naming the app is accepted. */
+  publicKey?: CryptoKey;
+  /** The most its tokens may be given, as GitHub names permissions. */
+  permissions: Record<string, "read" | "write">;
+  installations: FakeInstallation[];
+}
+/** An app installed on an account, for some or all of its repositories. */
+export interface FakeInstallation {
+  id: number;
+  /** The account it's installed on. */
+  account: string;
+  accountType?: "User" | "Organization";
+  /** The repositories it can use, as `owner/name`, or `all` of the account's. */
+  repositories: string[] | "all";
+}
+/** A token an app's sign-in made: a person's own, or an installation's for some repositories. */
+export interface FakeIssuedToken {
+  token: string;
+  kind: "user" | "installation";
+  app: string;
+  login?: string;
+  repositories?: string[];
+  permissions: Record<string, string>;
+  revoked?: boolean;
+}
+/** A repository created through the fake's API, as the setup page creates them. */
+export interface FakeCreatedRepo {
+  id: number;
+  fullName: string;
+  private: boolean;
+  description?: string;
+  repo: FakeRepo;
+  pages?: {
+    build_type: string;
+  };
+  rulesets: unknown[];
 }
 interface Deployment {
   id: number;
@@ -31,11 +136,38 @@ interface Deployment {
 }
 export declare function fakeGitHub(options: FakeGitHubOptions): {
   repo: FakeRepo;
+  /** How many GraphQL requests read files, as `readFiles()` makes. */
+  readonly graphqlReads: number;
+  /** Tokens apps' sign-ins made, in order. */
+  issued: FakeIssuedToken[];
+  /** Who commits made through the REST API name as their author, by commit. */
+  commitAuthors: Map<string, {
+    name?: string;
+    email?: string;
+  }>;
+  authorize: (login: string, clientId: string) => string;
+  install: (slug: string, login: string, repositories: string[], account?: string) => {
+    code: string;
+    installation: number;
+  };
+  /** Repositories created through the API, by `owner/name`. */
+  created: Map<string, FakeCreatedRepo>;
+  /** The site's GitHub Pages settings, which tests can change, such as to issue the certificate. */
+  pages: {
+    current?: FakePages;
+  };
+  /** The repository's collaborators, by login, and invitations waiting to be accepted. */
+  collaborators: Map<string, "admin" | "push" | "read">;
+  invitations: FakeInvitation[];
+  accept: (login: string) => void;
   deployments: Deployment[];
+  /** GitHub Actions workflow runs, which tests add with `failBuild()`. */
+  runs: FakeRun[];
+  failBuild: (sha: string, step?: string, job?: string) => FakeRun;
   /** Every request received, for checking what the backend sent. */
   requests: Request[];
   /** Simulates someone else publishing. */
-  commit: (changes: FileChange[], message: string, expectedHead?: string) => string;
+  commit: (changes: FileChange[], message: string, expectedHead?: string, author?: string, branch?: string) => string;
   handle: (request: Request) => Promise<Response>;
   /** A `fetch` that answers from the fake instead of the network. */
   fetch: typeof fetch;