*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;
```
returns true as expected
should make sure new operator used:
```javascript
Procedure(); // jshint ignore:line
```
Error: new operator required thrown as expected
should make sure argument properties are valid:
```javascript
new Procedure({yo: 'whatup'});
```
Error: error creating Procedure: invalid property: yo thrown as expected
#### 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});
```
Error: error creating Procedure: tasks is not an array thrown as expected
the parameters must be valid for the object in each element of the array:
```javascript
new Procedure({
tasks: [
{clean: 'room'}
]
});
```
Error: error creating Procedure: invalid task[0] property: clean thrown as expected
#### 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}
]
});
```
Error: error creating Procedure: task[0].label must be string thrown as expected
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}
]
});
```
Error: error creating Procedure: task[0].command must be a Command object thrown as expected
#### 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';
```
returns falsy as expected
#### 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();
```
returns abc123 as expected
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();
```
returns eenie meenie miney mo miney mo as expected
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();
```
returns todo: drugs sex rock & roll as expected
## [◀](#-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;
```
returns true as expected
should make sure new operator used:
```javascript
Request('Null'); // jshint ignore:line
```
Error: new operator required thrown as expected
request type must be specified:
```javascript
new Request();
```
Error: Request type required thrown as expected
simple string parameter creates request of named type:
```javascript
return new Request('example').type;
```
returns example as expected
type can be specified when object passed:
```javascript
return new Request({type: 'example'}).type;
```
returns example as expected
Command type requests expect contents to contain a command object:
```javascript
return new Request({type: 'Command'});
```
Error: command object required thrown as expected
correct version:
```javascript
return new Request({type: 'Command', command: new Command()});
```
returns Command Request: Stub Command: a command as expected
#### METHODS
#### toString()
should return a description of the Request:
```javascript
return new Request('Null').toString();
```
returns Null Request as expected
## [◀](#-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;
```
returns true as expected
should make sure new operator used:
```javascript
SurrogateStore(); // jshint ignore:line
```
Error: new operator required thrown as expected
should make sure properties are valid:
```javascript
new SurrogateStore({food: 'twinkies'});
```
Error: error creating Store: invalid property: food thrown as expected
#### PROPERTIES
#### name
name of store can be set in constructor:
```javascript
return new SurrogateStore({name: 'punchedCards'}).name;
```
returns punchedCards as expected
#### 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;
```
returns legacyStorage as expected
#### 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');
```
log: {"isReady":false,"canGetModel":false,"canPutModel":false,"canDeleteModel":false,"canGetList":false}
#### 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();
```
log: a Store
log: ConvenienceStore: 7-Eleven
returns ConvenienceStore: 7-Eleven as expected
#### onConnect()
must pass url string:
```javascript
new SurrogateStore().onConnect();
```
Error: argument must a url string thrown as expected
must pass callback function:
```javascript
new SurrogateStore().onConnect("");
```
Error: argument must a callback thrown as expected
see integration test for Store
#### getModel()
getModel() is not implemented for virtual class:
```javascript
new SurrogateStore().getModel();
```
Error: Store does not provide getModel thrown as expected
#### putModel(model)
putModel() is not implemented for virtual class:
```javascript
new SurrogateStore().putModel();
```
Error: Store does not provide putModel thrown as expected
#### deleteModel(model)
deleteModel() is not implemented for virtual class:
```javascript
new SurrogateStore().deleteModel();
```
Error: Store does not provide deleteModel thrown as expected
#### 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);
});
```
log: Store is not ready.
returns true as expected
## [◀](#-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;
```
returns true as expected
should make sure new operator used:
```javascript
Text('Null'); // jshint ignore:line
```
Error: new operator required thrown as expected
#### METHODS
#### toString()
should return a description of the Text:
```javascript
return new Text('me').toString();
```
returns Text: 'me' as expected
#### get()
return value:
```javascript
return new Text('yo').get();
```
returns yo as expected
#### set()
set value:
```javascript
var who = new Text('Me');
who.set('You');
return who.get();
```
returns You as expected
#### onEvent
Use onEvent(events,callback)
first parameter is a string or array of event subscriptions:
```javascript
new Text('').onEvent();
```
Error: subscription string or array required thrown as expected
callback is required:
```javascript
new Text('').onEvent([]);
```
Error: callback is required thrown as expected
events are checked against known types:
```javascript
new Text('').onEvent(['onDrunk'], function () {
});
```
Error: Unknown command event: onDrunk thrown as expected
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;
```
returns true as expected
should make sure new operator used:
```javascript
View(); // jshint ignore:line
```
Error: new operator required thrown as expected
first parameter is primary model:
```javascript
new View();
```
Error: argument must be a Model thrown as expected
second parameter is object with related models:
```javascript
new View(new Model());
```
Error: object expected thrown as expected
third parameter is array of attributes making up view:
```javascript
new View(new Model(), {});
```
Error: array of attributes expected thrown as expected
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']);
```
Error: attribute array must contain Attributes thrown as expected
attributes must be valid attribute:
```javascript
new View(new Model(), {}, [new Attribute({name: 'x'})]);
```
Error: attribute array must contain Attributes with model references thrown as expected
#### METHODS
#### toString()
should return a description of the view:
```javascript
return new View(new Model(), {}, []).toString();
```
returns a Model View as expected
## [◀](#-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;
```
returns function as expected
if no input state error generated:
```javascript
```
captureOutput(callback)
called when line of input available:
```javascript
return typeof REPLInterface.prototype.captureOutput;
```
returns function as expected
capturePrompt(callback)
called when line of input available:
```javascript
return typeof REPLInterface.prototype.capturePrompt;
```
returns function as expected
#### 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();
```
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
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');
```
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
## [◀](#-replinterface) [⌘](#constructors) [▶](#-log) Application
#### CONSTRUCTOR
objects created should be an instance of Application:
```javascript
return new Application() instanceof Application;
```
returns true as expected
*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);
```
returns true as expected
#### 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();
```
Error: instance of Interface a required parameter thrown as expected
#### getInterface()
returns primary user interface for application
default is undefined:
```javascript
return new Application().getInterface() === undefined;
```
returns true as expected
returns value set by set Interface:
```javascript
var myInterface = new Interface();
var myApplication = new Application();
myApplication.setInterface(myInterface);
return (myApplication.getInterface() === myInterface);
```
returns true as expected
#### setPresentation(presentation)
Setting the presentation for the application determines the primary commands available to the user.
must supply Presentation object:
```javascript
new Application().setPresentation();
```
Error: instance of Presentation a required parameter thrown as expected
#### getPresentation()
returns primary user presentation for application
default is undefined:
```javascript
return new Application().getPresentation() === undefined;
```
returns true as expected
returns value set by set Presentation:
```javascript
var myPresentation = new Presentation();
var myApplication = new Application();
myApplication.setPresentation(myPresentation);
return (myApplication.getPresentation() === myPresentation);
```
returns true as expected
#### start()
The start method executes the application.
must set interface before starting:
```javascript
new Application().start();
```
Error: error starting application: interface not set thrown as expected
callback parameter required:
```javascript
new Application({interface: new Interface()}).start();
```
Error: callback required thrown as expected
#### 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();
```
Error: Request required thrown as expected
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');
})
}));
```
log: PEACE
optional second parameter is the response callback:
```javascript
new Application().dispatch(new Request({type: 'Command', command: new Command()}), true);
```
Error: response callback is not a function thrown as expected
#### 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
```
Error: interface not set thrown as expected
#### 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
```
Error: interface not set thrown as expected
#### 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
```
Error: interface not set thrown as expected
#### 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
```
Error: interface not set thrown as expected
#### ok(prompt, callback)
Pause before proceeding
must set interface before invoking:
```javascript
new Application().ok();
```
Error: interface not set thrown as expected
must provide the text prompt param:
```javascript
new Application({interface: new Interface()}).ok();
```
Error: prompt required thrown as expected
must provide callback param:
```javascript
new Application({interface: new Interface()}).ok('You are about to enter the twilight zone.');
```
Error: callback required thrown as expected
#### yesno(prompt, callback)
Query user with a yes no question.
must set interface before invoking:
```javascript
new Application().yesno();
```
Error: interface not set thrown as expected
must provide the text question param:
```javascript
new Application({interface: new Interface()}).yesno();
```
Error: prompt required thrown as expected
must provide callback param:
```javascript
new Application({interface: new Interface()}).yesno('ok?');
```
Error: callback required thrown as expected
#### ask(prompt, attribute, callback)
Simple single item prompt.
must set interface before invoking:
```javascript
new Application().ask();
```
Error: interface not set thrown as expected
must provide the text question param:
```javascript
new Application({interface: new Interface()}).ask();
```
Error: prompt required thrown as expected
next param is attribute or callback:
```javascript
new Application({interface: new Interface()}).ask('sup');
```
Error: attribute or callback expected thrown as expected
must provide callback param:
```javascript
new Application({interface: new Interface()}).
ask('Please enter your name', new Attribute({name: 'Name'}));
```
Error: callback required thrown as expected
#### choose
prompt to choose an item
must set interface before invoking:
```javascript
new Application().choose();
```
Error: interface not set thrown as expected
must provide text prompt first:
```javascript
new Application({interface: new Interface()}).choose();
```
Error: prompt required thrown as expected
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']);
```
Error: callback required thrown as expected
#### 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}));
```
returns hello world as expected
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);
```
returns true as expected
## [◀](#-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;
```
returns true as expected
*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');
```
log: Wed Aug 30 2017 18:24:59 GMT-0400 (EDT)
#### LOG TYPES
must be valid:
```javascript
this.log('T.getLogTypes()');
new Log({logType: 'wood'}); // default attributes and values
```
log: T.getLogTypes()
Error: Unknown log type: wood thrown as expected
Text simple text message:
```javascript
return new Log('sup');
```
returns Info: sup as expected
Delta logged Delta (see in Core):
```javascript
var delta = new Delta(new Attribute.ModelID(new Model()));
return new Log({logType: 'Delta', contents: delta}).toString();
```
returns Info: (delta) as expected
## [◀](#-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;
```
returns true as expected
*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();
```
Error: callback is required thrown as expected
#### 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();
```
returns contents must be Array as expected
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();
```
returns contents elements must be Text, Command, Attribute, List or string as expected
#### 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);
});
```
returns contents has validation errors as expected
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);
```
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> ?
## [◀](#-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;
```
returns true as expected
#### CONSTRUCTOR
Creation of all Models must adhere to following examples:
objects created should be an instance of Model:
```javascript
return new SurrogateModel() instanceof Model;
```
returns true as expected
should make sure new operator used:
```javascript
SurrogateModel(); // jshint ignore:line
```
Error: new operator required thrown as expected
should make sure properties are valid:
```javascript
new SurrogateModel({sup: 'yo'});
```
Error: error creating Model: invalid property: sup thrown as expected
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');
```
returns scrabble as expected
#### 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);
```
returns true as expected
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;
```
returns true as expected
#### 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();
```
returns first attribute must be ID as expected
#### onEvent
Use onEvent(events,callback)
first parameter is a string or array of event subscriptions:
```javascript
new SurrogateModel().onEvent();
```
Error: subscription string or array required thrown as expected
callback is required:
```javascript
new SurrogateModel().onEvent([]);
```
Error: callback is required thrown as expected
events are checked against known types:
```javascript
new SurrogateModel().onEvent(['onDrunk'], function () {
});
```
Error: Unknown command event: onDrunk thrown as expected
here is a working version:
```javascript
this.log('T.getAttributeEvents()');
// Validate - callback when attribute needs to be validated
// StateChange -- callback when state of object (value or validation state) has changed
new Model().onEvent(['Validate'], function () {
});
```
log: T.getAttributeEvents()
#### attribute
return attribute by name:
```javascript
var attrib = new Attribute("Sue");
var model = new Model({attributes: [attrib]});
return model.attribute("Sue") == attrib;
```
returns true as expected
#### getShortName
returns short description of model, defaults to first string attribute:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('name')]});
question.attributes[1].value = 'Shorty';
return question.getShortName();
```
returns Shorty as expected
if no string attribute found empty string returned:
```javascript
// Test for model since models may provide attributes to fail this test
var question = new Model({attributes: [new Attribute('answer', 'Number')]});
question.attributes[1].value = 42;
return question.getShortName();
```
#### getLongName
note - both getShortName and getLongName should be overriden with method returning desired results when needed.
return a more verbose name for model than getShortName:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('name')]});
question.attributes[1].value = 'Shorty';
return question.getLongName();
```
returns Shorty as expected
#### get(attributeName)
returns undefined if the attribute does not exist:
```javascript
this.shouldBeTrue(new SurrogateModel().get('whatever') === undefined);
```
returns the value for given attribute:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('answer', 'Number')]});
question.attributes[1].value = 42;
return question.get('answer');
```
returns 42 as expected
#### getAttributeType(attributeName)
returns attribute type for given attribute name:
```javascript
return new SurrogateModel({attributes: [new Attribute('born', 'Date')]}).getAttributeType('born');
```
returns Date as expected
#### set(attributeName,value)
throws an error if the attribute does not exists:
```javascript
new SurrogateModel().set('whatever');
```
Error: attribute not valid for model thrown as expected
sets the value for given attribute:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('answer', 'Number')]});
question.set('answer', 42);
return question.attributes[1].value;
```
returns 42 as expected
#### validate
check valid object state and value for attribute - invoke callback for results
callback is required:
```javascript
new Model().validate();
```
Error: callback is required thrown as expected
#### setError
Set a error condition and descriptive message
first argument condition required:
```javascript
new Model().setError();
```
Error: condition required thrown as expected
second argument description required:
```javascript
new Model().setError('login');
```
Error: description required thrown as expected
#### clearError
Clear a error condition
first argument condition required:
```javascript
new Model().clearError();
```
Error: condition required thrown as expected
#### INTEGRATION
model validation usage demonstrated:
```javascript
// Create a model with each attribute having and error
var model = new Model({
attributes: [
new Attribute({name: 'Name', validationRule: {required: true}}),
new Attribute({name: 'Age', type: 'Number', validationRule: {range: [18, null]}}),
new Attribute({name: 'Sex', validationRule: {required: true}})
]
});
model.setError('danger', 'Danger Will Robinson');
// Create a model validation where males have to be 21
model.onEvent('Validate', function () {
var name = model.get('name');
var age = model.get('age');
var sex = model.get('sex');
if (sex != 'F' && age < 21)
model.validationErrors.push('Males must be 21 or over');
});
model.validate(test1);
// Expect 1 error from B9 Robot (Attribute errors ignored if model state error)
function test1() {
if (model.validationErrors.length == 1) {
model.clearError('danger');
model.validate(test2);
} else {
callback('test1: ' + model.validationErrors.length);
}
}
// Expect 3 errors for each attribute
function test2() {
if (model.validationErrors.length == 3) {
model.set('name', 'John Doe');
model.set('age', 18);
model.set('sex', 'M');
model.validate(test3);
} else {
callback('test2: ' + model.validationErrors.length);
}
}
// Expect 1 errors since all attributes fixed but model will fail
function test3() {
if (model.validationErrors.length == 1 && model.validationMessage == 'Males must be 21 or over') {
model.set('age', 21);
model.validate(test4);
} else {
callback('test3: ' + model.validationErrors.length);
}
}
// Test done should be no errors (to pass final test)
function test4() {
callback('test4: ' + model.validationErrors.length);
}
```
returns test4: 0 as expected
*29 model tests applied*
#### ATTRIBUTES
following attributes are defined::
```javascript
var session = new Session(); // default attributes and values
this.shouldBeTrue(session.get('id') === null);
this.shouldBeTrue(session.get('userID') instanceof Attribute.ModelID);
this.shouldBeTrue(session.get('userID').modelType == 'User');
this.shouldBeTrue(session.get('dateStarted') instanceof Date);
this.shouldBeTrue(session.get('passCode') === null);
this.shouldBeTrue(session.get('ipAddress') === null);
this.shouldBeTrue(session.get('active') === false);
```
#### METHODS
#### startSession()
This method will create a new session record for a user.
parameters are store, user, password, IP and callback:
```javascript
this.shouldThrowError(Error('store required'), function () {
new Session().startSession();
});
this.shouldThrowError(Error('userName required'), function () {
new Session().startSession(new Store());
});
this.shouldThrowError(Error('password required'), function () {
new Session().startSession(new Store(), 'blow');
});
this.shouldThrowError(Error('ip required'), function () {
new Session().startSession(new Store(), 'blow', 'me');
});
this.shouldThrowError(Error('callback required'), function () {
new Session().startSession(new Store(), 'blow', 'me', 'ipman');
});
```
#### resumeSession()
This method will resume an existing session.
parameters are store, IP, passcode and callback:
```javascript
this.shouldThrowError(Error('store required'), function () {
new Session().resumeSession();
});
this.shouldThrowError(Error('ip required'), function () {
new Session().resumeSession(new Store());
});
this.shouldThrowError(Error('passCode required'), function () {
new Session().resumeSession(new Store(), 'ipman');
});
this.shouldThrowError(Error('callback required'), function () {
new Session().resumeSession(new Store(), 'ipman', '123');
});
```
#### endSession()
Method to end session.
parameters are store and callback - session object should be in memory:
```javascript
this.shouldThrowError(Error('store required'), function () {
new Session().endSession();
});
this.shouldThrowError(Error('callback required'), function () {
new Session().endSession(new Store());
});
```
#### INTEGRATION TEST
simulate logging in etc:
```javascript
var self = this;
var store = new MemoryStore();
var session1 = new Session();
var session2 = new Session();
var user1 = new User(), name1 = 'jack', pass1 = 'wack', ip1 = '123';
user1.set('name', name1);
user1.set('password', pass1);
user1.set('active', true);
var user2 = new User(), name2 = 'jill', pass2 = 'pill', ip2 = '456';
user2.set('name', name2);
user2.set('password', pass2);
user2.set('active', true);
// start with empty store and add some users
store.putModel(user1, userStored);
store.putModel(user2, userStored);
// callback after users stored
function userStored(model, error) {
if (typeof error != 'undefined') {
callback(error);
return;
}
if (user1.get('id') && user2.get('id')) {
// users added to store now log them both in and also generate 2 errors
self.goodCount = 0;
self.badCount = 0;
session1.startSession(store, name1, 'badpassword', ip1, usersStarted);
session1.startSession(store, name1, pass1, ip1, usersStarted);
session2.startSession(store, 'john', pass2, ip2, usersStarted);
session2.startSession(store, name2, pass2, ip2, usersStarted);
}
}
// callback after session started called
function usersStarted(err, session) {
if (err)
self.badCount++;
else
self.goodCount++;
if (self.badCount == 2 && self.goodCount == 2) {
// Resume session1 correctly
new Session().resumeSession(store, ip1, session1.get('passCode'), sessionResumed_Test1);
}
}
function sessionResumed_Test1(err, session) {
if (err)
callback(Error('sessionResumed_Test1 failed'));
else
// Resume session2 with wrong passcode
new Session().resumeSession(store, ip2, 'no more secrets', sessionResumed_Test2);
}
function sessionResumed_Test2(err, session) {
if (err)
// Resume session2 correctly now after failing
new Session().resumeSession(store, ip2, session2.get('passCode'), sessionResumed_Test3);
else
callback(Error('sessionResumed_Test2 failed'));
}
function sessionResumed_Test3(err, session) {
if (err)
callback(Error('sessionResumed_Test3 failed: ' + err));
else
// Now we end this session
session.endSession(store, function (err, session) {
if (err)
callback(Error('session.endSession failed: '+err));
else
// Now try restoring again and it should fail
new Session().resumeSession(store, ip2, session2.get('passCode'), sessionResumed_Test4);
});
}
function sessionResumed_Test4(err, session) {
if (err)
callback(Error('sessionResumed_Test4 failed'));
else
callback(true);
}
```
returns true as expected
## [◀](#-session) [⌘](#constructors) [▶](#-workspace) User
#### User Model
The User Model represents the user logged into the system. The library uses this for system access, logging and other functions.
#### CONSTRUCTOR
objects created should be an instance of User:
```javascript
return new User() instanceof User;
```
returns true as expected
#### CONSTRUCTOR
Creation of all Models must adhere to following examples:
objects created should be an instance of Model:
```javascript
return new SurrogateModel() instanceof Model;
```
returns true as expected
should make sure new operator used:
```javascript
SurrogateModel(); // jshint ignore:line
```
Error: new operator required thrown as expected
should make sure properties are valid:
```javascript
new SurrogateModel({sup: 'yo'});
```
Error: error creating Model: invalid property: sup thrown as expected
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');
```
returns scrabble as expected
#### 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);
```
returns true as expected
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;
```
returns true as expected
#### 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();
```
returns first attribute must be ID as expected
#### onEvent
Use onEvent(events,callback)
first parameter is a string or array of event subscriptions:
```javascript
new SurrogateModel().onEvent();
```
Error: subscription string or array required thrown as expected
callback is required:
```javascript
new SurrogateModel().onEvent([]);
```
Error: callback is required thrown as expected
events are checked against known types:
```javascript
new SurrogateModel().onEvent(['onDrunk'], function () {
});
```
Error: Unknown command event: onDrunk thrown as expected
here is a working version:
```javascript
this.log('T.getAttributeEvents()');
// Validate - callback when attribute needs to be validated
// StateChange -- callback when state of object (value or validation state) has changed
new Model().onEvent(['Validate'], function () {
});
```
log: T.getAttributeEvents()
#### attribute
return attribute by name:
```javascript
var attrib = new Attribute("Sue");
var model = new Model({attributes: [attrib]});
return model.attribute("Sue") == attrib;
```
returns true as expected
#### getShortName
returns short description of model, defaults to first string attribute:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('name')]});
question.attributes[1].value = 'Shorty';
return question.getShortName();
```
returns Shorty as expected
if no string attribute found empty string returned:
```javascript
// Test for model since models may provide attributes to fail this test
var question = new Model({attributes: [new Attribute('answer', 'Number')]});
question.attributes[1].value = 42;
return question.getShortName();
```
#### getLongName
note - both getShortName and getLongName should be overriden with method returning desired results when needed.
return a more verbose name for model than getShortName:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('name')]});
question.attributes[1].value = 'Shorty';
return question.getLongName();
```
returns Shorty as expected
#### get(attributeName)
returns undefined if the attribute does not exist:
```javascript
this.shouldBeTrue(new SurrogateModel().get('whatever') === undefined);
```
returns the value for given attribute:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('answer', 'Number')]});
question.attributes[1].value = 42;
return question.get('answer');
```
returns 42 as expected
#### getAttributeType(attributeName)
returns attribute type for given attribute name:
```javascript
return new SurrogateModel({attributes: [new Attribute('born', 'Date')]}).getAttributeType('born');
```
returns Date as expected
#### set(attributeName,value)
throws an error if the attribute does not exists:
```javascript
new SurrogateModel().set('whatever');
```
Error: attribute not valid for model thrown as expected
sets the value for given attribute:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('answer', 'Number')]});
question.set('answer', 42);
return question.attributes[1].value;
```
returns 42 as expected
#### validate
check valid object state and value for attribute - invoke callback for results
callback is required:
```javascript
new Model().validate();
```
Error: callback is required thrown as expected
#### setError
Set a error condition and descriptive message
first argument condition required:
```javascript
new Model().setError();
```
Error: condition required thrown as expected
second argument description required:
```javascript
new Model().setError('login');
```
Error: description required thrown as expected
#### clearError
Clear a error condition
first argument condition required:
```javascript
new Model().clearError();
```
Error: condition required thrown as expected
#### INTEGRATION
model validation usage demonstrated:
```javascript
// Create a model with each attribute having and error
var model = new Model({
attributes: [
new Attribute({name: 'Name', validationRule: {required: true}}),
new Attribute({name: 'Age', type: 'Number', validationRule: {range: [18, null]}}),
new Attribute({name: 'Sex', validationRule: {required: true}})
]
});
model.setError('danger', 'Danger Will Robinson');
// Create a model validation where males have to be 21
model.onEvent('Validate', function () {
var name = model.get('name');
var age = model.get('age');
var sex = model.get('sex');
if (sex != 'F' && age < 21)
model.validationErrors.push('Males must be 21 or over');
});
model.validate(test1);
// Expect 1 error from B9 Robot (Attribute errors ignored if model state error)
function test1() {
if (model.validationErrors.length == 1) {
model.clearError('danger');
model.validate(test2);
} else {
callback('test1: ' + model.validationErrors.length);
}
}
// Expect 3 errors for each attribute
function test2() {
if (model.validationErrors.length == 3) {
model.set('name', 'John Doe');
model.set('age', 18);
model.set('sex', 'M');
model.validate(test3);
} else {
callback('test2: ' + model.validationErrors.length);
}
}
// Expect 1 errors since all attributes fixed but model will fail
function test3() {
if (model.validationErrors.length == 1 && model.validationMessage == 'Males must be 21 or over') {
model.set('age', 21);
model.validate(test4);
} else {
callback('test3: ' + model.validationErrors.length);
}
}
// Test done should be no errors (to pass final test)
function test4() {
callback('test4: ' + model.validationErrors.length);
}
```
returns test4: 0 as expected
*29 model tests applied*
#### ATTRIBUTES
following attributes are defined::
```javascript
var user = new User(); // default attributes and values
this.shouldBeTrue(user.get('id') === null);
this.shouldBeTrue(user.get('name') === null);
this.shouldBeTrue(user.get('active') === false);
this.shouldBeTrue(user.get('password') === null);
this.shouldBeTrue(user.get('firstName') === null);
this.shouldBeTrue(user.get('lastName') === null);
this.shouldBeTrue(user.get('email') === null);
```
## [◀](#-user) [⌘](#constructors) [▶](#-memorystore) Workspace
#### Workspace Model
A workspace is a collection of active deltas for a user. The GUI could represent that as opentabs for instance. Each tab a model view. The deltas represent the change in model state
#### CONSTRUCTOR
objects created should be an instance of Workspace:
```javascript
return new Workspace() instanceof Workspace;
```
returns true as expected
#### CONSTRUCTOR
Creation of all Models must adhere to following examples:
objects created should be an instance of Model:
```javascript
return new SurrogateModel() instanceof Model;
```
returns true as expected
should make sure new operator used:
```javascript
SurrogateModel(); // jshint ignore:line
```
Error: new operator required thrown as expected
should make sure properties are valid:
```javascript
new SurrogateModel({sup: 'yo'});
```
Error: error creating Model: invalid property: sup thrown as expected
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');
```
returns scrabble as expected
#### 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);
```
returns true as expected
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;
```
returns true as expected
#### 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();
```
returns first attribute must be ID as expected
#### onEvent
Use onEvent(events,callback)
first parameter is a string or array of event subscriptions:
```javascript
new SurrogateModel().onEvent();
```
Error: subscription string or array required thrown as expected
callback is required:
```javascript
new SurrogateModel().onEvent([]);
```
Error: callback is required thrown as expected
events are checked against known types:
```javascript
new SurrogateModel().onEvent(['onDrunk'], function () {
});
```
Error: Unknown command event: onDrunk thrown as expected
here is a working version:
```javascript
this.log('T.getAttributeEvents()');
// Validate - callback when attribute needs to be validated
// StateChange -- callback when state of object (value or validation state) has changed
new Model().onEvent(['Validate'], function () {
});
```
log: T.getAttributeEvents()
#### attribute
return attribute by name:
```javascript
var attrib = new Attribute("Sue");
var model = new Model({attributes: [attrib]});
return model.attribute("Sue") == attrib;
```
returns true as expected
#### getShortName
returns short description of model, defaults to first string attribute:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('name')]});
question.attributes[1].value = 'Shorty';
return question.getShortName();
```
returns Shorty as expected
if no string attribute found empty string returned:
```javascript
// Test for model since models may provide attributes to fail this test
var question = new Model({attributes: [new Attribute('answer', 'Number')]});
question.attributes[1].value = 42;
return question.getShortName();
```
#### getLongName
note - both getShortName and getLongName should be overriden with method returning desired results when needed.
return a more verbose name for model than getShortName:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('name')]});
question.attributes[1].value = 'Shorty';
return question.getLongName();
```
returns Shorty as expected
#### get(attributeName)
returns undefined if the attribute does not exist:
```javascript
this.shouldBeTrue(new SurrogateModel().get('whatever') === undefined);
```
returns the value for given attribute:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('answer', 'Number')]});
question.attributes[1].value = 42;
return question.get('answer');
```
returns 42 as expected
#### getAttributeType(attributeName)
returns attribute type for given attribute name:
```javascript
return new SurrogateModel({attributes: [new Attribute('born', 'Date')]}).getAttributeType('born');
```
returns Date as expected
#### set(attributeName,value)
throws an error if the attribute does not exists:
```javascript
new SurrogateModel().set('whatever');
```
Error: attribute not valid for model thrown as expected
sets the value for given attribute:
```javascript
var question = new SurrogateModel({attributes: [new Attribute('answer', 'Number')]});
question.set('answer', 42);
return question.attributes[1].value;
```
returns 42 as expected
#### validate
check valid object state and value for attribute - invoke callback for results
callback is required:
```javascript
new Model().validate();
```
Error: callback is required thrown as expected
#### setError
Set a error condition and descriptive message
first argument condition required:
```javascript
new Model().setError();
```
Error: condition required thrown as expected
second argument description required:
```javascript
new Model().setError('login');
```
Error: description required thrown as expected
#### clearError
Clear a error condition
first argument condition required:
```javascript
new Model().clearError();
```
Error: condition required thrown as expected
#### INTEGRATION
model validation usage demonstrated:
```javascript
// Create a model with each attribute having and error
var model = new Model({
attributes: [
new Attribute({name: 'Name', validationRule: {required: true}}),
new Attribute({name: 'Age', type: 'Number', validationRule: {range: [18, null]}}),
new Attribute({name: 'Sex', validationRule: {required: true}})
]
});
model.setError('danger', 'Danger Will Robinson');
// Create a model validation where males have to be 21
model.onEvent('Validate', function () {
var name = model.get('name');
var age = model.get('age');
var sex = model.get('sex');
if (sex != 'F' && age < 21)
model.validationErrors.push('Males must be 21 or over');
});
model.validate(test1);
// Expect 1 error from B9 Robot (Attribute errors ignored if model state error)
function test1() {
if (model.validationErrors.length == 1) {
model.clearError('danger');
model.validate(test2);
} else {
callback('test1: ' + model.validationErrors.length);
}
}
// Expect 3 errors for each attribute
function test2() {
if (model.validationErrors.length == 3) {
model.set('name', 'John Doe');
model.set('age', 18);
model.set('sex', 'M');
model.validate(test3);
} else {
callback('test2: ' + model.validationErrors.length);
}
}
// Expect 1 errors since all attributes fixed but model will fail
function test3() {
if (model.validationErrors.length == 1 && model.validationMessage == 'Males must be 21 or over') {
model.set('age', 21);
model.validate(test4);
} else {
callback('test3: ' + model.validationErrors.length);
}
}
// Test done should be no errors (to pass final test)
function test4() {
callback('test4: ' + model.validationErrors.length);
}
```
returns test4: 0 as expected
*29 model tests applied*
#### ATTRIBUTES
following attributes are defined::
```javascript
var user = new Workspace(); // default attributes and values
this.shouldBeTrue(user.get('id') !== undefined);
this.shouldBeTrue(user.get('user') instanceof Attribute.ModelID);
this.shouldBeTrue(user.get('user').modelType == 'User');
this.shouldBeTrue(typeof user.get('deltas') == 'object');
```
#### METHODS
loadUserWorkspace(user, callback)
sync
#### INTEGRATION
## [◀](#-workspace) [⌘](#constructors) [▶](#-array-functions) MemoryStore
#### MemoryStore
The MemoryStore is a simple volatile store. It is the first test standard to define the spec for all Stores to follow.
#### CONSTRUCTOR
#### Store Constructor tests are applied
objects created should be an instance of Store:
```javascript
return new SurrogateStore() instanceof Store;
```
returns true as expected
should make sure new operator used:
```javascript
SurrogateStore(); // jshint ignore:line
```
Error: new operator required thrown as expected
should make sure properties are valid:
```javascript
new SurrogateStore({food: 'twinkies'});
```
Error: error creating Store: invalid property: food thrown as expected
objects created should be an instance of MemoryStore:
```javascript
return new MemoryStore() instanceof MemoryStore;
```
returns true as expected
#### Store tests are applied
#### PROPERTIES
#### name
name of store can be set in constructor:
```javascript
return new SurrogateStore({name: 'punchedCards'}).name;
```
returns punchedCards as expected
#### 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;
```
returns legacyStorage as expected
#### 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');
```
log: {"isReady":true,"canGetModel":true,"canPutModel":true,"canDeleteModel":true,"canGetList":true}
#### 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();
```
log: a MemoryStore
log: ConvenienceStore: 7-Eleven
returns ConvenienceStore: 7-Eleven as expected
#### onConnect()
must pass url string:
```javascript
new SurrogateStore().onConnect();
```
Error: argument must a url string thrown as expected
must pass callback function:
```javascript
new SurrogateStore().onConnect("");
```
Error: argument must a callback thrown as expected
return store and undefined error upon successful connection to remote store.:
```javascript
new SurrogateStore().onConnect('', function (store, err) {
if (err) {
callback(err);
} else {
callback(store instanceof Store);
}
});
```
returns true as expected
#### getModel()
must pass valid model:
```javascript
new SurrogateStore().getModel();
```
Error: argument must be a Model thrown as expected
model must have no validation errors:
```javascript
var m = new Model();
m.attributes = null;
new SurrogateStore().getModel(m);
```
Error: model has validation errors thrown as expected
ID attribute must have truthy value:
```javascript
new SurrogateStore().getModel(new Model());
```
Error: ID not set thrown as expected
callback function required:
```javascript
var m = new Model();
m.attributes[0].value = 1;
new SurrogateStore().getModel(m);
```
Error: callback required thrown as expected
returns error when model not found:
```javascript
var m = new Model();
m.modelType = "Supermodel"; // change type so one not used in tests
m.attributes[0].value = 1;
new SurrogateStore().getModel(m, function (mod, err) {
if (err) {
callback(err);
} else {
callback(mod);
}
});
```
returns Error: model not found in store as expected
#### putModel(model)
must pass valid model:
```javascript
new SurrogateStore().putModel();
```
Error: argument must be a Model thrown as expected
model must have no validation errors:
```javascript
var m = new Model();
m.attributes = null;
new SurrogateStore().putModel(m);
```
Error: model has validation errors thrown as expected
callback function required:
```javascript
var m = new Model();
m.attributes[0].value = 1;
new SurrogateStore().putModel(m);
```
Error: callback required thrown as expected
returns error when model not found:
```javascript
var m = new Model();
m.modelType = "Supermodel";
m.attributes[0].value = 1;
new SurrogateStore().putModel(m, function (mod, err) {
if (err) {
callback(err);
} else {
callback(mod);
}
});
```
returns Error: model not found in store as expected
creates new model when ID is not set:
```javascript
// This works but pollutes store with crap
var m = new Model();
new SurrogateStore().putModel(m, function (mod, err) {
if (err) {
callback(err);
} else {
callback(mod.get('id') ? true : false);
}
});
```
returns true as expected
#### deleteModel(model)
must pass valid model:
```javascript
new SurrogateStore().deleteModel();
```
Error: argument must be a Model thrown as expected
model must have no validation errors:
```javascript
var m = new Model();
m.attributes = null;
new SurrogateStore().deleteModel(m);
```
Error: model has validation errors thrown as expected
callback function required:
```javascript
var m = new Model();
m.attributes[0].value = 1;
new SurrogateStore().deleteModel(m);
```
Error: callback required thrown as expected
returns error when model not found:
```javascript
var m = new Model();
m.modelType = 'PeopleAreString!';
m.attributes[0].value = 90210;
new SurrogateStore().deleteModel(m, function (mod, err) {
if (err) {
callback(err);
} else {
callback(mod);
}
});
```
returns Error: model not found in store as expected
#### 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._
returns a List populated from store:
```javascript
this.shouldThrowError(Error('argument must be a List'), function () {
new SurrogateStore().getList();
});
this.shouldThrowError(Error('List is View type use getViewList'), function () {
new SurrogateStore().getList(new List(new View(new Model(), {}, [])));
});
this.shouldThrowError(Error('filter argument must be Object'), function () {
new SurrogateStore().getList(new List(new Model()));
});
this.shouldThrowError(Error('callback required'), function () {
new SurrogateStore().getList(new List(new Model()), []);
});
// See integration tests for examples of usage
```
#### getViewList(list, filter, [optional order], callback)
This method provides getList() for View type Lists. _See integration test for more info._
returns a List populated from store:
```javascript
this.shouldThrowError(Error('argument must be a List'), function () {
new SurrogateStore().getViewList();
});
this.shouldThrowError(Error('List is Model type use getList'), function () {
new SurrogateStore().getViewList(new List(new Model()));
});
this.shouldThrowError(Error('filter argument must be Object'), function () {
new SurrogateStore().getViewList(new List(new View(new Model(), {}, [])));
});
this.shouldThrowError(Error('callback required'), function () {
new SurrogateStore().getViewList(new List(new View(new Model(), {}, [])), []);
});
// See integration tests for examples of usage
```
#### 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);
});
```
returns true as expected
## [◀](#-memorystore) [⌘](#constructors) [▶](#-object-functions) Array Functions
#### ARRAY FUNCTIONS
#### contains(array,object)
This method returns true or false as to whether object is contained in array.
object exists in array:
```javascript
return contains(['moe', 'larry', 'curley'], 'larry');
```
returns true as expected
object does not exist in array:
```javascript
return contains(['moe', 'larry', 'curley'], 'shemp');
```
## [◀](#-array-functions) [⌘](#constructors) [▶](#-string-functions) Object Functions
#### inheritPrototype(p)
[deprecated] ex: User.prototype = Object.create(Model.prototype);
Cannot pass null:
```javascript
this.shouldThrowError('*', function () {
inheritPrototype(null);
});
```
quack like a duck:
```javascript
// Duck class
var Duck = function () {
};
// Duck method
Duck.prototype.sound = function () {
return 'quack';
};
// Mallard class
var Mallard = function () {
};
// Mallard inherits Duck prototype
Mallard.prototype = inheritPrototype(Duck.prototype);
// Create instance
var daffy = new Mallard();
// Instance of constructor & the inherited prototype's class fir daffy
this.shouldBeTrue(daffy instanceof Mallard);
this.shouldBeTrue(daffy instanceof Duck);
// What sound does daffy make?
return daffy.sound();
```
returns quack as expected
#### getInvalidProperties(args,allowedProperties)
Functions that take an object as it's parameter use this to validate the properties of the parameter by returning any invalid properties
valid property:
```javascript
// got Kahn and value backwards so Kahn is an unknown property
return getInvalidProperties({name: 'name', Kahn: 'value'}, ['name', 'value'])[0];
```
returns Kahn as expected
invalid property:
```javascript
// no unknown properties
return getInvalidProperties({name: 'name', value: 'Kahn'}, ['name', 'value']).length;
```
#### getConstructorFromModelType(modelType)
returns Model constructor if type not registered:
```javascript
return getConstructorFromModelType();
```
returns function (args) {
var i;
if (false === (this instanceof Model)) throw new Error('new operator required');
this.attributes = [new Attribute('id', 'ID')];
args = args || {};
this.modelType = args.modelType || "Model";
if (args.attributes) {
for (i in args.attributes) {
if (args.attributes.hasOwnProperty(i))
this.attributes.push(args.attributes[i]);
}
}
var unusedProperties = getInvalidProperties(args, ['modelType', 'attributes']);
var errorList = this.getObjectStateErrors(); // before leaving make sure valid Model
for (i = 0; i < unusedProperties.length; i++) errorList.push('invalid property: ' + unusedProperties[i]);
if (errorList.length > 1) throw new Error('error creating Model: multiple errors');
if (errorList.length) throw new Error('error creating Model: ' + errorList[0]);
// Validations done
this._eventListeners = [];
this._errorConditions = {};
//for (i = 0; i < this.attributes.length; i++) {
// this.attributes[i].model = this;
//}
} as expected
registered models return the constructor function:
```javascript
return getConstructorFromModelType('User');
```
returns function (args) {
if (false === (this instanceof User)) throw new Error('new operator required');
args = args || {};
if (!args.attributes) {
args.attributes = [];
}
args.attributes.push(new Attribute({name: 'name', type: 'String(20)'}));
args.attributes.push(new Attribute({name: 'active', type: 'Boolean'}));
args.attributes.push(new Attribute({name: 'password', type: 'String(20)'}));
args.attributes.push(new Attribute({name: 'firstName', type: 'String(35)'}));
args.attributes.push(new Attribute({name: 'lastName', type: 'String(35)'}));
args.attributes.push(new Attribute({name: 'email', type: 'String(20)'}));
Model.call(this, args);
this.modelType = "User";
this.set('active', false);
} as expected
objects created utilize proper constructor:
```javascript
var ProxyModel = getConstructorFromModelType('User');
var proxyModel = new ProxyModel();
return proxyModel.get('active');
```
Core models are known:
```javascript
this.shouldBeTrue(getConstructorFromModelType('User') == User);
this.shouldBeTrue(getConstructorFromModelType('Session') == Session);
this.shouldBeTrue(getConstructorFromModelType('Workspace') == Workspace);
this.shouldBeTrue(getConstructorFromModelType('Presentation') == Presentation);
this.shouldBeTrue(getConstructorFromModelType('Log') == Log);
this.shouldBeTrue(getConstructorFromModelType('Application') == Application);
```
#### createModelFromModelType
returns instance of Model if type not registered:
```javascript
return createModelFromModelType().modelType;
```
returns Model as expected
objects created utilize proper constructor:
```javascript
return createModelFromModelType('User').get('active');
```
## [◀](#-object-functions) [⌘](#constructors) [▶](#-mongodb) String Functions
#### STRING FUNCTIONS
#### trim(string)
Remove leading and trailing spaces from string:
```javascript
return '(' + trim(' hello ') + ')';
```
returns (hello) as expected
#### ltrim(string)
Remove leading spaces from string:
```javascript
return '(' + ltrim(' hello ') + ')';
```
returns (hello ) as expected
#### rtrim(string)
Remove trailing spaces from string:
```javascript
return '(' + rtrim(' hello ') + ')';
```
returns ( hello) as expected
#### left(string)
return left part of string:
```javascript
return left('12345',3);
```
returns 123 as expected
#### right(string)
return right part of string:
```javascript
return right('12345',3);
```
returns 345 as expected
#### center(string)
return center part of string:
```javascript
return center('12345',3);
```
returns 234 as expected
#### lpad(string, length, fillChar)
Return string size length with fillChar padded on left. fillChar is optional and defaults to space.
add leading asteriks:
```javascript
return lpad('42', 10, '*');
```
returns ********42 as expected
truncate when length is less than string length:
```javascript
return lpad('okay', 2);
```
returns ok as expected
fillChar defaults to space:
```javascript
return ':' + lpad('x',2) + ':';
```
returns : x: as expected
#### rpad(string, length, fillChar)
Return string size length with fillChar padded on right. fillChar is optional and defaults to space.
Add trailing periods:
```javascript
return rpad('etc', 6, '.');
```
returns etc... as expected
truncate when length is less than string length:
```javascript
return rpad('wassup', 3);
```
returns sup as expected
fillChar defaults to space:
```javascript
return ':' + rpad('x',2) + ':';
```
returns :x : as expected
#### cpad(string, length, fillChar)
Return string size length with fillChar padded on left and right. fillChar is optional and defaults to space.
center with periods:
```javascript
return cpad('center', 13, '.');
```
returns ...center.... as expected
truncate when length is less than string length:
```javascript
return cpad('abcdef', 2);
```
returns cd as expected
fillChar defaults to space:
```javascript
return ':' + cpad('x',3) + ':';
```
returns : x : as expected
## [◀](#-string-functions) [⌘](#constructors) [▶](#-summary) MONGODB
#### MongoStore
The MongoStore handles data storage via MongoDB.
Core tests run: {"testsCreated":29}
#### CONSTRUCTOR
#### Store Constructor tests are applied
objects created should be an instance of Store:
```javascript
return new SurrogateStore() instanceof Store;
```
returns true as expected
should make sure new operator used:
```javascript
SurrogateStore(); // jshint ignore:line
```
Error: new operator required thrown as expected
should make sure properties are valid:
```javascript
new SurrogateStore({food: 'twinkies'});
```
Error: error creating Store: invalid property: food thrown as expected
objects created should be an instance of MongoStore:
```javascript
return new MongoStore() instanceof MongoStore;
```
returns true as expected
#### Store tests are applied
#### PROPERTIES
#### name
name of store can be set in constructor:
```javascript
return new SurrogateStore({name: 'punchedCards'}).name;
```
returns punchedCards as expected
#### 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;
```
returns legacyStorage as expected
#### 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');
```
log: {"isReady":true,"canGetModel":true,"canPutModel":true,"canDeleteModel":true,"canGetList":true}
#### 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();
```
log: a MongoStore
log: ConvenienceStore: 7-Eleven
returns ConvenienceStore: 7-Eleven as expected
#### onConnect()
must pass url string:
```javascript
new SurrogateStore().onConnect();
```
Error: argument must a url string thrown as expected
must pass callback function:
```javascript
new SurrogateStore().onConnect("");
```
Error: argument must a callback thrown as expected
return store and undefined error upon successful connection to remote store.:
```javascript
new SurrogateStore().onConnect('', function (store, err) {
if (err) {
callback(err);
} else {
callback(store instanceof Store);
}
});
```
returns true as expected
#### getModel()
must pass valid model:
```javascript
new SurrogateStore().getModel();
```
Error: argument must be a Model thrown as expected
model must have no validation errors:
```javascript
var m = new Model();
m.attributes = null;
new SurrogateStore().getModel(m);
```
Error: model has validation errors thrown as expected
ID attribute must have truthy value:
```javascript
new SurrogateStore().getModel(new Model());
```
Error: ID not set thrown as expected
callback function required:
```javascript
var m = new Model();
m.attributes[0].value = 1;
new SurrogateStore().getModel(m);
```
Error: callback required thrown as expected
returns error when model not found:
```javascript
var m = new Model();
m.modelType = "Supermodel"; // change type so one not used in tests
m.attributes[0].value = 1;
new SurrogateStore().getModel(m, function (mod, err) {
if (err) {
callback(err);
} else {
callback(mod);
}
});
```
returns Error: model not found in store as expected
#### putModel(model)
must pass valid model:
```javascript
new SurrogateStore().putModel();
```
Error: argument must be a Model thrown as expected
model must have no validation errors:
```javascript
var m = new Model();
m.attributes = null;
new SurrogateStore().putModel(m);
```
Error: model has validation errors thrown as expected
callback function required:
```javascript
var m = new Model();
m.attributes[0].value = 1;
new SurrogateStore().putModel(m);
```
Error: callback required thrown as expected
returns error when model not found:
```javascript
var m = new Model();
m.modelType = "Supermodel";
m.attributes[0].value = 1;
new SurrogateStore().putModel(m, function (mod, err) {
if (err) {
callback(err);
} else {
callback(mod);
}
});
```
returns Error: model not found in store as expected
creates new model when ID is not set:
```javascript
// This works but pollutes store with crap
var m = new Model();
new SurrogateStore().putModel(m, function (mod, err) {
if (err) {
callback(err);
} else {
callback(mod.get('id') ? true : false);
}
});
```
returns true as expected
#### deleteModel(model)
must pass valid model:
```javascript
new SurrogateStore().deleteModel();
```
Error: argument must be a Model thrown as expected
model must have no validation errors:
```javascript
var m = new Model();
m.attributes = null;
new SurrogateStore().deleteModel(m);
```
Error: model has validation errors thrown as expected
callback function required:
```javascript
var m = new Model();
m.attributes[0].value = 1;
new SurrogateStore().deleteModel(m);
```
Error: callback required thrown as expected
returns error when model not found:
```javascript
var m = new Model();
m.modelType = 'PeopleAreString!';
m.attributes[0].value = 90210;
new SurrogateStore().deleteModel(m, function (mod, err) {
if (err) {
callback(err);
} else {
callback(mod);
}
});
```
returns Error: model not found in store as expected
#### 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._
returns a List populated from store:
```javascript
this.shouldThrowError(Error('argument must be a List'), function () {
new SurrogateStore().getList();
});
this.shouldThrowError(Error('List is View type use getViewList'), function () {
new SurrogateStore().getList(new List(new View(new Model(), {}, [])));
});
this.shouldThrowError(Error('filter argument must be Object'), function () {
new SurrogateStore().getList(new List(new Model()));
});
this.shouldThrowError(Error('callback required'), function () {
new SurrogateStore().getList(new List(new Model()), []);
});
// See integration tests for examples of usage
```
#### getViewList(list, filter, [optional order], callback)
This method provides getList() for View type Lists. _See integration test for more info._
returns a List populated from store:
```javascript
this.shouldThrowError(Error('argument must be a List'), function () {
new SurrogateStore().getViewList();
});
this.shouldThrowError(Error('List is Model type use getList'), function () {
new SurrogateStore().getViewList(new List(new Model()));
});
this.shouldThrowError(Error('filter argument must be Object'), function () {
new SurrogateStore().getViewList(new List(new View(new Model(), {}, [])));
});
this.shouldThrowError(Error('callback required'), function () {
new SurrogateStore().getViewList(new List(new View(new Model(), {}, [])), []);
});
// See integration tests for examples of usage
```
#### 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);
});
```
returns true as expected
Test variations on getList method.:
```javascript
var test = this;
var storeBeingTested = new SurrogateStore();
test.log('storeBeingTested: ' + storeBeingTested);
// Create list of actors
test.actorsInfo = [
// Actor Born Male Oscards
['Jack Nicholson', new Date("01/01/1937"), true, 3],
['Meryl Streep', new Date("01/01/1949"), false, 3],
['Marlon Brando', new Date("01/01/1924"), true, 2],
['Cate Blanchett', new Date("01/01/1969"), false, 1],
['Robert De Niro', new Date("01/01/1943"), true, 2],
['Judi Dench', new Date("01/01/1934"), false, 1],
['Al Pacino', new Date("01/01/1940"), true, 1],
['Nicole Kidman', new Date("01/01/1967"), false, null],
['Daniel Day-Lewis', new Date("01/01/1957"), true, null],
['Shirley MacLaine', new Date("01/01/1934"), false, null],
['Dustin Hoffman', new Date("01/01/1937"), true, null],
['Jodie Foster', new Date("01/01/1962"), false, null],
['Tom Hanks', new Date("01/01/1956"), true, null],
['Kate Winslet', new Date("01/01/1975"), false, null],
['Anthony Hopkins', new Date("01/01/1937"), true, null],
['Angelina Jolie', new Date("01/01/1975"), false, null],
['Paul Newman', new Date("01/01/1925"), true, null],
['Sandra Bullock', new Date("01/01/1964"), false, null],
['Denzel Washington', new Date("01/01/1954"), true, null],
['Renée Zellweger', new Date("01/01/1969"), false, null]
];
// Create actor class
test.Actor = function (args) {
Model.call(this, args);
this.modelType = "Actor";
this.attributes.push(new Attribute('name'));
this.attributes.push(new Attribute('born', 'Date'));
this.attributes.push(new Attribute('isMale', 'Boolean'));
this.attributes.push(new Attribute('oscarWs', 'Number'));
};
test.Actor.prototype = inheritPrototype(Model.prototype);
test.actor = new test.Actor(); // instance to use for stuff
// Make sure store starts in known state. Stores such as mongoStore will retain test values.
// So... use getList to get all Actors then delete them from the Store
test.list = new List(new test.Actor());
test.oldActorsKilled = 0;
test.oldActorsFound = 0;
try {
test.killhim = new test.Actor();
storeBeingTested.getList(test.list, [], function (list, error) {
if (typeof error != 'undefined') {
callback(error);
return;
}
if (list._items.length < 1)
storeActors();
else {
test.oldActorsFound = list._items.length;
var testakill = function (model, error) {
if (++test.oldActorsKilled >= test.oldActorsFound) {
storeActors();
}
};
for (var i = 0; i < list._items.length; i++) {
test.killhim.set('id', list._items[i][0]);
storeBeingTested.deleteModel(test.killhim, testakill);
}
}
});
}
catch (err) {
callback(err);
}
// callback after model cleaned
// now, build List and add to store
function storeActors() {
test.actorsStored = 0;
for (var i = 0; i < test.actorsInfo.length; i++) {
test.actor.set('ID', null);
test.actor.set('name', test.actorsInfo[i][0]);
test.actor.set('born', test.actorsInfo[i][1]);
test.actor.set('isMale', test.actorsInfo[i][2]);
storeBeingTested.putModel(test.actor, actorStored);
}
}
// callback after actor stored
function actorStored(model, error) {
if (typeof error != 'undefined') {
callback(error);
return;
}
if (++test.actorsStored >= test.actorsInfo.length) {
getAllActors();
}
}
// test getting all 20
function getAllActors() {
try {
storeBeingTested.getList(test.list, {}, function (list, error) {
if (typeof error != 'undefined') {
callback(error);
return;
}
test.shouldBeTrue(list._items.length == 20, '20');
getTomHanks();
});
}
catch (err) {
callback(err);
}
}
// only one Tom Hanks
function getTomHanks() {
try {
storeBeingTested.getList(test.list, {name: "Tom Hanks"}, function (list, error) {
if (typeof error != 'undefined') {
callback(error);
return;
}
test.shouldBeTrue(list._items.length == 1, ('1 not ' + list._items.length));
getD();
});
}
catch (err) {
callback(err);
}
}
// 3 names begin with D
// test RegExp
function getD() {
try {
storeBeingTested.getList(test.list, {name: /^D/}, function (list, error) {
if (typeof error != 'undefined') {
callback(error);
return;
}
test.shouldBeTrue(list._items.length == 3, ('3 not ' + list._items.length));
getRZ();
});
}
catch (err) {
callback(err);
}
}
// Renée Zellweger only female starting name with 'R'
// test filter 2 properties (logical AND)
function getRZ() {
try {
storeBeingTested.getList(test.list, {name: /^r/i, isMale: false}, function (list, error) {
if (typeof error != 'undefined') {
callback(error);
return;
}
test.shouldBeTrue(list._items.length == 1, ('1 not ' + list._items.length));
if (list._items.length)
test.shouldBeTrue(list.get('name') == 'Renée Zellweger', 'rz');
getAlphabetical();
});
}
catch (err) {
callback(err);
}
}
// Retrieve list alphabetically by name
// test order parameter
function getAlphabetical() {
try {
storeBeingTested.getList(test.list, {}, {name: 1}, function (list, error) {
if (typeof error != 'undefined') {
callback(error);
return;
}
// Verify each move returns true when move succeeds
test.shouldBeTrue(list.moveFirst(), 'moveFirst');
test.shouldBeTrue(!list.movePrevious(), 'movePrevious');
test.shouldBeTrue(list.get('name') == 'Al Pacino', 'AP');
test.shouldBeTrue(list.moveLast(), 'moveLast');
test.shouldBeTrue(!list.moveNext(), 'moveNext');
test.shouldBeTrue(list.get('name') == 'Tom Hanks', 'TH');
callback(true);
});
}
catch (err) {
callback(err);
}
}
```
log: storeBeingTested: a MongoStore
returns true as expected
## [◀](#-mongodb) [⌘](#constructors) Summary
This documentation generated with https://github.com/tgicloud/tgi-spec.
TODO put testin stats here.