@tui-sandbox/library 11.11.2 → 12.1.0

package/src/server/cypress-support/contents.ts

@@ -1,245 +0,0 @@
-import { format, resolveConfig } from "prettier"
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url)
-
-export async function createCypressSupportFileContents(): Promise<string> {
-  // this is the interface of tui-sandbox as far as cypress in the user's
-  // application is concerned
-  let text = `/// <reference types="cypress" />
-//
-// This file is autogenerated by tui-sandbox. Do not edit it directly.
-//
-import type {
-  BrowserTerminalSettings,
-  GenericNeovimBrowserApi,
-  GenericTerminalBrowserApi,
-} from "@tui-sandbox/library/dist/src/browser/neovim-client"
-import type {
-  AllKeys,
-  BlockingShellCommandOutput,
-  RunExCommandOutput,
-  RunLuaCodeOutput,
-  StartNeovimGenericArguments,
-  TestDirectory,
-} from "@tui-sandbox/library/dist/src/server/types"
-import type { MyNeovimConfigModification } from "@tui-sandbox/library/src/client/MyNeovimConfigModification"
-import type {
-  ExCommandClientInput,
-  LuaCodeClientInput,
-  PollLuaCodeClientInput,
-  RunLuaFileClientInput,
-} from "@tui-sandbox/library/src/server/applications/neovim/neovimRouter"
-import type { StartTerminalGenericArguments } from "@tui-sandbox/library/src/server/applications/terminal/TerminalTestApplication"
-import type { BlockingCommandClientInput } from "@tui-sandbox/library/src/server/blockingCommandInputSchema"
-import type { OverrideProperties } from "type-fest"
-import type { MyNeovimAppName, MyTestDirectory, MyTestDirectoryFile } from "../../MyTestDirectory"
-
-export type TerminalTestApplicationContext = {
-  /** Types text into the terminal, making the terminal application receive the
-   * keystrokes as input. Requires the application to be running. */
-  typeIntoTerminal(text: string, options?: Partial<Cypress.TypeOptions>): void
-
-  /** Runs a shell command in a blocking manner, waiting for the command to
-   * finish before returning. Requires the terminal to be running. */
-  runBlockingShellCommand(input: MyBlockingCommandClientInput): Cypress.Chainable<BlockingShellCommandOutput>
-
-  /** The test directory, providing type-safe access to its file and directory structure */
-  dir: TestDirectory<MyTestDirectory>
-}
-
-/** The api that can be used in tests after a Neovim instance has been started. */
-export type NeovimContext = {
-  /** Types text into the terminal, making the terminal application receive
-   * the keystrokes as input. Requires neovim to be running. */
-  typeIntoTerminal(text: string, options?: Partial<Cypress.TypeOptions>): void
-
-  /** Runs a shell command in a blocking manner, waiting for the command to
-   * finish before returning. Requires neovim to be running. */
-  runBlockingShellCommand(input: MyBlockingCommandClientInput): Cypress.Chainable<BlockingShellCommandOutput>
-
-  /** Runs a shell command in a blocking manner, waiting for the command to
-   * finish before returning. Requires neovim to be running. */
-  runLuaCode(input: LuaCodeClientInput): Cypress.Chainable<RunLuaCodeOutput>
-
-  /** Runs a Lua file in neovim after it has started. Can be used to keep
-   * complex lua logic in a separate file, still being able to run it after
-   * startup. This way additional tools like lua LSP servers, linters, etc. can
-   * be used to ensure the code is correct.
-   */
-  doFile(input: MyRunLuaFileClientInput): Cypress.Chainable<RunExCommandOutput>
-
-  /**
-   * Like runLuaCode, but waits until the given code (maybe using lua's return
-   * assert()) does not raise an error, and returns the first successful result.
-   *
-   * Useful for waiting until Neovim's internal state has changed in a way that
-   * means the test can continue executing. This can avoid timing issues that are
-   * otherwise hard to catch.
-   */
-  waitForLuaCode(input: PollLuaCodeClientInput): Cypress.Chainable<RunLuaCodeOutput>
-
-  /** Run an ex command in neovim.
-   * @example "echo expand('%:.')" current file, relative to the cwd
-   */
-  runExCommand(input: ExCommandClientInput): Cypress.Chainable<RunExCommandOutput>
-
-  /** The test directory, providing type-safe access to its file and directory structure */
-  dir: TestDirectory<MyTestDirectory>
-}
-
-/** Arguments for starting the neovim server. They are built based on your test
- * environment in a type safe manner. */
-export type MyStartNeovimServerArguments = OverrideProperties<
-  StartNeovimGenericArguments,
-  {
-    NVIM_APPNAME?: MyNeovimAppName
-    filename?: MyTestDirectoryFile | { openInVerticalSplits: MyTestDirectoryFile[] }
-    startupScriptModifications?: Array<MyNeovimConfigModification<MyTestDirectoryFile>>
-  }
->
-
-export type MyRunLuaFileClientInput = OverrideProperties<RunLuaFileClientInput, { luaFile: MyTestDirectoryFile }>
-
-Cypress.Commands.add("startNeovim", (startArguments?: MyStartNeovimServerArguments) => {
-  cy.window().then(async win => {
-    const underlyingNeovim: GenericNeovimBrowserApi = await win.startNeovim(
-      startArguments as StartNeovimGenericArguments
-    )
-    testNeovim = underlyingNeovim
-
-    // wrap everything so that Cypress can await all the commands
-    Cypress.Commands.addAll({
-      nvim_runBlockingShellCommand: underlyingNeovim.runBlockingShellCommand,
-      nvim_runExCommand: underlyingNeovim.runExCommand,
-      nvim_runLuaCode: underlyingNeovim.runLuaCode,
-      nvim_waitForLuaCode: underlyingNeovim.waitForLuaCode,
-      nvim_doFile: underlyingNeovim.doFile,
-    })
-
-    const api: NeovimContext = {
-      runBlockingShellCommand(input) {
-        return cy.nvim_runBlockingShellCommand(input)
-      },
-      runExCommand(input) {
-        return cy.nvim_runExCommand(input)
-      },
-      runLuaCode(input) {
-        return cy.nvim_runLuaCode(input)
-      },
-      doFile(input) {
-        return cy.nvim_doFile(input)
-      },
-      waitForLuaCode(input) {
-        return cy.nvim_waitForLuaCode(input)
-      },
-      typeIntoTerminal(text, options) {
-        cy.typeIntoTerminal(text, options)
-      },
-      dir: underlyingNeovim.dir as TestDirectory<MyTestDirectory>,
-    }
-
-    return api
-  })
-})
-
-Cypress.Commands.add("nvim_isRunning", () => {
-  return cy.window().then(async _ => {
-    return !!testNeovim
-  })
-})
-
-Cypress.Commands.add("startTerminalApplication", (args: StartTerminalGenericArguments & BrowserTerminalSettings) => {
-  cy.window().then(async win => {
-    const terminal: GenericTerminalBrowserApi = await win.startTerminalApplication({
-      serverSettings: {
-        commandToRun: args.commandToRun,
-        additionalEnvironmentVariables: args.additionalEnvironmentVariables,
-      } satisfies AllKeys<StartTerminalGenericArguments>,
-      browserSettings: {
-        configureTerminal: args.configureTerminal,
-      } satisfies AllKeys<BrowserTerminalSettings>,
-    })
-
-    Cypress.Commands.addAll({
-      terminal_runBlockingShellCommand: terminal.runBlockingShellCommand,
-    })
-
-    const api: TerminalTestApplicationContext = {
-      dir: terminal.dir as TestDirectory<MyTestDirectory>,
-      runBlockingShellCommand(input) {
-        return cy.terminal_runBlockingShellCommand(input)
-      },
-      typeIntoTerminal(text, options) {
-        cy.typeIntoTerminal(text, options)
-      },
-    }
-
-    return api
-  })
-})
-
-Cypress.Commands.add("typeIntoTerminal", (text: string, options?: Partial<Cypress.TypeOptions>) => {
-  // the syntax for keys is described here:
-  // https://docs.cypress.io/api/commands/type
-  cy.get("textarea").focus().type(text, options)
-})
-
-let testNeovim: GenericNeovimBrowserApi | undefined
-
-before(function () {
-  // disable Cypress's default behavior of logging all XMLHttpRequests and
-  // fetches to the Command Log
-  // https://gist.github.com/simenbrekken/3d2248f9e50c1143bf9dbe02e67f5399?permalink_comment_id=4615046#gistcomment-4615046
-  cy.intercept({ resourceType: /xhr|fetch/ }, { log: false })
-})
-
-export type MyBlockingCommandClientInput = OverrideProperties<
-  BlockingCommandClientInput,
-  { cwdRelative?: MyTestDirectoryFile | undefined }
->
-
-declare global {
-  namespace Cypress {
-    interface Chainable {
-      startNeovim(args?: MyStartNeovimServerArguments): Chainable<NeovimContext>
-      startTerminalApplication(
-        args: StartTerminalGenericArguments & BrowserTerminalSettings
-      ): Chainable<TerminalTestApplicationContext>
-
-      /** Types text into the terminal, making the terminal application receive
-       * the keystrokes as input. Requires neovim to be running. */
-      typeIntoTerminal(text: string, options?: Partial<Cypress.TypeOptions>): Chainable<void>
-
-      /** Runs a shell command in a blocking manner, waiting for the command to
-       * finish before returning. Requires neovim to be running. */
-      nvim_runBlockingShellCommand(input: MyBlockingCommandClientInput): Chainable<BlockingShellCommandOutput>
-
-      nvim_runLuaCode(input: LuaCodeClientInput): Chainable<RunLuaCodeOutput>
-      nvim_doFile(input: MyRunLuaFileClientInput): Chainable<RunExCommandOutput>
-      nvim_waitForLuaCode(input: PollLuaCodeClientInput): Chainable<RunLuaCodeOutput>
-
-      /** Run an ex command in neovim.
-       * @example "echo expand('%:.')" current file, relative to the cwd
-       */
-      nvim_runExCommand(input: ExCommandClientInput): Chainable<RunExCommandOutput>
-
-      /** Returns true if neovim is running. Useful to conditionally run
-       * afterEach actions based on whether it's running. */
-      nvim_isRunning(): Chainable<boolean>
-
-      terminal_runBlockingShellCommand(input: MyBlockingCommandClientInput): Chainable<BlockingShellCommandOutput>
-    }
-  }
-}
-
-afterEach(async () => {
-  testNeovim = undefined
-})
-`
-
-  const options = await resolveConfig(__filename)
-  text = await format(text, { ...options, parser: "typescript" })
-
-  return text
-}

