Fix stopLiveSync method

Currently stopLiveSync method does not emit correct events in some cases. For example, when there's only one attached device and its identifier is passed to `stopLiveSync` method, we do not emit `liveSyncStopped` event.
Fix the code and add unit tests to assure `liveSyncStopped` event is raised correctly.

Author: rosen-vladimirov

lib/services/livesync/livesync-service.ts

@@ -17,7 +17,7 @@ const LiveSyncEvents = {
 
 export class LiveSyncService extends EventEmitter implements ILiveSyncService {
 	// key is projectDir
-	private liveSyncProcessesInfo: IDictionary<ILiveSyncProcessInfo> = {};
+	protected liveSyncProcessesInfo: IDictionary<ILiveSyncProcessInfo> = {};
 
 	constructor(protected $platformService: IPlatformService,
 		private $projectDataService: IProjectDataService,
@@ -48,12 +48,10 @@ export class LiveSyncService extends EventEmitter implements ILiveSyncService {
 			// so we cannot await it as this will cause infinite loop.
 			const shouldAwaitPendingOperation = !stopOptions || stopOptions.shouldAwaitAllActions;
 
-			let removedDeviceIdentifiers: string[] = deviceIdentifiers || [];
+			const deviceIdentifiersToRemove = deviceIdentifiers || _.map(liveSyncProcessInfo.deviceDescriptors, d => d.identifier);
 
-			_.each(deviceIdentifiers, deviceId => {
-				removedDeviceIdentifiers = _.remove(liveSyncProcessInfo.deviceDescriptors, descriptor => descriptor.identifier === deviceId)
-					.map(deviceDescriptor => deviceDescriptor.identifier);
-			});
+			const removedDeviceIdentifiers = _.remove(liveSyncProcessInfo.deviceDescriptors, descriptor => _.indexOf(deviceIdentifiersToRemove, descriptor.identifier) !== -1)
+				.map(descriptor => descriptor.identifier);
 
 			// In case deviceIdentifiers are not passed, we should stop the whole LiveSync.
 			if (!deviceIdentifiers || !deviceIdentifiers.length || !liveSyncProcessInfo.deviceDescriptors || !liveSyncProcessInfo.deviceDescriptors.length) {
@@ -72,7 +70,6 @@ export class LiveSyncService extends EventEmitter implements ILiveSyncService {
 					await liveSyncProcessInfo.actionsChain;
 				}
 
-				removedDeviceIdentifiers = _.map(liveSyncProcessInfo.deviceDescriptors, d => d.identifier);
 				liveSyncProcessInfo.deviceDescriptors = [];
 
 				// Kill typescript watcher

test/services/livesync-service.ts

@@ -0,0 +1,147 @@
+import { Yok } from "../../lib/common/yok";
+import { assert } from "chai";
+import { LiveSyncService } from "../../lib/services/livesync/livesync-service";
+import { LoggerStub } from "../stubs";
+
+const createTestInjector = (): IInjector => {
+	const testInjector = new Yok();
+
+	testInjector.register("platformService", {});
+	testInjector.register("projectDataService", {
+		getProjectData: (projectDir: string): IProjectData => (<any>{})
+	});
+
+	testInjector.register("devicesService", {});
+	testInjector.register("mobileHelper", {});
+	testInjector.register("devicePlatformsConstants", {});
+	testInjector.register("nodeModulesDependenciesBuilder", {});
+	testInjector.register("logger", LoggerStub);
+	testInjector.register("processService", {});
+	testInjector.register("hooksService", {
+		executeAfterHooks: (commandName: string, hookArguments?: IDictionary<any>): Promise<void> => Promise.resolve()
+	});
+
+	testInjector.register("pluginsService", {});
+	testInjector.register("injector", testInjector);
+
+	return testInjector;
+};
+
+class LiveSyncServiceInheritor extends LiveSyncService {
+	constructor($platformService: IPlatformService,
+		$projectDataService: IProjectDataService,
+		$devicesService: Mobile.IDevicesService,
+		$mobileHelper: Mobile.IMobileHelper,
+		$devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
+		$nodeModulesDependenciesBuilder: INodeModulesDependenciesBuilder,
+		$logger: ILogger,
+		$processService: IProcessService,
+		$hooksService: IHooksService,
+		$pluginsService: IPluginsService,
+		$injector: IInjector) {
+
+		super(
+			$platformService,
+			$projectDataService,
+			$devicesService,
+			$mobileHelper,
+			$devicePlatformsConstants,
+			$nodeModulesDependenciesBuilder,
+			$logger,
+			$processService,
+			$hooksService,
+			$pluginsService,
+			$injector
+		);
+	}
+
+	public liveSyncProcessesInfo: IDictionary<ILiveSyncProcessInfo> = {};
+}
+
+interface IStopLiveSyncTestCase {
+	name: string;
+	currentDeviceIdentifiers: string[];
+	expectedDeviceIdentifiers: string[];
+	deviceIdentifiersToBeStopped?: string[];
+}
+
+describe("liveSyncService", () => {
+	describe("stopLiveSync", () => {
+		const getLiveSyncProcessInfo = (): ILiveSyncProcessInfo => ({
+			actionsChain: Promise.resolve(),
+			currentSyncAction: Promise.resolve(),
+			isStopped: false,
+			timer: setTimeout(() => undefined, 1000),
+			watcherInfo: {
+				watcher: <any>{
+					close: (): any => undefined
+				},
+				pattern: "pattern"
+			},
+			deviceDescriptors: []
+		});
+
+		const getDeviceDescriptor = (identifier: string): ILiveSyncDeviceInfo => ({
+			identifier,
+			outputPath: "",
+			skipNativePrepare: false,
+			platformSpecificOptions: null,
+			buildAction: () => Promise.resolve("")
+		});
+
+		const testCases: IStopLiveSyncTestCase[] = [
+			{
+				name: "stops LiveSync operation for all devices and emits liveSyncStopped for all of them when stopLiveSync is called without deviceIdentifiers",
+				currentDeviceIdentifiers: ["device1", "device2", "device3"],
+				expectedDeviceIdentifiers: ["device1", "device2", "device3"]
+			},
+			{
+				name: "stops LiveSync operation for all devices and emits liveSyncStopped for all of them when stopLiveSync is called without deviceIdentifiers (when a single device is attached)",
+				currentDeviceIdentifiers: ["device1"],
+				expectedDeviceIdentifiers: ["device1"]
+			},
+			{
+				name: "stops LiveSync operation for specified devices and emits liveSyncStopped for each of them (when a single device is attached)",
+				currentDeviceIdentifiers: ["device1"],
+				expectedDeviceIdentifiers: ["device1"],
+				deviceIdentifiersToBeStopped: ["device1"]
+			},
+			{
+				name: "stops LiveSync operation for specified devices and emits liveSyncStopped for each of them",
+				currentDeviceIdentifiers: ["device1", "device2", "device3"],
+				expectedDeviceIdentifiers: ["device1", "device3"],
+				deviceIdentifiersToBeStopped: ["device1", "device3"]
+			},
+			{
+				name: "does not raise liveSyncStopped event for device, which is not currently being liveSynced",
+				currentDeviceIdentifiers: ["device1", "device2", "device3"],
+				expectedDeviceIdentifiers: ["device1"],
+				deviceIdentifiersToBeStopped: ["device1", "device4"]
+			}
+		];
+
+		for (const testCase of testCases) {
+			it(testCase.name, async () => {
+				const testInjector = createTestInjector();
+				const liveSyncService = testInjector.resolve<LiveSyncServiceInheritor>(LiveSyncServiceInheritor);
+				const projectDir = "projectDir";
+				const emittedDeviceIdentifiersForLiveSyncStoppedEvent: string[] = [];
+				liveSyncService.on("liveSyncStopped", (data: { projectDir: string, deviceIdentifier: string }) => {
+					assert.equal(data.projectDir, projectDir);
+					emittedDeviceIdentifiersForLiveSyncStoppedEvent.push(data.deviceIdentifier);
+				});
+
+				// Setup liveSyncProcessesInfo for current test
+				liveSyncService.liveSyncProcessesInfo[projectDir] = getLiveSyncProcessInfo();
+				const deviceDescriptors = testCase.currentDeviceIdentifiers.map(d => getDeviceDescriptor(d));
+				liveSyncService.liveSyncProcessesInfo[projectDir].deviceDescriptors.push(...deviceDescriptors);
+
+				await liveSyncService.stopLiveSync(projectDir, testCase.deviceIdentifiersToBeStopped);
+
+				assert.deepEqual(emittedDeviceIdentifiersForLiveSyncStoppedEvent, testCase.expectedDeviceIdentifiers);
+			});
+		}
+
+	});
+
+});