guzzlerio / deride Goto Github PK

var Person = deride.construct(Person);
var bob = new Person('bob');
bob.expect.constructedWith('bob');

connectionFactory.setup.connect
  .toResolveWith(mockConnection)
  .twice()
  .and.then
  .toRejectWith(new Error('Boom')

describe('multi', function() {
    it('only uses the stub x times', function() {
        bob.setup.greet
            .toReturn('alice')
            .twice()
            .and.then
            .toReturn('sally');
        bob.greet().should.eql('alice');
        bob.greet().should.eql('alice');
        bob.greet().should.eql('sally');
        bob.greet().should.eql('sally');
    });

    it('only uses the stub x times and then falls back', function() {
        var normalResult = bob.greet('alice');
        bob.setup.greet
            .toReturn('alice')
            .twice();
        bob.greet('alice').should.eql('alice');
        bob.greet('alice').should.eql('alice');
        should(bob.greet('alice')).eql(normalResult);
    });

    describe('also supports when specific arguments are provided', function() {
        it('only uses the stub X times when called with matching args', function() {
            var normalResult = bob.greet('talula');
            var normalSimon = bob.greet('simon');
            bob.setup.greet
                .when('simon')
                .toReturn('alice')
                .twice();
            // default Person behaviour
            should(bob.greet('talula')).eql(normalResult);
            // overridden behaviour
            bob.greet('simon').should.eql('alice');
            bob.greet('simon').should.eql('alice');
            // default Person behaviour
            should(bob.greet('simon')).eql(normalSimon);
        });

        it('falls back to default stub behaviour after X matching invocations', function() {
            bob = deride.wrap(bob);
            bob.setup.greet
                .toReturn('talula')
                .but.when('simon')
                .toReturn('alice')
                .times(2);
                        // default stubbed behaviour for non matching invocation
            bob.greet('alice').should.eql('talula');
                        // stubbed behaviour for 1st matching invocation
            bob.greet('simon').should.eql('alice');
                        // stubbed behaviour for 2nd matching invocation
            bob.greet('simon').should.eql('alice');
                        // falls back to default stubbed behaviour for other matching invocations
            bob.greet('simon').should.eql('talula');
                        // default stubbed behaviour for non matching invocation
            bob.greet('alice').should.eql('talula');
        });
    });
});

dleConsumer.setup.when(function(msg){
  var content = JSON.parse(msg.content.toString());
  return content.resource === 'talula';
}).toDoThis(done);

it('can provide a predicate to when', function(done) {
    var func = deride.func();
    func.setup.when(function(msg) {
        var content = JSON.parse(msg.content.toString());
        return content.resource === 'talula';
    }).toDoThis(done);

    var msg = {
        //...
        //other properties that we do not know until runtime
        //...
        content: new Buffer(JSON.stringify({
                resource: 'talula'
        }))
    };
    func(msg);
});

var mapper = deride.stub(['map']);
mapper.setup.map.toDoThis(function(a, b, cb) {
  debug('mapper.map', a, b);
  cb(); 
});

it('booooom', function() {
    var obj = deride.stub(['send']);
    obj.send(['a', 'b'], function() {});
    obj.expect.send.called.withArgs(['a', 'b']);
});

var mapper = deride.stub(['map'], { prefix: 'mymodule:deride:mapper' });

var bob = deride.stub(['greet']);
bob.setup.greet.toReturn('hello');

bob.greet('The inspiration for this was that my colleague was having a look at other mocking frameworks and mentioned to me that they do not work when using Object.freeze in the objects to enforce encapsulation. This library builds on composition to create a mocking library that can work with objects which are frozen.');

bob.expect.greet.called.withMatch(/^The inspiration for this was/);

class Person {
  foo() { 
    console.log('foo');
  }
  greet(person) { 
    console.log('Howdy ' + person); 
  } 
}

let bob = new Person();
bob.greet('sam') // => Howd'y sam
bob = deride.wrap(bob);
bob.greet('sam') // => bob.greet is not a function

var f = function (name) { return 'hello ' + name; };
var func = deride.func(f);
assert(func('bob'), 'hello bob');
func.expect.called.withArg('bob');

describe('copy by reference', function () {

    var bob;
    beforeEach(function testSetup() {
        bob = deride.stub(['greet']);
        bob.setup.greet.toResolve();
    });

    var mutatedObject = {
        test: 'abc'
    };

    beforeEach(function sampleInvocationMutatingObject(done) {
        bob.greet(mutatedObject)
            .then(function () {
                mutatedObject.test = '123';
                done();
            });
    });

    it('should not expect mutated object', function () {
        bob.expect.greet.called.matchExactly({
            test: 'abc' // this fails but only passes with { test: '123' }
        });
    });
});

    function call() {
        calledWithArgs[timesCalled++] = _.cloneDeep(arguments);
    }

bob.setup.greet.toCallbackWith([null, 'hello']);
bob.greet('sally', function(){
  done('this is not the callback');
}, function(err, msg) {
  msg.should.eql('hello');
  done();
});

bob.setup.greet.toEmit('testing', 'arg1', {a: 1});
bob.on('testing', function(a1, a2) {
   a1.should.eql('arg1');
   a2.should.eql({a:1);
   done();
});
bob.greet('bob');