2020-03-20 20:28:31 +00:00
|
|
|
import { expect } from 'chai';
|
|
|
|
import * as cp from 'child_process';
|
|
|
|
import * as https from 'https';
|
|
|
|
import * as http from 'http';
|
|
|
|
import * as net from 'net';
|
|
|
|
import * as fs from 'fs';
|
|
|
|
import * as path from 'path';
|
2020-07-01 19:14:38 +00:00
|
|
|
import { promisify } from 'util';
|
2020-04-07 00:04:09 +00:00
|
|
|
import { app, BrowserWindow, Menu, session } from 'electron/main';
|
2020-03-20 20:28:31 +00:00
|
|
|
import { emittedOnce } from './events-helpers';
|
|
|
|
import { closeWindow, closeAllWindows } from './window-helpers';
|
2020-05-20 20:18:48 +00:00
|
|
|
import { ifdescribe, ifit } from './spec-helpers';
|
2019-11-01 20:37:02 +00:00
|
|
|
import split = require('split')
|
2019-10-14 20:49:21 +00:00
|
|
|
|
2020-06-23 03:32:45 +00:00
|
|
|
const features = process._linkedBinding('electron_common_features');
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const fixturesPath = path.resolve(__dirname, '../spec/fixtures');
|
2018-04-20 07:09:23 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('electron module', () => {
|
|
|
|
it('does not expose internal modules to require', () => {
|
2018-06-14 16:44:27 +00:00
|
|
|
expect(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
require('clipboard');
|
|
|
|
}).to.throw(/Cannot find module 'clipboard'/);
|
|
|
|
});
|
2016-05-23 20:12:02 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('require("electron")', () => {
|
2019-03-10 22:38:44 +00:00
|
|
|
it('always returns the internal electron module', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
require('electron');
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('app module', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
let server: https.Server;
|
|
|
|
let secureUrl: string;
|
|
|
|
const certPath = path.join(fixturesPath, 'certificates');
|
2016-12-02 17:34:16 +00:00
|
|
|
|
2018-03-07 05:40:27 +00:00
|
|
|
before((done) => {
|
2016-12-02 17:34:16 +00:00
|
|
|
const options = {
|
|
|
|
key: fs.readFileSync(path.join(certPath, 'server.key')),
|
|
|
|
cert: fs.readFileSync(path.join(certPath, 'server.pem')),
|
|
|
|
ca: [
|
|
|
|
fs.readFileSync(path.join(certPath, 'rootCA.pem')),
|
|
|
|
fs.readFileSync(path.join(certPath, 'intermediateCA.pem'))
|
|
|
|
],
|
|
|
|
requestCert: true,
|
|
|
|
rejectUnauthorized: false
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|
2016-12-02 17:34:16 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
server = https.createServer(options, (req, res) => {
|
2019-03-10 22:38:44 +00:00
|
|
|
if ((req as any).client.authorized) {
|
2020-03-20 20:28:31 +00:00
|
|
|
res.writeHead(200);
|
|
|
|
res.end('<title>authorized</title>');
|
2016-12-02 17:34:16 +00:00
|
|
|
} else {
|
2020-03-20 20:28:31 +00:00
|
|
|
res.writeHead(401);
|
|
|
|
res.end('<title>denied</title>');
|
2016-12-02 17:34:16 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-12-02 17:34:16 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
server.listen(0, '127.0.0.1', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const port = (server.address() as net.AddressInfo).port;
|
|
|
|
secureUrl = `https://127.0.0.1:${port}`;
|
|
|
|
done();
|
|
|
|
});
|
|
|
|
});
|
2016-12-02 17:34:16 +00:00
|
|
|
|
2018-06-14 16:44:27 +00:00
|
|
|
after(done => {
|
2020-03-20 20:28:31 +00:00
|
|
|
server.close(() => done());
|
|
|
|
});
|
2016-12-02 17:34:16 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('app.getVersion()', () => {
|
|
|
|
it('returns the version field of package.json', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getVersion()).to.equal('0.1.0');
|
|
|
|
});
|
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('app.setVersion(version)', () => {
|
|
|
|
it('overrides the version', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getVersion()).to.equal('0.1.0');
|
|
|
|
app.setVersion('test-version');
|
2018-06-14 16:44:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getVersion()).to.equal('test-version');
|
|
|
|
app.setVersion('0.1.0');
|
|
|
|
});
|
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2020-03-18 17:06:41 +00:00
|
|
|
describe('app name APIs', () => {
|
|
|
|
it('with properties', () => {
|
|
|
|
it('returns the name field of package.json', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.name).to.equal('Electron Test Main');
|
|
|
|
});
|
2019-04-30 20:55:33 +00:00
|
|
|
|
2020-03-18 17:06:41 +00:00
|
|
|
it('overrides the name', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.name).to.equal('Electron Test Main');
|
|
|
|
app.name = 'test-name';
|
2019-04-30 20:55:33 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.name).to.equal('test-name');
|
|
|
|
app.name = 'Electron Test Main';
|
|
|
|
});
|
|
|
|
});
|
2019-04-30 20:55:33 +00:00
|
|
|
|
2020-03-18 17:06:41 +00:00
|
|
|
it('with functions', () => {
|
|
|
|
it('returns the name field of package.json', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getName()).to.equal('Electron Test Main');
|
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2020-03-18 17:06:41 +00:00
|
|
|
it('overrides the name', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getName()).to.equal('Electron Test Main');
|
|
|
|
app.setName('test-name');
|
2018-06-14 16:44:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getName()).to.equal('test-name');
|
|
|
|
app.setName('Electron Test Main');
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('app.getLocale()', () => {
|
|
|
|
it('should not be empty', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getLocale()).to.not.equal('');
|
|
|
|
});
|
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2018-11-20 20:33:23 +00:00
|
|
|
describe('app.getLocaleCountryCode()', () => {
|
|
|
|
it('should be empty or have length of two', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
let expectedLength = 2;
|
chore: bump chromium to 92.0.4475.0 (master) (#28462)
* chore: bump chromium in DEPS to 91.0.4464.0
* chore: rebuild chromium/dcheck.patch with import-patches -3
Mechanical only; no code changes
* chore: remove content_browser_main_loop.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2725153
The function being patched (BrowserMainLoop::MainMessageLoopRun()) no
longer exists.
NB: if removing this introduces regressions the likely fix will be to
add a similar patch for ShellBrowserMainParts::WillRunMainMessageLoop()
which has similar code and was added at the same time this was removed.
* chore: rebuild chromium/put_back_deleted_colors_for_autofill.patch with import-patches -3
Mechanical only; no code changes
* chore: rebuild chromium/disable_color_correct_rendering.patch with import-patches -3
Mechanical only; no code changes
* chore: rebuild chromium/eat_allow_disabling_blink_scheduler_throttling_per_renderview.patch with patch
Mechanical only; no code changes
* chore: rebuild chromium/gpu_notify_when_dxdiag_request_fails.patch with import-patches -3
Mechanical only; no code changes
* chore: rebuild chromium/ui_gtk_public_header.patch manually
no code changes
* chore: rebuild chromium/web_contents.patch with import-patches -3
Mechanical only; no code changes
* chore: remove v8/skip_global_registration_of_shared_arraybuffer_backing_stores.patch
Refs: https://chromium-review.googlesource.com/c/v8/v8/+/2763874
This patch has been merged upstream
* chore: export patches
* chore: update add_trustedauthclient_to_urlloaderfactory.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2757969
Sync with removal of render_frame_id_
* chore: sync chromium/put_back_deleted_colors_for_autofill.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2785841
SkColorFromColorId() no longer takes theme, scheme args
* chore: sync chromium/put_back_deleted_colors_for_autofill.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2772143
Change new calls to GetDarkSchemeColor to fit our patched call signature
* chore: update add_trustedauthclient_to_urlloaderfactory.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2757969
Sync with removal of render_frame_id_ in our mojom
* chore: update chromium/frame_host_manager.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2740008
UrlInfo ctor now takes UrlInfo::OriginIsolationRequest instead of a bool
* chore: update chromium/revert_remove_contentrendererclient_shouldfork.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2755314
Upstream has removed `history_list_length_` which we were comparing to 0
to calculate our `is_initial_navigation` bool when calling ShouldFork().
ShouldFork() is ours and none of the code paths actually use that param,
so this commit removes it altogether.
* chore: update permissions_to_register
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2789074
Replace all uses of APIPermission::ID enum with Mojo type
* refactor: update return type of PreMainMessageLoopRun()
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2725153
Used to return void; now returns an int errorcode.
Note: 2725153 also has some nice doc updates about Browser's "stages"
* refactor: sync ElectronBrowserMainParts to MainParts changes
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2725153
RunMainMessageLoopParts has been replaced with WillRunMainMessageLoop
so `BrowserMainLoop::result_code_` is no longer available to us for our
exit_code_ pointer.
This variable held a dual role: (1) of course, hold the exit code, but
also (2) was a nullptr before the message loop was ready, indicating to
anyone calling SetExitCode() that we were still in startup and could
just exit() without any extra steps. exit_code_ still fulfills these two
roles but is now a base::Optional.
* chore: update ElectronBrowserMainParts::PreDefaultMainMessageLoopRun
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2725153
BrowserMainParts::BrowsePreDefaultMainMesssageLoopRun() has been
removed; move that work to the new WillRunMainMessageLoop().
* refactor: stop using CallbackList; it has been removed.
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2785973
* refactor: update use of threadpools.
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2773408
The upstream code is still in flux (e.g. reverts and re-lands) but the
tl;dr for this commit is (1) include thread_pool.h if you're using it
and (2) don't instantiate pools directly.
* refactor: remove routing_id from CreateLoaderAndStart
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2762858
NB: One logic branch in ProxyingURLLoaderFactory::CreateLoaderAndStart
calls std::make_unique<InProgressRequest>, which needs a routing_id.
This PR uses the member field `routing_id_` since there's no longer one
being passed into CreateLoaderAndStart.
* refactor: sync to upstream ParittionOptions churn
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2771318
PartitionOptions' enums have changed.
* refactor: update Manifest::Location usage
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2771320
tldr: s/Manifest::FOO/ManifestLocation::kFoo/
* chore: bump chromium in DEPS to 91.0.4465.0
* update patches
* refactor: update extensions::Manifest to upstream
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2771320
- extensions::Manifest::COMPONENT
+ extensions::mojom::ManifestLocation::kExternalComponent
* refactor: sync with upstream UrlInfo ctor changes
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2740008
UrlInfo ctor now takes UrlInfo::OriginIsolationRequest instead of a bool
* chore: update invocation of convert_protocol_to_json.py
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2792623
python3 is being used in parts of the upstream build, but the copy of
convert_protocol_to_json.py invoked in v8/third_party/inspector_protocol
is not python3-friendly. Node has a py2+3-friendly version of it in its
tools directory, so call it instead.
* chore: use extensions::mojom::APIPermissionID
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2791122
tldr:
- extensions::APIPermission::kFoo
+ extensions::mojom::APIPermissionID::kFoo
* chore: Remove support for TLS1.0/1.1 in SSLVersionMin policy
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2765737
Remove TLS v1.0 & 1.1 from our SSLProtocolVersionFromString() function.
This is the same change made upstream at
https://chromium-review.googlesource.com/c/chromium/src/+/2765737/8/chrome/browser/ssl/ssl_config_service_manager_pref.cc
* fixup! chore: update ElectronBrowserMainParts::PreDefaultMainMessageLoopRun
* chore: Use IDType for permission change subscriptions.
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2791431
tldr: {Subscribe,Unsubscribe}PermissionStatusChange's tag type used to
be an int; now it's the new SubscriptionId type (which is an IdType64).
* chore: sync PowerMonitor code to upstream refactor
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2752635
tldr: PowerMonitor has been split into PowerStateObserver,
PowerSuspendObserver, and PowerThermalObserver to reduce number of tasks
posted to consumers who only need notifications for one of those things
instead of all of them.
* chore: use PartitionOptions's new Cookies field
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2771318
* Revert "refactor: remove routing_id from CreateLoaderAndStart"
This reverts commit 8c9773b87a3c84f9073a47089eb2b6889d745245.
8c9773b was only a partial fix; reverting to start & try again.
* update patches
* chore: bump chromium in DEPS to 91.0.4466.0
* chore: update chromium/accelerator.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2795472
tldr: sync patch with upstream renamed variable & macro names.
* chore: update chromium/gtk_visibility.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2796200
tldr: no code changes; just updating the diff to apply cleanly.
note: ooh upstream Wayland hacking!
* chore: update chromium/picture-in-picture.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2710023
tldr: no code changes; just updating the diff to apply cleanly.
* chore: update chromium/worker_feat_add_hook_to_notify_script_ready.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2775573
tldr: no code changes; just updating the diff to apply cleanly.
* chore: export_all_patches
* chore: update chromium/feat_add_set_theme_source_to_allow_apps_to.patch
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2796511
tldr: NotifyObservers has been renamed to NotifyOnNativeThemeUpdated,
so update the invocation in our patch.
* chore: update ElectronBrowserClient w/upstream API
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2797454
tldr: GetDevToolsManagerDelegate() was returning an owned raw pointer.
Replaced it with CreateDevToolsManagerDelegate() which uses unique_ptr<>.
* chore: handle new content::PermissionType::FILE_HANDLING in toV8()
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2762201
`file-handling` string confirmed in https://chromium-review.googlesource.com/c/chromium/src/+/2762201/18/chrome/browser/ui/webui/settings/site_settings_helper.cc
* refactor: remove routing_id from CreateLoaderAndStart pt 1
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2762858
Part 1: the easiest ones
* 2796724: Support Python3
https://chromium-review.googlesource.com/c/infra/luci/python-adb/+/2796724
* chore: bump chromium in DEPS to 91.0.4468.0
* 2668974: WebShare: Implement SharingServicePicker
https://chromium-review.googlesource.com/c/chromium/src/+/2668974
* 2802766: Apply modernize-make-unique to media/
https://chromium-review.googlesource.com/c/chromium/src/+/2802766
* 2802823: Apply modernize-make-unique to gpu/
https://chromium-review.googlesource.com/c/chromium/src/+/2802823
* 2803041: Apply modernize-make-unique to remaining files
https://chromium-review.googlesource.com/c/chromium/src/+/2803041
* 2798873: Convert GtkKeyBindingsHandler build checks to runtime checks
https://chromium-review.googlesource.com/c/chromium/src/+/2798873
* 2733595: [ch-r] Parse ACCEPT_CH H2/3 frame and restart with new headers if needed
https://chromium-review.googlesource.com/c/chromium/src/+/2733595
* chore: update patch indices
* 2795107: Remove unused PermissionRequest IDs.
https://chromium-review.googlesource.com/c/chromium/src/+/2795107
* chore: bump chromium in DEPS to 91.0.4469.0
* chore: fixup patch indices
* chore: bump chromium in DEPS to 91.0.4469.5
* PiP 1.5: Add microphone, camera, and hang up buttons to the PiP window
https://chromium-review.googlesource.com/c/chromium/src/+/2710023
* fixup! refactor: remove routing_id from CreateLoaderAndStart
* refactor: use URLLoaderNetworkServiceObserver for auth requests from SimpleURLLoader
* fixup! chore: fixup patch indices
* 2724817: Expand scope of wasm-eval to all URLs
https://chromium-review.googlesource.com/c/chromium/src/+/2724817
* Fixup patch after rebase
* chore: bump chromium in DEPS to 91.0.4472.0
* 2797341: [ozone/x11] Enabled the global shortcut listener.
https://chromium-review.googlesource.com/c/chromium/src/+/2797341
* 2805553: Reland Add GTK ColorMixers to ColorPipeline P1
https://chromium-review.googlesource.com/c/chromium/src/+/2805553
* 2804366: PiP 1.5: Label back to tab button with origin and center it
https://chromium-review.googlesource.com/c/chromium/src/+/2804366
* 2784730: Fix crash on AX mode change in NativeViewHost without a Widget
https://chromium-review.googlesource.com/c/chromium/src/+/2784730
* chore: update patch indices
* 2810174: Add PdfAnnotationsEnabled policy.
https://chromium-review.googlesource.com/c/chromium/src/+/2810174
* 2807829: Allow capturers to indicate if they want a WakeLock or not.
https://chromium-review.googlesource.com/c/chromium/src/+/2807829
* chore: bump chromium in DEPS to 92.0.4473.0
* chore: bump chromium in DEPS to 92.0.4474.0
* chore: bump chromium in DEPS to 92.0.4475.0
* chore: update patches
* chore: updates patches
* chore: update is_media_key patch to handle new ozone impl
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2797341
* fix: ExecuteJavascript requests now need to be flagged as non-bf-aware
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2787195
* chore: icon_util_x11 is now icon_util_linux
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2791362
* build: update sysroots
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2628496
* build: fix missing symbols on linux build
* use_ozone and use_x11 are not exclusive
* new button view to build for pip
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2797341
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2804366
* chore: fix broken gtk_util color patch
* chore: remove patch conflict
* build: update linux manifests
* chore: build bttlb on all platforms for pip
* chore: add thread_pool include for views delegate win
* chore: fix lint
* chore: add node patches for V8 changes
* build: add missing base include on windows
* fix: update frame host manager patch for new state transitions
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2714464
* chore: update windows zip manifests
* chore: update mac zip manifests
* chore: fix patch linting
* refactor: implement missing URLLoaderNetworkServiceObserver methods
It is against The Mojo Rules to leave hanging callbacks. These always
have to be called.
Refs: https://github.com/electron/electron/commit/186528aab9f8e29d658f07d220bb7f627980edda
* spec: fix locale test on local linux
* fix: pass the exit code correctly in new PreMainMessageLoopRun
Refs: https://github.com/electron/electron/commit/2622e91c4493ceb032e2f80cb484885bb8f97475
* fix: ensure we early-exit when request_handler_ is not provided
Refs: https://github.com/electron/electron/commit/93077afbfb6db248a0c0cc447d7ad2c9ccfda1d5
* fix: strongly set result_code in the BrowserMainLoop
* fix: invalid usage of non-targetted PostTask
You must always either use a host threadpool or specify a target
thread. In this case we did neither after this refactor.
Refs: https://github.com/electron/electron/pull/28462/commits/4e33ee0ad35a710bd34641cb0376bdee6aea2d1f
* chore: fix gn check
* chore: remove stray .rej files in patch
* chore: add mojo error code to url loader failure
* build: ensure CI is truthy in arm test env
* fix: handle windowCaptureMacV2 being enabled when fetching media source id
Refs: https://chromium-review.googlesource.com/c/chromium/src/+/2709931
Co-authored-by: Charles Kerr <charles@charleskerr.com>
Co-authored-by: Shelley Vohr <shelley.vohr@gmail.com>
Co-authored-by: deepak1556 <hop2deep@gmail.com>
Co-authored-by: Samuel Attard <samuel.r.attard@gmail.com>
Co-authored-by: Samuel Attard <sattard@slack-corp.com>
2021-04-15 17:44:35 +00:00
|
|
|
if (process.platform === 'linux' && process.env.CI) {
|
2018-11-20 20:33:23 +00:00
|
|
|
// Linux CI machines have no locale.
|
2020-03-20 20:28:31 +00:00
|
|
|
expectedLength = 0;
|
2018-11-20 20:33:23 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getLocaleCountryCode()).to.be.a('string').and.have.lengthOf(expectedLength);
|
|
|
|
});
|
|
|
|
});
|
2018-11-20 20:33:23 +00:00
|
|
|
|
2018-05-08 06:15:31 +00:00
|
|
|
describe('app.isPackaged', () => {
|
|
|
|
it('should be false durings tests', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.isPackaged).to.equal(false);
|
|
|
|
});
|
|
|
|
});
|
2018-05-08 06:15:31 +00:00
|
|
|
|
2019-10-30 23:38:21 +00:00
|
|
|
ifdescribe(process.platform === 'darwin')('app.isInApplicationsFolder()', () => {
|
2017-10-27 20:45:58 +00:00
|
|
|
it('should be false during tests', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.isInApplicationsFolder()).to.equal(false);
|
|
|
|
});
|
|
|
|
});
|
2017-08-31 14:37:12 +00:00
|
|
|
|
2021-04-09 07:09:17 +00:00
|
|
|
describe('app.exit(exitCode)', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
let appProcess: cp.ChildProcess | null = null;
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
afterEach(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
if (appProcess) appProcess.kill();
|
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2018-08-26 13:54:51 +00:00
|
|
|
it('emits a process exit event with the code', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', 'quit-app');
|
|
|
|
const electronPath = process.execPath;
|
|
|
|
let output = '';
|
2018-06-14 16:44:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
appProcess = cp.spawn(electronPath, [appPath]);
|
2019-07-01 18:25:45 +00:00
|
|
|
if (appProcess && appProcess.stdout) {
|
2020-03-20 20:28:31 +00:00
|
|
|
appProcess.stdout.on('data', data => { output += data; });
|
2019-07-01 18:25:45 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
const [code] = await emittedOnce(appProcess, 'exit');
|
2018-06-14 16:44:27 +00:00
|
|
|
|
2018-08-26 13:54:51 +00:00
|
|
|
if (process.platform !== 'win32') {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(output).to.include('Exit event with code: 123');
|
2018-08-26 13:54:51 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(code).to.equal(123);
|
|
|
|
});
|
2017-04-06 22:02:32 +00:00
|
|
|
|
2018-08-26 13:55:50 +00:00
|
|
|
it('closes all windows', async function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', 'exit-closes-all-windows-app');
|
|
|
|
const electronPath = process.execPath;
|
2018-06-14 16:44:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
appProcess = cp.spawn(electronPath, [appPath]);
|
|
|
|
const [code, signal] = await emittedOnce(appProcess, 'exit');
|
2018-08-26 13:54:51 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(signal).to.equal(null, 'exit signal should be null, if you see this please tag @MarshallOfSound');
|
|
|
|
expect(code).to.equal(123, 'exit code should be 123, if you see this please tag @MarshallOfSound');
|
|
|
|
});
|
2018-01-11 22:50:35 +00:00
|
|
|
|
2018-08-26 13:54:51 +00:00
|
|
|
it('exits gracefully', async function () {
|
2018-03-07 03:01:17 +00:00
|
|
|
if (!['darwin', 'linux'].includes(process.platform)) {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.skip();
|
|
|
|
return;
|
2018-01-11 22:50:35 +00:00
|
|
|
}
|
2018-03-07 03:01:17 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const electronPath = process.execPath;
|
|
|
|
const appPath = path.join(fixturesPath, 'api', 'singleton');
|
|
|
|
appProcess = cp.spawn(electronPath, [appPath]);
|
2018-03-07 03:01:17 +00:00
|
|
|
|
|
|
|
// Singleton will send us greeting data to let us know it's running.
|
|
|
|
// After that, ask it to exit gracefully and confirm that it does.
|
2019-07-01 18:25:45 +00:00
|
|
|
if (appProcess && appProcess.stdout) {
|
2020-03-20 20:28:31 +00:00
|
|
|
appProcess.stdout.on('data', () => appProcess!.kill());
|
2019-07-01 18:25:45 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
const [code, signal] = await emittedOnce(appProcess, 'exit');
|
2018-08-26 13:54:51 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const message = `code:\n${code}\nsignal:\n${signal}`;
|
|
|
|
expect(code).to.equal(0, message);
|
|
|
|
expect(signal).to.equal(null, message);
|
|
|
|
});
|
|
|
|
});
|
2016-02-17 01:09:41 +00:00
|
|
|
|
2020-02-05 19:12:25 +00:00
|
|
|
ifdescribe(process.platform === 'darwin')('app.setActivationPolicy', () => {
|
|
|
|
it('throws an error on invalid application policies', () => {
|
|
|
|
expect(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setActivationPolicy('terrible' as any);
|
|
|
|
}).to.throw(/Invalid activation policy: must be one of 'regular', 'accessory', or 'prohibited'/);
|
|
|
|
});
|
|
|
|
});
|
2020-02-05 19:12:25 +00:00
|
|
|
|
2021-04-09 07:09:17 +00:00
|
|
|
describe('app.requestSingleInstanceLock', () => {
|
2020-06-30 22:10:36 +00:00
|
|
|
it('prevents the second launch of app', async function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.timeout(120000);
|
|
|
|
const appPath = path.join(fixturesPath, 'api', 'singleton');
|
|
|
|
const first = cp.spawn(process.execPath, [appPath]);
|
2020-06-30 22:10:36 +00:00
|
|
|
await emittedOnce(first.stdout, 'data');
|
2017-09-25 02:19:25 +00:00
|
|
|
// Start second app when received output.
|
2020-06-30 22:10:36 +00:00
|
|
|
const second = cp.spawn(process.execPath, [appPath]);
|
|
|
|
const [code2] = await emittedOnce(second, 'exit');
|
|
|
|
expect(code2).to.equal(1);
|
|
|
|
const [code1] = await emittedOnce(first, 'exit');
|
|
|
|
expect(code1).to.equal(0);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2019-03-12 15:56:28 +00:00
|
|
|
|
|
|
|
it('passes arguments to the second-instance event', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', 'singleton');
|
|
|
|
const first = cp.spawn(process.execPath, [appPath]);
|
|
|
|
const firstExited = emittedOnce(first, 'exit');
|
2019-03-12 15:56:28 +00:00
|
|
|
|
|
|
|
// Wait for the first app to boot.
|
2020-03-20 20:28:31 +00:00
|
|
|
const firstStdoutLines = first.stdout.pipe(split());
|
2019-03-12 15:56:28 +00:00
|
|
|
while ((await emittedOnce(firstStdoutLines, 'data')).toString() !== 'started') {
|
|
|
|
// wait.
|
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
const data2Promise = emittedOnce(firstStdoutLines, 'data');
|
|
|
|
|
|
|
|
const secondInstanceArgs = [process.execPath, appPath, '--some-switch', 'some-arg'];
|
|
|
|
const second = cp.spawn(secondInstanceArgs[0], secondInstanceArgs.slice(1));
|
|
|
|
const [code2] = await emittedOnce(second, 'exit');
|
|
|
|
expect(code2).to.equal(1);
|
|
|
|
const [code1] = await firstExited;
|
|
|
|
expect(code1).to.equal(0);
|
|
|
|
const data2 = (await data2Promise)[0].toString('ascii');
|
|
|
|
const secondInstanceArgsReceived: string[] = JSON.parse(data2.toString('ascii'));
|
2019-03-12 15:56:28 +00:00
|
|
|
const expected = process.platform === 'win32'
|
2020-01-29 12:01:37 +00:00
|
|
|
? [process.execPath, '--some-switch', '--allow-file-access-from-files', appPath, 'some-arg']
|
2020-03-20 20:28:31 +00:00
|
|
|
: secondInstanceArgs;
|
2019-03-12 15:56:28 +00:00
|
|
|
expect(secondInstanceArgsReceived).to.eql(expected,
|
2020-03-20 20:28:31 +00:00
|
|
|
`expected ${JSON.stringify(expected)} but got ${data2.toString('ascii')}`);
|
|
|
|
});
|
|
|
|
});
|
2017-09-20 02:58:10 +00:00
|
|
|
|
2021-04-09 07:09:17 +00:00
|
|
|
describe('app.relaunch', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
let server: net.Server | null = null;
|
|
|
|
const socketPath = process.platform === 'win32' ? '\\\\.\\pipe\\electron-app-relaunch' : '/tmp/electron-app-relaunch';
|
2016-06-03 03:12:20 +00:00
|
|
|
|
2018-06-14 16:44:27 +00:00
|
|
|
beforeEach(done => {
|
2016-06-29 16:37:10 +00:00
|
|
|
fs.unlink(socketPath, () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
server = net.createServer();
|
|
|
|
server.listen(socketPath);
|
|
|
|
done();
|
|
|
|
});
|
|
|
|
});
|
2016-06-03 03:12:20 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
afterEach((done) => {
|
2019-03-10 22:38:44 +00:00
|
|
|
server!.close(() => {
|
2016-06-03 03:12:20 +00:00
|
|
|
if (process.platform === 'win32') {
|
2020-03-20 20:28:31 +00:00
|
|
|
done();
|
2016-06-03 03:12:20 +00:00
|
|
|
} else {
|
2020-03-20 20:28:31 +00:00
|
|
|
fs.unlink(socketPath, () => done());
|
2016-06-03 03:12:20 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
});
|
2016-06-03 03:12:20 +00:00
|
|
|
|
|
|
|
it('relaunches the app', function (done) {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.timeout(120000);
|
2016-11-29 22:31:57 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
let state = 'none';
|
|
|
|
server!.once('error', error => done(error));
|
2019-03-10 22:38:44 +00:00
|
|
|
server!.on('connection', client => {
|
2018-06-14 16:44:27 +00:00
|
|
|
client.once('data', data => {
|
2016-06-03 03:12:20 +00:00
|
|
|
if (String(data) === 'false' && state === 'none') {
|
2020-03-20 20:28:31 +00:00
|
|
|
state = 'first-launch';
|
2016-06-03 03:12:20 +00:00
|
|
|
} else if (String(data) === 'true' && state === 'first-launch') {
|
2020-03-20 20:28:31 +00:00
|
|
|
done();
|
2016-06-03 03:12:20 +00:00
|
|
|
} else {
|
2021-03-02 17:34:41 +00:00
|
|
|
done(`Unexpected state: "${state}", data: "${data}"`);
|
2016-06-03 03:12:20 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
});
|
2016-06-03 03:12:20 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', 'relaunch');
|
2021-03-02 17:34:41 +00:00
|
|
|
const child = cp.spawn(process.execPath, [appPath]);
|
|
|
|
child.stdout.on('data', (c) => console.log(c.toString()));
|
|
|
|
child.stderr.on('data', (c) => console.log(c.toString()));
|
2021-03-07 07:30:43 +00:00
|
|
|
child.on('exit', (code, signal) => {
|
2021-03-02 17:34:41 +00:00
|
|
|
if (code !== 0) {
|
2021-03-07 07:30:43 +00:00
|
|
|
console.log(`Process exited with code "${code}" signal "${signal}"`);
|
2021-03-02 17:34:41 +00:00
|
|
|
}
|
|
|
|
});
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
});
|
2016-06-03 03:12:20 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('app.setUserActivity(type, userInfo)', () => {
|
2017-11-15 21:05:46 +00:00
|
|
|
before(function () {
|
|
|
|
if (process.platform !== 'darwin') {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.skip();
|
2017-11-15 21:05:46 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-05-04 06:33:40 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
it('sets the current activity', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setUserActivity('com.electron.testActivity', { testData: '123' });
|
|
|
|
expect(app.getCurrentActivityType()).to.equal('com.electron.testActivity');
|
|
|
|
});
|
|
|
|
});
|
2016-05-03 22:51:31 +00:00
|
|
|
|
2020-01-31 23:25:01 +00:00
|
|
|
describe('certificate-error event', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
afterEach(closeAllWindows);
|
2020-01-31 23:25:01 +00:00
|
|
|
it('is emitted when visiting a server with a self-signed cert', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const w = new BrowserWindow({ show: false });
|
|
|
|
w.loadURL(secureUrl);
|
|
|
|
await emittedOnce(app, 'certificate-error');
|
|
|
|
});
|
|
|
|
});
|
2020-01-31 23:25:01 +00:00
|
|
|
|
2019-03-10 22:38:44 +00:00
|
|
|
// xdescribe('app.importCertificate', () => {
|
|
|
|
// let w = null
|
|
|
|
|
|
|
|
// before(function () {
|
|
|
|
// if (process.platform !== 'linux') {
|
|
|
|
// this.skip()
|
|
|
|
// }
|
|
|
|
// })
|
|
|
|
|
|
|
|
// afterEach(() => closeWindow(w).then(() => { w = null }))
|
|
|
|
|
|
|
|
// it('can import certificate into platform cert store', done => {
|
|
|
|
// const options = {
|
|
|
|
// certificate: path.join(certPath, 'client.p12'),
|
|
|
|
// password: 'electron'
|
|
|
|
// }
|
|
|
|
|
|
|
|
// w = new BrowserWindow({
|
|
|
|
// show: false,
|
|
|
|
// webPreferences: {
|
|
|
|
// nodeIntegration: true
|
|
|
|
// }
|
|
|
|
// })
|
|
|
|
|
|
|
|
// w.webContents.on('did-finish-load', () => {
|
|
|
|
// expect(w.webContents.getTitle()).to.equal('authorized')
|
|
|
|
// done()
|
|
|
|
// })
|
|
|
|
|
|
|
|
// ipcRenderer.once('select-client-certificate', (event, webContentsId, list) => {
|
|
|
|
// expect(webContentsId).to.equal(w.webContents.id)
|
|
|
|
// expect(list).to.have.lengthOf(1)
|
|
|
|
|
|
|
|
// expect(list[0]).to.deep.equal({
|
|
|
|
// issuerName: 'Intermediate CA',
|
|
|
|
// subjectName: 'Client Cert',
|
|
|
|
// issuer: { commonName: 'Intermediate CA' },
|
|
|
|
// subject: { commonName: 'Client Cert' }
|
|
|
|
// })
|
|
|
|
|
|
|
|
// event.sender.send('client-certificate-response', list[0])
|
|
|
|
// })
|
|
|
|
|
|
|
|
// app.importCertificate(options, result => {
|
|
|
|
// expect(result).toNotExist()
|
|
|
|
// ipcRenderer.sendSync('set-client-certificate-option', false)
|
|
|
|
// w.loadURL(secureUrl)
|
|
|
|
// })
|
|
|
|
// })
|
|
|
|
// })
|
2016-04-18 16:23:44 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('BrowserWindow events', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
let w: BrowserWindow = null as any;
|
2016-02-17 01:09:41 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
afterEach(() => closeWindow(w).then(() => { w = null as any; }));
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2020-05-20 20:18:48 +00:00
|
|
|
it('should emit browser-window-focus event when window is focused', async () => {
|
|
|
|
const emitted = emittedOnce(app, 'browser-window-focus');
|
2020-03-20 20:28:31 +00:00
|
|
|
w = new BrowserWindow({ show: false });
|
|
|
|
w.emit('focus');
|
2020-05-20 20:18:48 +00:00
|
|
|
const [, window] = await emitted;
|
|
|
|
expect(window.id).to.equal(w.id);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2020-05-20 20:18:48 +00:00
|
|
|
it('should emit browser-window-blur event when window is blured', async () => {
|
|
|
|
const emitted = emittedOnce(app, 'browser-window-blur');
|
2020-03-20 20:28:31 +00:00
|
|
|
w = new BrowserWindow({ show: false });
|
|
|
|
w.emit('blur');
|
2020-05-20 20:18:48 +00:00
|
|
|
const [, window] = await emitted;
|
|
|
|
expect(window.id).to.equal(w.id);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-03-25 19:57:17 +00:00
|
|
|
|
2020-05-20 20:18:48 +00:00
|
|
|
it('should emit browser-window-created event when window is created', async () => {
|
|
|
|
const emitted = emittedOnce(app, 'browser-window-created');
|
2020-03-20 20:28:31 +00:00
|
|
|
w = new BrowserWindow({ show: false });
|
2020-05-20 20:18:48 +00:00
|
|
|
const [, window] = await emitted;
|
|
|
|
expect(window.id).to.equal(w.id);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-06-13 16:05:04 +00:00
|
|
|
|
2020-05-20 20:18:48 +00:00
|
|
|
it('should emit web-contents-created event when a webContents is created', async () => {
|
|
|
|
const emitted = emittedOnce(app, 'web-contents-created');
|
2020-03-20 20:28:31 +00:00
|
|
|
w = new BrowserWindow({ show: false });
|
2020-05-20 20:18:48 +00:00
|
|
|
const [, webContents] = await emitted;
|
|
|
|
expect(webContents.id).to.equal(w.webContents.id);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2018-10-18 03:36:45 +00:00
|
|
|
|
2020-05-20 20:18:48 +00:00
|
|
|
// FIXME: re-enable this test on win32.
|
|
|
|
ifit(process.platform !== 'win32')('should emit renderer-process-crashed event when renderer crashes', async () => {
|
2019-03-11 23:17:24 +00:00
|
|
|
w = new BrowserWindow({
|
|
|
|
show: false,
|
|
|
|
webPreferences: {
|
2021-03-01 21:52:29 +00:00
|
|
|
nodeIntegration: true,
|
|
|
|
contextIsolation: false
|
2019-03-11 23:17:24 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
await w.loadURL('about:blank');
|
2019-03-11 23:17:24 +00:00
|
|
|
|
2020-05-20 20:18:48 +00:00
|
|
|
const emitted = emittedOnce(app, 'renderer-process-crashed');
|
2020-03-20 20:28:31 +00:00
|
|
|
w.webContents.executeJavaScript('process.crash()');
|
2019-03-11 23:17:24 +00:00
|
|
|
|
2020-05-20 20:18:48 +00:00
|
|
|
const [, webContents] = await emitted;
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(webContents).to.equal(w.webContents);
|
|
|
|
});
|
2019-03-11 23:17:24 +00:00
|
|
|
|
2020-05-20 20:18:48 +00:00
|
|
|
// FIXME: re-enable this test on win32.
|
|
|
|
ifit(process.platform !== 'win32')('should emit render-process-gone event when renderer crashes', async () => {
|
2020-05-17 15:05:05 +00:00
|
|
|
w = new BrowserWindow({
|
|
|
|
show: false,
|
|
|
|
webPreferences: {
|
2021-03-01 21:52:29 +00:00
|
|
|
nodeIntegration: true,
|
|
|
|
contextIsolation: false
|
2020-05-17 15:05:05 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
await w.loadURL('about:blank');
|
|
|
|
|
2020-05-20 20:18:48 +00:00
|
|
|
const emitted = emittedOnce(app, 'render-process-gone');
|
2020-05-17 15:05:05 +00:00
|
|
|
w.webContents.executeJavaScript('process.crash()');
|
|
|
|
|
2020-05-20 20:18:48 +00:00
|
|
|
const [, webContents, details] = await emitted;
|
2020-05-17 15:05:05 +00:00
|
|
|
expect(webContents).to.equal(w.webContents);
|
|
|
|
expect(details.reason).to.be.oneOf(['crashed', 'abnormal-exit']);
|
|
|
|
});
|
|
|
|
|
2019-10-14 20:49:21 +00:00
|
|
|
ifdescribe(features.isDesktopCapturerEnabled())('desktopCapturer module filtering', () => {
|
|
|
|
it('should emit desktop-capturer-get-sources event when desktopCapturer.getSources() is invoked', async () => {
|
|
|
|
w = new BrowserWindow({
|
|
|
|
show: false,
|
|
|
|
webPreferences: {
|
2021-03-01 21:52:29 +00:00
|
|
|
nodeIntegration: true,
|
|
|
|
contextIsolation: false
|
2019-10-14 20:49:21 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
await w.loadURL('about:blank');
|
2019-01-08 22:27:56 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const promise = emittedOnce(app, 'desktop-capturer-get-sources');
|
|
|
|
w.webContents.executeJavaScript('require(\'electron\').desktopCapturer.getSources({ types: [\'screen\'] })');
|
2018-12-20 02:44:30 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const [, webContents] = await promise;
|
|
|
|
expect(webContents).to.equal(w.webContents);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2016-06-29 17:47:20 +00:00
|
|
|
|
2019-04-25 22:44:54 +00:00
|
|
|
describe('app.badgeCount', () => {
|
2017-11-15 21:05:46 +00:00
|
|
|
const platformIsNotSupported =
|
|
|
|
(process.platform === 'win32') ||
|
2020-03-20 20:28:31 +00:00
|
|
|
(process.platform === 'linux' && !app.isUnityRunning());
|
2016-07-01 13:18:39 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const expectedBadgeCount = 42;
|
2017-11-15 21:05:46 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
after(() => { app.badgeCount = 0; });
|
2016-10-06 17:29:55 +00:00
|
|
|
|
2021-01-21 05:45:06 +00:00
|
|
|
ifdescribe(!platformIsNotSupported)('on supported platform', () => {
|
|
|
|
describe('with properties', () => {
|
2020-03-18 17:06:41 +00:00
|
|
|
it('sets a badge count', function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.badgeCount = expectedBadgeCount;
|
|
|
|
expect(app.badgeCount).to.equal(expectedBadgeCount);
|
|
|
|
});
|
|
|
|
});
|
2017-11-15 21:05:46 +00:00
|
|
|
|
2021-01-21 05:45:06 +00:00
|
|
|
describe('with functions', () => {
|
|
|
|
it('sets a numerical badge count', function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setBadgeCount(expectedBadgeCount);
|
|
|
|
expect(app.getBadgeCount()).to.equal(expectedBadgeCount);
|
|
|
|
});
|
2021-01-21 05:45:06 +00:00
|
|
|
it('sets an non numeric (dot) badge count', function () {
|
|
|
|
app.setBadgeCount();
|
|
|
|
// Badge count should be zero when non numeric (dot) is requested
|
|
|
|
expect(app.getBadgeCount()).to.equal(0);
|
|
|
|
});
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
});
|
2016-07-01 13:18:39 +00:00
|
|
|
|
2021-01-21 05:45:06 +00:00
|
|
|
ifdescribe(process.platform !== 'win32' && platformIsNotSupported)('on unsupported platform', () => {
|
|
|
|
describe('with properties', () => {
|
2020-03-18 17:06:41 +00:00
|
|
|
it('does not set a badge count', function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.badgeCount = 9999;
|
|
|
|
expect(app.badgeCount).to.equal(0);
|
|
|
|
});
|
|
|
|
});
|
2020-03-18 17:06:41 +00:00
|
|
|
|
2021-01-21 05:45:06 +00:00
|
|
|
describe('with functions', () => {
|
2020-03-18 17:06:41 +00:00
|
|
|
it('does not set a badge count)', function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setBadgeCount(9999);
|
|
|
|
expect(app.getBadgeCount()).to.equal(0);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2016-07-06 20:34:14 +00:00
|
|
|
|
2021-01-21 23:36:52 +00:00
|
|
|
ifdescribe(process.platform !== 'linux' && !process.mas)('app.get/setLoginItemSettings API', function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
const updateExe = path.resolve(path.dirname(process.execPath), '..', 'Update.exe');
|
2017-02-02 16:01:47 +00:00
|
|
|
const processStartArgs = [
|
|
|
|
'--processStart', `"${path.basename(process.execPath)}"`,
|
2020-03-20 15:12:18 +00:00
|
|
|
'--process-start-args', '"--hidden"'
|
2020-03-20 20:28:31 +00:00
|
|
|
];
|
2020-11-17 20:13:08 +00:00
|
|
|
const regAddArgs = [
|
|
|
|
'ADD',
|
|
|
|
'HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\StartupApproved\\Run',
|
|
|
|
'/v',
|
|
|
|
'additionalEntry',
|
|
|
|
'/t',
|
|
|
|
'REG_BINARY',
|
|
|
|
'/f',
|
|
|
|
'/d'
|
|
|
|
];
|
2017-02-02 16:01:47 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
beforeEach(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setLoginItemSettings({ openAtLogin: false });
|
|
|
|
app.setLoginItemSettings({ openAtLogin: false, path: updateExe, args: processStartArgs });
|
2020-11-17 20:13:08 +00:00
|
|
|
app.setLoginItemSettings({ name: 'additionalEntry', openAtLogin: false });
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-07-06 20:57:20 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
afterEach(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setLoginItemSettings({ openAtLogin: false });
|
|
|
|
app.setLoginItemSettings({ openAtLogin: false, path: updateExe, args: processStartArgs });
|
2020-11-17 20:13:08 +00:00
|
|
|
app.setLoginItemSettings({ name: 'additionalEntry', openAtLogin: false });
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-07-06 20:34:14 +00:00
|
|
|
|
2020-07-29 17:08:37 +00:00
|
|
|
ifit(process.platform !== 'win32')('sets and returns the app as a login item', function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setLoginItemSettings({ openAtLogin: true });
|
2019-01-31 17:59:32 +00:00
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal({
|
|
|
|
openAtLogin: true,
|
|
|
|
openAsHidden: false,
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
});
|
2017-01-26 20:24:33 +00:00
|
|
|
|
2020-07-29 17:08:37 +00:00
|
|
|
ifit(process.platform === 'win32')('sets and returns the app as a login item (windows)', function () {
|
2020-11-17 20:13:08 +00:00
|
|
|
app.setLoginItemSettings({ openAtLogin: true, enabled: true });
|
2020-07-29 17:08:37 +00:00
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal({
|
|
|
|
openAtLogin: true,
|
|
|
|
openAsHidden: false,
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false,
|
|
|
|
executableWillLaunchAtLogin: true,
|
|
|
|
launchItems: [{
|
|
|
|
name: 'electron.app.Electron',
|
|
|
|
path: process.execPath,
|
|
|
|
args: [],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: true
|
|
|
|
}]
|
|
|
|
});
|
2020-11-17 20:13:08 +00:00
|
|
|
|
|
|
|
app.setLoginItemSettings({ openAtLogin: false });
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, enabled: false });
|
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal({
|
|
|
|
openAtLogin: true,
|
|
|
|
openAsHidden: false,
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false,
|
|
|
|
executableWillLaunchAtLogin: false,
|
|
|
|
launchItems: [{
|
|
|
|
name: 'electron.app.Electron',
|
|
|
|
path: process.execPath,
|
|
|
|
args: [],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: false
|
|
|
|
}]
|
|
|
|
});
|
2020-07-29 17:08:37 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
ifit(process.platform !== 'win32')('adds a login item that loads in hidden mode', function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setLoginItemSettings({ openAtLogin: true, openAsHidden: true });
|
2019-01-31 17:59:32 +00:00
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal({
|
|
|
|
openAtLogin: true,
|
|
|
|
openAsHidden: process.platform === 'darwin' && !process.mas, // Only available on macOS
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2020-07-29 17:08:37 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
ifit(process.platform === 'win32')('adds a login item that loads in hidden mode (windows)', function () {
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, openAsHidden: true });
|
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal({
|
|
|
|
openAtLogin: true,
|
|
|
|
openAsHidden: false,
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false,
|
|
|
|
executableWillLaunchAtLogin: true,
|
|
|
|
launchItems: [{
|
|
|
|
name: 'electron.app.Electron',
|
|
|
|
path: process.execPath,
|
|
|
|
args: [],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: true
|
|
|
|
}]
|
|
|
|
});
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2018-10-13 07:52:19 +00:00
|
|
|
|
2018-11-06 19:31:32 +00:00
|
|
|
it('correctly sets and unsets the LoginItem', function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getLoginItemSettings().openAtLogin).to.equal(false);
|
2018-11-06 19:31:32 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setLoginItemSettings({ openAtLogin: true });
|
|
|
|
expect(app.getLoginItemSettings().openAtLogin).to.equal(true);
|
2018-11-06 19:31:32 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setLoginItemSettings({ openAtLogin: false });
|
|
|
|
expect(app.getLoginItemSettings().openAtLogin).to.equal(false);
|
|
|
|
});
|
2018-11-06 19:31:32 +00:00
|
|
|
|
2018-10-12 22:19:27 +00:00
|
|
|
it('correctly sets and unsets the LoginItem as hidden', function () {
|
2020-03-20 20:28:31 +00:00
|
|
|
if (process.platform !== 'darwin') this.skip();
|
2018-10-12 22:19:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getLoginItemSettings().openAtLogin).to.equal(false);
|
|
|
|
expect(app.getLoginItemSettings().openAsHidden).to.equal(false);
|
2018-10-12 22:19:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setLoginItemSettings({ openAtLogin: true, openAsHidden: true });
|
|
|
|
expect(app.getLoginItemSettings().openAtLogin).to.equal(true);
|
|
|
|
expect(app.getLoginItemSettings().openAsHidden).to.equal(true);
|
2018-10-12 22:19:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setLoginItemSettings({ openAtLogin: true, openAsHidden: false });
|
|
|
|
expect(app.getLoginItemSettings().openAtLogin).to.equal(true);
|
|
|
|
expect(app.getLoginItemSettings().openAsHidden).to.equal(false);
|
|
|
|
});
|
2018-10-12 22:19:27 +00:00
|
|
|
|
2020-07-29 17:08:37 +00:00
|
|
|
ifit(process.platform === 'win32')('allows you to pass a custom executable and arguments', function () {
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, path: updateExe, args: processStartArgs, enabled: true });
|
|
|
|
expect(app.getLoginItemSettings().openAtLogin).to.equal(false);
|
|
|
|
const openAtLoginTrueEnabledTrue = app.getLoginItemSettings({
|
|
|
|
path: updateExe,
|
|
|
|
args: processStartArgs
|
|
|
|
});
|
|
|
|
|
|
|
|
expect(openAtLoginTrueEnabledTrue.openAtLogin).to.equal(true);
|
|
|
|
expect(openAtLoginTrueEnabledTrue.executableWillLaunchAtLogin).to.equal(true);
|
|
|
|
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, path: updateExe, args: processStartArgs, enabled: false });
|
|
|
|
const openAtLoginTrueEnabledFalse = app.getLoginItemSettings({
|
|
|
|
path: updateExe,
|
|
|
|
args: processStartArgs
|
|
|
|
});
|
2017-01-26 20:24:33 +00:00
|
|
|
|
2020-07-29 17:08:37 +00:00
|
|
|
expect(openAtLoginTrueEnabledFalse.openAtLogin).to.equal(true);
|
|
|
|
expect(openAtLoginTrueEnabledFalse.executableWillLaunchAtLogin).to.equal(false);
|
2017-01-26 20:35:46 +00:00
|
|
|
|
2020-07-29 17:08:37 +00:00
|
|
|
app.setLoginItemSettings({ openAtLogin: false, path: updateExe, args: processStartArgs, enabled: false });
|
|
|
|
const openAtLoginFalseEnabledFalse = app.getLoginItemSettings({
|
2018-06-14 16:44:27 +00:00
|
|
|
path: updateExe,
|
|
|
|
args: processStartArgs
|
2020-07-29 17:08:37 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
expect(openAtLoginFalseEnabledFalse.openAtLogin).to.equal(false);
|
|
|
|
expect(openAtLoginFalseEnabledFalse.executableWillLaunchAtLogin).to.equal(false);
|
|
|
|
});
|
|
|
|
|
|
|
|
ifit(process.platform === 'win32')('allows you to pass a custom name', function () {
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true });
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, name: 'additionalEntry', enabled: false });
|
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal({
|
|
|
|
openAtLogin: true,
|
|
|
|
openAsHidden: false,
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false,
|
|
|
|
executableWillLaunchAtLogin: true,
|
|
|
|
launchItems: [{
|
|
|
|
name: 'additionalEntry',
|
|
|
|
path: process.execPath,
|
|
|
|
args: [],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: false
|
|
|
|
}, {
|
|
|
|
name: 'electron.app.Electron',
|
|
|
|
path: process.execPath,
|
|
|
|
args: [],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: true
|
|
|
|
}]
|
|
|
|
});
|
|
|
|
|
|
|
|
app.setLoginItemSettings({ openAtLogin: false, name: 'additionalEntry' });
|
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal({
|
|
|
|
openAtLogin: true,
|
|
|
|
openAsHidden: false,
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false,
|
|
|
|
executableWillLaunchAtLogin: true,
|
|
|
|
launchItems: [{
|
|
|
|
name: 'electron.app.Electron',
|
|
|
|
path: process.execPath,
|
|
|
|
args: [],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: true
|
|
|
|
}]
|
|
|
|
});
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2020-11-17 20:13:08 +00:00
|
|
|
|
|
|
|
ifit(process.platform === 'win32')('finds launch items independent of args', function () {
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, args: ['arg1'] });
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, name: 'additionalEntry', enabled: false, args: ['arg2'] });
|
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal({
|
|
|
|
openAtLogin: false,
|
|
|
|
openAsHidden: false,
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false,
|
|
|
|
executableWillLaunchAtLogin: true,
|
|
|
|
launchItems: [{
|
|
|
|
name: 'additionalEntry',
|
|
|
|
path: process.execPath,
|
|
|
|
args: ['arg2'],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: false
|
|
|
|
}, {
|
|
|
|
name: 'electron.app.Electron',
|
|
|
|
path: process.execPath,
|
|
|
|
args: ['arg1'],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: true
|
|
|
|
}]
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
ifit(process.platform === 'win32')('finds launch items independent of path quotation or casing', function () {
|
|
|
|
const expectation = {
|
|
|
|
openAtLogin: false,
|
|
|
|
openAsHidden: false,
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false,
|
|
|
|
executableWillLaunchAtLogin: true,
|
|
|
|
launchItems: [{
|
|
|
|
name: 'additionalEntry',
|
|
|
|
path: 'C:\\electron\\myapp.exe',
|
|
|
|
args: ['arg1'],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: true
|
|
|
|
}]
|
|
|
|
};
|
|
|
|
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, name: 'additionalEntry', enabled: true, path: 'C:\\electron\\myapp.exe', args: ['arg1'] });
|
|
|
|
expect(app.getLoginItemSettings({ path: '"C:\\electron\\MYAPP.exe"' })).to.deep.equal(expectation);
|
|
|
|
|
|
|
|
app.setLoginItemSettings({ openAtLogin: false, name: 'additionalEntry' });
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, name: 'additionalEntry', enabled: true, path: '"C:\\electron\\MYAPP.exe"', args: ['arg1'] });
|
|
|
|
expect(app.getLoginItemSettings({ path: 'C:\\electron\\myapp.exe' })).to.deep.equal({
|
|
|
|
...expectation,
|
|
|
|
launchItems: [
|
|
|
|
{
|
|
|
|
name: 'additionalEntry',
|
|
|
|
path: 'C:\\electron\\MYAPP.exe',
|
|
|
|
args: ['arg1'],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: true
|
|
|
|
}
|
|
|
|
]
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
ifit(process.platform === 'win32')('detects disabled by TaskManager', async function () {
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, name: 'additionalEntry', enabled: true, args: ['arg1'] });
|
|
|
|
const appProcess = cp.spawn('reg', [...regAddArgs, '030000000000000000000000']);
|
|
|
|
await emittedOnce(appProcess, 'exit');
|
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal({
|
|
|
|
openAtLogin: false,
|
|
|
|
openAsHidden: false,
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false,
|
|
|
|
executableWillLaunchAtLogin: false,
|
|
|
|
launchItems: [{
|
|
|
|
name: 'additionalEntry',
|
|
|
|
path: process.execPath,
|
|
|
|
args: ['arg1'],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: false
|
|
|
|
}]
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
ifit(process.platform === 'win32')('detects enabled by TaskManager', async function () {
|
|
|
|
const expectation = {
|
|
|
|
openAtLogin: false,
|
|
|
|
openAsHidden: false,
|
|
|
|
wasOpenedAtLogin: false,
|
|
|
|
wasOpenedAsHidden: false,
|
|
|
|
restoreState: false,
|
|
|
|
executableWillLaunchAtLogin: true,
|
|
|
|
launchItems: [{
|
|
|
|
name: 'additionalEntry',
|
|
|
|
path: process.execPath,
|
|
|
|
args: ['arg1'],
|
|
|
|
scope: 'user',
|
|
|
|
enabled: true
|
|
|
|
}]
|
|
|
|
};
|
|
|
|
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, name: 'additionalEntry', enabled: false, args: ['arg1'] });
|
|
|
|
let appProcess = cp.spawn('reg', [...regAddArgs, '020000000000000000000000']);
|
|
|
|
await emittedOnce(appProcess, 'exit');
|
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal(expectation);
|
|
|
|
|
|
|
|
app.setLoginItemSettings({ openAtLogin: true, name: 'additionalEntry', enabled: false, args: ['arg1'] });
|
|
|
|
appProcess = cp.spawn('reg', [...regAddArgs, '000000000000000000000000']);
|
|
|
|
await emittedOnce(appProcess, 'exit');
|
|
|
|
expect(app.getLoginItemSettings()).to.deep.equal(expectation);
|
|
|
|
});
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-07-11 21:32:24 +00:00
|
|
|
|
2020-03-18 17:06:41 +00:00
|
|
|
ifdescribe(process.platform !== 'linux')('accessibilitySupportEnabled property', () => {
|
|
|
|
it('with properties', () => {
|
|
|
|
it('can set accessibility support enabled', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.accessibilitySupportEnabled).to.eql(false);
|
2019-04-05 02:49:04 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
app.accessibilitySupportEnabled = true;
|
|
|
|
expect(app.accessibilitySupportEnabled).to.eql(true);
|
|
|
|
});
|
|
|
|
});
|
2019-04-05 02:49:04 +00:00
|
|
|
|
2020-03-18 17:06:41 +00:00
|
|
|
it('with functions', () => {
|
|
|
|
it('can set accessibility support enabled', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.isAccessibilitySupportEnabled()).to.eql(false);
|
2020-03-18 17:06:41 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setAccessibilitySupportEnabled(true);
|
|
|
|
expect(app.isAccessibilitySupportEnabled()).to.eql(true);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2016-10-06 16:57:25 +00:00
|
|
|
|
2021-04-09 07:09:17 +00:00
|
|
|
describe('getAppPath', () => {
|
2019-06-19 21:34:22 +00:00
|
|
|
it('works for directories with package.json', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const { appPath } = await runTestApp('app-path');
|
|
|
|
expect(appPath).to.equal(path.resolve(fixturesPath, 'api/app-path'));
|
|
|
|
});
|
2019-06-19 21:34:22 +00:00
|
|
|
|
|
|
|
it('works for directories with index.js', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const { appPath } = await runTestApp('app-path/lib');
|
|
|
|
expect(appPath).to.equal(path.resolve(fixturesPath, 'api/app-path/lib'));
|
|
|
|
});
|
2019-06-19 21:34:22 +00:00
|
|
|
|
|
|
|
it('works for files without extension', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const { appPath } = await runTestApp('app-path/lib/index');
|
|
|
|
expect(appPath).to.equal(path.resolve(fixturesPath, 'api/app-path/lib'));
|
|
|
|
});
|
2019-06-19 21:34:22 +00:00
|
|
|
|
|
|
|
it('works for files', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const { appPath } = await runTestApp('app-path/lib/index.js');
|
|
|
|
expect(appPath).to.equal(path.resolve(fixturesPath, 'api/app-path/lib'));
|
|
|
|
});
|
|
|
|
});
|
2019-06-19 21:34:22 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('getPath(name)', () => {
|
|
|
|
it('returns paths that exist', () => {
|
2018-06-14 16:44:27 +00:00
|
|
|
const paths = [
|
|
|
|
fs.existsSync(app.getPath('exe')),
|
|
|
|
fs.existsSync(app.getPath('home')),
|
|
|
|
fs.existsSync(app.getPath('temp'))
|
2020-03-20 20:28:31 +00:00
|
|
|
];
|
|
|
|
expect(paths).to.deep.equal([true, true, true]);
|
|
|
|
});
|
2016-10-06 16:57:25 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
it('throws an error when the name is invalid', () => {
|
2018-06-14 16:44:27 +00:00
|
|
|
expect(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.getPath('does-not-exist' as any);
|
|
|
|
}).to.throw(/Failed to get 'does-not-exist' path/);
|
|
|
|
});
|
2016-10-06 16:57:25 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
it('returns the overridden path', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setPath('music', __dirname);
|
|
|
|
expect(app.getPath('music')).to.equal(__dirname);
|
|
|
|
});
|
2020-05-13 02:27:56 +00:00
|
|
|
|
|
|
|
if (process.platform === 'win32') {
|
|
|
|
it('gets the folder for recent files', () => {
|
|
|
|
const recent = app.getPath('recent');
|
|
|
|
|
|
|
|
// We expect that one of our test machines have overriden this
|
|
|
|
// to be something crazy, it'll always include the word "Recent"
|
|
|
|
// unless people have been registry-hacking like crazy
|
|
|
|
expect(recent).to.include('Recent');
|
|
|
|
});
|
|
|
|
|
|
|
|
it('can override the recent files path', () => {
|
|
|
|
app.setPath('recent', 'C:\\fake-path');
|
|
|
|
expect(app.getPath('recent')).to.equal('C:\\fake-path');
|
|
|
|
});
|
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2016-12-02 17:34:16 +00:00
|
|
|
|
2019-05-28 17:37:54 +00:00
|
|
|
describe('setPath(name, path)', () => {
|
2020-03-10 16:03:52 +00:00
|
|
|
it('throws when a relative path is passed', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const badPath = 'hey/hi/hello';
|
2020-03-10 16:03:52 +00:00
|
|
|
|
|
|
|
expect(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setPath('music', badPath);
|
|
|
|
}).to.throw(/Path must be absolute/);
|
|
|
|
});
|
2020-03-10 16:03:52 +00:00
|
|
|
|
2019-05-28 17:37:54 +00:00
|
|
|
it('does not create a new directory by default', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const badPath = path.join(__dirname, 'music');
|
2019-05-28 17:37:54 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(fs.existsSync(badPath)).to.be.false();
|
|
|
|
app.setPath('music', badPath);
|
|
|
|
expect(fs.existsSync(badPath)).to.be.false();
|
2019-05-28 17:37:54 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(() => { app.getPath(badPath as any); }).to.throw();
|
|
|
|
});
|
|
|
|
});
|
2019-05-28 17:37:54 +00:00
|
|
|
|
2020-03-10 16:03:52 +00:00
|
|
|
describe('setAppLogsPath(path)', () => {
|
|
|
|
it('throws when a relative path is passed', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const badPath = 'hey/hi/hello';
|
2020-03-10 16:03:52 +00:00
|
|
|
|
|
|
|
expect(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setAppLogsPath(badPath);
|
|
|
|
}).to.throw(/Path must be absolute/);
|
|
|
|
});
|
|
|
|
});
|
2020-03-10 16:03:52 +00:00
|
|
|
|
2017-10-23 07:54:38 +00:00
|
|
|
describe('select-client-certificate event', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
let w: BrowserWindow;
|
2016-12-02 17:34:16 +00:00
|
|
|
|
2018-03-09 05:43:49 +00:00
|
|
|
before(function () {
|
|
|
|
if (process.platform === 'linux') {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.skip();
|
2018-03-09 05:43:49 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
session.fromPartition('empty-certificate').setCertificateVerifyProc((req, cb) => { cb(0); });
|
|
|
|
});
|
2018-03-09 05:43:49 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
beforeEach(() => {
|
2016-12-02 17:34:16 +00:00
|
|
|
w = new BrowserWindow({
|
|
|
|
show: false,
|
|
|
|
webPreferences: {
|
2019-01-07 19:19:27 +00:00
|
|
|
nodeIntegration: true,
|
2016-12-02 17:34:16 +00:00
|
|
|
partition: 'empty-certificate'
|
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
});
|
2016-12-02 17:34:16 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
afterEach(() => closeWindow(w).then(() => { w = null as any; }));
|
2016-12-02 17:34:16 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
after(() => session.fromPartition('empty-certificate').setCertificateVerifyProc(null));
|
2020-01-31 23:25:01 +00:00
|
|
|
|
2019-03-10 22:38:44 +00:00
|
|
|
it('can respond with empty certificate list', async () => {
|
|
|
|
app.once('select-client-certificate', function (event, webContents, url, list, callback) {
|
2020-03-20 20:28:31 +00:00
|
|
|
console.log('select-client-certificate emitted');
|
|
|
|
event.preventDefault();
|
|
|
|
callback();
|
|
|
|
});
|
|
|
|
await w.webContents.loadURL(secureUrl);
|
|
|
|
expect(w.webContents.getTitle()).to.equal('denied');
|
|
|
|
});
|
|
|
|
});
|
2017-02-02 16:11:34 +00:00
|
|
|
|
|
|
|
describe('setAsDefaultProtocolClient(protocol, path, args)', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const protocol = 'electron-test';
|
|
|
|
const updateExe = path.resolve(path.dirname(process.execPath), '..', 'Update.exe');
|
2017-02-02 16:11:34 +00:00
|
|
|
const processStartArgs = [
|
|
|
|
'--processStart', `"${path.basename(process.execPath)}"`,
|
2020-03-20 15:12:18 +00:00
|
|
|
'--process-start-args', '"--hidden"'
|
2020-03-20 20:28:31 +00:00
|
|
|
];
|
2017-02-02 16:11:34 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
let Winreg: any;
|
|
|
|
let classesKey: any;
|
2017-12-05 19:28:39 +00:00
|
|
|
|
2017-11-15 21:05:46 +00:00
|
|
|
before(function () {
|
|
|
|
if (process.platform !== 'win32') {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.skip();
|
2017-12-05 19:28:39 +00:00
|
|
|
} else {
|
2020-03-20 20:28:31 +00:00
|
|
|
Winreg = require('winreg');
|
2017-12-05 19:28:39 +00:00
|
|
|
|
|
|
|
classesKey = new Winreg({
|
|
|
|
hive: Winreg.HKCU,
|
|
|
|
key: '\\Software\\Classes\\'
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2017-11-15 21:05:46 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2017-11-15 21:05:46 +00:00
|
|
|
|
2017-12-05 19:31:40 +00:00
|
|
|
after(function (done) {
|
2017-12-06 01:07:22 +00:00
|
|
|
if (process.platform !== 'win32') {
|
2020-03-20 20:28:31 +00:00
|
|
|
done();
|
2017-12-06 01:07:22 +00:00
|
|
|
} else {
|
2017-12-05 20:14:19 +00:00
|
|
|
const protocolKey = new Winreg({
|
|
|
|
hive: Winreg.HKCU,
|
|
|
|
key: `\\Software\\Classes\\${protocol}`
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2017-12-05 19:31:40 +00:00
|
|
|
|
2017-12-05 20:14:19 +00:00
|
|
|
// The last test leaves the registry dirty,
|
|
|
|
// delete the protocol key for those of us who test at home
|
2020-03-20 20:28:31 +00:00
|
|
|
protocolKey.destroy(() => done());
|
2017-12-05 21:20:34 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2017-12-05 19:31:40 +00:00
|
|
|
|
2017-02-02 16:11:34 +00:00
|
|
|
beforeEach(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.removeAsDefaultProtocolClient(protocol);
|
|
|
|
app.removeAsDefaultProtocolClient(protocol, updateExe, processStartArgs);
|
|
|
|
});
|
2017-02-02 16:11:34 +00:00
|
|
|
|
|
|
|
afterEach(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.removeAsDefaultProtocolClient(protocol);
|
|
|
|
expect(app.isDefaultProtocolClient(protocol)).to.equal(false);
|
2018-06-14 16:44:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
app.removeAsDefaultProtocolClient(protocol, updateExe, processStartArgs);
|
|
|
|
expect(app.isDefaultProtocolClient(protocol, updateExe, processStartArgs)).to.equal(false);
|
|
|
|
});
|
2017-02-02 16:11:34 +00:00
|
|
|
|
|
|
|
it('sets the app as the default protocol client', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.isDefaultProtocolClient(protocol)).to.equal(false);
|
|
|
|
app.setAsDefaultProtocolClient(protocol);
|
|
|
|
expect(app.isDefaultProtocolClient(protocol)).to.equal(true);
|
|
|
|
});
|
2017-02-02 16:11:34 +00:00
|
|
|
|
|
|
|
it('allows a custom path and args to be specified', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.isDefaultProtocolClient(protocol, updateExe, processStartArgs)).to.equal(false);
|
|
|
|
app.setAsDefaultProtocolClient(protocol, updateExe, processStartArgs);
|
2018-06-14 16:44:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.isDefaultProtocolClient(protocol, updateExe, processStartArgs)).to.equal(true);
|
|
|
|
expect(app.isDefaultProtocolClient(protocol)).to.equal(false);
|
|
|
|
});
|
2017-12-05 19:28:39 +00:00
|
|
|
|
2020-07-01 19:14:38 +00:00
|
|
|
it('creates a registry entry for the protocol class', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setAsDefaultProtocolClient(protocol);
|
2017-12-05 19:38:19 +00:00
|
|
|
|
2020-07-01 19:14:38 +00:00
|
|
|
const keys = await promisify(classesKey.keys).call(classesKey) as any[];
|
|
|
|
const exists = !!keys.find(key => key.key.includes(protocol));
|
|
|
|
expect(exists).to.equal(true);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2017-12-05 19:28:39 +00:00
|
|
|
|
2020-07-01 19:14:38 +00:00
|
|
|
it('completely removes a registry entry for the protocol class', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setAsDefaultProtocolClient(protocol);
|
|
|
|
app.removeAsDefaultProtocolClient(protocol);
|
2017-12-05 19:38:19 +00:00
|
|
|
|
2020-07-01 19:14:38 +00:00
|
|
|
const keys = await promisify(classesKey.keys).call(classesKey) as any[];
|
|
|
|
const exists = !!keys.find(key => key.key.includes(protocol));
|
|
|
|
expect(exists).to.equal(false);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2017-12-05 19:28:39 +00:00
|
|
|
|
2020-07-01 19:14:38 +00:00
|
|
|
it('only unsets a class registry key if it contains other data', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setAsDefaultProtocolClient(protocol);
|
2017-12-05 19:28:39 +00:00
|
|
|
|
|
|
|
const protocolKey = new Winreg({
|
|
|
|
hive: Winreg.HKCU,
|
|
|
|
key: `\\Software\\Classes\\${protocol}`
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2017-12-05 19:28:39 +00:00
|
|
|
|
2020-07-01 19:14:38 +00:00
|
|
|
await promisify(protocolKey.set).call(protocolKey, 'test-value', 'REG_BINARY', '123');
|
|
|
|
app.removeAsDefaultProtocolClient(protocol);
|
2017-12-05 19:38:19 +00:00
|
|
|
|
2020-07-01 19:14:38 +00:00
|
|
|
const keys = await promisify(classesKey.keys).call(classesKey) as any[];
|
|
|
|
const exists = !!keys.find(key => key.key.includes(protocol));
|
|
|
|
expect(exists).to.equal(true);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2019-11-07 01:50:33 +00:00
|
|
|
|
|
|
|
it('sets the default client such that getApplicationNameForProtocol returns Electron', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.setAsDefaultProtocolClient(protocol);
|
|
|
|
expect(app.getApplicationNameForProtocol(`${protocol}://`)).to.equal('Electron');
|
|
|
|
});
|
|
|
|
});
|
2019-11-07 01:50:33 +00:00
|
|
|
|
|
|
|
describe('getApplicationNameForProtocol()', () => {
|
|
|
|
it('returns application names for common protocols', function () {
|
|
|
|
// We can't expect particular app names here, but these protocols should
|
|
|
|
// at least have _something_ registered. Except on our Linux CI
|
|
|
|
// environment apparently.
|
|
|
|
if (process.platform === 'linux') {
|
2020-03-20 20:28:31 +00:00
|
|
|
this.skip();
|
2019-11-07 01:50:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const protocols = [
|
|
|
|
'http://',
|
|
|
|
'https://'
|
2020-03-20 20:28:31 +00:00
|
|
|
];
|
2019-11-07 01:50:33 +00:00
|
|
|
protocols.forEach((protocol) => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getApplicationNameForProtocol(protocol)).to.not.equal('');
|
|
|
|
});
|
|
|
|
});
|
2019-11-07 01:50:33 +00:00
|
|
|
|
|
|
|
it('returns an empty string for a bogus protocol', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.getApplicationNameForProtocol('bogus-protocol://')).to.equal('');
|
|
|
|
});
|
|
|
|
});
|
2019-11-07 01:50:33 +00:00
|
|
|
|
2020-06-30 19:22:30 +00:00
|
|
|
ifdescribe(process.platform !== 'linux')('getApplicationInfoForProtocol()', () => {
|
|
|
|
it('returns promise rejection for a bogus protocol', async function () {
|
|
|
|
await expect(
|
|
|
|
app.getApplicationInfoForProtocol('bogus-protocol://')
|
|
|
|
).to.eventually.be.rejectedWith(
|
|
|
|
'Unable to retrieve installation path to app'
|
|
|
|
);
|
|
|
|
});
|
|
|
|
|
|
|
|
it('returns resolved promise with appPath, displayName and icon', async function () {
|
|
|
|
const appInfo = await app.getApplicationInfoForProtocol('https://');
|
|
|
|
expect(appInfo.path).not.to.be.undefined();
|
|
|
|
expect(appInfo.name).not.to.be.undefined();
|
|
|
|
expect(appInfo.icon).not.to.be.undefined();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
2019-11-07 01:50:33 +00:00
|
|
|
describe('isDefaultProtocolClient()', () => {
|
|
|
|
it('returns false for a bogus protocol', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.isDefaultProtocolClient('bogus-protocol://')).to.equal(false);
|
|
|
|
});
|
|
|
|
});
|
2016-11-06 10:59:17 +00:00
|
|
|
|
2021-03-16 21:02:47 +00:00
|
|
|
ifdescribe(process.platform === 'win32')('app launch through uri', () => {
|
2020-06-30 22:10:36 +00:00
|
|
|
it('does not launch for argument following a URL', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', 'quit-app');
|
2018-01-22 22:49:30 +00:00
|
|
|
// App should exit with non 123 code.
|
2020-03-20 20:28:31 +00:00
|
|
|
const first = cp.spawn(process.execPath, [appPath, 'electron-test:?', 'abc']);
|
2020-06-30 22:10:36 +00:00
|
|
|
const [code] = await emittedOnce(first, 'exit');
|
|
|
|
expect(code).to.not.equal(123);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2018-01-22 22:49:30 +00:00
|
|
|
|
2020-06-30 22:10:36 +00:00
|
|
|
it('launches successfully for argument following a file path', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', 'quit-app');
|
2018-01-22 22:49:30 +00:00
|
|
|
// App should exit with code 123.
|
2020-03-20 20:28:31 +00:00
|
|
|
const first = cp.spawn(process.execPath, [appPath, 'e:\\abc', 'abc']);
|
2020-06-30 22:10:36 +00:00
|
|
|
const [code] = await emittedOnce(first, 'exit');
|
|
|
|
expect(code).to.equal(123);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2018-01-22 22:49:30 +00:00
|
|
|
|
2020-06-30 22:10:36 +00:00
|
|
|
it('launches successfully for multiple URIs following --', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', 'quit-app');
|
2018-05-22 16:51:03 +00:00
|
|
|
// App should exit with code 123.
|
2020-03-20 20:28:31 +00:00
|
|
|
const first = cp.spawn(process.execPath, [appPath, '--', 'http://electronjs.org', 'electron-test://testdata']);
|
2020-06-30 22:10:36 +00:00
|
|
|
const [code] = await emittedOnce(first, 'exit');
|
|
|
|
expect(code).to.equal(123);
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
});
|
2018-01-22 22:49:30 +00:00
|
|
|
|
2019-10-30 23:38:21 +00:00
|
|
|
// FIXME Get these specs running on Linux CI
|
|
|
|
ifdescribe(process.platform !== 'linux')('getFileIcon() API', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const iconPath = path.join(__dirname, 'fixtures/assets/icon.ico');
|
2016-11-06 10:59:17 +00:00
|
|
|
const sizes = {
|
|
|
|
small: 16,
|
|
|
|
normal: 32,
|
2017-02-07 19:20:27 +00:00
|
|
|
large: process.platform === 'win32' ? 32 : 48
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|
2016-11-06 10:59:17 +00:00
|
|
|
|
2018-12-05 16:50:12 +00:00
|
|
|
it('fetches a non-empty icon', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const icon = await app.getFileIcon(iconPath);
|
|
|
|
expect(icon.isEmpty()).to.equal(false);
|
|
|
|
});
|
2016-11-06 10:59:17 +00:00
|
|
|
|
2018-12-05 16:50:12 +00:00
|
|
|
it('fetches normal icon size by default', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const icon = await app.getFileIcon(iconPath);
|
|
|
|
const size = icon.getSize();
|
2018-06-14 16:44:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(size.height).to.equal(sizes.normal);
|
|
|
|
expect(size.width).to.equal(sizes.normal);
|
|
|
|
});
|
2016-11-06 10:59:17 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('size option', () => {
|
2018-12-05 16:50:12 +00:00
|
|
|
it('fetches a small icon', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const icon = await app.getFileIcon(iconPath, { size: 'small' });
|
|
|
|
const size = icon.getSize();
|
2018-12-05 16:50:12 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(size.height).to.equal(sizes.small);
|
|
|
|
expect(size.width).to.equal(sizes.small);
|
|
|
|
});
|
2016-11-06 10:59:17 +00:00
|
|
|
|
2018-12-05 16:50:12 +00:00
|
|
|
it('fetches a normal icon', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const icon = await app.getFileIcon(iconPath, { size: 'normal' });
|
|
|
|
const size = icon.getSize();
|
2018-12-05 16:50:12 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(size.height).to.equal(sizes.normal);
|
|
|
|
expect(size.width).to.equal(sizes.normal);
|
|
|
|
});
|
2016-11-06 10:59:17 +00:00
|
|
|
|
2018-12-05 16:50:12 +00:00
|
|
|
it('fetches a large icon', async () => {
|
2017-02-07 18:16:09 +00:00
|
|
|
// macOS does not support large icons
|
2020-03-20 20:28:31 +00:00
|
|
|
if (process.platform === 'darwin') return;
|
2017-02-07 18:16:09 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const icon = await app.getFileIcon(iconPath, { size: 'large' });
|
|
|
|
const size = icon.getSize();
|
2018-12-05 16:50:12 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(size.height).to.equal(sizes.large);
|
|
|
|
expect(size.width).to.equal(sizes.large);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2017-04-27 04:04:53 +00:00
|
|
|
|
2018-08-09 18:35:29 +00:00
|
|
|
describe('getAppMetrics() API', () => {
|
2018-06-18 04:00:17 +00:00
|
|
|
it('returns memory and cpu stats of all running electron processes', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appMetrics = app.getAppMetrics();
|
|
|
|
expect(appMetrics).to.be.an('array').and.have.lengthOf.at.least(1, 'App memory info object is not > 0');
|
2018-06-14 16:44:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const types = [];
|
2019-06-14 19:39:55 +00:00
|
|
|
for (const entry of appMetrics) {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(entry.pid).to.be.above(0, 'pid is not > 0');
|
|
|
|
expect(entry.type).to.be.a('string').that.does.not.equal('');
|
|
|
|
expect(entry.creationTime).to.be.a('number').that.is.greaterThan(0);
|
2018-06-14 16:44:27 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
types.push(entry.type);
|
|
|
|
expect(entry.cpu).to.have.ownProperty('percentCPUUsage').that.is.a('number');
|
|
|
|
expect(entry.cpu).to.have.ownProperty('idleWakeupsPerSecond').that.is.a('number');
|
2019-06-14 19:39:55 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(entry.memory).to.have.property('workingSetSize').that.is.greaterThan(0);
|
|
|
|
expect(entry.memory).to.have.property('peakWorkingSetSize').that.is.greaterThan(0);
|
2019-07-23 20:41:59 +00:00
|
|
|
|
2020-10-19 11:55:47 +00:00
|
|
|
if (entry.type === 'Utility' || entry.type === 'GPU') {
|
|
|
|
expect(entry.serviceName).to.be.a('string').that.does.not.equal('');
|
|
|
|
}
|
|
|
|
|
2020-07-07 18:00:45 +00:00
|
|
|
if (entry.type === 'Utility') {
|
|
|
|
expect(entry).to.have.property('name').that.is.a('string');
|
|
|
|
}
|
|
|
|
|
2019-07-23 20:41:59 +00:00
|
|
|
if (process.platform === 'win32') {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(entry.memory).to.have.property('privateBytes').that.is.greaterThan(0);
|
2019-07-23 20:41:59 +00:00
|
|
|
}
|
|
|
|
|
2019-06-14 19:39:55 +00:00
|
|
|
if (process.platform !== 'linux') {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(entry.sandboxed).to.be.a('boolean');
|
2019-06-14 19:39:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (process.platform === 'win32') {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(entry.integrityLevel).to.be.a('string');
|
2019-06-14 19:39:55 +00:00
|
|
|
}
|
2017-05-04 20:43:45 +00:00
|
|
|
}
|
2017-05-26 15:53:26 +00:00
|
|
|
|
2017-05-26 17:10:56 +00:00
|
|
|
if (process.platform === 'darwin') {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(types).to.include('GPU');
|
2017-05-26 16:14:17 +00:00
|
|
|
}
|
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(types).to.include('Browser');
|
|
|
|
});
|
|
|
|
});
|
2017-05-30 20:00:00 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('getGPUFeatureStatus() API', () => {
|
|
|
|
it('returns the graphic features statuses', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const features = app.getGPUFeatureStatus();
|
|
|
|
expect(features).to.have.ownProperty('webgl').that.is.a('string');
|
|
|
|
expect(features).to.have.ownProperty('gpu_compositing').that.is.a('string');
|
|
|
|
});
|
|
|
|
});
|
2017-06-28 15:33:06 +00:00
|
|
|
|
2020-06-22 17:35:10 +00:00
|
|
|
// FIXME https://github.com/electron/electron/issues/24224
|
|
|
|
ifdescribe(process.platform !== 'linux')('getGPUInfo() API', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', 'gpu-info.js');
|
2018-10-02 01:34:52 +00:00
|
|
|
|
2019-03-10 22:38:44 +00:00
|
|
|
const getGPUInfo = async (type: string) => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appProcess = cp.spawn(process.execPath, [appPath, type]);
|
|
|
|
let gpuInfoData = '';
|
|
|
|
let errorData = '';
|
2018-10-02 01:34:52 +00:00
|
|
|
appProcess.stdout.on('data', (data) => {
|
2020-03-20 20:28:31 +00:00
|
|
|
gpuInfoData += data;
|
|
|
|
});
|
2018-10-02 01:34:52 +00:00
|
|
|
appProcess.stderr.on('data', (data) => {
|
2020-03-20 20:28:31 +00:00
|
|
|
errorData += data;
|
|
|
|
});
|
|
|
|
const [exitCode] = await emittedOnce(appProcess, 'exit');
|
2018-10-02 01:34:52 +00:00
|
|
|
if (exitCode === 0) {
|
|
|
|
// return info data on successful exit
|
2020-03-20 20:28:31 +00:00
|
|
|
return JSON.parse(gpuInfoData);
|
2018-10-02 01:34:52 +00:00
|
|
|
} else {
|
|
|
|
// return error if not clean exit
|
2020-03-20 20:28:31 +00:00
|
|
|
return Promise.reject(new Error(errorData));
|
2018-10-01 02:57:38 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
};
|
2019-03-10 22:38:44 +00:00
|
|
|
const verifyBasicGPUInfo = async (gpuInfo: any) => {
|
2018-10-02 01:34:52 +00:00
|
|
|
// Devices information is always present in the available info.
|
2019-03-10 22:38:44 +00:00
|
|
|
expect(gpuInfo).to.have.ownProperty('gpuDevice')
|
2018-10-02 01:34:52 +00:00
|
|
|
.that.is.an('array')
|
2020-03-20 20:28:31 +00:00
|
|
|
.and.does.not.equal([]);
|
2018-10-02 01:34:52 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const device = gpuInfo.gpuDevice[0];
|
2018-10-02 01:34:52 +00:00
|
|
|
expect(device).to.be.an('object')
|
|
|
|
.and.to.have.property('deviceId')
|
|
|
|
.that.is.a('number')
|
2020-03-20 20:28:31 +00:00
|
|
|
.not.lessThan(0);
|
|
|
|
};
|
2018-10-01 02:57:38 +00:00
|
|
|
|
2018-10-02 01:34:52 +00:00
|
|
|
it('succeeds with basic GPUInfo', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const gpuInfo = await getGPUInfo('basic');
|
|
|
|
await verifyBasicGPUInfo(gpuInfo);
|
|
|
|
});
|
2018-09-27 14:59:23 +00:00
|
|
|
|
2018-10-15 15:26:47 +00:00
|
|
|
it('succeeds with complete GPUInfo', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const completeInfo = await getGPUInfo('complete');
|
2018-10-15 15:26:47 +00:00
|
|
|
if (process.platform === 'linux') {
|
2018-10-08 04:06:50 +00:00
|
|
|
// For linux and macOS complete info is same as basic info
|
2020-03-20 20:28:31 +00:00
|
|
|
await verifyBasicGPUInfo(completeInfo);
|
|
|
|
const basicInfo = await getGPUInfo('basic');
|
|
|
|
expect(completeInfo).to.deep.equal(basicInfo);
|
2018-10-02 01:34:52 +00:00
|
|
|
} else {
|
|
|
|
// Gl version is present in the complete info.
|
2019-03-10 22:38:44 +00:00
|
|
|
expect(completeInfo).to.have.ownProperty('auxAttributes')
|
2020-03-20 20:28:31 +00:00
|
|
|
.that.is.an('object');
|
2020-03-03 21:35:05 +00:00
|
|
|
if (completeInfo.gpuDevice.active) {
|
|
|
|
expect(completeInfo.auxAttributes).to.have.ownProperty('glVersion')
|
|
|
|
.that.is.a('string')
|
2020-03-20 20:28:31 +00:00
|
|
|
.and.does.not.equal([]);
|
2020-03-03 21:35:05 +00:00
|
|
|
}
|
2018-10-02 01:34:52 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2018-09-27 14:59:23 +00:00
|
|
|
|
2018-10-02 01:34:52 +00:00
|
|
|
it('fails for invalid info_type', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const invalidType = 'invalid';
|
|
|
|
const expectedErrorMessage = "Invalid info type. Use 'basic' or 'complete'";
|
|
|
|
return expect(app.getGPUInfo(invalidType as any)).to.eventually.be.rejectedWith(expectedErrorMessage);
|
|
|
|
});
|
|
|
|
});
|
2018-09-27 14:59:23 +00:00
|
|
|
|
2021-04-09 07:09:17 +00:00
|
|
|
describe('sandbox options', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
let appProcess: cp.ChildProcess = null as any;
|
|
|
|
let server: net.Server = null as any;
|
|
|
|
const socketPath = process.platform === 'win32' ? '\\\\.\\pipe\\electron-mixed-sandbox' : '/tmp/electron-mixed-sandbox';
|
2017-06-28 15:33:06 +00:00
|
|
|
|
2017-11-15 21:05:46 +00:00
|
|
|
beforeEach(function (done) {
|
2018-12-06 01:42:12 +00:00
|
|
|
if (process.platform === 'linux' && (process.arch === 'arm64' || process.arch === 'arm')) {
|
|
|
|
// Our ARM tests are run on VSTS rather than CircleCI, and the Docker
|
|
|
|
// setup on VSTS disallows syscalls that Chrome requires for setting up
|
|
|
|
// sandboxing.
|
|
|
|
// See:
|
|
|
|
// - https://docs.docker.com/engine/security/seccomp/#significant-syscalls-blocked-by-the-default-profile
|
|
|
|
// - https://chromium.googlesource.com/chromium/src/+/70.0.3538.124/sandbox/linux/services/credentials.cc#292
|
|
|
|
// - https://github.com/docker/docker-ce/blob/ba7dfc59ccfe97c79ee0d1379894b35417b40bca/components/engine/profiles/seccomp/seccomp_default.go#L497
|
|
|
|
// - https://blog.jessfraz.com/post/how-to-use-new-docker-seccomp-profiles/
|
|
|
|
//
|
|
|
|
// Adding `--cap-add SYS_ADMIN` or `--security-opt seccomp=unconfined`
|
|
|
|
// to the Docker invocation allows the syscalls that Chrome needs, but
|
|
|
|
// are probably more permissive than we'd like.
|
2020-03-20 20:28:31 +00:00
|
|
|
this.skip();
|
2017-11-15 21:05:46 +00:00
|
|
|
}
|
2017-06-28 16:27:19 +00:00
|
|
|
fs.unlink(socketPath, () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
server = net.createServer();
|
|
|
|
server.listen(socketPath);
|
|
|
|
done();
|
|
|
|
});
|
|
|
|
});
|
2017-06-28 16:27:19 +00:00
|
|
|
|
2018-06-14 16:44:27 +00:00
|
|
|
afterEach(done => {
|
2020-03-20 20:28:31 +00:00
|
|
|
if (appProcess != null) appProcess.kill();
|
2017-06-28 16:27:19 +00:00
|
|
|
|
|
|
|
server.close(() => {
|
|
|
|
if (process.platform === 'win32') {
|
2020-03-20 20:28:31 +00:00
|
|
|
done();
|
2017-06-28 16:27:19 +00:00
|
|
|
} else {
|
2020-03-20 20:28:31 +00:00
|
|
|
fs.unlink(socketPath, () => done());
|
2017-06-28 16:27:19 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
});
|
2017-06-28 15:33:06 +00:00
|
|
|
|
2018-10-10 04:32:09 +00:00
|
|
|
describe('when app.enableSandbox() is called', () => {
|
2021-03-16 21:02:47 +00:00
|
|
|
it('adds --enable-sandbox to all renderer processes', done => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', 'mixed-sandbox-app');
|
|
|
|
appProcess = cp.spawn(process.execPath, [appPath, '--app-enable-sandbox']);
|
2018-10-10 04:32:09 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
server.once('error', error => { done(error); });
|
2018-10-10 04:32:09 +00:00
|
|
|
|
|
|
|
server.on('connection', client => {
|
2019-03-10 22:38:44 +00:00
|
|
|
client.once('data', (data) => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const argv = JSON.parse(data.toString());
|
|
|
|
expect(argv.sandbox).to.include('--enable-sandbox');
|
|
|
|
expect(argv.sandbox).to.not.include('--no-sandbox');
|
2018-10-10 04:32:09 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(argv.noSandbox).to.include('--enable-sandbox');
|
|
|
|
expect(argv.noSandbox).to.not.include('--no-sandbox');
|
2018-10-10 04:32:09 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(argv.noSandboxDevtools).to.equal(true);
|
|
|
|
expect(argv.sandboxDevtools).to.equal(true);
|
2018-10-10 04:32:09 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
done();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2018-10-10 04:32:09 +00:00
|
|
|
|
|
|
|
describe('when the app is launched with --enable-sandbox', () => {
|
2021-03-16 21:02:47 +00:00
|
|
|
it('adds --enable-sandbox to all renderer processes', done => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', 'mixed-sandbox-app');
|
|
|
|
appProcess = cp.spawn(process.execPath, [appPath, '--enable-sandbox']);
|
2018-10-10 04:32:09 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
server.once('error', error => { done(error); });
|
2018-10-10 04:32:09 +00:00
|
|
|
|
|
|
|
server.on('connection', client => {
|
|
|
|
client.once('data', data => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const argv = JSON.parse(data.toString());
|
|
|
|
expect(argv.sandbox).to.include('--enable-sandbox');
|
|
|
|
expect(argv.sandbox).to.not.include('--no-sandbox');
|
2018-10-10 04:32:09 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(argv.noSandbox).to.include('--enable-sandbox');
|
|
|
|
expect(argv.noSandbox).to.not.include('--no-sandbox');
|
2018-10-10 04:32:09 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(argv.noSandboxDevtools).to.equal(true);
|
|
|
|
expect(argv.sandboxDevtools).to.equal(true);
|
2018-10-10 04:32:09 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
done();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2017-07-13 22:27:03 +00:00
|
|
|
|
2017-10-27 20:45:58 +00:00
|
|
|
describe('disableDomainBlockingFor3DAPIs() API', () => {
|
|
|
|
it('throws when called after app is ready', () => {
|
2018-06-14 16:44:27 +00:00
|
|
|
expect(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.disableDomainBlockingFor3DAPIs();
|
|
|
|
}).to.throw(/before app is ready/);
|
|
|
|
});
|
|
|
|
});
|
2018-02-27 06:15:06 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
const dockDescribe = process.platform === 'darwin' ? describe : describe.skip;
|
2019-02-14 22:29:20 +00:00
|
|
|
dockDescribe('dock APIs', () => {
|
2019-03-10 22:38:44 +00:00
|
|
|
after(async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
await app.dock.show();
|
|
|
|
});
|
2019-03-10 22:38:44 +00:00
|
|
|
|
2019-02-14 22:29:20 +00:00
|
|
|
describe('dock.setMenu', () => {
|
|
|
|
it('can be retrieved via dock.getMenu', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.dock.getMenu()).to.equal(null);
|
|
|
|
const menu = new Menu();
|
|
|
|
app.dock.setMenu(menu);
|
|
|
|
expect(app.dock.getMenu()).to.equal(menu);
|
|
|
|
});
|
2019-02-13 05:06:33 +00:00
|
|
|
|
2019-02-14 22:29:20 +00:00
|
|
|
it('keeps references to the menu', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.dock.setMenu(new Menu());
|
2020-06-23 03:32:45 +00:00
|
|
|
const v8Util = process._linkedBinding('electron_common_v8_util');
|
2020-03-20 20:28:31 +00:00
|
|
|
v8Util.requestGarbageCollectionForTesting();
|
|
|
|
});
|
|
|
|
});
|
2018-02-27 06:15:06 +00:00
|
|
|
|
2021-01-04 20:58:31 +00:00
|
|
|
describe('dock.setIcon', () => {
|
|
|
|
it('throws a descriptive error for a bad icon path', () => {
|
|
|
|
const badPath = path.resolve('I', 'Do', 'Not', 'Exist');
|
|
|
|
expect(() => {
|
|
|
|
app.dock.setIcon(badPath);
|
|
|
|
}).to.throw(/Failed to load image from path (.+)/);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
2019-02-14 22:29:20 +00:00
|
|
|
describe('dock.bounce', () => {
|
|
|
|
it('should return -1 for unknown bounce type', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.dock.bounce('bad type' as any)).to.equal(-1);
|
|
|
|
});
|
2019-02-14 22:29:20 +00:00
|
|
|
|
|
|
|
it('should return a positive number for informational type', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appHasFocus = !!BrowserWindow.getFocusedWindow();
|
2019-02-14 22:29:20 +00:00
|
|
|
if (!appHasFocus) {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.dock.bounce('informational')).to.be.at.least(0);
|
2019-02-14 22:29:20 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2019-02-14 22:29:20 +00:00
|
|
|
|
|
|
|
it('should return a positive number for critical type', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appHasFocus = !!BrowserWindow.getFocusedWindow();
|
2019-02-14 22:29:20 +00:00
|
|
|
if (!appHasFocus) {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.dock.bounce('critical')).to.be.at.least(0);
|
2019-02-14 22:29:20 +00:00
|
|
|
}
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
|
|
|
});
|
2019-02-14 22:29:20 +00:00
|
|
|
|
|
|
|
describe('dock.cancelBounce', () => {
|
|
|
|
it('should not throw', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.dock.cancelBounce(app.dock.bounce('critical'));
|
|
|
|
});
|
|
|
|
});
|
2019-02-14 22:29:20 +00:00
|
|
|
|
|
|
|
describe('dock.setBadge', () => {
|
|
|
|
after(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.dock.setBadge('');
|
|
|
|
});
|
2019-02-14 22:29:20 +00:00
|
|
|
|
|
|
|
it('should not throw', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.dock.setBadge('1');
|
|
|
|
});
|
2019-02-14 22:29:20 +00:00
|
|
|
|
|
|
|
it('should be retrievable via getBadge', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.dock.setBadge('test');
|
|
|
|
expect(app.dock.getBadge()).to.equal('test');
|
|
|
|
});
|
|
|
|
});
|
2019-02-14 22:29:20 +00:00
|
|
|
|
2020-09-03 11:46:24 +00:00
|
|
|
describe('dock.hide', () => {
|
|
|
|
it('should not throw', () => {
|
|
|
|
app.dock.hide();
|
|
|
|
expect(app.dock.isVisible()).to.equal(false);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
// Note that dock.show tests should run after dock.hide tests, to work
|
|
|
|
// around a bug of macOS.
|
|
|
|
// See https://github.com/electron/electron/pull/25269 for more.
|
2019-02-14 22:29:20 +00:00
|
|
|
describe('dock.show', () => {
|
|
|
|
it('should not throw', () => {
|
|
|
|
return app.dock.show().then(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.dock.isVisible()).to.equal(true);
|
|
|
|
});
|
|
|
|
});
|
2019-02-13 05:06:33 +00:00
|
|
|
|
|
|
|
it('returns a Promise', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.dock.show()).to.be.a('promise');
|
|
|
|
});
|
2019-02-13 05:06:33 +00:00
|
|
|
|
2019-03-10 22:38:44 +00:00
|
|
|
it('eventually fulfills', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
await expect(app.dock.show()).to.eventually.be.fulfilled.equal(undefined);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2018-04-20 07:09:23 +00:00
|
|
|
|
|
|
|
describe('whenReady', () => {
|
|
|
|
it('returns a Promise', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.whenReady()).to.be.a('promise');
|
|
|
|
});
|
2018-04-20 07:09:23 +00:00
|
|
|
|
2019-03-15 00:22:42 +00:00
|
|
|
it('becomes fulfilled if the app is already ready', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.isReady()).to.equal(true);
|
|
|
|
await expect(app.whenReady()).to.be.eventually.fulfilled.equal(undefined);
|
|
|
|
});
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
2019-04-02 20:36:57 +00:00
|
|
|
describe('app.applicationMenu', () => {
|
|
|
|
it('has the applicationMenu property', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app).to.have.property('applicationMenu');
|
|
|
|
});
|
|
|
|
});
|
2019-04-02 20:36:57 +00:00
|
|
|
|
2019-01-07 15:48:27 +00:00
|
|
|
describe('commandLine.hasSwitch', () => {
|
|
|
|
it('returns true when present', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.commandLine.appendSwitch('foobar1');
|
|
|
|
expect(app.commandLine.hasSwitch('foobar1')).to.equal(true);
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
|
|
|
it('returns false when not present', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.commandLine.hasSwitch('foobar2')).to.equal(false);
|
|
|
|
});
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
2021-04-09 07:09:17 +00:00
|
|
|
describe('commandLine.hasSwitch (existing argv)', () => {
|
2019-01-07 15:48:27 +00:00
|
|
|
it('returns true when present', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const { hasSwitch } = await runTestApp('command-line', '--foobar');
|
|
|
|
expect(hasSwitch).to.equal(true);
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
|
|
|
it('returns false when not present', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const { hasSwitch } = await runTestApp('command-line');
|
|
|
|
expect(hasSwitch).to.equal(false);
|
|
|
|
});
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
|
|
|
describe('commandLine.getSwitchValue', () => {
|
|
|
|
it('returns the value when present', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.commandLine.appendSwitch('foobar', 'æøåü');
|
|
|
|
expect(app.commandLine.getSwitchValue('foobar')).to.equal('æøåü');
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
|
|
|
it('returns an empty string when present without value', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.commandLine.appendSwitch('foobar1');
|
|
|
|
expect(app.commandLine.getSwitchValue('foobar1')).to.equal('');
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
|
|
|
it('returns an empty string when not present', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(app.commandLine.getSwitchValue('foobar2')).to.equal('');
|
|
|
|
});
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
2021-04-09 07:09:17 +00:00
|
|
|
describe('commandLine.getSwitchValue (existing argv)', () => {
|
2019-01-07 15:48:27 +00:00
|
|
|
it('returns the value when present', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const { getSwitchValue } = await runTestApp('command-line', '--foobar=test');
|
|
|
|
expect(getSwitchValue).to.equal('test');
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
|
|
|
it('returns an empty string when present without value', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const { getSwitchValue } = await runTestApp('command-line', '--foobar');
|
|
|
|
expect(getSwitchValue).to.equal('');
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
|
|
|
it('returns an empty string when not present', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const { getSwitchValue } = await runTestApp('command-line');
|
|
|
|
expect(getSwitchValue).to.equal('');
|
|
|
|
});
|
|
|
|
});
|
2020-05-21 15:53:44 +00:00
|
|
|
|
|
|
|
ifdescribe(process.platform === 'darwin')('app.setSecureKeyboardEntryEnabled', () => {
|
|
|
|
it('changes Secure Keyboard Entry is enabled', () => {
|
|
|
|
app.setSecureKeyboardEntryEnabled(true);
|
|
|
|
expect(app.isSecureKeyboardEntryEnabled()).to.equal(true);
|
|
|
|
app.setSecureKeyboardEntryEnabled(false);
|
|
|
|
expect(app.isSecureKeyboardEntryEnabled()).to.equal(false);
|
|
|
|
});
|
|
|
|
});
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
2021-04-09 07:09:17 +00:00
|
|
|
describe('default behavior', () => {
|
2019-01-15 20:35:53 +00:00
|
|
|
describe('application menu', () => {
|
|
|
|
it('creates the default menu if the app does not set it', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const result = await runTestApp('default-menu');
|
|
|
|
expect(result).to.equal(false);
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
2019-01-15 20:35:53 +00:00
|
|
|
it('does not create the default menu if the app sets a custom menu', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const result = await runTestApp('default-menu', '--custom-menu');
|
|
|
|
expect(result).to.equal(true);
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
2019-01-15 20:35:53 +00:00
|
|
|
it('does not create the default menu if the app sets a null menu', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const result = await runTestApp('default-menu', '--null-menu');
|
|
|
|
expect(result).to.equal(true);
|
|
|
|
});
|
|
|
|
});
|
2019-01-15 20:35:53 +00:00
|
|
|
|
|
|
|
describe('window-all-closed', () => {
|
2021-04-28 17:55:08 +00:00
|
|
|
afterEach(closeAllWindows);
|
|
|
|
|
2019-01-15 20:35:53 +00:00
|
|
|
it('quits when the app does not handle the event', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const result = await runTestApp('window-all-closed');
|
|
|
|
expect(result).to.equal(false);
|
|
|
|
});
|
2019-01-07 15:48:27 +00:00
|
|
|
|
2019-01-15 20:35:53 +00:00
|
|
|
it('does not quit when the app handles the event', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const result = await runTestApp('window-all-closed', '--handle-event');
|
|
|
|
expect(result).to.equal(true);
|
|
|
|
});
|
2021-04-28 17:55:08 +00:00
|
|
|
|
|
|
|
it('should omit closed windows from getAllWindows', async () => {
|
|
|
|
const w = new BrowserWindow({ show: false });
|
|
|
|
const len = new Promise(resolve => {
|
|
|
|
app.on('window-all-closed', () => {
|
|
|
|
resolve(BrowserWindow.getAllWindows().length);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
w.close();
|
|
|
|
expect(await len).to.equal(0);
|
|
|
|
});
|
2020-03-20 20:28:31 +00:00
|
|
|
});
|
2019-05-01 23:34:42 +00:00
|
|
|
|
|
|
|
describe('user agent fallback', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
let initialValue: string;
|
2019-05-01 23:34:42 +00:00
|
|
|
|
|
|
|
before(() => {
|
2020-03-20 20:28:31 +00:00
|
|
|
initialValue = app.userAgentFallback!;
|
|
|
|
});
|
2019-05-01 23:34:42 +00:00
|
|
|
|
|
|
|
it('should have a reasonable default', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
expect(initialValue).to.include(`Electron/${process.versions.electron}`);
|
|
|
|
expect(initialValue).to.include(`Chrome/${process.versions.chrome}`);
|
|
|
|
});
|
2019-05-01 23:34:42 +00:00
|
|
|
|
|
|
|
it('should be overridable', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.userAgentFallback = 'test-agent/123';
|
|
|
|
expect(app.userAgentFallback).to.equal('test-agent/123');
|
|
|
|
});
|
2019-05-01 23:34:42 +00:00
|
|
|
|
|
|
|
it('should be restorable', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
app.userAgentFallback = 'test-agent/123';
|
|
|
|
app.userAgentFallback = '';
|
|
|
|
expect(app.userAgentFallback).to.equal(initialValue);
|
|
|
|
});
|
|
|
|
});
|
2019-05-31 22:47:18 +00:00
|
|
|
|
2019-11-11 17:47:01 +00:00
|
|
|
describe('login event', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
afterEach(closeAllWindows);
|
|
|
|
let server: http.Server;
|
|
|
|
let serverUrl: string;
|
2019-11-11 17:47:01 +00:00
|
|
|
|
|
|
|
before((done) => {
|
|
|
|
server = http.createServer((request, response) => {
|
|
|
|
if (request.headers.authorization) {
|
2020-03-20 20:28:31 +00:00
|
|
|
return response.end('ok');
|
2019-11-11 17:47:01 +00:00
|
|
|
}
|
|
|
|
response
|
|
|
|
.writeHead(401, { 'WWW-Authenticate': 'Basic realm="Foo"' })
|
2020-03-20 20:28:31 +00:00
|
|
|
.end();
|
2019-11-11 17:47:01 +00:00
|
|
|
}).listen(0, '127.0.0.1', () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
serverUrl = 'http://127.0.0.1:' + (server.address() as net.AddressInfo).port;
|
|
|
|
done();
|
|
|
|
});
|
|
|
|
});
|
2019-11-11 17:47:01 +00:00
|
|
|
|
|
|
|
it('should emit a login event on app when a WebContents hits a 401', async () => {
|
2020-03-20 20:28:31 +00:00
|
|
|
const w = new BrowserWindow({ show: false });
|
|
|
|
w.loadURL(serverUrl);
|
|
|
|
const [, webContents] = await emittedOnce(app, 'login');
|
|
|
|
expect(webContents).to.equal(w.webContents);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2019-01-15 20:35:53 +00:00
|
|
|
|
2019-03-10 22:38:44 +00:00
|
|
|
async function runTestApp (name: string, ...args: any[]) {
|
2020-03-20 20:28:31 +00:00
|
|
|
const appPath = path.join(fixturesPath, 'api', name);
|
|
|
|
const electronPath = process.execPath;
|
|
|
|
const appProcess = cp.spawn(electronPath, [appPath, ...args]);
|
2019-01-15 20:35:53 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
let output = '';
|
|
|
|
appProcess.stdout.on('data', (data) => { output += data; });
|
2019-01-15 20:35:53 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
await emittedOnce(appProcess.stdout, 'end');
|
2019-01-15 20:35:53 +00:00
|
|
|
|
2020-03-20 20:28:31 +00:00
|
|
|
return JSON.parse(output);
|
2019-01-15 20:35:53 +00:00
|
|
|
}
|