pending.spec.js

'use strict';

var assert = require('assert');
var run = require('./helpers').runMochaJSON;
var runMocha = require('./helpers').runMocha;
var splitRegExp = require('./helpers').splitRegExp;
var args = [];

describe('pending', function() {
  describe('pending specs', function() {
    it('should be created by omitting a function', function(done) {
      run('pending/spec.fixture.js', args, function(err, res) {
        if (err) {
          done(err);
          return;
        }
        assert.strictEqual(res.stats.pending, 1);
        assert.strictEqual(res.stats.passes, 0);
        assert.strictEqual(res.stats.failures, 0);
        assert.strictEqual(res.code, 0);
        done();
      });
    });
    it('should return the test object when used via shorthand methods', function(done) {
      run('pending/skip-shorthand.fixture.js', args, function(err, res) {
        if (err) {
          done(err);
          return;
        }
        assert.strictEqual(res.stats.pending, 3);
        assert.strictEqual(res.stats.passes, 0);
        assert.strictEqual(res.stats.failures, 0);
        assert.strictEqual(res.code, 0);
        done();
      });
    });
    it('should keep hierarchies of suites', function(done) {
      run('pending/skip-hierarchy.fixture.js', args, function(err, res) {
        if (err) {
          done(err);
          return;
        }
        assert.strictEqual(res.stats.suites, 2);
        assert.strictEqual(res.stats.pending, 0);
        assert.strictEqual(res.stats.passes, 1);
        assert.strictEqual(res.stats.failures, 0);
        assert.strictEqual(res.code, 0);
        assert.strictEqual(
          res.passes[0].fullTitle,
          'a suite another suite a test'
        );
        done();
      });
    });
  });

  describe('synchronous skip()', function() {
    describe('in spec', function() {
      it('should immediately skip the spec and run all others', function(done) {
        run('pending/skip-sync-spec.fixture.js', args, function(err, res) {
          if (err) {
            return done(err);
          }
          expect(res, 'to have failed with error', 'should throw this error')
            .and('to have failed test count', 1)
            .and('to have pending test count', 1)
            .and('to have pending test order', 'should skip immediately')
            .and('to have passed test count', 1)
            .and('to have passed tests', 'should run other tests in suite');
          done();
        });
      });
    });

    describe('in after', function() {
      it('should run all tests', function(done) {
        runMocha(
          'pending/skip-sync-after.fixture.js',
          args,
          function(err, res) {
            if (err) {
              return done(err);
            }
            expect(res, 'to have passed').and('to satisfy', {
              passing: 3,
              failing: 0,
              pending: 0,
              output: expect.it('to contain', '"after all" hook is DEPRECATED')
            });
            done();
          },
          'pipe'
        );
      });
    });

    describe('in before', function() {
      it('should skip all suite specs', function(done) {
        run('pending/skip-sync-before.fixture.js', args, function(err, res) {
          if (err) {
            done(err);
            return;
          }
          assert.strictEqual(res.stats.pending, 2);
          assert.strictEqual(res.stats.passes, 2);
          assert.strictEqual(res.stats.failures, 0);
          assert.strictEqual(res.code, 0);
          done();
        });
      });
      it('should run before and after hooks', function(done) {
        runMocha(
          'pending/skip-sync-before-hooks.fixture.js',
          args.concat(['--reporter', 'dot']),
          function(err, res) {
            if (err) {
              done(err);
              return;
            }

            var lines = res.output
              .split(splitRegExp)
              .map(function(line) {
                return line.trim();
              })
              .filter(function(line) {
                return line.length;
              })
              .slice(0, -1);

            var expected = [
              'outer before',
              'inner before',
              'inner after',
              'outer after'
            ];

            assert.strictEqual(res.pending, 2);
            assert.strictEqual(res.passing, 2);
            assert.strictEqual(res.failing, 0);
            assert.strictEqual(res.code, 0);
            expected.forEach(function(line, i) {
              assert.strictEqual(true, lines[i].includes(line));
            });

            done();
          }
        );
      });
    });

    describe('in before with nested describe', function() {
      it('should skip all suite specs, even if nested', function(done) {
        run('pending/skip-sync-before-nested.fixture.js', args, function(
          err,
          res
        ) {
          if (err) {
            done(err);
            return;
          }
          assert.strictEqual(res.stats.pending, 3);
          assert.strictEqual(res.stats.passes, 0);
          assert.strictEqual(res.stats.failures, 0);
          assert.strictEqual(res.code, 0);
          done();
        });
      });
    });

    describe('in beforeEach', function() {
      it('should skip all suite specs', function(done) {
        run('pending/skip-sync-beforeEach.fixture.js', args, function(
          err,
          res
        ) {
          if (err) {
            done(err);
            return;
          }
          assert.strictEqual(res.stats.pending, 2);
          assert.strictEqual(res.stats.passes, 0);
          assert.strictEqual(res.stats.failures, 0);
          assert.strictEqual(res.code, 0);
          done();
        });
      });
    });
  });

  describe('asynchronous skip()', function() {
    describe('in spec', function() {
      it('should immediately skip the spec and run all others', function(done) {
        run('pending/skip-async-spec.fixture.js', args, function(err, res) {
          if (err) {
            return done(err);
          }
          expect(res, 'to have failed with error', 'should throw this error')
            .and('to have failed test count', 1)
            .and('to have pending test count', 1)
            .and('to have pending test order', 'should skip async')
            .and('to have passed test count', 1)
            .and('to have passed tests', 'should run other tests in suite');
          done();
        });
      });
    });

    describe('in before', function() {
      it('should skip all suite specs', function(done) {
        run('pending/skip-async-before.fixture.js', args, function(err, res) {
          if (err) {
            done(err);
            return;
          }
          assert.strictEqual(res.stats.pending, 2);
          assert.strictEqual(res.stats.passes, 2);
          assert.strictEqual(res.stats.failures, 0);
          assert.strictEqual(res.code, 0);
          done();
        });
      });
      it('should run before and after hooks', function(done) {
        runMocha(
          'pending/skip-async-before-hooks.fixture.js',
          args.concat(['--reporter', 'dot']),
          function(err, res) {
            if (err) {
              done(err);
              return;
            }

            var lines = res.output
              .split(splitRegExp)
              .map(function(line) {
                return line.trim();
              })
              .filter(function(line) {
                return line.length;
              })
              .slice(0, -1);

            var expected = [
              'outer before',
              'inner before',
              'inner after',
              'outer after'
            ];

            assert.strictEqual(res.pending, 2);
            assert.strictEqual(res.passing, 2);
            assert.strictEqual(res.failing, 0);
            assert.strictEqual(res.code, 0);
            expected.forEach(function(line, i) {
              assert.strictEqual(true, lines[i].includes(line));
            });

            done();
          }
        );
      });
    });

    describe('in before with nested describe', function() {
      it('should skip all suite specs, even if nested', function(done) {
        run('pending/skip-async-before-nested.fixture.js', args, function(
          err,
          res
        ) {
          if (err) {
            done(err);
            return;
          }
          assert.strictEqual(res.stats.pending, 3);
          assert.strictEqual(res.stats.passes, 0);
          assert.strictEqual(res.stats.failures, 0);
          assert.strictEqual(res.code, 0);
          done();
        });
      });
    });

    describe('in beforeEach', function() {
      it('should skip all suite specs', function(done) {
        var fixture = 'pending/skip-async-beforeEach.fixture.js';
        run(fixture, args, function(err, res) {
          if (err) {
            return done(err);
          }
          expect(res, 'to have passed')
            .and('to have passed test count', 0)
            .and('to have pending test count', 3)
            .and(
              'to have pending test order',
              'should skip this test-1',
              'should skip this test-2',
              'should skip this test-3'
            )
            .and('to have failed test count', 0);
          done();
        });
      });
    });
  });
});