npm-support.ts

import yok = require('../lib/common/yok');
import stubs = require('./stubs');
import ErrorsLib = require("../lib/common/errors");
import NpmLib = require("../lib/node-package-manager");
import FsLib = require("../lib/common/file-system");
import OptionsLib = require("../lib/options");
import StaticConfigLib = require("../lib/config");
import HostInfoLib = require("../lib/common/host-info");
import PlatformsDataLib = require("../lib/platforms-data");
import PlatformServiceLib = require('../lib/services/platform-service');
import ProjectDataLib = require("../lib/project-data");
import ProjectHelperLib = require("../lib/common/project-helper");
import ProjectDataServiceLib = require("../lib/services/project-data-service");
import CommandsServiceLib = require("../lib/common/services/commands-service");
import NodeModulesLib = require("../lib/tools/node-modules/node-modules-builder");
import PluginsServiceLib = require("../lib/services/plugins-service");
import ChildProcessLib = require("../lib/common/child-process");
import ProjectFilesManagerLib = require("../lib/common/services/project-files-manager");
import { DeviceAppDataFactory } from "../lib/common/mobile/device-app-data/device-app-data-factory";
import { LocalToDevicePathDataFactory } from "../lib/common/mobile/local-to-device-path-data-factory";
import { MobileHelper } from "../lib/common/mobile/mobile-helper";
import { ProjectFilesProvider } from "../lib/providers/project-files-provider";
import { DeviceAppDataProvider } from "../lib/providers/device-app-data-provider";
import { MobilePlatformsCapabilities } from "../lib/mobile-platforms-capabilities";
import { DevicePlatformsConstants } from "../lib/common/mobile/device-platforms-constants";
import { XmlValidator } from "../lib/xml-validator";
import { LockFile } from "../lib/lockfile";
import ProjectChangesLib = require("../lib/services/project-changes-service");
import { Messages } from "../lib/common/messages/messages";

import path = require("path");
import temp = require("temp");
temp.track();

let assert = require("chai").assert;
let nodeModulesFolderName = "node_modules";
let packageJsonName = "package.json";

function createTestInjector(): IInjector {
	let testInjector = new yok.Yok();
	testInjector.register("fs", FsLib.FileSystem);
	testInjector.register("adb", {});
	testInjector.register("options", OptionsLib.Options);
	testInjector.register("errors", ErrorsLib.Errors);
	testInjector.register("staticConfig", StaticConfigLib.StaticConfig);
	testInjector.register("hostInfo", HostInfoLib.HostInfo);
	testInjector.register("platformsData", PlatformsDataLib.PlatformsData);
	testInjector.register("platformService", PlatformServiceLib.PlatformService);
	testInjector.register("logger", stubs.LoggerStub);
	testInjector.register("npmInstallationManager", {});
	testInjector.register("lockfile", LockFile);
	testInjector.register("prompter", {});
	testInjector.register("sysInfo", {});
	testInjector.register("androidProjectService", {});
	testInjector.register("iOSProjectService", {});
	testInjector.register("devicesService", {});
	testInjector.register("resources", {});
	testInjector.register("projectData", ProjectDataLib.ProjectData);
	testInjector.register("projectHelper", ProjectHelperLib.ProjectHelper);
	testInjector.register("projectDataService", ProjectDataServiceLib.ProjectDataService);
	testInjector.register("commandsService", CommandsServiceLib.CommandsService);
	testInjector.register("hooksService", stubs.HooksServiceStub);
	testInjector.register("nodeModulesBuilder", NodeModulesLib.NodeModulesBuilder);
	testInjector.register("pluginsService", PluginsServiceLib.PluginsService);
	testInjector.register("npm", NpmLib.NodePackageManager);
	testInjector.register("childProcess", ChildProcessLib.ChildProcess);
	testInjector.register("projectFilesManager", ProjectFilesManagerLib.ProjectFilesManager);
	testInjector.register("commandsServiceProvider", {
		registerDynamicSubCommands: () => { /* intentionally left blank */ }
	});
	testInjector.register("pluginVariablesService", {});
	testInjector.register("deviceAppDataFactory", DeviceAppDataFactory);
	testInjector.register("localToDevicePathDataFactory", LocalToDevicePathDataFactory);
	testInjector.register("mobileHelper", MobileHelper);
	testInjector.register("projectFilesProvider", ProjectFilesProvider);
	testInjector.register("deviceAppDataProvider", DeviceAppDataProvider);
	testInjector.register("mobilePlatformsCapabilities", MobilePlatformsCapabilities);
	testInjector.register("devicePlatformsConstants", DevicePlatformsConstants);
	testInjector.register("xmlValidator", XmlValidator);
	testInjector.register("config", StaticConfigLib.Configuration);
	testInjector.register("projectChangesService", ProjectChangesLib.ProjectChangesService);
	testInjector.register("emulatorPlatformService", stubs.EmulatorPlatformService);
	testInjector.register("analyticsService", {
		track: async () => undefined
	});
	testInjector.register("messages", Messages);

	return testInjector;
}

