@bucky24/jsbehave 0.12.9 → 0.13.1

package/README.md

@@ -9,23 +9,77 @@ In order to use this, you must have the webdriver for your chosen browser access
 
 Running `jsbehave` directly will locate all files that end in `.behave` and will run them.
 
+## Blocks
+
+### Test Block
+
+Defines a block of operations that runs when the test framework is triggered.
+
+```
+[test <test name>]
+...
+[endtest]
+```
+
+### Action Block
+
+Defines an Action. This is similar to a test in that it is a block of operations. Actions are not run automatically, however, and require a specific Operation to run them.
+
+```
+[action <action name>]`
+...
+[endaction]
+```
+
+### Before and After blocks
+
+Code in these blocks looks like the following:
+
+```
+[before all]
+open chrome
+[endbefore]
+
+[before each]
+reload page
+[endbefore]
+
+[test blah]
+
+[endtest]
+
+[after each]
+# cleanup
+[endafter]
+
+[after all]
+close browser
+[endafter]
+```
+
+`[before all]` blocks will run before all the tests. `[before each]` runs before each test. `[after each]` runs after each test, and `[after all]` runs after all the tests are done. This is similar to most other test systems.
+
 ## Operations
 
 `open <browser>` (note the name for this browser is `default`)
 
+`open <browser> as <name>` - opens a new browser and attaches its session to the given name
+
+`set active browser to <name>` - sets the current active browser (the one that operations will be run on)
+
+`close browser` - closes the active browser
+
+`close browser <name>` - closes browser with given name
+
 `navigate to <url>`
 
 `type <text> into <selector>`
 
 `wait for title to be <text>`
 
-`[test <string>]`
-
-`[endtest]`
-
 `click <selector>`
 
-`sleep <number>`
+`sleep <number of seconds, can be fractional>`
 
 `wait until located <selector>`
 
@@ -37,39 +91,29 @@ Running `jsbehave` directly will locate all files that end in `.behave` and will
 
 `expect element <selector> to not exist`
 
-`close browser`
-
 `reload page`
 
-`require test <test name>` runs the test only if it has not already been run
+`require test <test name>` - runs the test only if it has not already been run
 
 `expect elements <selector> to have count of <count>`
 
 `expect variable <variable> to match <text>`
 
-`open <browser> as <name>`
-
-`close browser <name>`
-
-`set active browser to <name>`
-
 `expect element <selector> to have content <text>`
 
 `set variable <variable name> to <text>`
 
 `concat variable <variable name> with <text>`
 
-`run test <test name>` runs the test regardless if it has been run before
-
-`[action <action name>]`
+`concat variables <variable name> and <variable name>` - concats two variables, storing the result in the first variable
 
-`[endaction]`
+`run test <test name>` - runs the test regardless if it has been run before
 
-`run action <action name>` runs the given action
+`run action <action name>` - runs the given action
 
-`switch to window <index>` switches context to the window handle at the index (useful for popups)
+`switch to window <index>` - switches context to the window handle at the index (useful for popups)
 
-`read content from element <selector> into variable <variable name>` Takes the value or inner html from the element and stores it in the given variable
+`read content from element <selector> into variable <variable name>` - Takes the value or inner html from the element and stores it in the given variable
 
 ## Tests
 
@@ -134,51 +178,6 @@ The following are configs that the jsbehave system will use for various operatio
 | screenshotDirectory | The directory where screenshots will be saved. Defaults to `.` |
 | screenshotOnFailure | Boolean. If true (default), takes a screenshot when the test fails. |
 
-## Before and After blocks
-
-Code in these blocks looks like the following:
-
-```
-[before all]
-open chrome
-[endbefore]
-
-[before each]
-reload page
-[endbefore]
-
-[test blah]
-
-[endtest]
-
-[after each]
-# cleanup
-[endafter]
-
-[after all]
-close browser
-[endafter]
-```
-
-`[before all]` blocks will run before all the tests. `[before each]` runs before each test. `[after each]` runs after each test, and `[after all]` runs after all the tests are done. This is similar to most other test systems.
-
-## Action blocks
-
-Code in these blocks looks like the following:
-```
-[action some action]
-open chrome
-[endaction]
-```
-
-These actions are identical to test blocks, except they are not automatically run when tests are run. They can be run as follows:
-
-```
-[test a test]
-run action some action
-[endtest]
-```
-
 ## Custom code
 
 In order to load custom code, put `load funcs <filename>` in your test file. Functions can be async.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bucky24/jsbehave",
-    "version": "0.12.9",
+    "version": "0.13.1",
     "description": "A module that allows BDD testing for browser based testing in Selenium.",
     "main": "src/index.js",
     "scripts": {

package/src/index.js

@@ -22,6 +22,7 @@ if (process.argv.length > 2) {
         .filter(e => {
             return e.isFile() && e.name.endsWith(".behave");
         })
+        .filter(e => !e.path.includes('node_modules'))
         .map(e => path.join(e.path, e.name));
 }
 
@@ -251,7 +252,7 @@ function closeBrowser() {
     const activeBrowser = getVariable("jsbehave.active_driver");
     const driver = getVariable(`jsbehave.driver.${activeBrowser}`);
     if (!driver) {
-        throw new Error("Unable to close default browser: no driver found");
+        throw new Error("Unable to close active browser: no driver found");
     }
     delete variables[`jsbehave.driver.${activeBrowser}`];
     return driver.close();
@@ -268,15 +269,18 @@ async function noop() {
 
 async function runTest(name, showTitle=false) {
     for (const before of beforeEach) {
-        await handleLines(before);
+        const result = await handleLines(before);
+        if (!result) return false;
     }
     if (showTitle) {
         console.log("Running '" + name + "'");
     }
     const content = allTests[name];
-    await handleLines(content);
+    const result = await handleLines(content);
+    if (!result) return false;
     for (const after of afterEach) {
-        await handleLines(after);
+        const result = await handleLines(after);
+        if (!result) return false;
     }
 
     const testsRun = getVariable("jsbehave.run_tests");
@@ -284,6 +288,8 @@ async function runTest(name, showTitle=false) {
         ...testsRun,
         name,
     ];
+
+    return true;
 }
 
 async function runAction(name, showTitle=false) {
@@ -404,11 +410,11 @@ async function compareContent([ selector, text ]) {
     if (text instanceof RegExp && text.test(value)) {
         return;
     }
-    if (value.includes(text)) {
+    if (value?.includes(text)) {
         return;
     }
 
-    throw new Error(`Expected element to have inner html of "${text}". Instead it had inner html of "${html}"`);
+    throw new Error(`Expected element to have inner html of "${text}". Instead it had inner html of "${html}" and value of "${value}"`);
 }
 
 function doSetVariable([ key, input ]) {
@@ -423,6 +429,12 @@ function concatVariable([ key, input ]) {
     setVariable(key, `${oldValue}${finalInput}`);
 }
 
+function concatVariable([ key, key2 ]) {
+    const var1 = getVariable(key) || '';
+    const var2 = getVariable(key2) || "";
+    setVariable(key, `${var1}${var2}`);
+}
+
 async function executeJS(code) {
     return driver().executeScript(code);
 }
@@ -526,6 +538,7 @@ const operations = {
     "expect element (.+) to have content (.+)": compareContent,
     "set variable (.+) to (.+)": doSetVariable,
     "concat variable (.+) with (.+)": concatVariable,
+    "concat variables (.+) and (.+)": concatVariables,
     "run test (.+)": doRunTest,
     "run action (.+)": doRunAction,
     [startActionRegex]: startBlock,
@@ -536,7 +549,7 @@ const operations = {
 
 async function handleLines(lines) {
     for (let i=0;i<lines.length;i++) {
-        const line = lines[i];
+        const { lineNum, line } = lines[i];
         if (line === "") {
             continue;
         }
@@ -574,8 +587,15 @@ async function handleLines(lines) {
                     const test = variables["jsbehave.activeBlock"];
                     if (test) {
                         console.log(`Test ${test} - FAILURE`);
-                        console.log(`Failed on line ${i+1}: "${line}" for "${operation}"`);
-                        console.log(error);
+                        console.log(`Failed on line ${lineNum}: "${line}" for "${operation}"`);
+                        const errorType = error.constructor.name;
+                        if (errorType === "NoSuchElementError") {
+                            console.log(`Could not find any matching element`);
+                        } else {
+                            console.log(error.constructor.name, error);
+                        }
+                        // newline
+                        console.log();
                         const screenshotOnFailure = getVariable("screenshotOnFailure") === 'true';
                         if (screenshotOnFailure) {
                             const screenshot = await takeScreenshot(test);
@@ -584,7 +604,7 @@ async function handleLines(lines) {
                     } else {
                         console.error(error);
                     }
-                    return;
+                    return false;
                 }
                 handled = true;
                 break;
@@ -595,9 +615,12 @@ async function handleLines(lines) {
             console.log(`Unable to handle "${line}"`);
         }
     }
+
+    return true;
 }
 
 (async function main() {
+    const allFailures = [];
     for (const fileName of fileNames) {
         const contents = fs.readFileSync(fileName, "utf-8");
         const lines = contents.split(EOL);
@@ -617,7 +640,8 @@ async function handleLines(lines) {
         let testName = null;
         let allOrEach = null;
         let inAction = false;
-        for (const line of lines) {
+        for (let i=0;i<lines.length;i++) {
+            const line = lines[i];
             if (line === "") {
                 continue;
             }
@@ -660,7 +684,10 @@ async function handleLines(lines) {
                 }
             }
 
-            testLines.push(line);
+            testLines.push({
+                lineNum: i+1,
+                line,
+            });
 
             if (line.startsWith("[endtest")) {
                 inTest = false;
@@ -697,6 +724,8 @@ async function handleLines(lines) {
             endLines = [...testLines];
         }
 
+        let anyError = false;
+
         if (specificTest) {
             if (!allTests[specificTest]) {
                 console.log("No test case found for '" + specificTest + "'");
@@ -704,34 +733,49 @@ async function handleLines(lines) {
                 return;
             }
 
-            await handleLines(startLines);
+            let result = await handleLines(startLines);
+            if (!result) anyError = true;
             console.log("Running beforeAll");
             for (const before of beforeAll) {
-                await handleLines(before);
+                result = await handleLines(before);
+                if (!result) anyError = true;
             }
-            await runTest(specificTest, true);
+            result = await runTest(specificTest, true);
+            if (!result) anyError = true;
             console.log("Running afterAll");
             for (const after of afterAll) {
-                await handleLines(after);
+                result = await handleLines(after);
+                if (!result) anyError = true;
             }
-            await handleLines(endLines);
+            const anyError = await handleLines(endLines);
         } else {
-            await handleLines(startLines);
+            let result = await handleLines(startLines);
+            if (!result) anyError = true;
             console.log("Running beforeAll");
             for (const before of beforeAll) {
-                await handleLines(before);
+                result = await handleLines(before);
+                if (!result) anyError = true;
             }
             for (const testName in allTests) {
-                await runTest(testName, true);
+                result = await runTest(testName, true);
+                if (!result) anyError = true;
             }
             console.log("Running afterAll");
             for (const after of afterAll) {
-                await handleLines(after);
+                result = await handleLines(after);
+                if (!result) anyError = true;
             }
-            await handleLines(endLines);
+            result = await handleLines(endLines);
+            if (!result) anyError = true;
+        }
+
+        if (anyError) {
+            allFailures.push(fileName);
         }
     }
 
+    console.log(`All failing tests:\n${allFailures.join("\n")}`);
+
     // force terminate
     process.exit(0);
 })();