import { describe, test } from "vitest";

import { HttpdClient } from "../index";

const api = new HttpdClient({

  hostname: "127.0.0.1",

  });

  test("#getById(id)", async () => {

  });

  test("#getActivity(id)", async () => {

  });

  test("#getReadme(id, sha)", async () => {

  });

  test("#getBlob(id, sha, path)", async () => {

  });

  test("#getTree(id, sha)", async () => {

  });

  test("#getTree(id, sha, path)", async () => {

  });

  test("#getAllRemotes(id)", async () => {

  });

  test("#getRemoteByPeer(id, peer)", async () => {

  });

  test("#getAllCommits(id)", async () => {

  });

  // TODO: test since/until properly.

  test("#getAllCommits(id, {parent, since, until, page, perPage})", async () => {

      parent: aliceMainHead,

      since: 1679065819581,

      until: 1679065819590,

  });

  test("#getCommitBySha(id, sha)", async () => {

  });

  test.todo("#getDiff(id, revisionBase, revisionOid)");

import {

  expect,

  seedRemote,

  test,

} from "@tests/support/fixtures.js";

  }

  await context.grantPermissions(["clipboard-read", "clipboard-write"]);

  // Reset system clipboard to a known state.

  await page.evaluate<string>("navigator.clipboard.writeText('')");

    const clipboardContent = await page.evaluate<string>(

      "navigator.clipboard.readText()",

    );

  }

  // `rad clone` URL.

  {

    await page.getByText("Clone").click();

    await page

      .locator(".clone-url-wrapper > span")

      .first()

      .locator(".clipboard")

      .click();

  }

  // `git clone` URL.

    await page.getByText("Clone").click();

    await page

      .locator(

          .replace("rad:", "")

          .substring(0, 10)}`,

      )

      .locator(".clipboard")

      .click();

    await expectClipboard(

        "rad:",

        "",

      )}.git source-browsing`,

  aliceRemote,

  appConfigWithFixture,

  expect,

  test,

} from "@tests/support/fixtures.js";

