1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
Metadata-Version: 1.0
Name: MiniMock
Version: 0.9
Summary: The simplest possible mock library
Home-page: http://pypi.python.org/pypi/MiniMock
Author: Ian Bicking
Author-email: ianb@colorstudy.com
License: MIT
Description: MiniMock
========
.. contents:
License & Repository
--------------------
MiniMock is by `Ian Bicking <http://blog.ianbicking.org>`_ with
substantial contributions by Mike Beachy. It is licensed under an
`MIT-style license
<http://svn.colorstudy.com/MiniMock/trunk/docs/license.txt>`_.
To install from the `subversion repository
<http://svn.colorstudy.com/MiniMock/trunk/#egg=MiniMock-dev>`_ you can
use ``easy_install MiniMock==dev`` or::
svn co http://svn.colorstudy.com/MiniMock/trunk MiniMock
Introduction
------------
minimock is a simple library for doing Mock objects with doctest.
When using doctest, mock objects can be very simple.
Here's an example of something we might test, a simple email sender::
>>> import smtplib
>>> def send_email(from_addr, to_addr, subject, body):
... conn = smtplib.SMTP('localhost')
... msg = 'To: %s\nFrom: %s\nSubject: %s\n\n%s' % (
... to_addr, from_addr, subject, body)
... conn.sendmail(from_addr, [to_addr], msg)
... conn.quit()
Now we want to make a mock ``smtplib.SMTP`` object. We'll have to
inject our mock into the ``smtplib`` module::
>>> smtplib.SMTP = Mock('smtplib.SMTP')
>>> smtplib.SMTP.mock_returns = Mock('smtp_connection')
Now we do the test::
>>> send_email('ianb@colorstudy.com', 'joe@example.com',
... 'Hi there!', 'How is it going?')
Called smtplib.SMTP('localhost')
Called smtp_connection.sendmail(
'ianb@colorstudy.com',
['joe@example.com'],
'To: joe@example.com\nFrom: ianb@colorstudy.com\nSubject: Hi there!\n\nHow is it going?')
Called smtp_connection.quit()
Voila! We've tested implicitly that no unexpected methods were called
on the object. We've also tested the arguments that the mock object
got. We've provided fake return calls (for the ``smtplib.SMTP()``
constructor). These are all the core parts of a mock library. The
implementation is simple because most of the work is done by doctest.
Controlling Mocks
-----------------
Mock objects have several attributes, all of which you can set when
instantiating the object. To avoid name collision, all the attributes
start with ``mock_``, while the constructor arguments don't.
``name``:
The name of the object, used when printing out messages. In the
example about it was ``'smtplib.SMTP'``.
``returns``:
When this object is called, it will return this value. By default
it is None.
``returns_iter``:
Alternately, you can give an iterable of return results, like
``returns_iter=[1, 2, 3]``; on each subsequent call it will return
the next value.
``returns_func``:
If given, this will be called to get the return value. In
essence, this function will be the *real* implementation of the
method.
``raises``:
An exception (instance or class) that will be raised when this
object is called.
``show_attrs``:
If this is true, everytime a new attribute is set on the mock
object something will be printed. Otherwise attribute sets are
silent, and only function calls print something.
So to create an object that always raises ValueError, do::
>>> dummy_module = Mock('mylibrary')
>>> dummy_module.invalid_func.raises = ValueError
Creating Mocks
--------------
Every attribute of a mock object will itself be another mock object,
unless you specifically set it to something else. For instance, you
can do::
>>> from minimock import Mock
>>> dummy_module = Mock('mylibrary')
>>> dummy_module.CONSTANT = 1
Then the ``CONSTANT`` value will persist. But you can also traverse
to whatever object you want, and you will get another mock object.
Another technique for creating a mock object is the ``mock(...)``
function. This works like::
>>> from minimock import mock
>>> import os.path
>>> mock('os.path.isfile', returns=True)
This looks up the ``os.path.isfile`` object, and changes it to a mock
object. Any keyword arguments you give (like ``returns=True`` in this
example) will be used to create the mock object; you can also give a
``mock_obj`` keyword argument to pass in a mock object you've already
created.
This function looks in the calling function to figure out what to
replace (``os.path.isfile`` in the example). You must import the
proper modules first. Alternately you can pass in a dictionary like
``[locals(), globals()]`` for it to use for lookup.
To restore all the objects mocked with ``mock()``, use
``minimock.restore()`` (with no arguments; all the mocks are kept
track of).
News
----
0.9
---
* Added ``show_attrs``
0.8
---
First official release.
Keywords: mock testing unittest
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: License :: OSI Approved :: MIT License
Classifier: Topic :: Software Development :: Testing
|
