fix: Test command runs tests twice and often fails on Android

With the new LiveSync with sockets functionality, the `tns test android` command executes the tests twice and often exits with a non-zero exit code. The problem is that the command uses the LiveSync logic to upload the files first, restart the application after that and runs the tests. However, the new LiveSync requires the application to be running on device in order to have a socket for file transfer. When we start the application in order to execute the LiveSync, the tests are run. During the run the LiveSync may end and CLI will restart the app. If this happens during running the tests, Karma will mark them as failure and the next execution may not be triggered.
Fix this by creating a temp file on device before starting the LiveSync operation. Runtime will check if the file exists and if it does, it will sleep the application for 30 seconds, i.e. it will not load the JS implementation of the app. During this time CLI will transfer all files, remove the temp file from device and restart the application. Runtime will not find the file and it will load the application.

Author: rosen-vladimirov

lib/common

@@ -98,13 +98,6 @@ class ItunesConnectApplicationTypesClass implements IiTunesConnectApplicationTyp
 }
 
 export const ItunesConnectApplicationTypes = new ItunesConnectApplicationTypesClass();
-export class LiveSyncPaths {
-	static SYNC_DIR_NAME = "sync";
-	static REMOVEDSYNC_DIR_NAME = "removedsync";
-	static FULLSYNC_DIR_NAME = "fullsync";
-	static IOS_DEVICE_PROJECT_ROOT_PATH = "Library/Application Support/LiveSync";
-	static IOS_DEVICE_SYNC_ZIP_PATH = "Library/Application Support/LiveSync/sync.zip";
-}
 export const ANGULAR_NAME = "angular";
 export const TYPESCRIPT_NAME = "typescript";
 export const BUILD_OUTPUT_EVENT_NAME = "buildOutput";

lib/constants.ts

@@ -1,5 +1,6 @@
 import { fromWindowsRelativePathToUnix } from "./common/helpers";
-import { APP_FOLDER_NAME, LiveSyncPaths } from "./constants";
+import { APP_FOLDER_NAME } from "./constants";
+import { LiveSyncPaths } from "./common/constants";
 import { AndroidDeviceLiveSyncService } from "./services/livesync/android-device-livesync-service";
 import * as path from "path";
 
