From bfa9bdda943507df6c40a871606daa64ec1d9136 Mon Sep 17 00:00:00 2001 From: DavertMik Date: Sat, 4 Jan 2025 04:29:18 +0200 Subject: [PATCH] updated tests --- test/unit/assert/empty_test.js | 46 +-- test/unit/assert/equal_test.js | 50 +-- test/unit/assert/include_test.js | 50 +-- test/unit/bdd_test.js | 452 ++++++++++----------- test/unit/data/dataTableArgument_test.js | 76 ++-- test/unit/data/table_test.js | 134 +++--- test/unit/data/ui_test.js | 130 +++--- test/unit/helper/FileSystem_test.js | 72 ++-- test/unit/helper/element_not_found_test.js | 38 +- test/unit/plugin/customLocator_test.js | 92 ++--- test/unit/plugin/eachElement_test.js | 58 +-- test/unit/plugin/retryFailedStep_test.js | 345 +++++++++------- test/unit/plugin/retryto_test.js | 56 +-- test/unit/plugin/screenshotOnFail_test.js | 112 ++--- test/unit/plugin/subtitles_test.js | 207 +++++----- test/unit/plugin/tryTo_test.js | 38 +- test/unit/scenario_test.js | 128 +++--- test/unit/ui_test.js | 282 ++++++------- 18 files changed, 1231 insertions(+), 1135 deletions(-) diff --git a/test/unit/assert/empty_test.js b/test/unit/assert/empty_test.js index 299d37392..19d989de0 100644 --- a/test/unit/assert/empty_test.js +++ b/test/unit/assert/empty_test.js @@ -1,37 +1,37 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); + expect = chai.expect +}) -const { Assertion } = require('../../../lib/assert/empty'); -const AssertionError = require('../../../lib/assert/error'); +const { Assertion } = require('../../../lib/assert/empty') +const AssertionError = require('../../../lib/assert/error') -let empty; +let empty describe('empty assertion', () => { beforeEach(() => { - empty = new Assertion({ subject: 'web page' }); - }); + empty = new Assertion({ subject: 'web page' }) + }) it('should check for something to be empty', () => { - empty.assert(null); - expect(() => empty.negate(null)).to.throw(AssertionError); - }); + empty.assert(null) + expect(() => empty.negate(null)).to.throw(AssertionError) + }) it('should check for something not to be empty', () => { - empty.negate('something'); - expect(() => empty.assert('something')).to.throw(AssertionError); - }); + empty.negate('something') + expect(() => empty.assert('something')).to.throw(AssertionError) + }) it('should provide nice assert error message', () => { - empty.params.value = '/nothing'; - const err = empty.getFailedAssertion(); - expect(err.inspect()).to.equal("expected web page '/nothing' to be empty"); - }); + empty.params.value = '/nothing' + const err = empty.getFailedAssertion() + expect(err.inspect()).to.equal("expected web page '/nothing' to be empty") + }) it('should provide nice negate error message', () => { - empty.params.value = '/nothing'; - const err = empty.getFailedNegation(); - expect(err.inspect()).to.equal("expected web page '/nothing' not to be empty"); - }); -}); + empty.params.value = '/nothing' + const err = empty.getFailedNegation() + expect(err.inspect()).to.equal("expected web page '/nothing' not to be empty") + }) +}) diff --git a/test/unit/assert/equal_test.js b/test/unit/assert/equal_test.js index 232a715b2..bfe513721 100644 --- a/test/unit/assert/equal_test.js +++ b/test/unit/assert/equal_test.js @@ -1,39 +1,39 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); + expect = chai.expect +}) -const { Assertion } = require('../../../lib/assert/equal'); -const AssertionError = require('../../../lib/assert/error'); +const { Assertion } = require('../../../lib/assert/equal') +const AssertionError = require('../../../lib/assert/error') -let equal; +let equal describe('equal assertion', () => { beforeEach(() => { - equal = new Assertion({ jar: 'contents of webpage' }); - }); + equal = new Assertion({ jar: 'contents of webpage' }) + }) it('should check for equality', () => { - equal.assert('hello', 'hello'); - expect(() => equal.negate('hello', 'hello')).to.throw(AssertionError); - }); + equal.assert('hello', 'hello') + expect(() => equal.negate('hello', 'hello')).to.throw(AssertionError) + }) it('should check for something not to be equal', () => { - equal.negate('hello', 'hi'); - expect(() => equal.assert('hello', 'hi')).to.throw(AssertionError); - }); + equal.negate('hello', 'hi') + expect(() => equal.assert('hello', 'hi')).to.throw(AssertionError) + }) it('should provide nice assert error message', () => { - equal.params.expected = 'hello'; - equal.params.actual = 'hi'; - const err = equal.getFailedAssertion(); - expect(err.inspect()).to.equal('expected contents of webpage "hello" to equal "hi"'); - }); + equal.params.expected = 'hello' + equal.params.actual = 'hi' + const err = equal.getFailedAssertion() + expect(err.inspect()).to.equal('expected contents of webpage "hello" to equal "hi"') + }) it('should provide nice negate error message', () => { - equal.params.expected = 'hello'; - equal.params.actual = 'hello'; - const err = equal.getFailedNegation(); - expect(err.inspect()).to.equal('expected contents of webpage "hello" not to equal "hello"'); - }); -}); + equal.params.expected = 'hello' + equal.params.actual = 'hello' + const err = equal.getFailedNegation() + expect(err.inspect()).to.equal('expected contents of webpage "hello" not to equal "hello"') + }) +}) diff --git a/test/unit/assert/include_test.js b/test/unit/assert/include_test.js index 7bbe78661..6a60372f2 100644 --- a/test/unit/assert/include_test.js +++ b/test/unit/assert/include_test.js @@ -1,39 +1,39 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); + expect = chai.expect +}) -const Assertion = require('../../../lib/assert/include').Assertion; -const AssertionError = require('../../../lib/assert/error'); +const Assertion = require('../../../lib/assert/include').Assertion +const AssertionError = require('../../../lib/assert/error') -let equal; +let equal describe('equal assertion', () => { beforeEach(() => { - equal = new Assertion({ jar: 'contents of webpage' }); - }); + equal = new Assertion({ jar: 'contents of webpage' }) + }) it('should check for inclusion', () => { - equal.assert('h', 'hello'); - expect(() => equal.negate('h', 'hello')).to.throw(AssertionError); - }); + equal.assert('h', 'hello') + expect(() => equal.negate('h', 'hello')).to.throw(AssertionError) + }) it('should check !include', () => { - equal.negate('x', 'hello'); - expect(() => equal.assert('x', 'hello')).to.throw(AssertionError); - }); + equal.negate('x', 'hello') + expect(() => equal.assert('x', 'hello')).to.throw(AssertionError) + }) it('should provide nice assert error message', () => { - equal.params.needle = 'hello'; - equal.params.haystack = 'x'; - const err = equal.getFailedAssertion(); - expect(err.inspect()).to.equal('expected contents of webpage to include "hello"'); - }); + equal.params.needle = 'hello' + equal.params.haystack = 'x' + const err = equal.getFailedAssertion() + expect(err.inspect()).to.equal('expected contents of webpage to include "hello"') + }) it('should provide nice negate error message', () => { - equal.params.needle = 'hello'; - equal.params.haystack = 'h'; - const err = equal.getFailedNegation(); - expect(err.inspect()).to.equal('expected contents of webpage not to include "hello"'); - }); -}); + equal.params.needle = 'hello' + equal.params.haystack = 'h' + const err = equal.getFailedNegation() + expect(err.inspect()).to.equal('expected contents of webpage not to include "hello"') + }) +}) diff --git a/test/unit/bdd_test.js b/test/unit/bdd_test.js index a2249c633..f41c4fc79 100644 --- a/test/unit/bdd_test.js +++ b/test/unit/bdd_test.js @@ -1,25 +1,25 @@ -const Gherkin = require('@cucumber/gherkin'); -const Messages = require('@cucumber/messages'); +const Gherkin = require('@cucumber/gherkin') +const Messages = require('@cucumber/messages') -const chai = require('chai'); +const chai = require('chai') -const expect = chai.expect; +const expect = chai.expect -const uuidFn = Messages.IdGenerator.uuid(); -const builder = new Gherkin.AstBuilder(uuidFn); -const matcher = new Gherkin.GherkinClassicTokenMatcher(); +const uuidFn = Messages.IdGenerator.uuid() +const builder = new Gherkin.AstBuilder(uuidFn) +const matcher = new Gherkin.GherkinClassicTokenMatcher() -const Config = require('../../lib/config'); -const { Given, When, And, Then, matchStep, clearSteps, defineParameterType } = require('../../lib/mocha/bdd'); -const run = require('../../lib/mocha/gherkin'); -const recorder = require('../../lib/recorder'); -const container = require('../../lib/container'); -const actor = require('../../lib/actor'); -const event = require('../../lib/event'); +const Config = require('../../lib/config') +const { Given, When, And, Then, matchStep, clearSteps, defineParameterType } = require('../../lib/mocha/bdd') +const run = require('../../lib/mocha/gherkin') +const recorder = require('../../lib/recorder') +const container = require('../../lib/container') +const actor = require('../../lib/actor') +const event = require('../../lib/event') class Color { constructor(name) { - this.name = name; + this.name = name } } @@ -34,186 +34,186 @@ const text = ` Given I have product with 600 price And I have product with 1000 price When I go to checkout process -`; +` const checkTestForErrors = test => { return new Promise((resolve, reject) => { test.fn(err => { if (err) { - return reject(err); + return reject(err) } - resolve(); - }); - }); -}; + resolve() + }) + }) +} describe('BDD', () => { beforeEach(() => { - clearSteps(); - recorder.start(); - container.create({}); - Config.reset(); - }); + clearSteps() + recorder.start() + container.create({}) + Config.reset() + }) afterEach(() => { - container.clear(); - recorder.stop(); - }); + container.clear() + recorder.stop() + }) it('should parse gherkin input', () => { - const parser = new Gherkin.Parser(builder, matcher); - parser.stopAtFirstError = false; - const ast = parser.parse(text); + const parser = new Gherkin.Parser(builder, matcher) + parser.stopAtFirstError = false + const ast = parser.parse(text) // console.log('Feature', ast.feature); // console.log('Scenario', ast.feature.children); // console.log('Steps', ast.feature.children[0].steps[0]); - expect(ast.feature).is.ok; - expect(ast.feature.children).is.ok; - expect(ast.feature.children[0].scenario.steps).is.ok; - }); + expect(ast.feature).is.ok + expect(ast.feature.children).is.ok + expect(ast.feature.children[0].scenario.steps).is.ok + }) it('should load step definitions', () => { - Given('I am a bird', () => 1); - When('I fly over ocean', () => 2); - And(/^I fly over land$/i, () => 3); - Then(/I see (.*?)/, () => 4); - expect(1).is.equal(matchStep('I am a bird')()); - expect(3).is.equal(matchStep('I Fly oVer Land')()); - expect(4).is.equal(matchStep('I see ocean')()); - expect(4).is.equal(matchStep('I see world')()); - }); + Given('I am a bird', () => 1) + When('I fly over ocean', () => 2) + And(/^I fly over land$/i, () => 3) + Then(/I see (.*?)/, () => 4) + expect(1).is.equal(matchStep('I am a bird')()) + expect(3).is.equal(matchStep('I Fly oVer Land')()) + expect(4).is.equal(matchStep('I see ocean')()) + expect(4).is.equal(matchStep('I see world')()) + }) it('should fail on duplicate step definitions with option', () => { Config.append({ gherkin: { avoidDuplicateSteps: true, }, - }); + }) - let error = null; + let error = null try { - Given('I am a bird', () => 1); - Then('I am a bird', () => 1); + Given('I am a bird', () => 1) + Then('I am a bird', () => 1) } catch (err) { - error = err; + error = err } finally { - expect(!!error).is.true; + expect(!!error).is.true } - }); + }) it('should contain tags', async () => { - let sum = 0; - Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))); - When('I go to checkout process', () => (sum += 10)); - const suite = await run(text); - suite.tests[0].fn(() => {}); - expect(suite.tests[0].tags).is.ok; - expect('@super').is.equal(suite.tests[0].tags[0]); - }); + let sum = 0 + Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))) + When('I go to checkout process', () => (sum += 10)) + const suite = await run(text) + suite.tests[0].fn(() => {}) + expect(suite.tests[0].tags).is.ok + expect('@super').is.equal(suite.tests[0].tags[0]) + }) it('should load step definitions', done => { - let sum = 0; - Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))); - When('I go to checkout process', () => (sum += 10)); - const suite = run(text); - expect('checkout process').is.equal(suite.title); + let sum = 0 + Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))) + When('I go to checkout process', () => (sum += 10)) + const suite = run(text) + expect('checkout process').is.equal(suite.title) suite.tests[0].fn(() => { - expect(suite.tests[0].steps).is.ok; - expect(1610).is.equal(sum); - done(); - }); - }); + expect(suite.tests[0].steps).is.ok + expect(1610).is.equal(sum) + done() + }) + }) it('should allow failed steps', async () => { - let sum = 0; - Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))); - When('I go to checkout process', () => expect(false).is.true); - const suite = run(text); - expect('checkout process').is.equal(suite.title); + let sum = 0 + Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))) + When('I go to checkout process', () => expect(false).is.true) + const suite = run(text) + expect('checkout process').is.equal(suite.title) try { - await checkTestForErrors(suite.tests[0]); - return Promise.reject(new Error('Test should have thrown with failed step, but did not')); + await checkTestForErrors(suite.tests[0]) + return Promise.reject(new Error('Test should have thrown with failed step, but did not')) } catch (err) { - const errored = !!err; - expect(errored).is.true; + const errored = !!err + expect(errored).is.true } - }); + }) it('handles errors in steps', async () => { - let sum = 0; - Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))); + let sum = 0 + Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))) When('I go to checkout process', () => { - throw new Error('errored step'); - }); - const suite = run(text); - expect('checkout process').is.equal(suite.title); + throw new Error('errored step') + }) + const suite = run(text) + expect('checkout process').is.equal(suite.title) try { - await checkTestForErrors(suite.tests[0]); - return Promise.reject(new Error('Test should have thrown with error, but did not')); + await checkTestForErrors(suite.tests[0]) + return Promise.reject(new Error('Test should have thrown with error, but did not')) } catch (err) { - const errored = !!err; - expect(errored).is.true; + const errored = !!err + expect(errored).is.true } - }); + }) it('handles async errors in steps', async () => { - let sum = 0; - Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))); - When('I go to checkout process', () => Promise.reject(new Error('step failed'))); - const suite = run(text); - expect('checkout process').is.equal(suite.title); + let sum = 0 + Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))) + When('I go to checkout process', () => Promise.reject(new Error('step failed'))) + const suite = run(text) + expect('checkout process').is.equal(suite.title) try { - await checkTestForErrors(suite.tests[0]); - return Promise.reject(new Error('Test should have thrown with error, but did not')); + await checkTestForErrors(suite.tests[0]) + return Promise.reject(new Error('Test should have thrown with error, but did not')) } catch (err) { - const errored = !!err; - expect(errored).is.true; + const errored = !!err + expect(errored).is.true } - }); + }) it('should work with async functions', done => { - let sum = 0; - Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))); + let sum = 0 + Given(/I have product with (\d+) price/, param => (sum += parseInt(param, 10))) When('I go to checkout process', async () => { return new Promise(checkoutDone => { - sum += 10; - setTimeout(checkoutDone, 0); - }); - }); - const suite = run(text); - expect('checkout process').is.equal(suite.title); + sum += 10 + setTimeout(checkoutDone, 0) + }) + }) + const suite = run(text) + expect('checkout process').is.equal(suite.title) suite.tests[0].fn(() => { - expect(suite.tests[0].steps).is.ok; - expect(1610).is.equal(sum); - done(); - }); - }); + expect(suite.tests[0].steps).is.ok + expect(1610).is.equal(sum) + done() + }) + }) it('should execute scenarios step-by-step ', async () => { - recorder.start(); - printed = []; + recorder.start() + printed = [] container.append({ helpers: { simple: { do(...args) { - return Promise.resolve().then(() => printed.push(args.join(' '))); + return Promise.resolve().then(() => printed.push(args.join(' '))) }, }, }, - }); - I = actor(); - let sum = 0; + }) + I = actor() + let sum = 0 Given(/I have product with (\d+) price/, price => { - I.do('add', (sum += parseInt(price, 10))); - }); + I.do('add', (sum += parseInt(price, 10))) + }) When('I go to checkout process', () => { - I.do('add finish checkout'); - }); - const suite = run(text); + I.do('add finish checkout') + }) + const suite = run(text) suite.tests[0].fn(() => { recorder.promise().then(() => { - printed.should.include.members(['add 600', 'add 1600', 'add finish checkout']); - const lines = recorder.scheduled().split('\n'); + printed.should.include.members(['add 600', 'add 1600', 'add finish checkout']) + const lines = recorder.scheduled().split('\n') lines.should.include.members([ 'do: "add", 600', 'step passed', @@ -226,17 +226,17 @@ describe('BDD', () => { 'return result', 'fire test.passed', 'finish test', - ]); - done(); - }); - }); - }); + ]) + done() + }) + }) + }) it('should match step with params', () => { - Given('I am a {word}', param => param); - const fn = matchStep('I am a bird'); - expect('bird').is.equal(fn.params[0]); - }); + Given('I am a {word}', param => param) + const fn = matchStep('I am a bird') + expect('bird').is.equal(fn.params[0]) + }) it('should produce step events', done => { const text = ` @@ -244,34 +244,34 @@ describe('BDD', () => { Scenario: Then I emit step events - `; - Then('I emit step events', () => {}); - let listeners = 0; - event.dispatcher.addListener(event.bddStep.before, () => listeners++); - event.dispatcher.addListener(event.bddStep.after, () => listeners++); + ` + Then('I emit step events', () => {}) + let listeners = 0 + event.dispatcher.addListener(event.bddStep.before, () => listeners++) + event.dispatcher.addListener(event.bddStep.after, () => listeners++) - const suite = run(text); + const suite = run(text) suite.tests[0].fn(() => { - listeners.should.eql(2); - done(); - }); - }); + listeners.should.eql(2) + done() + }) + }) it('should use shortened form for step definitions', () => { - let fn; - Given('I am a {word}', params => params[0]); - When('I have {int} wings and {int} eyes', params => params[0] + params[1]); - Given('I have ${int} in my pocket', params => params[0]); // eslint-disable-line no-template-curly-in-string - Given('I have also ${float} in my pocket', params => params[0]); // eslint-disable-line no-template-curly-in-string - fn = matchStep('I am a bird'); - expect('bird').is.equal(fn(fn.params)); - fn = matchStep('I have 2 wings and 2 eyes'); - expect(4).is.equal(fn(fn.params)); - fn = matchStep('I have $500 in my pocket'); - expect(500).is.equal(fn(fn.params)); - fn = matchStep('I have also $500.30 in my pocket'); - expect(500.3).is.equal(fn(fn.params)); - }); + let fn + Given('I am a {word}', params => params[0]) + When('I have {int} wings and {int} eyes', params => params[0] + params[1]) + Given('I have ${int} in my pocket', params => params[0]) // eslint-disable-line no-template-curly-in-string + Given('I have also ${float} in my pocket', params => params[0]) // eslint-disable-line no-template-curly-in-string + fn = matchStep('I am a bird') + expect('bird').is.equal(fn(fn.params)) + fn = matchStep('I have 2 wings and 2 eyes') + expect(4).is.equal(fn(fn.params)) + fn = matchStep('I have $500 in my pocket') + expect(500).is.equal(fn(fn.params)) + fn = matchStep('I have also $500.30 in my pocket') + expect(500.3).is.equal(fn(fn.params)) + }) it('should attach before hook for Background', finish => { const text = ` @@ -282,22 +282,22 @@ describe('BDD', () => { Scenario: Then I am shopping - `; - let sum = 0; + ` + let sum = 0 function incrementSum() { - sum++; + sum++ } - Given('I am logged in as customer', incrementSum); - Then('I am shopping', incrementSum); - const suite = run(text); - const done = () => {}; + Given('I am logged in as customer', incrementSum) + Then('I am shopping', incrementSum) + const suite = run(text) + const done = () => {} - suite._beforeEach.forEach(hook => hook.run(done)); + suite._beforeEach.forEach(hook => hook.run(done)) suite.tests[0].fn(() => { - expect(sum).is.equal(2); - finish(); - }); - }); + expect(sum).is.equal(2) + finish() + }) + }) it('should execute scenario outlines', done => { const text = ` @@ -319,37 +319,37 @@ describe('BDD', () => { Examples: | price | total | | 20 | 18 | - `; - let cart = 0; - let sum = 0; + ` + let cart = 0 + let sum = 0 Given('I have product with price {int}$ in my cart', price => { - cart = price; - }); + cart = price + }) Given('discount is {int} %', discount => { - cart -= (cart * discount) / 100; - }); + cart -= (cart * discount) / 100 + }) Then('I should see price is {string} $', total => { - sum = parseInt(total, 10); - }); + sum = parseInt(total, 10) + }) - const suite = run(text); + const suite = run(text) - expect(suite.tests[0].tags).is.ok; - expect(['@awesome', '@cool', '@super']).is.deep.equal(suite.tests[0].tags); - expect(['@awesome', '@cool', '@super', '@exampleTag1', '@exampleTag2']).is.deep.equal(suite.tests[1].tags); + expect(suite.tests[0].tags).is.ok + expect(['@awesome', '@cool', '@super']).is.deep.equal(suite.tests[0].tags) + expect(['@awesome', '@cool', '@super', '@exampleTag1', '@exampleTag2']).is.deep.equal(suite.tests[1].tags) - expect(2).is.equal(suite.tests.length); + expect(2).is.equal(suite.tests.length) suite.tests[0].fn(() => { - expect(9).is.equal(cart); - expect(9).is.equal(sum); + expect(9).is.equal(cart) + expect(9).is.equal(sum) suite.tests[1].fn(() => { - expect(18).is.equal(cart); - expect(18).is.equal(sum); - done(); - }); - }); - }); + expect(18).is.equal(cart) + expect(18).is.equal(sum) + done() + }) + }) + }) it('should provide a parsed DataTable', done => { const text = ` @@ -366,59 +366,59 @@ describe('BDD', () => { | label | price | | beer | 9 | | cookies | 12 | - `; + ` - let givenParsedRows; - let thenParsedRows; + let givenParsedRows + let thenParsedRows Given('I have the following products :', products => { - expect(products.rows.length).to.equal(3); - givenParsedRows = products.parse(); - }); + expect(products.rows.length).to.equal(3) + givenParsedRows = products.parse() + }) Then('I should see the following products :', products => { - expect(products.rows.length).to.equal(3); - thenParsedRows = products.parse(); - }); + expect(products.rows.length).to.equal(3) + thenParsedRows = products.parse() + }) - const suite = run(text); + const suite = run(text) const expectedParsedDataTable = [ ['label', 'price'], ['beer', '9'], ['cookies', '12'], - ]; + ] suite.tests[0].fn(() => { - expect(givenParsedRows.rawData).is.deep.equal(expectedParsedDataTable); - expect(thenParsedRows.rawData).is.deep.equal(expectedParsedDataTable); - done(); - }); - }); + expect(givenParsedRows.rawData).is.deep.equal(expectedParsedDataTable) + expect(thenParsedRows.rawData).is.deep.equal(expectedParsedDataTable) + done() + }) + }) it('should match step with custom parameter type', done => { const colorType = { name: 'color', regexp: /red|blue|yellow/, transformer: s => new Color(s), - }; - defineParameterType(colorType); - Given('I have a {color} label', color => color); - const fn = matchStep('I have a red label'); - expect('red').is.equal(fn.params[0].name); - done(); - }); + } + defineParameterType(colorType) + Given('I have a {color} label', color => color) + const fn = matchStep('I have a red label') + expect('red').is.equal(fn.params[0].name) + done() + }) it('should match step with async custom parameter type transformation', async () => { const colorType = { name: 'async_color', regexp: /red|blue|yellow/, transformer: async s => new Color(s), - }; - defineParameterType(colorType); - Given('I have a {async_color} label', color => color); - const fn = matchStep('I have a blue label'); - const color = await fn.params[0]; - expect('blue').is.equal(color.name); - await Promise.resolve(); - }); -}); + } + defineParameterType(colorType) + Given('I have a {async_color} label', color => color) + const fn = matchStep('I have a blue label') + const color = await fn.params[0] + expect('blue').is.equal(color.name) + await Promise.resolve() + }) +}) diff --git a/test/unit/data/dataTableArgument_test.js b/test/unit/data/dataTableArgument_test.js index b62c187bd..999186ade 100644 --- a/test/unit/data/dataTableArgument_test.js +++ b/test/unit/data/dataTableArgument_test.js @@ -1,9 +1,9 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); -const { it } = require('mocha'); -const DataTableArgument = require('../../../lib/data/dataTableArgument'); + expect = chai.expect +}) +const { it } = require('mocha') +const DataTableArgument = require('../../../lib/data/dataTableArgument') describe('DataTableArgument', () => { const gherkinDataTable = { @@ -25,7 +25,7 @@ describe('DataTableArgument', () => { ], }, ], - }; + } const gherkinDataTableWithHeader = { rows: [ @@ -46,7 +46,7 @@ describe('DataTableArgument', () => { ], }, ], - }; + } const gherkinDataTableWithColumnHeader = { rows: [ @@ -67,41 +67,47 @@ describe('DataTableArgument', () => { ], }, ], - }; + } it('should return a 2D array containing each row', () => { - const dta = new DataTableArgument(gherkinDataTable); - const raw = dta.raw(); - const expectedRaw = [['John', 'Doe'], ['Chuck', 'Norris']]; - expect(raw).to.deep.equal(expectedRaw); - }); + const dta = new DataTableArgument(gherkinDataTable) + const raw = dta.raw() + const expectedRaw = [ + ['John', 'Doe'], + ['Chuck', 'Norris'], + ] + expect(raw).to.deep.equal(expectedRaw) + }) it('should return a 2D array containing each row without the header (first one)', () => { - const dta = new DataTableArgument(gherkinDataTableWithHeader); - const rows = dta.rows(); - const expectedRows = [['Chuck', 'Norris']]; - expect(rows).to.deep.equal(expectedRows); - }); + const dta = new DataTableArgument(gherkinDataTableWithHeader) + const rows = dta.rows() + const expectedRows = [['Chuck', 'Norris']] + expect(rows).to.deep.equal(expectedRows) + }) it('should return an of object where properties is the header', () => { - const dta = new DataTableArgument(gherkinDataTableWithHeader); - const rows = dta.hashes(); - const expectedRows = [{ firstName: 'Chuck', lastName: 'Norris' }]; - expect(rows).to.deep.equal(expectedRows); - }); + const dta = new DataTableArgument(gherkinDataTableWithHeader) + const rows = dta.hashes() + const expectedRows = [{ firstName: 'Chuck', lastName: 'Norris' }] + expect(rows).to.deep.equal(expectedRows) + }) it('transpose should transpose the gherkin data table', () => { - const dta = new DataTableArgument(gherkinDataTable); - dta.transpose(); - const raw = dta.raw(); - const expectedRaw = [['John', 'Chuck'], ['Doe', 'Norris']]; - expect(raw).to.deep.equal(expectedRaw); - }); + const dta = new DataTableArgument(gherkinDataTable) + dta.transpose() + const raw = dta.raw() + const expectedRaw = [ + ['John', 'Chuck'], + ['Doe', 'Norris'], + ] + expect(raw).to.deep.equal(expectedRaw) + }) it('rowsHash returns an object where the keys are the first column', () => { - const dta = new DataTableArgument(gherkinDataTableWithColumnHeader); - const rawHash = dta.rowsHash(); - const expectedRaw = { firstName: 'Chuck', lastName: 'Norris' }; - expect(rawHash).to.deep.equal(expectedRaw); - }); -}); + const dta = new DataTableArgument(gherkinDataTableWithColumnHeader) + const rawHash = dta.rowsHash() + const expectedRaw = { firstName: 'Chuck', lastName: 'Norris' } + expect(rawHash).to.deep.equal(expectedRaw) + }) +}) diff --git a/test/unit/data/table_test.js b/test/unit/data/table_test.js index ae209f56b..23aa15903 100644 --- a/test/unit/data/table_test.js +++ b/test/unit/data/table_test.js @@ -1,91 +1,97 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); + expect = chai.expect +}) -const DataTable = require('../../../lib/data/table'); +const DataTable = require('../../../lib/data/table') describe('DataTable', () => { it('should take an array for creation', () => { - const data = ['login', 'password']; - const dataTable = new DataTable(data); - expect(dataTable.array).to.deep.equal(data); - expect(dataTable.rows).to.deep.equal([]); - }); + const data = ['login', 'password'] + const dataTable = new DataTable(data) + expect(dataTable.array).to.deep.equal(data) + expect(dataTable.rows).to.deep.equal([]) + }) it('should allow arrays to be added', () => { - const data = ['login', 'password']; - const dataTable = new DataTable(data); - dataTable.add(['jon', 'snow']); + const data = ['login', 'password'] + const dataTable = new DataTable(data) + dataTable.add(['jon', 'snow']) const expected = { login: 'jon', password: 'snow', - }; - expect(JSON.stringify(dataTable.rows[0].data)).to.equal(JSON.stringify(expected)); - }); + } + expect(JSON.stringify(dataTable.rows[0].data)).to.equal(JSON.stringify(expected)) + }) it('should not allow an empty array to be added', () => { - const data = ['login', 'password']; - const dataTable = new DataTable(data); - expect(() => dataTable.add([])).to.throw(); - }); + const data = ['login', 'password'] + const dataTable = new DataTable(data) + expect(() => dataTable.add([])).to.throw() + }) it('should not allow an array with more slots than the original to be added', () => { - const data = ['login', 'password']; - const dataTable = new DataTable(data); - expect(() => dataTable.add(['Henrietta'])).to.throw(); - }); + const data = ['login', 'password'] + const dataTable = new DataTable(data) + expect(() => dataTable.add(['Henrietta'])).to.throw() + }) it('should not allow an array with less slots than the original to be added', () => { - const data = ['login', 'password']; - const dataTable = new DataTable(data); - expect(() => dataTable.add(['Acid', 'Jazz', 'Singer'])).to.throw(); - }); + const data = ['login', 'password'] + const dataTable = new DataTable(data) + expect(() => dataTable.add(['Acid', 'Jazz', 'Singer'])).to.throw() + }) it('should filter an array', () => { - const data = ['login', 'password']; - const dataTable = new DataTable(data); - dataTable.add(['jon', 'snow']); - dataTable.add(['tyrion', 'lannister']); - dataTable.add(['jaime', 'lannister']); + const data = ['login', 'password'] + const dataTable = new DataTable(data) + dataTable.add(['jon', 'snow']) + dataTable.add(['tyrion', 'lannister']) + dataTable.add(['jaime', 'lannister']) - const expected = [{ - skip: false, - data: { - login: 'tyrion', - password: 'lannister', + const expected = [ + { + skip: false, + data: { + login: 'tyrion', + password: 'lannister', + }, }, - }, { - skip: false, - data: { - login: 'jaime', - password: 'lannister', + { + skip: false, + data: { + login: 'jaime', + password: 'lannister', + }, }, - }]; - expect(JSON.stringify(dataTable.filter(row => row.password === 'lannister'))).to.equal(JSON.stringify(expected)); - }); + ] + expect(JSON.stringify(dataTable.filter(row => row.password === 'lannister'))).to.equal(JSON.stringify(expected)) + }) it('should filter an array with skips', () => { - const data = ['login', 'password']; - const dataTable = new DataTable(data); - dataTable.add(['jon', 'snow']); - dataTable.xadd(['tyrion', 'lannister']); - dataTable.add(['jaime', 'lannister']); + const data = ['login', 'password'] + const dataTable = new DataTable(data) + dataTable.add(['jon', 'snow']) + dataTable.xadd(['tyrion', 'lannister']) + dataTable.add(['jaime', 'lannister']) - const expected = [{ - skip: true, - data: { - login: 'tyrion', - password: 'lannister', + const expected = [ + { + skip: true, + data: { + login: 'tyrion', + password: 'lannister', + }, }, - }, { - skip: false, - data: { - login: 'jaime', - password: 'lannister', + { + skip: false, + data: { + login: 'jaime', + password: 'lannister', + }, }, - }]; - expect(JSON.stringify(dataTable.filter(row => row.password === 'lannister'))).to.equal(JSON.stringify(expected)); - }); -}); + ] + expect(JSON.stringify(dataTable.filter(row => row.password === 'lannister'))).to.equal(JSON.stringify(expected)) + }) +}) diff --git a/test/unit/data/ui_test.js b/test/unit/data/ui_test.js index 0190e74a2..6292d08c4 100644 --- a/test/unit/data/ui_test.js +++ b/test/unit/data/ui_test.js @@ -1,105 +1,105 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); -const Mocha = require('mocha/lib/mocha'); -const Suite = require('mocha/lib/suite'); + expect = chai.expect +}) +const Mocha = require('mocha/lib/mocha') +const Suite = require('mocha/lib/suite') -const makeUI = require('../../../lib/mocha/ui'); -const addData = require('../../../lib/data/context'); -const DataTable = require('../../../lib/data/table'); -const Secret = require('../../../lib/secret'); +const makeUI = require('../../../lib/mocha/ui') +const addData = require('../../../lib/data/context') +const DataTable = require('../../../lib/data/table') +const Secret = require('../../../lib/secret') describe('ui', () => { - let suite; - let context; - let dataTable; + let suite + let context + let dataTable beforeEach(() => { - context = {}; - suite = new Suite('empty', null); - makeUI(suite); - suite.emit('pre-require', context, {}, new Mocha()); - addData(context); - - dataTable = new DataTable(['username', 'password']); - dataTable.add(['jon', 'snow']); - dataTable.xadd(['tyrion', 'lannister']); - dataTable.add(['jaime', 'lannister']); - dataTable.add(['Username', new Secret('theSecretPassword')]); - }); + context = {} + suite = new Suite('empty', null) + makeUI(suite) + suite.emit('pre-require', context, {}, new Mocha()) + addData(context) + + dataTable = new DataTable(['username', 'password']) + dataTable.add(['jon', 'snow']) + dataTable.xadd(['tyrion', 'lannister']) + dataTable.add(['jaime', 'lannister']) + dataTable.add(['Username', new Secret('theSecretPassword')]) + }) describe('Data', () => { it('can add a tag to all scenarios', () => { - const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}); + const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}) - dataScenarioConfig.tag('@user'); + dataScenarioConfig.tag('@user') dataScenarioConfig.scenarios.forEach(scenario => { - expect(scenario.test.tags).to.include('@user'); - }); - }); + expect(scenario.test.tags).to.include('@user') + }) + }) it('can add a timeout to all scenarios', () => { - const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}); + const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}) - dataScenarioConfig.timeout(3); + dataScenarioConfig.timeout(3) - dataScenarioConfig.scenarios.forEach(scenario => expect(3).to.equal(scenario.test._timeout)); - }); + dataScenarioConfig.scenarios.forEach(scenario => expect(3).to.equal(scenario.test._timeout)) + }) it('can add retries to all scenarios', () => { - const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}); + const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}) - dataScenarioConfig.retry(3); + dataScenarioConfig.retry(3) - dataScenarioConfig.scenarios.forEach(scenario => expect(3).to.equal(scenario.test._retries)); - }); + dataScenarioConfig.scenarios.forEach(scenario => expect(3).to.equal(scenario.test._retries)) + }) it('can expect failure for all scenarios', () => { - const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}); + const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}) - dataScenarioConfig.fails(); + dataScenarioConfig.fails() - dataScenarioConfig.scenarios.forEach(scenario => expect(scenario.test.throws).to.exist); - }); + dataScenarioConfig.scenarios.forEach(scenario => expect(scenario.test.throws).to.exist) + }) it('can expect a specific error for all scenarios', () => { - const err = new Error(); + const err = new Error() - const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}); + const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}) - dataScenarioConfig.throws(err); + dataScenarioConfig.throws(err) - dataScenarioConfig.scenarios.forEach(scenario => expect(err).to.equal(scenario.test.throws)); - }); + dataScenarioConfig.scenarios.forEach(scenario => expect(err).to.equal(scenario.test.throws)) + }) it('can configure a helper for all scenarios', () => { - const helperName = 'myHelper'; - const helper = {}; + const helperName = 'myHelper' + const helper = {} - const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}); + const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}) - dataScenarioConfig.config(helperName, helper); + dataScenarioConfig.config(helperName, helper) - dataScenarioConfig.scenarios.forEach(scenario => expect(helper).to.equal(scenario.test.config[helperName])); - }); + dataScenarioConfig.scenarios.forEach(scenario => expect(helper).to.equal(scenario.test.config[helperName])) + }) it("should shows object's toString() method in each scenario's name if the toString() method is overridden", () => { - const data = [{ toString: () => 'test case title' }]; - const dataScenarioConfig = context.Data(data).Scenario('scenario', () => {}); - expect('scenario | test case title').to.equal(dataScenarioConfig.scenarios[0].test.title); - }); + const data = [{ toString: () => 'test case title' }] + const dataScenarioConfig = context.Data(data).Scenario('scenario', () => {}) + expect('scenario | test case title').to.equal(dataScenarioConfig.scenarios[0].test.title) + }) it("should shows JSON.stringify() in each scenario's name if the toString() method isn't overridden", () => { - const data = [{ name: 'John Do' }]; - const dataScenarioConfig = context.Data(data).Scenario('scenario', () => {}); - expect(`scenario | ${JSON.stringify(data[0])}`).to.equal(dataScenarioConfig.scenarios[0].test.title); - }); + const data = [{ name: 'John Do' }] + const dataScenarioConfig = context.Data(data).Scenario('scenario', () => {}) + expect(`scenario | ${JSON.stringify(data[0])}`).to.equal(dataScenarioConfig.scenarios[0].test.title) + }) it('should shows secret value as *****', () => { - const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}); - expect('scenario | {"username":"Username","password":"*****"}').to.equal(dataScenarioConfig.scenarios[2].test.title); - }); - }); -}); + const dataScenarioConfig = context.Data(dataTable).Scenario('scenario', () => {}) + expect('scenario | {"username":"Username","password":"*****"}').to.equal(dataScenarioConfig.scenarios[2].test.title) + }) + }) +}) diff --git a/test/unit/helper/FileSystem_test.js b/test/unit/helper/FileSystem_test.js index 81d22b8f3..ef1ac4ebd 100644 --- a/test/unit/helper/FileSystem_test.js +++ b/test/unit/helper/FileSystem_test.js @@ -1,58 +1,58 @@ -const path = require('path'); +const path = require('path') -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); + expect = chai.expect +}) -const FileSystem = require('../../../lib/helper/FileSystem'); +const FileSystem = require('../../../lib/helper/FileSystem') -global.codeceptjs = require('../../../lib'); +global.codeceptjs = require('../../../lib') -let fs; +let fs describe('FileSystem', () => { before(() => { - global.codecept_dir = path.join(__dirname, '/../..'); - }); + global.codecept_dir = path.join(__dirname, '/../..') + }) beforeEach(() => { - fs = new FileSystem(); - fs._before(); - }); + fs = new FileSystem() + fs._before() + }) it('should be initialized before tests', () => { - expect(fs.dir).to.eql(global.codecept_dir); - }); + expect(fs.dir).to.eql(global.codecept_dir) + }) it('should open dirs', () => { - fs.amInPath('data'); - expect(fs.dir).to.eql(path.join(global.codecept_dir, '/data')); - }); + fs.amInPath('data') + expect(fs.dir).to.eql(path.join(global.codecept_dir, '/data')) + }) it('should see file', () => { - fs.seeFile('data/fs_sample.txt'); - fs.amInPath('data'); - fs.seeFile('fs_sample.txt'); - expect(fs.grabFileNames()).to.include('fs_sample.txt'); - fs.seeFileNameMatching('sample'); - }); + fs.seeFile('data/fs_sample.txt') + fs.amInPath('data') + fs.seeFile('fs_sample.txt') + expect(fs.grabFileNames()).to.include('fs_sample.txt') + fs.seeFileNameMatching('sample') + }) it('should check file contents', () => { - fs.seeFile('data/fs_sample.txt'); - fs.seeInThisFile('FileSystem'); - fs.dontSeeInThisFile('WebDriverIO'); - fs.dontSeeFileContentsEqual('123345'); + fs.seeFile('data/fs_sample.txt') + fs.seeInThisFile('FileSystem') + fs.dontSeeInThisFile('WebDriverIO') + fs.dontSeeFileContentsEqual('123345') fs.seeFileContentsEqual(`A simple file for FileSystem helper -test`); - }); +test`) + }) it('should write text to file', () => { - const outputFilePath = 'data/output/fs_output.txt'; - const text = '123'; - fs.writeToFile(outputFilePath, text); - fs.seeFile(outputFilePath); - fs.seeInThisFile(text); - }); -}); + const outputFilePath = 'data/output/fs_output.txt' + const text = '123' + fs.writeToFile(outputFilePath, text) + fs.seeFile(outputFilePath) + fs.seeInThisFile(text) + }) +}) diff --git a/test/unit/helper/element_not_found_test.js b/test/unit/helper/element_not_found_test.js index f09b92680..7a19e063e 100644 --- a/test/unit/helper/element_not_found_test.js +++ b/test/unit/helper/element_not_found_test.js @@ -1,35 +1,31 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); + expect = chai.expect +}) -const ElementNotFound = require('../../../lib/helper/errors/ElementNotFound'); +const ElementNotFound = require('../../../lib/helper/errors/ElementNotFound') -const locator = '#invalidSelector'; +const locator = '#invalidSelector' describe('ElementNotFound error', () => { it('should throw error', () => { - expect(() => new ElementNotFound(locator)).to.throw(Error); - }); + expect(() => new ElementNotFound(locator)).to.throw(Error) + }) it('should provide default message', () => { - expect(() => new ElementNotFound(locator)) - .to.throw(Error, 'Element "#invalidSelector" was not found by text|CSS|XPath'); - }); + expect(() => new ElementNotFound(locator)).to.throw(Error, 'Element "#invalidSelector" was not found by text|CSS|XPath') + }) it('should use prefix for message', () => { - expect(() => new ElementNotFound(locator, 'Field')) - .to.throw(Error, 'Field "#invalidSelector" was not found by text|CSS|XPath'); - }); + expect(() => new ElementNotFound(locator, 'Field')).to.throw(Error, 'Field "#invalidSelector" was not found by text|CSS|XPath') + }) it('should use postfix for message', () => { - expect(() => new ElementNotFound(locator, 'Locator', 'cannot be found')) - .to.throw(Error, 'Locator "#invalidSelector" cannot be found'); - }); + expect(() => new ElementNotFound(locator, 'Locator', 'cannot be found')).to.throw(Error, 'Locator "#invalidSelector" cannot be found') + }) it('should stringify locator object', () => { - const objectLocator = { css: locator }; - expect(() => new ElementNotFound(objectLocator)) - .to.throw(Error, `Element "${JSON.stringify(objectLocator)}" was not found by text|CSS|XPath`); - }); -}); + const objectLocator = { css: locator } + expect(() => new ElementNotFound(objectLocator)).to.throw(Error, `Element "${JSON.stringify(objectLocator)}" was not found by text|CSS|XPath`) + }) +}) diff --git a/test/unit/plugin/customLocator_test.js b/test/unit/plugin/customLocator_test.js index e3834c7f8..aab33ff08 100644 --- a/test/unit/plugin/customLocator_test.js +++ b/test/unit/plugin/customLocator_test.js @@ -1,91 +1,91 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); -const customLocatorPlugin = require('../../../lib/plugin/customLocator'); -const Locator = require('../../../lib/locator'); + expect = chai.expect +}) +const customLocatorPlugin = require('../../../lib/plugin/customLocator') +const Locator = require('../../../lib/locator') describe('customLocator', () => { beforeEach(() => { - Locator.filters = []; - }); + Locator.filters = [] + }) it('add a custom locator by $ -> data-qa', () => { customLocatorPlugin({ prefix: '$', attribute: 'data-qa', showActual: true, - }); - const l = new Locator('$user-id'); - expect(l.isXPath()).to.be.true; - expect(l.toXPath()).to.eql('.//*[@data-qa=\'user-id\']'); - expect(l.toString()).to.eql('.//*[@data-qa=\'user-id\']'); - }); + }) + const l = new Locator('$user-id') + expect(l.isXPath()).to.be.true + expect(l.toXPath()).to.eql(".//*[@data-qa='user-id']") + expect(l.toString()).to.eql(".//*[@data-qa='user-id']") + }) it('add a custom locator by = -> data-test-id', () => { customLocatorPlugin({ prefix: '=', attribute: 'data-test-id', showActual: false, - }); - const l = new Locator('=no-user'); - expect(l.isXPath()).to.be.true; - expect(l.toXPath()).to.eql('.//*[@data-test-id=\'no-user\']'); - expect(l.toString()).to.eql('=no-user'); - }); + }) + const l = new Locator('=no-user') + expect(l.isXPath()).to.be.true + expect(l.toXPath()).to.eql(".//*[@data-test-id='no-user']") + expect(l.toString()).to.eql('=no-user') + }) it('add a custom locator with multple char prefix = -> data-test-id', () => { customLocatorPlugin({ prefix: 'test=', attribute: 'data-test-id', showActual: false, - }); - const l = new Locator('test=no-user'); - expect(l.isXPath()).to.be.true; - expect(l.toXPath()).to.eql('.//*[@data-test-id=\'no-user\']'); - expect(l.toString()).to.eql('test=no-user'); - }); + }) + const l = new Locator('test=no-user') + expect(l.isXPath()).to.be.true + expect(l.toXPath()).to.eql(".//*[@data-test-id='no-user']") + expect(l.toString()).to.eql('test=no-user') + }) it('add a custom locator with CSS', () => { customLocatorPlugin({ prefix: '$', attribute: 'data-test', strategy: 'css', - }); - const l = new Locator('$user'); - expect(l.isCSS()).to.be.true; - expect(l.simplify()).to.eql('[data-test=user]'); - }); + }) + const l = new Locator('$user') + expect(l.isCSS()).to.be.true + expect(l.simplify()).to.eql('[data-test=user]') + }) it('add a custom locator with array $ -> data-qa, data-qa-id', () => { customLocatorPlugin({ prefix: '$', attribute: ['data-qa', 'data-qa-id'], showActual: true, - }); - const l = new Locator('$user-id'); - expect(l.isXPath()).to.be.true; - expect(l.toXPath()).to.eql('.//*[@data-qa=\'user-id\' or @data-qa-id=\'user-id\']'); - expect(l.toString()).to.eql('.//*[@data-qa=\'user-id\' or @data-qa-id=\'user-id\']'); - }); + }) + const l = new Locator('$user-id') + expect(l.isXPath()).to.be.true + expect(l.toXPath()).to.eql(".//*[@data-qa='user-id' or @data-qa-id='user-id']") + expect(l.toString()).to.eql(".//*[@data-qa='user-id' or @data-qa-id='user-id']") + }) it('add a custom locator array with CSS', () => { customLocatorPlugin({ prefix: '$', attribute: ['data-test', 'data-test-id'], strategy: 'css', - }); - const l = new Locator('$user'); - expect(l.isCSS()).to.be.true; - expect(l.simplify()).to.eql('[data-test=user],[data-test-id=user]'); - }); + }) + const l = new Locator('$user') + expect(l.isCSS()).to.be.true + expect(l.simplify()).to.eql('[data-test=user],[data-test-id=user]') + }) it('should return initial locator value when it does not start with specified prefix', () => { customLocatorPlugin({ prefix: '$', attribute: 'data-test', - }); - const l = new Locator('=user'); - expect(l.simplify()).to.eql('=user'); - }); -}); + }) + const l = new Locator('=user') + expect(l.simplify()).to.eql('=user') + }) +}) diff --git a/test/unit/plugin/eachElement_test.js b/test/unit/plugin/eachElement_test.js index efa6d19f3..1c7724156 100644 --- a/test/unit/plugin/eachElement_test.js +++ b/test/unit/plugin/eachElement_test.js @@ -1,49 +1,49 @@ -const path = require('path'); +const path = require('path') -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); -const container = require('../../../lib/container'); -const eachElement = require('../../../lib/plugin/eachElement')(); -const recorder = require('../../../lib/recorder'); + expect = chai.expect +}) +const container = require('../../../lib/container') +const eachElement = require('../../../lib/plugin/eachElement')() +const recorder = require('../../../lib/recorder') describe('eachElement plugin', () => { beforeEach(() => { - global.codecept_dir = path.join(__dirname, '/../..'); - recorder.start(); + global.codecept_dir = path.join(__dirname, '/../..') + recorder.start() container.create({ helpers: { MyHelper: { require: './data/helper', }, }, - }); - }); + }) + }) afterEach(() => { - container.clear(); - }); + container.clear() + }) it('should iterate for each elements', async () => { - let counter = 0; - await eachElement('some action', 'some locator', async (el) => { - expect(el).is.not.null; - counter++; - }); - await recorder.promise(); - expect(counter).to.equal(2); - }); + let counter = 0 + await eachElement('some action', 'some locator', async el => { + expect(el).is.not.null + counter++ + }) + await recorder.promise() + expect(counter).to.equal(2) + }) it('should not allow non async function', async () => { - let errorCaught = false; + let errorCaught = false try { - await eachElement('some action', 'some locator', (el) => {}); - await recorder.promise(); + await eachElement('some action', 'some locator', el => {}) + await recorder.promise() } catch (err) { - errorCaught = true; - expect(err.message).to.include('Async'); + errorCaught = true + expect(err.message).to.include('Async') } - expect(errorCaught).is.true; - }); -}); + expect(errorCaught).is.true + }) +}) diff --git a/test/unit/plugin/retryFailedStep_test.js b/test/unit/plugin/retryFailedStep_test.js index a866a94b3..2a13e2212 100644 --- a/test/unit/plugin/retryFailedStep_test.js +++ b/test/unit/plugin/retryFailedStep_test.js @@ -1,213 +1,274 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); + expect = chai.expect +}) -const retryFailedStep = require('../../../lib/plugin/retryFailedStep'); -const tryTo = require('../../../lib/plugin/tryTo'); -const within = require('../../../lib/within'); -const session = require('../../../lib/session'); -const container = require('../../../lib/container'); -const event = require('../../../lib/event'); -const recorder = require('../../../lib/recorder'); +const retryFailedStep = require('../../../lib/plugin/retryFailedStep') +const tryTo = require('../../../lib/plugin/tryTo') +const within = require('../../../lib/within') +const session = require('../../../lib/session') +const container = require('../../../lib/container') +const event = require('../../../lib/event') +const recorder = require('../../../lib/recorder') describe('retryFailedStep', () => { beforeEach(() => { - recorder.retries = []; + recorder.retries = [] container.clear({ mock: { _session: () => {}, }, - }); - recorder.start(); - }); + }) + recorder.start() + }) afterEach(() => { - event.dispatcher.emit(event.step.finished, { }); - }); + event.dispatcher.emit(event.step.finished, {}) + }) it('should retry failed step', async () => { - retryFailedStep({ retries: 2, minTimeout: 1 }); - event.dispatcher.emit(event.test.before, {}); - event.dispatcher.emit(event.step.started, { name: 'click' }); - - let counter = 0; - await recorder.add(() => { - counter++; - if (counter < 3) { - throw new Error(); - } - }, undefined, undefined, true); - return recorder.promise(); - }); + retryFailedStep({ retries: 2, minTimeout: 1 }) + event.dispatcher.emit(event.test.before, {}) + event.dispatcher.emit(event.step.started, { name: 'click' }) + + let counter = 0 + await recorder.add( + () => { + counter++ + if (counter < 3) { + throw new Error() + } + }, + undefined, + undefined, + true, + ) + return recorder.promise() + }) it('should not retry failed step when tryTo plugin is enabled', async () => { - tryTo(); - retryFailedStep({ retries: 2, minTimeout: 1 }); - event.dispatcher.emit(event.test.before, {}); - event.dispatcher.emit(event.step.started, { name: 'click' }); + tryTo() + retryFailedStep({ retries: 2, minTimeout: 1 }) + event.dispatcher.emit(event.test.before, {}) + event.dispatcher.emit(event.step.started, { name: 'click' }) try { - let counter = 0; - await recorder.add(() => { - counter++; - if (counter < 3) { - throw new Error('Retry failed step is disabled when tryTo plugin is enabled'); - } - }, undefined, undefined, true); - return recorder.promise(); + let counter = 0 + await recorder.add( + () => { + counter++ + if (counter < 3) { + throw new Error('Retry failed step is disabled when tryTo plugin is enabled') + } + }, + undefined, + undefined, + true, + ) + return recorder.promise() } catch (e) { - expect(e.message).equal('Retry failed step is disabled when tryTo plugin is enabled'); + expect(e.message).equal('Retry failed step is disabled when tryTo plugin is enabled') } - }); + }) it('should not retry within', async () => { - retryFailedStep({ retries: 1, minTimeout: 1 }); - event.dispatcher.emit(event.test.before, {}); + retryFailedStep({ retries: 1, minTimeout: 1 }) + event.dispatcher.emit(event.test.before, {}) - let counter = 0; - event.dispatcher.emit(event.step.started, { name: 'click' }); + let counter = 0 + event.dispatcher.emit(event.step.started, { name: 'click' }) try { within('foo', () => { - recorder.add(() => { - counter++; - throw new Error(); - }, undefined, undefined, true); - }); - await recorder.promise(); + recorder.add( + () => { + counter++ + throw new Error() + }, + undefined, + undefined, + true, + ) + }) + await recorder.promise() } catch (e) { - await recorder.catchWithoutStop((err) => err); + await recorder.catchWithoutStop(err => err) } - expect(process.env.FAILED_STEP_RETRIES).to.equal('1'); + expect(process.env.FAILED_STEP_RETRIES).to.equal('1') // expects to retry only once - counter.should.equal(2); - }); + counter.should.equal(2) + }) it('should not retry steps with wait*', async () => { - retryFailedStep({ retries: 2, minTimeout: 1 }); - event.dispatcher.emit(event.test.before, {}); + retryFailedStep({ retries: 2, minTimeout: 1 }) + event.dispatcher.emit(event.test.before, {}) - let counter = 0; - event.dispatcher.emit(event.step.started, { name: 'waitForElement' }); + let counter = 0 + event.dispatcher.emit(event.step.started, { name: 'waitForElement' }) try { - await recorder.add(() => { - counter++; - if (counter < 3) { - throw new Error(); - } - }, undefined, undefined, true); - await recorder.promise(); + await recorder.add( + () => { + counter++ + if (counter < 3) { + throw new Error() + } + }, + undefined, + undefined, + true, + ) + await recorder.promise() } catch (e) { - await recorder.catchWithoutStop((err) => err); + await recorder.catchWithoutStop(err => err) } - expect(counter).to.equal(1); + expect(counter).to.equal(1) // expects to retry only once - }); + }) it('should not retry steps with amOnPage', async () => { - retryFailedStep({ retries: 2, minTimeout: 1 }); - event.dispatcher.emit(event.test.before, {}); + retryFailedStep({ retries: 2, minTimeout: 1 }) + event.dispatcher.emit(event.test.before, {}) - let counter = 0; - event.dispatcher.emit(event.step.started, { name: 'amOnPage' }); + let counter = 0 + event.dispatcher.emit(event.step.started, { name: 'amOnPage' }) try { - await recorder.add(() => { - counter++; - if (counter < 3) { - throw new Error(); - } - }, undefined, undefined, true); - await recorder.promise(); + await recorder.add( + () => { + counter++ + if (counter < 3) { + throw new Error() + } + }, + undefined, + undefined, + true, + ) + await recorder.promise() } catch (e) { - await recorder.catchWithoutStop((err) => err); + await recorder.catchWithoutStop(err => err) } - expect(counter).to.equal(1); + expect(counter).to.equal(1) // expects to retry only once - }); + }) it('should add custom steps to ignore', async () => { - retryFailedStep({ retries: 2, minTimeout: 1, ignoredSteps: ['somethingNew*'] }); - event.dispatcher.emit(event.test.before, {}); + retryFailedStep({ retries: 2, minTimeout: 1, ignoredSteps: ['somethingNew*'] }) + event.dispatcher.emit(event.test.before, {}) - let counter = 0; - event.dispatcher.emit(event.step.started, { name: 'somethingNew' }); + let counter = 0 + event.dispatcher.emit(event.step.started, { name: 'somethingNew' }) try { - await recorder.add(() => { - counter++; - if (counter < 3) { - throw new Error(); - } - }, undefined, undefined, true); - await recorder.promise(); + await recorder.add( + () => { + counter++ + if (counter < 3) { + throw new Error() + } + }, + undefined, + undefined, + true, + ) + await recorder.promise() } catch (e) { - await recorder.catchWithoutStop((err) => err); + await recorder.catchWithoutStop(err => err) } - expect(counter).to.equal(1); + expect(counter).to.equal(1) // expects to retry only once - }); + }) it('should add custom regexp steps to ignore', async () => { - retryFailedStep({ retries: 2, minTimeout: 1, ignoredSteps: [/somethingNew/] }); - event.dispatcher.emit(event.test.before, {}); + retryFailedStep({ retries: 2, minTimeout: 1, ignoredSteps: [/somethingNew/] }) + event.dispatcher.emit(event.test.before, {}) - let counter = 0; - event.dispatcher.emit(event.step.started, { name: 'somethingNew' }); + let counter = 0 + event.dispatcher.emit(event.step.started, { name: 'somethingNew' }) try { - await recorder.add(() => { - counter++; - if (counter < 3) { - throw new Error(); - } - }, undefined, undefined, true); - await recorder.promise(); + await recorder.add( + () => { + counter++ + if (counter < 3) { + throw new Error() + } + }, + undefined, + undefined, + true, + ) + await recorder.promise() } catch (e) { - await recorder.catchWithoutStop((err) => err); + await recorder.catchWithoutStop(err => err) } - expect(counter).to.equal(1); + expect(counter).to.equal(1) // expects to retry only once - }); + }) it('should not retry session', async () => { - retryFailedStep({ retries: 1, minTimeout: 1 }); - event.dispatcher.emit(event.test.before, {}); - event.dispatcher.emit(event.step.started, { name: 'click' }); - let counter = 0; + retryFailedStep({ retries: 1, minTimeout: 1 }) + event.dispatcher.emit(event.test.before, {}) + event.dispatcher.emit(event.step.started, { name: 'click' }) + let counter = 0 try { session('foo', () => { - recorder.add(() => { - counter++; - throw new Error(); - }, undefined, undefined, true); - }); - await recorder.promise(); + recorder.add( + () => { + counter++ + throw new Error() + }, + undefined, + undefined, + true, + ) + }) + await recorder.promise() } catch (e) { - await recorder.catchWithoutStop((err) => err); + await recorder.catchWithoutStop(err => err) } // expects to retry only once - expect(counter).to.equal(2); - }); + expect(counter).to.equal(2) + }) it('should not turn around the chain of retries', () => { - recorder.retry({ retries: 2, when: (err) => { return err.message === 'someerror'; }, identifier: 'test' }); - recorder.retry({ retries: 2, when: (err) => { return err.message === 'othererror'; } }); - - const getRetryIndex = () => recorder.retries.indexOf(recorder.retries.find(retry => retry.identifier)); - let initalIndex; - - recorder.add(() => { - initalIndex = getRetryIndex(); - }, undefined, undefined, true); - - recorder.add(() => { - initalIndex.should.equal(getRetryIndex()); - }, undefined, undefined, true); - return recorder.promise(); - }); -}); + recorder.retry({ + retries: 2, + when: err => { + return err.message === 'someerror' + }, + identifier: 'test', + }) + recorder.retry({ + retries: 2, + when: err => { + return err.message === 'othererror' + }, + }) + + const getRetryIndex = () => recorder.retries.indexOf(recorder.retries.find(retry => retry.identifier)) + let initalIndex + + recorder.add( + () => { + initalIndex = getRetryIndex() + }, + undefined, + undefined, + true, + ) + + recorder.add( + () => { + initalIndex.should.equal(getRetryIndex()) + }, + undefined, + undefined, + true, + ) + return recorder.promise() + }) +}) diff --git a/test/unit/plugin/retryto_test.js b/test/unit/plugin/retryto_test.js index 293adf1d7..213dd577b 100644 --- a/test/unit/plugin/retryto_test.js +++ b/test/unit/plugin/retryto_test.js @@ -1,36 +1,42 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); -const retryTo = require('../../../lib/plugin/retryTo')(); -const recorder = require('../../../lib/recorder'); + expect = chai.expect +}) +const retryTo = require('../../../lib/plugin/retryTo')() +const recorder = require('../../../lib/recorder') describe('retryTo plugin', () => { beforeEach(() => { - recorder.start(); - }); + recorder.start() + }) it('should execute command on success', async () => { - let counter = 0; - await retryTo(() => recorder.add(() => counter++), 5); - expect(counter).is.equal(1); - return recorder.promise(); - }); + let counter = 0 + await retryTo(() => recorder.add(() => counter++), 5) + expect(counter).is.equal(1) + return recorder.promise() + }) it('should execute few times command on fail', async () => { - let counter = 0; - let errorCaught = false; + let counter = 0 + let errorCaught = false try { - await retryTo(() => { - recorder.add(() => counter++); - recorder.add(() => { throw new Error('Ups'); }); - }, 5, 10); - await recorder.promise(); + await retryTo( + () => { + recorder.add(() => counter++) + recorder.add(() => { + throw new Error('Ups') + }) + }, + 5, + 10, + ) + await recorder.promise() } catch (err) { - errorCaught = true; - expect(err.message).to.eql('Ups'); + errorCaught = true + expect(err.message).to.eql('Ups') } - expect(counter).to.equal(5); - expect(errorCaught).is.true; - }); -}); + expect(counter).to.equal(5) + expect(errorCaught).is.true + }) +}) diff --git a/test/unit/plugin/screenshotOnFail_test.js b/test/unit/plugin/screenshotOnFail_test.js index fc6b7295f..70d07e501 100644 --- a/test/unit/plugin/screenshotOnFail_test.js +++ b/test/unit/plugin/screenshotOnFail_test.js @@ -1,82 +1,82 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); -const sinon = require('sinon'); + expect = chai.expect +}) +const sinon = require('sinon') -const screenshotOnFail = require('../../../lib/plugin/screenshotOnFail'); -const container = require('../../../lib/container'); -const event = require('../../../lib/event'); -const recorder = require('../../../lib/recorder'); +const screenshotOnFail = require('../../../lib/plugin/screenshotOnFail') +const container = require('../../../lib/container') +const event = require('../../../lib/event') +const recorder = require('../../../lib/recorder') -let screenshotSaved; +let screenshotSaved describe('screenshotOnFail', () => { beforeEach(() => { - recorder.reset(); - screenshotSaved = sinon.spy(); + recorder.reset() + screenshotSaved = sinon.spy() container.clear({ WebDriver: { options: {}, saveScreenshot: screenshotSaved, }, - }); - }); + }) + }) it('should remove the . at the end of test title', async () => { - screenshotOnFail({}); - event.dispatcher.emit(event.test.failed, { title: 'test title.' }); - await recorder.promise(); - expect(screenshotSaved.called).is.ok; - expect('test_title.failed.png').is.equal(screenshotSaved.getCall(0).args[0]); - }); + screenshotOnFail({}) + event.dispatcher.emit(event.test.failed, { title: 'test title.' }) + await recorder.promise() + expect(screenshotSaved.called).is.ok + expect('test_title.failed.png').is.equal(screenshotSaved.getCall(0).args[0]) + }) it('should exclude the data driven in failed screenshot file name', async () => { - screenshotOnFail({}); - event.dispatcher.emit(event.test.failed, { title: 'Scenario with data driven | {"login":"admin","password":"123456"}' }); - await recorder.promise(); - expect(screenshotSaved.called).is.ok; - expect('Scenario_with_data_driven.failed.png').is.equal(screenshotSaved.getCall(0).args[0]); - }); + screenshotOnFail({}) + event.dispatcher.emit(event.test.failed, { title: 'Scenario with data driven | {"login":"admin","password":"123456"}' }) + await recorder.promise() + expect(screenshotSaved.called).is.ok + expect('Scenario_with_data_driven.failed.png').is.equal(screenshotSaved.getCall(0).args[0]) + }) it('should create screenshot on fail', async () => { - screenshotOnFail({}); - event.dispatcher.emit(event.test.failed, { title: 'test1' }); - await recorder.promise(); - expect(screenshotSaved.called).is.ok; - expect('test1.failed.png').is.equal(screenshotSaved.getCall(0).args[0]); - }); + screenshotOnFail({}) + event.dispatcher.emit(event.test.failed, { title: 'test1' }) + await recorder.promise() + expect(screenshotSaved.called).is.ok + expect('test1.failed.png').is.equal(screenshotSaved.getCall(0).args[0]) + }) it('should create screenshot with unique name', async () => { - screenshotOnFail({ uniqueScreenshotNames: true }); - event.dispatcher.emit(event.test.failed, { title: 'test1', uuid: 1 }); - await recorder.promise(); - expect(screenshotSaved.called).is.ok; - expect('test1_1.failed.png').is.equal(screenshotSaved.getCall(0).args[0]); - }); + screenshotOnFail({ uniqueScreenshotNames: true }) + event.dispatcher.emit(event.test.failed, { title: 'test1', uuid: 1 }) + await recorder.promise() + expect(screenshotSaved.called).is.ok + expect('test1_1.failed.png').is.equal(screenshotSaved.getCall(0).args[0]) + }) it('should create screenshot with unique name when uuid is null', async () => { - screenshotOnFail({ uniqueScreenshotNames: true }); - event.dispatcher.emit(event.test.failed, { title: 'test1' }); - await recorder.promise(); - expect(screenshotSaved.called).is.ok; - const fileName = screenshotSaved.getCall(0).args[0]; - const regexpFileName = /test1_[0-9]{10}.failed.png/; - expect(fileName.match(regexpFileName).length).is.equal(1); - }); + screenshotOnFail({ uniqueScreenshotNames: true }) + event.dispatcher.emit(event.test.failed, { title: 'test1' }) + await recorder.promise() + expect(screenshotSaved.called).is.ok + const fileName = screenshotSaved.getCall(0).args[0] + const regexpFileName = /test1_[0-9]{10}.failed.png/ + expect(fileName.match(regexpFileName).length).is.equal(1) + }) it('should not save screenshot in BeforeSuite', async () => { - screenshotOnFail({ uniqueScreenshotNames: true }); - event.dispatcher.emit(event.test.failed, { title: 'test1', ctx: { _runnable: { title: 'hook: BeforeSuite' } } }); - await recorder.promise(); - expect(!screenshotSaved.called).is.ok; - }); + screenshotOnFail({ uniqueScreenshotNames: true }) + event.dispatcher.emit(event.test.failed, { title: 'test1', ctx: { _runnable: { title: 'hook: BeforeSuite' } } }) + await recorder.promise() + expect(!screenshotSaved.called).is.ok + }) it('should not save screenshot in AfterSuite', async () => { - screenshotOnFail({ uniqueScreenshotNames: true }); - event.dispatcher.emit(event.test.failed, { title: 'test1', ctx: { _runnable: { title: 'hook: AfterSuite' } } }); - await recorder.promise(); - expect(!screenshotSaved.called).is.ok; - }); + screenshotOnFail({ uniqueScreenshotNames: true }) + event.dispatcher.emit(event.test.failed, { title: 'test1', ctx: { _runnable: { title: 'hook: AfterSuite' } } }) + await recorder.promise() + expect(!screenshotSaved.called).is.ok + }) // TODO: write more tests for different options -}); +}) diff --git a/test/unit/plugin/subtitles_test.js b/test/unit/plugin/subtitles_test.js index 64c59694c..a20b5459c 100644 --- a/test/unit/plugin/subtitles_test.js +++ b/test/unit/plugin/subtitles_test.js @@ -1,15 +1,15 @@ -const sinon = require('sinon'); +const sinon = require('sinon') -const fsPromises = require('fs').promises; -const subtitles = require('../../../lib/plugin/subtitles'); -const container = require('../../../lib/container'); -const event = require('../../../lib/event'); -const recorder = require('../../../lib/recorder'); +const fsPromises = require('fs').promises +const subtitles = require('../../../lib/plugin/subtitles') +const container = require('../../../lib/container') +const event = require('../../../lib/event') +const recorder = require('../../../lib/recorder') function sleep(ms) { - return new Promise((resolve) => { - setTimeout(resolve, ms); - }); + return new Promise(resolve => { + setTimeout(resolve, ms) + }) } describe('subtitles', () => { @@ -18,130 +18,149 @@ describe('subtitles', () => { mock: { _session: () => {}, }, - }); - recorder.start(); - }); + }) + recorder.start() + }) before(() => { - subtitles({}); - }); + subtitles({}) + }) it('should not capture subtitle as video artifact was missing', async () => { - const fsMock = sinon.mock(fsPromises); + const fsMock = sinon.mock(fsPromises) - const test = {}; + const test = {} - fsMock.expects('writeFile') - .never(); + fsMock.expects('writeFile').never() - event.dispatcher.emit(event.test.before, test); - const step1 = { name: 'see', actor: 'I', args: ['Test 1'] }; - event.dispatcher.emit(event.step.started, step1); - event.dispatcher.emit(event.step.finished, step1); - event.dispatcher.emit(event.test.after, test); - fsMock.verify(); - }); + event.dispatcher.emit(event.test.before, test) + const step1 = { name: 'see', actor: 'I', args: ['Test 1'] } + event.dispatcher.emit(event.step.started, step1) + event.dispatcher.emit(event.step.finished, step1) + event.dispatcher.emit(event.test.after, test) + fsMock.verify() + }) it('should capture subtitle as video artifact is present', async () => { - const fsMock = sinon.mock(fsPromises); + const fsMock = sinon.mock(fsPromises) const test = { artifacts: { video: '../../lib/output/failedTest1.webm', }, - }; + } - fsMock.expects('writeFile') + fsMock + .expects('writeFile') .once() - .withExactArgs('../../lib/output/failedTest1.srt', sinon.match((value) => { - return value.match(/^1\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.click\(Continue\)\n\n$/gm); - })); - - event.dispatcher.emit(event.test.before, test); - const step1 = { name: 'click', actor: 'I', args: ['Continue'] }; - event.dispatcher.emit(event.step.started, step1); - event.dispatcher.emit(event.step.finished, step1); - event.dispatcher.emit(event.test.after, test); - fsMock.verify(); - }); + .withExactArgs( + '../../lib/output/failedTest1.srt', + sinon.match(value => { + return value.match(/^1\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.click\(Continue\)\n\n$/gm) + }), + ) + + event.dispatcher.emit(event.test.before, test) + const step1 = { name: 'click', actor: 'I', args: ['Continue'] } + event.dispatcher.emit(event.step.started, step1) + event.dispatcher.emit(event.step.finished, step1) + event.dispatcher.emit(event.test.after, test) + fsMock.verify() + }) it('should capture mutiple steps as subtitle', async () => { - const fsMock = sinon.mock(fsPromises); + const fsMock = sinon.mock(fsPromises) const test = { artifacts: { video: '../../lib/output/failedTest1.webm', }, - }; + } - fsMock.expects('writeFile') + fsMock + .expects('writeFile') .once() - .withExactArgs('../../lib/output/failedTest1.srt', sinon.match((value) => { - return value.match(/^1\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.click\(Continue\)\n\n2\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.see\(Github\)\n\n$/gm); - })); - - event.dispatcher.emit(event.test.before, test); - const step1 = { name: 'click', actor: 'I', args: ['Continue'] }; - const step2 = { name: 'see', actor: 'I', args: ['Github'] }; - event.dispatcher.emit(event.step.started, step1); - event.dispatcher.emit(event.step.started, step2); - event.dispatcher.emit(event.step.finished, step2); - await sleep(300); - - event.dispatcher.emit(event.step.finished, step1); - event.dispatcher.emit(event.test.after, test); - fsMock.verify(); - }); + .withExactArgs( + '../../lib/output/failedTest1.srt', + sinon.match(value => { + return value.match( + /^1\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.click\(Continue\)\n\n2\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.see\(Github\)\n\n$/gm, + ) + }), + ) + + event.dispatcher.emit(event.test.before, test) + const step1 = { name: 'click', actor: 'I', args: ['Continue'] } + const step2 = { name: 'see', actor: 'I', args: ['Github'] } + event.dispatcher.emit(event.step.started, step1) + event.dispatcher.emit(event.step.started, step2) + event.dispatcher.emit(event.step.finished, step2) + await sleep(300) + + event.dispatcher.emit(event.step.finished, step1) + event.dispatcher.emit(event.test.after, test) + fsMock.verify() + }) it('should capture seperate steps for separate tests', async () => { - const fsMock = sinon.mock(fsPromises); + const fsMock = sinon.mock(fsPromises) const test1 = { artifacts: { video: '../../lib/output/failedTest1.webm', }, - }; + } - fsMock.expects('writeFile') + fsMock + .expects('writeFile') .once() - .withExactArgs('../../lib/output/failedTest1.srt', sinon.match((value) => { - return value.match(/^1\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.click\(Continue\)\n\n2\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.see\(Github\)\n\n$/gm); - })); - - event.dispatcher.emit(event.test.before, test1); - const step1 = { name: 'click', actor: 'I', args: ['Continue'] }; - const step2 = { name: 'see', actor: 'I', args: ['Github'] }; - event.dispatcher.emit(event.step.started, step1); - event.dispatcher.emit(event.step.started, step2); - event.dispatcher.emit(event.step.finished, step2); - await sleep(300); - - event.dispatcher.emit(event.step.finished, step1); - event.dispatcher.emit(event.test.after, test1); - fsMock.verify(); - fsMock.restore(); + .withExactArgs( + '../../lib/output/failedTest1.srt', + sinon.match(value => { + return value.match( + /^1\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.click\(Continue\)\n\n2\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.see\(Github\)\n\n$/gm, + ) + }), + ) + + event.dispatcher.emit(event.test.before, test1) + const step1 = { name: 'click', actor: 'I', args: ['Continue'] } + const step2 = { name: 'see', actor: 'I', args: ['Github'] } + event.dispatcher.emit(event.step.started, step1) + event.dispatcher.emit(event.step.started, step2) + event.dispatcher.emit(event.step.finished, step2) + await sleep(300) + + event.dispatcher.emit(event.step.finished, step1) + event.dispatcher.emit(event.test.after, test1) + fsMock.verify() + fsMock.restore() /** * To Ensure that when multiple tests are run steps are not incorrectly captured */ - const fsMock1 = sinon.mock(fsPromises); - fsMock1.expects('writeFile') + const fsMock1 = sinon.mock(fsPromises) + fsMock1 + .expects('writeFile') .once() - .withExactArgs('../../lib/output/failedTest2.srt', sinon.match((value) => { - return value.match(/^1\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.click\(Login\)\n\n$/gm); - })); + .withExactArgs( + '../../lib/output/failedTest2.srt', + sinon.match(value => { + return value.match(/^1\n[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\s-->\s[0-9]{2}:[0-9]{2}:[0-9]{2},[0-9]{3}\nI\.click\(Login\)\n\n$/gm) + }), + ) const test2 = { artifacts: { video: '../../lib/output/failedTest2.webm', }, - }; - - event.dispatcher.emit(event.test.before, test2); - const step3 = { name: 'click', actor: 'I', args: ['Login'] }; - event.dispatcher.emit(event.step.started, step3); - await sleep(300); - - event.dispatcher.emit(event.step.finished, step3); - event.dispatcher.emit(event.test.after, test2); - fsMock1.verify(); - }); -}); + } + + event.dispatcher.emit(event.test.before, test2) + const step3 = { name: 'click', actor: 'I', args: ['Login'] } + event.dispatcher.emit(event.step.started, step3) + await sleep(300) + + event.dispatcher.emit(event.step.finished, step3) + event.dispatcher.emit(event.test.after, test2) + fsMock1.verify() + }) +}) diff --git a/test/unit/plugin/tryTo_test.js b/test/unit/plugin/tryTo_test.js index 412f0ccb8..efd8ebdea 100644 --- a/test/unit/plugin/tryTo_test.js +++ b/test/unit/plugin/tryTo_test.js @@ -1,26 +1,28 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); -const tryTo = require('../../../lib/plugin/tryTo')(); -const recorder = require('../../../lib/recorder'); + expect = chai.expect +}) +const tryTo = require('../../../lib/plugin/tryTo')() +const recorder = require('../../../lib/recorder') describe('tryTo plugin', () => { beforeEach(() => { - recorder.start(); - }); + recorder.start() + }) it('should execute command on success', async () => { - const ok = await tryTo(() => recorder.add(() => 5)); - expect(true).is.equal(ok); - return recorder.promise(); - }); + const ok = await tryTo(() => recorder.add(() => 5)) + expect(true).is.equal(ok) + return recorder.promise() + }) it('should execute command on fail', async () => { - const notOk = await tryTo(() => recorder.add(() => { - throw new Error('Ups'); - })); - expect(false).is.equal(notOk); - return recorder.promise(); - }); -}); + const notOk = await tryTo(() => + recorder.add(() => { + throw new Error('Ups') + }), + ) + expect(false).is.equal(notOk) + return recorder.promise() + }) +}) diff --git a/test/unit/scenario_test.js b/test/unit/scenario_test.js index c97cf91a9..601956989 100644 --- a/test/unit/scenario_test.js +++ b/test/unit/scenario_test.js @@ -1,99 +1,99 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); -const sinon = require('sinon'); + expect = chai.expect +}) +const sinon = require('sinon') -const scenario = require('../../lib/mocha/scenario'); -const recorder = require('../../lib/recorder'); -const event = require('../../lib/event'); +const scenario = require('../../lib/mocha/scenario') +const recorder = require('../../lib/recorder') +const event = require('../../lib/event') -let test; -let fn; -let before; -let after; -let beforeSuite; -let afterSuite; -let failed; -let started; +let test +let fn +let before +let after +let beforeSuite +let afterSuite +let failed +let started describe('Scenario', () => { beforeEach(() => { - test = { timeout: () => {} }; - fn = sinon.spy(); - test.fn = fn; - }); - beforeEach(() => recorder.reset()); - afterEach(() => event.cleanDispatcher()); + test = { timeout: () => {} } + fn = sinon.spy() + test.fn = fn + }) + beforeEach(() => recorder.reset()) + afterEach(() => event.cleanDispatcher()) it('should wrap test function', () => { - scenario.test(test).fn(() => {}); - expect(fn.called).is.ok; - }); + scenario.test(test).fn(() => {}) + expect(fn.called).is.ok + }) it('should work with async func', () => { - let counter = 0; + let counter = 0 test.fn = () => { recorder.add('test', async () => { - await counter++; - await counter++; - await counter++; - counter++; - }); - }; + await counter++ + await counter++ + await counter++ + counter++ + }) + } - scenario.setup(); - scenario.test(test).fn(() => null); - recorder.add('validation', () => expect(counter).to.eq(4)); - return recorder.promise(); - }); + scenario.setup() + scenario.test(test).fn(() => null) + recorder.add('validation', () => expect(counter).to.eq(4)) + return recorder.promise() + }) describe('events', () => { beforeEach(() => { - event.dispatcher.on(event.test.before, (before = sinon.spy())); - event.dispatcher.on(event.test.after, (after = sinon.spy())); - event.dispatcher.on(event.test.started, (started = sinon.spy())); - event.dispatcher.on(event.suite.before, (beforeSuite = sinon.spy())); - event.dispatcher.on(event.suite.after, (afterSuite = sinon.spy())); - scenario.suiteSetup(); - scenario.setup(); - }); + event.dispatcher.on(event.test.before, (before = sinon.spy())) + event.dispatcher.on(event.test.after, (after = sinon.spy())) + event.dispatcher.on(event.test.started, (started = sinon.spy())) + event.dispatcher.on(event.suite.before, (beforeSuite = sinon.spy())) + event.dispatcher.on(event.suite.after, (afterSuite = sinon.spy())) + scenario.suiteSetup() + scenario.setup() + }) it('should fire events', () => { - scenario.test(test).fn(() => null); - expect(started.called).is.ok; - scenario.teardown(); - scenario.suiteTeardown(); + scenario.test(test).fn(() => null) + expect(started.called).is.ok + scenario.teardown() + scenario.suiteTeardown() return recorder .promise() .then(() => expect(beforeSuite.called).is.ok) .then(() => expect(afterSuite.called).is.ok) .then(() => expect(before.called).is.ok) - .then(() => expect(after.called).is.ok); - }); + .then(() => expect(after.called).is.ok) + }) it('should fire failed event on error', () => { - event.dispatcher.on(event.test.failed, (failed = sinon.spy())); - scenario.setup(); + event.dispatcher.on(event.test.failed, (failed = sinon.spy())) + scenario.setup() test.fn = () => { - throw new Error('ups'); - }; - scenario.test(test).fn(() => {}); + throw new Error('ups') + } + scenario.test(test).fn(() => {}) return recorder .promise() .then(() => expect(failed.called).is.ok) - .catch(() => null); - }); + .catch(() => null) + }) it('should fire failed event on async error', () => { test.fn = () => { - recorder.throw(new Error('ups')); - }; - scenario.test(test).fn(() => {}); + recorder.throw(new Error('ups')) + } + scenario.test(test).fn(() => {}) return recorder .promise() .then(() => expect(failed.called).is.ok) - .catch(() => null); - }); - }); -}); + .catch(() => null) + }) + }) +}) diff --git a/test/unit/ui_test.js b/test/unit/ui_test.js index eb1bf5889..85034f775 100644 --- a/test/unit/ui_test.js +++ b/test/unit/ui_test.js @@ -1,220 +1,220 @@ -let expect; +let expect import('chai').then(chai => { - expect = chai.expect; -}); -const Mocha = require('mocha/lib/mocha'); -const Suite = require('mocha/lib/suite'); + expect = chai.expect +}) +const Mocha = require('mocha/lib/mocha') +const Suite = require('mocha/lib/suite') -global.codeceptjs = require('../../lib'); -const makeUI = require('../../lib/mocha/ui'); +global.codeceptjs = require('../../lib') +const makeUI = require('../../lib/mocha/ui') describe('ui', () => { - let suite; - let context; + let suite + let context beforeEach(() => { - context = {}; - suite = new Suite('empty'); - makeUI(suite); - suite.emit('pre-require', context, {}, new Mocha()); - }); + context = {} + suite = new Suite('empty') + makeUI(suite) + suite.emit('pre-require', context, {}, new Mocha()) + }) describe('basic constants', () => { - const constants = ['Before', 'Background', 'BeforeAll', 'After', 'AfterAll', 'Scenario', 'xScenario']; + const constants = ['Before', 'Background', 'BeforeAll', 'After', 'AfterAll', 'Scenario', 'xScenario'] constants.forEach(c => { - it(`context should contain ${c}`, () => expect(context[c]).is.ok); - }); - }); + it(`context should contain ${c}`, () => expect(context[c]).is.ok) + }) + }) describe('Feature', () => { - let suiteConfig; + let suiteConfig it('Feature should return featureConfig', () => { - suiteConfig = context.Feature('basic suite'); - expect(suiteConfig.suite).is.ok; - }); + suiteConfig = context.Feature('basic suite') + expect(suiteConfig.suite).is.ok + }) it('should contain title', () => { - suiteConfig = context.Feature('basic suite'); - expect(suiteConfig.suite).is.ok; - expect(suiteConfig.suite.title).eq('basic suite'); - expect(suiteConfig.suite.fullTitle()).eq('basic suite:'); - }); + suiteConfig = context.Feature('basic suite') + expect(suiteConfig.suite).is.ok + expect(suiteConfig.suite.title).eq('basic suite') + expect(suiteConfig.suite.fullTitle()).eq('basic suite:') + }) it('should contain tags', () => { - suiteConfig = context.Feature('basic suite'); - expect(0).eq(suiteConfig.suite.tags.length); + suiteConfig = context.Feature('basic suite') + expect(0).eq(suiteConfig.suite.tags.length) - suiteConfig = context.Feature('basic suite @very @important'); - expect(suiteConfig.suite).is.ok; + suiteConfig = context.Feature('basic suite @very @important') + expect(suiteConfig.suite).is.ok - suiteConfig.suite.tags.should.include('@very'); - suiteConfig.suite.tags.should.include('@important'); + suiteConfig.suite.tags.should.include('@very') + suiteConfig.suite.tags.should.include('@important') - suiteConfig.tag('@user'); - suiteConfig.suite.tags.should.include('@user'); + suiteConfig.tag('@user') + suiteConfig.suite.tags.should.include('@user') - suiteConfig.suite.tags.should.not.include('@slow'); - suiteConfig.tag('slow'); - suiteConfig.suite.tags.should.include('@slow'); - }); + suiteConfig.suite.tags.should.not.include('@slow') + suiteConfig.tag('slow') + suiteConfig.suite.tags.should.include('@slow') + }) it('retries can be set', () => { - suiteConfig = context.Feature('basic suite'); - suiteConfig.retry(3); - expect(3).eq(suiteConfig.suite.retries()); - }); + suiteConfig = context.Feature('basic suite') + suiteConfig.retry(3) + expect(3).eq(suiteConfig.suite.retries()) + }) it('timeout can be set', () => { - suiteConfig = context.Feature('basic suite'); - expect(0).eq(suiteConfig.suite.timeout()); - suiteConfig.timeout(3); - expect(3).eq(suiteConfig.suite.timeout()); - }); + suiteConfig = context.Feature('basic suite') + expect(0).eq(suiteConfig.suite.timeout()) + suiteConfig.timeout(3) + expect(3).eq(suiteConfig.suite.timeout()) + }) it('helpers can be configured', () => { - suiteConfig = context.Feature('basic suite'); - expect(!suiteConfig.suite.config); - suiteConfig.config('WebDriver', { browser: 'chrome' }); - expect('chrome').eq(suiteConfig.suite.config.WebDriver.browser); - suiteConfig.config({ browser: 'firefox' }); - expect('firefox').eq(suiteConfig.suite.config[0].browser); + suiteConfig = context.Feature('basic suite') + expect(!suiteConfig.suite.config) + suiteConfig.config('WebDriver', { browser: 'chrome' }) + expect('chrome').eq(suiteConfig.suite.config.WebDriver.browser) + suiteConfig.config({ browser: 'firefox' }) + expect('firefox').eq(suiteConfig.suite.config[0].browser) suiteConfig.config('WebDriver', () => { - return { browser: 'edge' }; - }); - expect('edge').eq(suiteConfig.suite.config.WebDriver.browser); - }); + return { browser: 'edge' } + }) + expect('edge').eq(suiteConfig.suite.config.WebDriver.browser) + }) it('Feature can be skipped', () => { - suiteConfig = context.Feature.skip('skipped suite'); - expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true'); - expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.'); - expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo'); - }); + suiteConfig = context.Feature.skip('skipped suite') + expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true') + expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.') + expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo') + }) it('Feature can be skipped via xFeature', () => { - suiteConfig = context.xFeature('skipped suite'); - expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true'); - expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.'); - expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo'); - }); + suiteConfig = context.xFeature('skipped suite') + expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true') + expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.') + expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo') + }) it('Feature are not skipped by default', () => { - suiteConfig = context.Feature('not skipped suite'); - expect(suiteConfig.suite.pending).eq(false, 'Feature must not contain pending === true'); + suiteConfig = context.Feature('not skipped suite') + expect(suiteConfig.suite.pending).eq(false, 'Feature must not contain pending === true') // expect(suiteConfig.suite.opts, undefined, 'Features should have no skip info'); - }); + }) it('Feature can be skipped', () => { - suiteConfig = context.Feature.skip('skipped suite'); - expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true'); - expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.'); - expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo'); - }); + suiteConfig = context.Feature.skip('skipped suite') + expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true') + expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.') + expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo') + }) it('Feature can be skipped via xFeature', () => { - suiteConfig = context.xFeature('skipped suite'); - expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true'); - expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.'); - expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo'); - }); + suiteConfig = context.xFeature('skipped suite') + expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true') + expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.') + expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo') + }) it('Feature are not skipped by default', () => { - suiteConfig = context.Feature('not skipped suite'); - expect(suiteConfig.suite.pending).eq(false, 'Feature must not contain pending === true'); - expect(suiteConfig.suite.opts).to.deep.eq({}, 'Features should have no skip info'); - }); + suiteConfig = context.Feature('not skipped suite') + expect(suiteConfig.suite.pending).eq(false, 'Feature must not contain pending === true') + expect(suiteConfig.suite.opts).to.deep.eq({}, 'Features should have no skip info') + }) it('Feature should correctly pass options to suite context', () => { - suiteConfig = context.Feature('not skipped suite', { key: 'value' }); - expect(suiteConfig.suite.opts).to.deep.eq({ key: 'value' }, 'Features should have passed options'); - }); - }); + suiteConfig = context.Feature('not skipped suite', { key: 'value' }) + expect(suiteConfig.suite.opts).to.deep.eq({ key: 'value' }, 'Features should have passed options') + }) + }) describe('Scenario', () => { - let scenarioConfig; + let scenarioConfig it('Scenario should return scenarioConfig', () => { - scenarioConfig = context.Scenario('basic scenario'); - expect(scenarioConfig.test).is.ok; - }); + scenarioConfig = context.Scenario('basic scenario') + expect(scenarioConfig.test).is.ok + }) it('should contain title', () => { - context.Feature('suite'); - scenarioConfig = context.Scenario('scenario'); - expect(scenarioConfig.test.title).eq('scenario'); - expect(scenarioConfig.test.fullTitle()).eq('suite: scenario'); - expect(scenarioConfig.test.tags.length).eq(0); - }); + context.Feature('suite') + scenarioConfig = context.Scenario('scenario') + expect(scenarioConfig.test.title).eq('scenario') + expect(scenarioConfig.test.fullTitle()).eq('suite: scenario') + expect(scenarioConfig.test.tags.length).eq(0) + }) it('should contain tags', () => { - context.Feature('basic suite @cool'); + context.Feature('basic suite @cool') - scenarioConfig = context.Scenario('scenario @very @important'); + scenarioConfig = context.Scenario('scenario @very @important') - scenarioConfig.test.tags.should.include('@cool'); - scenarioConfig.test.tags.should.include('@very'); - scenarioConfig.test.tags.should.include('@important'); + scenarioConfig.test.tags.should.include('@cool') + scenarioConfig.test.tags.should.include('@very') + scenarioConfig.test.tags.should.include('@important') - scenarioConfig.tag('@user'); - scenarioConfig.test.tags.should.include('@user'); - }); + scenarioConfig.tag('@user') + scenarioConfig.test.tags.should.include('@user') + }) it('should dynamically inject dependencies', () => { - scenarioConfig = context.Scenario('scenario'); - scenarioConfig.injectDependencies({ Data: 'data' }); - expect(scenarioConfig.test.inject.Data).eq('data'); - }); + scenarioConfig = context.Scenario('scenario') + scenarioConfig.injectDependencies({ Data: 'data' }) + expect(scenarioConfig.test.inject.Data).eq('data') + }) describe('todo', () => { it('should inject skipInfo to opts', () => { scenarioConfig = context.Scenario.todo('scenario', () => { - console.log('Scenario Body'); - }); + console.log('Scenario Body') + }) - expect(scenarioConfig.test.pending).eq(true, 'Todo Scenario must be contain pending === true'); - expect(scenarioConfig.test.opts.skipInfo.message).eq('Test not implemented!'); - expect(scenarioConfig.test.opts.skipInfo.description).to.include("console.log('Scenario Body')"); - }); + expect(scenarioConfig.test.pending).eq(true, 'Todo Scenario must be contain pending === true') + expect(scenarioConfig.test.opts.skipInfo.message).eq('Test not implemented!') + expect(scenarioConfig.test.opts.skipInfo.description).to.include("console.log('Scenario Body')") + }) it('should contain empty description in skipInfo and empty body', () => { - scenarioConfig = context.Scenario.todo('scenario'); + scenarioConfig = context.Scenario.todo('scenario') - expect(scenarioConfig.test.pending).eq(true, 'Todo Scenario must be contain pending === true'); - expect(scenarioConfig.test.opts.skipInfo.description).eq(''); - expect(scenarioConfig.test.body).eq(''); - }); + expect(scenarioConfig.test.pending).eq(true, 'Todo Scenario must be contain pending === true') + expect(scenarioConfig.test.opts.skipInfo.description).eq('') + expect(scenarioConfig.test.body).eq('') + }) it('should inject custom opts to opts and without callback', () => { - scenarioConfig = context.Scenario.todo('scenario', { customOpts: 'Custom Opts' }); + scenarioConfig = context.Scenario.todo('scenario', { customOpts: 'Custom Opts' }) - expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts'); - }); + expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts') + }) it('should inject custom opts to opts and with callback', () => { scenarioConfig = context.Scenario.todo('scenario', { customOpts: 'Custom Opts' }, () => { - console.log('Scenario Body'); - }); + console.log('Scenario Body') + }) - expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts'); - }); - }); + expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts') + }) + }) describe('skip', () => { it('should inject custom opts to opts and without callback', () => { - scenarioConfig = context.Scenario.skip('scenario', { customOpts: 'Custom Opts' }); + scenarioConfig = context.Scenario.skip('scenario', { customOpts: 'Custom Opts' }) - expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts'); - }); + expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts') + }) it('should inject custom opts to opts and with callback', () => { scenarioConfig = context.Scenario.skip('scenario', { customOpts: 'Custom Opts' }, () => { - console.log('Scenario Body'); - }); - - expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts'); - }); - }); - }); -}); + console.log('Scenario Body') + }) + + expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts') + }) + }) + }) +})