import {

  await expect(page).toHaveURL("/#/");

  await page.locator("text=source-browsing").click();

  await expectBackAndForwardNavigationWorks("/#/", page);

  await expectUrlPersistsReload(page);

test("navigation between seed and project pages", async ({ page }) => {

  await page.goto("/#/seeds/radicle.local");

  await project.click();

  await expectBackAndForwardNavigationWorks("/#/seeds/radicle.local", page);

  await expectUrlPersistsReload(page);

  test("navigation between commit history and single commit", async ({

    page,

  }) => {

    await page.goto(projectHistoryURL);

    await expect(page).toHaveURL(

    );

    await expectBackAndForwardNavigationWorks(projectHistoryURL, page);

  });

  test("navigate between tree and commit history", async ({ page }) => {

    await page.goto(projectTreeURL);

    await expect(page).toHaveURL(projectTreeURL);

    await expectBackAndForwardNavigationWorks(projectTreeURL, page);

    await expectUrlPersistsReload(page);

  });

  test("navigate project paths", async ({ page }) => {

    await page.goto(projectTreeURL);

    await expect(page).toHaveURL(projectTreeURL);

  });

  test("navigate project paths with a selected peer", async ({ page }) => {

      8,

    )}`;

  aliceRemote,

  appConfigWithFixture,

  expect,

  test,

} from "@tests/support/fixtures.js";

import {

  await expect(page).toHaveURL("/");

  await page.locator("text=source-browsing").click();

  await expectBackAndForwardNavigationWorks("/", page);

  await expectUrlPersistsReload(page);

test("navigation between seed and project pages", async ({ page }) => {

  await page.goto("/seeds/radicle.local");

  await project.click();

  await expectBackAndForwardNavigationWorks("/seeds/radicle.local", page);

  await expectUrlPersistsReload(page);

  test("navigation between commit history and single commit", async ({

    page,

  }) => {

    await page.goto(projectHistoryURL);

    await expect(page).toHaveURL(

    );

    await expectBackAndForwardNavigationWorks(projectHistoryURL, page);

  });

  test("navigate between tree and commit history", async ({ page }) => {

    await page.goto(projectTreeURL);

    await expect(page).toHaveURL(projectTreeURL);

    await expect(page).toHaveURL(

    );

    await expectBackAndForwardNavigationWorks(projectTreeURL, page);

  });

  test("navigate project paths", async ({ page }) => {

    await page.goto(projectTreeURL);

    await expect(page).toHaveURL(projectTreeURL);

  });

  test("navigate project paths with a selected peer", async ({ page }) => {

      8,

    )}`;

import {

  aliceMainHead,

  aliceRemote,

  bobRemote,

  expect,

  test,

} from "@tests/support/fixtures.js";

import { expectUrlPersistsReload } from "@tests/support/router";

}

test("navigate to project", async ({ page }) => {

  // Header.

  {

    const name = page.locator("text=source-browsing");

    const description = page.locator(

      "text=Git repository for source browsing tests",

    );

    await expect(page.getByTitle("Current branch")).toContainText(

      `main ${aliceMainHead.substring(0, 7)}`,

    );

  }

  // Navigate to the project README.md by default.

});

test("show source tree at specific revision", async ({ page }) => {

  await page

    .locator(".teaser", { hasText: "335dd6d" })

});

test("source file highlighting", async ({ page }) => {

  await page.getByText("src/").click();

  await page.getByText("true.c").click();

});

test("navigate line numbers", async ({ page }) => {

  await page.locator('text="Plain"').click();

  await page.locator('[href="#L5"]').click();

  await expect(page.locator("#L5")).toHaveClass("line highlight");

  await expectUrlPersistsReload(page);

  await expect(page.locator("#L5")).toHaveClass("line highlight");

  await page.locator('[href="#L30"]').click();

  await expect(page.locator("#L5")).not.toHaveClass("line highlight");

  await expect(page.locator("#L30")).toHaveClass("line highlight");

});

test("navigate deep file hierarchies", async ({ page }) => {

  const sourceTree = page.locator(".source-tree");

});

test("files with special characters in the filename", async ({ page }) => {

  const sourceTree = page.locator(".source-tree");

  await sourceTree.getByText("special/").click();

});

test("binary files", async ({ page }) => {

  await page.getByText("bin/").click();

  await page.getByText("true").click();

});

test("hidden files", async ({ page }) => {

  await page.getByText(".hidden").click();

});

test("markdown files", async ({ page }) => {

  await expect(

    page.locator("text=This is intended as a quick reference and showcase."),

  {

    await page.getByRole("link", { name: "YouTube Videos" }).click();

    await expect(page).toHaveURL(

    );

  }

});

test("clone modal", async ({ page }) => {

  await page.getByText("Clone").click();

  await expect(

  ).toBeVisible();

});

test("peer and branch switching", async ({ page }) => {

  // Alice's peer.

  {

    // Default `main` branch.

    {

      await expect(page.getByTitle("Current branch")).toContainText(

      );

    }

    // Feature branch with a slash in the name.

      await page.locator("text=feature/branch").click();

      await expect(page.getByTitle("Current branch")).toContainText(

      );

    }

    // Branch without a history or files in it.

    await expect(page.getByTitle("Change peer")).not.toContainText("bob");

    await expect(page.getByTitle("Current branch")).toContainText(

    );

    await expect(page.locator("text=Git test repository")).toBeVisible();

  }

    // Default `main` branch.

    {

      await expect(page.getByTitle("Current branch")).toContainText(

      );

    }

  }

});

test("only one modal can be open at a time", async ({ page }) => {

  await page.getByTitle("Change peer").click();

  await page.locator(`text=${aliceRemote}`).click();

test.describe("browser error handling", () => {

  test("error appears when folder can't be loaded", async ({ page }) => {

    await page.route(

      route => route.fulfill({ status: 500 }),

    );

    const sourceTree = page.locator(".source-tree");

    await expect(

      page.locator("text=Not able to expand directory"),

  });

  test("error appears when file can't be loaded", async ({ page }) => {

    await page.route(

      route => route.fulfill({ status: 500 }),

    );

    await page.locator("text=.hidden").click();

    await expect(page.locator("text=Not able to load file")).toBeVisible();

  });

  test("error appears when README can't be loaded", async ({ page }) => {

    );

    await expect(

      page.locator("text=The README could not be loaded."),

    ).toBeVisible();

  });

  test("error appears when navigating to missing file", async ({ page }) => {

    await page.route(

      route => route.fulfill({ status: 500 }),

    );

    await expect(page.locator("text=Not able to load file")).toBeVisible();

  });

import {

  test,

  expect,

  bobRemote,

  bobHead,

} from "@tests/support/fixtures.js";

  8,

)}/commits/${bobHead}`;

test("navigation from commit list", async ({ page }) => {

  await page.getByTitle("Change peer").click();

  await page.locator(`text=${bobRemote}`).click();

  await page.locator("text=Update readme").click();

  await expect(page).toHaveURL(modifiedFileFixture);

  {

    const header = page.locator(".commit .header");

    await expect(header.locator("text=Update readme")).toBeVisible();

  }

  // Diff header.

test("created file", async ({ page }) => {

  await page.goto(

  );

  await expect(

  ).toBeVisible();

});

test("deleted file", async ({ page }) => {

  await page.goto(

  );

  await expect(

    page.locator("text=1 file deleted with 0 insertions and 1 deletion"),

test("navigation to source tree at specific revision", async ({ page }) => {

  await page.goto(

  );

  // Go to source tree at this revision.

    page.locator("text=Add a deeply nested directory tree"),

  ).toBeVisible();

  await expect(page).toHaveURL(

  );

  await expect(page.getByTitle("Current branch")).toContainText(

    "0801aceeab500033f8d608778218657bd626ef73",

import {

  test,

  expect,

  bobRemote,

  aliceRemote,

  gitOptions,

} from "@tests/support/fixtures.js";

test("peer and branch switching", async ({ page }) => {

  // Alice's peer.

  {

    );

    await expect(page.getByText("Thursday, November 17, 2022")).toBeVisible();

    const latestCommit = page.locator(".teaser").first();

    const earliestCommit = page.locator(".teaser").last();

    await expect(earliestCommit).toContainText(

    await page.locator("text=feature/branch").click();

    await expect(page.getByTitle("Current branch")).toContainText(

    );

    await expect(page.getByText("Thursday, November 17, 2022")).toBeVisible();

    await page.getByTitle("Change branch").click();

    await page.locator("text=orphaned-branch").click();

      )} `,

    );

    await expect(page.locator(".group").first().locator(".teaser")).toHaveCount(

      1,

    );

    const latestCommit = page.locator(".teaser").first();

    await expect(latestCommit).toContainText("Update readme");

    const earliestCommit = page.locator(".teaser").last();

    await expect(earliestCommit).toContainText(

    };

  });

  await page.getByTitle("Change peer").click();

  await page.locator(`text=${bobRemote}`).click();

  );

  const latestCommit = page.locator(".teaser").first();

  await expect(latestCommit).toContainText("Bob Belcher committed now");

  const earliestCommit = page.locator(".teaser").last();

  await expect(earliestCommit).toContainText(

    "Alice Liddell committed last month",

  });

  await alice.startHttpd(8090);

  await alice.startNode();

  await page.goto(`/seeds/127.0.0.1:8090/${rid}`);

  await page.locator('role=link[name="1 commit"]').click();

  await expect(page).toHaveURL(`/seeds/127.0.0.1:8090/${rid}/history`);

