2.0 is now working great, not published yet but almost ready

Author: Jason Byrne

.vscode/launch.json

@@ -18,6 +18,12 @@
             "request": "launch",
             "name": "Example - Browser (Google)",
             "program": "${workspaceFolder}/example/browser/google.js",
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Example - MileSplit",
+            "program": "${workspaceFolder}/example/milesplit.js",
         }
     ]
 }

example/browser/google.js

@@ -20,9 +20,9 @@ const paths = {
     searchResultsItem: '#search div.g'
 }
 
-suite.Browser('Google Search for Flagpole', browserOpts)
+suite.browser('Google Search for Flagpole', browserOpts)
     .open('/')
-    .then(async function () {
+    .next(async function () {
         this.assert('Landing Page HTTP Status is 200', this.response.status()).equals(200);
         await this.assert('Wait for search input box', this.exists(paths.queryInput)).resolves();
         await this.page.type(paths.queryInput, searchTerm);

example/milesplit.js

@@ -4,21 +4,25 @@ let suite = Flagpole.Suite('Test MileSplit')
     .base('https://www.milesplit.com')
     .finally(() => { suite.print(); });
 
-suite.Html('Test MileSplit Hompage').open('/')
-    .then('Load up homepage and verify response', function () {
+suite.html('Test MileSplit Hompage').open('/')
+    .next('Load up homepage and verify response', function () {
         this.assert('HTTP Status is 200', this.response.status()).equals(200);
         this.assert('Content type is HTML', this.response.headers('content-type')).contains('text/html');
     })
-    .then('Look for images in top stories', async function () {
+    .next('Look for images in top stories', async function () {
         const coverImages = await this.selectAll('section.topStories figure img');
         this.assert('There should be at least 4 top stories', coverImages.length)
             .greaterThanOrEquals(4);
         return coverImages;
     })
-    .then(async function (response, context) {
+    .next('Verify images load', async function () {
         const coverImages = await this.result;
-        coverImages.forEach(async function (element, i) {
-            context.comment(await element.getAttribute('src'));
+        this.assert('Every cover image has src attribute', coverImages).every(async function(image) {
+            return (await image.hasAttribute('src'));
+        });
+        coverImages.forEach(async function (image, i) {
+            image.load(`Load Cover Image ${i + 1}`, async function () {
+                this.assert('Width is 620', await this.select('width')).equals(620);
+            });
         });
-        await this.comment(await (await this.select('.topStories')).getClassName());
     });

example/smoke.js

@@ -5,15 +5,15 @@ Flagpole.Suite('Smoke Tests')
     .finally(function (suite) {
         suite.print();
     })
-    .Html('Homepage').open('/')
-    .then('Do basic homepage tests', function () {
+    .html('Homepage').open('/')
+    .next('Do basic homepage tests', function () {
         this.response.status().equals(200)
             .headers('content-type').contains('text/html')
             .select('title').text().contains('Stack Overflow')
             .select('link')
             .not().select('frameset');
     })
-    .then('Test the top navigation bar', function () {
+    .next('Test the top navigation bar', function () {
         this.response
             .label('Top bar and call to actions exists')
             .select('.top-bar').find('.-ctas').length().greaterThan(0)
@@ -24,7 +24,7 @@ Flagpole.Suite('Smoke Tests')
             .select('a.login-link').nth(1)
             .and().text().similarTo('Sign Up');
     })
-    .then('There should be questions', function () {
+    .next('There should be questions', function () {
         this.response
             .select('.question-summary')
             .and().length().greaterThan(5)
@@ -35,17 +35,17 @@ Flagpole.Suite('Smoke Tests')
             .and().find('.status span').exists()
             .and().text().parseInt().greaterThanOrEquals(0);
     })
-    .then('Test that each image exists', function () {
+    .next('Test that each image exists', function () {
         this.response.select('img').each(function (img, index) {
             img.load('Image ' + index, true);
         });
     })
-    .then('Test that the stylesheets exist', function () {
+    .next('Test that the stylesheets exist', function () {
         this.response.select('link[rel="stylesheet"]').each(function (link, index) {
             link.load('Stylesheet ' + index, true);
         });
     })
-    .then('Test that the javascript files exist', function () {
+    .next('Test that the javascript files exist', function () {
         this.response.select('script[src]').each(function (script, index) {
             script.load('Script ' + index, true);
         })

src/assertion.ts

@@ -1,6 +1,5 @@
 import { AssertionContext } from './assertioncontext';
 import { Value } from './value';
-import { Flagpole } from '.';
 
 export class Assertion {
 
@@ -225,4 +224,40 @@ export class Assertion {
         return this;
     }
 
+    public none(callback: Function): boolean {
+        let bool: boolean = false;
+        if (this._assertValue.isArray()) {
+            const arr: Array<any> = this._assertValue.get();
+            bool = arr.every((value: any, index: number, array: any[]) => {
+                return !callback(value, index, array);
+            });
+        }
+        this._assert(bool, 'None');
+        return bool;
+    }
+
+    public every(callback: Function): boolean {
+        let bool: boolean = false;
+        if (this._assertValue.isArray()) {
+            const arr: Array<any> = this._assertValue.get();
+            bool = arr.every((value: any, index: number, array: any[]) => {
+                return callback(value, index, array);
+            });
+        }
+        this._assert(bool, 'Every');
+        return bool;
+    }
+
+    public some(callback: Function): boolean {
+        let bool: boolean = false;
+        if (this._assertValue.isArray()) {
+            const arr: Array<any> = this._assertValue.get();
+            bool = arr.some((value: any, index: number, array: any[]) => {
+                return callback(value, index, array);
+            });
+        }
+        this._assert(bool, 'Some');
+        return bool;
+    }
+
 }

src/assertioncontext.ts

@@ -12,7 +12,7 @@ export class AssertionContext {
     private _response: iResponse;
 
     private get _isBrowserRequest(): boolean {
-        return this._scenario.getResponseType() == ResponseType.browser;
+        return this._scenario.responseType == ResponseType.browser;
     }
 
     public result: any;

src/flagpole.ts

@@ -54,6 +54,7 @@ export class Flagpole {
      * @returns {Suite}
      * @constructor
      */
+    static suite = Flagpole.Suite;
     static Suite(title: string): Suite {
         let suite: Suite = new Suite(title);
         return suite;

src/link.ts

@@ -73,9 +73,13 @@ export class Link {
         return /^(ftp):/.test(this.uri);
     }
 
+    /*
     public isNonNavigation(): boolean {
-        return /^(gopher|archie|veronica|telnet|file|nntp|news|irc|spdy|rtmp|rtp|tcp|udp):\/\//i.test(this.uri);
+        return (
+            /^(gopher|archie|veronica|telnet|file|nntp|news|irc|spdy|rtmp|rtp|tcp|udp):\/\//i.test(this.uri)
+        );
     }
+    */
 
     public isNavigation(): boolean {
         return (

src/nodeelement.ts

@@ -1,12 +1,15 @@
 import { ProtoValue } from './value';
 import { JSHandle } from 'puppeteer';
 import { Flagpole } from '.';
+import { Link } from './link';
+import { Scenario } from './scenario';
+import { ResponseType, iResponse } from './response';
 
 export class NodeElement extends ProtoValue {
 
     public async isFormTag(): Promise<boolean> {
         if (this.isCheerioElement() || this.isPuppeteerElement()) {
-            return await this.getTagName() === 'form';
+            return (await this.getTagName()) == 'form';
         }
         return false;
     }
@@ -154,6 +157,10 @@ export class NodeElement extends ProtoValue {
         return null;
     }
 
+    public async hasAttribute(key: string): Promise<boolean> {
+        return (await this.getAttribute(key)) !== null;
+    }
+
     public async getAttribute(key: string): Promise<any> {
         if (this.isCheerioElement()) {
             return (typeof this._input.get(0).attribs[key] !== 'undefined') ?
@@ -184,6 +191,10 @@ export class NodeElement extends ProtoValue {
         return null;
     }
 
+    public async hasData(key: string): Promise<boolean> {
+        return (await this.getData(key)) !== null;
+    }
+
     public async getData(key: string): Promise<any> {
         let text: any;
         if (this.isCheerioElement()) {
@@ -290,4 +301,78 @@ export class NodeElement extends ProtoValue {
         return null;
     }
 
+    /**
+     * Load the URL from this NodeElement if it has something to load
+     * This is used to create a lambda scenario
+     * 
+     * @param a 
+     */
+    public async load(a?: string | Function, b?: Function): Promise<Scenario> {
+        const element: NodeElement = this;
+        const srcPath: string | null = await element.getUrl();
+        const link: Link = new Link(element._context.response, srcPath || '');
+        const title: string = typeof a == 'string' ? a : `Load ${srcPath}`;
+        const callback: Function = (function () {
+            // Handle overloading
+            if (typeof b == 'function') {
+                return b;
+            }
+            else if (typeof a == 'function') {
+                return a;
+            }
+            // No callback was set, so just create a blank one
+            else {
+                return function () { };
+            }
+        })();
+        const scenario: Scenario = element._context.suite.Scenario(title);
+        // Is this link one that we can actually load?
+        if (link.isNavigation()) {
+            const scenarioType: string = await element.getLambdaScenarioType();
+            const uri: string = link.getUri();
+            // Get the options or just pass the default
+            const opts: any = (
+                (scenarioType == 'browser' && element._context.scenario.responseType == ResponseType.browser) ||
+                scenarioType != 'browser'
+            ) ? element._context.scenario.getRequestOptions() : {};
+            // Initialize the scenario
+            scenario[scenarioType](opts);
+            // Set our callback
+            scenario.next(callback);
+            // Done. Execute it asynchronously
+            setTimeout(() => {
+                scenario.open(uri);
+            }, 1);
+        }
+        else {
+            scenario.skip('Not a navigational link');
+        }
+        return scenario;
+    }
+
+    public async getLambdaScenarioType(): Promise<string> {
+        if (
+            (await this.isFormTag()) || (await this.isClickable())
+        ) {
+            // Assume if we are already in browser mode, we want to stay there
+            return (this._context.scenario.responseType == ResponseType.browser) ?
+                'browser' : 'html';
+        }
+        else if (await this.isImageTag()) {
+            return 'image';
+        }
+        else if (await this.isStylesheetTag()) {
+            return 'stylesheet';
+        }
+        else if (await this.isScriptTag()) {
+            return 'script';
+        }
+        else if (await this.isVideoTag()) {
+            return 'video'
+        }
+        else {
+            return 'resource';
+        }
+    }
+
 }

src/response.ts

@@ -292,7 +292,7 @@ export abstract class GenericResponse implements iResponse {
      * Load time of request to response
      */
     public loadTime(): Node {
-        return new Node(this, 'Load Time', this.scenario.getRequestLoadTime());
+        return new Node(this, 'Load Time', this.scenario.requestDuration);
     }
 
     /**

src/responsefactory.ts

@@ -10,7 +10,7 @@ import { Scenario } from './scenario';
 import { NormalizedResponse, iResponse, ResponseType } from './response';
 
 export function createResponse(scenario: Scenario, response: NormalizedResponse): iResponse {
-    const type: ResponseType = scenario.getResponseType();
+    const type: ResponseType = scenario.responseType;
     let className;
     if (type == ResponseType.html) {
         className = HtmlResponse;