test: fix unit tests

Author: Fatme

.vscode/launch.json

@@ -15,7 +15,7 @@
 			"program": "${workspaceRoot}/lib/nativescript-cli.js",
 
 			// example commands
-			"args": [ "run", "ios", "--path", "${workspaceRoot}/scratch/webpackApp", "--hmr"]
+			"args": [ "test", "ios", "--path", "${workspaceRoot}/scratch/webpackApp", "--bundle"]
 			// "args": [ "test", "android", "--justlaunch"]
 			// "args": [ "platform", "add", "android@1.3.0", "--path", "cliapp"]
 			// "args": [ "platform", "remove", "android", "--path", "cliapp"]

lib/commands/appstore-upload.ts

@@ -1,5 +1,8 @@
 import * as path from "path";
 import { StringCommandParameter } from "../common/command-params";
+import { BuildPlatformService } from "../services/platform/build-platform-service";
+import { WorkflowDataService } from "../services/workflow/workflow-data-service";
+import { MainController } from "../controllers/main-controller";
 
 export class PublishIOS implements ICommand {
 	public allowedParameters: ICommandParameter[] = [new StringCommandParameter(this.$injector), new StringCommandParameter(this.$injector),
@@ -13,29 +16,20 @@ export class PublishIOS implements ICommand {
 		private $options: IOptions,
 		private $prompter: IPrompter,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
+		private $mainController: MainController,
 		private $platformValidationService: IPlatformValidationService,
-		// private $buildPlatformService: BuildPlatformService,
-		// private $xcodebuildService: IXcodebuildService
-		) {
+		private $buildPlatformService: BuildPlatformService,
+		private $workflowDataService: WorkflowDataService
+	) {
 		this.$projectData.initializeProjectData();
 	}
 
-	// private get $platformsData(): IPlatformsData {
-	// 	return this.$injector.resolve("platformsData");
-	// }
-
-	// This property was introduced due to the fact that the $platformService dependency
-	// ultimately tries to resolve the current project's dir and fails if not executed from within a project
-	// private get $platformService(): IPlatformService {
-	// 	return this.$injector.resolve("platformService");
-	// }
-
 	public async execute(args: string[]): Promise<void> {
 		let username = args[0];
 		let password = args[1];
 		const mobileProvisionIdentifier = args[2];
 		const codeSignIdentity = args[3];
-		const ipaFilePath = this.$options.ipa ? path.resolve(this.$options.ipa) : null;
+		let ipaFilePath = this.$options.ipa ? path.resolve(this.$options.ipa) : null;
 
 		if (!username) {
 			username = await this.$prompter.getString("Apple ID", { allowEmpty: false });
@@ -54,47 +48,24 @@ export class PublishIOS implements ICommand {
 		}
 
 		this.$options.release = true;
+		const platform = this.$devicePlatformsConstants.iOS.toLowerCase();
 
 		if (!ipaFilePath) {
-			// const platform = this.$devicePlatformsConstants.iOS;
 			// No .ipa path provided, build .ipa on out own.
-			// const platformWorkflowData = {
-			// 	release: this.$options.release,
-			// 	useHotModuleReload: false,
-			// 	env: this.$options.env,
-			// 	platformParam: platform,
-			// 	signingOptions: {
-			// 		teamId: this.$options.teamId,
-			// 		provision: this.$options.provision
-			// 	}
-			// };
-			// const buildConfig: IBuildConfig = {
-			// 	projectDir: this.$options.path,
-			// 	release: this.$options.release,
-			// 	device: this.$options.device,
-			// 	provision: this.$options.provision,
-			// 	teamId: this.$options.teamId,
-			// 	buildForDevice: true,
-			// 	iCloudContainerEnvironment: this.$options.iCloudContainerEnvironment,
-			// 	mobileProvisionIdentifier,
-			// 	codeSignIdentity
-			// };
-
-			// const platformData = this.$platformsData.getPlatformData(platform, this.$projectData);
-
-			// if (mobileProvisionIdentifier || codeSignIdentity) {
-			// 	this.$logger.info("Building .ipa with the selected mobile provision and/or certificate.");
-			// 	// This is not very correct as if we build multiple targets we will try to sign all of them using the signing identity here.
-			// 	await this.$platformService.preparePlatform(platformData, this.$projectData, platformWorkflowData);
-			// 	await this.$platformBuildService.buildPlatform(platformData, this.$projectData, buildConfig);
-			// 	ipaFilePath = this.$platformService.lastOutputPath(platform, buildConfig, this.$projectData);
-			// } else {
-			// 	this.$logger.info("No .ipa, mobile provision or certificate set. Perfect! Now we'll build .xcarchive and let Xcode pick the distribution certificate and provisioning profile for you when exporting .ipa for AppStore submission.");
-			// 	await this.$platformService.preparePlatform(platformData, this.$projectData, platformWorkflowData);
-
-			// 	ipaFilePath = await this.$xcodebuildService.buildForAppStore(platformData, this.$projectData, buildConfig);
-			// 	this.$logger.info(`Export at: ${ipaFilePath}`);
-			// }
+			if (mobileProvisionIdentifier || codeSignIdentity) {
+				// This is not very correct as if we build multiple targets we will try to sign all of them using the signing identity here.
+				this.$logger.info("Building .ipa with the selected mobile provision and/or certificate.");
+
+				// As we need to build the package for device
+				this.$options.forDevice = true;
+
+				const { nativePlatformData, buildPlatformData } = this.$workflowDataService.createWorkflowData(platform, this.$projectData.projectDir, this.$options);
+				ipaFilePath = await this.$buildPlatformService.buildPlatform(nativePlatformData, this.$projectData, buildPlatformData);
+			} else {
+				this.$logger.info("No .ipa, mobile provision or certificate set. Perfect! Now we'll build .xcarchive and let Xcode pick the distribution certificate and provisioning profile for you when exporting .ipa for AppStore submission.");
+				ipaFilePath = await this.$mainController.buildPlatform(platform, this.$projectData.projectDir, { ...this.$options, buildForAppStore: true })
+				this.$logger.info(`Export at: ${ipaFilePath}`);
+			}
 		}
 
 		await this.$itmsTransporterService.upload({

lib/commands/test.ts

@@ -1,8 +1,7 @@
-import * as helpers from "../common/helpers";
+import { LiveSyncCommandHelper } from "../helpers/livesync-command-helper";
 
 abstract class TestCommandBase {
 	public allowedParameters: ICommandParameter[] = [];
-	private projectFilesConfig: IProjectFilesConfig;
 	protected abstract platform: string;
 	protected abstract $projectData: IProjectData;
 	protected abstract $testExecutionService: ITestExecutionService;
@@ -11,16 +10,41 @@ abstract class TestCommandBase {
 	protected abstract $platformEnvironmentRequirements: IPlatformEnvironmentRequirements;
 	protected abstract $errors: IErrors;
 	protected abstract $cleanupService: ICleanupService;
+	protected abstract $liveSyncCommandHelper: LiveSyncCommandHelper;
+	protected abstract $devicesService: Mobile.IDevicesService;
 
 	async execute(args: string[]): Promise<void> {
-		await this.$testExecutionService.startKarmaServer(this.platform, this.$projectData, this.projectFilesConfig);
+		let devices = [];
+		if (this.$options.debugBrk) {
+			const selectedDeviceForDebug = await 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 = await this.$liveSyncCommandHelper.getDeviceInstances(this.platform);
+		}
+
+		if (!this.$options.env) { this.$options.env = { }; }
+		this.$options.env.unitTesting = true;
+
+		const liveSyncInfo = this.$liveSyncCommandHelper.createLiveSyncInfo();
+
+		const deviceDebugMap: IDictionary<boolean> = {};
+		devices.forEach(device => deviceDebugMap[device.deviceInfo.identifier] = this.$options.debugBrk);
+
+		const deviceDescriptors = await this.$liveSyncCommandHelper.createDeviceDescriptors(devices, this.platform, <any>{ deviceDebugMap });
+
+		await this.$testExecutionService.startKarmaServer(this.platform, liveSyncInfo, deviceDescriptors);
 	}
 
 	async canExecute(args: string[]): Promise<boolean | ICanExecuteCommandOutput> {
 		this.$projectData.initializeProjectData();
 		this.$analyticsService.setShouldDispose(this.$options.justlaunch || !this.$options.watch);
 		this.$cleanupService.setShouldDispose(this.$options.justlaunch || !this.$options.watch);
-		this.projectFilesConfig = helpers.getProjectFilesConfig({ isReleaseBuild: this.$options.release });
 
 		const output = await this.$platformEnvironmentRequirements.checkEnvironmentRequirements({
 			platform: this.platform,
@@ -54,7 +78,9 @@ class TestAndroidCommand extends TestCommandBase implements ICommand {
 		protected $options: IOptions,
 		protected $platformEnvironmentRequirements: IPlatformEnvironmentRequirements,
 		protected $errors: IErrors,
-		protected $cleanupService: ICleanupService) {
+		protected $cleanupService: ICleanupService,
+		protected $liveSyncCommandHelper: LiveSyncCommandHelper,
+		protected $devicesService: Mobile.IDevicesService) {
 		super();
 	}
 
@@ -69,7 +95,9 @@ class TestIosCommand extends TestCommandBase implements ICommand {
 		protected $options: IOptions,
 		protected $platformEnvironmentRequirements: IPlatformEnvironmentRequirements,
 		protected $errors: IErrors,
-		protected $cleanupService: ICleanupService) {
+		protected $cleanupService: ICleanupService,
+		protected $liveSyncCommandHelper: LiveSyncCommandHelper,
+		protected $devicesService: Mobile.IDevicesService) {
 		super();
 	}
 

lib/common/yok.ts

@@ -6,11 +6,11 @@ import { CommandsDelimiters } from "./constants";
 let indent = "";
 function trace(formatStr: string, ...args: any[]) {
 	// uncomment following lines when debugging dependency injection
-	// var args = [];
-	// for (var _i = 1; _i < arguments.length; _i++) {
-	// 	args[_i - 1] = arguments[_i];
+	// const items: any[] = [];
+	// for (let _i = 1; _i < arguments.length; _i++) {
+	// 	items[_i - 1] = arguments[_i];
 	// }
-	// var util = require("util");
+	// const util = require("util");
 	// console.log(util.format.apply(util, [indent + formatStr].concat(args)));
 }
 

lib/controllers/main-controller.ts

@@ -38,7 +38,7 @@ export class MainController extends EventEmitter {
 		await this.$preparePlatformService.preparePlatform(nativePlatformData, projectData, preparePlatformData);
 	}
 
-	public async buildPlatform(platform: string, projectDir: string, options: IOptions): Promise<string> {
+	public async buildPlatform(platform: string, projectDir: string, options: IOptions | any): Promise<string> {
 		const { nativePlatformData, projectData, buildPlatformData } = this.$workflowDataService.createWorkflowData(platform, projectDir, options);
 
 		await this.preparePlatform(platform, projectDir, options);

lib/declarations.d.ts

@@ -556,7 +556,6 @@ interface IOptions extends IRelease, IDeviceIdentifier, IJustLaunch, IAvd, IAvai
 	javascript: boolean;
 	androidTypings: boolean;
 	production: boolean; //npm flag
-	syncAllFiles: boolean;
 	chrome: boolean;
 	inspector: boolean; // the counterpart to --chrome
 	background: string;
@@ -1038,11 +1037,6 @@ interface IPlatformValidationService {
 	isPlatformSupportedForOS(platform: string, projectData: IProjectData): boolean;
 }
 
-interface IBuildArtefactsService {
-	getLastBuiltPackagePath(platformData: IPlatformData, buildConfig: IBuildConfig, outputPath?: string): Promise<string>;
-	getAllBuiltApplicationPackages(buildOutputPath: string, validBuildOutputData: IValidBuildOutputData): IApplicationPackage[];
-}
-
 interface IPlatformCommandsService {
 	addPlatforms(platforms: string[], projectData: IProjectData, frameworkPath: string): Promise<void>;
 	cleanPlatforms(platforms: string[], projectData: IProjectData, framworkPath: string): Promise<void>;

lib/definitions/livesync.d.ts

@@ -433,7 +433,6 @@ declare global {
 	interface IDeviceProjectRootOptions {
 		appIdentifier: string;
 		getDirname?: boolean;
-		syncAllFiles?: boolean;
 		watch?: boolean;
 	}
 

lib/definitions/project.d.ts

@@ -358,7 +358,7 @@ interface IValidatePlatformOutput {
 }
 
 interface ITestExecutionService {
-	startKarmaServer(platform: string, projectData: IProjectData, projectFilesConfig: IProjectFilesConfig): Promise<void>;
+	startKarmaServer(platform: string, liveSyncInfo: ILiveSyncInfo, deviceDescriptors: ILiveSyncDeviceInfo[]): Promise<void>;
 	canStartKarmaServer(projectData: IProjectData): Promise<boolean>;
 }
 

lib/device-path-provider.ts

@@ -25,7 +25,7 @@ export class DevicePathProvider implements IDevicePathProvider {
 			projectRoot = `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${options.appIdentifier}`;
 			if (!options.getDirname) {
 				const hashService = (<Mobile.IAndroidDevice>device).fileSystem.getDeviceHashService(options.appIdentifier);
-				const hashFile = options.syncAllFiles ? null : await hashService.doesShasumFileExistsOnDevice();
+				const hashFile = await hashService.doesShasumFileExistsOnDevice();
 				const syncFolderName = options.watch || hashFile ? LiveSyncPaths.SYNC_DIR_NAME : LiveSyncPaths.FULLSYNC_DIR_NAME;
 				projectRoot = path.join(projectRoot, syncFolderName);
 			}

lib/helpers/livesync-command-helper.ts

@@ -13,46 +13,51 @@ export class LiveSyncCommandHelper implements ILiveSyncCommandHelper {
 		private $iosDeviceOperations: IIOSDeviceOperations,
 		private $mobileHelper: Mobile.IMobileHelper,
 		private $devicesService: Mobile.IDevicesService,
-		private $platformsData: IPlatformsData,
+		private $injector: IInjector,
 		private $buildPlatformService: BuildPlatformService,
 		private $analyticsService: IAnalyticsService,
 		private $bundleValidatorHelper: IBundleValidatorHelper,
 		private $errors: IErrors,
 		private $iOSSimulatorLogProvider: Mobile.IiOSSimulatorLogProvider,
-		private $logger: ILogger,
 		private $cleanupService: ICleanupService
 	) { }
 
-	public getPlatformsForOperation(platform: string): string[] {
-		const availablePlatforms = platform ? [platform] : _.values<string>(this.$platformsData.availablePlatforms);
-		return availablePlatforms;
+	private get $platformsData(): IPlatformsData {
+		return this.$injector.resolve("platformsData");
 	}
 
-	public async executeCommandLiveSync(platform?: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions) {
-		if (additionalOptions && additionalOptions.syncToPreviewApp) {
-			return;
-		}
-
-		if (!this.$options.syncAllFiles) {
-			this.$logger.info("Skipping node_modules folder! Use the syncAllFiles option to sync files from this folder.");
-		}
-
-		const emulator = this.$options.emulator;
+	public async getDeviceInstances(platform?: string): Promise<Mobile.IDevice[]> {
 		await this.$devicesService.initialize({
-			deviceId: this.$options.device,
 			platform,
-			emulator,
+			deviceId: this.$options.device,
+			emulator: this.$options.emulator,
 			skipInferPlatform: !platform,
 			sdk: this.$options.sdk
 		});
 
 		const devices = this.$devicesService.getDeviceInstances()
 			.filter(d => !platform || d.deviceInfo.platform.toLowerCase() === platform.toLowerCase());
 
-		await this.executeLiveSyncOperation(devices, platform, additionalOptions);
+		return devices;
 	}
 
-	public async executeLiveSyncOperation(devices: Mobile.IDevice[], platform: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions): Promise<void> {
+	public createLiveSyncInfo(): ILiveSyncInfo {
+		const liveSyncInfo: ILiveSyncInfo = {
+			projectDir: this.$projectData.projectDir,
+			skipWatcher: !this.$options.watch || this.$options.justlaunch,
+			clean: this.$options.clean,
+			release: this.$options.release,
+			env: this.$options.env,
+			timeout: this.$options.timeout,
+			useHotModuleReload: this.$options.hmr,
+			force: this.$options.force,
+			emulator: this.$options.emulator
+		};
+
+		return liveSyncInfo;
+	}
+
+	public async createDeviceDescriptors(devices: Mobile.IDevice[], platform: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions): Promise<ILiveSyncDeviceInfo[]> {
 		if (!devices || !devices.length) {
 			if (platform) {
 				this.$errors.failWithoutHelp("Unable to find applicable devices to execute operation. Ensure connected devices are trusted and try again.");
@@ -113,6 +118,22 @@ export class LiveSyncCommandHelper implements ILiveSyncCommandHelper {
 				return info;
 			});
 
+			return deviceDescriptors;
+	}
+
+	public getPlatformsForOperation(platform: string): string[] {
+		const availablePlatforms = platform ? [platform] : _.values<string>(this.$platformsData.availablePlatforms);
+		return availablePlatforms;
+	}
+
+	public async executeCommandLiveSync(platform?: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions) {
+		const devices = await this.getDeviceInstances(platform);
+		await this.executeLiveSyncOperation(devices, platform, additionalOptions);
+	}
+
+	public async executeLiveSyncOperation(devices: Mobile.IDevice[], platform: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions): Promise<void> {
+		const deviceDescriptors = await this.createDeviceDescriptors(devices, platform, additionalOptions);
+
 		const liveSyncInfo: ILiveSyncInfo = {
 			projectDir: this.$projectData.projectDir,
 			skipWatcher: !this.$options.watch || this.$options.justlaunch,