import {

  test,

  expect,

} from "@tests/support/fixtures.js";

test("navigate to existing project", async ({ page }) => {

  await page.goto("/");

  const searchInput = page.getByPlaceholder(searchPlaceholder);

  await searchInput.click();

  await searchInput.press("Enter");

});

test("navigate to a project that does not exist", async ({ page }) => {

import {

  aliceMainHead,

  expect,

  seedRemote,

  test,

} from "@tests/support/fixtures.js";

test("seed projects", async ({ page }) => {

  await page.goto("/seeds/radicle.local");

  // Project metadata.

  {

  // Show project ID on hover.

  {

    await project.hover();

  }

});

test("default settings", async ({ page }) => {

  await page.goto(sourceBrowsingFixture);

/* eslint-disable @typescript-eslint/naming-convention */

import type * as Stream from "node:stream";

import * as Fs from "node:fs/promises";

import * as FsSync from "node:fs";

import * as Path from "node:path";

import { test as base, expect } from "@playwright/test";

import * as Process from "./process.js";

import * as logLabel from "@tests/support/logLabel.js";

export { expect };

const filename = fileURLToPath(import.meta.url);

export const supportDir = dirname(filename);

export const tmpDir = Path.resolve(supportDir, "..", "./tmp");

export const test = base.extend<{

  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type

    outputLog: FsSync.createWriteStream(Path.resolve(Path.join(tmpDir, "log"))),

  });

  const palm = await peerManager.startPeer({ name: "palm" });

}

  const projectName = "source-browsing";

  const sourceBrowsingDir = Path.join(tmpDir, "repos", projectName);

  await Fs.mkdir(sourceBrowsingDir, { recursive: true });

    "-C",

    sourceBrowsingDir,

  ]);

  const alice = await peerManager.startPeer({

    name: "alice",

    gitOptions: gitOptions["alice"],

    gitOptions: gitOptions["bob"],

  });

  const bobProjectPath = Path.join(bob.checkoutPath, "source-browsing");

  await alice.startNode();

  await bob.startNode();

  await alice.connect(palm);

  );

}