package/src/server/cypress-support/createCypressSupportFile.test.ts

@@ -1,69 +0,0 @@
-import { readFileSync, writeFileSync } from "fs"
-import { mkdir, stat } from "fs/promises"
-import { describe, expect, it, vi } from "vitest"
-import { createCypressSupportFileContents } from "./contents.js"
-import type { CreateCypressSupportFileResult } from "./createCypressSupportFile.js"
-import { createCypressSupportFile } from "./createCypressSupportFile.js"
-
-vi.mock("fs")
-vi.mock("fs/promises")
-vi.mock("./contents.ts")
-
-const mocked = {
-  readFileSync: vi.mocked(readFileSync),
-  writeFileSync: vi.mocked(writeFileSync),
-  createCypressSupportFileContents: vi.mocked(createCypressSupportFileContents),
-  mkdir: vi.mocked(mkdir),
-  stat: vi.mocked(stat),
-}
-
-describe("createCypressSupportFileContents", () => {
-  it("should update the file if the schema has changed", async () => {
-    mocked.readFileSync.mockImplementationOnce(() => "")
-    mocked.writeFileSync.mockImplementationOnce(() => {
-      //
-    })
-
-    const result = await createCypressSupportFile({
-      cypressSupportDirectoryPath: "cypress/support",
-      supportFileName: "tui-sandbox.ts",
-    })
-
-    expect(result).toBe("updated" satisfies CreateCypressSupportFileResult)
-  })
-
-  it("should not update the file if the schema has not changed", async () => {
-    mocked.readFileSync.mockImplementationOnce(() => "contents")
-    mocked.writeFileSync.mockImplementationOnce(() => {
-      //
-    })
-    mocked.createCypressSupportFileContents.mockImplementationOnce(async () => "contents")
-
-    const result = await createCypressSupportFile({
-      cypressSupportDirectoryPath: "cypress/support",
-      supportFileName: "tui-sandbox.ts",
-    })
-
-    expect(result).toBe("did-nothing" satisfies CreateCypressSupportFileResult)
-  })
-
-  it("should create the config-modifications directory if it does not exist", async () => {
-    // This directory is required to exist so that a type safe schema of the
-    // neovimArguments can be built and used.
-    mocked.readFileSync.mockImplementationOnce(() => "")
-    mocked.writeFileSync.mockImplementationOnce(() => {
-      //
-    })
-    mocked.createCypressSupportFileContents.mockImplementationOnce(async () => "contents")
-    mocked.stat.mockRejectedValueOnce(new Error("ENOENT"))
-
-    const result = await createCypressSupportFile({
-      cypressSupportDirectoryPath: "cypress/support",
-      supportFileName: "tui-sandbox.ts",
-    })
-
-    expect(result).toBe("updated" satisfies CreateCypressSupportFileResult)
-    expect(mocked.mkdir).toHaveBeenCalledWith("cypress/support/config-modifications", { recursive: true })
-    expect(mocked.mkdir).toHaveBeenCalledTimes(1)
-  })
-})

