UNPKG

kocha

Version:

Modern, simpler Mocha clone, no globals, lint friendly

103 lines (82 loc) 4.28 kB
'use strict'; var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } var TestRunnableNode = require('./test-runnable-node'); var EVENT_START = 'test'; var EVENT_END = 'test end'; var EVENT_PASS = 'pass'; var EVENT_PENDING = 'pending'; var TestCase = function (_TestRunnableNode) { _inherits(TestCase, _TestRunnableNode); /** * @param {string} title The title of the test case * @param {Function} test The function which implements the test case * @param {boolean} skipped True iff the case is skipped * @param {TestSuite} parent The parent suite */ function TestCase(title, test, skipped, parent) { _classCallCheck(this, TestCase); var _this = _possibleConstructorReturn(this, (TestCase.__proto__ || Object.getPrototypeOf(TestCase)).call(this, title, test, skipped, parent)); _this.type = 'test'; _this.passed = false; _this.pending = false; return _this; } _createClass(TestCase, [{ key: 'pass', value: function pass() { if (this.failed) { // If it's already failed then, do not pass it return; } this.passed = true; this.state = 'passed'; this.bubbleEvent(EVENT_PASS, this); } }, { key: 'skip', value: function skip() { this.pending = true; this.state = 'pending'; this.bubbleEvent(EVENT_PENDING, this); } /** * Runs the test case. * @return {Promise|undefined} */ }, { key: 'run', value: function run() { var _this2 = this; this.bubbleEvent(EVENT_START, this); this.start(); if (this.isSkipped()) { this.end(); this.skip(); this.bubbleEvent(EVENT_END, this); return Promise.resolve(); } return this.parent.runBeforeEachHooks().then(function (passed) { if (!passed) { return; } return _get(TestCase.prototype.__proto__ || Object.getPrototypeOf(TestCase.prototype), 'run', _this2).call(_this2).then(function () { _this2.end(); _this2.pass(); }, function (e) { _this2.end(); _this2.fail(e); }); }).then(function () { return _this2.bubbleEvent(EVENT_END, _this2); }).then(function () { return _this2.parent.runAfterEachHooks(); }); } }]); return TestCase; }(TestRunnableNode); module.exports = TestCase;