apeman-tmpl-bud/test/load_test.js

apeman template of bud files.

/**
 * Test case for load.
 * Runs with mocha.
 */
"use strict";

const load = require('../lib/load.js'),
    coz = require('coz'),
    assert = require('assert');

describe('load', () => {

    let tmpDir = `${__dirname}/../tmp`;

    before((done) => {
        done();
    });

    after((done) => {
        done();
    });


    it('Render ci', (done) => {
        let bud = load({
            type: 'ci',
            names: [
                "build"
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-ci/.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render ci misc', (done) => {
        let bud = load({
            type: 'ciMisc'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-ci/misc/.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render scss attributes', (done) => {
        let bud = load({
            type: 'scssAttributes'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-scss/attributes/.scss.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render scss components', (done) => {
        let bud = load({
            type: 'scssComponents'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-scss/components/.scss.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render scss media', (done) => {
        let bud = load({
            type: 'scssMedia'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-scss/media/.scss.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render scss variables', (done) => {
        let bud = load({
            type: 'scssVariables'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-scss/variables/.scss.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render locale', (done) => {
        let bud = load({
            type: 'locale',
            namespace: [
                'sections',
                'titles'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-locale/.json.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render env', (done) => {
        let bud = load({
            type: 'env'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-env/.json.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render db models', (done) => {
        let bud = load({
            type: 'models',
            name: [
                'sign',
                'user'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.force = true;
        bud.path = `${tmpDir}/testing-db/models/.json.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render db seeds', (done) => {
        let bud = load({
            type: 'seeds',
            name: [
                'sign',
                'user'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.force = true;
        bud.path = `${tmpDir}/testing-db/seeds/.seed.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render db hooks', (done) => {
        let bud = load({
            type: 'hooks',
            name: [
                'UserVerify',
                'UserRecover'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.force = true;
        bud.path = `${tmpDir}/testing-db/hooks/.hook.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render db addons', (done) => {
        let bud = load({
            type: 'addons',
            name: [
                'UserSign'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.force = true;
        bud.path = `${tmpDir}/testing-db/addons/.addon.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });


    it('Render guide', (done) => {
        let bud = load({
            type: 'guides',
            name: [
                'requirements',
                'setup',
                'development',
                'dockerlize',
                'production'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-doc/guides/.json.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render ui route', (done) => {
        let bud = load({
            type: 'uiRoute'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.force = true;
        bud.path = `${tmpDir}/testing-route/ui-route/.route.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render ui middleware', (done) => {
        let bud = load({
            type: 'uiMiddleware'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.force = true;
        bud.path = `${tmpDir}/testing-middleware/ui-middleware/.middleware.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render api middleware', (done) => {
        let bud = load({
            type: 'apiMiddleware',
            name: [
                'locale'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.force = true;
        bud.path = `${tmpDir}/testing-middleware/api-middleware/.middleware.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react middleware', (done) => {
        let bud = load({
            type: 'reactMiddleware'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.force = true;
        bud.path = `${tmpDir}/testing-middleware/react-middleware/.middleware.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });


    it('Render react service', (done) => {
        let bud = load({
            type: 'reactService',
            name: [
                'foo',
                'bar'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.force = true;
        bud.path = `${tmpDir}/testing-service/react-service/.service.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render api route', (done) => {
        let bud = load({
            type: 'apiRoute'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-route/api-route/.route.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render admin api route', (done) => {
        let bud = load({
            type: 'apiRoute'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-route/admin-api-route/.route.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render schema', (done) => {
        let bud = load({
            type: 'schema'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-schema/schema/.schema.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react view', (done) => {
        let bud = load({
            type: 'reactView',
            name: [
                'splash/SplashTop',
                'other/OtherTop',
                'sign/SignSignup',
                'sign/SignSignin',
                'recover/RecoverSend'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-react/views/.jsx.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react browser', (done) => {
        let bud = load({
            type: 'reactBrowser'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-react/browsers/.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react mixin', (done) => {
        let bud = load({
            type: 'reactMixin'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-react/mixins/.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react mixin group', (done) => {
        let bud = load({
            type: 'reactMixinGroup',
            name: [
                'view',
                'form'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-react/mixins/groups/.group.jsx.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react store', (done) => {
        let bud = load({
            type: 'reactStore',
            name: [
                'sign'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-react/stores/.store.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react store access', (done) => {
        let bud = load({
            type: 'reactStoreAccess',
            name: [
                'dispatch'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-react/stores/accessing/.access.jsx.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react store reduce', (done) => {
        let bud = load({
            type: 'reactStoreReduce',
            name: [
                'listing'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-react/stores/reducing/.reduce.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react page', (done) => {
        let bud = load({
            type: 'reactPage'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-react/pages/.json.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react fragment', (done) => {
        let bud = load({
            type: 'reactFragment'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-react/fragments/.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render react component', (done) => {
        let bud = load({
            type: 'reactComponent'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-react/components/.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render bin daemon', (done) => {
        let bud = load({
            type: 'binDaemon',
            commands: [
                'start',
                'stop',
                'show'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-bin/bin/.json.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render bin app', (done) => {
        let bud = load({
            type: 'binApp',
            commands: [
                'start',
                'stop',
                'show'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-bin/bin/app/.json.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });


    it('Render terminal', (done) => {
        let bud = load({
            type: 'terminal'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-debug/.terminal.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render util', (done) => {
        let bud = load({
            type: 'util',
            name:[
                'array',
                'object'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-generic/.util.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });


    it('Render node cache', (done) => {
        let bud = load({
            type: 'nodeCache'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-node/.package.json.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });


    it('Render mysql', (done) => {
        let bud = load({
            type: 'bin-mysql'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-mysql/.mysql.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render node', (done) => {
        let bud = load({
            type: 'bin-node'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-node/.node.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render nginx', (done) => {
        let bud = load({
            type: 'bin-nginx'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-nginx/.nginx.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render env-bin', (done) => {
        let bud = load({
            type: 'bin-env'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-env-bin/.sh.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render env-local-bin', (done) => {
        let bud = load({
            type: 'bin-env-local'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-env-local-bin/.sh.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render settings', (done) => {
        let bud = load({
            type: 'settings',
            name: [
                'route',
                'asset'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-settings/.setting.json.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render route-test', (done) => {
        let bud = load({
            type: 'route-test',
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-route-test/.test.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render component-test', (done) => {
        let bud = load({
            type: 'component-test',
            src: '../../components/**/*.js'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-component-test/.test.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render static privacy', (done) => {
        let bud = load({
            type: 'privacy',
            langs: 'en,ja'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-statics/.privacy-policy.html.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render static terms', (done) => {
        let bud = load({
            type: 'terms',
            langs: 'en,ja'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-statics/.terms-of-use.html.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render mail templates', (done) => {
        let bud = load({
            type: 'mailTemplate',
            name: [
                'email-verify',
                'password-reset',
                'resign-done'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-mail/templates/.hbs.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render mail triggers', (done) => {
        let bud = load({
            type: 'mailTrigger',
            name: [
                'verify'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-mail/triggers/.trigger.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render errors', (done) => {
        let bud = load({
            type: 'error'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-errors/.html.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });


    it('Render readme', (done) => {
        let bud = load({
            type: 'readme'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-readme/.README.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render consts', (done) => {
        let bud = load({
            type: 'consts',
            suffix: 'constants'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-constants/.constants.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render extensions', (done) => {
        let bud = load({
            type: 'extension',
            name: [
                'props',
                'locale'
            ],
            to: 'http.IncomingMessage instances'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-extensions/.extension.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render extension tests', (done) => {
        let bud = load({
            type: 'extensionTest',
            src: '../testing-extensions/**/*.js'
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-extension-tests/.test.js.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });

    it('Render code tests', (done) => {
        let bud = load({
            type: 'code',
            name: [
                'userRole'
            ]
        }, '444', true);
        assert.ok(bud);
        assert.ok(bud.tmpl);
        bud.mkdirp = true;
        bud.path = `${tmpDir}/testing-codes/.code.json.bud`;
        coz.render(bud, (err) => {
            assert.ifError(err);
            done();
        });
    });


});