@@ -23,7 +24,7 @@ export class DevicePathProvider implements IDevicePathProvider {
 				projectRoot = path.join(projectRoot, APP_FOLDER_NAME);
 			}
 		} else if (this.$mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
-			projectRoot = `/data/local/tmp/${options.appIdentifier}`;
+			projectRoot = `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${options.appIdentifier}`;
 			if (!options.getDirname) {
 				const deviceLiveSyncService = this.$injector.resolve<AndroidDeviceLiveSyncService>(AndroidDeviceLiveSyncService, { device });
 				const hashService = deviceLiveSyncService.getDeviceHashService(options.appIdentifier);

lib/device-path-provider.ts

@@ -1,5 +1,6 @@
 import { sleep } from "../common/helpers";
 import { DebugServiceBase } from "./debug-service-base";
+import { LiveSyncPaths } from "../common/constants";
 
 export class AndroidDebugService extends DebugServiceBase implements IPlatformDebugService {
 	private _packageName: string;
@@ -158,22 +159,23 @@ export class AndroidDebugService extends DebugServiceBase implements IPlatformDe
 		await this.device.applicationManager.stopApplication(appData);
 
 		if (debugOptions.debugBrk) {
-			await this.device.adb.executeShellCommand([`cat /dev/null > /data/local/tmp/${appData.appId}-debugbreak`]);
+			await this.device.adb.executeShellCommand([`cat /dev/null > ${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugbreak`]);
 		}
 
-		await this.device.adb.executeShellCommand([`cat /dev/null > /data/local/tmp/${appData.appId}-debugger-started`]);
+		await this.device.adb.executeShellCommand([`cat /dev/null > ${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugger-started`]);
 
 		await this.device.applicationManager.startApplication(appData);
 
 		await this.waitForDebugger(appData.appId);
 	}
 
 	private async waitForDebugger(packageName: String): Promise<void> {
-		const waitText: string = `0 /data/local/tmp/${packageName}-debugger-started`;
+		const debuggerStartedFilePath = `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${packageName}-debugger-started`;
+		const waitText: string = `0 ${debuggerStartedFilePath}`;
 		let maxWait = 12;
 		let debuggerStarted: boolean = false;
 		while (maxWait > 0 && !debuggerStarted) {
-			const forwardsResult = await this.device.adb.executeShellCommand(["ls", "-s", `/data/local/tmp/${packageName}-debugger-started`]);
+			const forwardsResult = await this.device.adb.executeShellCommand(["ls", "-s", debuggerStartedFilePath]);
 
 			maxWait--;
 

lib/services/android-debug-service.ts

@@ -5,7 +5,7 @@ import * as semver from "semver";
 import * as projectServiceBaseLib from "./platform-project-service-base";
 import { DeviceAndroidDebugBridge } from "../common/mobile/android/device-android-debug-bridge";
 import { attachAwaitDetach, isRecommendedAarFile } from "../common/helpers";
-import { Configurations } from "../common/constants";
+import { Configurations, LiveSyncPaths } from "../common/constants";
 import { SpawnOptions } from "child_process";
 
 export class AndroidProjectService extends projectServiceBaseLib.PlatformProjectServiceBase implements IPlatformProjectService {
@@ -631,7 +631,7 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 
 	public async cleanDeviceTempFolder(deviceIdentifier: string, projectData: IProjectData): Promise<void> {
 		const adb = this.$injector.resolve(DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
-		const deviceRootPath = `/data/local/tmp/${projectData.projectId}`;
+		const deviceRootPath = `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${projectData.projectId}`;
 		await adb.executeShellCommand(["rm", "-rf", deviceRootPath]);
 	}
 

lib/services/android-project-service.ts

@@ -2,7 +2,7 @@ import { DeviceAndroidDebugBridge } from "../../common/mobile/android/device-and
 import { AndroidDeviceHashService } from "../../common/mobile/android/android-device-hash-service";
 import { DeviceLiveSyncServiceBase } from "./device-livesync-service-base";
 import * as helpers from "../../common/helpers";
-import { LiveSyncPaths } from "../../constants";
+import { LiveSyncPaths } from "../../common/constants";
 import { cache } from "../../common/decorators";
 import * as path from "path";
 import * as net from "net";

lib/services/livesync/android-device-livesync-service.ts

@@ -2,8 +2,10 @@ import { DeviceAndroidDebugBridge } from "../../common/mobile/android/device-and
 import { AndroidDeviceHashService } from "../../common/mobile/android/android-device-hash-service";
 import { DeviceLiveSyncServiceBase } from "./device-livesync-service-base";
 import { APP_FOLDER_NAME } from "../../constants";
+import { LiveSyncPaths } from "../../common/constants";
 import { AndroidLivesyncTool } from "./android-livesync-tool";
 import * as path from "path";
+import * as temp from "temp";
 
 export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBase implements IAndroidNativeScriptDeviceLiveSyncService, INativeScriptDeviceLiveSyncService {
 	private livesyncTool: IAndroidLivesyncTool;
@@ -17,54 +19,65 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 		private $logger: ILogger,
 		protected device: Mobile.IAndroidDevice,
 		private $options: ICommonOptions,
-		private $processService: IProcessService) {
+		private $processService: IProcessService,
+		private $fs: IFileSystem) {
 		super($platformsData, device);
 		this.livesyncTool = this.$injector.resolve(AndroidLivesyncTool);
 	}
 
 	public async beforeLiveSyncAction(deviceAppData: Mobile.IDeviceAppData): Promise<void> {
 		const platformData = this.$platformsData.getPlatformData(deviceAppData.platform, this.data);
 		const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, APP_FOLDER_NAME);
+		const pathToLiveSyncFile = temp.path({ prefix: "livesync" });
+		this.$fs.writeFile(pathToLiveSyncFile, "");
+		await this.device.fileSystem.putFile(pathToLiveSyncFile, this.getPathToLiveSyncFileOnDevice(deviceAppData.appIdentifier), deviceAppData.appIdentifier);
 		await this.device.applicationManager.startApplication({ appId: deviceAppData.appIdentifier, projectName: this.data.projectName });
 		await this.connectLivesyncTool(projectFilesPath, this.data.projectId);
 	}
 
+	private getPathToLiveSyncFileOnDevice(appIdentifier: string): string {
+		return `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}-livesync-in-progress`;
+	}
+
 	public async finalizeSync(liveSyncInfo: ILiveSyncResultInfo) {
 		await this.doSync(liveSyncInfo);
 	}
 
-	private async doSync(liveSyncInfo: ILiveSyncResultInfo, {doRefresh = false}: {doRefresh?: boolean} = {}): Promise<IAndroidLivesyncSyncOperationResult> {
+	private async doSync(liveSyncInfo: ILiveSyncResultInfo, { doRefresh = false }: { doRefresh?: boolean } = {}): Promise<IAndroidLivesyncSyncOperationResult> {
 		const operationId = this.livesyncTool.generateOperationIdentifier();
 
-		let result = {operationId, didRefresh: true };
+		let result = { operationId, didRefresh: true };
 
 		if (liveSyncInfo.modifiedFilesData.length) {
 
 			const doSyncPromise = this.livesyncTool.sendDoSyncOperation(doRefresh, null, operationId);
 
-			const syncInterval : NodeJS.Timer = setInterval(() => {
+			const syncInterval: NodeJS.Timer = setInterval(() => {
 				if (this.livesyncTool.isOperationInProgress(operationId)) {
 					this.$logger.info("Sync operation in progress...");
 				}
 			}, AndroidDeviceSocketsLiveSyncService.STATUS_UPDATE_INTERVAL);
 
-			const clearSyncInterval = () => {
+			const actionOnEnd = async () => {
 				clearInterval(syncInterval);
+				await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
 			};
 
-			this.$processService.attachToProcessExitSignals(this, clearSyncInterval);
-			doSyncPromise.then(clearSyncInterval, clearSyncInterval);
+			this.$processService.attachToProcessExitSignals(this, actionOnEnd);
+			doSyncPromise.then(actionOnEnd, actionOnEnd);
 
 			result = await doSyncPromise;
 		}
 
+		await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
+
 		return result;
 	}
 
 	public async refreshApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo) {
 		const canExecuteFastSync = !liveSyncInfo.isFullSync && this.canExecuteFastSyncForPaths(liveSyncInfo.modifiedFilesData, projectData, this.device.deviceInfo.platform);
 
-		const syncOperationResult = await this.doSync(liveSyncInfo, {doRefresh: canExecuteFastSync});
+		const syncOperationResult = await this.doSync(liveSyncInfo, { doRefresh: canExecuteFastSync });
 
 		this.livesyncTool.end();
 
@@ -96,28 +109,28 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 	}
 
 	private async _transferDirectory(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<Mobile.ILocalToDevicePathData[]> {
-		let transferredLocalToDevicePaths : Mobile.ILocalToDevicePathData[];
+		let transferredLocalToDevicePaths: Mobile.ILocalToDevicePathData[];
 		const deviceHashService = this.getDeviceHashService(deviceAppData.appIdentifier);
 		const currentShasums: IStringDictionary = await deviceHashService.generateHashesFromLocalToDevicePaths(localToDevicePaths);
 		const oldShasums = await deviceHashService.getShasumsFromDevice();
 
 		if (this.$options.force || !oldShasums) {
 			await this.livesyncTool.sendDirectory(projectFilesPath);
 			await deviceHashService.uploadHashFileToDevice(currentShasums);
-			transferredLocalToDevicePaths  = localToDevicePaths;
+			transferredLocalToDevicePaths = localToDevicePaths;
 		} else {
 			const changedShasums = deviceHashService.getChangedShasums(oldShasums, currentShasums);
 			const changedFiles = _.keys(changedShasums);
 			if (changedFiles.length) {
 				await this.livesyncTool.sendFiles(changedFiles);
 				await deviceHashService.uploadHashFileToDevice(currentShasums);
-				transferredLocalToDevicePaths  = localToDevicePaths.filter(localToDevicePathData => changedFiles.indexOf(localToDevicePathData.getLocalPath()) >= 0);
+				transferredLocalToDevicePaths = localToDevicePaths.filter(localToDevicePathData => changedFiles.indexOf(localToDevicePathData.getLocalPath()) >= 0);
 			} else {
-				transferredLocalToDevicePaths  = [];
+				transferredLocalToDevicePaths = [];
 			}
 		}
 
-		return transferredLocalToDevicePaths ;
+		return transferredLocalToDevicePaths;
 	}
 
 	private async connectLivesyncTool(projectFilesPath: string, appIdentifier: string) {