How to use getRuns method in Cypress

1'use strict';
2
3const Code = require('code');
4const Lab = require('lab');
5
6const FishFinder = require('..');
7
8const internals = {
9    defaults: {
10        dirPath: __dirname + '/tmp/runs',
11        workspace: 'workspace',
12        configFile: 'config.json'
13    }
14};
15
16const lab = exports.lab = Lab.script();
17const expect = Code.expect;
18const describe = lab.describe;
19const it = lab.it;
20
21describe('normal', () => {
22
23    it('createRun', (done) => {
24
25        const fishFinder = new FishFinder(internals.defaults);
26        const commands = ['uptime', 'date'];
27        const run = fishFinder.createRun(null, commands);
28        expect(run.id).to.exist();
29        done();
30    });
31
32    it('getRuns', (done) => {
33
34        const fishFinder = new FishFinder(internals.defaults);
35        const runs = fishFinder.getRuns();
36        expect(runs.length).to.equal(1);
37        done();
38    });
39
40    it('startRun', (done) => {
41
42        const fishFinder = new FishFinder(internals.defaults);
43        const runId = fishFinder.getRuns()[0].id;
44        fishFinder.startRun(runId, () => {
45
46            const runs = fishFinder.getRuns();
47            expect(runs[0].status).to.equal('started');
48            done();
49        });
50    });
51
52    it('getRun', (done) => {
53
54        const fishFinder = new FishFinder(internals.defaults);
55        const runId = fishFinder.getRuns()[0].id;
56        let run = fishFinder.getRun(runId);
57        const interval = setInterval(() => {
58
59            run = fishFinder.getRun(runId);
60            if (run.finishTime) {
61                clearInterval(interval);
62                //console.log(run);
63                expect(run.status).to.equal('succeeded');
64                expect(run.commands.length).to.equal(2);
65                done();
66            }
67        }, 1000);
68    });
69
70    it('createRun 2', (done) => {
71
72        const fishFinder = new FishFinder(internals.defaults);
73        const commands = ['uptime', 'date'];
74        const run = fishFinder.createRun(null, commands);
75        expect(run.id).to.exist();
76        done();
77    });
78
79    it('startRun 2', (done) => {
80
81        const fishFinder = new FishFinder(internals.defaults);
82        const runId = fishFinder.getRuns()[0].id;
83        fishFinder.startRun(runId, () => {
84
85            const runs = fishFinder.getRuns();
86            expect(runs[0].status).to.equal('started');
87            done();
88        });
89    });
90
91    it('getRuns 2', (done) => {
92
93        const fishFinder = new FishFinder(internals.defaults);
94        const runs = fishFinder.getRuns();
95        expect(runs.length).to.equal(2);
96        done();
97    });
98
99    it('getRun 2', (done) => {
100
101        const fishFinder = new FishFinder(internals.defaults);
102        const runId = fishFinder.getRuns()[0].id;
103        let run = fishFinder.getRun(runId);
104        const interval = setInterval(() => {
105
106            run = fishFinder.getRun(runId);
107            if (run.finishTime) {
108                clearInterval(interval);
109                //console.log(run);
110                expect(run.status).to.equal('succeeded');
111                expect(run.commands.length).to.equal(2);
112                done();
113            }
114        }, 1000);
115    });
116
117    it('deleteRun 2', (done) => {
118
119        const fishFinder = new FishFinder(internals.defaults);
120        const runId = fishFinder.getRuns()[0].id;
121        fishFinder.deleteRun(runId);
122        const runs = fishFinder.getRuns();
123        expect(runs.length).to.equal(1);
124        done();
125    });
126
127    it('deleteRun', (done) => {
128
129        const fishFinder = new FishFinder(internals.defaults);
130        const runId = fishFinder.getRuns()[0].id;
131        fishFinder.deleteRun(runId);
132        const runs = fishFinder.getRuns();
133        expect(runs.length).to.equal(0);
134        done();
135    });
136
137    it('deleteWorkspace', (done) => {
138
139        const fishFinder = new FishFinder(internals.defaults);
140        fishFinder.deleteWorkspace();
141        done();
142    });
143});
144

Source: normal.js

'use strict';

const Code = require('code');
const Lab = require('lab');

const FishFinder = require('..');

const internals = {
    defaults: {
        dirPath: __dirname + '/tmp/runs',
        workspace: 'workspace',
        configFile: 'config.json'
    }
};

const lab = exports.lab = Lab.script();
const expect = Code.expect;
const describe = lab.describe;
const it = lab.it;

