flagpole/dist/cli/config.js

Simple and fast DOM integration, headless or headful browser, and REST API testing framework.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const util_1 = require("../util");
const fs = require('fs');
const path = require('path');
class EnvConfig {
    constructor(config, opts) {
        this.config = config;
        this.name = opts.name || '';
        this.defaultDomain = opts.defaultDomain || '';
    }
}
exports.EnvConfig = EnvConfig;
class SuiteConfig {
    constructor(config, opts) {
        this.tags = [];
        this.config = config;
        this.name = opts.name || '';
        this.id = opts.id || '';
        if (util_1.toType(opts.tags) == 'array') {
            opts.tags.forEach(tag => {
                this.tags.push(String(tag));
            });
        }
    }
    getPath() {
        return this.config.getTestsFolder() + this.name + '.js';
    }
    clearTags() {
        this.tags = [];
    }
    addTag(tag) {
        tag = String(tag).trim();
        if (tag.length && this.tags.indexOf(tag) < 0) {
            this.tags.push(tag);
        }
    }
}
exports.SuiteConfig = SuiteConfig;
class ProjectConfig {
    constructor(config, opts) {
        this.id = '';
        this.name = 'default';
        this.path = 'tests';
        this.config = config;
        if (util_1.toType(opts) == 'object') {
            this.id = opts.id || '';
            this.name = opts.name || 'default';
            this.path = opts.path || 'tests';
        }
    }
    hasId() {
        return (this.id.length > 0);
    }
    toJson() {
        return {
            id: this.id,
            name: this.name,
            path: this.path
        };
    }
}
exports.ProjectConfig = ProjectConfig;
class FlagpoleConfig {
    constructor(configData = {}) {
        this._onSave = [];
        this.suites = {};
        this.environments = {};
        let config = this;
        this.configPath = configData.configPath || process.cwd() + '/flagpole.json';
        this.project = new ProjectConfig(this, configData.project);
        if (util_1.toType(configData.suites) == 'object') {
            for (let key in configData.suites) {
                configData.suites[key]['name'] = key;
                config.suites[key] = new SuiteConfig(this, configData.suites[key]);
            }
        }
        if (util_1.toType(configData.environments) == 'object') {
            for (let key in configData.environments) {
                configData.environments[key]['name'] = key;
                config.environments[key] = new EnvConfig(this, configData.environments[key]);
            }
        }
    }
    getConfigFolder() {
        return path.dirname(this.configPath);
    }
    getConfigPath() {
        return this.configPath;
    }
    getTestsFolder() {
        return util_1.normalizePath(this.getConfigFolder() + '/' + this.project.path);
    }
    addEnvironment(name, opts = {}) {
        if (name.length) {
            this.environments[name] = new EnvConfig(this, Object.assign(opts, { name: name }));
        }
    }
    addSuite(name, opts = {}) {
        if (name.length) {
            const suite = new SuiteConfig(this, Object.assign(opts, { name: name }));
            this.suites[name] = suite;
        }
    }
    removeEnvironment(name) {
        delete this.environments[name];
    }
    removeSuite(name) {
        delete this.suites[name];
    }
    getEnvironments() {
        let envConfigs = [];
        for (let key in this.environments) {
            envConfigs.push(this.environments[key]);
        }
        return envConfigs;
    }
    getEnvironmentNames() {
        let envs = [];
        for (let key in this.environments) {
            envs.push(this.environments[key].name);
        }
        return envs;
    }
    getSuites() {
        let suiteConfigs = [];
        for (let key in this.suites) {
            suiteConfigs.push(this.suites[key]);
        }
        return suiteConfigs;
    }
    getSuiteNames() {
        let suiteNames = [];
        for (let key in this.suites) {
            suiteNames.push(this.suites[key].name);
        }
        return suiteNames;
    }
    isValid() {
        if (this.project === null || this.project.name.length == 0 || this.project.path.length == 0) {
            return false;
        }
        if (typeof this.getTestsFolder() == 'undefined' || !fs.existsSync(this.getTestsFolder())) {
            return false;
        }
        if (Object.keys(this.environments).length == 0) {
            return false;
        }
        return true;
    }
    toString() {
        let config = this;
        return JSON.stringify({
            project: this.project.toJson(),
            environments: (function () {
                let envs = {};
                for (let key in config.environments) {
                    envs[key] = {
                        name: config.environments[key].name,
                        defaultDomain: config.environments[key].defaultDomain
                    };
                }
                return envs;
            })(),
            suites: (function () {
                let suites = {};
                for (let key in config.suites) {
                    suites[key] = {
                        name: config.suites[key].name,
                        tags: config.suites[key].tags
                    };
                }
                return suites;
            })()
        }, null, 2);
    }
    onSave(callback) {
        this._onSave.push(callback);
    }
    save() {
        return new Promise((resolve, reject) => {
            fs.writeFile(this.getConfigPath(), this.toString(), (err) => {
                if (err) {
                    return reject(err);
                }
                this._onSave.forEach(callback => {
                    callback();
                });
                resolve();
            });
        });
    }
}
exports.FlagpoleConfig = FlagpoleConfig;
//# sourceMappingURL=config.js.map