Skip to content

fix: tool-cache does not work #533

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 8 commits into from
May 3, 2024
Merged

fix: tool-cache does not work #533

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
3b2e27c
VersionSpec supports other types
ueokande Apr 30, 2024
7344d0e
migrate release channel name to version.ts
ueokande May 1, 2024
a26d4f6
add cache features
ueokande May 1, 2024
822ff9b
migrate cache
ueokande May 1, 2024
0fe1fa1
fix cache test
ueokande May 1, 2024
cc892f0
migration
ueokande May 1, 2024
ac7531c
fix cache find returned value
ueokande May 3, 2024
7c963f6
add comment
ueokande May 3, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
146 changes: 146 additions & 0 deletions __test__/cache.test.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,146 @@
import { cacheDir, find } from "../src/cache";
import * as fs from "fs";
import * as os from "os";
import * as path from "path";

const mkdir = (dir: string) => fs.promises.mkdir(dir, { recursive: true });
const touch = (file: string) => fs.promises.writeFile(file, "");
const expectDir = async (dir: string) =>
expect((await fs.promises.stat(dir)).isDirectory()).toBeTruthy();
const expectFile = async (file: string) =>
expect((await fs.promises.stat(file)).isFile()).toBeTruthy();

describe("find", () => {
let tempToolCacheDir: string;
beforeEach(async () => {
tempToolCacheDir = await fs.promises.mkdtemp(
path.join(os.tmpdir(), "setup-chrome-"),
);
process.env.RUNNER_TOOL_CACHE = tempToolCacheDir;
});

afterEach(async () => {
await fs.promises.rm(tempToolCacheDir, { recursive: true });
});

describe("when several versions are cached", () => {
beforeEach(async () => {
const caches = [
["100.0.1.0", "x64"],
["100.1.0.0", "x64"],
["100.1.1.0", "x64"],
["100.2.0.0", "x64"],
["latest", "x64"],
["canary", "x64"],
["123456", "x64"],
["200000", "x64"],
["300000", "arm64"],
];
for (const [version, arch] of caches) {
const dir = path.join(
tempToolCacheDir,
"setup-chrome",
"chrome",
version,
arch,
);
await mkdir(dir);
await touch(`${dir}.complete`);
}
});

test.each`
version | arch | subdir
${"100.0.1.0"} | ${"x64"} | ${"100.0.1.0/x64"}
${"100.1"} | ${"x64"} | ${"100.1.1.0/x64"}
${"100"} | ${"x64"} | ${"100.2.0.0/x64"}
${"latest"} | ${"x64"} | ${"latest/x64"}
${"canary"} | ${"x64"} | ${"canary/x64"}
${"123456"} | ${"x64"} | ${"123456/x64"}
${"300000"} | ${"arm64"} | ${"300000/arm64"}
${"200"} | ${"x64"} | ${undefined}
${"stable"} | ${"x64"} | ${undefined}
`("finds a tool in the cache", async ({ version, arch, subdir }) => {
expect(await find("chrome", version, arch)).toBe(
subdir && path.join(tempToolCacheDir, "setup-chrome", "chrome", subdir),
);
});
});

describe("when cache is empty", () => {
test("cache is not found", async () => {
expect(await find("chrome", "100", "x64")).toBeUndefined();
});
});

describe("when cache includes corrupted cache", () => {
beforeEach(async () => {
const dir = path.join(tempToolCacheDir, "setup-chrome", "chrome");
await mkdir(path.join(dir, "100.0.0.0", "x64"));
await mkdir(path.join(dir, "100.0.0.0", "x64") + ".complete");
await mkdir(path.join(dir, "100.1.0.0", "x64"));
await mkdir(path.join(dir, "100.1.0.0", "x64") + ".complete");
await mkdir(path.join(dir, "100.2.0.0", "x64"));
});

test("cache is not found", async () => {
expect(await find("chrome", "100.2.0.0", "x64")).toBeUndefined();
});

test("corrupted cache is ignored", async () => {
expect(await find("chrome", "100", "x64")).toBe(
path.join(
tempToolCacheDir,
"setup-chrome",
"chrome",
"100.1.0.0",
"x64",
),
);
});
});
});