function createProject(testInjector: IInjector, dependencies?: any): string {
	let tempFolder = temp.mkdirSync("npmSupportTests");
	let options = testInjector.resolve("options");
	options.path = tempFolder;

	dependencies = dependencies || {
		"lodash": "3.9.3"
	};

	let packageJsonData: any = {
		"name": "testModuleName",
		"version": "0.1.0",
		"nativescript": {
			"id": "org.nativescript.Test",
			"tns-android": {
				"version": "1.0.0"
			}
		},
		"description": "dummy",
		"license": "MIT",
		"readme": "dummy",
		"repository": "dummy"
	};
	packageJsonData["dependencies"] = dependencies;
	packageJsonData["devDependencies"] = {};

	testInjector.resolve("fs").writeJson(path.join(tempFolder, "package.json"), packageJsonData);
	return tempFolder;
}

async function setupProject(dependencies?: any): Promise<any> {
	let testInjector = createTestInjector();
	let projectFolder = createProject(testInjector, dependencies);

	let fs = testInjector.resolve("fs");

	// Creates app folder
	let appFolderPath = path.join(projectFolder, "app");
	fs.createDirectory(appFolderPath);
	let appResourcesFolderPath = path.join(appFolderPath, "App_Resources");
	fs.createDirectory(appResourcesFolderPath);
	fs.createDirectory(path.join(appResourcesFolderPath, "Android"));
	fs.createDirectory(path.join(appResourcesFolderPath, "Android", "mockdir"));
	fs.createDirectory(path.join(appFolderPath, "tns_modules"));

	// Creates platforms/android folder
	let androidFolderPath = path.join(projectFolder, "platforms", "android");
	fs.ensureDirectoryExists(androidFolderPath);

	// Mock platform data
	let appDestinationFolderPath = path.join(androidFolderPath, "assets");
	let platformsData = testInjector.resolve("platformsData");

	platformsData.getPlatformData = (platform: string) => {
		return {
			appDestinationDirectoryPath: appDestinationFolderPath,
			appResourcesDestinationDirectoryPath: path.join(appDestinationFolderPath, "app", "App_Resources"),
			frameworkPackageName: "tns-android",
			normalizedPlatformName: "Android",
			projectRoot: projectFolder,
			configurationFileName: "AndroidManifest.xml",
			platformProjectService: {
				prepareProject: (): any => null,
				prepareAppResources: (): any => null,
				afterPrepareAllPlugins: () => Promise.resolve(),
				beforePrepareAllPlugins: () => Promise.resolve(),
				getAppResourcesDestinationDirectoryPath: () => path.join(androidFolderPath, "src", "main", "res"),
				processConfigurationFilesFromAppResources: () => Promise.resolve(),
				ensureConfigurationFileInAppResources: (): any => null,
				interpolateConfigurationFile: (): void => undefined,
				isPlatformPrepared: (projectRoot: string) => false,
				validatePlugins: (projectData: IProjectData) => Promise.resolve(),
				cleanProject: () => Promise.resolve(),
			}
		};
	};

	return {
		testInjector: testInjector,
		projectFolder: projectFolder,
		appDestinationFolderPath: appDestinationFolderPath,
	};
}