describe('normal', () => {

    it('createRun', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const commands = ['uptime', 'date'];
        const run = fishFinder.createRun(null, commands);
        expect(run.id).to.exist();
        done();
    });

    it('getRuns', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runs = fishFinder.getRuns();
        expect(runs.length).to.equal(1);
        done();
    });

    it('startRun', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        fishFinder.startRun(runId, () => {

            const runs = fishFinder.getRuns();
            expect(runs[0].status).to.equal('started');
            done();
        });
    });

    it('getRun', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        let run = fishFinder.getRun(runId);
        const interval = setInterval(() => {

            run = fishFinder.getRun(runId);
            if (run.finishTime) {
                clearInterval(interval);
                //console.log(run);
                expect(run.status).to.equal('succeeded');
                expect(run.commands.length).to.equal(2);
                done();
            }
        }, 1000);
    });

    it('createRun 2', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const commands = ['uptime', 'date'];
        const run = fishFinder.createRun(null, commands);
        expect(run.id).to.exist();
        done();
    });

    it('startRun 2', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        fishFinder.startRun(runId, () => {

            const runs = fishFinder.getRuns();
            expect(runs[0].status).to.equal('started');
            done();
        });
    });

    it('getRuns 2', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runs = fishFinder.getRuns();
        expect(runs.length).to.equal(2);
        done();
    });

    it('getRun 2', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        let run = fishFinder.getRun(runId);
        const interval = setInterval(() => {

            run = fishFinder.getRun(runId);
            if (run.finishTime) {
                clearInterval(interval);
                //console.log(run);
                expect(run.status).to.equal('succeeded');
                expect(run.commands.length).to.equal(2);
                done();
            }
        }, 1000);
    });

    it('deleteRun 2', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        fishFinder.deleteRun(runId);
        const runs = fishFinder.getRuns();
        expect(runs.length).to.equal(1);
        done();
    });

    it('deleteRun', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        fishFinder.deleteRun(runId);
        const runs = fishFinder.getRuns();
        expect(runs.length).to.equal(0);
        done();
    });

    it('deleteWorkspace', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        fishFinder.deleteWorkspace();
        done();
    });
});

1'use strict';
2
3const Code = require('code');
4const Lab = require('lab');
5
6const FishFinder = require('..');
7
8const internals = {
9    defaults: {
10        dirPath: __dirname + '/tmp/runs',
11        workspace: 'workspace',
12        configFile: 'config.json'
13    }
14};
15const lab = exports.lab = Lab.script();
16const expect = Code.expect;
17const describe = lab.describe;
18const it = lab.it;
19
20describe('fixed', () => {
21
22    it('createRun invalid', (done) => {
23
24        const fishFinder = new FishFinder(internals.defaults);
25        const commands = ['invalid'];
26        const run = fishFinder.createRun(null, commands);
27        expect(run.id).to.exist();
28        done();
29    });
30
31    it('getRuns invalid', (done) => {
32
33        const fishFinder = new FishFinder(internals.defaults);
34        const runs = fishFinder.getRuns();
35        expect(runs.length).to.equal(1);
36        done();
37    });
38
39    it('startRun invalid', (done) => {
40
41        const fishFinder = new FishFinder(internals.defaults);
42        const runId = fishFinder.getRuns()[0].id;
43        fishFinder.startRun(runId, () => {
44
45            const runs = fishFinder.getRuns();
46            expect(runs[0].status).to.equal('started');
47            done();
48        });
49    });
50
51    it('getRun invalid', (done) => {
52
53        const fishFinder = new FishFinder(internals.defaults);
54        const runId = fishFinder.getRuns()[0].id;
55        let run = fishFinder.getRun(runId);
56        const interval = setInterval(() => {
57
58            run = fishFinder.getRun(runId);
59            if (run.finishTime) {
60                clearInterval(interval);
61                //console.log(run);
62                expect(run.status).to.equal('failed');
63                expect(run.commands.length).to.equal(1);
64                done();
65            }
66        }, 1000);
67    });
68
69    it('createRun valid', (done) => {
70
71        const fishFinder = new FishFinder(internals.defaults);
72        const commands = ['uptime'];
73        const run = fishFinder.createRun(null, commands);
74        expect(run.id).to.exist();
75        done();
76    });
77
78    it('getRuns valid', (done) => {
79
80        const fishFinder = new FishFinder(internals.defaults);
81        const runs = fishFinder.getRuns();
82        expect(runs.length).to.equal(2);
83        done();
84    });
85
86    it('startRun valid', (done) => {
87
88        const fishFinder = new FishFinder(internals.defaults);
89        const runId = fishFinder.getRuns()[0].id;
90        fishFinder.startRun(runId, () => {
91
92            const runs = fishFinder.getRuns();
93            expect(runs[0].status).to.equal('started');
94            done();
95        });
96    });
97
98    it('getRun valid', (done) => {
99
100        const fishFinder = new FishFinder(internals.defaults);
101        const runId = fishFinder.getRuns()[0].id;
102        let run = fishFinder.getRun(runId);
103        const interval = setInterval(() => {
104
105            run = fishFinder.getRun(runId);
106            if (run.finishTime) {
107                clearInterval(interval);
108                //console.log(run);
109                expect(run.status).to.equal('fixed');
110                expect(run.commands.length).to.equal(1);
111                done();
112            }
113        }, 1000);
114    });
115
116
117    it('deleteRuns', (done) => {
118
119        const fishFinder = new FishFinder(internals.defaults);
120        fishFinder.deleteRuns();
121        const runs = fishFinder.getRuns();
122        expect(runs.length).to.equal(0);
123        done();
124    });
125
126    it('deleteWorkspace', (done) => {
127
128        const fishFinder = new FishFinder(internals.defaults);
129        fishFinder.deleteWorkspace();
130        done();
131    });
132});
133

