From e9620a4dfe1bbdac5a4f207624362fb8da841c9d Mon Sep 17 00:00:00 2001
From: Sergei Chipiga <chipiga86@gmail.com>
Date: Thu, 2 Aug 2018 20:48:54 +0300
Subject: [PATCH] Refactor pass reporter and cover with tests #169

---
 lib/reporter/base.js           | 44 ++++++++--------
 tests/unit/testReporterBase.js | 96 ++++++++++++++++++++++++++++++++++
 2 files changed, 119 insertions(+), 21 deletions(-)

diff --git a/lib/reporter/base.js b/lib/reporter/base.js
index 4abe4d15..343c833d 100644
--- a/lib/reporter/base.js
+++ b/lib/reporter/base.js
@@ -108,27 +108,7 @@ const GlaceReporter = function (runner) {
     });
 
     runner.on("fail", (mochaTest, err) => {
-        if (CONF.test.curCase) {
-            let errMsg = mochaTest.title;
-
-            if (!_.isEmpty(CONF.test.curCase.testParams)) {
-                errMsg += "\n" + util.format(CONF.test.curCase.testParams);
-            }
-            if (err.message) {
-                errMsg += "\nmessage: " + err.message;
-            }
-            if (err.stack) {
-                errMsg += "\nstack: " + err.stack;
-            }
-            if (err.seleniumStack) {
-                errMsg += "\nselenium: " + JSON.stringify(err.seleniumStack,
-                    null, "\t");
-            }
-
-            CONF.test.curCase.addError(errMsg);
-        } else {
-            CONF.session.isPassed = false; // error happened before/between tests and session should be marked as failed
-        }
+        accountError(mochaTest.title, err);
 
         for (const reporter of reporters) {
             if (reporter.fail) reporter.fail(mochaTest, err);
@@ -219,3 +199,25 @@ const handleSkipState = mochaTest => {
     mochaTest.state = "skipped";
     CONF.test.curCase.skipChunk = null;
 };
+
+const accountError = (errMsg, err) => {
+    if (!CONF.test.curCase) {
+        CONF.session.isPassed = false; // error happened before/between tests and session should be marked as failed
+        return;
+    }
+
+    if (!_.isEmpty(CONF.test.curCase.testParams)) {
+        errMsg += "\n" + util.format(CONF.test.curCase.testParams);
+    }
+    if (err.message) {
+        errMsg += "\nmessage: " + err.message;
+    }
+    if (err.stack) {
+        errMsg += "\nstack: " + err.stack;
+    }
+    if (err.seleniumStack) {
+        errMsg += "\nselenium: " + JSON.stringify(err.seleniumStack, null, "\t");
+    }
+
+    CONF.test.curCase.addError(errMsg);
+};
diff --git a/tests/unit/testReporterBase.js b/tests/unit/testReporterBase.js
index 36f25b22..15cec502 100644
--- a/tests/unit/testReporterBase.js
+++ b/tests/unit/testReporterBase.js
@@ -298,6 +298,62 @@ suite("reporter/base", () => {
         });
     });
 
+    test("on fail", () => {
+        let onFail, reporters, accountError, conf;
+
+        beforeChunk(() => {
+            onFail = methods["fail"];
+
+            reporters = [];
+            GlaceReporter.__set__("reporters", reporters);
+
+            conf = {
+                session: {
+                },
+            };
+            GlaceReporter.__set__("CONF", conf);
+
+            accountError = sinon.spy();
+            GlaceReporter.__set__("accountError", accountError);
+        });
+
+        afterChunk(() => {
+            delete runner.emit;
+        });
+
+        chunk("calls reporters 'fail' method if it exists", () => {
+            reporters.push({ fail: sinon.spy() });
+            onFail({ title: "my chunk" }, "error");
+
+            expect(accountError).to.be.calledOnce;
+            expect(accountError.args[0][0]).to.be.equal("my chunk");
+            expect(accountError.args[0][1]).to.be.equal("error");
+
+            expect(reporters[0].fail).to.be.calledOnce;
+            expect(reporters[0].fail.args[0][0]).to.be.eql({ title: "my chunk" });
+            expect(reporters[0].fail.args[0][1]).to.be.equal("error");
+        });
+
+        chunk("fails session immediately if flag is set", () => {
+            conf.session.exitOnFail = true;
+            conf.test = {
+                curCase: {
+                    end: sinon.spy(),
+                },
+            };
+
+            runner.emit = sinon.spy();
+
+            onFail({ title: "my chunk" }, "error");
+
+            expect(conf.test.curCase.end).to.be.calledOnce;
+            expect(conf.test.curCase.end.args[0][0]).to.be.equal("failed");
+
+            expect(runner.emit).to.be.calledOnce;
+            expect(runner.emit.args[0][0]).to.be.equal("end");
+        });
+    });
+
     test("on pending", () => {
         let onPending;
 
@@ -543,4 +599,44 @@ suite("reporter/base", () => {
             expect(conf.test.curCase.skipChunk).to.be.null;
         });
     });
+
+    test("accountError()", () => {
+        let accountError, conf;
+
+        beforeChunk(() => {
+            accountError = GlaceReporter.__get__("accountError");
+
+            conf = {
+                test: {},
+                session: {},
+            };
+            GlaceReporter.__set__("CONF", conf);
+        });
+
+        chunk("marks session as failed if no tests", () => {
+            accountError("my chunk", "error");
+            expect(conf.session.isPassed).to.be.false;
+        });
+
+        chunk("logs test error if tests are present", () => {
+            conf.test.curCase = {
+                addError: sinon.spy(),
+                testParams: { lang: "ru" },
+            };
+
+            accountError("my chunk", {
+                message: "error message",
+                stack: "error stack",
+                seleniumStack: { "selenium": "error" },
+            });
+
+            expect(conf.test.curCase.addError).to.be.calledOnce;
+
+            const errMsg = conf.test.curCase.addError.args[0][0];
+            expect(errMsg).to.startWith("my chunk");
+            expect(errMsg).to.include("lang");
+            expect(errMsg).to.include("error stack");
+            expect(errMsg).to.include("selenium");
+        });
+    });
 });