describe("cacheDir", () => {
let tempToolCacheDir: string;
let workspaceDir: string;
beforeEach(async () => {
tempToolCacheDir = await fs.promises.mkdtemp(
path.join(os.tmpdir(), "setup-chrome-"),
);
workspaceDir = await fs.promises.mkdtemp(
path.join(os.tmpdir(), "setup-chrome-"),
);
process.env.RUNNER_TOOL_CACHE = tempToolCacheDir;
});

afterEach(async () => {
await fs.promises.rm(workspaceDir, { recursive: true });
await fs.promises.rm(tempToolCacheDir, { recursive: true });
});

test("saves a tool in the cache", async () => {
const caches = [
["100.0.0.0", "x64"],
["100.1.0.0", "arm64"],
["latest", "x64"],
];
for (const [version, arch] of caches) {
const src = path.join(workspaceDir, version);
await mkdir(src);
await touch(path.join(src, "file"));

await cacheDir(src, "chrome", version, arch);
}

const prefix = path.join(tempToolCacheDir, "setup-chrome", "chrome");
await expectDir(path.join(prefix, "100.0.0.0", "x64"));
await expectFile(path.join(prefix, "100.0.0.0", "x64", "file"));
await expectFile(path.join(prefix, "100.0.0.0", "x64") + ".complete");
await expectDir(path.join(prefix, "100.1.0.0", "arm64"));
await expectFile(path.join(prefix, "100.1.0.0", "arm64", "file"));
await expectFile(path.join(prefix, "100.1.0.0", "arm64") + ".complete");
await expectDir(path.join(prefix, "latest", "x64"));
await expectFile(path.join(prefix, "latest", "x64", "file"));
});
});
191 changes: 78 additions & 113 deletions __test__/version.test.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,141 +1,106 @@
import { StaticVersion, VersionSpec } from "../src/version";
import { parse, isReleaseChannelName } from "../src/version";