Source: fixed.js

'use strict';

const Code = require('code');
const Lab = require('lab');

const FishFinder = require('..');

const internals = {
    defaults: {
        dirPath: __dirname + '/tmp/runs',
        workspace: 'workspace',
        configFile: 'config.json'
    }
};
const lab = exports.lab = Lab.script();
const expect = Code.expect;
const describe = lab.describe;
const it = lab.it;

describe('fixed', () => {

    it('createRun invalid', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const commands = ['invalid'];
        const run = fishFinder.createRun(null, commands);
        expect(run.id).to.exist();
        done();
    });

    it('getRuns invalid', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runs = fishFinder.getRuns();
        expect(runs.length).to.equal(1);
        done();
    });

    it('startRun invalid', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        fishFinder.startRun(runId, () => {

            const runs = fishFinder.getRuns();
            expect(runs[0].status).to.equal('started');
            done();
        });
    });

    it('getRun invalid', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        let run = fishFinder.getRun(runId);
        const interval = setInterval(() => {

            run = fishFinder.getRun(runId);
            if (run.finishTime) {
                clearInterval(interval);
                //console.log(run);
                expect(run.status).to.equal('failed');
                expect(run.commands.length).to.equal(1);
                done();
            }
        }, 1000);
    });

    it('createRun valid', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const commands = ['uptime'];
        const run = fishFinder.createRun(null, commands);
        expect(run.id).to.exist();
        done();
    });

    it('getRuns valid', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runs = fishFinder.getRuns();
        expect(runs.length).to.equal(2);
        done();
    });

    it('startRun valid', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        fishFinder.startRun(runId, () => {

            const runs = fishFinder.getRuns();
            expect(runs[0].status).to.equal('started');
            done();
        });
    });

    it('getRun valid', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        let run = fishFinder.getRun(runId);
        const interval = setInterval(() => {

            run = fishFinder.getRun(runId);
            if (run.finishTime) {
                clearInterval(interval);
                //console.log(run);
                expect(run.status).to.equal('fixed');
                expect(run.commands.length).to.equal(1);
                done();
            }
        }, 1000);
    });


    it('deleteRuns', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        fishFinder.deleteRuns();
        const runs = fishFinder.getRuns();
        expect(runs.length).to.equal(0);
        done();
    });

    it('deleteWorkspace', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        fishFinder.deleteWorkspace();
        done();
    });
});

