memo-is provides a memoization system with the same semantics as #let
in
RSpec for Ruby. It allows you to provide a function that should be memoized
for the duration of a spec example and reset between examples. It also
supports nested overriding, as expected.
It will work with Jasmine and Mocha out of the box, since it only needs to
hook into beforeEach()
and afterEach()
hooks to work. It may work with
other testing frameworks (e.g. vows) if you can provide implementations of
beforeEach()
and afterEach()
to do the correct thing.
This should work just fine in a browser, if you include the lib/memo-is.js
file via a <script>
tag. For Node.js, you can install it via NPM:
npm install memo-is
What better way to document this usage than with a spec? :-) This is the actual spec from the package itself.
var memo = require('memo-is')
, assert = require('assert')
;
describe('Memoizer', function(){
var example = memo().is(function() { return []; });
var value;
beforeEach(function() { value = example(); });
it('returns the same value every time', function(){
assert(example() === example());
});
describe('when overridden', function(){
example.is(function() { return ['bob']; });
it('returns the overridden value', function(){
assert.equal(example()[0], 'bob');
});
it('is available in the before of an outer context', function(){
assert.equal(value[0], 'bob');
});
describe('and used in a sub context', function(){
it('returns the overridden value', function(){
assert.equal(example()[0], 'bob');
});
});
});
describe('state between tests', function(){
it('is reset to the value for the current context', function(){
assert.equal(example().length, 0);
});
describe('when the value is modified', function(){
it('is changed in the example that modifies it', function(){
example().push(42);
assert.equal(example()[0], 42);
});
it('is reset between examples', function(){
assert.equal(example().length, 0);
});
});
});
});
One thing you should be aware of is the fact that memo-is depends on the
before()
hook in order to prepare the memoized function. When working with
the memoized function inside a beforeEach()
, you won't have any unexpected
issues. When working with it inside a before()
hook of a context nested
deeper than where the memoized function is defined, you won't have any issues
neither. When working, however, with a before()
hook in the same context as
where you define the memoized function, you must define the memoizer first,
so that it is available in your before()
hook.
This is fine:
describe('using inside a before()', function(){
var numPlusOne;
var example = memo().is(function(){ return 42; });
before(function() { numPlusOne = example() + 1; }
it('works when the hook is declared after the memoizer', function(){
assert.equal(numPlusOne, 43);
});
});
This won't work:
describe('using inside a before()', function(){
var numPlusOne;
before(function() { numPlusOne = example() + 1; }
var example = memo().is(function(){ return 42; }); // too late!
it('explodes in an unexpected way', function(){
assert.equal(numPlusOne, 43);
});
});
The same applies for overriding memoizer functions—do the override first.
If anybody can think of a way to remove this limitation, please send a pull
request :-) In a perfect world, it would hook into something that runs before
the before()
hook; it feels like I'd need to patch Mocha to achieve that.
Written and maintained by Chris Corbyn. Licensed under the MIT license. See the LICENSE file for details.