async function addDependencies(testInjector: IInjector, projectFolder: string, dependencies: any, devDependencies?: any): Promise<void> {
	let fs = testInjector.resolve("fs");
	let packageJsonPath = path.join(projectFolder, "package.json");
	let packageJsonData = fs.readJson(packageJsonPath);

	let currentDependencies = packageJsonData.dependencies;
	_.extend(currentDependencies, dependencies);

	if (devDependencies) {
		let currentDevDependencies = packageJsonData.devDependencies;
		_.extend(currentDevDependencies, devDependencies);
	}
	fs.writeJson(packageJsonPath, packageJsonData);
}

async function preparePlatform(testInjector: IInjector): Promise<void> {
	const platformService: IPlatformService = testInjector.resolve("platformService");
	const projectData: IProjectData = testInjector.resolve("projectData");
	projectData.initializeProjectData();
	const options: IOptions = testInjector.resolve("options");

	await platformService.preparePlatform("android", { bundle: options.bundle, release: options.release }, "", projectData, { provision: options.provision, sdk: options.sdk });
}

describe("Npm support tests", () => {
	let testInjector: IInjector, projectFolder: string, appDestinationFolderPath: string;
	beforeEach(async () => {
		let projectSetup = await setupProject();
		testInjector = projectSetup.testInjector;
		projectFolder = projectSetup.projectFolder;
		appDestinationFolderPath = projectSetup.appDestinationFolderPath;
	});
	it("Ensures that the installed dependencies are prepared correctly", async () => {
		let fs: IFileSystem = testInjector.resolve("fs");
		// Setup
		await addDependencies(testInjector, projectFolder, { "bplist": "0.0.4" });

		// Act
		await preparePlatform(testInjector);

		// Assert
		let tnsModulesFolderPath = path.join(appDestinationFolderPath, "app", "tns_modules");

		let results = fs.enumerateFilesInDirectorySync(tnsModulesFolderPath, (file, stat) => {
			return true;
		}, { enumerateDirectories: true });

		assert.isTrue(results.filter((val) => _.endsWith(val, "lodash")).length === 1);
		assert.isTrue(results.filter((val) => _.endsWith(val, path.join(tnsModulesFolderPath, "bplist"))).length === 1);
		assert.isTrue(results.filter((val) => _.endsWith(val, "bplist-creator")).length === 1);
		assert.isTrue(results.filter((val) => _.endsWith(val, "bplist-parser")).length === 1);
	});
	it("Ensures that scoped dependencies are prepared correctly", async () => {
		// Setup
		let fs = testInjector.resolve("fs");
		let scopedName = "@reactivex/rxjs";
		let dependencies: any = {};
		dependencies[scopedName] = "0.0.0-prealpha.3";
		// Do not pass dependencies object as the sinopia cannot work with scoped dependencies. Instead move them manually.
		await addDependencies(testInjector, projectFolder, dependencies);
		// Act
		await preparePlatform(testInjector);
		// Assert
		let tnsModulesFolderPath = path.join(appDestinationFolderPath, "app", "tns_modules");
		let scopedDependencyPath = path.join(tnsModulesFolderPath, "@reactivex", "rxjs");
		assert.isTrue(fs.exists(scopedDependencyPath));
	});

	it("Ensures that scoped dependencies are prepared correctly when are not in root level", async () => {
		// Setup
		let customPluginName = "plugin-with-scoped-dependency";
		let customPluginDirectory = temp.mkdirSync("custom-plugin-directory");

		let fs: IFileSystem = testInjector.resolve("fs");
		await fs.unzip(path.join("resources", "test", `${customPluginName}.zip`), customPluginDirectory);

		await addDependencies(testInjector, projectFolder, { "plugin-with-scoped-dependency": `file:${path.join(customPluginDirectory, customPluginName)}` });
		// Act
		await preparePlatform(testInjector);
		// Assert
		let tnsModulesFolderPath = path.join(appDestinationFolderPath, "app", "tns_modules");
		let results = fs.enumerateFilesInDirectorySync(tnsModulesFolderPath, (file, stat) => {
			return true;
		}, { enumerateDirectories: true });

		let filteredResults = results.filter((val) => {
			return _.endsWith(val, path.join("@scoped-plugin", "inner-plugin"));
		});

		assert.isTrue(filteredResults.length === 1);
	});

	it("Ensures that tns_modules absent when bundling", async () => {
		let fs = testInjector.resolve("fs");
		let options = testInjector.resolve("options");
		let tnsModulesFolderPath = path.join(appDestinationFolderPath, "app", "tns_modules");

		try {
			options.bundle = false;
			await preparePlatform(testInjector);
			assert.isTrue(fs.exists(tnsModulesFolderPath), "tns_modules created first");

			options.bundle = true;
			await preparePlatform(testInjector);
			assert.isFalse(fs.exists(tnsModulesFolderPath), "tns_modules deleted when bundling");

			options.bundle = false;
			await preparePlatform(testInjector);
			assert.isTrue(fs.exists(tnsModulesFolderPath), "tns_modules recreated");
		} finally {
			options.bundle = false;
		}
	});
});