1'use strict';
2
3const Code = require('code');
4const Lab = require('lab');
5
6const FishFinder = require('..');
7
8const internals = {
9    defaults: {
10        dirPath: __dirname + '/tmp/runs',
11        workspace: 'workspace',
12        configFile: 'config.json'
13    }
14};
15
16const lab = exports.lab = Lab.script();
17const expect = Code.expect;
18const describe = lab.describe;
19const it = lab.it;
20
21describe('runOnCommit', () => {
22
23    it('createRun', (done) => {
24
25        const fishFinder = new FishFinder(internals.defaults);
26        const commands = ['uptime'];
27        const scm = {
28            type: 'git',
29            url: 'https://github.com/fishin/pail',
30            runOnCommit: true,
31            branch: 'master'
32        };
33        const run = fishFinder.createRun(scm, commands);
34        expect(run.id).to.exist();
35        done();
36    });
37
38    it('getRuns', (done) => {
39
40        const fishFinder = new FishFinder(internals.defaults);
41        const runs = fishFinder.getRuns();
42        expect(runs.length).to.equal(1);
43        done();
44    });
45
46    it('startRun', (done) => {
47
48        const fishFinder = new FishFinder(internals.defaults);
49        const runId = fishFinder.getRuns()[0].id;
50        fishFinder.startRun(runId, () => {
51
52            const runs = fishFinder.getRuns();
53            expect(runs[0].status).to.equal('started');
54            done();
55        });
56    });
57
58    it('getRun', (done) => {
59
60        const fishFinder = new FishFinder(internals.defaults);
61        const runId = fishFinder.getRuns()[0].id;
62        let run = fishFinder.getRun(runId);
63        const interval = setInterval(() => {
64
65            run = fishFinder.getRun(runId);
66            if (run.finishTime) {
67                //console.log(run);
68                expect(run.checkout).to.exist();
69                expect(run.checkout.status).to.equal('succeeded');
70                expect(run.commit).to.exist();
71                clearInterval(interval);
72                done();
73            }
74        }, 1000);
75    });
76
77    it('createRun 2', (done) => {
78
79        const fishFinder = new FishFinder(internals.defaults);
80        const commands = ['uptime'];
81        const scm = {
82            type: 'git',
83            url: 'https://github.com/fishin/pail',
84            runOnCommit: true,
85            branch: 'master'
86        };
87        const run = fishFinder.createRun(scm, commands);
88        expect(run.id).to.exist();
89        done();
90    });
91
92    it('startRun 2', (done) => {
93
94        const fishFinder = new FishFinder(internals.defaults);
95        const runId = fishFinder.getRuns()[1].id;
96        fishFinder.startRun(runId, () => {
97
98            const runs = fishFinder.getRuns();
99            expect(runs.length).to.equal(1);
100            done();
101        });
102    });
103
104    it('deleteRuns', (done) => {
105
106        const fishFinder = new FishFinder(internals.defaults);
107        fishFinder.deleteRuns();
108        const runs = fishFinder.getRuns();
109        expect(runs.length).to.equal(0);
110        done();
111    });
112
113    it('deleteWorkspace', (done) => {
114
115        const fishFinder = new FishFinder(internals.defaults);
116        fishFinder.deleteWorkspace();
117        done();
118    });
119});
120

Source: runOnCommit.js

'use strict';

const Code = require('code');
const Lab = require('lab');

const FishFinder = require('..');

const internals = {
    defaults: {
        dirPath: __dirname + '/tmp/runs',
        workspace: 'workspace',
        configFile: 'config.json'
    }
};

const lab = exports.lab = Lab.script();
const expect = Code.expect;
const describe = lab.describe;
const it = lab.it;

describe('runOnCommit', () => {

    it('createRun', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const commands = ['uptime'];
        const scm = {
            type: 'git',
            url: 'https://github.com/fishin/pail',
            runOnCommit: true,
            branch: 'master'
        };
        const run = fishFinder.createRun(scm, commands);
        expect(run.id).to.exist();
        done();
    });

    it('getRuns', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runs = fishFinder.getRuns();
        expect(runs.length).to.equal(1);
        done();
    });

    it('startRun', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        fishFinder.startRun(runId, () => {

            const runs = fishFinder.getRuns();
            expect(runs[0].status).to.equal('started');
            done();
        });
    });

    it('getRun', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[0].id;
        let run = fishFinder.getRun(runId);
        const interval = setInterval(() => {

            run = fishFinder.getRun(runId);
            if (run.finishTime) {
                //console.log(run);
                expect(run.checkout).to.exist();
                expect(run.checkout.status).to.equal('succeeded');
                expect(run.commit).to.exist();
                clearInterval(interval);
                done();
            }
        }, 1000);
    });

    it('createRun 2', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const commands = ['uptime'];
        const scm = {
            type: 'git',
            url: 'https://github.com/fishin/pail',
            runOnCommit: true,
            branch: 'master'
        };
        const run = fishFinder.createRun(scm, commands);
        expect(run.id).to.exist();
        done();
    });

    it('startRun 2', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        const runId = fishFinder.getRuns()[1].id;
        fishFinder.startRun(runId, () => {

            const runs = fishFinder.getRuns();
            expect(runs.length).to.equal(1);
            done();
        });
    });

    it('deleteRuns', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        fishFinder.deleteRuns();
        const runs = fishFinder.getRuns();
        expect(runs.length).to.equal(0);
        done();
    });

    it('deleteWorkspace', (done) => {

        const fishFinder = new FishFinder(internals.defaults);
        fishFinder.deleteWorkspace();
        done();
    });
});