Compare commits

...
6 Commits
v5 ... v6
Author SHA1 Message Date
semantic-release-bot c3c02de017 chore: create new release 6.0.0
## [6.0.0](https://github.com/expo/expo-github-action/compare/5.5.1...6.0.0) (2021-06-22)

### ⚠ BREAKING CHANGES

* Github Action inputs are changed to allow both Expo and EAS CLI.

### New features

* add support for eas cli installs ([#98](https://github.com/expo/expo-github-action/issues/98)) ([04692c3](https://github.com/expo/expo-github-action/commit/04692c3cb1f7ad977f62841ca0bb175c903f653f))

### Other chores

* update node to 14 and 16 in ci ([#100](https://github.com/expo/expo-github-action/issues/100)) ([a03876e](https://github.com/expo/expo-github-action/commit/a03876e3c556bea147f2be007eac911bf78c9b23))

### Documentation changes

* add commands to contirbuting guide for updating v{major} tags ([1b57c37](https://github.com/expo/expo-github-action/commit/1b57c37e9bdfe92e183befb3595debc64da672f0))
* update readme for v6 release ([#101](https://github.com/expo/expo-github-action/issues/101)) ([8b43bae](https://github.com/expo/expo-github-action/commit/8b43bae073f280d4fa76aa174642ad46febe985c))
* update upstream reference in contributing guide ([76ce4de](https://github.com/expo/expo-github-action/commit/76ce4de80ea89b343404cdabadc922882af80487))
2021-06-22 14:32:09 +00:00
Cedric van Putten 8b43bae073 docs: update readme for v6 release (#101)
* docs: update readme for v6 release

* docs: update all master references to main

* docs: update references to v6

* docs: fix link to eas build example
2021-06-22 16:27:07 +02:00
Cedric van Putten a03876e3c5 chore: update node to 14 and 16 in ci (#100) 2021-06-22 15:30:18 +02:00
Cedric van Putten 04692c3cb1 feature!: add support for eas cli installs (#98)
* feature!: add support for eas cli installs

* refactor: update the action metadata

* docs: update documentation to include eas examples

* fix: breaking change detection for semantic release

* docs: add notion about latest eas version

BREAKING CHANGE: Github Action inputs are changed to allow both Expo and EAS CLI.
2021-06-22 14:48:17 +02:00
Cedric van Putten 1b57c37e9b docs: add commands to contirbuting guide for updating v{major} tags 2021-06-17 14:13:56 +02:00
Cedric van Putten 76ce4de80e docs: update upstream reference in contributing guide 2021-06-17 14:11:07 +02:00
17 changed files with 646 additions and 314 deletions

No files matched your search

+1 -1
View File
@@ -11,7 +11,7 @@ jobs:
runs-on: ${{ matrix.os }}
strategy:
matrix:
node: [12, 14]
node: [14, 16]
os:
- macos-latest
- ubuntu-latest
+6 -1
View File
@@ -16,7 +16,12 @@ module.exports = {
plugins: [
['@semantic-release/commit-analyzer', {
preset: 'conventionalcommits',
releaseRules: rules.map(({ type, release }) => ({ type, release })),
releaseRules: [
{ breaking: true, release: 'major' },
{ revert: true, release: 'patch' },
].concat(
rules.map(({ type, release, breaking }) => ({ type, release, breaking }))
),
}],
['@semantic-release/release-notes-generator', {
preset: 'conventionalcommits',
+23
View File
@@ -1,3 +1,26 @@
## [6.0.0](https://github.com/expo/expo-github-action/compare/5.5.1...6.0.0) (2021-06-22)
### ⚠ BREAKING CHANGES
* Github Action inputs are changed to allow both Expo and EAS CLI.
### New features
* add support for eas cli installs ([#98](https://github.com/expo/expo-github-action/issues/98)) ([04692c3](https://github.com/expo/expo-github-action/commit/04692c3cb1f7ad977f62841ca0bb175c903f653f))
### Other chores
* update node to 14 and 16 in ci ([#100](https://github.com/expo/expo-github-action/issues/100)) ([a03876e](https://github.com/expo/expo-github-action/commit/a03876e3c556bea147f2be007eac911bf78c9b23))
### Documentation changes
* add commands to contirbuting guide for updating v{major} tags ([1b57c37](https://github.com/expo/expo-github-action/commit/1b57c37e9bdfe92e183befb3595debc64da672f0))
* update readme for v6 release ([#101](https://github.com/expo/expo-github-action/issues/101)) ([8b43bae](https://github.com/expo/expo-github-action/commit/8b43bae073f280d4fa76aa174642ad46febe985c))
* update upstream reference in contributing guide ([76ce4de](https://github.com/expo/expo-github-action/commit/76ce4de80ea89b343404cdabadc922882af80487))
### [5.5.1](https://github.com/expo/expo-github-action/compare/5.5.0...5.5.1) (2021-06-17)
+9 -2
View File
@@ -2,7 +2,7 @@
## 📦 Download and Setup
1. [Fork](https://help.github.com/articles/fork-a-repo/) this repository to your own GitHub account and then [clone](https://help.github.com/articles/cloning-a-repository/) it to your local device. (`git remote add upstream [email protected]:expo/vscode-expo.git` 😉)
1. [Fork](https://help.github.com/articles/fork-a-repo/) this repository to your own GitHub account and then [clone](https://help.github.com/articles/cloning-a-repository/) it to your local device. (`git remote add upstream [email protected]:expo/expo-github-action.git` 😉)
2. Make sure you have the following packages globally installed on your system:
- [node](https://nodejs.org/) (active Node LTS or higher is recommended)
- [yarn](https://yarnpkg.com/)
@@ -47,4 +47,11 @@ To get your PR merged as fast as possible, please make sure you have done the fo
To release a new version for Github Actions, we have to create a new release in Github. You can run the `Release` workflow to generate a new version, changelog, and Github release.
After the exact version tag is created, update the `v{major}` tag to the latest major version.
After the exact version tag is created, update the `v{major}` tag to the latest major version. Make sure you are on the default branch at the commit of versioning.
```bash
$ git checkout master
$ git fetch --tags && git pull
$ git tag --force v{major}
$ git push --force --tags
```
+80 -46
View File
@@ -7,9 +7,9 @@
<img src="https://img.shields.io/github/release/expo/expo-github-action/all.svg?style=flat-square" alt="releases" />
</a>
<a href="https://github.com/expo/expo-github-action/actions">
<img src="https://img.shields.io/github/workflow/status/expo/expo-github-action/CI/master.svg?style=flat-square" alt="builds" />
<img src="https://img.shields.io/github/workflow/status/expo/expo-github-action/CI/main.svg?style=flat-square" alt="builds" />
</a>
<a href="https://github.com/expo/expo-github-action/blob/master/LICENSE.md">
<a href="https://github.com/expo/expo-github-action/blob/main/LICENSE.md">
<img src="https://img.shields.io/github/license/expo/expo-github-action?style=flat-square" alt="license" />
</a>
</sup>
@@ -21,14 +21,14 @@
&nbsp;&nbsp;&mdash;&nbsp;&nbsp;
<a href="https://github.com/expo/expo-github-action#things-to-know"><b>Caveats</b></a>
&nbsp;&nbsp;&mdash;&nbsp;&nbsp;
<a href="https://github.com/expo/expo-github-action/blob/master/CHANGELOG.md"><b>Changelog</b></a>
<a href="https://github.com/expo/expo-github-action/blob/main/CHANGELOG.md"><b>Changelog</b></a>
</p>
<br />
</div>
## What's inside?
With this Expo action, you have full access to the [Expo CLI][link-expo-cli] itself.
With this Expo action, you have full access to [Expo CLI][link-expo-cli] and [EAS CLI][link-eas-cli] itself.
It allows you to fully automate the `expo publish` or `expo build` process, leaving you with more time available for your project.
There are some additional features included to make the usage of this action as simple as possible, like caching and authentication.
@@ -37,45 +37,49 @@ There are some additional features included to make the usage of this action as
This action is customizable through variables; they are defined in the [`action.yml`](action.yml).
Here is a summary of all the variables that you can use and their purpose.
variable | default | description
--- | --- | ---
`expo-username` | - | The username of your Expo account _(e.g. `bycedric`)_
`expo-token` | - | The token of your Expo account _(e.g. [`${{ secrets.EXPO_TOKEN }}`][link-actions-secrets])_
`expo-password` | - | The password of your Expo account _(e.g. [`${{ secrets.EXPO_CLI_PASSWORD }}`][link-actions-secrets])_
`expo-version` | `latest` | The Expo CLI version to use, can be any [SemVer][link-semver-playground]. _(e.g. `3.x`)_
`expo-packager` | `yarn` | The package manager to install the CLI with. _(e.g. `npm`)_
`expo-cache` | `false` | If it should use the [GitHub actions (remote) cache](#using-the-built-in-cache).
`expo-cache-key` | - | An optional custom (remote) cache key. _(**use with caution**)_
`expo-patch-watchers` | `true` | If it should [patch the `fs.inotify.` limits](#enospc-errors-on-linux).
| variable | default | description |
| ---------------- | ------- | ------------------------------------------------------------------------------------------------------------ |
| `expo-version` | - | [Expo CLI](https://github.com/expo/expo-cli) version to install, skips when omitted. |
| `expo-cache` | `false` | If it should use the [GitHub actions (remote) cache](#using-the-built-in-cache). |
| `expo-cache-key` | - | An optional custom (remote) cache key. _(**use with caution**)_ |
| `eas-version` | - | [EAS CLI](https://github.com/expo/eas-cli) version to install, skips when omitted. (`latest` is recommended) |
| `eas-cache` | `false` | If it should use the [GitHub actions (remote) cache](#using-the-built-in-cache). |
| `eas-cache-key` | - | An optional custom (remote) cache key. _(**use with caution**)_ |
| `packager` | `yarn` | The package manager to use. _(e.g. `npm`)_ |
| `token` | - | The token of your Expo account _(e.g. [`${{ secrets.EXPO_TOKEN }}`][link-actions-secrets])_ |
| `username` | - | The username of your Expo account _(e.g. `bycedric`)_ |
| `password` | - | The password of your Expo account _(e.g. [`${{ secrets.EXPO_CLI_PASSWORD }}`][link-actions-secrets])_ |
| `patch-watchers` | `true` | If it should [patch the `fs.inotify.` limits](#enospc-errors-on-linux). |
> Never hardcode `expo-token` or `expo-password` in your workflow, use [secrets][link-actions-secrets] to store them.
> It's also recommended to set the `expo-version` to avoid breaking changes when a new major version is released.
> Using `latest` for `eas-version` is recommened, you should always have the latest version of this CLI installed.
## Example workflows
Before you dive into the workflow examples, you should know the basics of GitHub Actions.
You can read more about this in the [GitHub Actions documentation][link-actions].
1. [Publish on any push to master](#publish-on-any-push-to-master)
1. [Publish on any push to main](#publish-on-any-push-to-main)
2. [Cache Expo CLI for other jobs](#cache-expo-cli-for-other-jobs)
3. [Test PRs and publish a review version](#test-prs-and-publish-a-review-version)
4. [Test PRs on multiple nodes and systems](#test-prs-on-multiple-nodes-and-systems)
5. [Test and build web every day at 08:00](#test-and-build-web-every-day-at-0800)
6. [Authenticate using an Expo token](#authenticate-using-an-expo-token)
3. [Creating a new EAS build](#creating-a-new-eas-build)
4. [Test PRs and publish a review version](#test-prs-and-publish-a-review-version)
5. [Test PRs on multiple nodes and systems](#test-prs-on-multiple-nodes-and-systems)
6. [Test and build web every day at 08:00](#test-and-build-web-every-day-at-0800)
7. [Authenticate using credentials](#authenticate-using-credentials)
### Publish on any push to master
### Publish on any push to main
Below you can see the example configuration to publish whenever the master branch is updated.
Below you can see the example configuration to publish whenever the main branch is updated.
The workflow listens to the `push` event and sets up Node 12 using the [Setup Node Action][link-actions-node].
It also authenticates the Expo project by defining both `expo-username` and `expo-password`.
It also auto-authenticates when the `token` is provided.
```yml
name: Expo Publish
on:
push:
branches:
- master
- main
jobs:
publish:
name: Install and publish
@@ -85,11 +89,10 @@ jobs:
- uses: actions/setup-node@v1
with:
node-version: 14.x
- uses: expo/expo-github-action@v5
- uses: expo/expo-github-action@v6
with:
expo-version: 4.x
expo-username: ${{ secrets.EXPO_CLI_USERNAME }}
expo-password: ${{ secrets.EXPO_CLI_PASSWORD }}
token: ${{ secrets.EXPO_TOKEN }}
- run: yarn install
- run: expo publish
```
@@ -107,7 +110,7 @@ name: Expo Publish
on:
push:
branches:
- master
- main
jobs:
publish:
name: Install and publish
@@ -117,16 +120,46 @@ jobs:
- uses: actions/setup-node@v1
with:
node-version: 14.x
- uses: expo/expo-github-action@v5
- uses: expo/expo-github-action@v6
with:
expo-version: 4.x
expo-username: ${{ secrets.EXPO_CLI_USERNAME }}
expo-password: ${{ secrets.EXPO_CLI_PASSWORD }}
expo-cache: true
token: ${{ secrets.EXPO_TOKEN }}
- run: yarn install
- run: expo publish
```
### Creating a new EAS build
You can also install [EAS](https://docs.expo.io/eas/) CLI with this Github Action.
Below we've swapped `expo-version` with `eas-version`, but you can also use them together.
Both the `token` and `username`/`password` is shared between both Expo and EAS CLI.
> We recommend using `latest` for `eas-version` to always have the most up-to-date version.
```yml
name: EAS build
on:
push:
branches:
- main
jobs:
build:
name: Create new build
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions/setup-node@v1
with:
node-version: 14.x
- uses: expo/expo-github-action@v6
with:
eas-version: latest
token: ${{ secrets.EXPO_TOKEN }}
- run: yarn install
- run: eas build
```
### Test PRs and publish a review version
Reviewing pull requests can take some time if you have to read every line of code.
@@ -145,14 +178,13 @@ jobs:
- uses: actions/setup-node@v1
with:
node-version: 14.x
- uses: expo/expo-github-action@v5
- uses: expo/expo-github-action@v6
with:
expo-version: 4.x
expo-username: ${{ secrets.EXPO_CLI_USERNAME }}
expo-password: ${{ secrets.EXPO_CLI_PASSWORD }}
token: ${{ secrets.EXPO_TOKEN }}
- run: yarn install
- run: expo publish --release-channel=pr-${{ github.event.number }}
- uses: unsplash/comment-on-pr@master
- uses: unsplash/comment-on-pr@main
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
@@ -164,7 +196,7 @@ jobs:
With GitHub Actions, it's reasonably easy to set up a matrix build and test the app on multiple environments.
These matrixes can help to make sure your app runs smoothly on a broad set of different development machines.
> If you don't need automatic authentication, you can omit the `expo-username` and `expo-password` variables.
> If you don't need automatic authentication, you can omit the `token` variables.
```yml
name: Expo CI
@@ -182,7 +214,7 @@ jobs:
- uses: actions/setup-node@v1
with:
node-version: ${{ matrix.node }}
- uses: expo/expo-github-action@v5
- uses: expo/expo-github-action@v6
with:
expo-version: 4.x
- run: yarn install
@@ -209,7 +241,7 @@ jobs:
- uses: actions/setup-node@v1
with:
node-version: 14.x
- uses: expo/expo-github-action@v5
- uses: expo/expo-github-action@v6
with:
expo-version: 4.x
- run: yarn install
@@ -217,17 +249,17 @@ jobs:
- run: expo build:web
```
### Authenticate using an Expo token
### Authenticate using credentials
Instead of username and password, you can also authenticate using a token.
This might help increasing security and avoids adding username and password to your repository secrets.
Instead of using an access token, you can also authenticate using credentials.
This is only possible when Expo CLI is installed.
```yml
name: Expo Publish
on:
push:
branches:
- master
- main
jobs:
publish:
name: Install and publish
@@ -237,10 +269,11 @@ jobs:
- uses: actions/setup-node@v1
with:
node-version: 14.x
- uses: expo/expo-github-action@v5
- uses: expo/expo-github-action@v6
with:
expo-version: 4.x
expo-token: ${{ secrets.EXPO_TOKEN }}
username: ${{ secrets.EXPO_CLI_USERNAME }}
password: ${{ secrets.EXPO_CLI_PASSWORD }}
- run: yarn install
- run: expo publish
```
@@ -263,7 +296,7 @@ Under the hood, it uses the [`@action/cache`][link-actions-cache-package] packag
This action generates a unique cache key for the OS, used packager, and exact version of the Expo CLI.
If you need more control over this cache, you can define a custom cache key with `expo-cache-key`.
> Note, this cache will count towards your [repo cache limit][link-actions-cache-limit].
> Note, this cache will count towards your [repo cache limit][link-actions-cache-limit]. The Expo and EAS CLI are stored in different caches.
### ENOSPC errors on Linux
@@ -272,7 +305,7 @@ Creating these bundles require quite some resources.
As of writing, GitHub actions has some small default values for the `fs.inotify` settings.
Inside this action, we included a patch that increases these limits for the current workflow.
It increases the `max_user_instances`, `max_user_watches` and `max_queued_events` to `524288`.
You can disable this patch by setting the `expo-patch-watchers` to `false`.
You can disable this patch by setting the `patch-watchers` to `false`.
<div align="center">
<br />
@@ -288,4 +321,5 @@ You can disable this patch by setting the `expo-patch-watchers` to `false`.
[link-expo-cli]: https://docs.expo.io/workflow/expo-cli/
[link-expo-cli-password]: https://github.com/expo/expo-cli/blob/master/packages/expo-cli/src/accounts.ts#L88-L90
[link-expo-release-channels]: https://docs.expo.io/distribution/release-channels/
[link-eas-cli]: https://github.com/expo/eas-cli#readme
[link-semver-playground]: https://semver.npmjs.com/
+22 -16
View File
@@ -10,22 +10,28 @@ runs:
main: build/index.js
inputs:
expo-version:
description: The Expo CLI version to install. (use any semver/dist-tag available)
default: latest
expo-username:
description: Your Expo username, for authentication.
expo-token:
description: Your Expo token, for authentication. (use with secrets)
expo-password:
description: Your Expo password, for authentication. (use with secrets)
expo-packager:
description: The package manager used to install the Expo CLI. (can be yarn or npm)
default: yarn
expo-patch-watchers:
description: If Expo should fix the default watchers limit, helps with ENOSPC errors. (can be true or false)
default: true
description: The Expo CLI version to install (use any semver/dist-tag available).
expo-cache:
description: If Expo should be stored in the GitHub Actions cache (can be true or false)
description: If Expo CLI should be stored in the GitHub Actions cache.
default: false
expo-cache-key:
description: A custom remote cache key to use (best to let GitHub Actions handle it)
description: A custom remote cache key to use for Expo CLI.
eas-version:
description: The EAS CLI version to install (use any semver/dist-tag available).
eas-cache:
description: If EAS CLI should be stored in the GitHub Actions cache.
default: false
eas-cache-key:
description: A custom remote cache key to use for EAS CLI.
username:
description: Your Expo username, for authentication.
token:
description: Your Expo token, for authentication. (use with secrets)
password:
description: Your Expo password, for authentication. (use with secrets)
packager:
description: The package manager used to install the Expo CLI. (can be yarn or npm)
default: yarn
patch-watchers:
description: If Expo should fix the default watchers limit, helps with ENOSPC errors. (can be true or false)
default: true
+115 -59
View File
@@ -49560,18 +49560,18 @@ const cache_1 = __webpack_require__(5722);
* It returns the path where Expo is installed.
*/
async function install(config) {
let root = await cache_1.fromLocalCache(config.version);
let root = await cache_1.fromLocalCache(config);
if (!root && config.cache) {
root = await cache_1.fromRemoteCache(config.version, config.packager, config.cacheKey);
root = await cache_1.fromRemoteCache(config);
}
else {
core.info('Skipping remote cache, not enabled...');
}
if (!root) {
root = await fromPackager(config.version, config.packager);
root = await cache_1.toLocalCache(root, config.version);
root = await fromPackager(config);
root = await cache_1.toLocalCache(root, config);
if (config.cache) {
await cache_1.toRemoteCache(root, config.version, config.packager, config.cacheKey);
await cache_1.toRemoteCache(root, config);
}
}
return path.join(root, 'node_modules', '.bin');
@@ -49581,11 +49581,11 @@ exports.install = install;
* Install `expo-cli`, by version, using npm or yarn.
* It creates a temporary directory to store all required files.
*/
async function fromPackager(version, packager) {
async function fromPackager(config) {
const root = process.env['RUNNER_TEMP'] || '';
const tool = await io.which(packager);
const tool = await io.which(config.packager);
await io.mkdirP(root);
await cli.exec(tool, ['add', `expo-cli@${version}`], { cwd: root });
await cli.exec(tool, ['add', `${config.package}@${config.version}`], { cwd: root });
return root;
}
exports.fromPackager = fromPackager;
@@ -63093,8 +63093,7 @@ if (typeof Object.create === 'function') {
Object.defineProperty(exports, "__esModule", { value: true });
const run_1 = __webpack_require__(4180);
const tools_1 = __webpack_require__(3534);
run_1.run().catch(tools_1.handleError);
run_1.run();
/***/ }),
@@ -74612,19 +74611,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.handleError = exports.maybeWarnForUpdate = exports.maybePatchWatchers = exports.maybeAuthenticate = exports.resolveVersion = void 0;
exports.handleError = exports.maybeWarnForUpdate = exports.maybePatchWatchers = exports.maybeAuthenticate = exports.resolveVersion = exports.getBinaryName = exports.getBoolean = void 0;
const core = __importStar(__webpack_require__(6470));
const cli = __importStar(__webpack_require__(4986));
const semver_1 = __importDefault(__webpack_require__(7876));
// eslint-disable-next-line @typescript-eslint/no-var-requires
const registry = __webpack_require__(5019);
/**
* Get a boolean value from string, useful for Github Actions boolean inputs.
*/
function getBoolean(value, defaultValue = false) {
return (value.toLowerCase() || (defaultValue ? 'true' : 'false')) === 'true';
}
exports.getBoolean = getBoolean;
/**
* 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.
*/
function getBinaryName(name, forWindows = false) {
const bin = name.toLowerCase().replace('-cli', '');
return forWindows ? `${bin}.cmd` : bin;
}
exports.getBinaryName = getBinaryName;
/**
* Resolve the provided semver to exact version of `expo-cli`.
* This uses the npm registry and accepts latest, dist-tags or version ranges.
* It's used to determine the cached version of `expo-cli`.
*/
async function resolveVersion(version) {
return (await registry.manifest(`expo-cli@${version}`)).version;
async function resolveVersion(name, version) {
return (await registry.manifest(`${name}@${version}`)).version;
}
exports.resolveVersion = resolveVersion;
/**
@@ -74632,24 +74647,31 @@ exports.resolveVersion = resolveVersion;
* If both of them are set, token has priority.
*/
async function maybeAuthenticate(options = {}) {
// github actions toolkit will handle commands with `.cmd` on windows, we need that
const bin = process.platform === 'win32' ? 'expo.cmd' : 'expo';
if (options.token) {
await cli.exec(bin, ['whoami'], {
env: { ...process.env, EXPO_TOKEN: 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.username || !options.password) {
return core.info('Skipping authentication: `expo-username` and/or `expo-password` not set...');
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 },
});
return;
}
core.info('Skipping authentication: `expo-token`, `expo-username`, and/or `expo-password` not set...');
core.info('Skipping authentication: `token`, `username`, and/or `password` not set...');
}
exports.maybeAuthenticate = maybeAuthenticate;
/**
@@ -74682,12 +74704,13 @@ exports.maybePatchWatchers = maybePatchWatchers;
* If there is, create a warning for people to upgrade their workflow.
* Because this introduces additional requests, it should only be executed when necessary.
*/
async function maybeWarnForUpdate() {
const latest = await resolveVersion('latest');
const current = await resolveVersion(core.getInput('expo-version') || 'latest');
async function maybeWarnForUpdate(name) {
const binaryName = getBinaryName(name);
const latest = await resolveVersion(name, 'latest');
const current = await resolveVersion(name, core.getInput(`${getBinaryName(name)}-version`) || 'latest');
if (semver_1.default.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 "expo-version: ${semver_1.default.major(latest)}.x"`);
core.warning(`If you run into issues, try upgrading your workflow to "${binaryName}-version: ${semver_1.default.major(latest)}.x"`);
}
}
exports.maybeWarnForUpdate = maybeWarnForUpdate;
@@ -74695,9 +74718,9 @@ exports.maybeWarnForUpdate = maybeWarnForUpdate;
* Handle errors when this action fails, providing useful next-steps for developers.
* This mostly checks if the installed version is the latest version.
*/
async function handleError(error) {
async function handleError(name, error) {
try {
await maybeWarnForUpdate();
await maybeWarnForUpdate(name);
}
catch {
// If this fails, ignore it
@@ -80923,35 +80946,68 @@ module.exports = minVersion
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.run = void 0;
const core_1 = __webpack_require__(6470);
const install_1 = __webpack_require__(1655);
const tools_1 = __webpack_require__(3534);
const tools = __importStar(__webpack_require__(3534));
async function run() {
const config = {
version: core_1.getInput('expo-version') || 'latest',
packager: core_1.getInput('expo-packager') || 'yarn',
cache: (core_1.getInput('expo-cache') || 'false') === 'true',
cacheKey: core_1.getInput('expo-cache-key') || undefined,
};
// Resolve the exact requested Expo CLI version
config.version = await tools_1.resolveVersion(config.version);
const path = await core_1.group(config.cache
? `Installing Expo CLI (${config.version}) from cache or with ${config.packager}`
: `Installing Expo CLI (${config.version}) with ${config.packager}`, () => install_1.install(config));
core_1.addPath(path);
await core_1.group('Checking current authenticated account', () => tools_1.maybeAuthenticate({
token: core_1.getInput('expo-token') || undefined,
username: core_1.getInput('expo-username') || undefined,
password: core_1.getInput('expo-password') || undefined,
const expoVersion = await installCli('expo-cli');
const easVersion = await installCli('eas-cli');
await core_1.group('Checking current authenticated account', () => tools.maybeAuthenticate({
cli: expoVersion ? 'expo-cli' : easVersion ? 'eas-cli' : undefined,
token: core_1.getInput('token') || undefined,
username: core_1.getInput('username') || undefined,
password: core_1.getInput('password') || undefined,
}));
const shouldPatchWatchers = core_1.getInput('expo-patch-watchers') || 'true';
if (shouldPatchWatchers !== 'false') {
await core_1.group('Patching system watchers for the `ENOSPC` error', () => tools_1.maybePatchWatchers());
if (tools.getBoolean(core_1.getInput('patch-watchers'), true)) {
await core_1.group('Patching system watchers for the `ENOSPC` error', () => tools.maybePatchWatchers());
}
}
exports.run = run;
async function installCli(name) {
const shortName = tools.getBinaryName(name);
const inputVersion = core_1.getInput(`${shortName}-version`);
const packager = core_1.getInput('packager') || 'yarn';
if (!inputVersion) {
return core_1.info(`Skipping installation of ${name}, \`${shortName}-version\` not provided.`);
}
const version = await tools.resolveVersion(name, inputVersion);
const cache = tools.getBoolean(core_1.getInput(`${shortName}-cache`), false);
try {
const path = await core_1.group(cache
? `Installing ${name} (${version}) from cache or with ${packager}`
: `Installing ${name} (${version}) with ${packager}`, () => install_1.install({
packager, version, cache,
package: name,
cacheKey: core_1.getInput(`${shortName}-cache-key`) || undefined,
}));
core_1.addPath(path);
}
catch (error) {
tools.handleError(name, error);
}
return version;
}
/***/ }),
@@ -101170,8 +101226,8 @@ const os_1 = __importDefault(__webpack_require__(2087));
*
* @see https://github.com/actions/toolkit/issues/47
*/
async function fromLocalCache(version) {
return toolCache.find('expo-cli', version);
async function fromLocalCache(config) {
return toolCache.find(config.package, config.version);
}
exports.fromLocalCache = fromLocalCache;
/**
@@ -101180,18 +101236,18 @@ exports.fromLocalCache = fromLocalCache;
*
* @see https://github.com/actions/toolkit/issues/47
*/
async function toLocalCache(root, version) {
return toolCache.cacheDir(root, 'expo-cli', version);
async function toLocalCache(root, config) {
return toolCache.cacheDir(root, config.package, config.version);
}
exports.toLocalCache = toLocalCache;
/**
* Download the remotely stored `expo-cli` from cache, if any.
* Note, this cache is shared between jobs.
*/
async function fromRemoteCache(version, packager, customCacheKey) {
async function fromRemoteCache(config) {
// see: https://github.com/actions/toolkit/blob/8a4134761f09d0d97fb15f297705fd8644fef920/packages/tool-cache/src/tool-cache.ts#L401
const target = path_1.default.join(process.env['RUNNER_TOOL_CACHE'] || '', 'expo-cli', version, os_1.default.arch());
const cacheKey = customCacheKey || getRemoteKey(version, packager);
const target = path_1.default.join(process.env['RUNNER_TOOL_CACHE'] || '', config.package, config.version, os_1.default.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 cache_1.restoreCache([target], cacheKey);
@@ -101210,8 +101266,8 @@ exports.fromRemoteCache = fromRemoteCache;
* Store the root of `expo-cli` in the remote cache, for future reuse.
* Note, this cache is shared between jobs.
*/
async function toRemoteCache(source, version, packager, customCacheKey) {
const cacheKey = customCacheKey || getRemoteKey(version, packager);
async function toRemoteCache(source, config) {
const cacheKey = config.cacheKey || getRemoteKey(config);
try {
await cache_1.saveCache([source], cacheKey);
}
@@ -101225,8 +101281,8 @@ exports.toRemoteCache = toRemoteCache;
/**
* Get the cache key to use when (re)storing the Expo CLI from remote cache.
*/
function getRemoteKey(version, packager) {
return `expo-cli-${process.platform}-${os_1.default.arch()}-${packager}-${version}`;
function getRemoteKey(config) {
return `${config.package}-${process.platform}-${os_1.default.arch()}-${config.packager}-${config.version}`;
}
/**
* Handle any incoming errors from cache methods.
+1 -1
View File
@@ -1,7 +1,7 @@
{
"private": true,
"name": "expo-github-action",
"version": "5.5.1",
"version": "6.0.0",
"description": "Expo CLI in your GitHub Actions workflow",
"main": "build/index.js",
"repository": {
+15 -11
View File
@@ -4,14 +4,18 @@ import * as toolCache from '@actions/tool-cache';
import path from 'path';
import os from 'os';
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(version: string): Promise<string | undefined> {
return toolCache.find('expo-cli', version);
export async function fromLocalCache(config: CacheConfig): Promise<string | undefined> {
return toolCache.find(config.package, config.version);
}
/**
@@ -20,18 +24,18 @@ export async function fromLocalCache(version: string): Promise<string | undefine
*
* @see https://github.com/actions/toolkit/issues/47
*/
export async function toLocalCache(root: string, version: string): Promise<string> {
return toolCache.cacheDir(root, 'expo-cli', version);
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(version: string, packager: string, customCacheKey?: string): Promise<string | undefined> {
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'] || '', 'expo-cli', version, os.arch());
const cacheKey = customCacheKey || getRemoteKey(version, packager);
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.
@@ -50,8 +54,8 @@ export async function fromRemoteCache(version: string, packager: string, customC
* 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, version: string, packager: string, customCacheKey?: string): Promise<void> {
const cacheKey = customCacheKey || getRemoteKey(version, packager);
export async function toRemoteCache(source: string, config: CacheConfig): Promise<void> {
const cacheKey = config.cacheKey || getRemoteKey(config);
try {
await saveCache([source], cacheKey);
@@ -65,8 +69,8 @@ export async function toRemoteCache(source: string, version: string, packager: s
/**
* Get the cache key to use when (re)storing the Expo CLI from remote cache.
*/
function getRemoteKey(version: string, packager: string): string {
return `expo-cli-${process.platform}-${os.arch()}-${packager}-${version}`;
function getRemoteKey(config: Omit<CacheConfig, 'cacheKey'>): string {
return `${config.package}-${process.platform}-${os.arch()}-${config.packager}-${config.version}`;
}
/**
+1 -2
View File
@@ -1,4 +1,3 @@
import { run } from './run';
import { handleError } from './tools';
run().catch(handleError);
run();
+15 -8
View File
@@ -4,11 +4,18 @@ 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;
};
@@ -18,20 +25,20 @@ export type InstallConfig = {
* It returns the path where Expo is installed.
*/
export async function install(config: InstallConfig): Promise<string> {
let root: string | undefined = await fromLocalCache(config.version);
let root: string | undefined = await fromLocalCache(config);
if (!root && config.cache) {
root = await fromRemoteCache(config.version, config.packager, config.cacheKey);
root = await fromRemoteCache(config);
} else {
core.info('Skipping remote cache, not enabled...');
}
if (!root) {
root = await fromPackager(config.version, config.packager);
root = await toLocalCache(root, config.version);
root = await fromPackager(config);
root = await toLocalCache(root, config);
if (config.cache) {
await toRemoteCache(root, config.version, config.packager, config.cacheKey);
await toRemoteCache(root, config);
}
}
@@ -42,12 +49,12 @@ export async function install(config: InstallConfig): Promise<string> {
* Install `expo-cli`, by version, using npm or yarn.
* It creates a temporary directory to store all required files.
*/
export async function fromPackager(version: string, packager: string): Promise<string> {
export async function fromPackager(config: InstallConfig): Promise<string> {
const root = process.env['RUNNER_TEMP'] || '';
const tool = await io.which(packager);
const tool = await io.which(config.packager);
await io.mkdirP(root);
await cli.exec(tool, ['add', `expo-cli@${version}`], { cwd: root });
await cli.exec(tool, ['add', `${config.package}@${config.version}`], { cwd: root });
return root;
}
+44 -29
View File
@@ -1,43 +1,58 @@
import { addPath, getInput, group } from '@actions/core';
import { addPath, getInput, group, info } from '@actions/core';
import { install, InstallConfig } from './install';
import { maybeAuthenticate, maybePatchWatchers, resolveVersion } from './tools';
import { install } from './install';
import * as tools from './tools';
export async function run(): Promise<void> {
const config: InstallConfig = {
version: getInput('expo-version') || 'latest',
packager: getInput('expo-packager') || 'yarn',
cache: (getInput('expo-cache') || 'false') === 'true',
cacheKey: getInput('expo-cache-key') || undefined,
};
// Resolve the exact requested Expo CLI version
config.version = await resolveVersion(config.version);
const path = await group(
config.cache
? `Installing Expo CLI (${config.version}) from cache or with ${config.packager}`
: `Installing Expo CLI (${config.version}) with ${config.packager}`,
() => install(config),
);
addPath(path);
const expoVersion = await installCli('expo-cli');
const easVersion = await installCli('eas-cli');
await group(
'Checking current authenticated account',
() => maybeAuthenticate({
token: getInput('expo-token') || undefined,
username: getInput('expo-username') || undefined,
password: getInput('expo-password') || undefined,
() => tools.maybeAuthenticate({
cli: expoVersion ? 'expo-cli' : easVersion ? 'eas-cli' : undefined,
token: getInput('token') || undefined,
username: getInput('username') || undefined,
password: getInput('password') || undefined,
}),
);
const shouldPatchWatchers = getInput('expo-patch-watchers') || 'true';
if (shouldPatchWatchers !== 'false') {
if (tools.getBoolean(getInput('patch-watchers'), true)) {
await group(
'Patching system watchers for the `ENOSPC` error',
() => maybePatchWatchers(),
() => tools.maybePatchWatchers(),
);
}
}
async function installCli(name: tools.PackageName): Promise<string | void> {
const shortName = tools.getBinaryName(name);
const inputVersion = getInput(`${shortName}-version`);
const packager = getInput('packager') || 'yarn';
if (!inputVersion) {
return info(`Skipping installation of ${name}, \`${shortName}-version\` not provided.`);
}
const version = await tools.resolveVersion(name, inputVersion);
const cache = tools.getBoolean(getInput(`${shortName}-cache`), false);
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,
}),
);
addPath(path);
} catch (error) {
tools.handleError(name, error);
}
return version;
}
+47 -19
View File
@@ -5,19 +5,38 @@ import semver from 'semver';
// eslint-disable-next-line @typescript-eslint/no-var-requires
const registry = require('libnpm');
type AuthenticateOptions = {
export type PackageName = 'expo-cli' | 'eas-cli';
export type AuthenticateOptions = {
cli?: PackageName;
token?: string;
username?: string;
password?: string;
};
/**
* Get a boolean value from string, useful for Github Actions boolean inputs.
*/
export function getBoolean(value: string, defaultValue = false): boolean {
return (value.toLowerCase() || (defaultValue ? 'true' : 'false')) === 'true';
}
/**
* 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;
}
/**
* Resolve the provided semver to exact version of `expo-cli`.
* This uses the npm registry and accepts latest, dist-tags or version ranges.
* It's used to determine the cached version of `expo-cli`.
*/
export async function resolveVersion(version: string): Promise<string> {
return (await registry.manifest(`expo-cli@${version}`)).version;
export async function resolveVersion(name: PackageName, version: string): Promise<string> {
return (await registry.manifest(`${name}@${version}`)).version;
}
/**
@@ -25,27 +44,35 @@ export async function resolveVersion(version: string): Promise<string> {
* If both of them are set, token has priority.
*/
export async function maybeAuthenticate(options: AuthenticateOptions = {}): Promise<void> {
// github actions toolkit will handle commands with `.cmd` on windows, we need that
const bin = process.platform === 'win32' ? 'expo.cmd' : 'expo';
if (options.token) {
await cli.exec(bin, ['whoami'], {
env: { ...process.env, EXPO_TOKEN: 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.username || !options.password) {
return core.info('Skipping authentication: `expo-username` and/or `expo-password` not set...');
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 },
});
return;
}
core.info('Skipping authentication: `expo-token`, `expo-username`, and/or `expo-password` not set...');
core.info('Skipping authentication: `token`, `username`, and/or `password` not set...');
}
/**
@@ -79,13 +106,14 @@ export async function maybePatchWatchers(): Promise<void> {
* 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(): Promise<void> {
const latest = await resolveVersion('latest');
const current = await resolveVersion(core.getInput('expo-version') || 'latest');
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 "expo-version: ${semver.major(latest)}.x"`);
core.warning(`If you run into issues, try upgrading your workflow to "${binaryName}-version: ${semver.major(latest)}.x"`);
}
}
@@ -93,9 +121,9 @@ export async function maybeWarnForUpdate(): Promise<void> {
* 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(error: Error) {
export async function handleError(name: PackageName, error: Error) {
try {
await maybeWarnForUpdate();
await maybeWarnForUpdate(name);
} catch {
// If this fails, ignore it
}
+39 -21
View File
@@ -7,29 +7,29 @@ import * as toolCache from '@actions/tool-cache';
import * as cache from '../src/cache';
import * as utils from './utils';
describe('fromLocalCache', () => {
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('3.20.1');
const result = await cache.fromLocalCache({ package: 'eas-cli', version: '4.2.0', packager: 'npm' });
expect(result).toBe(path);
expect(find).toBeCalledWith('expo-cli', '3.20.1');
expect(find).toBeCalledWith('eas-cli', '4.2.0');
});
});
describe('toLocalCache', () => {
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, '3.20.1');
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', '3.20.1');
expect(cacheDir).toBeCalledWith(root, 'expo-cli', '4.2.0');
});
});
describe('fromRemoteCache', () => {
describe(cache.fromRemoteCache, () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
@@ -50,7 +50,7 @@ describe('fromRemoteCache', () => {
});
it('restores remote cache with default key', async () => {
expect(await cache.fromRemoteCache('3.20.1', 'yarn')).toBeUndefined();
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`,
@@ -58,36 +58,45 @@ describe('fromRemoteCache', () => {
});
it('restores remote cache with custom key', async () => {
expect(await cache.fromRemoteCache('3.20.0', 'yarn', 'custom-cache-key')).toBeUndefined();
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', 'expo-cli', '3.20.0', os.arch())],
[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);
await expect(cache.fromRemoteCache('3.20.1', 'npm')).resolves.toBe(
join('cache', 'path', 'expo-cli', '3.20.1', os.arch())
);
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('3.20.1', 'yarn')).rejects.toBe(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);
await expect(cache.fromRemoteCache('3.20.1', 'yarn')).resolves.toBeUndefined();
expect(
await cache.fromRemoteCache({ package: 'expo-cli', version: '3.20.1', packager: 'yarn' })
).toBeUndefined();
expect(spy.warning).toHaveBeenCalledWith(expect.stringContaining('Skipping remote cache'));
});
});
describe('toRemoteCache', () => {
describe(cache.toRemoteCache, () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
@@ -103,29 +112,38 @@ describe('toRemoteCache', () => {
});
it('saves remote cache with default key', async () => {
expect(await cache.toRemoteCache(join('local', 'path'), '3.20.1', 'npm')).toBeUndefined();
expect(await cache.toRemoteCache(join('local', 'path'), { package: 'eas-cli', version: '3.20.1', packager: 'npm' })).toBeUndefined();
expect(remoteCache.saveCache).toBeCalledWith(
[join('local', 'path')],
`expo-cli-${process.platform}-${os.arch()}-npm-3.20.1`
`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'), '3.20.1', 'yarn', 'custom-cache-key')).toBeUndefined();
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'), '3.20.1', 'yarn')).rejects.toBe(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'), '3.20.1', 'yarn')).resolves.toBeUndefined();
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'));
});
});
+11 -11
View File
@@ -19,7 +19,7 @@ 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({ version: '3.0.10', packager: 'npm' });
const expoPath = await install.install({ package: 'expo-cli', version: '3.0.10', packager: 'npm' });
expect(expoPath).toBe(join('cache', 'path', 'node_modules', '.bin'));
});
@@ -27,18 +27,18 @@ describe('install', () => {
utils.setEnv('RUNNER_TEMP', join('temp', 'path'));
cache.fromLocalCache.mockResolvedValue(undefined);
cache.toLocalCache.mockResolvedValue(join('cache', 'path'));
const expoPath = await install.install({ version: '3.0.10', packager: 'npm' });
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'), '3.0.10');
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({ version: '3.20.1', packager: 'npm', cache: true });
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('3.20.1', 'npm', undefined);
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 () => {
@@ -46,22 +46,22 @@ describe('install', () => {
cache.fromLocalCache.mockResolvedValue(undefined);
cache.fromRemoteCache.mockResolvedValue(undefined);
cache.toLocalCache.mockResolvedValue(join('cache', 'path'));
const expoPath = await install.install({ version: '3.20.1', packager: 'npm', cache: true });
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'), '3.20.1', 'npm', undefined);
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('3.0.10', 'npm');
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('latest', 'yarn');
await install.fromPackager({ package: 'eas-cli', version: 'latest', packager: 'yarn' });
expect(io.mkdirP).toBeCalledWith(join('temp', 'path'));
utils.restoreEnv();
});
@@ -69,11 +69,11 @@ describe('fromPackager', () => {
it('installs expo with tool', async () => {
utils.setEnv('RUNNER_TEMP', join('temp', 'path'));
io.which.mockResolvedValue('npm');
const expoPath = await install.fromPackager('beta', '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', 'expo-cli@beta']);
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();
});
+127 -59
View File
@@ -1,12 +1,15 @@
const core = {
addPath: jest.fn(),
getInput: jest.fn(),
group: (message: string, action: () => Promise<any>) => action()
group: (message: string, action: () => Promise<any>) => action(),
info: jest.fn(),
};
const exec = { exec: jest.fn() };
const install = { install: jest.fn() };
const tools = {
resolveVersion: jest.fn(v => v),
getBoolean: jest.fn((v, d) => v ? v === 'true' : d),
getBinaryName: jest.fn(v => v.replace('-cli', '')),
resolveVersion: jest.fn((n, v) => v),
maybeAuthenticate: jest.fn(),
maybePatchWatchers: jest.fn(),
};
@@ -18,64 +21,7 @@ jest.mock('../src/install', () => install);
import { run } from '../src/run';
interface MockInputProps {
version?: string;
packager?: string;
token?: string;
username?: string;
password?: string;
patchWatchers?: string;
cache?: string;
cacheKey?: string;
}
const mockInput = (props: MockInputProps = {}) => {
// fix: kind of dirty workaround for missing "mock 'value' based on arguments"
const input = (name: string) => {
switch (name) {
case 'expo-version':
return props.version || '';
case 'expo-packager':
return props.packager || '';
case 'expo-token':
return props.token || '';
case 'expo-username':
return props.username || '';
case 'expo-password':
return props.password || '';
case 'expo-patch-watchers':
return props.patchWatchers || '';
case 'expo-cache':
return props.cache || '';
case 'expo-cache-key':
return props.cacheKey || '';
default:
return '';
}
};
// eslint-disable-next-line @typescript-eslint/no-explicit-any
core.getInput = input as any;
};
describe('run', () => {
it('installs latest expo-cli with yarn by default', async () => {
await run();
expect(install.install).toBeCalledWith({ version: 'latest', packager: 'yarn', cache: false });
});
it('installs provided version expo-cli with npm', async () => {
mockInput({ version: '3.0.10', packager: 'npm' });
await run();
expect(install.install).toBeCalledWith({ version: '3.0.10', packager: 'npm', cache: false });
});
it('installs path to global path', async () => {
install.install.mockResolvedValue('/expo/install/path');
await run();
expect(core.addPath).toBeCalledWith('/expo/install/path');
});
it('patches the system when set to true', async () => {
mockInput({ patchWatchers: 'true' });
await run();
@@ -105,4 +51,126 @@ describe('run', () => {
await run();
expect(tools.maybeAuthenticate).toBeCalledWith({ token: 'ABC123' });
});
['expo', 'eas'].forEach(cliName => {
const packageName = `${cliName}-cli`;
describe(packageName, () => {
it(`skips installation without \`${cliName}-version\``, async () => {
mockInput();
await run();
expect(install.install).not.toBeCalledWith({ package: packageName });
});
it('installs with yarn by default', async () => {
mockInput({ [`${cliName}Version`]: 'latest' });
await run();
expect(install.install).toBeCalledWith({
package:
packageName,
version: 'latest',
packager: 'yarn',
cache: false,
});
});
it('installs provided version with npm', async () => {
mockInput({ [`${cliName}Version`]: '3.0.10', packager: 'npm' });
await run();
expect(install.install).toBeCalledWith({
package: packageName,
version: '3.0.10',
packager: 'npm',
cache: false,
});
});
it('installs with yarn and cache enabled', async () => {
mockInput({
packager: 'yarn',
[`${cliName}Version`]: '4.2.0',
[`${cliName}Cache`]: 'true',
});
await run();
expect(install.install).toBeCalledWith({
package: packageName,
version: '4.2.0',
packager: 'yarn',
cache: true,
});
});
it('installs with yarn and custom cache key', async () => {
mockInput({
packager: 'yarn',
[`${cliName}Version`]: '4.2.0',
[`${cliName}Cache`]: 'true',
[`${cliName}CacheKey`]: 'custom-key'
});
await run();
expect(install.install).toBeCalledWith({
package: packageName,
version: '4.2.0',
packager: 'yarn',
cache: true,
cacheKey: 'custom-key',
});
});
it('installs path to global path', async () => {
install.install.mockResolvedValue(`/${cliName}/install/path`);
await run();
expect(core.addPath).toBeCalledWith(`/${cliName}/install/path`);
});
});
});
});
interface MockInputProps {
expoVersion?: string;
expoCache?: string;
expoCacheKey?: string;
easVersion?: string;
easCache?: string;
easCacheKey?: string;
packager?: string;
token?: string;
username?: string;
password?: string;
patchWatchers?: string;
}
function mockInput(props: MockInputProps = {}) {
// fix: kind of dirty workaround for missing "mock 'value' based on arguments"
const input = (name: string) => {
switch (name) {
case 'expo-version':
return props.expoVersion || '';
case 'expo-cache':
return props.expoCache || '';
case 'expo-cache-key':
return props.expoCacheKey || '';
case 'eas-version':
return props.easVersion || '';
case 'eas-cache':
return props.easCache || '';
case 'eas-cache-key':
return props.easCacheKey || '';
case 'packager':
return props.packager || '';
case 'token':
return props.token || '';
case 'username':
return props.username || '';
case 'password':
return props.password || '';
case 'patch-watchers':
return props.patchWatchers || '';
default:
return '';
}
};
// eslint-disable-next-line @typescript-eslint/no-explicit-any
core.getInput = input as any;
}
+90 -28
View File
@@ -7,15 +7,57 @@ import * as cli from '@actions/exec';
import * as tools from '../src/tools';
import * as utils from './utils';
describe('resolveVersion', () => {
it('fetches exact version of expo-cli', async () => {
registry.manifest.mockResolvedValue({ version: '3.0.10' });
expect(await tools.resolveVersion('latest')).toBe('3.0.10');
expect(registry.manifest).toBeCalledWith('expo-cli@latest');
describe(tools.getBoolean, () => {
it('rreturns false for empty strings by default', () => {
expect(tools.getBoolean('')).toBeFalsy();
});
it('returns true for empty strings with default set to true', () => {
expect(tools.getBoolean('', true)).toBeTruthy();
});
it('returns true for `true` strings by default', () => {
expect(tools.getBoolean('true')).toBeTruthy();
});
it('returns false for `false` strings with default set to false', () => {
expect(tools.getBoolean('false', false)).toBeFalsy();
});
it('returns false for `false` strings with default set to true', () => {
expect(tools.getBoolean('false', true)).toBeFalsy();
});
});
describe('maybeAuthenticate', () => {
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.resolveVersion, () => {
it('fetches exact version of expo-cli', async () => {
registry.manifest.mockResolvedValue({ version: '3.0.10' });
expect(await tools.resolveVersion('expo-cli', 'latest')).toBe('3.0.10');
expect(registry.manifest).toBeCalledWith('expo-cli@latest');
});
it('fetches exact version of eas-cli', async () => {
registry.manifest.mockResolvedValue({ version: '4.2.0' });
expect(await tools.resolveVersion('eas-cli', 'latest')).toBe('4.2.0');
expect(registry.manifest).toBeCalledWith('eas-cli@latest');
});
});
describe(tools.maybeAuthenticate, () => {
const token = 'ABC123';
const username = 'bycedric';
const password = 'mypassword';
@@ -45,7 +87,7 @@ describe('maybeAuthenticate', () => {
it('executes whoami command with token through environment', async () => {
utils.setEnv('TEST_INCLUDED', 'hellyeah');
await tools.maybeAuthenticate({ token });
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({
@@ -60,28 +102,34 @@ describe('maybeAuthenticate', () => {
it('fails when token is incorrect', async () => {
const error = new Error('Not logged in');
spy.exec.mockRejectedValue(error);
await expect(tools.maybeAuthenticate({ token })).rejects.toBe(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 });
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 `expo` on ubuntu', async () => {
it('executes whoami command with `eas` on ubuntu', async () => {
utils.setPlatform('linux');
await tools.maybeAuthenticate({ token });
await tools.maybeAuthenticate({ token, cli: 'eas-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('expo');
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 });
await tools.maybeAuthenticate({ token, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('expo.cmd');
utils.restorePlatform();
@@ -95,29 +143,43 @@ describe('maybeAuthenticate', () => {
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();
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 });
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 })
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({
@@ -132,14 +194,14 @@ describe('maybeAuthenticate', () => {
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 }))
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 });
await tools.maybeAuthenticate({ username, password, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('expo');
utils.restorePlatform();
@@ -147,7 +209,7 @@ describe('maybeAuthenticate', () => {
it('executes login command with `expo` on ubuntu', async () => {
utils.setPlatform('linux');
await tools.maybeAuthenticate({ username, password });
await tools.maybeAuthenticate({ username, password, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('expo');
utils.restorePlatform();
@@ -155,7 +217,7 @@ describe('maybeAuthenticate', () => {
it('executes login command with `expo.cmd` on windows', async () => {
utils.setPlatform('win32');
await tools.maybeAuthenticate({ username, password });
await tools.maybeAuthenticate({ username, password, cli: 'expo-cli' });
expect(spy.exec).toBeCalled();
expect(spy.exec.mock.calls[0][0]).toBe('expo.cmd');
utils.restorePlatform();
@@ -163,7 +225,7 @@ describe('maybeAuthenticate', () => {
});
});
describe('maybePatchWatchers', () => {
describe(tools.maybePatchWatchers, () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
@@ -226,7 +288,7 @@ describe('maybePatchWatchers', () => {
});
});
describe('maybeWarnForUpdate', () => {
describe(tools.maybeWarnForUpdate, () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
@@ -241,7 +303,7 @@ describe('maybeWarnForUpdate', () => {
registry.manifest
.mockResolvedValueOnce({ version: '4.1.0' })
.mockResolvedValueOnce({ version: '4.0.1'});
await tools.maybeWarnForUpdate();
await tools.maybeWarnForUpdate('eas-cli');
expect(spy.warning).not.toBeCalled();
})
@@ -249,13 +311,13 @@ describe('maybeWarnForUpdate', () => {
registry.manifest
.mockResolvedValueOnce({ version: '4.1.0' })
.mockResolvedValueOnce({ version: '3.0.1'});
await tools.maybeWarnForUpdate();
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('handleError', () => {
describe(tools.handleError, () => {
let spy: { [key: string]: jest.SpyInstance } = {};
beforeEach(() => {
@@ -266,17 +328,17 @@ describe('handleError', () => {
spy.setFailed.mockRestore();
});
it('marks the job as failed', async () => {
it('marks the job as failed with expo-cli', async () => {
const error = new Error('test');
registry.manifest.mockResolvedValue('4.0.0');
await tools.handleError(error);
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');
registry.manifest.mockRejectedValue(new Error('npm issue'));
await tools.handleError(error);
await tools.handleError('eas-cli', error);
expect(core.setFailed).toBeCalledWith(error);
});
});