ics-builder 4.4.9 → 4.4.10

package/src/services/source/loaders/baseLoader.ts

@@ -0,0 +1,28 @@
+import { SourceConfig, PackageVersion } from "../sourceManager";
+import * as shell from "shelljs";
+import * as yaml from "yamljs";
+import * as path from "path";
+
+export type ScmProviderOptions = {
+	url: string;
+	group: string;
+};
+
+export interface ScmProvider {
+	exec(cmd: string, targetDir?: string): shell.ShellString;
+	clone(config: SourceConfig): shell.ShellString;
+	pull(config: SourceConfig): shell.ShellString;
+	update(config: SourceConfig, version: PackageVersion): shell.ShellString;
+	getBranches(config: SourceConfig): shell.ShellString;
+	getTags(config: SourceConfig): shell.ShellString;
+	getVersion(config: SourceConfig): PackageVersion;
+	clean(config: SourceConfig): void;
+}
+
+export type ScmType = "git" | "hg";
+
+export interface ScmHosts {
+	[hostName: string]: { defaultType: ScmType; url: string; defaultGroup?: string };
+}
+
+export const sources: ScmHosts = <ScmHosts>yaml.load(path.join(__dirname, "../assets/hostList.yml"));

package/src/services/source/loaders/gitScmProvider.ts

