10 examples of 'your test suite must contain at least one test' in JavaScript

7
static test(test) {
8
    TestRunner.tests.push(test);
9
}

50
function filterOutTests(suite) {
51
  suite.tests = suite.tests.filter(test => filters.every(f => f.filter(test)));
52
  suite.suites.forEach(suite => filterOutTests(suite));
53
}

65
function getFailedTests(suite) {
66
    return suite.tests.filter(isFailedTest);
67
}

10
function TestSuite() {
11
  TestSuite.super.apply(this, arguments);
12
13
  var moduleNames = {};
14
  this.props.harness.getTests().forEach(function(t) {
15
    if (t.moduleName) {
16
      moduleNames[t.moduleName] = true;
17
    }
18
  });
19
  this.moduleNames = Object.keys(moduleNames);
20
}

125
_splitTest(testFile: string) : TestFile[]{
126
  return null;
127
}

43
function fastest(suite) {
44
  return suite.filter('fastest').pluck('name') }

24
_splitTest(testFile: string) {
25
  super._splitTest(testFile);
26
  var testFileContent = this._fileUtils.readFile(testFile);
27
  var ast = this._parserUtils.parse(testFileContent);
28
  var nodes = this._parserUtils.getNodesWithType(ast, ['ExpressionStatement']);
29
  var testFiles: TestFile[] = [];
30
31
  _.forEach(nodes, (astNode: any, index: any) => {
32
    if (astNode.node.expression.callee && astNode.node.expression.callee.name === 'it') {
33
      var astNodesLeft = _.dropRight(nodes, nodes.length - index);
34
      this._removeItsFromParent(astNodesLeft);
35
      var astNodesRight = _.drop(nodes, index + 1);
36
      this._removeItsFromParent(astNodesRight);
37
38
      var testCode = this._parserUtils.generate(ast);
39
      var describes = _.filter(astNodesLeft, (astNode: any) => {
40
        return astNode.node.expression.callee && astNode.node.expression.callee.name === 'describe';
41
      });
42
      var testFilename = this._generateTestName(astNode, describes);
43
      testFiles.push(new TestFile(testFilename, testCode));
44
45
      _.forEach(nodes, (expressionStatement: any, index: any) => {
46
        if (expressionStatement !== astNode) {
47
          var parent = expressionStatement.parent;
48
          if (parent instanceof Object && !(parent instanceof Array)) {
49
            parent[expressionStatement.key] = expressionStatement.node;
50
          } else if (_.indexOf(parent, expressionStatement.node) < 0) {
51
            parent.splice(expressionStatement.key, 0, expressionStatement.node);
52
          }
53
        }
54
      });
55
    }
56
  });
57
58
  return testFiles;
59
};

85
private async runTestcases(name: string, testCases: { [name: string]: Function }, logger?: Logger): Promise<Report> {
86
    const report = new CompositeReport(name, logger);
87
88
    if (logger) { logger.increaseIndentation(); }
89
    for (const testCaseName in testCases) {
90
        const testCase = testCases[testCaseName];
91
        const testReport = await this.runTest(testCaseName, testCase, logger);
92
        report.addReport(testReport);
93
    }
94
    if (logger) { logger.decreaseIndentation(); }
95
96
    return report;
97
}

47
function runTestSuite(parentTest, tests, suiteCompleteCallback) {
48
	if (!tests.length) {
49
		//completed successfully
50
		suiteCompleteCallback();
51
		return;
52
	}
53
54
	var self = this;
55
56
	parentTest.tearDown(function(err) {
57
		if (err) {
58
			suiteCompleteCallback(err);
59
			return;
60
		}
61
62
		parentTest.setup(function(err) {
63
			if (err) {
64
				suiteCompleteCallback(err);
65
				return;
66
			}
67
			
68
			self.run(tests.shift(), parentTest.id /* parentId */, function(err) {
69
				if (err) {
70
					suiteCompleteCallback(err);
71
					return;
72
				}
73
74
				parentTest.tearDown(function(err) {
75
					if (err) {
76
						suiteCompleteCallback(err);
77
						return;
78
					}
79
					
80
					runTestSuite.call(self, parentTest, tests, suiteCompleteCallback);
81
				});
82
			});
83
		});
84
	});
85
}

112
onTest (mochaTest) {
113
  this.errors = []
114
115
  this.emit('testStart', this.convertTest(mochaTest))
116
}