// complete (quiet) mocking with params and return
var foo = schmock.mock('foo');
foo.when('bar').with(1,'2').return('response');
foo.when('bar').with(3,'4').return('response2');
 
assert.equal('response',foo.bar(1,'2'));            // PASS
assert.equal('response',foo.bar(1));                // FAIL
assert.equal(null,foo.bar(1));                      // PASS
assert.equal('response',foo.bar(1,'3'));            // FAIL
assert.equal('response',foo.bar(1,'2','3'));        // FAIL
assert.equal('response',foo.bar(1,undefined));      // FAIL
assert.equal('response',foo.bar(1,null));           // FAIL
assert.equal('response2',foo.bar(3,'4'));           // PASS
 
// complete (loud) mocking with params and return
foo = schmock.mock('foo').loud();
foo.when('bar').with(1).return('response');
 
assert.equal('response',foo.bar());     // OK
foo.bar(2);                             // Error: expected argument:'1' did not match actual:'2' for argument 1
foo.bar();                              // Error: expected number of arguments:1 did not match actual:0
foo.bar(1,2);                           // Error: expected number of arguments:1 did not match actual:2
 
// complete mocking with throw
foo = schmock.mock('foo');
foo.when('bar').with(1234).throw(new Error('Ham Sandwiches!'));
foo.bar(1234);  // Error: Ham Sandwiches!
 
// complete mocking with a callback
var foo = schmock.mock('foo');
foo.when('bar').callback(function (one,two,three) {
    console.log(one);   // Prints 1
    console.log(two);   // Prints 2
    console.log(three); // Prints 3
}).with(1,2,3);
foo.bar();
 
// complete mocking with a callback and return
foo = schmock.mock('foo');
var callbackInvoked = false;
foo.when('bar').return(1234).callback(function (one,two,three) {
    console.log(one);           // Prints 1
    console.log(two);           // Prints 2
    console.log(three);         // Prints 3
}).with(1,2,3);
assert.equal(1234,foo.bar());   // OK
 
// complete mocking with a callback and throw
foo = schmock.mock('foo');
callbackInvoked = false;
foo.when('bar').callback(function (one) {
   console.log(one);                    // Prints 1
   callbackInvoked = true;
}).with(1).throw(new Error('OMG!'));
foo.bar();                              // Error: OMG!
 
// mocking without params and with a return
foo = schmock.mock('foo');
foo.when('bar').return(1234);
assert.equal(1234, foo.bar());  // OK
 
// mocking without params, return and throw
foo = schmock.mock('foo');
foo.when('bar').throw(new Error('OMG!'));
foo.bar();  // Error: OMG!
 
// verify method was called 'n' times
var foo = schmock.mock('foo');
foo.when('bar').with(1,'2').times(1);
foo.bar(1,'2');
foo.verify();       // OK
foo.bar(1,'2');
foo.verify();       // "Error: mocked method:'bar' was called with [1,'2'] 2 times, but was expected 1 times"
 
// expect a method to be called 'n' times (with no return or callback behavior)
var foo = schmock.mock('foo');
foo.expect('bar').with(1,'3').times(1);
foo.expect('bar').with(1,'2').times(0);
foo.bar(1,'3');
foo.verify();       // OK
foo.bar(1,'2');
foo.verify();       // "Error: mocked method:'bar' was called with [1,'2] 1 time, but was expected 0 times"

var schmock = require('schmock');
 
// newly created mocks will throw errors when method parameters do not match
schmock.loud();
 
// newly created mocks will log errors and return null from methods when method parameters do not match
// Default
schmock.quiet();
 
// create a mock
var foo = schmock.mock();
// create a mock with an optional name parameter for identification in console log messages (quiet mode)
foo = schmock.mock('foo');
 
// this mock will throw errors when method parameters do not match
foo = foo.loud();
 
// this mock will log errors and return null from methods when method parameters do not match
foo = foo.quiet();
 
// mock the method 'bar'
var bar = foo.when('bar');
 
// expect the params (1,'param2') to be passed to 'bar' when called
bar = bar.with(1,'param2');
 
// return 'response' when 'bar' is called
bar.return('response');
 
// return the result of function when 'bar' is called
bar.return(function() {
    return 'response'; 
});
 
// throw an Error when 'bar' is called
bar.throw(new Error('oops!'));
 
// invoke a callback when 'bar' is called
bar.callback(function() {
   console.log('callback invoked');
});
 
// invoke a callback with params when 'bar' is called
bar.callback(function(one,two,three) {
}).with(1,2.3);
 
// invoke a callback with params and return a value when 'bar' is called
bar.callback(function(one,two,three) {
}).with(1,2.3).return('response');
// OR
bar.return('response').callback(function(one,two,three) {
}).with(1,2.3);
 
// invoke a callback with params and throw an Error when 'bar' is called
bar.callback(function(one,two,three) {
}).with(1,2.3).throw(new Error('oops!'));
// OR
bar.throw(new Error('oops!')).callback(function(one,two,three) {
}).with(1,2.3);