Instance
Instances are the individual results from a Sequelize call. In SequelizeMock, these objects have most of the same attributes as in the normal Sequelize Instance, however they also have a few additional bits of functionality.
Values for instances are defined by defaults provided to the Model Mock on definition and
they are overriden by values provided during queries. The major exceptions are the id
,
createdAt
, and updatedAt
values, which are available on all instances regardless of if
they are in the query or default values. This is the same way Sequelize will add these to
your instances.
The id
value is an auto-incrementing value with each query (unless provided as a part of
your query). The createdAt
and updatedAt
values are set to the current timestamp at the
time the instance is created.
Additionally, there are a few additional test methods you can use to test functionality
coming from Sequelize behavior. These methods are prefixed with a $
so as to distinguish
them from mocked native Sequelize functionality. Any test specific properties also include
a double underscore (__
) so that they are also uniquely distinguished from mock internals.
new Instance(defaults, [obj])
Instance Mock Object. Creation of this object should almost always be handled through the
Model
class methods. In cases when you need to create an Instance
directly, providing
the defaults
parameter should be enough, as the obj
overrides parameter is optional.
Parameters
Name | Type | Description |
---|---|---|
defaults | Object | The default values. This will come from the Model when created via that class |
[obj] | Object | Any overridden values that should be specific to this instance |
.dataValues
As with Sequelize, we include a dataValues
property which contains the values for the
instance. As with Sequelize, you should use other methods to edit the values for any
code that will also interact with Sequelize.
For test code, when possible, we also recommend you use other means to validate. But
this object is also available if needed.
Alias _values
$addValidationError(col, [message], [type]) -> Instance
Create a new validation error to be triggered the next time a validation would run. Any time Sequelize code would go to the database, it will trigger a check for any validation errors that should be thrown. This allows you to test any validation failures in a more unit-testing focused manner.
Once a validation has occured, all validation errors will be emptied from the queue and
returned in a single ValidationError
object.
If you do add validation errors for a test, be sure to clear the errors after each test
so you don't fail your next test in case a validation does not occur. You can do so by
calling the $clearValidationErrors
method.
Example
myUser.$addValidationError('email', 'Not a valid email address', 'InvalidEmail');
// ...
myUser.save().then(function () {}, function (error) {
// error will be a ValidationErrorItem
error.errors[0].type === 'InvalidEmail';
});
See
Parameters
Name | Type | Description |
---|---|---|
col | String | Field to add validation error for |
[message] | String | Message the error should contain |
[type] | String | Type of the validation error |
Return
Instance
: Instance object for chainability
$removeValidationError(col) -> Instance
Removes all validation errors that would be triggered against a specific column.
Parameters
Name | Type | Description |
---|---|---|
col | String | Field to remove validation errors for |
Return
Instance
: The object for chainability
$clearValidationErrors() -> Instance
Removes all validation errors for every column.
Example
beforeEach(function () {
myUser = new Instance({ 'name': 'Test' });
});
afterEach(function () {
// Recommended that you always run $clearValidationErrors after
// each test so that you don't pollute your test data
myUser.$clearValidationErrors();
});
Return
Instance
: The object for chainability
set(key, [val]) -> Instance
Sets the value for the given key. Also accepts an object as the first parameter and it will loop through the key/value pairs and set each.
Parameters
Name | Type | Description |
---|---|---|
key | String, Object | Key to set the value for. If key is an Object, each key/value pair will be set on the Instance |
[val] | Any | Any value to set on the Instance. If key is an Object, this parameter is ignored. |
Return
Instance
: The object for chainability
get([key]) -> Any, Object
If no key is provided, it will return all values on the Instance.
If a key is provided, it will return that value
Parameters
Name | Type | Description |
---|---|---|
[key] | String, Object | Key to get the value for |
Return
Any, Object
: either the value of the key, or all the values if there is no key or key is an object with plain set to true: {plain: true}
validate() -> Promise.<ValidationErrorItem|undefined>
Triggers validation. If there are errors added through $addValidationError
they will
be returned and the queue of validation errors will be cleared.
As with Sequelize, this will resolve any validation errors, not throw the errors.
Return
Promise.<ValidationErrorItem|undefined>
: will resolve with any errors, or with nothing if there were no errors queued.
save() -> Promise.<Instance>
Because there is no database that it saves to, this will mainly trigger validation of the Instance and reject the promise if there are any validation errors.
Return
Promise.<Instance>
: Instance if there are no validation errors, otherwise it will reject the promise with those errors
destroy() -> Promise
This simply sets the deletedAt
value and has no other effect on the mock Instance
Return
Promise
: will always resolve as a successful destroy
reload() -> Promise.<Instance>
This has no effect on the Instance
Return
Promise.<Instance>
: will always resolve with the current instance
update() -> Promise.<Instance>
Acts as a set()
then a save()
. That means this function will also trigger validation
and pass any errors along
See
Return
Promise.<Instance>
: Promise from the save function
toJSON() -> Object
Returns all the values in a JSON representation.
Alias toJson
Return
Object
: all the values on the object