nativescript 8.9.0-dev.1 → 8.9.0-dev.2

package/lib/commands/setup.js

@@ -13,3 +13,4 @@ class SetupCommand {
 }
 exports.SetupCommand = SetupCommand;
 yok_1.injector.registerCommand("setup|*", SetupCommand);
+//# sourceMappingURL=setup.js.map

package/lib/commands/start.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartCommand = void 0;
 const header_1 = require("../common/header");
@@ -7,14 +16,19 @@ class StartCommand {
     constructor($startService) {
         this.$startService = $startService;
     }
-    async execute(args) {
-        (0, header_1.printHeader)();
-        this.$startService.start();
-        return;
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, header_1.printHeader)();
+            this.$startService.start();
+            return;
+        });
     }
-    async canExecute(args) {
-        return true;
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
     }
 }
 exports.StartCommand = StartCommand;
 yok_1.injector.registerCommand("start", StartCommand);
+//# sourceMappingURL=start.js.map

package/lib/commands/test-init.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
 const _ = require("lodash");
@@ -24,133 +33,139 @@ class TestInitCommand {
         };
         this.$projectData.initializeProjectData();
     }
-    async execute(args) {
-        const projectDir = this.$projectData.projectDir;
-        const frameworkToInstall = this.$options.framework ||
-            (await this.$prompter.promptForChoice("Select testing framework:", constants_1.TESTING_FRAMEWORKS));
-        if (constants_1.TESTING_FRAMEWORKS.indexOf(frameworkToInstall) === -1) {
-            this.$errors.failWithHelp(`Unknown or unsupported unit testing framework: ${frameworkToInstall}.`);
-        }
-        const projectFilesExtension = this.$projectData.projectType === constants_1.ProjectTypes.TsFlavorName ||
-            this.$projectData.projectType === constants_1.ProjectTypes.NgFlavorName
-            ? ".ts"
-            : ".js";
-        let modulesToInstall = [];
-        try {
-            modulesToInstall = this.$testInitializationService.getDependencies(frameworkToInstall);
-        }
-        catch (err) {
-            this.$errors.fail(`Unable to install the unit testing dependencies. Error: '${err.message}'`);
-        }
-        modulesToInstall = modulesToInstall.filter((moduleToInstall) => !moduleToInstall.projectType ||
-            moduleToInstall.projectType === projectFilesExtension);
-        for (const mod of modulesToInstall) {
-            let moduleToInstall = mod.name;
-            moduleToInstall += `@${mod.version}`;
-            await this.$packageManager.install(moduleToInstall, projectDir, {
-                "save-dev": true,
-                "save-exact": true,
-                optional: false,
-                disableNpmInstall: this.$options.disableNpmInstall,
-                frameworkPath: this.$options.frameworkPath,
-                ignoreScripts: this.$options.ignoreScripts,
-                path: this.$options.path,
-            });
-            const modulePath = path.join(projectDir, "node_modules", mod.name);
-            const modulePackageJsonPath = path.join(modulePath, "package.json");
-            const modulePackageJsonContent = this.$fs.readJson(modulePackageJsonPath);
-            const modulePeerDependencies = modulePackageJsonContent.peerDependencies || {};
-            for (const peerDependency in modulePeerDependencies) {
-                const isPeerDependencyExcluded = _.includes(mod.excludedPeerDependencies, peerDependency);
-                if (isPeerDependencyExcluded) {
-                    continue;
-                }
-                const dependencyVersion = modulePeerDependencies[peerDependency] || "*";
-                try {
-                    await this.$packageManager.install(`${peerDependency}@${dependencyVersion}`, projectDir, {
-                        "save-dev": true,
-                        "save-exact": true,
-                        disableNpmInstall: false,
-                        frameworkPath: this.$options.frameworkPath,
-                        ignoreScripts: this.$options.ignoreScripts,
-                        path: this.$options.path,
-                    });
-                }
-                catch (e) {
-                    this.$logger.error(e.message);
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projectDir = this.$projectData.projectDir;
+            const frameworkToInstall = this.$options.framework ||
+                (yield this.$prompter.promptForChoice("Select testing framework:", constants_1.TESTING_FRAMEWORKS));
+            if (constants_1.TESTING_FRAMEWORKS.indexOf(frameworkToInstall) === -1) {
+                this.$errors.failWithHelp(`Unknown or unsupported unit testing framework: ${frameworkToInstall}.`);
+            }
+            const projectFilesExtension = this.$projectData.projectType === constants_1.ProjectTypes.TsFlavorName ||
+                this.$projectData.projectType === constants_1.ProjectTypes.NgFlavorName
+                ? ".ts"
+                : ".js";
+            let modulesToInstall = [];
+            try {
+                modulesToInstall = this.$testInitializationService.getDependencies(frameworkToInstall);
+            }
+            catch (err) {
+                this.$errors.fail(`Unable to install the unit testing dependencies. Error: '${err.message}'`);
+            }
+            modulesToInstall = modulesToInstall.filter((moduleToInstall) => !moduleToInstall.projectType ||
+                moduleToInstall.projectType === projectFilesExtension);
+            for (const mod of modulesToInstall) {
+                let moduleToInstall = mod.name;
+                moduleToInstall += `@${mod.version}`;
+                yield this.$packageManager.install(moduleToInstall, projectDir, {
+                    "save-dev": true,
+                    "save-exact": true,
+                    optional: false,
+                    disableNpmInstall: this.$options.disableNpmInstall,
+                    frameworkPath: this.$options.frameworkPath,
+                    ignoreScripts: this.$options.ignoreScripts,
+                    path: this.$options.path,
+                });
+                const modulePath = path.join(projectDir, "node_modules", mod.name);
+                const modulePackageJsonPath = path.join(modulePath, "package.json");
+                const modulePackageJsonContent = this.$fs.readJson(modulePackageJsonPath);
+                const modulePeerDependencies = modulePackageJsonContent.peerDependencies || {};
+                for (const peerDependency in modulePeerDependencies) {
+                    const isPeerDependencyExcluded = _.includes(mod.excludedPeerDependencies, peerDependency);
+                    if (isPeerDependencyExcluded) {
+                        continue;
+                    }
+                    const dependencyVersion = modulePeerDependencies[peerDependency] || "*";
+                    // catch errors when a peerDependency is already installed
+                    // e.g karma is installed; karma-jasmine depends on karma and will try to install it again
+                    try {
+                        yield this.$packageManager.install(`${peerDependency}@${dependencyVersion}`, projectDir, {
+                            "save-dev": true,
+                            "save-exact": true,
+                            disableNpmInstall: false,
+                            frameworkPath: this.$options.frameworkPath,
+                            ignoreScripts: this.$options.ignoreScripts,
+                            path: this.$options.path,
+                        });
+                    }
+                    catch (e) {
+                        this.$logger.error(e.message);
+                    }
                 }
             }
-        }
-        await this.$pluginsService.add("@nativescript/unit-test-runner", this.$projectData);
-        this.$logger.clearScreen();
-        const bufferedLogs = [];
-        const testsDir = path.join(this.$projectData.appDirectoryPath, "tests");
-        const projectTestsDir = path.relative(this.$projectData.projectDir, testsDir);
-        const relativeTestsDir = path.relative(this.$projectData.appDirectoryPath, testsDir);
-        let shouldCreateSampleTests = true;
-        if (this.$fs.exists(testsDir)) {
-            const specFilenamePattern = `<filename>.spec${projectFilesExtension}`;
-            bufferedLogs.push(color_1.color.yellow([
-                `Note: The "${projectTestsDir}" directory already exists, will not create example tests in the project.`,
-                `You may create "${specFilenamePattern}" files anywhere you'd like.`,
+            yield this.$pluginsService.add("@nativescript/unit-test-runner", this.$projectData);
+            this.$logger.clearScreen();
+            const bufferedLogs = [];
+            const testsDir = path.join(this.$projectData.appDirectoryPath, "tests");
+            const projectTestsDir = path.relative(this.$projectData.projectDir, testsDir);
+            const relativeTestsDir = path.relative(this.$projectData.appDirectoryPath, testsDir);
+            let shouldCreateSampleTests = true;
+            if (this.$fs.exists(testsDir)) {
+                const specFilenamePattern = `<filename>.spec${projectFilesExtension}`;
+                bufferedLogs.push(color_1.color.yellow([
+                    `Note: The "${projectTestsDir}" directory already exists, will not create example tests in the project.`,
+                    `You may create "${specFilenamePattern}" files anywhere you'd like.`,
+                    "",
+                ].join("\n")));
+                shouldCreateSampleTests = false;
+            }
+            this.$fs.ensureDirectoryExists(testsDir);
+            const frameworks = [frameworkToInstall]
+                .concat(this.karmaConfigAdditionalFrameworks[frameworkToInstall] || [])
+                .map((fw) => `'${fw}'`)
+                .join(", ");
+            const testFiles = `'${(0, helpers_1.fromWindowsRelativePathToUnix)(relativeTestsDir)}/**/*${projectFilesExtension}'`;
+            const karmaConfTemplate = this.$resources.readText("test/karma.conf.js");
+            const karmaConf = _.template(karmaConfTemplate)({
+                frameworks,
+                testFiles,
+                basePath: this.$projectData.getAppDirectoryRelativePath(),
+            });
+            this.$fs.writeFile(path.join(projectDir, "karma.conf.js"), karmaConf);
+            const exampleFilePath = this.$resources.resolvePath(`test/example.${frameworkToInstall}${projectFilesExtension}`);
+            const targetExampleTestPath = path.join(testsDir, `example.spec${projectFilesExtension}`);
+            if (shouldCreateSampleTests && this.$fs.exists(exampleFilePath)) {
+                this.$fs.copyFile(exampleFilePath, targetExampleTestPath);
+                const targetExampleTestRelativePath = path.relative(projectDir, targetExampleTestPath);
+                bufferedLogs.push(`Added example test: ${color_1.color.yellow(targetExampleTestRelativePath)}`);
+            }
+            // test main entry
+            const testMainResourcesPath = this.$resources.resolvePath(`test/test-main${projectFilesExtension}`);
+            const testMainPath = path.join(this.$projectData.appDirectoryPath, `test${projectFilesExtension}`);
+            if (!this.$fs.exists(testMainPath)) {
+                this.$fs.copyFile(testMainResourcesPath, testMainPath);
+                const testMainRelativePath = path.relative(projectDir, testMainPath);
+                bufferedLogs.push(`Main test entrypoint created: ${color_1.color.yellow(testMainRelativePath)}`);
+            }
+            const testTsConfigTemplate = this.$resources.readText("test/tsconfig.spec.json");
+            const testTsConfig = _.template(testTsConfigTemplate)({
+                basePath: this.$projectData.getAppDirectoryRelativePath(),
+            });
+            this.$fs.writeFile(path.join(projectDir, "tsconfig.spec.json"), testTsConfig);
+            bufferedLogs.push(`Added/replaced ${color_1.color.yellow("tsconfig.spec.json")}`);
+            const greyDollarSign = color_1.color.grey("$");
+            this.$logger.info([
+                [
+                    color_1.color.green(`Tests using`),
+                    color_1.color.cyan(frameworkToInstall),
+                    color_1.color.green(`were successfully initialized.`),
+                ].join(" "),
                 "",
-            ].join("\n")));
-            shouldCreateSampleTests = false;
-        }
-        this.$fs.ensureDirectoryExists(testsDir);
-        const frameworks = [frameworkToInstall]
-            .concat(this.karmaConfigAdditionalFrameworks[frameworkToInstall] || [])
-            .map((fw) => `'${fw}'`)
-            .join(", ");
-        const testFiles = `'${(0, helpers_1.fromWindowsRelativePathToUnix)(relativeTestsDir)}/**/*${projectFilesExtension}'`;
-        const karmaConfTemplate = this.$resources.readText("test/karma.conf.js");
-        const karmaConf = _.template(karmaConfTemplate)({
-            frameworks,
-            testFiles,
-            basePath: this.$projectData.getAppDirectoryRelativePath(),
-        });
-        this.$fs.writeFile(path.join(projectDir, "karma.conf.js"), karmaConf);
-        const exampleFilePath = this.$resources.resolvePath(`test/example.${frameworkToInstall}${projectFilesExtension}`);
-        const targetExampleTestPath = path.join(testsDir, `example.spec${projectFilesExtension}`);
-        if (shouldCreateSampleTests && this.$fs.exists(exampleFilePath)) {
-            this.$fs.copyFile(exampleFilePath, targetExampleTestPath);
-            const targetExampleTestRelativePath = path.relative(projectDir, targetExampleTestPath);
-            bufferedLogs.push(`Added example test: ${color_1.color.yellow(targetExampleTestRelativePath)}`);
-        }
-        const testMainResourcesPath = this.$resources.resolvePath(`test/test-main${projectFilesExtension}`);
-        const testMainPath = path.join(this.$projectData.appDirectoryPath, `test${projectFilesExtension}`);
-        if (!this.$fs.exists(testMainPath)) {
-            this.$fs.copyFile(testMainResourcesPath, testMainPath);
-            const testMainRelativePath = path.relative(projectDir, testMainPath);
-            bufferedLogs.push(`Main test entrypoint created: ${color_1.color.yellow(testMainRelativePath)}`);
-        }
-        const testTsConfigTemplate = this.$resources.readText("test/tsconfig.spec.json");
-        const testTsConfig = _.template(testTsConfigTemplate)({
-            basePath: this.$projectData.getAppDirectoryRelativePath(),
+                ...bufferedLogs,
+                "",
+                color_1.color.yellow(`Note: @nativescript/unit-test-runner was included in "dependencies" as a convenience to automatically adjust your app's Info.plist on iOS and AndroidManifest.xml on Android to ensure the socket connects properly.`),
+                "",
+                color_1.color.yellow(`For production you may want to move to "devDependencies" and manage the settings yourself.`),
+                "",
+                "",
+                `You can now run your tests:`,
+                "",
+                `  ${greyDollarSign} ${color_1.color.green("ns test ios")}`,
+                `  ${greyDollarSign} ${color_1.color.green("ns test android")}`,
+                "",
+            ].join("\n"));
         });
-        this.$fs.writeFile(path.join(projectDir, "tsconfig.spec.json"), testTsConfig);
-        bufferedLogs.push(`Added/replaced ${color_1.color.yellow("tsconfig.spec.json")}`);
-        const greyDollarSign = color_1.color.grey("$");
-        this.$logger.info([
-            [
-                color_1.color.green(`Tests using`),
-                color_1.color.cyan(frameworkToInstall),
-                color_1.color.green(`were successfully initialized.`),
-            ].join(" "),
-            "",
-            ...bufferedLogs,
-            "",
-            color_1.color.yellow(`Note: @nativescript/unit-test-runner was included in "dependencies" as a convenience to automatically adjust your app's Info.plist on iOS and AndroidManifest.xml on Android to ensure the socket connects properly.`),
-            "",
-            color_1.color.yellow(`For production you may want to move to "devDependencies" and manage the settings yourself.`),
-            "",
-            "",
-            `You can now run your tests:`,
-            "",
-            `  ${greyDollarSign} ${color_1.color.green("ns test ios")}`,
-            `  ${greyDollarSign} ${color_1.color.green("ns test android")}`,
-            "",
-        ].join("\n"));
     }
 }
 yok_1.injector.registerCommand("test|init", TestInitCommand);
+//# sourceMappingURL=test-init.js.map

package/lib/commands/test.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const helpers_1 = require("../common/helpers");
 const constants_1 = require("../constants");
@@ -7,66 +16,76 @@ class TestCommandBase {
     constructor() {
         this.allowedParameters = [];
         this.dashedOptions = {
-            hmr: { type: "boolean", default: false, hasSensitiveValue: false },
+            hmr: { type: "boolean" /* OptionType.Boolean */, default: false, hasSensitiveValue: false },
         };
     }
-    async execute(args) {
-        let devices = [];
-        if (this.$options.debugBrk) {
-            await this.$devicesService.initialize({
-                platform: this.platform,
-                deviceId: this.$options.device,
-                emulator: this.$options.emulator,
-                skipInferPlatform: !this.platform,
-                sdk: this.$options.sdk,
-            });
-            const selectedDeviceForDebug = await this.$devicesService.pickSingleDevice({
-                onlyEmulators: this.$options.emulator,
-                onlyDevices: this.$options.forDevice,
-                deviceId: this.$options.device,
-            });
-            devices = [selectedDeviceForDebug];
-        }
-        else {
-            devices = await this.$liveSyncCommandHelper.getDeviceInstances(this.platform);
-        }
-        if (!this.$options.env) {
-            this.$options.env = {};
-        }
-        this.$options.env.unitTesting = true;
-        const liveSyncInfo = this.$liveSyncCommandHelper.getLiveSyncData(this.$projectData.projectDir);
-        const deviceDebugMap = {};
-        devices.forEach((device) => (deviceDebugMap[device.deviceInfo.identifier] = this.$options.debugBrk));
-        const deviceDescriptors = await this.$liveSyncCommandHelper.createDeviceDescriptors(devices, this.platform, { deviceDebugMap });
-        await this.$testExecutionService.startKarmaServer(this.platform, liveSyncInfo, deviceDescriptors);
-        process.exit(0);
+    execute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let devices = [];
+            if (this.$options.debugBrk) {
+                yield this.$devicesService.initialize({
+                    platform: this.platform,
+                    deviceId: this.$options.device,
+                    emulator: this.$options.emulator,
+                    skipInferPlatform: !this.platform,
+                    sdk: this.$options.sdk,
+                });
+                const selectedDeviceForDebug = yield this.$devicesService.pickSingleDevice({
+                    onlyEmulators: this.$options.emulator,
+                    onlyDevices: this.$options.forDevice,
+                    deviceId: this.$options.device,
+                });
+                devices = [selectedDeviceForDebug];
+                // const debugData = this.getDebugData(platform, projectData, deployOptions, { device: selectedDeviceForDebug.deviceInfo.identifier });
+                // await this.$debugService.debug(debugData, this.$options);
+            }
+            else {
+                devices = yield this.$liveSyncCommandHelper.getDeviceInstances(this.platform);
+            }
+            if (!this.$options.env) {
+                this.$options.env = {};
+            }
+            this.$options.env.unitTesting = true;
+            const liveSyncInfo = this.$liveSyncCommandHelper.getLiveSyncData(this.$projectData.projectDir);
+            const deviceDebugMap = {};
+            devices.forEach((device) => (deviceDebugMap[device.deviceInfo.identifier] = this.$options.debugBrk));
+            const deviceDescriptors = yield this.$liveSyncCommandHelper.createDeviceDescriptors(devices, this.platform, { deviceDebugMap });
+            yield this.$testExecutionService.startKarmaServer(this.platform, liveSyncInfo, deviceDescriptors);
+            // if we got here, it means karma exited with exit code 0 (success)
+            process.exit(0);
+        });
     }