export const aliceRemote =

  "did:key:z6MkqGC3nWZhYieEVTVDKW5v588CiGfsDSmRVG9ZwwWTvLSK";

export const bobRemote =

  "did:key:z6Mkg49NtQR2LyYRDCQFK4w1VVHqhypZSSRo7HsyuN7SV7v5";

export const seedPort = 8080;

export const seedRemote = "z6MktULudTtAsAhRegYPiZ6631RV3viv12qd4GQF8z1xB22S";

export const gitOptions = {

import type { FullConfig } from "@playwright/test";

import * as Fs from "node:fs/promises";

import * as Path from "node:path";

import * as readline from "node:readline/promises";

import { execa } from "execa";

import {

  startPalmHttpd,

  tmpDir,

const workspacePaths = [Path.join(tmpDir, "peers"), Path.join(tmpDir, "repos")];

    }

    await removeWorkspace();

    console.log("Running tests");

  } else {

    await startPalmHttpd();

    outputLog = createParams.outputLog;

  } else {

    outputLogFile = await Fs.open(

      "a",

    );

    outputLog = outputLogFile.createWriteStream();

  const nodes: RadiclePeer[] = [];

  return {

    async startPeer(params) {

      const peer = await RadiclePeer.create({

        dataPath: createParams.dataDir,

    });

  }

    await waitOn({

      resources: [`tcp:127.0.0.1:${port}`],

      args.push("--tracking-policy", params.trackingPolicy);

    }

    void this.spawn("radicle-node", args);

    await waitOn({

    );

  }

  public async waitForRoutes(rid: string, ...nodes: string[]) {

    let remaining = nodes;

    };

    const childProcess = Process.spawn(cmd, args, opts);

    return childProcess;

  }

import * as sinon from "sinon";

import { describe, expect, test } from "vitest";

    const e = mutexExecutor.create();

    const abortListener = sinon.spy();

      abort.addEventListener("abort", abortListener);

      await sleep(10);

      return "first";

    });

    expect(abortListener.called).toBe(false);

    // eslint-disable-next-line @typescript-eslint/no-empty-function

    expect(abortListener.called).toBe(true);

  });

    const nextOutput = w.output.firstToPromise();

    expect(await nextOutput).toEqual(3);

  });

import type { Page } from "@playwright/test";

async function goToSection(section: string, page: Page) {

    waitUntil: "networkidle",

  });

  await page.locator(`[href="${section}"]`).click();

    test.use({ viewport: { width: 1280, height: 450 } });

    test("table of contents", async ({ page }) => {

      await page.goto(

        {

          waitUntil: "networkidle",

        },

  });

  test.describe(async () => {

    test("footnotes", async ({ page }) => {

    });

  });

    });

  });

});

import {

  test,

  expect,

  aliceRemote,

} from "@tests/support/fixtures.js";

test("source tree page", async ({ page }) => {

  await expect(page).toHaveScreenshot();

});

  });

  await page.goto(

    {

      waitUntil: "networkidle",

    },

  });

  await page.goto(

      8,

    )}/commits/d6318f7f3d9c15b8ac6dd52267c53220d00f0982`,

  );

  await expect(page.locator("text=subconscious.txt added")).toBeVisible();

  await expect(page).toHaveScreenshot({ fullPage: true });

});