Added tests for debug + livesync

Author: Tsvetan Raikov

test/debug.ts

@@ -0,0 +1,94 @@
+import * as stubs from "./stubs";
+import * as yok from "../lib/common/yok";
+import {DebugAndroidCommand} from "../lib/commands/debug";
+import {assert} from "chai";
+import {Configuration, StaticConfig} from "../lib/config";
+import {Options} from "../lib/options";
+import {DevicePlatformsConstants} from "../lib/common/mobile/device-platforms-constants";
+import {FileSystem} from "../lib/common/file-system";
+import {AndroidProjectService} from "../lib/services/android-project-service";
+import {AndroidDebugBridge} from "../lib/common/mobile/android/android-debug-bridge";
+import {AndroidDebugBridgeResultHandler} from "../lib/common/mobile/android/android-debug-bridge-result-handler";
+import future = require("fibers/future");
+
+function createTestInjector(): IInjector {
+	let testInjector: IInjector = new yok.Yok();
+
+	testInjector.register("debug|android", DebugAndroidCommand);
+	testInjector.register("config", Configuration);
+	testInjector.register("staticConfig", StaticConfig);
+	testInjector.register("logger", stubs.LoggerStub);
+	testInjector.register("options", Options);
+	testInjector.register("devicePlatformsConstants", DevicePlatformsConstants);
+	testInjector.register('devicesService', {});
+	testInjector.register('childProcess', stubs.ChildProcessStub);
+	testInjector.register('androidDebugService', stubs.DebugServiceStub);
+	testInjector.register('fs', FileSystem);
+	testInjector.register('errors', stubs.ErrorsStub);
+	testInjector.register('hostInfo', {});
+	testInjector.register("analyticsService", {
+		trackException: () => { return future.fromResult(); },
+		checkConsent: () => { return future.fromResult(); },
+		trackFeature: () => { return future.fromResult(); }
+	});
+	testInjector.register("usbLiveSyncService", stubs.LiveSyncServiceStub);
+	testInjector.register("androidProjectService", AndroidProjectService);
+	testInjector.register("androidToolsInfo", stubs.AndroidToolsInfoStub);
+	testInjector.register("hostInfo", {});
+	testInjector.register("projectData", { platformsDir: "" });
+	testInjector.register("projectDataService", {});
+	testInjector.register("sysInfo", {});
+	testInjector.register("mobileHelper", {});
+	testInjector.register("pluginVariablesService", {});
+	testInjector.register("deviceAppDataFactory", {});
+	testInjector.register("projectTemplatesService", {});
+	testInjector.register("xmlValidator", {});
+	testInjector.register("npm", {});
+	testInjector.register("androidEmulatorServices", {});
+	testInjector.register("adb", AndroidDebugBridge);
+	testInjector.register("androidDebugBridgeResultHandler", AndroidDebugBridgeResultHandler);
+
+	return testInjector;
+}
+
+describe("Debugger tests", () => {
+	let testInjector: IInjector;
+
+	beforeEach(() => {
+		testInjector = createTestInjector();
+	});
+
+	it("Ensures that debugLivesync flag is true when executing debug --watch command", () => {
+		let debugCommand: ICommand = testInjector.resolve("debug|android");
+		let options: IOptions = testInjector.resolve("options");
+		options.watch = true;
+		debugCommand.execute(["android","--watch"]).wait();
+		let config:IConfiguration = testInjector.resolve("config");
+		assert.isTrue(config.debugLivesync);
+		assert.isFalse(options.rebuild);
+    });
+
+	it("Ensures that beforePrepareAllPlugins will not call gradle when livesyncing", () => {
+		let config:IConfiguration = testInjector.resolve("config");
+		config.debugLivesync = true;
+		let childProcess: stubs.ChildProcessStub = testInjector.resolve("childProcess");
+		let androidProjectService: IPlatformProjectService = testInjector.resolve("androidProjectService");
+		let spawnFromEventCount = childProcess.spawnFromEventCount;
+		androidProjectService.beforePrepareAllPlugins().wait();
+		assert.isTrue(spawnFromEventCount === 0);
+		assert.isTrue(spawnFromEventCount === childProcess.spawnFromEventCount);
+	});
+
+	it("Ensures that beforePrepareAllPlugins will call gradle with clean option when *NOT* livesyncing", () => {
+		let config:IConfiguration = testInjector.resolve("config");
+		config.debugLivesync = false;
+		let childProcess: stubs.ChildProcessStub = testInjector.resolve("childProcess");
+		let androidProjectService: IPlatformProjectService = testInjector.resolve("androidProjectService");
+		let spawnFromEventCount = childProcess.spawnFromEventCount;
+		androidProjectService.beforePrepareAllPlugins().wait();
+		assert.isTrue(childProcess.lastCommand === "gradle");
+		assert.isTrue(childProcess.lastCommandArgs[0] === "clean");
+		assert.isTrue(spawnFromEventCount === 0);
+		assert.isTrue(spawnFromEventCount + 1 === childProcess.spawnFromEventCount);
+	});
+});