-    async canExecute(args) {
-        if (!this.$options.force) {
-            if (this.$options.hmr) {
-                this.$errors.fail("The `--hmr` option is not supported for this command.");
+    canExecute(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$options.force) {
+                if (this.$options.hmr) {
+                    // With HMR we are not restarting after LiveSync which is causing a 30 seconds app start on Android
+                    // because the Runtime does not watch for the `/data/local/tmp<appId>-livesync-in-progress` file deletion.
+                    // The App is closing itself after each test execution and the bug will be reproducible on each LiveSync.
+                    this.$errors.fail("The `--hmr` option is not supported for this command.");
+                }
+                yield this.$migrateController.validate({
+                    projectDir: this.$projectData.projectDir,
+                    platforms: [this.platform],
+                });
             }
-            await this.$migrateController.validate({
+            this.$projectData.initializeProjectData();
+            this.$analyticsService.setShouldDispose(this.$options.justlaunch || !this.$options.watch);
+            this.$cleanupService.setShouldDispose(this.$options.justlaunch || !this.$options.watch);
+            const output = yield this.$platformEnvironmentRequirements.checkEnvironmentRequirements({
+                platform: this.platform,
                 projectDir: this.$projectData.projectDir,
-                platforms: [this.platform],
+                options: this.$options,
             });
-        }
-        this.$projectData.initializeProjectData();
-        this.$analyticsService.setShouldDispose(this.$options.justlaunch || !this.$options.watch);
-        this.$cleanupService.setShouldDispose(this.$options.justlaunch || !this.$options.watch);
-        const output = await this.$platformEnvironmentRequirements.checkEnvironmentRequirements({
-            platform: this.platform,
-            projectDir: this.$projectData.projectDir,
-            options: this.$options,
+            const canStartKarmaServer = yield this.$testExecutionService.canStartKarmaServer(this.$projectData);
+            if (!canStartKarmaServer) {
+                this.$errors.fail({
+                    formatStr: "Error: In order to run unit tests, your project must already be configured by running $ ns test init.",
+                    errorCode: 133 /* ErrorCodes.TESTS_INIT_REQUIRED */,
+                });
+            }
+            return output.canExecute && canStartKarmaServer;
         });
-        const canStartKarmaServer = await this.$testExecutionService.canStartKarmaServer(this.$projectData);
-        if (!canStartKarmaServer) {
-            this.$errors.fail({
-                formatStr: "Error: In order to run unit tests, your project must already be configured by running $ ns test init.",
-                errorCode: 133,
-            });
-        }
-        return output.canExecute && canStartKarmaServer;
     }
 }
 class TestAndroidCommand extends TestCommandBase {
@@ -84,23 +103,33 @@ class TestAndroidCommand extends TestCommandBase {
         this.$migrateController = $migrateController;
         this.platform = "android";
     }
-    async execute(args) {
-        await super.execute(args);
+    execute(args) {
+        const _super = Object.create(null, {
+            execute: { get: () => super.execute }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.execute.call(this, args);
+        });
     }
-    async canExecute(args) {
-        const canExecuteBase = await super.canExecute(args);
-        if (canExecuteBase) {
-            if ((this.$options.release || this.$options.aab) &&
-                !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
-                if (this.$options.release) {
-                    this.$errors.failWithHelp(constants_1.ANDROID_RELEASE_BUILD_ERROR_MESSAGE);
-                }
-                else {
-                    this.$errors.failWithHelp(constants_1.ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE);
+    canExecute(args) {
+        const _super = Object.create(null, {
+            canExecute: { get: () => super.canExecute }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const canExecuteBase = yield _super.canExecute.call(this, args);
+            if (canExecuteBase) {
+                if ((this.$options.release || this.$options.aab) &&
+                    !(0, helpers_1.hasValidAndroidSigning)(this.$options)) {
+                    if (this.$options.release) {
+                        this.$errors.failWithHelp(constants_1.ANDROID_RELEASE_BUILD_ERROR_MESSAGE);
+                    }
+                    else {
+                        this.$errors.failWithHelp(constants_1.ANDROID_APP_BUNDLE_SIGNING_ERROR_MESSAGE);
+                    }
                 }
             }
-        }
-        return canExecuteBase;
+            return canExecuteBase;
+        });
     }
 }
 class TestIosCommand extends TestCommandBase {
@@ -121,3 +150,4 @@ class TestIosCommand extends TestCommandBase {
 }
 yok_1.injector.registerCommand("test|android", TestAndroidCommand);
 yok_1.injector.registerCommand("test|ios", TestIosCommand);
+//# sourceMappingURL=test.js.map