feat: add tests

Author: rocketraccoon

test/src/cli/commands/list-tests/index.ts

@@ -120,6 +120,14 @@ describe("cli/commands/list-tests", () => {
             });
         });
 
+        it("should use tag from cli", async () => {
+            await listTests_("--tag smoke");
+
+            assert.calledWithMatch(Testplane.prototype.readTests as SinonStub, sinon.match.any, {
+                tag: sinon.match.instanceOf(Function),
+            });
+        });
+
         it("should use ignore paths from cli", async () => {
             await listTests_("--ignore first --ignore second");
 

test/src/cli/index.js

@@ -144,6 +144,28 @@ describe("cli", () => {
         assert.calledWithMatch(Testplane.prototype.run, any, { browsers: ["first", "second"] });
     });
 
+    describe("tag", () => {
+        it("should not pass any grep rule if it was not specified from cli", async () => {
+            await run_();
+
+            assert.calledWithMatch(Testplane.prototype.run, any, { tag: undefined });
+        });
+
+        it("should use tag rule from cli", async () => {
+            await run_("--tag foo");
+
+            console.log("Testplane.prototype.run.firstCall.args", Testplane.prototype.run.firstCall.args);
+
+            assert.instanceOf(Testplane.prototype.run.firstCall.args[1].tag, Function);
+        });
+
+        it("should warn about invalid regex", async () => {
+            await run_("--tag foo&bar");
+
+            assert.calledOnceWith(loggerWarnStub, sinon.match("(foo|bar"));
+        });
+    });
+
     describe("grep", () => {
         it("should not pass any grep rule if it was not specified from cli", async () => {
             await run_();

test/src/test-reader/index.js

@@ -18,6 +18,7 @@ describe("test-reader", () => {
             ignore: [],
             browsers: [],
             grep: undefined,
+            tag: undefined,
         });
 
         config = config || makeConfigStub();
@@ -247,6 +248,7 @@ describe("test-reader", () => {
                 { name: "ignore", value: "ignore1", expectedMsg: "- ignore: ignore1\n" },
                 { name: "sets", value: ["set1", "set2"], expectedMsg: "- sets: set1, set2\n" },
                 { name: "grep", value: "grep1", expectedMsg: "- grep: grep1\n" },
+                { name: "tag", value: "tag_one", expectedMsg: "- tag: tag_one\n" },
             ].forEach(({ name, value, expectedMsg }) => {
                 it(`should correctly print passed option ${name}`, async () => {
                     try {
@@ -277,7 +279,10 @@ describe("test-reader", () => {
             });
 
             it("should print supported options if none are specified", async () => {
-                await assert.isRejected(readTests_(), "Try to specify [paths, sets, ignore, browsers, grep] options");
+                await assert.isRejected(
+                    readTests_(),
+                    "Try to specify [paths, sets, ignore, browsers, grep, tag] options",
+                );
             });
 
             it("should throw error if there are only silently skipped tests", async () => {

test/src/test-reader/test-parser.js

@@ -15,6 +15,7 @@ const path = require("path");
 const { EventEmitter } = require("events");
 const _ = require("lodash");
 const fs = require("fs-extra");
+const { compileTagFilter } = require("src/utils/cli");
 
 const { NEW_BUILD_INSTRUCTION } = TestReaderEvents;
 
@@ -515,7 +516,7 @@ describe("test-reader/test-parser", () => {
     });
 
     describe("parse", () => {
-        const parse_ = async ({ files, browserId, config, grep } = {}, loadFilesConfig) => {
+        const parse_ = async ({ files, browserId, config, grep, tag } = {}, loadFilesConfig) => {
             loadFilesConfig = loadFilesConfig || makeConfigStub();
             config = _.defaults(config, {
                 desiredCapabilities: {},
@@ -524,7 +525,7 @@ describe("test-reader/test-parser", () => {
             const parser = new TestParser();
             await parser.loadFiles([], { config: loadFilesConfig });
 
-            return parser.parse(files || [], { browserId, config, grep });
+            return parser.parse(files || [], { browserId, config, grep, tag });
         };
 
         beforeEach(() => {
@@ -616,6 +617,76 @@ describe("test-reader/test-parser", () => {
             });
         });
 
+        describe("tag", () => {
+            it("should not set test filter to tree builder if grep not set", async () => {
+                await parse_();
+
+                assert.notCalled(TreeBuilder.prototype.addTestFilter);
+            });
+
+            describe("if set", () => {
+                it("should set test filter to tree builder", async () => {
+                    await parse_({ tag: compileTagFilter("smoke") });
+
+                    assert.calledOnceWith(TreeBuilder.prototype.addTestFilter, sinon.match.func);
+                });
+
+                it("should set test filter to tree builder before applying filters", async () => {
+                    await parse_({ tag: compileTagFilter("smoke") });
+
+                    assert.callOrder(TreeBuilder.prototype.addTestFilter, TreeBuilder.prototype.applyFilters);
+                });
+
+                it("installed filter should accept matched test", async () => {
+                    await parse_({ tag: compileTagFilter("smoke") });
+
+                    const filter = TreeBuilder.prototype.addTestFilter.lastCall.args[0];
+                    const test = { fullTitle: () => "Some name", tag: new Map([["smoke", false]]) };
+
+                    assert.isTrue(filter(test));
+                });
+
+                it("installed filter should accept matched test with and operator for tags", async () => {
+                    await parse_({ tag: compileTagFilter("smoke&slow") });
+
+                    const filter = TreeBuilder.prototype.addTestFilter.lastCall.args[0];
+                    const test = {
+                        fullTitle: () => "Some name",
+                        tag: new Map([
+                            ["smoke", false],
+                            ["slow", false],
+                        ]),
+                    };
+
+                    assert.isTrue(filter(test));
+                });
+
+                it("installed filter should accept matched test with or operator for tags", async () => {
+                    await parse_({ tag: compileTagFilter("smoke|slow") });
+
+                    const filter = TreeBuilder.prototype.addTestFilter.lastCall.args[0];
+                    const test = {
+                        fullTitle: () => "Some name",
+                        tag: new Map([
+                            ["smoke", false],
+                            ["fast", false],
+                        ]),
+                    };
+
+                    assert.isTrue(filter(test));
+                });
+
+                it("installed filter should ignore not matched test", async () => {
+                    await parse_({ tag: compileTagFilter("desktop") });
+
+                    const filter = TreeBuilder.prototype.addTestFilter.lastCall.args[0];
+                    const test = { fullTitle: () => "Some name", tag: new Map([["smoke", false]]) };
+
+                    assert.isFalse(filter(test));
+                });
+            });
+        });
+
         describe("grep", () => {
             it("should not set test filter to tree builder if grep not set", async () => {
                 await parse_();

test/src/testplane.js

@@ -342,6 +342,7 @@ describe("testplane", () => {
                 const testPaths = ["foo/bar"];
                 const browsers = ["bro1", "bro2"];
                 const grep = "baz.*";
+                const tag = "baz";
                 const sets = ["set1", "set2"];
                 const replMode = { enabled: false };
                 const keepBrowserMode = { enabled: false };
@@ -351,6 +352,7 @@ describe("testplane", () => {
                 await runTestplane(testPaths, {
                     browsers,
                     grep,
+                    tag,
                     sets,
                     replMode,
                     keepBrowserMode,
@@ -362,7 +364,7 @@ describe("testplane", () => {
                     sets,
                     replMode,
                     keepBrowserMode,
-                    tag: undefined,
+                    tag,
                 });
             });
 
@@ -669,6 +671,7 @@ describe("testplane", () => {
                 ignore: "baz/qux",
                 sets: ["s1", "s2"],
                 grep: "grep",
+                tag: "tag_one",
                 replMode: { enabled: false },
                 keepBrowserMode: { enabled: false, onFail: false },
                 runnableOpts: {
@@ -682,12 +685,12 @@ describe("testplane", () => {
                 ignore: "baz/qux",
                 sets: ["s1", "s2"],
                 grep: "grep",
+                tag: "tag_one",
                 replMode: { enabled: false },
                 keepBrowserMode: { enabled: false, onFail: false },
                 runnableOpts: {
                     saveLocations: true,
                 },
-                tag: undefined,
             });
         });