test/stubs.ts

@@ -2,7 +2,6 @@
 
 import Future = require("fibers/future");
 import * as util from "util";
-
 import * as chai from "chai";
 
 export class LoggerStub implements ILogger {
@@ -483,3 +482,76 @@ function unexpected(msg: string): Error {
 	err.showDiff = false;
 	return err;
 }
+
+export class DebugServiceStub implements IDebugService {
+	public debug(shouldBreak?: boolean): IFuture<void> {
+		return Future.fromResult();
+	}
+
+	public debugStart(): IFuture<void> {
+		return Future.fromResult();
+	}
+
+	public debugStop(): IFuture<void> {
+		return Future.fromResult();
+	}
+
+	public platform: string;
+}
+
+export class LiveSyncServiceStub implements ILiveSyncService {
+	public liveSync(platform: string, applicationReloadAction?: (deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]) => IFuture<void>): IFuture<void> {
+		return Future.fromResult();
+	}
+
+	public forceExecuteFullSync: boolean;
+}
+
+export class AndroidToolsInfoStub implements IAndroidToolsInfo {
+	public getToolsInfo(): IFuture<IAndroidToolsInfoData> {
+		let infoData: IAndroidToolsInfoData = Object.create(null);
+		infoData.androidHomeEnvVar = "";
+		infoData.compileSdkVersion = 23;
+		infoData.buildToolsVersion = "23";
+		infoData.targetSdkVersion = 23;
+		infoData.supportRepositoryVersion = "23";
+		return Future.fromResult(infoData);
+	}
+
+	public validateInfo(options?: { showWarningsAsErrors: boolean, validateTargetSdk: boolean }): IFuture<boolean> {
+		return Future.fromResult(true);
+	}
+
+	public validateJavacVersion(installedJavaVersion: string, options?: { showWarningsAsErrors: boolean }): IFuture<boolean> {
+		return Future.fromResult(true);
+	}
+
+	public getPathToAndroidExecutable(options?: { showWarningsAsErrors: boolean }): IFuture<string> {
+		return Future.fromResult("");
+	}
+
+	getPathToAdbFromAndroidHome(): IFuture<string> {
+		return Future.fromResult("");
+	}
+}
+
+export class ChildProcessStub {
+	public spawnCount = 0;
+	public spawnFromEventCount = 0;
+	public lastCommand = "";
+	public lastCommandArgs: string[] = [];
+
+	public spawn(command: string, args?: string[], options?: any): any {
+		this.spawnCount ++;
+		this.lastCommand = command;
+		this.lastCommandArgs = args;
+		return null;
+	}
+
+	public spawnFromEvent(command: string, args: string[], event: string, options?: any, spawnFromEventOptions?: ISpawnFromEventOptions): IFuture<ISpawnResult> {
+		this.spawnFromEventCount ++;
+		this.lastCommand = command;
+		this.lastCommandArgs = args;
+		return Future.fromResult(null);
+	}
+}