@@ -0,0 +1,73 @@
+import { SourceConfig, PackageVersion } from "../sourceManager";
+import { ScmProvider, ScmProviderOptions } from "./baseLoader";
+import { Logger, Utils } from "../../../utils";
+import * as shell from "shelljs";
+
+export class GitScmProvider implements ScmProvider {
+	constructor(protected options: ScmProviderOptions) {}
+
+	exec(cmd: string, targetDir?: string, skipError?: boolean) {
+		return Utils.exec("git " + cmd, { silent: true, cwd: targetDir || "", skipError: skipError } );
+	}
+
+	clone(config: SourceConfig) {
+		Logger.info(`Cloning repository ${config.package.name} in ${config.paths.source}, please wait...`);
+		return this.exec(
+			`clone --no-checkout ${this._getGitUrl(config)} ${config.paths.source}`
+		);
+	}
+
+	pull(config: SourceConfig) {
+		Logger.info(
+			`Pulling from repository ${config.package.name} (${this._getGitUrl(config)}) ...`
+		);
+		return this.exec(`fetch --all --tags -f`, config.paths.source);
+	}
+
+	update(config: SourceConfig, version: PackageVersion) {
+		let update = this.exec(`checkout ${version.branch} --force`, config.paths.source);
+		if (!version.isTag) {
+			let result = this.exec("merge", config.paths.source, true);
+			if (result.code !== 0)
+				throw result.stderr || result.stdout;
+		}
+		Logger.info(`${config.package.name} updated to ${version.branch} (rev. ${version.revision})`);
+		return update;
+	}
+
+	getBranches(config: SourceConfig) {
+		return this.exec(`for-each-ref --format="%(refname) %(objectname:short=8)" refs/remotes refs/tags`, config.paths.source);
+	}
+
+	getTags(config: SourceConfig) {
+		return this.exec(`tag --list`, config.paths.source);
+	}
+
+	getVersion(config: SourceConfig) {
+		let parse = (response: shell.ShellString): PackageVersion =>
+			response
+				.split("\n")
+				.filter(v => v)
+				.map(line => line.split(/\s+/))
+				.map(arr => ({ branch: arr[0].replace(/tags\/|origin\/|heads\/|remotes\/|refs\//gi, ""), revision: arr[1], isTag: arr[0].includes("tags") }))
+				.filter(version => version.branch == config.package.version)[0];
+			
+		let version = parse(this.getBranches(config));
+		
+		if (!version) Logger.error(`Cannot find version ${config.package.version} of module ${config.package.name}`);
+
+		return version;
+	}
+
+	clean(config: SourceConfig) {
+		this.exec(`clean -fdx '*/package-lock.json'`, config.paths.source);
+		this.exec(`clean -fdx 'api/*/bin/*'`, config.paths.source);
+		this.exec(`clean -fdx '*/api/*/bin/*'`, config.paths.source);
+		this.exec(`clean -fdx 'api/*/obj/*'`, config.paths.source);
+		this.exec(`clean -fdx '*/api/*/obj/*'`, config.paths.source);
+	}
+
+	private _getGitUrl(config: SourceConfig): string {
+		return config.package.url ?? `${this.options.url + this.options.group}/${config.package.name}`;
+	}
+}

package/src/services/source/loaders/hgScmProvider.ts

@@ -0,0 +1,63 @@
+import { SourceConfig, PackageVersion } from "../sourceManager";
+import * as shell from "shelljs";
+import { Logger, Utils } from "../../../utils";
+import { ScmProviderOptions, ScmProvider } from "./baseLoader";
+
+export class HgScmProvider implements ScmProvider {
+	constructor(protected options: ScmProviderOptions) {}
+
+	exec(cmd: string, targetDir?: string) {
+		return Utils.exec("hg " + cmd + (targetDir ? ` -R ${targetDir}` : ""), { silent: true });
+	}
+
+	clone(config: SourceConfig) {
+		Logger.info(`Cloning repository ${config.package.name} in ${config.paths.source}, please wait...`);
+		return this.exec(
+			`clone -U ${this.options.url + this.options.group}/${config.package.name} ${config.paths.source}`
+		);
+	}
+
+	pull(config: SourceConfig) {
+		Logger.info(
+			`Pulling from repository ${config.package.name} (${this.options.url + this.options.group}/${
+				config.package.name
+			}) ...`
+		);
+		return this.exec(`pull`, config.paths.source);
+	}
+
+	update(config: SourceConfig, version: PackageVersion) {
+		let update = this.exec(`update ${version.revision} --clean`, config.paths.source);
+		Logger.info(`${config.package.name} updated to ${version.branch} (rev. ${version.revision})`);
+		return update;
+	}
+
+	getBranches(config: SourceConfig) {
+		return this.exec(`branches`, config.paths.source);
+	}
+
+	getTags(config: SourceConfig) {
+		return this.exec(`tags`, config.paths.source);
+	}
+
+	getVersion(config: SourceConfig): PackageVersion {
+		let parse = (response: shell.ShellString): PackageVersion =>
+			response
+				.split("\n")
+				.filter(value => value)
+				.map(line => line.split(/\s+/))
+				.map(arr => {
+					return { branch: arr[0], revision: arr[1].split(":")[0] };
+				})
+				.filter(version => version.branch == config.package.version)[0];
+
+		let version = parse(this.getBranches(config)) || parse(this.getTags(config));
+
+		if (!version) Logger.error(`Cannot find version ${config.package.version} of module ${config.package.name}`);
+
+		return version;
+	}
+
+	clean(config: SourceConfig) {
+	}
+}

package/src/services/source/sourceManager.ts

@@ -0,0 +1,95 @@
+import * as shell from "shelljs";
+import * as yaml from "yamljs";
+import * as path from "path";
+
+import { Config, Package } from "../configManager";
+import { Utils, Logger } from "../../utils";
+import { ScmProvider, ScmType, ScmHosts, sources } from "./loaders/baseLoader";
+import { loadPackages } from "./loadPackages";
+import { GitScmProvider } from "./loaders/gitScmProvider";
+import { HgScmProvider } from "./loaders/hgScmProvider";
+
+export interface PackageVersion {
+	branch: string;
+	revision: string;
+	isTag?: boolean;
+}
+
+export interface SourceConfig {
+	paths: { source: string; build: string };
+	package: Package;
+}
+
+interface Packages {
+	[packageName: string]: { host: string; type?: ScmType; group?: string };
+}
+
+const defaultPackage: Packages[keyof Packages] = { host: "gitlab" };
+
+const packages: Packages = loadPackages(path.join(__dirname, "./assets/sourceList.yml"));
+
+export class SourceManager {
+	private config: Config;
+
+	constructor(config: Config) {
+		this.config = config;
+	}
+
+	public loadSource(pkg: Package, skipLoad?: boolean): PackageVersion {
+		let sourceConfig: SourceConfig = {
+			package: pkg,
+			paths: {
+				source: path.join(this.config.paths.source, pkg.name),
+				build: path.join(this.config.paths.build, pkg.name)
+			}
+		};
+
+		let packageSource = packages[pkg.name] ?? defaultPackage;
+		let sourceType = packageSource.type ?? sources[packageSource.host].defaultType;
+		let packageGroup = packageSource.group ?? sources[packageSource.host].defaultGroup;
+
+		let scmOptions = { url: sources[packageSource.host].url, group: packageGroup };
+		let scmProvider = sourceType === "git" ? new GitScmProvider(scmOptions) : new HgScmProvider(scmOptions);
+
+		let version: PackageVersion;
+		if (!skipLoad) {
+			try {
+				if (Utils.ensurePath(path.join(sourceConfig.paths.source, `.${sourceType.toLowerCase()}`))) {
+					scmProvider.clean(sourceConfig);
+					scmProvider.pull(sourceConfig);
+				}
+				else {
+					scmProvider.clone(sourceConfig);
+				}
+				version = this.update(scmProvider, sourceConfig, true);
+			}
+			catch (e) {
+				if (e.includes("Merge conflict")) {
+					Logger.warn("Merge conflict, retrying");
+					Utils.prepareDir(sourceConfig.paths.source);
+					scmProvider.clone(sourceConfig);
+					version = this.update(scmProvider, sourceConfig, false);
+				}
+				else throw e;
+			}
+		} else version = scmProvider.getVersion(sourceConfig);
+
+		return version;
+	}
+
+	private update(scmProvider: ScmProvider, sourceConfig: SourceConfig, throwError: boolean): PackageVersion
+	{
+		try
+		{
+			let version = scmProvider.getVersion(sourceConfig);
+			scmProvider.update(sourceConfig, version);
+			return version
+		}
+		catch (e)
+		{
+			if (throwError)
+				throw e;
+			Logger.error(e);
+		} 
+	}
+}

package/src/services/testManager.ts

@@ -0,0 +1,27 @@
+import { ApiTestRunner } from "../testRunners/apiTestRunner";
+import { UiTestRunner } from "../testRunners/uiTestRunner";
+import { BaseTestRunner, TestRunnerConfig } from "../testRunners/baseTestRunner";
+
+interface TestRunnerConstructor {
+	new (config: TestRunnerConfig): BaseTestRunner;
+}
+
+export class TestManager {
+	private config: TestRunnerConfig;
+	private layerTestRunner: Map<string, TestRunnerConstructor>;
+
+	constructor(config: TestRunnerConfig) {
+		this.config = config;
+		this.layerTestRunner = new Map<string, TestRunnerConstructor>();
+		this.layerTestRunner.set("api", ApiTestRunner);
+		this.layerTestRunner.set("ui", UiTestRunner);
+	}
+
+	testApi(): BaseTestRunner {
+		return new (this.layerTestRunner.get("api"))(this.config);
+	}
+
+	testUi(): BaseTestRunner {
+		return new (this.layerTestRunner.get("ui"))(this.config);
+	}
+}

package/src/testRunners/apiTestRunner.ts

@@ -0,0 +1,68 @@
+import * as path from "path";
+import * as fs from "fs";
+
+import { DotnetUtils } from "../dotnetUtils";
+import { Utils } from "../utils";
+import { BaseTestRunner, TestRunnerConfig } from "./baseTestRunner";
+
+export class ApiTestRunner extends BaseTestRunner {
+	private path: string;
+	private projects = new Array<string>();
+
+	constructor(config: TestRunnerConfig) {
+		super(config);
+	}
+
+	run(): void | Promise<void> {
+		this.path = fs.lstatSync(this.config.basePath).isDirectory()
+			? this.config.basePath
+			: path.dirname(this.config.basePath);
+
+		this.projects = this.findProjects();
+
+		this.runTests();
+	}
+
+	private runSeparately() {
+		this.projects.forEach(p => {
+			var name = path.basename(p, ".csproj");
+			var logPath = path.join(this.config.resultPath, name + ".trx");
+			Utils.exec(
+				`dotnet test ${p} -p:DefineConstants=TEST --logger:"trx;LogFileName=${this.config.resultPath}"`,
+				{
+					silent: false
+				}
+			);
+		})
+	}
+
+	private findProjects(): Array<string> {
+		return Utils.findFilesInDirRecursively(this.path, "[A-Za-z0-9\\.]*.csproj$");
+	}
+
+	private runEntirely() {
+		var testSlnFileName = "Temp";
+		let projects = this.findProjects();
+		DotnetUtils.createTempSln(this.path, testSlnFileName);
+		DotnetUtils.addProjectsToSln(`${this.getSlnFullPath(testSlnFileName)}`, projects, true);
+		DotnetUtils.restoreNugetPackages(this.getSlnFullPath(testSlnFileName));
+		Utils.exec(
+			`dotnet test ${this.getSlnFullPath(testSlnFileName)} --no-restore -p:DefineConstants=TEST --logger:"trx;LogFileName=${this.config.resultPath}"`,
+			{ onProcessExit: () => this.dropTestSln("Test") }
+		);
+
+		this.dropTestSln(testSlnFileName);
+	}
+
+	private getSlnFullPath(name: string): string {
+		return `${path.join(this.path, name + ".sln")}`;
+	}
+
+	private dropTestSln(name: string): void {
+		Utils.deleteFiles("", [this.getSlnFullPath(name)]);
+	}
+
+	private runTests(): void {
+		this.runEntirely();
+	}
+}

package/src/testRunners/baseTestRunner.ts

@@ -0,0 +1,19 @@
+import { Run } from "../services/commandManager";
+import { Logger } from "../utils";
+
+export interface TestRunnerConfig {
+	resultPath?: string;
+	basePath?: string;
+	watch?: boolean;
+}
+
+export abstract class BaseTestRunner implements Run {
+	protected config: TestRunnerConfig;
+
+	abstract run(): void | Promise<void>;
+
+	constructor(config: TestRunnerConfig) {
+		this.config = config;
+		Logger.info(`using ${this.constructor.name}`);
+	}
+}

package/src/testRunners/uiTestRunner.ts

@@ -0,0 +1,8 @@
+import { BaseTestRunner } from "./baseTestRunner";
+import { run } from "jest-cli";
+
+export class UiTestRunner extends BaseTestRunner {
+	run(): void | Promise<void> {
+		run(["--ci", "--reporters=default", "--reporters=jest-junit", `--roots=${this.config.basePath}`], __dirname);
+	}
+}

package/src/utils.ts

@@ -0,0 +1,228 @@
+import { logger } from "just-task/lib/index";
+import * as shell from "shelljs";
+import * as fs from "fs";
+import * as path from "path";
+import * as glob from "glob";
+import stripBomBuffer = require("strip-bom-buf");
+import * as child_process from "child_process";
+
+export interface ExecOptions extends shell.ExecOptions {
+	skipError?: boolean;
+	logCmd?: boolean;
+	onProcessExit?: { (): void };
+	async?: false;
+}
+
+export class Utils {
+	static exec(cmd: string, options?: ExecOptions) {
+		const { skipError, logCmd = true, ...cmdOptions } = { ...options };
+		logCmd && Logger.info(cmd);
+		try {
+			const result = shell.exec(cmd, { ...cmdOptions });
+			if (result.code !== 0 && !skipError) {
+				if (options?.onProcessExit) options.onProcessExit();
+				Logger.error(result.stderr || result.stdout || `Command execution ended with code ${result.code}`);
+			}
+			return result;
+		} catch (e) {
+			if (e?.code === "ENOENT") {
+				Logger.error(`Path: ${options?.cwd} does not exsit`);
+			} else throw e;
+		}
+	}
+
+	static execModule(path: string, args: string[], options: child_process.ForkOptions) {
+		const proc = child_process.fork(path, args, options);
+
+		process.on("SIGTERM", () => proc.kill("SIGTERM"));
+		process.on("SIGINT", () => proc.kill("SIGINT"));
+		process.on("SIGBREAK", () => proc.kill("SIGBREAK"));
+		process.on("SIGHUP", () => proc.kill("SIGHUP"));
+		proc.on("exit", (code, signal) => {
+			let exitCode = code;
+			if (exitCode === null) {
+				exitCode = signal === "SIGINT" ? 0 : 1;
+			}
+			process.exit(exitCode);
+		});
+		
+		return proc;
+	}
+
+	static ensurePath(path: string): boolean {
+		return fs.existsSync(path);
+	}
+
+	static ensureFolder(path: string): void {
+		if (!Utils.ensurePath(path)) shell.mkdir("-p", path);
+	}
+
+	static copyAllFilesByPattern(sourcePath: string, destinationPath: string, pattern: string) {
+		glob.sync(pattern, { cwd: sourcePath }).forEach(file => {
+			this.copyFile(path.join(sourcePath, file), path.join(destinationPath, file));
+		});
+	}
+
+	static copyAllFolders(sourcePath: string, destinationPath: string) {
+		glob.sync("**/", { cwd: sourcePath }).forEach(folder => {
+			this.copyFolder(path.join(sourcePath, folder), path.join(destinationPath, folder));
+		});
+	}
+
+	static copyFile(from: string, to: string): void {
+		if (Utils.ensurePath(from)) {
+			Utils.ensureFolder(path.dirname(to));
+			fs.writeFileSync(to, stripBomBuffer(fs.readFileSync(from)));
+		}
+	}
+
+	static copyFolder(from: string, to: string, skip?: Array<string>): void {
+		if (!fs.existsSync(from) || fs.lstatSync(from).isSymbolicLink())
+			// ссылки пропускаем
+			return;
+		let files = fs.readdirSync(from);
+		Utils.ensureFolder(to);
+
+		files.forEach((file, index) => {
+			let currentFrom = path.join(from, file);
+			let currentTo = path.join(to, file);
+
+			if (skip && skip.length > 0) {
+				let found = false;
+				skip.forEach(item => {
+					if (item.toLowerCase() == currentFrom.toLowerCase()) {
+						found = true;
+						return;
+					}
+				});
+				if (found) return;
+			}
+
+			let stats = fs.statSync(currentFrom);
+			if (stats.isFile()) {
+				Utils.copyFile(currentFrom, currentTo);
+			} else if (stats.isDirectory()) {
+				Utils.copyFolder(currentFrom, currentTo, skip);
+			}
+		});
+	}
+
+	static clearFolder(dir: string): void {
+		if (fs.existsSync(dir)) {
+			fs.readdirSync(dir).forEach(function (file, index) {
+				var curPath = path.join(dir, file);
+				if (fs.lstatSync(curPath).isDirectory()) {
+					Utils.clearFolder(curPath);
+				} else {
+					// delete file
+					Utils.safeInvoke(() => {
+						fs.unlinkSync(curPath);
+					});
+				}
+			});
+			Utils.safeInvoke(() => {
+				fs.rmdirSync(dir);
+			});
+		}
+	}
+
+	static safeInvoke(func: Function): void {
+		try {
+			func();
+		} catch (ex) {
+			// do nothing
+		}
+	}
+
+	static deleteFiles(dir: string, files: Array<string>) {
+		for (var i = 0; i < files.length; i++) {
+			var file = path.join(dir, files[i]);
+			this.deleteFile(file);
+		}
+	}
+
+	static deleteFile(path: string) {
+		if (fs.existsSync(path)) fs.unlinkSync(path);
+	}
+
+	static prepareDir(dir: string): void {
+		Utils.clearFolder(dir);
+		Utils.ensureFolder(dir);
+	}
+
+	static removeEmptyFolders(dir: string) {
+		try {
+			if (fs.existsSync(dir)) {
+				fs.readdirSync(dir).forEach(file => {
+					let curPath = path.join(dir, file);
+					if (fs.lstatSync(curPath).isDirectory()) {
+						Utils.removeEmptyFolders(curPath);
+					}
+				});
+
+				if (fs.readdirSync(dir).length == 0)
+					Utils.safeInvoke(() => {
+						fs.rmdirSync(dir);
+					});
+			}
+		} catch (ex) {}
+	}
+
+	static findFilesInDirRecursively(dir: string, fileNamePattern: string): Array<string> {
+		let res = Array<string>();
+		let regex = RegExp(fileNamePattern);
+
+		let findFilesRecursively = (files: fs.Dirent[], baseDirPath: string) => {
+			files.forEach(f => {
+				let dirFullPath = path.join(baseDirPath, f.name);
+				if (f.isDirectory()) {
+					findFilesRecursively(fs.readdirSync(dirFullPath, { withFileTypes: true }), dirFullPath);
+				} else if (f.isFile()) {
+					if (regex.test(f.name)) res.push(dirFullPath);
+				}
+			});
+		};
+
+		let startFile = fs.lstatSync(dir);
+
+		if (startFile.isDirectory()) {
+			findFilesRecursively(fs.readdirSync(dir, { withFileTypes: true }), dir);
+		} else if (startFile.isFile() && regex.test(path.basename(dir))) {
+			res.push(dir);
+		}
+
+		return res;
+	}
+
+	static deleteAllFoldersRecursively(cwd: string, folderName: string): void {
+		let files = fs.readdirSync(cwd, { withFileTypes: true });
+		files.forEach(f => {
+			if (!f.isDirectory()) return;
+			let dirFullPath = path.join(cwd, f.name);
+			if (f.name == folderName) {
+				Utils.clearFolder(dirFullPath);
+				return;
+			}
+			this.deleteAllFoldersRecursively(dirFullPath, folderName);
+		});
+	}
+
+	static getFileName(path: string) {
+		return path.match(/([^\\/]+?)(\.[^.\\/]+)?$/)?.[1] ?? "";
+	}
+}
+
+export class Logger {
+	static info(...args: any): void {
+		logger.info(...args);
+	}
+
+	static warn(...args: any): void {
+		logger.warn(...args);
+	}
+
+	static error(...args: any): void {
+		logger.error(...args);
+		process.exit(1);
+	}
+}

package/test/sourceManager.test.ts

@@ -0,0 +1,17 @@
+import { mapPackages } from "../src/services/source/loadPackages";
+
+test("Packages config is loaded correctly", () => {
+	const groups = {
+		icsit: {
+			mdt: { host: "bitbucket" },
+			ics: { host: "bitbucket", type: "git" }
+		},
+		alfa: { mdm: { host: "gitlab" } }
+	};
+
+	const packages = mapPackages(groups);
+
+	expect(packages).not.toBe(null);
+	expect(Object.keys(packages).length).toBe(3);
+	expect(packages["mdt"]).toEqual({ host: "bitbucket", group: "icsit" });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+	"compilerOptions": {
+		"sourceMap": false,
+		"target": "es5",
+		"baseUrl": "./",
+		"moduleResolution": "node",
+		"outDir": "./dist/src",
+		"skipLibCheck": true
+	},
+	"exclude": [
+		"node_modules",
+		"**/*.test.ts"
+	],
+	"include": [
+		"src"
+	],
+	"compileOnSave": false
+}

package/wallaby.js

@@ -0,0 +1,14 @@
+module.exports = function(w) {
+	return {
+		files: ["src/**/*.ts"],
+
+		tests: ["test/**/*.test.ts"],
+
+		env: {
+			type: "node"
+		},
+
+		testFramework: "jest",
+		debug: true
+	};
+};