How to use jsface - 10 common examples

var jsface = require('jsface'),
    AbstractResponseHandler = require('./AbstractResponseHandler');

/**
 * @class DefaultResponseHandler
 * @classdesc
 * @extends AbstractResponseHandler
 */
var DefaultResponseHandler = jsface.Class(AbstractResponseHandler, {
    $singleton: true,

    // function called when the event "requestExecuted" is fired. Takes 4 self-explanatory parameters
    _onRequestExecuted: function (error, response, body, request) {
        AbstractResponseHandler._onRequestExecuted.call(this, error, response, body, request);
    }
});

module.exports = DefaultResponseHandler;

log = require('../utilities/Logger'),
    Backbone = require("backbone"),
    xmlToJson = require("xml2js"),
    CryptoJS = require('crypto-js'),
    Globals = require("../utilities/Globals"),
    HttpStatusCodes = require("../utilities/HttpStatusCodes"),
    ResponseExporter = require("../utilities/ResponseExporter"),
    btoa = require("btoa"),
    atob = require("atob"),
    tv4 = require("tv4");
require('sugar');
/**
 * @class TestResponseHandler
 * @classdesc
 */
var TestResponseHandler = jsface.Class(AbstractResponseHandler, {
    $singleton: true,
    throwErrorOnLog: false,

    main: function () {
        jsdom.env("", function (err, window) {
            _jq = require('jquery')(window);
        });
    },


    // function called when the event "requestExecuted" is fired. Takes 4 self-explanatory parameters
    _onRequestExecuted: function (error, response, body, request) {
        var results = this._runTestCases(error, response, body, request);
        AbstractResponseHandler._onRequestExecuted.call(this, error, response, body, request, results);
        this._logTestResults(results);

setAddress:function (city, street) {
            $super.setAddress('China', city, street);
        }
    }
});

var OvyBeijingLover3 = ovy.extend(OvyChinaGuy3, function ($super) {
    return {
        setAddress:function (street) {
            $super.setAddress('Beijing', street);
        }
    }
});

// JSFace
var JSFacePerson = jsface.Class({
    constructor:function (name) {
        this.name = name;
    },
    setAddress:function (country, city, street) {
        this.country = country;
        this.city = city;
        this.street = street;
    }
});

var JSFaceFrenchGuy = jsface.Class(JSFacePerson, {
    constructor:function (name) {
        JSFaceFrenchGuy.$super.call(this, name);
    },
    setAddress:function (city, street) {
        JSFaceFrenchGuy.$superp.setAddress.call(this, 'France', city, street);

var jsface = require("jsface");

var HttpStatusCodes = jsface.Class({
    $singleton: true,

    getCodes: function () {
        return this.httpStatusCodes;
    },

    httpStatusCodes: {
        100: {
            "name": "Continue",
            "detail": "This means that the server has received the request headers, and that the client should proceed to send the request body (in the case of a request for which a body needs to be sent; for example, a POST request). If the request body is large, sending it to a server when a request has already been rejected based upon inappropriate headers is inefficient. To have a server check if the request could be accepted based on the request's headers alone, a client must send Expect: 100-continue as a header in its initial request and check if a 100 Continue status code is received in response before continuing (or receive 417 Expectation Failed and not continue)."
        },
        101: {
            "name": "Switching Protocols",
            "detail": "This means the requester has asked the server to switch protocols and the server is acknowledging that it will do so."
        },
        102: {

var jsface = require('jsface'),
	fs     = require('fs'),
	Errors = require('./ErrorHandler'),
    CSVHelper = require('./CsvHelper'),
	_und   = require('underscore');

/**
 * @name Helpers
 * @namespace
 * @classdesc Helper class with useful methods used throughout Newman
 */
var Helpers = jsface.Class({
	$singleton: true,

    /**
     * @function
     * @memberOf Helpers
     * @param  {String}  url [Takes a URL as an input]
     * @return {Boolean}     [Returns is the url is valid or not.]
     */
    validateCollectionUrl: function(url) {
		var result = url.match(/(https|http):\/\/([_a-z\d\-]+(\.[_a-z\d\-]+)+)(([_a-z\d\-\\\.\/]+[_a-z\d\-\\\/])+)*/);
		if (!result)  {
			Errors.terminateWithError("Please specify a valid URL");
		}
    },

	validateDataFile: function(file) {

var jsface = require('jsface'),
    Globals = require('./Globals'),
    log = require('./Logger'),
    fs = require('fs');

/**
 * @class HtmlExporter
 * @classdesc Class Used to generate pretty html reports
 */
var HtmlExporter = jsface.Class({
    $singleton: true,
    templates: null,
    generateHTML: function (resultObj) {
        var template;
        //Always use existing file
        template = require('../templates/htmlResponseTemplate');
        var htmlPath = Globals.html;
        try {
            fs.writeFileSync(htmlPath, template(resultObj));
            log.note("\nHTML Report written to: " + htmlPath + "\n");
        }
        catch (e) {
            log.error("Error writing to file. Try using sudo. Error: " + (e.stack || e));
        }
    }
});

*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
var Class = require("jsface").Class;

Class(function() {
  "use strict";

  var PORT           = 2011,
      TIMEOUT        = 5*60*1000,
      WAIT_TIMEOUT   = 250,
      CHECK_INTERVAL = 2000,
      express        = require("express"),
      crypto         = require("crypto"),
      hostname       = require("os").hostname(),
      colors         = require("colors"),
      path           = require("path"),
      app            = express.createServer(),
      io             = require("socket.io"),
      urlData        = {},
      connections    = 0,
      clear          = false,

function test_jsface() {
    var Person = jsface.Class({
        $classname: 'Person',
        name: {type: String},
        email: {type: String},
        age: {type: Number},
        sex: {type: String}
    });
}

var addEventDir = function(event) {
  registerDirective('d-' + event, Class(EventDirective, {
    isPair: false,
    constructor: function(options) {
      EventDirective.call(this, options);
    },
    event: event
  }));
};

var jsface = require('jsface'),
    ParentModel = require('./ParentModel.js');

/**
 * @class FolderModel
 * @classdesc FolderModel class that inherits from ParentModel representing
 * a postman folder object.
 * @extends ParentModel
 * @param folderJson {JSON} Folder JSON object from Postman.
 */
var FolderModel = jsface.Class(ParentModel, {
    constructor: function (folderJson) {
        this.$class.$super.call(this, folderJson);
        this.order = folderJson.order;
    },
    toString: function () {
        return "Folder: " + this.name;
    }
});

module.exports = FolderModel;