describe("Flatten npm modules tests", () => {
	it("Doesn't handle the dependencies of devDependencies", async () => {
		let projectSetup = await setupProject({});
		let testInjector = projectSetup.testInjector;
		let projectFolder = projectSetup.projectFolder;
		let appDestinationFolderPath = projectSetup.appDestinationFolderPath;

		let devDependencies = {
			"gulp": "3.9.0",
			"gulp-jscs": "1.6.0",
			"gulp-jshint": "1.11.0"
		};

		await addDependencies(testInjector, projectFolder, {}, devDependencies);

		await preparePlatform(testInjector);

		// Assert
		let fs = testInjector.resolve("fs");
		let tnsModulesFolderPath = path.join(appDestinationFolderPath, "app", "tns_modules");

		let gulpFolderPath = path.join(tnsModulesFolderPath, "gulp");
		assert.isFalse(fs.exists(gulpFolderPath));

		let gulpJscsFolderPath = path.join(tnsModulesFolderPath, "gulp-jscs");
		assert.isFalse(fs.exists(gulpJscsFolderPath));

		let gulpJshint = path.join(tnsModulesFolderPath, "gulp-jshint");
		assert.isFalse(fs.exists(gulpJshint));

		// Get	all gulp dependencies
		let gulpJsonContent = fs.readJson(path.join(projectFolder, nodeModulesFolderName, "gulp", packageJsonName));
		_.each(_.keys(gulpJsonContent.dependencies), dependency => {
			assert.isFalse(fs.exists(path.join(tnsModulesFolderPath, dependency)));
		});

		// Get all gulp-jscs dependencies
		let gulpJscsJsonContent = fs.readJson(path.join(projectFolder, nodeModulesFolderName, "gulp-jscs", packageJsonName));
		_.each(_.keys(gulpJscsJsonContent.dependencies), dependency => {
			assert.isFalse(fs.exists(path.join(tnsModulesFolderPath, dependency)));
		});

		// Get all gulp-jshint dependencies
		let gulpJshintJsonContent = fs.readJson(path.join(projectFolder, nodeModulesFolderName, "gulp-jshint", packageJsonName));
		_.each(_.keys(gulpJshintJsonContent.dependencies), dependency => {
			assert.isFalse(fs.exists(path.join(tnsModulesFolderPath, dependency)));
		});
	});
});