tgi-store-mongodb

*217 model tests applied* ## [◀](#-model) [⌘](#constructors) [▶](#-request)  Procedure #### Procedure Class The `Procedure` class manages a set of `Command` objects. It provides a pattern for handling asynchronous and synchronous command execution. `Command` objects create and manage the `Procedure` object. #### CONSTRUCTOR  objects created should be an instance of Procedure: ```javascript return new Procedure() instanceof Procedure; ``` <blockquote>returns true as expected </blockquote>  should make sure new operator used: ```javascript Procedure(); // jshint ignore:line ``` <blockquote>Error: new operator required thrown as expected </blockquote>  should make sure argument properties are valid: ```javascript new Procedure({yo: 'whatup'}); ``` <blockquote>Error: error creating Procedure: invalid property: yo thrown as expected </blockquote> #### PROPERTIES #### tasks Tasks is an array of objects that represent each step of the procedure. See TASKS section below for each property of this unnamed object (task array element).  tasks can be falsy if no tasks defined otherwise it has to be an array: ```javascript new Procedure({tasks: true}); ``` <blockquote>Error: error creating Procedure: tasks is not an array thrown as expected </blockquote>  the parameters must be valid for the object in each element of the array: ```javascript new Procedure({ tasks: [ {clean: 'room'} ] }); ``` <blockquote>Error: error creating Procedure: invalid task[0] property: clean thrown as expected </blockquote> #### tasksNeeded Total tasks that will execute (does not include skipped tasks). _See Integration Tests for usage_ #### tasksCompleted Number of tasks completed and started (does not include skipped tasks) _See Integration Tests for usage_ #### TASKS Each element of the array tasks is an object with the following properties: #### label optional label for this task element  if used it must be a string: ```javascript new Procedure({ tasks: [ {label: true} ] }); ``` <blockquote>Error: error creating Procedure: task[0].label must be string thrown as expected </blockquote>  shorthand version: ```javascript new Procedure([function () { }]); ``` #### command Command to execute for this task  if used it must be a `Command`: ```javascript new Procedure({ tasks: [ {command: true} ] }); ``` <blockquote>Error: error creating Procedure: task[0].command must be a Command object thrown as expected </blockquote> #### requires Establish other tasks that must be complete before this task is executed. Pass as array of or single element. Can be string(for label label) or number(for array index). Use -1 for previous task, null for no dependencies  test it: ```javascript this.shouldThrowError(Error('invalid type for requires in task[0]'), function () { new Procedure({ tasks: [ {requires: new Date()} ] }); }); // if number supplied it is index in array this.shouldThrowError(Error('missing task #1 for requires in task[0]'), function () { new Procedure({ tasks: [ {command: new Procedure({}), requires: 1} ] }); }); this.shouldThrowError(Error('task #-2 invalid requires in task[0]'), function () { new Procedure({ tasks: [ {command: new Procedure({}), requires: -2} ] }); }); // requires defaults to -1 which means the previous element in the array so essentially the default // is sequential processing. Set to null for no dependencies which makes it asynchronous -1 means // previous element is ignored for first index and is the default var proc = new Procedure({ tasks: [ {command: new Command({})} ] }); this.shouldBeTrue(proc.tasks[0].requires == -1); ``` #### METHODS #### getObjectStateErrors  should return array of validation errors: ```javascript if (!new Procedure().getObjectStateErrors()) return 'falsy'; ``` <blockquote>returns falsy as expected </blockquote> #### INTEGRATION  synchronous sequential tasks are the default when tasks has no requires property: ```javascript var cmd = new Command({ name: 'cmdProcedure', type: 'Procedure', contents: new Procedure({ tasks: [ { command: new Command({ type: 'Function', contents: function () { var self = this; setTimeout(function () { self._parentProcedure.bucket += '1'; self.complete(); }, 250); // delayed to test that order is maintained } }) }, { command: new Command({ type: 'Function', contents: function () { this._parentProcedure.bucket += '2'; this.complete(); } }) }, function () { // shorthand version of command function ... this._parentProcedure.bucket += '3'; this.complete(); } ] }) }); cmd.onEvent('*', function (event) { if (event == 'Completed') callback(cmd.bucket); }); cmd.bucket = 'abc'; cmd.execute(); ``` <blockquote>returns abc123 as expected </blockquote>  async tasks are designated when requires is set to null: ```javascript var execCount = 0; // Call twice to test reset state var cmd = new Command({ name: 'cmdProcedure', type: 'Procedure', contents: new Procedure({ tasks: [ { command: new Command({ type: 'Function', contents: function () { var self = this; setTimeout(function () { self._parentProcedure.bucket += ' mo'; self.complete(); }, 50); // This will be done last } }) }, { requires: null, // no wait to run this command: new Command({ type: 'Function', contents: function () { this._parentProcedure.bucket += ' miney'; this.complete(); } }) } ] }) }); cmd.onEvent('*', function (event) { if (event == 'Completed') { if (execCount++ < 2) { cmd.execute(); } else { callback(cmd.bucket); } } }); cmd.bucket = 'eenie meenie'; execCount++; cmd.execute(); ``` <blockquote>returns eenie meenie miney mo miney mo as expected </blockquote>  this example shows multiple dependencies: ```javascript var cmd = new Command({ name: 'cmdProcedure', type: 'Procedure', contents: new Procedure({ tasks: [ { command: new Command({ type: 'Function', contents: function () { var self = this; setTimeout(function () { self._parentProcedure.bucket += ' rock'; self.complete(); }, 300); } }) }, { requires: null, // no wait to run this label: 'sex', command: new Command({ type: 'Function', contents: function () { var self = this; setTimeout(function () { self._parentProcedure.bucket += ' sex'; self.complete(); }, 200); } }) }, { requires: null, // no wait to run this label: 'drugs', command: new Command({ type: 'Function', contents: function () { var self = this; setTimeout(function () { self._parentProcedure.bucket += ' drugs'; self.complete(); }, 100); } }) }, { requires: ['sex', 'drugs', 0], // need these labels and array index 0 command: new Command({ type: 'Function', contents: function () { this._parentProcedure.bucket += ' & roll'; this.complete(); } }) } ] }) }); cmd.onEvent('*', function (event) { if (event == 'Completed') callback(cmd.bucket); }); cmd.bucket = 'todo:'; cmd.execute(); ``` <blockquote>returns todo: drugs sex rock & roll as expected </blockquote> ## [◀](#-procedure) [⌘](#constructors) [▶](#-store)  Request Requests handle the Request / Response design pattern. They are used by the Interface class to communicate with the Application Model #### CONSTRUCTOR  objects created should be an instance of Request: ```javascript return new Request('Null') instanceof Request; ``` <blockquote>returns true as expected </blockquote>  should make sure new operator used: ```javascript Request('Null'); // jshint ignore:line ``` <blockquote>Error: new operator required thrown as expected </blockquote>  request type must be specified: ```javascript new Request(); ``` <blockquote>Error: Request type required thrown as expected </blockquote>  simple string parameter creates request of named type: ```javascript return new Request('example').type; ``` <blockquote>returns example as expected </blockquote>  type can be specified when object passed: ```javascript return new Request({type: 'example'}).type; ``` <blockquote>returns example as expected </blockquote>  Command type requests expect contents to contain a command object: ```javascript return new Request({type: 'Command'}); ``` <blockquote>Error: command object required thrown as expected </blockquote>  correct version: ```javascript return new Request({type: 'Command', command: new Command()}); ``` <blockquote>returns Command Request: Stub Command: a command as expected </blockquote> #### METHODS #### toString()  should return a description of the Request: ```javascript return new Request('Null').toString(); ``` <blockquote>returns Null Request as expected </blockquote> ## [◀](#-request) [⌘](#constructors) [▶](#-text)  Store The store class is used for object persistence. #### CONSTRUCTOR  objects created should be an instance of Store: ```javascript return new SurrogateStore() instanceof Store; ``` <blockquote>returns true as expected </blockquote>  should make sure new operator used: ```javascript SurrogateStore(); // jshint ignore:line ``` <blockquote>Error: new operator required thrown as expected </blockquote>  should make sure properties are valid: ```javascript new SurrogateStore({food: 'twinkies'}); ``` <blockquote>Error: error creating Store: invalid property: food thrown as expected </blockquote> #### PROPERTIES #### name  name of store can be set in constructor: ```javascript return new SurrogateStore({name: 'punchedCards'}).name; ``` <blockquote>returns punchedCards as expected </blockquote> #### storeType storeType defaults to Store Class Name but can be set to suite the app architecture.  storeType can be set in constructor: ```javascript return new SurrogateStore({storeType: 'legacyStorage'}).storeType; ``` <blockquote>returns legacyStorage as expected </blockquote> #### METHODS  getServices() returns an object with interface for the Store.: ```javascript this.log(JSON.stringify(services)); this.shouldBeTrue(services instanceof Object); this.shouldBeTrue(typeof services['isReady'] == 'boolean'); // don't use until this.shouldBeTrue(typeof services['canGetModel'] == 'boolean'); // define all allowed methods... this.shouldBeTrue(typeof services['canPutModel'] == 'boolean'); this.shouldBeTrue(typeof services['canDeleteModel'] == 'boolean'); this.shouldBeTrue(typeof services['canGetList'] == 'boolean'); ``` <blockquote>log: {"isReady":false,"canGetModel":false,"canPutModel":false,"canDeleteModel":false,"canGetList":false} </blockquote> #### toString()  should return a description of the Store: ```javascript var cStore = new SurrogateStore(); this.log(cStore.toString()); cStore.name = '7-Eleven'; cStore.storeType = 'ConvenienceStore'; this.log(cStore.toString()); return cStore.toString(); ``` <blockquote>log: a Store log: ConvenienceStore: 7-Eleven returns ConvenienceStore: 7-Eleven as expected </blockquote> #### onConnect()  must pass url string: ```javascript new SurrogateStore().onConnect(); ``` <blockquote>Error: argument must a url string thrown as expected </blockquote>  must pass callback function: ```javascript new SurrogateStore().onConnect(""); ``` <blockquote>Error: argument must a callback thrown as expected </blockquote> see integration test for Store #### getModel()  getModel() is not implemented for virtual class: ```javascript new SurrogateStore().getModel(); ``` <blockquote>Error: Store does not provide getModel thrown as expected </blockquote> #### putModel(model)  putModel() is not implemented for virtual class: ```javascript new SurrogateStore().putModel(); ``` <blockquote>Error: Store does not provide putModel thrown as expected </blockquote> #### deleteModel(model)  deleteModel() is not implemented for virtual class: ```javascript new SurrogateStore().deleteModel(); ``` <blockquote>Error: Store does not provide deleteModel thrown as expected </blockquote> #### getList(list, filter, [optional order], callback) This method will clear and populate the list with collection from store. The **filter** property can be used to query the store. The **order** property can specify the sort order of the list. _See integration test for more info._ #### getViewList(list, filter, [optional order], callback) This method provides getList() for View type Lists. _See integration test for more info._ #### Store Integration  Check each type: ```javascript var self = this; spec.integrationStore = new SurrogateStore(); // If store is not ready then get out... if (!spec.integrationStore.getServices().isReady) { self.log('Store is not ready.'); callback(true); return; } self.Types = function () { Model.call(this, { modelType: '_tempTypes', attributes: [ new Attribute({name: 'String', type: 'String', value: 'cheese'}), new Attribute({name: 'Date', type: 'Date', value: new Date()}), new Attribute({name: 'Boolean', type: 'Boolean', value: true}), new Attribute({name: 'Number', type: 'Number', value: 42}) ] }); }; self.Types.prototype = Object.create(Model.prototype); self.types = new self.Types(); self.types2 = new self.Types(); self.types2.copy(self.types); spec.integrationStore.putModel(self.types, function (model, error) { if (typeof error != 'undefined') { callback(error); return; } self.shouldBeTrue(model.get('String') == self.types2.get('String')); self.shouldBeTrue(model.get('Date') == self.types2.get('Date')); self.shouldBeTrue(model.get('Date') instanceof Date); self.shouldBeTrue(model.get('Boolean') == self.types2.get('Boolean')); self.shouldBeTrue(model.get('Number') == self.types2.get('Number')); callback(true); }); ``` <blockquote>log: Store is not ready. returns true as expected </blockquote> ## [◀](#-store) [⌘](#constructors) [▶](#-transport)  Text #### Text Class Text is used to allow display and setting of application / user text. #### CONSTRUCTOR  objects created should be an instance of Text: ```javascript return new Text('Null') instanceof Text; ``` <blockquote>returns true as expected </blockquote>  should make sure new operator used: ```javascript Text('Null'); // jshint ignore:line ``` <blockquote>Error: new operator required thrown as expected </blockquote> #### METHODS #### toString()  should return a description of the Text: ```javascript return new Text('me').toString(); ``` <blockquote>returns Text: 'me' as expected </blockquote> #### get()  return value: ```javascript return new Text('yo').get(); ``` <blockquote>returns yo as expected </blockquote> #### set()  set value: ```javascript var who = new Text('Me'); who.set('You'); return who.get(); ``` <blockquote>returns You as expected </blockquote> #### onEvent Use onEvent(events,callback)  first parameter is a string or array of event subscriptions: ```javascript new Text('').onEvent(); ``` <blockquote>Error: subscription string or array required thrown as expected </blockquote>  callback is required: ```javascript new Text('').onEvent([]); ``` <blockquote>Error: callback is required thrown as expected </blockquote>  events are checked against known types: ```javascript new Text('').onEvent(['onDrunk'], function () { }); ``` <blockquote>Error: Unknown command event: onDrunk thrown as expected </blockquote>  here is a working version: ```javascript new Text('').onEvent(['StateChange'], function () { }); ``` #### offEvents Free all onEvent listeners  example: ```javascript new Text('').offEvent(); ``` ## [◀](#-text) [⌘](#constructors) [▶](#-view)  Transport Handle message passing between host and UI. TODO: run these tests in node-make-spec-md with io defined Read the source until then... https://github.com/tgi-io/tgi-core/blob/master/lib/core/tgi-core-transport.spec.js ## [◀](#-transport) [⌘](#constructors) [▶](#-replinterface)  View #### View Does stuff #### CONSTRUCTOR  objects created should be an instance of View: ```javascript return new View(new Model(), {}, []) instanceof View; ``` <blockquote>returns true as expected </blockquote>  should make sure new operator used: ```javascript View(); // jshint ignore:line ``` <blockquote>Error: new operator required thrown as expected </blockquote>  first parameter is primary model: ```javascript new View(); ``` <blockquote>Error: argument must be a Model thrown as expected </blockquote>  second parameter is object with related models: ```javascript new View(new Model()); ``` <blockquote>Error: object expected thrown as expected </blockquote>  third parameter is array of attributes making up view: ```javascript new View(new Model(), {}); ``` <blockquote>Error: array of attributes expected thrown as expected </blockquote>  related models are named objects with id & model: ```javascript this.shouldThrowError('Error: relatedModel key values expect object', function () { new View(new Model(), {eat: 'me'}, []); }); this.shouldThrowError('Error: relatedModel key values expect object with id key', function () { new View(new Model(), {eat: {}}, []); }); this.shouldThrowError('Error: relatedModel key values expect object with model key', function () { new View(new Model(), {eat: {id: 1}}, []); }); this.shouldThrowError('Error: relatedModel id must be a Attribute', function () { new View(new Model(), {eat: {id: 1, model: new Model()}}, []); }); this.shouldThrowError('Error: relatedModel model must be a Model', function () { new View(new Model(), {eat: {id: new Attribute({name: 'eatID'}), model: 2}}, []); }); ```  attributes must be valid attribute: ```javascript new View(new Model(), {}, ['this is so wrong']); ``` <blockquote>Error: attribute array must contain Attributes thrown as expected </blockquote>  attributes must be valid attribute: ```javascript new View(new Model(), {}, [new Attribute({name: 'x'})]); ``` <blockquote>Error: attribute array must contain Attributes with model references thrown as expected </blockquote> #### METHODS #### toString()  should return a description of the view: ```javascript return new View(new Model(), {}, []).toString(); ``` <blockquote>returns a Model View as expected </blockquote> ## [◀](#-view) [⌘](#constructors) [▶](#-application)  REPLInterface #### REPLInterface The REPLInterface is a Read Evaluate Print Loop Interface. #### CONSTRUCTOR TODO: //spec.runnerInterfaceConstructor(REPLInterface); TODO: //spec.runnerInterfaceMethods(REPLInterface); #### METHODS The REPLInterface defines adds the following methods. evaluateInput(line)  called when line of input available: ```javascript return typeof REPLInterface.prototype.evaluateInput; ``` <blockquote>returns function as expected </blockquote>  if no input state error generated: ```javascript ``` captureOutput(callback)  called when line of input available: ```javascript return typeof REPLInterface.prototype.captureOutput; ``` <blockquote>returns function as expected </blockquote> capturePrompt(callback)  called when line of input available: ```javascript return typeof REPLInterface.prototype.capturePrompt; ``` <blockquote>returns function as expected </blockquote> #### INTEGRATION  user queries: ```javascript var repl = new REPLInterface(); var app = new Application({interface: repl}); var ex = this; repl.captureOutput(function (text) { ex.log('out> ' + text); //console.log('out> ' + text); }); repl.evaluateInput('input ignored if no context for it'); var input = function (text) { ex.log('in> ' + text); //console.log('in> ' + text); repl.evaluateInput(text); }; /** * test per function */ var ok1 = function () { app.ok('This is a test.', function () { yesno1(); }); input('whatever'); }; var yesno1 = function () { app.yesno('Are we having fun?', function (answer) { if (answer) { callback(answer); } else { yesno2(); } }); input('nope'); // this will be ignored input('n'); // this will be ignored }; var yesno2 = function () { app.yesno('Should I continue?', function (answer) { if (answer) { ask1(); } else { callback(answer); } }); input('yeppers'); // this will be ignored input('y'); }; var ask1 = function () { app.ask('What is your name?', function (answer) { repl.info('Nice to meet you ' + answer + '.'); if (answer == 'Sean') { choose1(); } else { callback(answer); } }); input('Sean'); }; var choose1 = function () { app.choose('Pick one...', ['Eenie', 'Meenie', 'Miney', 'Moe'], function (choice) { if (choice == 1) callback('done'); else callback(choice); }); input('m'); // first partial match }; /** * Start the first test */ ok1(); ``` <blockquote>log: out> input ignored: input ignored if no context for it log: out> This is a test. log: in> whatever log: in> nope log: out> yes or no response required log: in> n log: in> yeppers log: out> yes or no response required log: in> y log: in> Sean log: out> Nice to meet you Sean. log: out> Pick one... log: out> Eenie log: out> Meenie log: out> Miney log: out> Moe log: in> m returns done as expected </blockquote>  app navigation: ```javascript var repl = new REPLInterface(); var app = new Application({interface: repl}); var ex = this; repl.captureOutput(function (text) { ex.log('out> ' + text); //console.log('out> ' + text); }); var input = function (text) { ex.log('in> ' + text); //console.log('in> ' + text); repl.evaluateInput(text); }; var answer = ''; var rockCommand = new Command({ name: 'Rock', type: 'Function', contents: function () { answer += 'Rock'; } }); var paperCommand = new Command({ name: 'Paper', type: 'Function', contents: function () { answer += 'Paper'; } }); var scissorsCommand = new Command({ name: 'Scissors', type: 'Function', contents: function () { answer += 'Scissors'; } }); var seeYouCommand = new Command({ name: 'SeeYou', type: 'Function', contents: function () { callback(answer); } }); var menu = new Presentation(); menu.set('name', 'Public Menu'); menu.set('contents', [ 'Strings are ignored', new Attribute({name: 'ignoredAlso'}), rockCommand, paperCommand, scissorsCommand, seeYouCommand ]); app.setPresentation(menu); app.start(function () { ex.log('app got stuff: ' + JSON.stringify(stuff)); //console.log('app got stuff: ' + JSON.stringify(stuff)); }); input('Rockaby'); input('r'); input('p'); input('s'); input('se'); ``` <blockquote>log: in> Rockaby log: out> "Rockaby" not valid log: in> r log: in> p log: in> s log: in> se log: out> Rock, Paper, Scissors, SeeYou log: out> Rock, Paper, Scissors, SeeYou log: out> Rock, Paper, Scissors, SeeYou log: out> Rock, Paper, Scissors, SeeYou log: out> Rock, Paper, Scissors, SeeYou log: out> Rock, Paper, Scissors, SeeYou returns RockPaperScissors as expected </blockquote> ## [◀](#-replinterface) [⌘](#constructors) [▶](#-log)  Application #### CONSTRUCTOR  objects created should be an instance of Application: ```javascript return new Application() instanceof Application; ``` <blockquote>returns true as expected </blockquote> *29 model tests applied*  argument property interface will invoke setInterface method: ```javascript var myInterface = new Interface(); var myApplication = new Application({interface: myInterface}); return (myApplication.getInterface() === myInterface); ``` <blockquote>returns true as expected </blockquote> #### ATTRIBUTES Application extends model and inherits the attributes property. All Application objects have the following attributes:  following attributes are defined:: ```javascript var presentation = new Application(); // default attributes and values this.shouldBeTrue(presentation.get('name') === 'newApp'); this.shouldBeTrue(presentation.get('brand') === 'NEW APP'); ``` #### METHODS #### setInterface(interface) Setting the interface for the application determines the primary method of user interaction.  must supply Interface object: ```javascript new Application().setInterface(); ``` <blockquote>Error: instance of Interface a required parameter thrown as expected </blockquote> #### getInterface() returns primary user interface for application  default is undefined: ```javascript return new Application().getInterface() === undefined; ``` <blockquote>returns true as expected </blockquote>  returns value set by set Interface: ```javascript var myInterface = new Interface(); var myApplication = new Application(); myApplication.setInterface(myInterface); return (myApplication.getInterface() === myInterface); ``` <blockquote>returns true as expected </blockquote> #### setPresentation(presentation) Setting the presentation for the application determines the primary commands available to the user.  must supply Presentation object: ```javascript new Application().setPresentation(); ``` <blockquote>Error: instance of Presentation a required parameter thrown as expected </blockquote> #### getPresentation() returns primary user presentation for application  default is undefined: ```javascript return new Application().getPresentation() === undefined; ``` <blockquote>returns true as expected </blockquote>  returns value set by set Presentation: ```javascript var myPresentation = new Presentation(); var myApplication = new Application(); myApplication.setPresentation(myPresentation); return (myApplication.getPresentation() === myPresentation); ``` <blockquote>returns true as expected </blockquote> #### start() The start method executes the application.  must set interface before starting: ```javascript new Application().start(); ``` <blockquote>Error: error starting application: interface not set thrown as expected </blockquote>  callback parameter required: ```javascript new Application({interface: new Interface()}).start(); ``` <blockquote>Error: callback required thrown as expected </blockquote> #### dispatch() The dispatch method will accept a request and act on it or pass it to the app.  must pass a Request object: ```javascript new Application().dispatch(); ``` <blockquote>Error: Request required thrown as expected </blockquote>  send command without callback when no response needed: ```javascript var ex = this; new Application().dispatch(new Request({ type: 'Command', command: new Command(function () { ex.log('PEACE'); }) })); ``` <blockquote>log: PEACE </blockquote>  optional second parameter is the response callback: ```javascript new Application().dispatch(new Request({type: 'Command', command: new Command()}), true); ``` <blockquote>Error: response callback is not a function thrown as expected </blockquote> #### info(text) Display info to user in background of primary presentation.  must set interface before invoking: ```javascript new Application().info(); // see Interface for more info ``` <blockquote>Error: interface not set thrown as expected </blockquote> #### done(text) Display done to user in background of primary presentation.  must set interface before invoking: ```javascript new Application().done(); // see Interface for more info ``` <blockquote>Error: interface not set thrown as expected </blockquote> #### warn(text) Display info to user in background of primary presentation.  must set interface before invoking: ```javascript new Application().warn(); // see Interface for more info ``` <blockquote>Error: interface not set thrown as expected </blockquote> #### err(text) Display info to user in background of primary presentation.  must set interface before invoking: ```javascript new Application().err(); // see Interface for more info ``` <blockquote>Error: interface not set thrown as expected </blockquote> #### ok(prompt, callback) Pause before proceeding  must set interface before invoking: ```javascript new Application().ok(); ``` <blockquote>Error: interface not set thrown as expected </blockquote>  must provide the text prompt param: ```javascript new Application({interface: new Interface()}).ok(); ``` <blockquote>Error: prompt required thrown as expected </blockquote>  must provide callback param: ```javascript new Application({interface: new Interface()}).ok('You are about to enter the twilight zone.'); ``` <blockquote>Error: callback required thrown as expected </blockquote> #### yesno(prompt, callback) Query user with a yes no question.  must set interface before invoking: ```javascript new Application().yesno(); ``` <blockquote>Error: interface not set thrown as expected </blockquote>  must provide the text question param: ```javascript new Application({interface: new Interface()}).yesno(); ``` <blockquote>Error: prompt required thrown as expected </blockquote>  must provide callback param: ```javascript new Application({interface: new Interface()}).yesno('ok?'); ``` <blockquote>Error: callback required thrown as expected </blockquote> #### ask(prompt, attribute, callback) Simple single item prompt.  must set interface before invoking: ```javascript new Application().ask(); ``` <blockquote>Error: interface not set thrown as expected </blockquote>  must provide the text question param: ```javascript new Application({interface: new Interface()}).ask(); ``` <blockquote>Error: prompt required thrown as expected </blockquote>  next param is attribute or callback: ```javascript new Application({interface: new Interface()}).ask('sup'); ``` <blockquote>Error: attribute or callback expected thrown as expected </blockquote>  must provide callback param: ```javascript new Application({interface: new Interface()}). ask('Please enter your name', new Attribute({name: 'Name'})); ``` <blockquote>Error: callback required thrown as expected </blockquote> #### choose prompt to choose an item  must set interface before invoking: ```javascript new Application().choose(); ``` <blockquote>Error: interface not set thrown as expected </blockquote>  must provide text prompt first: ```javascript new Application({interface: new Interface()}).choose(); ``` <blockquote>Error: prompt required thrown as expected </blockquote>  must supply array of choices: ```javascript var myApplication = new Application({interface: new Interface()}); this.shouldThrowError(Error('choices array required'), function () { myApplication.choose('What it do'); }); this.shouldThrowError(Error('choices array required'), function () { myApplication.choose('this will not', 'work'); }); this.shouldThrowError(Error('choices array empty'), function () { myApplication.choose('empty array?', []); }); ```  must provide callback param: ```javascript var myApplication = new Application(); myApplication.setInterface(new Interface()); myApplication.choose('choose wisely', ['rock', 'paper', 'scissors']); ``` <blockquote>Error: callback required thrown as expected </blockquote> #### Application Integration  minimal app: ```javascript // Here is our app var ui = new Interface(); var app = new Application(); app.setInterface(ui); app.start(console.log); // define command to satisfy test var helloWorldCommand = new Command(function () { callback('hello world'); }); // mock ui command request - this will get executed by app directly ui.mockRequest(new Request({type: 'Command', command: helloWorldCommand})); ``` <blockquote>returns hello world as expected </blockquote>  little app with command execution mocking: ```javascript // todo delamify this // Send 4 mocks and make sure we get 4 callback calls var self = this; self.callbackCount = 0; var app = new Application(); var testInterface = new Interface(); var testPresentation = new Presentation(); app.setInterface(testInterface); app.setPresentation(testPresentation); app.start(function (request) { if (request.type == 'mock count') self.callbackCount++; if (self.callbackCount > 3) callback(true); }); var cmds = []; var i; for (i = 0; i < 4; i++) { cmds.push(new Request('mock count')); } testInterface.mockRequest(cmds); ``` <blockquote>returns true as expected </blockquote> ## [◀](#-application) [⌘](#constructors) [▶](#-presentation)  Log #### Log Model Multi purpose log model. #### CONSTRUCTOR  objects created should be an instance of Workspace: ```javascript return new Log() instanceof Log; ``` <blockquote>returns true as expected </blockquote> *29 model tests applied* #### ATTRIBUTES  following attributes are defined:: ```javascript var log = new Log('what up'); // default attributes and values this.shouldBeTrue(log.get('id') !== undefined); this.shouldBeTrue(log.get('dateLogged') instanceof Date); this.log(log.get('dateLogged')); this.shouldBeTrue(log.get('logType') == 'Text'); this.shouldBeTrue(log.get('importance') == 'Info'); this.shouldBeTrue(log.get('contents') == 'what up'); ``` <blockquote>log: Wed Aug 30 2017 18:24:59 GMT-0400 (EDT) </blockquote> #### LOG TYPES  must be valid: ```javascript this.log('T.getLogTypes()'); new Log({logType: 'wood'}); // default attributes and values ``` <blockquote>log: T.getLogTypes() Error: Unknown log type: wood thrown as expected </blockquote>  Text simple text message: ```javascript return new Log('sup'); ``` <blockquote>returns Info: sup as expected </blockquote>  Delta logged Delta (see in Core): ```javascript var delta = new Delta(new Attribute.ModelID(new Model())); return new Log({logType: 'Delta', contents: delta}).toString(); ``` <blockquote>returns Info: (delta) as expected </blockquote> ## [◀](#-log) [⌘](#constructors) [▶](#-session)  Presentation #### Presentation Model The Presentation Model represents the way in which a model is to be presented to the user. The specific Interface object will represent the model data according to the Presentation object. #### CONSTRUCTOR  objects created should be an instance of Presentation: ```javascript return new Presentation() instanceof Presentation; ``` <blockquote>returns true as expected </blockquote> *29 model tests applied* #### PROPERTIES #### model This is a model instance for the presentation instance. #### validationErrors  Array of errors: ```javascript this.shouldBeTrue(new Presentation().validationErrors instanceof Array); this.shouldBeTrue(new Presentation().validationErrors.length === 0); ``` #### validationMessage  string description of error(s): ```javascript return new Presentation().validationMessage; ``` #### preRenderCallback preRenderCallback can be set to prepare presentation prior to Interface render #### ATTRIBUTES Presentation extends model and inherits the attributes property. All Presentation objects have the following attributes:  following attributes are defined:: ```javascript var presentation = new Presentation(); // default attributes and values this.shouldBeTrue(presentation.get('id') === null); this.shouldBeTrue(presentation.get('name') === null); this.shouldBeTrue(presentation.get('modelName') === null); this.shouldBeTrue(presentation.get('contents') instanceof Array); ``` #### METHODS #### modelConstructor This is a reference to the constructor function to create a new model #### validate check valid object state then extend to presentation contents  callback is required -- see integration: ```javascript new Presentation().validate(); ``` <blockquote>Error: callback is required thrown as expected </blockquote> #### CONTENTS The contents attributes provides the structure for the presentation.  content must be an array: ```javascript var pres = new Presentation(); pres.set('contents', true); return pres.getObjectStateErrors(); ``` <blockquote>returns contents must be Array as expected </blockquote>  contents elements must be Text, Command, Attribute, List or string: ```javascript var pres = new Presentation(); // strings with prefix # are heading, a dash - by itself is for a visual separator pres.set('contents', ['#heading', new Text('sup'), new Command(), new Attribute({name: 'meh'}), new List(new Model())]); this.shouldBeTrue(pres.getObjectStateErrors().length === 0); pres.set('contents', [new Command(), new Attribute({name: 'meh'}), true]); return pres.getObjectStateErrors(); ``` <blockquote>returns contents elements must be Text, Command, Attribute, List or string as expected </blockquote> #### INTEGRATION  validation usage demonstrated: ```javascript var attribute = new Attribute({name: 'test'}); var presentation = new Presentation(); // default attributes and values presentation.set('contents', [attribute]); attribute.setError('test', 'test error'); presentation.validate(function () { callback(presentation.validationMessage); }); ``` <blockquote>returns contents has validation errors as expected </blockquote>  use REPLInterface to view and edit: ```javascript var repl = new REPLInterface(); var ex = this; repl.captureOutput(function (text) { ex.log('out> ' + text); //console.log('out> ' + text); }); repl.capturePrompt(function (text) { ex.log('prompt> ' + text); //console.log('prompt> ' + text); }); var input = function (text) { ex.log('in> ' + text); //console.log('in> ' + text); repl.evaluateInput(text); }; /** * Here is the presentation */ var firstName = new Attribute({name: 'firstName'}); var lastName = new Attribute({name: 'lastName'}); var presentation = new Presentation(); presentation.set('contents', [ '##TITLE', 'Here is **text**. _Note it uses markdown_. Eventually this will be **stripped** out!', 'Here are some attributes:', firstName, lastName ]); firstName.value = 'Elmer'; lastName.value = 'Fud'; /** * Create a command to view it (default mode) */ var presentationCommand = new Command({name: 'Presentation', type: 'Presentation', contents: presentation}); presentationCommand.onEvent('*', function (event, err) { var eventDesc = 'event> ' + event + (err || ' ok'); ex.log(eventDesc); //console.log(eventDesc); }); presentationCommand.execute(repl); /** * Now edit it */ presentationCommand.presentationMode = 'Edit'; presentationCommand.execute(repl); input('John'); input('Doe'); /** * View again */ presentationCommand.presentationMode = 'View'; presentationCommand.execute(repl); ``` <blockquote>log: event> BeforeExecute ok log: event> ErrorError: Presentation object required log: event> Completed ok log: event> AfterExecute ok log: event> BeforeExecute ok log: event> ErrorError: Presentation object required log: event> Completed ok log: event> AfterExecute ok log: in> John log: out> input ignored: John log: in> Doe log: out> input ignored: Doe log: event> BeforeExecute ok log: event> ErrorError: Presentation object required log: event> Completed ok log: event> AfterExecute ok log: prompt> ? log: prompt> ? </blockquote> ## [◀](#-presentation) [⌘](#constructors) [▶](#-user)  Session #### Session Model The Session Model represents the Session logged into the system. The library uses this for system access, logging and other functions. #### CONSTRUCTOR  objects created should be an instance of Session: ```javascript return new Session() instanceof Session; ``` <blockquote>returns true as expected </blockquote> #### CONSTRUCTOR Creation of all Models must adhere to following examples:  objects created should be an instance of Model: ```javascript return new SurrogateModel() instanceof Model; ``` <blockquote>returns true as expected </blockquote>  should make sure new operator used: ```javascript SurrogateModel(); // jshint ignore:line ``` <blockquote>Error: new operator required thrown as expected </blockquote>  should make sure properties are valid: ```javascript new SurrogateModel({sup: 'yo'}); ``` <blockquote>Error: error creating Model: invalid property: sup thrown as expected </blockquote>  can supply attributes in constructor in addition to ID default: ```javascript var play = new SurrogateModel({attributes: [new Attribute('game')]}); play.set('game', 'scrabble'); // this would throw error if attribute did not exist return play.get('game'); ``` <blockquote>returns scrabble as expected </blockquote> #### PROPERTIES #### tags Tags are an array of strings that can be used in searching.  should be an array or undefined: ```javascript var m = new SurrogateModel(); // default is undefined this.shouldBeTrue(m.tag === undefined && m.getObjectStateErrors().length === 0); m.tags = []; this.shouldBeTrue(m.getObjectStateErrors().length === 0); m.tags = 'your it'; this.shouldBeTrue(m.getObjectStateErrors().length == 1); ``` #### attributes The attributes property is an array of Attributes.  should be an array: ```javascript var goodModel = new SurrogateModel(), badModel = new SurrogateModel(); badModel.attributes = 'wtf'; return (goodModel.getObjectStateErrors().length === 0 && badModel.getObjectStateErrors().length == 1); ``` <blockquote>returns true as expected </blockquote>  elements of array must be instance of Attribute: ```javascript // passing true to getObjectStateErrors() means only check model and not subclass validations // todo make unit test for above var model = new SurrogateModel(); model.attributes = [new Attribute("ID", "ID")]; this.shouldBeTrue(model.getObjectStateErrors(true).length === 0); model.attributes = [new Attribute("ID", "ID"), new SurrogateModel(), 0, 'a', {}, [], null]; this.shouldBeTrue(model.getObjectStateErrors(true).length == 6); ``` #### METHODS #### toString()  should return a description of the model: ```javascript return new SurrogateModel().toString().length > 0; ``` <blockquote>returns true as expected </blockquote> #### copy(sourceModel)  copy all attribute values of a model: ```javascript var Foo = function (args) { Model.call(this, args); this.modelType = "Foo"; this.attributes.push(new Attribute('name')); }; Foo.prototype = inheritPrototype(Model.prototype); var m1 = new Foo(); var m2 = new Foo(); var m3 = m1; m1.set('name', 'Bar'); m2.set('name', 'Bar'); // First demonstrate instance ref versus another model with equal attributes this.shouldBeTrue(m1 === m3); // assigning one model to variable references same instance this.shouldBeTrue(m3.get('name') === 'Bar'); // m3 changed when m1 changed this.shouldBeTrue(m1 !== m2); // 2 models are not the same instance // clone m1 into m4 and demonstrate that contents equal but not same ref to object var m4 = new Foo(); m4.copy(m1); this.shouldBeTrue(m1 !== m4); // 2 models are not the same instance ``` #### getObjectStateErrors()  should return array of validation errors: ```javascript this.shouldBeTrue(new SurrogateModel().getObjectStateErrors() instanceof Array); ```  first attribute must be an ID field: ```javascript var m = new SurrogateModel(); m.attributes = [new Attribute('spoon')]; return m.getObjectStateErrors(); ``` <blockquote>returns first attribute must be ID as expected </blockquote> #### onEvent Use onEvent(events,callback)  first parameter is a string or array of event subscriptions: ```javascript new SurrogateModel().onEvent(); ``` <blockquote>Error: subscription string or array required thrown as expected </blockquote>  callback is required: ```javascript new SurrogateModel().onEvent([]); ``` <blockquote>Error: callback is required thrown as expected </blockquote>  events are checked against known types: ```javascript new SurrogateModel().onEvent(['onDrunk'], function () { }); ``` <blockquote>Error: Unknown command event: onDrunk thrown as expected </blockquote>  here is a working version: ```javascript this.log('T.getAttributeEvents()'); // Validate - callback when attribute needs to be validated // StateChange -- callback w