refactor: clean up setup action (#146)

* refactor: replace cache with opinionated tool cacher

* refactor: replace install with packager

* refactor: replace various tools with worker

BEARKING CHANGE: Dropping username and password authentication in favor of token authentication only.

* refactor: update setup action with latest refactors

* chore: rebuild project

* chore: remove semver and rebuild project

* refactor: update tests for new components

* chore: fix linting issues and rebuild project
This commit is contained in:
Cedric van Putten authored and GitHub committed 2022-01-13 19:04:24 +01:00
1 parent 3ae799926e
commit 439ff4c9aa
19 files changed
+742 -4501

No files matched your search

+200 -3402
View File
File diff suppressed because it is too large. Load diff
-38
View File
@@ -736,25 +736,6 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
lru-cache
ISC
The ISC License
Copyright (c) Isaac Z. Schlueter and Contributors
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
mime-db
MIT
@@ -1106,22 +1087,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
yallist
ISC
The ISC License
Copyright (c) Isaac Z. Schlueter and Contributors
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+1 -3
View File
@@ -25,8 +25,7 @@
"@actions/core": "^1.6.0",
"@actions/exec": "^1.1.0",
"@actions/io": "^1.1.1",
"@actions/tool-cache": "^1.7.1",
"semver": "^7.3.5"
"@actions/tool-cache": "^1.7.1"
},
"devDependencies": {
"@semantic-release/changelog": "^6.0.1",
@@ -34,7 +33,6 @@
"@tsconfig/node16": "^1.0.2",
"@types/jest": "^27.4.0",
"@types/node": "^16.11.19",
"@types/semver": "^7.3.9",
"@typescript-eslint/eslint-plugin": "^5.9.1",
"@typescript-eslint/parser": "^5.9.1",
"@vercel/ncc": "^0.33.1",
+64 -46
View File
@@ -1,61 +1,79 @@
import { addPath, getBooleanInput, getInput, group, info } from '@actions/core';
import { getBooleanInput, getInput, group, info } from '@actions/core';
import { install } from '../install';
import { resolveVersion } from '../packager';
import * as tools from '../tools';
import { restoreFromCache, saveToCache } from '../cacher';
import { installPackage, resolvePackage } from '../packager';
import { executeAction, expoAuthenticate, findTool, installToolFromPackage, patchWatchers } from '../worker';
// Auto-execute in GitHub actions
tools.performAction(setupAction);
executeAction(setupAction);
export async function setupAction(): Promise<void> {
const expoVersion = await installCli('expo-cli');
const easVersion = await installCli('eas-cli');
export type SetupInput = ReturnType<typeof setupInput>;
await group('Checking current authenticated account', () =>
tools.maybeAuthenticate({
cli: expoVersion ? 'expo-cli' : easVersion ? 'eas-cli' : undefined,
token: getInput('token') || undefined,
username: getInput('username') || undefined,
password: getInput('password') || undefined,
})
);
if (!getInput('patch-watchers') || getBooleanInput('patch-watchers') !== false) {
await group('Patching system watchers for the `ENOSPC` error', () => tools.maybePatchWatchers());
}
export function setupInput() {
return {
easCache: getBooleanInput('eas-cache'),
easVersion: getInput('eas-version'),
expoCache: getBooleanInput('expo-cache'),
expoVersion: getInput('expo-version'),
packager: getInput('packager') || 'yarn',
patchWatchers: !getInput('patch-watchers') || getBooleanInput('patch-watchers'),
token: getInput('token'),
};
}
async function installCli(name: tools.PackageName): Promise<string | void> {
const shortName = tools.getBinaryName(name);
const inputVersion = getInput(`${shortName}-version`);
const packager = getInput('packager') || 'yarn';
export async function setupAction(input: SetupInput = setupInput()): Promise<void> {
if (!input.expoVersion) {
info(`Skipped installing expo-cli: 'expo-version' not provided.`);
} else {
const version = await resolvePackage('expo-cli', input.expoVersion);
const message = input.expoCache
? `Installing expo-cli (${version}) from cache or with ${input.packager}`
: `Installing expo-cli (${version}) with ${input.packager}`;
if (!inputVersion) {
return info(`Skipping installation of ${name}, \`${shortName}-version\` not provided.`);
await group(message, () => installCli('expo-cli', version, input.packager, input.expoCache));
}
const version = await resolveVersion(name, inputVersion);
const cache = getBooleanInput(`${shortName}-cache`);
if (!input.easVersion) {
info(`Skipped installing eas-cli: 'eas-version' not provided.`);
} else {
const version = await resolvePackage('eas-cli', input.easVersion);
const message = input.easCache
? `Installing eas-cli (${version}) from cache or with ${input.packager}`
: `Installing eas-cli (${version}) with ${input.packager}`;
try {
const path = await group(
cache
? `Installing ${name} (${version}) from cache or with ${packager}`
: `Installing ${name} (${version}) with ${packager}`,
() =>
install({
packager,
version,
cache,
package: name,
cacheKey: getInput(`${shortName}-cache-key`) || undefined,
})
await group(message, () => installCli('eas-cli', input.easVersion, input.packager, input.easCache));
}
if (!input.token) {
info(`Skipped authentication: 'token' not provided.`);
} else {
await group('Validating authenticated account', () =>
expoAuthenticate(input.token, input.easVersion ? 'eas' : input.expoVersion ? 'expo' : undefined)
);
addPath(path);
} catch (error) {
tools.handleError(name, error);
}
return version;
if (!input.patchWatchers) {
info(`Skipped patching watchers: 'patch-watchers' disabled.`);
} else {
await group(`Patching system watchers for the 'ENOSPC' error`, patchWatchers);
}
}
async function installCli(name: string, version: string, packager: string, cache: boolean = true) {
const cliVersion = await resolvePackage(name, version);
let cliPath = findTool(name, cliVersion) || undefined;
if (!cliPath && cache) {
cliPath = await restoreFromCache(name, cliVersion, packager);
}
if (!cliPath) {
cliPath = await installPackage(name, cliVersion, packager);
if (cache) {
await saveToCache(name, cliVersion, packager);
}
}
installToolFromPackage(cliPath);
}
-94
View File
@@ -1,94 +0,0 @@
import { ReserveCacheError, restoreCache, saveCache } from '@actions/cache';
import * as core from '@actions/core';
import * as toolCache from '@actions/tool-cache';
import os from 'os';
import path from 'path';
import type { InstallConfig } from './install';
export type CacheConfig = Omit<InstallConfig, 'cache'>;
/**
* Get the path to the `expo-cli` from cache, if any.
* Note, this cache is **NOT** shared between jobs.
*
* @see https://github.com/actions/toolkit/issues/47
*/
export async function fromLocalCache(config: CacheConfig): Promise<string | undefined> {
return toolCache.find(config.package, config.version);
}
/**
* Store the root of `expo-cli` in the cache, for future reuse.
* Note, this cache is **NOT** shared between jobs.
*
* @see https://github.com/actions/toolkit/issues/47
*/
export async function toLocalCache(root: string, config: CacheConfig): Promise<string> {
return toolCache.cacheDir(root, config.package, config.version);
}
/**
* Download the remotely stored `expo-cli` from cache, if any.
* Note, this cache is shared between jobs.
*/
export async function fromRemoteCache(config: CacheConfig): Promise<string | undefined> {
// see: https://github.com/actions/toolkit/blob/8a4134761f09d0d97fb15f297705fd8644fef920/packages/tool-cache/src/tool-cache.ts#L401
const target = path.join(process.env['RUNNER_TOOL_CACHE'] || '', config.package, config.version, os.arch());
const cacheKey = config.cacheKey || getRemoteKey(config);
try {
// When running with nektos/act, or other custom environments, the cache might not be set up.
const hit = await restoreCache([target], cacheKey);
if (hit) {
return target;
}
} catch (error) {
if (!handleRemoteCacheError(error)) {
throw error;
}
}
}
/**
* Store the root of `expo-cli` in the remote cache, for future reuse.
* Note, this cache is shared between jobs.
*/
export async function toRemoteCache(source: string, config: CacheConfig): Promise<void> {
const cacheKey = config.cacheKey || getRemoteKey(config);
try {
await saveCache([source], cacheKey);
} catch (error) {
if (!handleRemoteCacheError(error)) {
throw error;
}
}
}
/**
* Get the cache key to use when (re)storing the Expo CLI from remote cache.
*/
function getRemoteKey(config: Omit<CacheConfig, 'cacheKey'>): string {
return `${config.package}-${process.platform}-${os.arch()}-${config.packager}-${config.version}`;
}
/**
* Handle any incoming errors from cache methods.
* This can include actual errors like `ReserveCacheErrors` or unavailability errors.
* When the error is handled, it MUST provide feedback for the developer.
*
* @returns If the error was handled properly.
*/
function handleRemoteCacheError(error: Error): boolean {
const isReserveCacheError = error instanceof ReserveCacheError;
const isCacheUnavailable = error.message.toLowerCase().includes('cache service url not found');
if (isReserveCacheError || isCacheUnavailable) {
core.warning('Skipping remote cache storage, encountered error:');
core.warning(error.message);
return true;
}
return false;
}
+61
View File
@@ -0,0 +1,61 @@
import { saveCache, restoreCache, ReserveCacheError } from '@actions/cache';
import { warning } from '@actions/core';
import os from 'os';
import { toolPath } from './worker';
/**
* Get the exact cache key for the package.
* We can prefix this when there are breaking changes in this action.
*/
export function cacheKey(name: string, version: string, manager: string): string {
return `${name}-${process.platform}-${os.arch()}-${manager}-${version}`;
}
/**
* Restore a tool from the remote cache.
* This will install the tool back into the local tool cache.
*/
export async function restoreFromCache(name: string, version: string, manager: string) {
const dir = toolPath(name, version)!;
try {
if (await restoreCache([dir], cacheKey(name, version, manager))) {
return dir;
}
} catch (error) {
handleCacheError(error);
}
}
/**
* Save a tool to the remote cache.
* This will fetch the tool from the local tool cache.
*/
export async function saveToCache(name: string, version: string, manager: string) {
try {
await saveCache([toolPath(name, version)], cacheKey(name, version, manager));
} catch (error) {
handleCacheError(error);
}
}
/**
* Try to handle incoming cache errors.
* Because workers can operate in environments without cache configured,
* we need to make sure to only skip the cache instead of fail.
*
* Currently we handle these types of errors:
* - ReserveCacheError
* - "cache service url not found"
*/
export function handleCacheError(error: Error): void {
const isReserveCacheError = error instanceof ReserveCacheError;
const isCacheUnavailable = error.message.toLowerCase().includes('cache service url not found');
if (isReserveCacheError || isCacheUnavailable) {
warning('Skipped remote cache, encountered error:');
warning(error.message);
} else {
throw error;
}
}
-60
View File
@@ -1,60 +0,0 @@
import * as core from '@actions/core';
import * as cli from '@actions/exec';
import * as io from '@actions/io';
import * as path from 'path';
import { fromLocalCache, fromRemoteCache, toLocalCache, toRemoteCache } from './cache';
import { PackageName } from './tools';
export type InstallConfig = {
/** The exact version to install */
version: string;
/** The name of the package to install */
package: PackageName;
/** The packager to install with, likely to be `yarn` or `npm` */
packager: string;
/** If remote caching is enabled or not */
cache?: boolean;
/** The custom remote cache key */
cacheKey?: string;
};
/**
* Install `expo-cli`, by version, using the packager.
* Here you can provide any semver range or dist tag used in the registry.
* It returns the path where Expo is installed.
*/
export async function install(config: InstallConfig): Promise<string> {
let root: string | undefined = await fromLocalCache(config);
if (!root && config.cache) {
root = await fromRemoteCache(config);
} else {
core.info('Skipping remote cache, not enabled...');
}
if (!root) {
root = await fromPackager(config);
root = await toLocalCache(root, config);
if (config.cache) {
await toRemoteCache(root, config);
}
}
return path.join(root, 'node_modules', '.bin');
}
/**
* Install `expo-cli`, by version, using npm or yarn.
* It creates a temporary directory to store all required files.
*/
export async function fromPackager(config: InstallConfig): Promise<string> {
const root = process.env['RUNNER_TEMP'] || '';
const tool = await io.which(config.packager);
await io.mkdirP(root);
await cli.exec(tool, ['add', `${config.package}@${config.version}`], { cwd: root });
return root;
}
+20 -2
View File
@@ -1,11 +1,14 @@
import { exec } from '@actions/exec';
import { which, mkdirP } from '@actions/io';
import { cacheTool, tempPath } from './worker';
/**
* Resolve a package with version range to an exact version.
* This is useful to invalidate the cache _and_ using dist-tags or version ranges.
* It executes `npm info` and parses the latest manifest.
*/
export async function resolveVersion(name: string, range: string): Promise<string> {
export async function resolvePackage(name: string, range: string): Promise<string> {
let stdout = '';
try {
@@ -18,7 +21,7 @@ export async function resolveVersion(name: string, range: string): Promise<strin
},
});
} catch (error) {
throw new Error(`Could not resolve version "${range}" of "${name}", reason:\n${error.message || error}`);
throw new Error(`Could not resolve ${name}@${range}, reason:\n${error.message || error}`);
}
// thanks npm, for returning a "x.x.x" json value...
@@ -28,3 +31,18 @@ export async function resolveVersion(name: string, range: string): Promise<strin
return JSON.parse(stdout).at(-1);
}
/**
* Install a module using a node package manager.
* The installation is executed in a temporary folder.
* After this is complete, it's "installed" into the worker's tool cache.
*/
export async function installPackage(name: string, version: string, manager: string) {
const temp = tempPath(name, version);
const tool = await which(manager);
await mkdirP(temp);
await exec(tool, ['add', `${name}@${version}`], { cwd: temp });
return cacheTool(temp, name, version);
}
-132
View File
@@ -1,132 +0,0 @@
import * as core from '@actions/core';
import * as cli from '@actions/exec';
import semver from 'semver';
import { resolveVersion } from './packager';
export type PackageName = 'expo-cli' | 'eas-cli';
export type AuthenticateOptions = {
cli?: PackageName;
token?: string;
username?: string;
password?: string;
};
/**
* Convert `expo-cli` or `eas-cli` to just their binary name.
* For windows we have to use `<bin>.cmd`, toolkit will handle the Windows binary with that.
*/
export function getBinaryName(name: PackageName, forWindows = false): string {
const bin = name.toLowerCase().replace('-cli', '');
return forWindows ? `${bin}.cmd` : bin;
}
/**
* Authenticate with Expo using either the token or username/password method.
* If both of them are set, token has priority.
*/
export async function maybeAuthenticate(options: AuthenticateOptions = {}): Promise<void> {
if (options.token) {
if (options.cli) {
const bin = getBinaryName(options.cli, process.platform === 'win32');
await cli.exec(bin, ['whoami'], {
env: { ...process.env, EXPO_TOKEN: options.token },
});
} else {
core.info("Skipping token validation: no CLI installed, can't run `whoami`.");
}
return core.exportVariable('EXPO_TOKEN', options.token);
}
if (options.username || options.password) {
if (options.cli !== 'expo-cli') {
return core.warning(
'Skipping authentication: only Expo CLI supports programmatic credentials, use `token` instead.'
);
}
if (!options.username || !options.password) {
return core.info('Skipping authentication: `username` and/or `password` not set...');
}
const bin = getBinaryName(options.cli, process.platform === 'win32');
await cli.exec(bin, ['login', `--username=${options.username}`], {
env: { ...process.env, EXPO_CLI_PASSWORD: options.password },
});
}
core.info('Skipping authentication: `token`, `username`, and/or `password` not set...');
}
/**
* Try to patch the default watcher/inotify limit.
* This is a limitation from GitHub Actions and might be an issue in some Expo projects.
* It sets the system's `fs.inotify` limits to a more sensible setting.
*
* @see https://github.com/expo/expo-github-action/issues/20
*/
export async function maybePatchWatchers(): Promise<void> {
if (process.platform !== 'linux') {
return core.info('Skipping patch for watchers, not running on Linux...');
}
core.info('Patching system watchers for the `ENOSPC` error...');
try {
// see https://github.com/expo/expo-cli/issues/277#issuecomment-452685177
await cli.exec('sudo sysctl fs.inotify.max_user_instances=524288');
await cli.exec('sudo sysctl fs.inotify.max_user_watches=524288');
await cli.exec('sudo sysctl fs.inotify.max_queued_events=524288');
await cli.exec('sudo sysctl -p');
} catch {
core.warning("Looks like we can't patch watchers/inotify limits, you might encouter the `ENOSPC` error.");
core.warning('For more info, https://github.com/expo/expo-github-action/issues/20');
}
}
/**
* Check if there is a new major version available.
* If there is, create a warning for people to upgrade their workflow.
* Because this introduces additional requests, it should only be executed when necessary.
*/
export async function maybeWarnForUpdate(name: PackageName): Promise<void> {
const binaryName = getBinaryName(name);
const latest = await resolveVersion(name, 'latest');
const current = await resolveVersion(name, core.getInput(`${getBinaryName(name)}-version`) || 'latest');
if (semver.diff(latest, current) === 'major') {
core.warning(`There is a new major version available of the Expo CLI (${latest})`);
core.warning(
`If you run into issues, try upgrading your workflow to "${binaryName}-version: ${semver.major(latest)}.x"`
);
}
}
/**
* Handle errors when this action fails, providing useful next-steps for developers.
* This mostly checks if the installed version is the latest version.
*/
export async function handleError(name: PackageName, error: Error) {
try {
await maybeWarnForUpdate(name);
} catch {
// If this fails, ignore it
}
core.setFailed(error);
}
/**
* Auto-execute the action if it's not running in a test environment.
* This is useful to test the action, without running it in tests.
* The method can also be mocked.
*/
export function performAction(action: () => Promise<void>) {
if (process.env.JEST_WORKER_ID) {
return Promise.resolve(null);
}
return action();
}
+92
View File
@@ -0,0 +1,92 @@
import { addPath, exportVariable, info, setFailed, warning } from '@actions/core';
import { exec } from '@actions/exec';
import os from 'os';
import path from 'path';
export { find as findTool, cacheDir as cacheTool } from '@actions/tool-cache';
export function tempPath(name: string, version: string): string {
const temp = process.env['RUNNER_TEMP'] || '';
if (!temp) {
throw new Error(`Could not resolve temporary path, 'RUNNER_TEMP' not defined.`);
}
return path.join(temp, name, version, os.arch());
}
export function toolPath(name: string, version: string): string {
const toolCache = process.env['RUNNER_TOOL_CACHE'] || '';
if (!toolCache) {
throw new Error(`Could not resolve the local tool cache, 'RUNNER_TOOL_CACHE' not defined.`);
}
// https://github.com/actions/toolkit/blob/daf8bb00606d37ee2431d9b1596b88513dcf9c59/packages/tool-cache/src/tool-cache.ts#L747-L749
return path.join(toolCache, name, version, os.arch());
}
/**
* Install a "tool" from a node package.
* This will add the folder, containing the `node_modules`, to the global path.
*/
export function installToolFromPackage(dir: string) {
return addPath(path.join(dir, 'node_modules', '.bin'));
}
/**
* Try to patch Linux's inotify limits to a more sensible setting on Linux.
* This limitation could cause `ENOSPC` errors when bundling Expo or React Native projects.
*
* It will try to change these `fs.inotify.` limits:
* - .max_user_instances = 524288
* - .max_user_watches = 524288
* - .max_queued_events = 524288
*
* @see https://github.com/expo/expo-github-action/issues/20
*/
export async function patchWatchers(): Promise<void> {
if (process.platform !== 'linux') {
return info('Skipped patching watchers: not running on Linux.');
}
try {
// see https://github.com/expo/expo-cli/issues/277#issuecomment-452685177
await exec('sudo sysctl fs.inotify.max_user_instances=524288');
await exec('sudo sysctl fs.inotify.max_user_watches=524288');
await exec('sudo sysctl fs.inotify.max_queued_events=524288');
await exec('sudo sysctl -p');
info('Patched system watchers for the `ENOSPC` error.');
} catch (error) {
warning(`Looks like we can't patch watchers/inotify limits, you might encouter the 'ENOSPC' error.`);
warning('For more info: https://github.com/expo/expo-github-action/issues/20, encountered error:');
warning(error.message);
}
}
/**
* Try to authenticate the user using either Expo or EAS CLI.
* This method tries to invoke 'whoami' to validate if the token is valid.
* If that passes, the token is exported as EXPO_TOKEN for all steps within the job.
*/
export async function expoAuthenticate(token: string, cli?: 'expo' | 'eas'): Promise<void> {
if (!cli) {
info(`Skipped token validation: no CLI installed, can't run 'whoami'.`);
} else {
await exec('npx --no-install', [cli, 'whoami'], {
env: { ...process.env, EXPO_TOKEN: token },
});
}
exportVariable('EXPO_TOKEN', token);
}
/**
* Auto-execute the action if it's not running in a test environment.
* This also propagate possible errors to GitHub actions, with setFailed.
*/
export async function executeAction(action: () => Promise<void>) {
if (process.env.JEST_WORKER_ID) {
return Promise.resolve(null);
}
return action().catch(setFailed);
}
+88 -113
View File
@@ -1,133 +1,108 @@
/* eslint-disable import/order,import/first */
import { getToolsMock, mockInput } from '../utils';
jest.mock('../../src/tools', () => getToolsMock());
jest.mock('../../src/packager', () => ({
async resolveVersion(_: string, version: string) {
return version;
},
}));
import * as core from '@actions/core';
import * as install from '../../src/install';
import * as tools from '../../src/tools';
import { setupAction } from '../../src/actions/setup';
import { SetupInput, setupInput, setupAction } from '../../src/actions/setup';
import * as cacher from '../../src/cacher';
import * as packager from '../../src/packager';
import * as worker from '../../src/worker';
import { mockInput } from '../utils';
describe(setupAction, () => {
describe('patch watchers', () => {
it('patches the system when set to true', async () => {
mockInput({ 'patch-watchers': 'true' });
await setupAction();
expect(tools.maybePatchWatchers).toHaveBeenCalled();
});
jest.mock('@actions/core');
jest.mock('../../src/cacher');
jest.mock('../../src/packager');
jest.mock('../../src/worker');
it('patches the system when not set', async () => {
mockInput({ 'patch-watchers': '' });
await setupAction();
expect(tools.maybePatchWatchers).toHaveBeenCalled();
});
it('skips the system patch when set to false', async () => {
mockInput({ 'patch-watchers': 'false' });
await setupAction();
expect(tools.maybePatchWatchers).not.toHaveBeenCalled();
describe(setupInput, () => {
it('returns object with correct defaults', () => {
expect(setupInput()).toMatchObject({
easCache: undefined,
easVersion: undefined,
expoCache: undefined,
expoVersion: undefined,
packager: 'yarn',
patchWatchers: true,
token: undefined,
});
});
describe('authentication', () => {
it('authenticates with provided credentials', async () => {
mockInput({ username: 'bycedric', password: 'mypassword' });
await setupAction();
expect(tools.maybeAuthenticate).toBeCalledWith({ username: 'bycedric', password: 'mypassword' });
});
it('authenticates with provided token', async () => {
mockInput({ token: 'ABC123' });
await setupAction();
expect(tools.maybeAuthenticate).toBeCalledWith({ token: 'ABC123' });
});
it('returns expo version and cache', () => {
mockInput({ 'expo-version': '5.x', 'expo-cache': 'true' });
expect(setupInput()).toMatchObject({ expoVersion: '5.x', expoCache: true });
});
['expo', 'eas'].forEach(cliName => {
const packageName = `${cliName}-cli`;
let installMock: jest.SpyInstance;
it('returns eas version and cache', () => {
mockInput({ 'eas-version': 'latest', 'eas-cache': 'true' });
expect(setupInput()).toMatchObject({ easVersion: 'latest', easCache: true });
});
beforeEach(() => {
installMock = jest.spyOn(install, 'install').mockImplementation();
});
it('returns different packager', () => {
mockInput({ packager: 'npm' });
expect(setupInput()).toMatchObject({ packager: 'npm' });
});
afterEach(() => {
installMock.mockRestore();
});
it('returns disabled patch watchers', () => {
mockInput({ 'patch-watchers': 'false' });
expect(setupInput()).toMatchObject({ patchWatchers: false });
});
describe(packageName, () => {
it(`skips installation without \`${cliName}-version\``, async () => {
mockInput();
await setupAction();
expect(installMock).not.toBeCalledWith({ package: packageName });
});
it('returns token', () => {
mockInput({ token: 'faketoken' });
expect(setupInput()).toMatchObject({ token: 'faketoken' });
});
});
it('installs with yarn by default', async () => {
mockInput({ [`${cliName}-version`]: 'latest' });
await setupAction();
expect(installMock).toBeCalledWith({
package: packageName,
version: 'latest',
packager: 'yarn',
cache: false,
});
});
describe(setupAction, () => {
const input: SetupInput = {
easCache: false,
easVersion: '',
expoCache: false,
expoVersion: '',
packager: 'yarn',
patchWatchers: true,
token: '',
};
it('installs provided version with npm', async () => {
mockInput({ [`${cliName}-version`]: '3.0.10', packager: 'npm' });
await setupAction();
expect(installMock).toBeCalledWith({
package: packageName,
version: '3.0.10',
packager: 'npm',
cache: false,
});
});
beforeAll(() => {
jest.mocked(core.group).mockImplementation((_, action) => action());
});
it('installs with yarn and cache enabled', async () => {
mockInput({
packager: 'yarn',
[`${cliName}-version`]: '4.2.0',
[`${cliName}-cache`]: 'true',
});
await setupAction();
expect(installMock).toBeCalledWith({
package: packageName,
version: '4.2.0',
packager: 'yarn',
cache: true,
});
});
['expo', 'eas'].forEach(cli => {
const cliName = `${cli}-cli`;
const cliVersion = `${cli}Version`;
const cliCache = `${cli}Cache`;
it('installs with yarn and custom cache key', async () => {
mockInput({
packager: 'yarn',
[`${cliName}-version`]: '4.2.0',
[`${cliName}-cache`]: 'true',
[`${cliName}-cache-key`]: 'custom-key',
});
await setupAction();
expect(installMock).toBeCalledWith({
package: packageName,
version: '4.2.0',
packager: 'yarn',
cache: true,
cacheKey: 'custom-key',
});
});
it(`installs ${cliName} using npm`, async () => {
jest.mocked(packager.resolvePackage).mockResolvedValue('5.0.3');
await setupAction({ ...input, [cliVersion]: '5.x', packager: 'npm' });
expect(packager.installPackage).toBeCalledWith(cliName, '5.0.3', 'npm');
expect(worker.installToolFromPackage).toBeCalled();
});
it('installs path to global path', async () => {
installMock.mockResolvedValue(`/${cliName}/install/path`);
const addPathSpy = jest.spyOn(core, 'addPath').mockImplementation();
await setupAction();
expect(addPathSpy).toBeCalledWith(`/${cliName}/install/path`);
});
it(`installs ${cliName} from cache`, async () => {
jest.mocked(packager.resolvePackage).mockResolvedValue('5.0.3');
jest.mocked(cacher.restoreFromCache).mockResolvedValue('fake/path');
await setupAction({ ...input, [cliVersion]: 'latest', [cliCache]: true });
expect(packager.installPackage).not.toBeCalled();
expect(worker.installToolFromPackage).toBeCalledWith('fake/path');
});
});
it('authenticates token with eas-cli by default', async () => {
await setupAction({ ...input, expoVersion: 'latest', easVersion: 'latest', token: 'faketoken' });
expect(worker.expoAuthenticate).toBeCalledWith('faketoken', 'eas');
});
it('authenticates token with expo-cli without eas-cli', async () => {
await setupAction({ ...input, expoVersion: 'latest', token: 'faketoken' });
expect(worker.expoAuthenticate).toBeCalledWith('faketoken', 'expo');
});
it('authenticates token without any cli', async () => {
await setupAction({ ...input, token: 'faketoken' });
expect(worker.expoAuthenticate).toBeCalledWith('faketoken', undefined);
});
it('patches watchers', async () => {
await setupAction({ ...input, patchWatchers: true });
expect(worker.patchWatchers).toBeCalled();
});
});
-153
View File
@@ -1,153 +0,0 @@
import * as remoteCache from '@actions/cache';
import * as core from '@actions/core';
import * as toolCache from '@actions/tool-cache';
import os from 'os';
import { join } from 'path';
import * as cache from '../src/cache';
import * as utils from './utils';
describe(cache.fromLocalCache, () => {
it('fetches the version specific cache', async () => {
const path = join('path', 'to', 'local', 'cache');
// todo: check why jest wants `never` instead of `string`
const find = jest.spyOn(toolCache, 'find').mockResolvedValue(path as never);
const result = await cache.fromLocalCache({ package: 'eas-cli', version: '4.2.0', packager: 'npm' });
expect(result).toBe(path);
expect(find).toBeCalledWith('eas-cli', '4.2.0');
});
});
describe(cache.toLocalCache, () => {
it('stores the version specific cache', async () => {
const path = join('path', 'to', 'local', 'cache');
const root = join('path', 'from', 'source');
const cacheDir = jest.spyOn(toolCache, 'cacheDir').mockResolvedValue(path);
const result = await cache.toLocalCache(root, { package: 'expo-cli', version: '4.2.0', packager: 'yarn' });
expect(result).toBe(path);
expect(cacheDir).toBeCalledWith(root, 'expo-cli', '4.2.0');
});
});
describe(cache.fromRemoteCache, () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
spy = {
restore: jest.spyOn(remoteCache, 'restoreCache').mockImplementation(),
warning: jest.spyOn(core, 'warning').mockImplementation(),
};
});
beforeAll(() => {
utils.setEnv('RUNNER_TOOL_CACHE', join('cache', 'path'));
});
afterAll(() => {
utils.restoreEnv();
spy.restore.mockRestore();
spy.warning.mockRestore();
});
it('restores remote cache with default key', async () => {
expect(await cache.fromRemoteCache({ package: 'expo-cli', version: '3.20.1', packager: 'yarn' })).toBeUndefined();
expect(remoteCache.restoreCache).toBeCalledWith(
[join('cache', 'path', 'expo-cli', '3.20.1', os.arch())],
`expo-cli-${process.platform}-${os.arch()}-yarn-3.20.1`
);
});
it('restores remote cache with custom key', async () => {
expect(
await cache.fromRemoteCache({
package: 'eas-cli',
version: '4.2.0',
packager: 'yarn',
cacheKey: 'custom-cache-key',
})
).toBeUndefined();
expect(remoteCache.restoreCache).toBeCalledWith(
[join('cache', 'path', 'eas-cli', '4.2.0', os.arch())],
'custom-cache-key'
);
});
it('returns path when remote cache exists', async () => {
spy.restore.mockResolvedValueOnce(true);
expect(await cache.fromRemoteCache({ package: 'expo-cli', version: '3.20.1', packager: 'npm' })).toBe(
join('cache', 'path', 'expo-cli', '3.20.1', os.arch())
);
});
it('fails when remote cache throws', async () => {
const error = new Error('Remote cache restore failed');
spy.restore.mockRejectedValueOnce(error);
await expect(cache.fromRemoteCache({ package: 'eas-cli', version: '3.20.1', packager: 'yarn' })).rejects.toBe(
error
);
});
it('skips remote cache when unavailable', async () => {
// see: https://github.com/actions/toolkit/blob/9167ce1f3a32ad495fc1dbcb574c03c0e013ae53/packages/cache/src/internal/cacheHttpClient.ts#L41
const error = new Error('Cache Service Url not found, unable to restore cache.');
spy.restore.mockRejectedValueOnce(error);
expect(await cache.fromRemoteCache({ package: 'expo-cli', version: '3.20.1', packager: 'yarn' })).toBeUndefined();
expect(spy.warning).toHaveBeenCalledWith(expect.stringContaining('Skipping remote cache'));
});
});
describe(cache.toRemoteCache, () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
spy = {
save: jest.spyOn(remoteCache, 'saveCache').mockImplementation(),
warning: jest.spyOn(core, 'warning').mockImplementation(),
};
});
afterAll(() => {
spy.save.mockRestore();
spy.warning.mockRestore();
});
it('saves remote cache with default key', async () => {
expect(
await cache.toRemoteCache(join('local', 'path'), { package: 'eas-cli', version: '3.20.1', packager: 'npm' })
).toBeUndefined();
expect(remoteCache.saveCache).toBeCalledWith(
[join('local', 'path')],
`eas-cli-${process.platform}-${os.arch()}-npm-3.20.1`
);
});
it('saves remote cache with custom key', async () => {
expect(
await cache.toRemoteCache(join('local', 'path'), {
package: 'eas-cli',
version: '3.20.1',
packager: 'yarn',
cacheKey: 'custom-cache-key',
})
).toBeUndefined();
expect(remoteCache.saveCache).toBeCalledWith([join('local', 'path')], 'custom-cache-key');
});
it('fails when remote cache throws', async () => {
const error = new Error('Remote cache save failed');
spy.save.mockRejectedValueOnce(error);
await expect(
cache.toRemoteCache(join('local', 'path'), { package: 'expo-cli', version: '3.20.1', packager: 'yarn' })
).rejects.toBe(error);
});
it('skips remote cache when unavailable', async () => {
// see: https://github.com/actions/toolkit/blob/9167ce1f3a32ad495fc1dbcb574c03c0e013ae53/packages/cache/src/internal/cacheHttpClient.ts#L41
const error = new Error('Cache Service Url not found, unable to restore cache.');
spy.save.mockRejectedValueOnce(error);
await expect(
cache.toRemoteCache(join('local', 'path'), { package: 'expo-cli', version: '3.20.1', packager: 'yarn' })
).resolves.toBeUndefined();
expect(spy.warning).toHaveBeenCalledWith(expect.stringContaining('Skipping remote cache'));
});
});
+70
View File
@@ -0,0 +1,70 @@
import * as cache from '@actions/cache';
import os from 'os';
import { cacheKey, restoreFromCache, saveToCache } from '../src/cacher';
import { toolPath } from '../src/worker';
import { resetEnv, setEnv } from './utils';
jest.mock('@actions/cache');
jest.mock('@actions/core');
beforeAll(() => {
setEnv('RUNNER_TOOL_CACHE', os.tmpdir());
});
afterAll(resetEnv);
describe(cacheKey, () => {
it('returns contains package name, version, and manager', () => {
expect(cacheKey('expo-cli', '5.0.3', 'yarn')).toMatch('expo-cli');
expect(cacheKey('expo-cli', '5.0.3', 'yarn')).toMatch('5.0.3');
expect(cacheKey('eas-cli', '5.0.3', 'npm')).toMatch('npm');
});
it('contains the os arch type', () => {
expect(cacheKey('eas-cli', '5.0.3', 'yarn')).toMatch(os.arch());
});
it('contains the platform type', () => {
expect(cacheKey('eas-cli', '5.0.3', 'yarn')).toMatch(process.platform);
});
});
describe(restoreFromCache, () => {
it('skips when cache is unavailable', async () => {
jest.mocked(cache.restoreCache).mockRejectedValue(new Error('Cache service url not found'));
await expect(restoreFromCache('expo-cli', '5.0.3', 'yarn')).resolves.toBeUndefined();
});
it('throws when cache has unexpected error', async () => {
jest.mocked(cache.restoreCache).mockRejectedValue(new Error('Node registry is down'));
await expect(restoreFromCache('expo-cli', '5.0.3', 'yarn')).rejects.toThrow('Node registry is down');
});
it('returns expo-cli path from cache when available', async () => {
jest.mocked(cache.restoreCache).mockResolvedValue('fake/path');
await expect(restoreFromCache('expo-cli', '5.0.3', 'yarn')).resolves.toBe(toolPath('expo-cli', '5.0.3'));
});
it('returns nothing when cache is empty', async () => {
jest.mocked(cache.restoreCache).mockResolvedValue(undefined);
await expect(restoreFromCache('eas-cli', '0.46.2', 'npm')).resolves.toBeUndefined();
});
});
describe(saveToCache, () => {
it('skips when cache is unavailable', async () => {
jest.mocked(cache.saveCache).mockRejectedValue(new Error('Cache service url not found'));
await expect(saveToCache('expo-cli', '5.0.3', 'yarn')).resolves.toBeUndefined();
});
it('throws when cache has unexpected error', async () => {
jest.mocked(cache.saveCache).mockRejectedValue(new Error('Node registry is down'));
await expect(saveToCache('expo-cli', '5.0.3', 'yarn')).rejects.toThrow('Node registry is down');
});
it('saves expo-cli to cache when available', async () => {
jest.mocked(cache.saveCache).mockResolvedValue(1337);
await expect(saveToCache('expo-cli', '5.0.3', 'yarn')).resolves.toBeUndefined();
});
});
-95
View File
@@ -1,95 +0,0 @@
/* eslint-disable import/order,import/first */
const cli = { exec: jest.fn() };
const io = { mkdirP: jest.fn(), which: jest.fn() };
const cache = {
fromLocalCache: jest.fn(),
fromRemoteCache: jest.fn(),
toLocalCache: jest.fn(),
toRemoteCache: jest.fn(),
};
jest.mock('@actions/exec', () => cli);
jest.mock('@actions/io', () => io);
jest.mock('../src/cache', () => cache);
import { join } from 'path';
import * as install from '../src/install';
import * as utils from './utils';
describe('install', () => {
it('installs path from local cache', async () => {
cache.fromLocalCache.mockResolvedValue(join('cache', 'path'));
const expoPath = await install.install({ package: 'expo-cli', version: '3.0.10', packager: 'npm' });
expect(expoPath).toBe(join('cache', 'path', 'node_modules', '.bin'));
});
it('installs path from packager and cache it locally', async () => {
utils.setEnv('RUNNER_TEMP', join('temp', 'path'));
cache.fromLocalCache.mockResolvedValue(undefined);
cache.toLocalCache.mockResolvedValue(join('cache', 'path'));
const expoPath = await install.install({ package: 'expo-cli', version: '3.0.10', packager: 'npm' });
expect(expoPath).toBe(join('cache', 'path', 'node_modules', '.bin'));
expect(cache.toLocalCache).toBeCalledWith(join('temp', 'path'), {
package: 'expo-cli',
version: '3.0.10',
packager: 'npm',
});
utils.restoreEnv();
});
it('installs path from remote cache', async () => {
cache.fromLocalCache.mockResolvedValue(undefined);
cache.fromRemoteCache.mockResolvedValue(join('cache', 'path'));
const expoPath = await install.install({ package: 'eas-cli', version: '4.2.0', packager: 'yarn', cache: true });
expect(expoPath).toBe(join('cache', 'path', 'node_modules', '.bin'));
expect(cache.fromRemoteCache).toBeCalledWith({
package: 'eas-cli',
version: '4.2.0',
packager: 'yarn',
cache: true,
});
});
it('installs path from packager and cache it remotely', async () => {
utils.setEnv('RUNNER_TEMP', join('temp', 'path'));
cache.fromLocalCache.mockResolvedValue(undefined);
cache.fromRemoteCache.mockResolvedValue(undefined);
cache.toLocalCache.mockResolvedValue(join('cache', 'path'));
const expoPath = await install.install({ package: 'expo-cli', version: '3.20.1', packager: 'npm', cache: true });
expect(expoPath).toBe(join('cache', 'path', 'node_modules', '.bin'));
expect(cache.toRemoteCache).toBeCalledWith(join('cache', 'path'), {
package: 'expo-cli',
version: '3.20.1',
packager: 'npm',
cache: true,
});
utils.restoreEnv();
});
});
describe('fromPackager', () => {
it('resolves tool path', async () => {
await install.fromPackager({ package: 'expo-cli', version: '3.0.10', packager: 'npm' });
expect(io.which).toBeCalledWith('npm');
});
it('creates temporary folder', async () => {
utils.setEnv('RUNNER_TEMP', join('temp', 'path'));
await install.fromPackager({ package: 'eas-cli', version: 'latest', packager: 'yarn' });
expect(io.mkdirP).toBeCalledWith(join('temp', 'path'));
utils.restoreEnv();
});
it('installs expo with tool', async () => {
utils.setEnv('RUNNER_TEMP', join('temp', 'path'));
io.which.mockResolvedValue('npm');
const expoPath = await install.fromPackager({ package: 'eas-cli', version: 'beta', packager: 'npm' });
expect(expoPath).toBe(join('temp', 'path'));
expect(cli.exec).toBeCalled();
expect(cli.exec.mock.calls[0][0]).toBe('npm');
expect(cli.exec.mock.calls[0][1]).toStrictEqual(['add', 'eas-cli@beta']);
expect(cli.exec.mock.calls[0][2]).toMatchObject({ cwd: join('temp', 'path') });
utils.restoreEnv();
});
});
+9 -12
View File
@@ -1,28 +1,25 @@
import { valid as validVersion } from 'semver';
import { resolvePackage } from '../src/packager';
import { resolveVersion } from '../src/packager';
describe(resolveVersion, () => {
describe(resolvePackage, () => {
it('resolves expo-cli@^2.0.0 to 2.21.2', async () => {
await expect(resolveVersion('expo-cli', '^2.0.0')).resolves.toBe('2.21.2');
await expect(resolvePackage('expo-cli', '^2.0.0')).resolves.toBe('2.21.2');
});
it('resolves expo-cli@~3.15.0 to 3.15.5', async () => {
await expect(resolveVersion('expo-cli', '~3.15.0')).resolves.toBe('3.15.5');
await expect(resolvePackage('expo-cli', '~3.15.0')).resolves.toBe('3.15.5');
});
it('resolves eas-cli@~0.33.0 to 0.33.1', async () => {
await expect(resolveVersion('eas-cli', '~0.33.0')).resolves.toBe('0.33.1');
await expect(resolvePackage('eas-cli', '~0.33.0')).resolves.toBe('0.33.1');
});
it('resolves expo-cli@latest to a valid version', async () => {
const version = await resolveVersion('expo-cli', 'latest');
expect(validVersion(version)).not.toBeNull();
it('resolves expo-cli@latest to a version', async () => {
await expect(resolvePackage('expo-cli', 'latest')).resolves.not.toMatch('latest');
});
it('rejects donotpublishthispackageoryouwillbefired with proper error', async () => {
await expect(resolveVersion('donotpublishthispackageoryouwillbefired', 'latest')).rejects.toThrow(
'Could not resolve version "latest" of "donotpublishthispackageoryouwillbefired"'
await expect(resolvePackage('donotpublishthispackageoryouwillbefired', 'latest')).rejects.toThrow(
'Could not resolve'
);
});
});
-328
View File
@@ -1,328 +0,0 @@
import * as core from '@actions/core';
import * as cli from '@actions/exec';
import * as packager from '../src/packager';
import * as tools from '../src/tools';
import * as utils from './utils';
describe(tools.getBinaryName, () => {
it('returns expo for `expo-cli`', () => {
expect(tools.getBinaryName('expo-cli')).toBe('expo');
});
it('returns eas for `eas-cli`', () => {
expect(tools.getBinaryName('eas-cli')).toBe('eas');
});
it('returns eas.cmd for `eas-cli` for windows', () => {
expect(tools.getBinaryName('eas-cli', true)).toBe('eas.cmd');
});
});
describe(tools.maybeAuthenticate, () => {
const token = 'ABC123';
const username = 'bycedric';
const password = 'mypassword';
describe('with token', () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
spy = {
exportVariable: jest.spyOn(core, 'exportVariable').mockImplementation(),
exec: jest.spyOn(cli, 'exec').mockImplementation(),
info: jest.spyOn(core, 'info').mockImplementation(),
};
});
afterAll(() => {
spy.exportVariable.mockRestore();
spy.exec.mockRestore();
spy.info.mockRestore();
});
it('skips authentication without token', async () => {
await tools.maybeAuthenticate();
expect(spy.exec).not.toBeCalled();
expect(spy.info).toBeCalledWith(expect.stringContaining('Skipping authentication'));
});
it('executes whoami command with token through environment', async () => {
utils.setEnv('TEST_INCLUDED', 'hellyeah');
await tools.maybeAuthenticate({ token, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][1]).toStrictEqual(['whoami']);
expect(spy.exec.mock.calls[0][2]).toMatchObject({
env: {
TEST_INCLUDED: 'hellyeah',
EXPO_TOKEN: token,
},
});
utils.restoreEnv();
});
it('fails when token is incorrect', async () => {
const error = new Error('Not logged in');
spy.exec.mockRejectedValue(error);
await expect(tools.maybeAuthenticate({ token, cli: 'expo-cli' })).rejects.toBe(error);
});
it('skips validation without cli', async () => {
await tools.maybeAuthenticate({ token });
expect(spy.exec).not.toBeCalled();
expect(spy.info).toBeCalledWith(expect.stringContaining('Skipping token validation'));
});
it('executes whoami command with `expo` on macos', async () => {
utils.setPlatform('darwin');
await tools.maybeAuthenticate({ token, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('expo');
utils.restorePlatform();
});
it('executes whoami command with `eas` on ubuntu', async () => {
utils.setPlatform('linux');
await tools.maybeAuthenticate({ token, cli: 'eas-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('eas');
utils.restorePlatform();
});
it('executes whoami command with `expo.cmd` on windows', async () => {
utils.setPlatform('win32');
await tools.maybeAuthenticate({ token, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('expo.cmd');
utils.restorePlatform();
});
});
describe('credentials', () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
spy = {
exec: jest.spyOn(cli, 'exec').mockImplementation(),
info: jest.spyOn(core, 'info').mockImplementation(),
warning: jest.spyOn(core, 'warning').mockImplementation(),
};
});
afterAll(() => {
spy.exec.mockRestore();
spy.info.mockRestore();
spy.warning.mockRestore();
});
it('skips authentication without cli', async () => {
await tools.maybeAuthenticate({});
expect(spy.exec).not.toBeCalled();
expect(spy.info).toBeCalledWith(expect.stringContaining('Skipping authentication'));
});
it('skips authentication without credentials', async () => {
await tools.maybeAuthenticate({ cli: 'expo-cli' });
expect(spy.exec).not.toBeCalled();
expect(spy.info).toBeCalledWith(expect.stringContaining('Skipping authentication'));
});
it('skips authentication without password', async () => {
await tools.maybeAuthenticate({ username, cli: 'expo-cli' });
expect(spy.exec).not.toBeCalled();
expect(spy.info).toBeCalledWith(expect.stringContaining('Skipping authentication'));
});
it('skips authentication with credentials for eas-cli', async () => {
await tools.maybeAuthenticate({ username, password, cli: 'eas-cli' });
expect(spy.exec).not.toBeCalled();
expect(spy.warning).toBeCalledWith(expect.stringContaining('Skipping authentication'));
});
it('executes login command with password through environment', async () => {
utils.setEnv('TEST_INCLUDED', 'hellyeah');
await tools.maybeAuthenticate({ username, password, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][1]).toStrictEqual(['login', `--username=${username}`]);
expect(spy.exec.mock.calls[0][2]).toMatchObject({
env: {
TEST_INCLUDED: 'hellyeah',
EXPO_CLI_PASSWORD: password,
},
});
utils.restoreEnv();
});
it('fails when credentials are incorrect', async () => {
const error = new Error('Invalid username/password. Please try again.');
spy.exec.mockRejectedValue(error);
await expect(tools.maybeAuthenticate({ username, password, cli: 'expo-cli' })).rejects.toBe(error);
});
it('executes login command with `expo` on macos', async () => {
utils.setPlatform('darwin');
await tools.maybeAuthenticate({ username, password, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('expo');
utils.restorePlatform();
});
it('executes login command with `expo` on ubuntu', async () => {
utils.setPlatform('linux');
await tools.maybeAuthenticate({ username, password, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('expo');
utils.restorePlatform();
});
it('executes login command with `expo.cmd` on windows', async () => {
utils.setPlatform('win32');
await tools.maybeAuthenticate({ username, password, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('expo.cmd');
utils.restorePlatform();
});
});
});
describe(tools.maybePatchWatchers, () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
spy = {
info: jest.spyOn(core, 'info').mockImplementation(),
warning: jest.spyOn(core, 'warning').mockImplementation(),
exec: jest.spyOn(cli, 'exec').mockImplementation(),
};
});
afterEach(() => {
utils.restorePlatform();
});
afterAll(() => {
spy.info.mockRestore();
spy.warning.mockRestore();
spy.exec.mockRestore();
});
it('increses fs inotify settings with sysctl', async () => {
utils.setPlatform('linux');
await tools.maybePatchWatchers();
expect(spy.exec).toBeCalledWith('sudo sysctl fs.inotify.max_user_instances=524288');
expect(spy.exec).toBeCalledWith('sudo sysctl fs.inotify.max_user_watches=524288');
expect(spy.exec).toBeCalledWith('sudo sysctl fs.inotify.max_queued_events=524288');
expect(spy.exec).toBeCalledWith('sudo sysctl -p');
});
it('warns for unsuccessful patches', async () => {
const error = new Error('Something went wrong');
spy.exec.mockRejectedValueOnce(error);
utils.setPlatform('linux');
await tools.maybePatchWatchers();
expect(core.warning).toBeCalledWith(expect.stringContaining("can't patch watchers"));
expect(core.warning).toBeCalledWith(
expect.stringContaining('https://github.com/expo/expo-github-action/issues/20')
);
});
it('skips on windows platform', async () => {
utils.setPlatform('win32');
await tools.maybePatchWatchers();
expect(spy.info).toBeCalledWith(expect.stringContaining('Skipping'));
expect(spy.exec).not.toHaveBeenCalled();
});
it('skips on macos platform', async () => {
utils.setPlatform('darwin');
await tools.maybePatchWatchers();
expect(spy.info).toBeCalledWith(expect.stringContaining('Skipping'));
expect(spy.exec).not.toHaveBeenCalled();
});
it('runs on linux platform', async () => {
utils.setPlatform('linux');
await tools.maybePatchWatchers();
expect(spy.info).toBeCalledWith(expect.stringContaining('Patching'));
expect(spy.exec).toHaveBeenCalled();
});
});
describe(tools.maybeWarnForUpdate, () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
spy = {
warning: jest.spyOn(core, 'warning').mockImplementation(),
resolveVersion: jest.spyOn(packager, 'resolveVersion').mockImplementation(),
};
});
afterAll(() => {
spy.warning.mockRestore();
spy.resolveVersion.mockRestore();
});
it('is silent when major version is up to date', async () => {
spy.resolveVersion.mockResolvedValueOnce('4.1.0').mockResolvedValueOnce('4.0.1');
await tools.maybeWarnForUpdate('eas-cli');
expect(spy.warning).not.toBeCalled();
});
it('warns when major version is outdated', async () => {
spy.resolveVersion.mockResolvedValueOnce('4.1.0').mockResolvedValueOnce('3.0.1');
await tools.maybeWarnForUpdate('expo-cli');
expect(spy.warning).toBeCalledWith('There is a new major version available of the Expo CLI (4.1.0)');
expect(spy.warning).toBeCalledWith('If you run into issues, try upgrading your workflow to "expo-version: 4.x"');
});
});
describe(tools.handleError, () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
spy = {
setFailed: jest.spyOn(core, 'setFailed').mockImplementation(),
resolveVersion: jest.spyOn(packager, 'resolveVersion').mockImplementation(),
};
});
afterAll(() => {
spy.setFailed.mockRestore();
spy.resolveVersion.mockRestore();
});
it('marks the job as failed with expo-cli', async () => {
const error = new Error('test');
spy.resolveVersion.mockResolvedValue('4.0.0');
await tools.handleError('expo-cli', error);
expect(core.setFailed).toBeCalledWith(error);
});
it('fails with original error when update warning failed', async () => {
const error = new Error('test');
spy.resolveVersion.mockRejectedValue(new Error('npm issue'));
await tools.handleError('eas-cli', error);
expect(core.setFailed).toBeCalledWith(error);
});
});
describe(tools.performAction, () => {
it('skips the test in a jest environment', async () => {
utils.setEnv('JEST_WORKER_ID', '69');
const action = jest.fn();
const result = await tools.performAction(action);
expect(result).toBeNull();
expect(action).not.toBeCalled();
utils.restoreEnv();
});
it('runs the test outside a jest environment', async () => {
utils.setEnv('JEST_WORKER_ID', '');
const action = jest.fn();
const result = await tools.performAction(action);
expect(result).toBeUndefined();
expect(action).toBeCalled();
utils.restoreEnv();
});
});
+4 -18
View File
@@ -14,7 +14,7 @@ export function setPlatform(platform: NodeJS.Platform): void {
/**
* Revert the platform to the original one.
*/
export function restorePlatform(): void {
export function resetPlatform(): void {
setPlatform(originalPlatform);
}
@@ -31,28 +31,14 @@ export function setEnv(name: string, value: string): void {
/**
* Revert the environment variable changes.
*/
export function restoreEnv(): void {
export function resetEnv(): void {
process.env = originalEnv;
}
/**
* Get a mocked version of the tools.
*/
export function getToolsMock() {
return {
getBinaryName: jest.fn(v => v.replace('-cli', '')),
maybeAuthenticate: jest.fn(),
maybePatchWatchers: jest.fn(),
maybeWarnForUpdate: jest.fn(),
handleError: jest.fn(),
performAction: jest.fn(),
};
}
/**
* Mock both the input and boolean input methods from `@actions/core`.
*/
export function mockInput(inputs: Record<string, string> = {}) {
jest.spyOn(core, 'getInput').mockImplementation(name => inputs[name]);
jest.spyOn(core, 'getBooleanInput').mockImplementation(name => inputs[name] === 'true');
jest.mocked(core.getInput).mockImplementation(name => inputs[name]);
jest.mocked(core.getBooleanInput).mockImplementation(name => inputs[name] === 'true');
}
+133
View File
@@ -0,0 +1,133 @@
import * as core from '@actions/core';
import * as exec from '@actions/exec';
import os from 'os';
import path from 'path';
import {
tempPath,
toolPath,
installToolFromPackage,
patchWatchers,
expoAuthenticate,
executeAction,
} from '../src/worker';
import { resetEnv, setEnv, setPlatform, resetPlatform } from './utils';
jest.mock('@actions/core');
jest.mock('@actions/exec');
describe(tempPath, () => {
afterEach(resetEnv);
it('throws when RUNNER_TEMP is undefined', () => {
setEnv('RUNNER_TEMP', '');
expect(tempPath).toThrow(`'RUNNER_TEMP' not defined`);
});
it('returns path with name, version, and arch type', () => {
setEnv('RUNNER_TEMP', 'fake/temp');
expect(tempPath('expo-cli', '5.0.3')).toBe(path.join('fake', 'temp', 'expo-cli', '5.0.3', os.arch()));
});
});
describe(toolPath, () => {
afterEach(resetEnv);
it('throws when RUNNER_TOOL_CACHE is undefined', () => {
setEnv('RUNNER_TOOL_CACHE', '');
expect(toolPath).toThrow(`'RUNNER_TOOL_CACHE' not defined`);
});
it('returns path with name, version, and arch type', () => {
setEnv('RUNNER_TOOL_CACHE', 'fake/tool');
expect(toolPath('eas-cli', '0.34.3')).toBe(path.join('fake', 'tool', 'eas-cli', '0.34.3', os.arch()));
});
});
describe(installToolFromPackage, () => {
it('registers path to <dir>/node_modules/.bin', () => {
installToolFromPackage('fake/install');
expect(core.addPath).toBeCalledWith(path.join('fake', 'install', 'node_modules', '.bin'));
});
});
describe(patchWatchers, () => {
afterEach(resetPlatform);
it('skips patches on windows', async () => {
setPlatform('win32');
await patchWatchers();
expect(exec.exec).not.toBeCalled();
});
it('skips patches on macos', async () => {
setPlatform('darwin');
await patchWatchers();
expect(exec.exec).not.toBeCalled();
});
it('patches on ubuntu', async () => {
setPlatform('linux');
await patchWatchers();
expect(exec.exec).toBeCalledWith('sudo sysctl fs.inotify.max_user_instances=524288');
expect(exec.exec).toBeCalledWith('sudo sysctl fs.inotify.max_user_watches=524288');
expect(exec.exec).toBeCalledWith('sudo sysctl fs.inotify.max_queued_events=524288');
expect(exec.exec).toBeCalledWith('sudo sysctl -p');
});
it('handles exception from commands', async () => {
setPlatform('linux');
jest
.mocked(exec.exec)
.mockResolvedValueOnce(0)
.mockResolvedValueOnce(0)
.mockRejectedValueOnce(new Error('fake error'));
await expect(patchWatchers()).resolves.not.toThrow();
});
});
describe(expoAuthenticate, () => {
it('exports EXPO_TOKEN variable', async () => {
await expoAuthenticate('faketoken', undefined);
expect(core.exportVariable).toBeCalledWith('EXPO_TOKEN', 'faketoken');
});
it('validates EXPO_TOKEN with expo-cli', async () => {
await expoAuthenticate('faketoken', 'expo');
expect(exec.exec).toBeCalledWith('npx --no-install', ['expo', 'whoami'], {
env: expect.objectContaining({ EXPO_TOKEN: 'faketoken' }),
});
});
it('validates EXPO_TOKEN with eas-cli', async () => {
await expoAuthenticate('faketoken', 'eas');
expect(exec.exec).toBeCalledWith('npx --no-install', ['eas', 'whoami'], {
env: expect.objectContaining({ EXPO_TOKEN: 'faketoken' }),
});
});
});
describe(executeAction, () => {
afterEach(resetEnv);
it('skips executing action in jest', async () => {
const action = jest.fn(() => Promise.resolve());
await executeAction(action);
expect(action).not.toBeCalled();
});
it('executes action outside jest', async () => {
setEnv('JEST_WORKER_ID', '');
const action = jest.fn(() => Promise.resolve());
await executeAction(action);
expect(action).toBeCalled();
});
it('handles action errors', async () => {
setEnv('JEST_WORKER_ID', '');
const error = new Error('fake error');
const action = jest.fn(() => Promise.reject(error));
await expect(executeAction(action)).resolves.not.toThrow();
expect(core.setFailed).toBeCalledWith(error);
});
});
-5
View File
@@ -1426,11 +1426,6 @@
resolved "https://registry.yarnpkg.com/@types/retry/-/retry-0.12.0.tgz#2b35eccfcee7d38cd72ad99232fbd58bffb3c84d"
integrity sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==
"@types/semver@^7.3.9":
version "7.3.9"
resolved "https://registry.yarnpkg.com/@types/semver/-/semver-7.3.9.tgz#152c6c20a7688c30b967ec1841d31ace569863fc"
integrity sha512-L/TMpyURfBkf+o/526Zb6kd/tchUP3iBDEPjqjb+U2MAJhVRxxrmr2fwpe08E7QsV7YLcpq0tUaQ9O9x97ZIxQ==
"@types/stack-utils@^2.0.0":
version "2.0.0"
resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-2.0.0.tgz#7036640b4e21cc2f259ae826ce843d277dad8cff"