describe("StaticVersion", () => {
describe("constructor", () => {
test("new instance", () => {
const version = new StaticVersion({
major: 119,
minor: 0,
build: 6045,
patch: 123,
});

expect(version.major).toBe(119);
expect(version.minor).toBe(0);
expect(version.build).toBe(6045);
expect(version.patch).toBe(123);
});

test("parse", () => {
const version = new StaticVersion("119.0.6045.123");

expect([
version.major,
version.minor,
version.build,
version.patch,
]).toEqual([119, 0, 6045, 123]);
});

test.each([
["119.0.6045.123.456"],
["119.0.6045.-123"],
["119.0.6045.beta"],
["119.0.6045"],
])("throw an error for %s", (version) => {
expect(() => new StaticVersion(version)).toThrow(
`Invalid version: ${version}`,
);
});
describe("isReleaseChannelName", () => {
test("return true if the version is a release channel name", () => {
expect(isReleaseChannelName("stable")).toBe(true);
expect(isReleaseChannelName("beta")).toBe(true);
expect(isReleaseChannelName("dev")).toBe(true);
expect(isReleaseChannelName("canary")).toBe(true);
expect(isReleaseChannelName("latest")).toBe(false);
expect(isReleaseChannelName("unknown")).toBe(false);
});
});

describe("compare", () => {
test.each`
a | b | equals | greaterThan | lessThan | greaterThanOrEqual | lessThanOrEqual
${"119.0.6045.123"} | ${"119.0.6045.123"} | ${true} | ${false} | ${false} | ${true} | ${true}
${"119.0.6045.123"} | ${"119.0.6045.100"} | ${false} | ${true} | ${false} | ${false} | ${true}
${"119.0.6045.123"} | ${"119.0.6045.200"} | ${false} | ${false} | ${true} | ${false} | ${true}
${"119.0.6045.123"} | ${"119.0.7000.100"} | ${false} | ${false} | ${true} | ${false} | ${true}
${"119.0.6045.123"} | ${"119.0.5000.100"} | ${false} | ${true} | ${false} | ${false} | ${true}
${"119.0.6045.123"} | ${"119.1.6045.100"} | ${false} | ${false} | ${true} | ${false} | ${true}
${"119.0.6045.123"} | ${"120.0.6045.100"} | ${false} | ${false} | ${true} | ${false} | ${true}
${"119.0.6045.123"} | ${"118.0.6045.100"} | ${false} | ${true} | ${false} | ${false} | ${true}
${"119.0.6045.123"} | ${"119.0.6045.122"} | ${false} | ${true} | ${false} | ${false} | ${true}
`('compare "$a" and "$b"', ({ a, b, equals, greaterThan, lessThan }) => {
const v1 = new StaticVersion(a);
const v2 = new StaticVersion(b);
expect(v1.equals(v2)).toBe(equals);
expect(v1.greaterThan(v2)).toBe(greaterThan);
expect(v1.lessThan(v2)).toBe(lessThan);
expect(v1.greaterThanOrEqual(v2)).toBe(greaterThan || equals);
expect(v1.lessThanOrEqual(v2)).toBe(lessThan || equals);
});
describe("parse", () => {
test.each([
[
"119.0.6045.123",
{ type: "four-parts", major: 119, minor: 0, build: 6045, patch: 123 },
],
["119.0.6045", { type: "four-parts", major: 119, minor: 0, build: 6045 }],
["119.0", { type: "four-parts", major: 119, minor: 0 }],
["119", { type: "four-parts", major: 119 }],
["119.0.6045.x", { type: "four-parts", major: 119, minor: 0, build: 6045 }],
["119.0.x", { type: "four-parts", major: 119, minor: 0 }],
["119.x", { type: "four-parts", major: 119 }],
["latest", { type: "latest" }],
["beta", { type: "channel", channel: "beta" }],
["stable", { type: "channel", channel: "stable" }],
["canary", { type: "channel", channel: "canary" }],
["123456", { type: "snapshot", snapshot: 123456 }],
])("parse %s", (version, expected) => {
const v = parse(version);
expect(v.value).toEqual(expected);
});

describe("toString", () => {
test("return stringified version", () => {
const v = new StaticVersion("119.0.6045.123");
expect(v.toString()).toBe("119.0.6045.123");
});
test.each([
["119.0.6045.beta"],
["119.0.x.123"],
["x"],
["119.0.6045.123.456"],
["119.0.6045.-123"],
[""],
["invalid"],
])("throw an error for %s", (version) => {
expect(() => parse(version)).toThrow(`Invalid version: ${version}`);
});
});

describe("VersionSpec", () => {
describe("constructor", () => {
test("new instance", () => {
const version = new VersionSpec({
major: 119,
minor: 0,
build: 6045,
patch: 123,
});

expect(version.major).toBe(119);
expect(version.minor).toBe(0);
expect(version.build).toBe(6045);
expect(version.patch).toBe(123);
});

test.each([
["119.0.6045.123", [119, 0, 6045, 123]],
["119.0.6045", [119, 0, 6045]],
["119.0", [119, 0]],
["119", [119]],
["119.0.6045.x", [119, 0, 6045]],
["119.0.x", [119, 0]],
["119.x", [119]],
])("parse %s", (version, expected) => {
const v = new VersionSpec(version);
expect([v.major, v.minor, v.build, v.patch]).toEqual(expected);
});

test.each([
["119.0.6045.beta"],
["119.0.x.123"],
["x"],
["119.0.6045.123.456"],
["119.0.6045.-123"],
[""],
])("throw an error for %s", (version) => {
expect(() => new VersionSpec(version)).toThrow(
`Invalid version: ${version}`,
);
});
});

describe("toString", () => {
test.each([
["119.0.6045.123", "119.0.6045.123"],
["119", "119"],
])("return %s for %s", (expected, version) => {
const v = new VersionSpec(version);
["latest", "latest"],
["123456", "123456"],
])("return %s for %s", (spec, expected) => {
const v = parse(spec);
expect(v.toString()).toBe(expected);
});
});

describe("satisfies", () => {
test.each`
spec | version | satisfies
spec | target | satisfies
${"119.0.6045.123"} | ${"119.0.6045.123"} | ${true}
${"119.0.6045"} | ${"119.0.6045.123"} | ${true}
${"119"} | ${"119.0.6045.123"} | ${true}
${"119.0.6045.123"} | ${"119.0.6045.100"} | ${false}
${"119.0.6000"} | ${"119.0.6045.100"} | ${false}
${"120"} | ${"119.0.6045.100"} | ${false}
`("return if $spec satisfies $version", ({ spec, version, satisfies }) => {
const s = new VersionSpec(spec);
const v = new StaticVersion(version);
expect(s.satisfies(v)).toBe(satisfies);
${"latest"} | ${"119.0.6045.100"} | ${false}
${"latest"} | ${"latest"} | ${true}
${"123456"} | ${"123456"} | ${true}
${"123456"} | ${"123457"} | ${false}
`("return if $spec satisfies $target", ({ spec, target, satisfies }) => {
const v = parse(spec);
expect(v.satisfies(target)).toBe(satisfies);
});
});

describe("compare", () => {
test.each`
a | b | gt | lt
${"119.0.6045.123"} | ${"119.0.6045.123"} | ${false} | ${false}
${"119.0.6045.123"} | ${"119.0.6045.100"} | ${true} | ${false}
${"119.0.6045.123"} | ${"119.0.6045.200"} | ${false} | ${true}
${"119.0.6045.123"} | ${"119.0.7000.100"} | ${false} | ${true}
${"119.0.6045.123"} | ${"119.0.5000.100"} | ${true} | ${false}
${"119.0.6045.123"} | ${"119.1.6045.100"} | ${false} | ${true}
${"119.0.6045.123"} | ${"120.0.6045.100"} | ${false} | ${true}
${"119.0.6045.123"} | ${"118.0.6045.100"} | ${true} | ${false}
${"119.0.6045.123"} | ${"119.0.6045.122"} | ${true} | ${false}
${"119"} | ${"119.0.6045.123"} | ${false} | ${false}
${"123456"} | ${"123456"} | ${false} | ${false}
${"123456"} | ${"123457"} | ${false} | ${true}
${"latest"} | ${"latest"} | ${false} | ${false}
${"latest"} | ${"stable"} | ${false} | ${false}
${"119.0.6045.123"} | ${"latest"} | ${false} | ${false}
`('compare "$a" and "$b"', ({ a, b, gt, lt }) => {
const v1 = parse(a);

expect(v1.gt(b)).toBe(gt);
expect(v1.lt(b)).toBe(lt);
});
});
});
Loading