note35 / sinon Goto Github PK

Pure
wrap2spy
unwrap
wrap2stub
args_type
pure
obj
prop
orig_func

sinon.createStubInstance
# If you want to create a stub object of MyConstructor, but don’t want the constructor
# to be invoked, use this utility function.

stub.resetBehavior();
# Resets the stub’s behaviour to the default behaviour

stub.resetHistory();
# Resets the stub’s history

stub.returnsArg(index);
# Causes the stub to return the argument at the provided index.
# stub.returnsArg(0); causes the stub to return the first argument.

stub.throws(function() { return new Error(); });
# Causes the stub to throw the exception returned by the function.

stub.callThrough();
# Causes the original method wrapped into the stub to be called when none 
# of the conditional stubs are matched.

class A:
	def B(self):
		return 5
stub = sinon.stub(A, 'B').onFirstCall().throws(BaseException('Hello World')).onSecondCall().returns(42)
stub() # error
stub()
stub()
stub.restore()

import sinon
import logging
log = logging.getLogger('test')
stub = sinon.stub(log, 'warning')

import sinon
import logging
import sys
log = logging.getLogger('test')
streamHandler = logging.StreamHandler(sys.stdout)
log.addHandler(streamHandler)
stub = sinon.stub(log, 'warning') # raises "TypeError: can't pickle thread.lock objects"

sinon.addBehavior(name, fn);
# Add a custom behavior. The name will be available as a function on stubs,
# and the chaining mechanism will be set up for you

stub.get(getterFn)
# Replaces a new getter for this stub.

stub.set(setterFn)
# Defines a new setter for this stub.

stub.value(newVal)
# Defines a new value for this stub.

stub = sinon.stub()
stub.withArgs('A')
stub.returns(5)
assert stub() == 5  # fails, returns None, and stub('A') returns 5

class C():
    def f2(self, x):
        return x*2
c = C()
stub = sinon.stub(c, 'f2')
stub.onCall(0).returns(0)
stub.onCall(1).returns(1)
stub.onCall(2).returns(2)
assert c.f2() == 0 # fails, returns 1
assert c.f2() == 1
assert c.f2() == 2

import sinon
import urllib2
stub = sinon.stub(urllib2, 'urlopen').onFirstCall().throws(BaseException('Hello World')).onSecondCall().returns(42)
stub() # error
stub()
stub()
stub.restore() # error

var stub = sinon.stub(object, "method", func);
# This has been removed from v3.0.0. Instead you should use
# stub(obj, 'meth').callsFake(fn)

stub = sinon.stub()
stub.withArgs('A').onFirstCall().returns(1)
stub.withArgs('A').onSecondCall().returns(2)
stub.withArgs('B').onFirstCall().returns(10)
stub.withArgs('B').onSecondCall().returns(20)
assert stub() == None
assert stub('A') == 1  # fails, returns 2
assert stub('A') == 2  # fails, returns None
assert stub('A') == None
assert stub('B') == 10  # fails, returns None
assert stub('B') == 20  # fails, returns None
assert stub('B') == None

import sinon
import os
os.system("cd") # returns 0
stub = sinon.stub(os, "system").returns(5)
os.system("cd") # returns 5
stub.callCount # returns 1
stub.reset()
stub.callCount # returns 0
os.system("cd") # returns 0, which is wrong! should return None
stub.returns(5)
os.system("cd") # returns 0, which is wrong! should return 5

stub_function_fsm_table = {
    "onCall": {"returns", "throws"},
    "withArgs": {"onCall", "returns", "throws"}
}
CURRENT_STATE = ""

def fsm_control(func, *args, **kwargs):
    def inner_fsm_control():
        if CURRENT_STATE and func.__name__ in stub_function_fsm_table[CURRENT_STATE]:
            CURRENT_STATE = func.__name__
            return func(*args, **kwargs)
        else:
            raise Exception("not allowed")
    return inner_fsm_control

@fsm_control
def onCall(...):
   ...

stub = sinon.stub()
stub.withArgs(3) # this condition is lost
stub.returns(5)  # line 3, state is reset
assert stub() == 5

stub.callsArgAsync(index);
# Same as their corresponding non-Async counterparts, but with callback 
# being deferred (executed not immediately but after short timeout and in another “thread”)

spy.notCalled  # true if the spy was not called

spy.calledImmediatelyBefore(anotherSpy);
# Returns true if spy was called before anotherSpy, and no spy calls occurred between spy and 
# anotherSpy.

spy.calledImmediatelyAfter(anotherSpy);
# Returns true if spy was called after anotherSpy, and no spy calls occurred between anotherSpy and spy.

spy.getCalls()  # Returns an Array of all calls recorded by the spy.

spyCall.calledWith(arg1, arg2, ...); # Returns true if call received provided arguments (and possibly others).