package/src/server/cypress-support/createCypressSupportFile.ts

@@ -1,56 +0,0 @@
-import { readFileSync, writeFileSync } from "fs"
-import { mkdir, stat } from "fs/promises"
-import path from "path"
-import { debuglog } from "util"
-import { createCypressSupportFileContents } from "./contents.js"
-
-const log = debuglog("tui-sandbox.dirtree")
-
-export type CreateCypressSupportFileArgs = {
-  cypressSupportDirectoryPath: string
-  supportFileName: string
-}
-
-export type CreateCypressSupportFileResult = "updated" | "did-nothing"
-
-/**
- * This is the interface of tui-sandbox as far as cypress in the user's
- * application is concerned. It needs to be checked for changes once per
- * tui-sandbox version.
- */
-export async function createCypressSupportFile({
-  cypressSupportDirectoryPath,
-  supportFileName,
-}: CreateCypressSupportFileArgs): Promise<CreateCypressSupportFileResult> {
-  // create config-modifications directory if it doesn't exist
-  const configModificationsDirectoryPath = path.join(cypressSupportDirectoryPath, "config-modifications")
-  try {
-    await stat(configModificationsDirectoryPath)
-  } catch {
-    console.info(
-      `Creating config-modifications directory at ${configModificationsDirectoryPath}. You can put Neovim startup scripts into this directory, and load them when starting your Neovim test.`
-    )
-    await mkdir(configModificationsDirectoryPath, { recursive: true })
-  }
-
-  const text = await createCypressSupportFileContents()
-
-  let oldSchema = ""
-  const outputFilePath = path.join(cypressSupportDirectoryPath, supportFileName)
-  try {
-    oldSchema = readFileSync(outputFilePath, "utf-8")
-  } catch {
-    console.warn(`No existing cypress support file found at ${outputFilePath}`)
-  }
-
-  if (oldSchema !== text) {
-    // it's important to not write the file if the schema hasn't changed
-    // because file watchers will trigger on file changes and we don't want to
-    // trigger a build if the schema hasn't changed
-    log(`🪛 Writing cypress support file to ${outputFilePath}`)
-    writeFileSync(outputFilePath, text)
-    return "updated"
-  } else {
-    return "did-nothing"
-  }
-}