spyCall.calledWithExactly(arg1, arg2, ...); # Returns true if call received provided arguments and no others.

spyCall.calledWithMatch(arg1, arg2, ...);
# Returns true if call received matching arguments (and possibly others). This behaves the same as 
# spyCall.calledWith(sinon.match(arg1), sinon.match(arg2), ...).

spyCall.notCalledWith(arg1, arg2, ...); # Returns true if call did not receive provided arguments.

spyCall.notCalledWithMatch(arg1, arg2, ...);
# Returns true if call did not receive matching arguments. This behaves the same as 
# spyCall.notCalledWith(sinon.match(arg1), sinon.match(arg2), ...).

spyCall.threw(); # Returns true if call threw an exception.

spyCall.threw("TypeError"); # Returns true if call threw exception of provided type.

spyCall.threw(obj); # Returns true if call threw provided exception object.

class C():
    def f2(self, x):
        return x*2
c = C()
stub = sinon.stub(c, 'f2')
stub.returns(5)
assert c.f2() == 5
assert stub() == 5 # fails, returns None

spy.withArgs()
# Creates a spy that only records calls when the received arguments match those passed
# to withArgs. This is useful to be more expressive in your assertions, where you can access
# the spy with the same call.

spy.printf("format string", [arg1, arg2, ...])
# Returns the passed format string with the following replacements performed:
# %n
#     the name of the spy "spy" by default)
# %c
#     the number of times the spy was called, in words ("once", "twice", etc.)
# %C
#     a list of string representations of the calls to the spy, with each call prefixed by a newline and four
#     spaces
# %t
#     a comma-delimited list of this values the spy was called on
# %n
#     the formatted value of the nth argument passed to printf
# %*
#     a comma-delimited list of the (non-format string) arguments passed to printf 

class C():
    def f2(self, x):
        return x*2
    def f3(self, x):
        return x*3
c = C()
stub = sinon.stub(c) # raises exception

import urllib2
import sinon
stub = sinon.stub(urllib2, 'Request')

stub = sinon.stub()
stub.withArgs(42).onFirstCall().returns(1).onSecondCall().returns(2)
stub.returns(0);
assert stub(1) == 0
assert stub(42) == 1 # fails, returns 0
assert stub(1) == 0
assert stub(42) == 2
assert stub(1) == 0
assert stub(42) == 0

stub.callsArg(index);
# Causes the stub to call the argument at the provided index as a callback function.
# stub.callsArg(0); causes the stub to call the first argument as a callback.

stub.callsArgWith(index, arg1, arg2, ...);
# Like callsArg, but with arguments to pass to the callback.

stub.yields([arg1, arg2, ...])
# Similar to callsArg.
# Causes the stub to call the first callback it receives with the provided arguments (if any).
# If a method accepts more than one callback, you need to use callsArg to have the stub
# invoke other callbacks than the first one.

stub.yieldsTo(property, [arg1, arg2, ...])
# Causes the spy to invoke a callback passed as a property of an object to the spy.
# Like yields, yieldsTo grabs the first matching argument, finds the callback and calls 
# it with the (optional) arguments.

stub.yield([arg1, arg2, ...])
# Invoke callbacks passed to the stub with the given arguments.
# If the stub was never called with a function argument, yield throws an error.
# Also aliased as invokeCallback.

stub.yieldTo(callback, [arg1, arg2, ...])
# Invokes callbacks passed as a property of an object to the stub.
# Like yield, yieldTo grabs the first matching argument, finds the callback and 
# calls it with the (optional) arguments.

stub.callArg(argNum)
# Like yield, but with an explicit argument number specifying which callback to call.
# Useful if a function is called with more than one callback, and simply calling the
# first callback is not desired.

stub.callArgWith(argNum, [arg1, arg2, ...])
# Like callArg, but with arguments.

class A:
	def B(self):
		return 5
stub = sinon.stub(A, 'B')
stub() # error

stub = sinon.stub()
stub.withArgs('A').returns('Arg of A')
stub.onFirstCall().returns('First call!')
stub.onSecondCall().returns('Second call!')
stub.returns('No args')
assert stub() == 'First call!'  # fails, returns 'No args'
assert stub('A') == 'Arg of A'
assert stub() == 'No args'

stub = sinon.stub()
stub.onFirstCall().returns('first call')
assert stub() == 'first call'
stub.onSecondCall().returns('second call')
assert stub() == 'second call' # fails, returns 'first call'

stub = sinon.stub().onFirstCall().throws(BaseException('Hello World')).onSecondCall().returns(42)
stub() # we expect an exception 'Hello World', instead we get an error
stub() # we expect a return value of 42, instead we get an error
stub() # we expect a return value of None, instead we get an error