Merge lp:~gandelman-a/ubuntu/precise/python-dingus/lp879051 into lp:ubuntu/precise/python-dingus

[Adam Gandelman]

python-dingus (0.3.2-1ubuntu1) precise; urgency=low

  * Merge from debian testing (LP: #879051). Remaining changes:
    - dh_python2 transition

 -- Adam Gandelman <email address hidden> Thu, 20 Oct 2011 12:17:50 -0700

python-dingus (0.3.2-1) unstable; urgency=low

  * New upstream release
  * Update Standards version, no changes needed.

 -- David Watson <email address hidden> Sun, 07 Aug 2011 09:16:45 +0100

[Daniel Holbach (dholbach)]

Good work! Thanks! Do you think you can forward the changes to Debian?

review: Approve

=== added directory '.pc'
=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2011-10-20 19:36:43 +0000
@@ -0,0 +1,1 @@
+2

=== added file '.pc/applied-patches'
--- .pc/applied-patches	1970-01-01 00:00:00 +0000
+++ .pc/applied-patches	2011-10-20 19:36:43 +0000
@@ -0,0 +1,1 @@
+debian-changes-0.3.2-1

=== added directory '.pc/debian-changes-0.3.2-1'
=== added directory '.pc/debian-changes-0.3.2-1/dingus.egg-info'
=== added file '.pc/debian-changes-0.3.2-1/dingus.egg-info/SOURCES.txt'
--- .pc/debian-changes-0.3.2-1/dingus.egg-info/SOURCES.txt	1970-01-01 00:00:00 +0000
+++ .pc/debian-changes-0.3.2-1/dingus.egg-info/SOURCES.txt	2011-10-20 19:36:43 +0000
@@ -0,0 +1,7 @@
+README.txt
+dingus.py
+setup.py
+dingus.egg-info/PKG-INFO
+dingus.egg-info/SOURCES.txt
+dingus.egg-info/dependency_links.txt
+dingus.egg-info/top_level.txt
\ No newline at end of file

=== added directory '.pc/debian-changes-0.3.2-1/patches'
=== added file '.pc/debian-changes-0.3.2-1/patches/series'
=== added file '.pc/debian-changes-0.3.2-1/patches/setup_cleanup'
=== added file '.pc/debian-changes-0.3.2-1/setup.py'
--- .pc/debian-changes-0.3.2-1/setup.py	1970-01-01 00:00:00 +0000
+++ .pc/debian-changes-0.3.2-1/setup.py	2011-10-20 19:36:43 +0000
@@ -0,0 +1,22 @@
+from setuptools import setup
+
+setup(name='dingus',
+      version='0.3.2',
+      description='A record-then-assert mocking library',
+      long_description=file('README.txt').read(),
+      author='Gary Bernhardt',
+      author_email='[e-mail]',
+      py_modules=['dingus'],
+      data_files=[('', ['README.txt'])],
+      license='MIT',
+      url='https://github.com/garybernhardt/dingus',
+      keywords='testing test mocking mock double stub fake record assert',
+      classifiers=["Development Status :: 4 - Beta",
+                   "Intended Audience :: Developers",
+                   "License :: OSI Approved :: MIT License",
+                   "Operating System :: OS Independent",
+                   "Programming Language :: Python",
+                   "Topic :: Software Development :: Testing",
+                   ],
+     )
+

=== modified file 'PKG-INFO'
--- PKG-INFO	2009-10-22 11:00:55 +0000
+++ PKG-INFO	2011-10-20 19:36:43 +0000
@@ -1,15 +1,129 @@
 Metadata-Version: 1.0
 Name: dingus
-Version: 0.1
+Version: 0.3.2
 Summary: A record-then-assert mocking library
-Home-page: http://bitbucket.org/garybernhardt/dingus
+Home-page: https://github.com/garybernhardt/dingus
 Author: Gary Bernhardt
 Author-email: [e-mail]
 License: MIT
-Description: UNKNOWN
-Keywords: testing test mocking mock double stub fake
+Description: ========
+        DINGUSES
+        ========
+        
+        A dingus is sort of like a mock object. The main difference is that you don't
+        set up expectations ahead of time. You just run your code, using a dingus in
+        place of another object or class, and it will record what happens to it. Then,
+        once your code has been exercised, you can make assertions about what it did
+        to the dingus.
+        
+        A new dingus is created from the Dingus class. You can give dinguses names,
+        which helps with debugging your tests, especially when there are multiple
+        dinguses in play.
+        
+        >>> from dingus import Dingus
+        >>> d = Dingus('root')
+        >>> d
+        <Dingus root>
+        
+        Accessing any attribute of a dingus will return a new dingus.
+        
+        >>> d.something
+        <Dingus root.something>
+        
+        There are a few exceptions for special dingus methods. We'll see some in a
+        bit.
+        
+        A dingus can also be called like a function or method. It doesn't care how
+        many arguments you give it or what those arguments are. Calls to a dingus will
+        always return the same object, regardless of the arguments.
+        
+        >>> d()
+        <Dingus root()>
+        >>> d('argument')
+        <Dingus root()>
+        >>> d(55)
+        <Dingus root()>
+        
+        ========================
+        RECORDING AND ASSERTIONS
+        ========================
+        
+        At any time we can get a list of calls that have been made to a dingus. Each
+        entry in the call list contains:
+        
+        * the name of the method called (or "()" if the dingus itself was called)
+        * The arguments, or () if none
+        * The keyword argumnets, or {} if none
+        * The value that was returned to the caller
+        
+        Here is a list of the calls we've made to d so far:
+        
+        >>> from pprint import pprint
+        >>> pprint(d.calls)
+        [('()', (), {}, <Dingus root()>),
+        ('()', ('argument',), {}, <Dingus root()>),
+        ('()', (55,), {}, <Dingus root()>)]
+        
+        You can filter calls by name, arguments, and keyword arguments:
+        
+        >>> pprint(d.calls('()', 55))
+        [('()', (55,), {}, <Dingus root()>)]
+        
+        If you don't care about a particular argument's value, you can use the value
+        DontCare when filtering:
+        
+        >>> from dingus import DontCare
+        >>> pprint(d.calls('()', DontCare))
+        [('()', ('argument',), {}, <Dingus root()>),
+        ('()', (55,), {}, <Dingus root()>)]
+        
+        Dinguses can do more than just have attributes accessed and be called. They
+        support many Python operators. The goal is to allow, and record, any
+        interaction:
+        
+        >>> d = Dingus('root')
+        >>> (2 ** d.something)['hello']() / 100 * 'foo'
+        <Dingus root.something.__rpow__[hello]().__div__.__mul__>
+        
+        (Hopefully your real-world dingus recordings won't look like this!)
+        
+        ========
+        PATCHING
+        ========
+        
+        Dingus provides a context manager for patching objects during tests. For
+        example:
+        
+        >>> from dingus import patch
+        >>> import urllib2
+        >>> with patch('urllib2.urlopen'):
+        ...     print urllib2.urlopen.__class__
+        <class 'dingus.Dingus'>
+        >>> print urllib2.urlopen.__class__
+        <type 'function'>
+        
+        You can also use this as a decorator on your test methods:
+        
+        >>> @patch('urllib2.urlopen')
+        ... def test_something(self):
+        ...     pass
+        ...
+        
+        ===============
+        DANGEROUS MAGIC
+        ===============
+        
+        Dingus can also automatically replace a module's globals when running tests.
+        This allows you to write fully isolated unit tests. See
+        examples/urllib2/test\_urllib2.py for an example. The author no longer
+        recommends this feature, as it can encourage very brittle tests. You should
+        feel the pain of manually mocking dependencies; the pain will tell you when a
+        class collaborates with too many others.
+        
+        
+Keywords: testing test mocking mock double stub fake record assert
 Platform: UNKNOWN
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

=== removed file 'README'
--- README	2009-10-22 11:00:55 +0000
+++ README	1970-01-01 00:00:00 +0000
@@ -1,76 +0,0 @@
-A dingus is sort of like a mock object. The main difference is that you don't
-set up expectations ahead of time. You just run your code, using a dingus in
-place of another object or class, and it will record what happens to it. Then,
-once your code has been exercised, you can make assertions about what it did
-to the dingus.
-
-A new dingus is created from the Dingus class. You can give dinguses names,
-which helps with debugging your tests, especially when there are multiple
-dinguses in play.
-
-    >>> from dingus import Dingus
-    >>> d = Dingus('root')
-    >>> d
-    <Dingus root>
-
-Accessing any attribute of a dingus will return a new dingus.
-
-    >>> d.something
-    <Dingus root.something>
-
-There are a few exceptions for special dingus methods. We'll see some in a
-bit.
-
-A dingus can also be called like a function or method. It doesn't care how
-many arguments you give it or what those arguments are. Calls to a dingus will
-always return the same object, regardless of the arguments.
-
-    >>> d()
-    <Dingus root()>
-    >>> d('argument')
-    <Dingus root()>
-    >>> d(55)
-    <Dingus root()>
-
-At any time we can get a list of calls that have been made to a dingus. Each
-entry in the call list contains:
-  * the name of the method called (or "()" if the dingus itself was called)
-  * The arguments, or () if none
-  * The keyword argumnets, or {} if none
-  * The value that was returned to the caller
-
-Here is a list of the calls we've made to d so far:
-
-    >>> from pprint import pprint
-    >>> pprint(d.calls)
-    [('()', (), {}, <Dingus root()>),
-     ('()', ('argument',), {}, <Dingus root()>),
-     ('()', (55,), {}, <Dingus root()>)]
-
-You can filter calls by name, arguments, and keyword arguments:
-
-    >>> pprint(d.calls('()', 55))
-    [('()', (55,), {}, <Dingus root()>)]
-
-If you don't care about a particular argument's value, you can use the value
-DontCare when filtering:
-
-    >>> from dingus import DontCare
-    >>> pprint(d.calls('()', DontCare))
-    [('()', ('argument',), {}, <Dingus root()>),
-     ('()', (55,), {}, <Dingus root()>)]
-
-Dinguses can do more than just have attributes accessed and be called. They
-support many Python operators. The goal is to allow, and record, any
-interaction:
-
-    >>> d = Dingus('root')
-    >>> (2 ** d.something)['hello']() / 100 * 'foo'
-    <Dingus root.something.__rpow__[hello]().__div__.__mul__>
-
-(Hopefully your real-world dingus recordings won't look like this!)
-
-Dingus can also automatically replace a module's globals when running tests.
-This allows you to write fully isolated unit tests. See
-examples/urllib2/test_urllib2.py for an example.
-

=== added file 'README.txt'
--- README.txt	1970-01-01 00:00:00 +0000
+++ README.txt	2011-10-20 19:36:43 +0000
@@ -0,0 +1,114 @@
+========
+DINGUSES
+========
+
+A dingus is sort of like a mock object. The main difference is that you don't
+set up expectations ahead of time. You just run your code, using a dingus in
+place of another object or class, and it will record what happens to it. Then,
+once your code has been exercised, you can make assertions about what it did
+to the dingus.
+
+A new dingus is created from the Dingus class. You can give dinguses names,
+which helps with debugging your tests, especially when there are multiple
+dinguses in play.
+
+    >>> from dingus import Dingus
+    >>> d = Dingus('root')
+    >>> d
+    <Dingus root>
+
+Accessing any attribute of a dingus will return a new dingus.
+
+    >>> d.something
+    <Dingus root.something>
+
+There are a few exceptions for special dingus methods. We'll see some in a
+bit.
+
+A dingus can also be called like a function or method. It doesn't care how
+many arguments you give it or what those arguments are. Calls to a dingus will
+always return the same object, regardless of the arguments.
+
+    >>> d()
+    <Dingus root()>
+    >>> d('argument')
+    <Dingus root()>
+    >>> d(55)
+    <Dingus root()>
+
+========================
+RECORDING AND ASSERTIONS
+========================
+
+At any time we can get a list of calls that have been made to a dingus. Each
+entry in the call list contains:
+
+* the name of the method called (or "()" if the dingus itself was called)
+* The arguments, or () if none
+* The keyword argumnets, or {} if none
+* The value that was returned to the caller
+
+Here is a list of the calls we've made to d so far:
+
+    >>> from pprint import pprint
+    >>> pprint(d.calls)
+    [('()', (), {}, <Dingus root()>),
+     ('()', ('argument',), {}, <Dingus root()>),
+     ('()', (55,), {}, <Dingus root()>)]
+
+You can filter calls by name, arguments, and keyword arguments:
+
+    >>> pprint(d.calls('()', 55))
+    [('()', (55,), {}, <Dingus root()>)]
+
+If you don't care about a particular argument's value, you can use the value
+DontCare when filtering:
+
+    >>> from dingus import DontCare
+    >>> pprint(d.calls('()', DontCare))
+    [('()', ('argument',), {}, <Dingus root()>),
+     ('()', (55,), {}, <Dingus root()>)]
+
+Dinguses can do more than just have attributes accessed and be called. They
+support many Python operators. The goal is to allow, and record, any
+interaction:
+
+    >>> d = Dingus('root')
+    >>> (2 ** d.something)['hello']() / 100 * 'foo'
+    <Dingus root.something.__rpow__[hello]().__div__.__mul__>
+
+(Hopefully your real-world dingus recordings won't look like this!)
+
+========
+PATCHING
+========
+
+Dingus provides a context manager for patching objects during tests. For
+example:
+
+    >>> from dingus import patch
+    >>> import urllib2
+    >>> with patch('urllib2.urlopen'):
+    ...     print urllib2.urlopen.__class__
+    <class 'dingus.Dingus'>
+    >>> print urllib2.urlopen.__class__
+    <type 'function'>
+
+You can also use this as a decorator on your test methods:
+
+    >>> @patch('urllib2.urlopen')
+    ... def test_something(self):
+    ...     pass
+    ...
+
+===============
+DANGEROUS MAGIC
+===============
+
+Dingus can also automatically replace a module's globals when running tests.
+This allows you to write fully isolated unit tests. See
+examples/urllib2/test\_urllib2.py for an example. The author no longer
+recommends this feature, as it can encourage very brittle tests. You should
+feel the pain of manually mocking dependencies; the pain will tell you when a
+class collaborates with too many others.
+

=== modified file 'debian/changelog'
--- debian/changelog	2011-08-31 08:36:44 +0000
+++ debian/changelog	2011-10-20 19:36:43 +0000
@@ -1,3 +1,17 @@
+python-dingus (0.3.2-1ubuntu1) precise; urgency=low
+
+  * Merge from debian testing (LP: #879051). Remaining changes:
+    - dh_python2 transition
+
+ -- Adam Gandelman <[e-mail]>  Thu, 20 Oct 2011 12:17:50 -0700
+
+python-dingus (0.3.2-1) unstable; urgency=low
+
+  * New upstream release
+  * Update Standards version, no changes needed.
+
+ -- David Watson <[e-mail]>  Sun, 07 Aug 2011 09:16:45 +0100
+
 python-dingus (0.1-2ubuntu1) oneiric; urgency=low
 
   * dh_python2 transition. 

=== modified file 'debian/control'
--- debian/control	2011-08-31 08:36:44 +0000
+++ debian/control	2011-10-20 19:36:43 +0000
@@ -11,7 +11,7 @@
 Package: python-dingus
 Architecture: all
 Depends: ${misc:Depends}, ${python:Depends}
-Description: A record-then-assert mocking library
+Description: Record-then-assert mocking library
  A dingus is sort of like a mock object. The main difference is that you don't
  set up expectations ahead of time. You just run your code, using a dingus in
  place of another object or class, and it will record what happens to it. Then,

=== modified file 'debian/docs'
--- debian/docs	2009-10-22 11:00:55 +0000
+++ debian/docs	2011-10-20 19:36:43 +0000
@@ -1,2 +1,1 @@
-README
-examples/
+README.txt

=== added directory 'debian/patches'
=== added file 'debian/patches/debian-changes-0.3.2-1'
--- debian/patches/debian-changes-0.3.2-1	1970-01-01 00:00:00 +0000
+++ debian/patches/debian-changes-0.3.2-1	2011-10-20 19:36:43 +0000
@@ -0,0 +1,64 @@
+Description: Upstream changes introduced in version 0.3.2-1
+ This patch has been created by dpkg-source during the package build.
+ Here's the last changelog entry, hopefully it gives details on why
+ those changes were made:
+ .
+ python-dingus (0.3.2-1) unstable; urgency=low
+ .
+   * New upstream release
+   * Update Standards version, no changes needed.
+ .
+ The person named in the Author field signed this changelog entry.
+Author: David Watson <[e-mail]>
+
+---
+The information above should follow the Patch Tagging Guidelines, please
+checkout http://dep.debian.net/deps/dep3/ to learn about the format. Here
+are templates for supplementary fields that you might want to add:
+
+Origin: <vendor|upstream|other>, <url of original patch>
+Bug: <url in upstream bugtracker>
+Bug-Debian: http://bugs.debian.org/<bugnumber>
+Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
+Forwarded: <no|not-needed|url proving that it has been forwarded>
+Reviewed-By: <name and email of someone who approved the patch>
+Last-Update: <YYYY-MM-DD>
+
+--- python-dingus-0.3.2.orig/setup.py
++++ python-dingus-0.3.2/setup.py
+@@ -7,7 +7,6 @@ setup(name='dingus',
+       author='Gary Bernhardt',
+       author_email='[e-mail]',
+       py_modules=['dingus'],
+-      data_files=[('', ['README.txt'])],
+       license='MIT',
+       url='https://github.com/garybernhardt/dingus',
+       keywords='testing test mocking mock double stub fake record assert',
+--- python-dingus-0.3.2.orig/dingus.egg-info/SOURCES.txt
++++ python-dingus-0.3.2/dingus.egg-info/SOURCES.txt
+@@ -1,5 +1,6 @@
+ README.txt
+ dingus.py
++setup.cfg
+ setup.py
+ dingus.egg-info/PKG-INFO
+ dingus.egg-info/SOURCES.txt
+--- /dev/null
++++ python-dingus-0.3.2/patches/setup_cleanup
+@@ -0,0 +1,12 @@
++Index: python-dingus-0.3.2/setup.py
++===================================================================
++--- python-dingus-0.3.2.orig/setup.py	2011-08-07 09:37:57.900948735 +0100
+++++ python-dingus-0.3.2/setup.py	2011-08-07 09:38:03.340954228 +0100
++@@ -7,7 +7,6 @@
++       author='Gary Bernhardt',
++       author_email='[e-mail]',
++       py_modules=['dingus'],
++-      data_files=[('', ['README.txt'])],
++       license='MIT',
++       url='https://github.com/garybernhardt/dingus',
++       keywords='testing test mocking mock double stub fake record assert',
+--- /dev/null
++++ python-dingus-0.3.2/patches/series
+@@ -0,0 +1 @@
++setup_cleanup

=== added file 'debian/patches/series'
--- debian/patches/series	1970-01-01 00:00:00 +0000
+++ debian/patches/series	2011-10-20 19:36:43 +0000
@@ -0,0 +1,1 @@
+debian-changes-0.3.2-1

=== added directory 'debian/source'
=== added file 'debian/source/format'
--- debian/source/format	1970-01-01 00:00:00 +0000
+++ debian/source/format	2011-10-20 19:36:43 +0000
@@ -0,0 +1,1 @@
+3.0 (quilt)

=== modified file 'dingus.egg-info/PKG-INFO'
--- dingus.egg-info/PKG-INFO	2009-10-22 11:00:55 +0000
+++ dingus.egg-info/PKG-INFO	2011-10-20 19:36:43 +0000
@@ -1,15 +1,129 @@
 Metadata-Version: 1.0
 Name: dingus
-Version: 0.1
+Version: 0.3.2
 Summary: A record-then-assert mocking library
-Home-page: http://bitbucket.org/garybernhardt/dingus
+Home-page: https://github.com/garybernhardt/dingus
 Author: Gary Bernhardt
 Author-email: [e-mail]
 License: MIT
-Description: UNKNOWN
-Keywords: testing test mocking mock double stub fake
+Description: ========
+        DINGUSES
+        ========
+        
+        A dingus is sort of like a mock object. The main difference is that you don't
+        set up expectations ahead of time. You just run your code, using a dingus in
+        place of another object or class, and it will record what happens to it. Then,
+        once your code has been exercised, you can make assertions about what it did
+        to the dingus.
+        
+        A new dingus is created from the Dingus class. You can give dinguses names,
+        which helps with debugging your tests, especially when there are multiple
+        dinguses in play.
+        
+        >>> from dingus import Dingus
+        >>> d = Dingus('root')
+        >>> d
+        <Dingus root>
+        
+        Accessing any attribute of a dingus will return a new dingus.
+        
+        >>> d.something
+        <Dingus root.something>
+        
+        There are a few exceptions for special dingus methods. We'll see some in a
+        bit.
+        
+        A dingus can also be called like a function or method. It doesn't care how
+        many arguments you give it or what those arguments are. Calls to a dingus will
+        always return the same object, regardless of the arguments.
+        
+        >>> d()
+        <Dingus root()>
+        >>> d('argument')
+        <Dingus root()>
+        >>> d(55)
+        <Dingus root()>
+        
+        ========================
+        RECORDING AND ASSERTIONS
+        ========================
+        
+        At any time we can get a list of calls that have been made to a dingus. Each
+        entry in the call list contains:
+        
+        * the name of the method called (or "()" if the dingus itself was called)
+        * The arguments, or () if none
+        * The keyword argumnets, or {} if none
+        * The value that was returned to the caller
+        
+        Here is a list of the calls we've made to d so far:
+        
+        >>> from pprint import pprint
+        >>> pprint(d.calls)
+        [('()', (), {}, <Dingus root()>),
+        ('()', ('argument',), {}, <Dingus root()>),
+        ('()', (55,), {}, <Dingus root()>)]
+        
+        You can filter calls by name, arguments, and keyword arguments:
+        
+        >>> pprint(d.calls('()', 55))
+        [('()', (55,), {}, <Dingus root()>)]
+        
+        If you don't care about a particular argument's value, you can use the value
+        DontCare when filtering:
+        
+        >>> from dingus import DontCare
+        >>> pprint(d.calls('()', DontCare))
+        [('()', ('argument',), {}, <Dingus root()>),
+        ('()', (55,), {}, <Dingus root()>)]
+        
+        Dinguses can do more than just have attributes accessed and be called. They
+        support many Python operators. The goal is to allow, and record, any
+        interaction:
+        
+        >>> d = Dingus('root')
+        >>> (2 ** d.something)['hello']() / 100 * 'foo'
+        <Dingus root.something.__rpow__[hello]().__div__.__mul__>
+        
+        (Hopefully your real-world dingus recordings won't look like this!)
+        
+        ========
+        PATCHING
+        ========
+        
+        Dingus provides a context manager for patching objects during tests. For
+        example:
+        
+        >>> from dingus import patch
+        >>> import urllib2
+        >>> with patch('urllib2.urlopen'):
+        ...     print urllib2.urlopen.__class__
+        <class 'dingus.Dingus'>
+        >>> print urllib2.urlopen.__class__
+        <type 'function'>
+        
+        You can also use this as a decorator on your test methods:
+        
+        >>> @patch('urllib2.urlopen')
+        ... def test_something(self):
+        ...     pass
+        ...
+        
+        ===============
+        DANGEROUS MAGIC
+        ===============
+        
+        Dingus can also automatically replace a module's globals when running tests.
+        This allows you to write fully isolated unit tests. See
+        examples/urllib2/test\_urllib2.py for an example. The author no longer
+        recommends this feature, as it can encourage very brittle tests. You should
+        feel the pain of manually mocking dependencies; the pain will tell you when a
+        class collaborates with too many others.
+        
+        
+Keywords: testing test mocking mock double stub fake record assert
 Platform: UNKNOWN
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

=== modified file 'dingus.egg-info/SOURCES.txt'
--- dingus.egg-info/SOURCES.txt	2009-10-22 11:00:55 +0000
+++ dingus.egg-info/SOURCES.txt	2011-10-20 19:36:43 +0000
@@ -1,23 +1,8 @@
-README
+README.txt
 dingus.py
 setup.cfg
 setup.py
 dingus.egg-info/PKG-INFO
 dingus.egg-info/SOURCES.txt
 dingus.egg-info/dependency_links.txt
-dingus.egg-info/top_level.txt
-examples/__init__.py
-examples/googler/__init__.py
-examples/googler/googler.py
-examples/googler/runtests.py
-examples/googler/test_googler.py
-examples/urllib2/__init__.py
-examples/urllib2/runtests.py
-examples/urllib2/test_urllib2.py
-tests/__init__.py
-tests/runtests.py
-tests/test_call.py
-tests/test_call_list.py
-tests/test_dingus.py
-tests/test_dingus_test_case.py
-tests/test_exception_raiser.py
\ No newline at end of file
+dingus.egg-info/top_level.txt
\ No newline at end of file

=== modified file 'dingus.py'
--- dingus.py	2009-10-22 11:00:55 +0000
+++ dingus.py	2011-10-20 19:36:43 +0000
@@ -4,51 +4,50 @@
 
 
 import sys
-import new
-
-
-def DingusTestCase(class_under_test):
+from functools import wraps
+
+def DingusTestCase(object_under_test, exclude=None):
+    if isinstance(exclude, basestring):
+        raise ValueError("Strings not allowed for exclude. " +
+                         "Use a list: exclude=['identifier']")
+    exclude = [] if exclude is None else exclude
+
+    def get_names_under_test():
+        module = sys.modules[object_under_test.__module__]
+        for name, value in module.__dict__.iteritems():
+            if value is object_under_test or name in exclude:
+                yield name
+
     class TestCase(object):
         def setup(self):
-            module_name = class_under_test.__module__
+            module_name = object_under_test.__module__
             self._dingus_module = sys.modules[module_name]
-            self._dingus_replace_module_globals(self._dingus_module,
-                                                class_under_test)
+            self._dingus_replace_module_globals(self._dingus_module)
 
         def teardown(self):
             self._dingus_restore_module(self._dingus_module)
 
-        def _dingus_wipe_module(self, module):
+        def _dingus_replace_module_globals(self, module):
             old_module_dict = module.__dict__.copy()
-            module.__dict__.clear()
-            module.__dict__.update(__builtins__)
-            module.__dict__['__dingused_dict__'] = old_module_dict
-
-
-        def _dingus_replace_module_globals(self, module, class_under_test):
             module_keys = set(module.__dict__.iterkeys())
-            builtin_keys = set(__builtins__.iterkeys())
 
-            test_class_name = class_under_test.__name__
-            replaced_keys = (module_keys -
-                             builtin_keys -
-                             set([test_class_name]))
-            self._dingus_wipe_module(module)
+            dunders = set(k for k in module_keys
+                           if k.startswith('__') and k.endswith('__'))
+            replaced_keys = (module_keys - dunders - set(names_under_test))
             for key in replaced_keys:
                 module.__dict__[key] = Dingus()
-            module.__dict__[test_class_name] = class_under_test
+            module.__dict__['__dingused_dict__'] = old_module_dict
 
         def _dingus_restore_module(self, module):
             old_module_dict = module.__dict__['__dingused_dict__']
             module.__dict__.clear()
             module.__dict__.update(old_module_dict)
 
-
-    TestCase.__name__ = '%sDingusTestCase' % class_under_test.__module__
+    names_under_test = list(get_names_under_test())
+    TestCase.__name__ = '%s_DingusTestCase' % '_'.join(names_under_test)
     return TestCase
 
 
-
 # These sentinels are used for argument defaults because the user might want
 # to pass in None, which is different in some cases than passing nothing.
 class NoReturnValue(object):
@@ -57,6 +56,65 @@
     pass
 
 
+def patch(object_path, new_object=NoArgument):
+    module_name, attribute_name = object_path.rsplit('.', 1)
+    return _Patcher(module_name, attribute_name, new_object)
+
+
+class _Patcher:
+    def __init__(self, module_name, attribute_name, new_object):
+        self.module_name = module_name
+        self.attribute_name = attribute_name
+        self.module = _importer(self.module_name)
+        if new_object is NoArgument:
+            full_name = '%s.%s' % (module_name, attribute_name)
+            self.new_object = Dingus(full_name)
+        else:
+            self.new_object = new_object
+
+    def __call__(self, fn):
+        @wraps(fn)
+        def new_fn(*args, **kwargs):
+            self.patch_object()
+            try:
+                return fn(*args, **kwargs)
+            finally:
+                self.restore_object()
+        return new_fn
+
+    def __enter__(self):
+        self.patch_object()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.restore_object()
+
+    def patch_object(self):
+        self.original_object = getattr(self.module, self.attribute_name)
+        setattr(self.module, self.attribute_name, self.new_object)
+
+    def restore_object(self):
+        setattr(self.module, self.attribute_name, self.original_object)
+
+
+def _importer(target):
+    components = target.split('.')
+    import_path = components.pop(0)
+    thing = __import__(import_path)
+
+    for comp in components:
+        import_path += ".%s" % comp
+        thing = _dot_lookup(thing, comp, import_path)
+    return thing
+
+
+def _dot_lookup(thing, comp, import_path):
+    try:
+        return getattr(thing, comp)
+    except AttributeError:
+        __import__(import_path)
+        return getattr(thing, comp)
+
+
 class DontCare(object):
     pass
 
@@ -70,6 +128,9 @@
         self.args = self[1]
         self.kwargs = self[2]
         self.return_value = self[3]
+        
+    def __getnewargs__(self):
+        return (self.name, self.args, self.kwargs, self.return_value)
 
 
 class CallList(list):
@@ -83,24 +144,41 @@
             return all(args[i] in (DontCare, call.args[i])
                        for i in range(len(call.args)))
 
+    @staticmethod
+    def _match_kwargs(call, kwargs):
+        if not kwargs:
+            return True
+        elif len(kwargs) != len(call.kwargs):
+            return False
+        else:
+            return all(name in kwargs and kwargs[name] in (DontCare, val)
+                       for name, val in call.kwargs.iteritems())
+
     def one(self):
         if len(self) == 1:
             return self[0]
         else:
             return None
 
-    def __call__(self, name=NoArgument, *args, **kwargs):
+    def once(self):
+        return self.one()
+
+    def __call__(self, __name=NoArgument, *args, **kwargs):
         return CallList([call for call in self
-                         if (name is NoArgument or name == call.name)
+                         if (__name is NoArgument or __name == call.name)
                          and self._match_args(call, args)
-                         and (not kwargs or kwargs == call.kwargs)])
+                         and self._match_kwargs(call, kwargs)])
+
+
+def returner(return_value):
+    return Dingus(return_value=return_value)
 
 
 class Dingus(object):
-    def __init__(self, name=None, full_name=None, **kwargs):
+    def __init__(self, dingus_name=None, full_name=None, **kwargs):
         self._parent = None
         self.reset()
-        name = 'dingus_%i' % id(self) if name is None else name
+        name = 'dingus_%i' % id(self) if dingus_name is None else dingus_name
         full_name = name if full_name is None else full_name
         self._short_name = name
         self._full_name = full_name
@@ -108,7 +186,13 @@
         self._full_name = full_name
 
         for attr_name, attr_value in kwargs.iteritems():
-            setattr(self, attr_name, attr_value)
+            if attr_name.endswith('__returns'):
+                attr_name = attr_name.replace('__returns', '')
+                returner = self._create_child(attr_name)
+                returner.return_value = attr_value
+                setattr(self, attr_name, returner)
+            else:
+                setattr(self, attr_name, attr_value)
 
         self._replace_init_method()
 
@@ -126,7 +210,7 @@
         separator = ('' if (name.startswith('()') or name.startswith('['))
                      else '.')
         full_name = self._full_name + separator + name
-        child = Dingus(name, full_name)
+        child = self.__class__(name, full_name)
         child._parent = self
         return child
 
@@ -146,9 +230,6 @@
     return_value = property(_get_return_value, _set_return_value)
 
     def __call__(self, *args, **kwargs):
-        if self.return_value is NoReturnValue:
-            self.return_value = self._create_child('()')
-
         self._log_call('()', args, kwargs, self.return_value)
         if self._parent:
             self._parent._log_call(self._short_name,
@@ -162,50 +243,97 @@
         self.calls.append(Call(name, args, kwargs, return_value))
 
     def _should_ignore_attribute(self, name):
-        return name == '__pyobjc_object__'
+        return name in ['__pyobjc_object__', '__getnewargs__']
+    
+    def __getstate__(self):
+        # Python cannot pickle a instancemethod
+        # http://bugs.python.org/issue558238
+        return [ (attr, value) for attr, value in self.__dict__.items() if attr != "__init__"]
+    
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        self._replace_init_method()
+
+    def _existing_or_new_child(self, child_name, default_value=NoArgument):
+        if child_name not in self._children:
+            value = (self._create_child(child_name)
+                     if default_value is NoArgument
+                     else default_value)
+            self._children[child_name] = value
+
+        return self._children[child_name]
+
+    def _remove_child_if_exists(self, child_name):
+        if child_name in self._children:
+            del self._children[child_name]
 
     def __getattr__(self, name):
         if self._should_ignore_attribute(name):
             raise AttributeError(name)
-
-        if name not in self._children:
-            self._children[name] = self._create_child(name)
-
-        return self._children[name]
+        return self._existing_or_new_child(name)
+
+    def __delattr__(self, name):
+        self._log_call('__delattr__', (name,), {}, None)
 
     def __getitem__(self, index):
-        child_name = '[%s]' % index
-        return_value = self._children.setdefault(
-            child_name, self._create_child('[%s]' % index))
+        child_name = '[%s]' % (index,)
+        return_value = self._existing_or_new_child(child_name)
         self._log_call('__getitem__', (index,), {}, return_value)
         return return_value
 
     def __setitem__(self, index, value):
-        child_name = '[%s]' % index
+        child_name = '[%s]' % (index,)
         self._log_call('__setitem__', (index, value), {}, None)
-        self._children[child_name] = value
+        self._remove_child_if_exists(child_name)
+        self._existing_or_new_child(child_name, value)
 
-    def _create_operator(name):
+    def _create_infix_operator(name):
         def operator_fn(self, other):
-            if name not in self._children:
-                self._children[name] = self._create_child(name)
-            return self._children[name]
+            return_value = self._existing_or_new_child(name)
+            self._log_call(name, (other,), {}, return_value)
+            return return_value
         operator_fn.__name__ = name
         return operator_fn
 
-    def _operators():
-        operator_names = ['add', 'and', 'div', 'lshift', 'mod', 'mul', 'or',
-                          'pow', 'rshift', 'sub', 'xor']
-        reverse_operator_names = ['r%s' % name for name in operator_names]
-        for operator_name in operator_names + reverse_operator_names:
+    _BASE_OPERATOR_NAMES = ['add', 'and', 'div', 'lshift', 'mod', 'mul', 'or',
+                            'pow', 'rshift', 'sub', 'xor']
+
+    def _infix_operator_names(base_operator_names):
+        # This function has to have base_operator_names passed in because
+        # Python's scoping rules prevent it from seeing the class-level
+        # _BASE_OPERATOR_NAMES.
+
+        reverse_operator_names = ['r%s' % name for name in base_operator_names]
+        for operator_name in base_operator_names + reverse_operator_names:
             operator_fn_name = '__%s__' % operator_name
             yield operator_fn_name
 
-    # Define each operator
-    for operator_fn_name in _operators():
-        exec('%s = _create_operator("%s")' % (operator_fn_name,
+    # Define each infix operator
+    for operator_fn_name in _infix_operator_names(_BASE_OPERATOR_NAMES):
+        exec('%s = _create_infix_operator("%s")' % (operator_fn_name,
                                               operator_fn_name))
 
+    def _augmented_operator_names(base_operator_names):
+        # Augmented operators are things like +=. They behavior differently
+        # than normal infix operators because they return self instead of a
+        # new object.
+
+        return ['__i%s__' % operator_name
+                for operator_name in base_operator_names]
+
+    def _create_augmented_operator(name):
+        def operator_fn(self, other):
+            return_value = self
+            self._log_call(name, (other,), {}, return_value)
+            return return_value
+        operator_fn.__name__ = name
+        return operator_fn
+
+    # Define each augmenting operator
+    for operator_fn_name in _augmented_operator_names(_BASE_OPERATOR_NAMES):
+        exec('%s = _create_augmented_operator("%s")' % (operator_fn_name,
+                                                        operator_fn_name))
+
     def __str__(self):
         return '<Dingus %s>' % self._full_name
     __repr__ = __str__
@@ -213,6 +341,13 @@
     def __len__(self):
         return 1
 
+    def __iter__(self):
+        return iter([self._existing_or_new_child('__iter__')])
+
+    # We don't want to define __deepcopy__ at all. If there isn't one, deepcopy
+    # will clone the whole object, which is what we want.
+    __deepcopy__ = None
+
 
 def exception_raiser(exception):
     def raise_exception(*args, **kwargs):

=== removed directory 'examples'
=== removed file 'examples/__init__.py'
--- examples/__init__.py	2009-10-22 11:00:55 +0000
+++ examples/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-

=== removed directory 'examples/googler'
=== removed file 'examples/googler/__init__.py'
--- examples/googler/__init__.py	2009-10-22 11:00:55 +0000
+++ examples/googler/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-

=== removed file 'examples/googler/googler.py'
--- examples/googler/googler.py	2009-10-22 11:00:55 +0000
+++ examples/googler/googler.py	1970-01-01 00:00:00 +0000
@@ -1,21 +0,0 @@
-import urllib2
-
-
-class Googler(object):
-    BASE_QUERY_URL = 'http://www.google.com/search?q='
-    USER_AGENT = ('Mozilla/5.0' +
-                  '(X11; U; Linux i686; en-US; rv:1.7.8)' +
-                  'Gecko/20050524 Fedora/1.5 Firefox/1.5')
-
-    def __init__(self, terms):
-        query_string = '+'.join(terms)
-        request = urllib2.Request('%s%s' % (self.BASE_QUERY_URL,
-                                            query_string))
-        request.add_header('User-Agent', self.USER_AGENT)
-        connection = urllib2.urlopen(request)
-        self.response = connection.read()
-
-
-if __name__ == '__main__':
-    print Googler(['lulz', 'megalulz']).response
-

=== removed file 'examples/googler/runtests.py'
--- examples/googler/runtests.py	2009-10-22 11:00:55 +0000
+++ examples/googler/runtests.py	1970-01-01 00:00:00 +0000
@@ -1,12 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-
-import nose
-
-
-if __name__ == '__main__':
-    nose_args = sys.argv + [r'-m',
-                            r'((?:^|[b_.-])(:?[Tt]est|When|should))']
-    nose.run(argv=nose_args)
-

=== removed file 'examples/googler/test_googler.py'
--- examples/googler/test_googler.py	2009-10-22 11:00:55 +0000
+++ examples/googler/test_googler.py	1970-01-01 00:00:00 +0000
@@ -1,56 +0,0 @@
-from dingus import Dingus, DingusTestCase, DontCare
-import googler
-from googler import Googler
-
-
-class WhenCreatingRequest(DingusTestCase(Googler)):
-    def setup(self):
-        super(WhenCreatingRequest, self).setup()
-        self.query_term = 'query term'
-        self.googler = Googler([self.query_term])
-
-    def should_use_google_search_url(self):
-        query_url = 'http://www.google.com/search?q=%s' % self.query_term
-        assert googler.urllib2.calls('Request', query_url)
-
-
-class WhenCreatingRequestWithTwoTerms(DingusTestCase(Googler)):
-    def setup(self):
-        super(WhenCreatingRequestWithTwoTerms, self).setup()
-        self.terms = ['term1', 'term2']
-        self.googler = Googler(self.terms)
-
-    def should_combine_terms_in_search_url(self):
-        query_string = '+'.join(self.terms)
-        query_url = 'http://www.google.com/search?q=%s' % query_string
-        assert googler.urllib2.calls('Request', query_url)
-
-
-class WhenSendingRequest(DingusTestCase(Googler)):
-    def setup(self):
-        super(WhenSendingRequest, self).setup()
-        self.request = googler.urllib2.Request.return_value
-        Googler(['query term'])
-
-    def should_connect_to_google(self):
-        assert googler.urllib2.calls('urlopen', self.request)
-
-    def should_add_fake_user_agent_to_evade_filters(self):
-        call = self.request.calls('add_header',
-                                  'User-Agent',
-                                  DontCare).one()
-        assert 'Mozilla' in call.args[1]
-
-
-class WhenConnected(DingusTestCase(Googler)):
-    def setup(self):
-        super(WhenConnected, self).setup()
-        self.connection = googler.urllib2.urlopen.return_value
-        self.googler = Googler(['query term'])
-
-    def should_read_result(self):
-        assert self.connection.calls('read')
-
-    def should_store_result_in_attribute(self):
-        assert self.googler.response is self.connection.read.return_value
-

=== removed directory 'examples/urllib2'
=== removed file 'examples/urllib2/__init__.py'
--- examples/urllib2/__init__.py	2009-10-22 11:00:55 +0000
+++ examples/urllib2/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-

=== removed file 'examples/urllib2/runtests.py'
--- examples/urllib2/runtests.py	2009-10-22 11:00:55 +0000
+++ examples/urllib2/runtests.py	1970-01-01 00:00:00 +0000
@@ -1,12 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-
-import nose
-
-
-if __name__ == '__main__':
-    nose_args = sys.argv + [r'-m',
-                            r'((?:^|[b_.-])(:?[Tt]est|When|should))']
-    nose.run(argv=nose_args)
-

=== removed file 'examples/urllib2/test_urllib2.py'
--- examples/urllib2/test_urllib2.py	2009-10-22 11:00:55 +0000
+++ examples/urllib2/test_urllib2.py	1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
-from dingus import DingusTestCase, DontCare
-import urllib2
-from urllib2 import urlopen
-
-
-# We want to unit test the urlopen function. It's very small (as you can see
-# by looking at the source at ${PYTHON_INSTALL}/lib/python2.5/urllib2.py
-#
-# (This example assumes Python 2.5. Hopefully it also works for your version.)
-#
-# Dingus allows us to test urlopen without actually touching the network, or
-# any other classes and functions at all. When we define the test class, we
-# inherit from "DingusTestCase(urlopen)". DingusTestCase will define setup and
-# teardown method that replace every object in urllib2 with a dingus
-# (except urlopen, which is the "object under test". It does this by looking
-# at the module that urlopen was defined in, making a backup copy of its
-# contents, then replacing everything with a dingus. So, instead of making
-# network connections as it usually would, urlopen will be making calls into
-# the dinguses, which will record the calls so that we can make assertions
-# about them later.
-class WhenOpeningURLs(DingusTestCase(urlopen)):
-    def setup(self):
-        # We have to call DingusTestCase's setup method so that it can
-        # modify the urllib2 module's contents.
-        super(WhenOpeningURLs, self).setup()
-
-        # We set up the object under test here by calling urlopen with a URL.
-        self.url = 'http://www.example.com'
-        self.opened_url = urlopen(self.url)
-
-    # First, we expect urlopen to try to open the URL.
-    def should_open_provided_url(self):
-        # Normally urlopen would use a prexisting "opener" object that would
-        # touch the network, disk, etc., but DingusTestCase has replaced it
-        # with a dingus. We first grab that _opener object so we can make
-        # assertions about it.
-        opener = urllib2._opener
-
-        # We want to assert that urlopen should call "open" on the opener,
-        # passing the URL we gave it. "open" also takes another argument, but
-        # we don't care about that for this test. We pass in DontCare for
-        # things we don't care about, and the dingus will ignore that argument
-        # for the purposes of this assertion.
-        assert opener.calls('open', self.url, DontCare).one()
-
-        # Note that we never told the _opener dingus that it should have an
-        # "open" method. A dingus has *all* methods - it will try to allow
-        # anything to be done to it.
-
-    def should_return_opened_url(self):
-        # Now we want to assert that the opened object is returned to the
-        # caller. The line of code from urllib2 that we're testing is:
-        #     return _opener.open(url, data)
-        # We need to make sure that urlopen returned the result of that. We do
-        # that by accessing _opener.open.return_value. _opener.open is the
-        # dingus that replaced the original _opener.open method. The
-        # return_value is a special attribute of all dinguses that gets
-        # returned when the dingus is called as a function.
-        assert self.opened_url is urllib2._opener.open.return_value
-
-    # We could also define a teardown method for this test class, but that's
-    # rarely needed when writing fully isolated tests like this one.
-    # DingusTestCase does define a teardown method, though - it reverses the
-    # changes it made to the module under test, removing the dinguses and
-    # restoring the module's original contents. This class inherited it, so we
-    # don't have to call it manually.
-

=== added directory 'patches'
=== added file 'patches/series'
--- patches/series	1970-01-01 00:00:00 +0000
+++ patches/series	2011-10-20 19:36:43 +0000
@@ -0,0 +1,1 @@
+setup_cleanup

=== added file 'patches/setup_cleanup'
--- patches/setup_cleanup	1970-01-01 00:00:00 +0000
+++ patches/setup_cleanup	2011-10-20 19:36:43 +0000
@@ -0,0 +1,12 @@
+Index: python-dingus-0.3.2/setup.py
+===================================================================
+--- python-dingus-0.3.2.orig/setup.py	2011-08-07 09:37:57.900948735 +0100
++++ python-dingus-0.3.2/setup.py	2011-08-07 09:38:03.340954228 +0100
+@@ -7,7 +7,6 @@
+       author='Gary Bernhardt',
+       author_email='[e-mail]',
+       py_modules=['dingus'],
+-      data_files=[('', ['README.txt'])],
+       license='MIT',
+       url='https://github.com/garybernhardt/dingus',
+       keywords='testing test mocking mock double stub fake record assert',

=== modified file 'setup.py'
--- setup.py	2009-10-22 11:00:55 +0000
+++ setup.py	2011-10-20 19:36:43 +0000
@@ -1,15 +1,16 @@
-from setuptools import setup, find_packages
+from setuptools import setup
 
 setup(name='dingus',
-      version='0.1',
+      version='0.3.2',
       description='A record-then-assert mocking library',
+      long_description=file('README.txt').read(),
       author='Gary Bernhardt',
       author_email='[e-mail]',
       py_modules=['dingus'],
       license='MIT',
-      url='http://bitbucket.org/garybernhardt/dingus',
-      keywords='testing test mocking mock double stub fake',
-      classifiers=["Development Status :: 2 - Pre-Alpha",
+      url='https://github.com/garybernhardt/dingus',
+      keywords='testing test mocking mock double stub fake record assert',
+      classifiers=["Development Status :: 4 - Beta",
                    "Intended Audience :: Developers",
                    "License :: OSI Approved :: MIT License",
                    "Operating System :: OS Independent",
@@ -17,3 +18,4 @@
                    "Topic :: Software Development :: Testing",
                    ],
      )
+

=== removed directory 'tests'
=== removed file 'tests/__init__.py'
=== removed file 'tests/runtests.py'
--- tests/runtests.py	2009-10-22 11:00:55 +0000
+++ tests/runtests.py	1970-01-01 00:00:00 +0000
@@ -1,14 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-
-import nose
-
-
-if __name__ == '__main__':
-    nose_args = sys.argv + [r'-m',
-                            r'((?:^|[b_.-])(:?[Tt]est|When|should))',
-                            r'--with-doctest',
-                            r'--doctest-extension=']
-    nose.run(argv=nose_args)
-

=== removed file 'tests/test_call.py'
--- tests/test_call.py	2009-10-22 11:00:55 +0000
+++ tests/test_call.py	1970-01-01 00:00:00 +0000
@@ -1,22 +0,0 @@
-from dingus import Call
-
-
-class WhenInstantiated:
-    def setup(self):
-        self.call = Call('test name',
-                         'test args',
-                         'test kwargs',
-                         'test return_value')
-
-    def should_have_name(self):
-        assert self.call.name == 'test name'
-
-    def should_have_args(self):
-        assert self.call.args == 'test args'
-
-    def should_have_kwargs(self):
-        assert self.call.kwargs == 'test kwargs'
-
-    def should_have_return_value(self):
-        assert self.call.return_value == 'test return_value'
-

=== removed file 'tests/test_call_list.py'
--- tests/test_call_list.py	2009-10-22 11:00:55 +0000
+++ tests/test_call_list.py	1970-01-01 00:00:00 +0000
@@ -1,113 +0,0 @@
-from nose.tools import assert_raises
-
-from dingus import Call, CallList, DontCare
-
-
-class WhenEmpty:
-    def setup(self):
-        self.calls = CallList()
-
-    def should_be_false_in_boolean_context(self):
-        assert not self.calls
-
-    def should_not_have_one_element(self):
-        assert not self.calls.one()
-
-
-class WhenPopulatedWithACall:
-    def setup(self):
-        self.calls = CallList()
-        self.calls.append(Call('test name',
-                               'test args',
-                               'test kwargs',
-                               'test return_value'))
-
-    def should_be_true_in_boolean_context(self):
-        assert self.calls
-
-    def should_have_exactly_one_call(self):
-        assert self.calls.one()
-
-    def should_not_return_call_when_querying_for_wrong_name(self):
-        assert not self.calls('wrong name')
-
-    def should_not_return_call_when_querying_for_wrong_args(self):
-        assert not self.calls('test name', 'wrong args')
-
-    def should_not_return_call_when_querying_for_wrong_kwargs(self):
-        assert not self.calls('test name', wrong_key='wrong_value')
-
-
-class WhenPopulatedWithTwoCalls:
-    def setup(self):
-        self.calls = CallList()
-        for _ in range(2):
-            self.calls.append(Call('name', (), {}, None))
-
-    def should_not_have_one_element(self):
-        assert not self.calls.one()
-
-
-class WhenTwoCallsDifferByName:
-    def setup(self):
-        self.calls = CallList()
-        self.calls.append(Call('name1', (), {}, None))
-        self.calls.append(Call('name2', (), {}, None))
-
-    def should_filter_on_name(self):
-        assert self.calls('name1').one()
-
-
-class WhenTwoCallsDifferByArgs:
-    def setup(self):
-        self.calls = CallList()
-        self.calls.append(Call('name', ('arg1',), {}, None))
-        self.calls.append(Call('name', ('arg2',), {}, None))
-
-    def should_filter_on_args(self):
-        assert self.calls('name', 'arg1').one()
-
-
-class WhenCallsDifferInAllWays:
-    def setup(self):
-        self.calls = CallList()
-        for name in ('name1', 'name2'):
-            for args in (('arg1',), ('arg2',)):
-                for kwargs in ({'kwarg1': 1}, {'kwarg2': 2}):
-                    call = Call(name, args, kwargs, 'return value')
-                    self.calls.append(call)
-        self.call_count = len(self.calls)
-
-    def should_filter_on_name(self):
-        assert len(self.calls('name1')) == self.call_count / 2
-
-    def should_filter_on_args(self):
-        assert len(self.calls('name1', 'arg1')) == self.call_count / 4
-
-    def should_filter_on_kwargs(self):
-        assert len(self.calls('name1', kwarg1=1)) == self.call_count / 4
-
-
-class WhenCallsHaveMultipleArguments:
-    def setup(self):
-        self.calls = CallList()
-        for arg1 in (1, 2):
-            for arg2 in (1, 2):
-                self.calls.append(Call('name',
-                                       (arg1, arg2),
-                                       {},
-                                       'return_value'))
-        self.call_count = len(self.calls)
-
-    def should_be_able_to_ignore_all_arguments(self):
-        assert len(self.calls('name', DontCare, DontCare)) == self.call_count
-
-    def should_be_able_to_ignore_first_argument(self):
-        assert len(self.calls('name', 1, DontCare)) == self.call_count / 2
-
-    def should_be_able_to_ignore_second_argument(self):
-        assert len(self.calls('name', DontCare, 1)) == self.call_count / 2
-
-    def should_be_able_to_specify_both_arguments(self):
-        assert len(self.calls('name', 1, 1)) == self.call_count / 4
-

=== removed file 'tests/test_dingus.py'
--- tests/test_dingus.py	2009-10-22 11:00:55 +0000
+++ tests/test_dingus.py	1970-01-01 00:00:00 +0000
@@ -1,290 +0,0 @@
-import operator
-from functools import partial
-
-from nose.tools import assert_raises
-
-from dingus import Dingus
-
-
-class WhenCreatingNewDingus:
-    def setup(self):
-        self.dingus = Dingus()
-
-    def should_not_have_any_recorded_calls(self):
-        assert not self.dingus.calls()
-
-    def should_have_a_name(self):
-        assert self.dingus.__name__ == 'dingus_%i' % id(self.dingus)
-
-
-class WhenCreatingNewDingusWithAName:
-    def setup(self):
-        self.dingus = Dingus('something')
-
-    def should_have_a_name(self):
-        assert self.dingus.__name__ == 'something'
-
-    def should_include_name_in_repr(self):
-        assert repr(self.dingus) == '<Dingus something>'
-
-    def should_include_attribute_name_in_childrens_repr(self):
-        assert repr(self.dingus.child) == '<Dingus something.child>'
-
-    def should_include_attribute_name_in_repr_of_children_from_calling(self):
-        assert repr(self.dingus()) == '<Dingus something()>'
-
-    def should_include_attribute_name_in_repr_of_children_from_indexing(self):
-        assert repr(self.dingus()['5']) == '<Dingus something()[5]>'
-
-
-class WhenCallingDingusAsFunction:
-    def setup(self):
-        self.dingus = Dingus()
-        self.dingus('arg', kwarg=None)
-
-    def should_record_call(self):
-        assert self.dingus.calls()
-
-    def should_have_exactly_one_call(self):
-        assert self.dingus.calls().one()
-
-    def should_record_args(self):
-        assert self.dingus.calls.one().args == ('arg',)
-
-    def should_record_kwargs(self):
-        assert self.dingus.calls.one().kwargs == {'kwarg': None}
-
-
-class WhenCallingAttributeChild:
-    def setup(self):
-        self.parent = Dingus()
-        self.child = self.parent.child
-        self.child('arg', kwarg=None)
-
-    def should_record_call_on_child(self):
-        assert self.child.calls.one()
-
-    def should_record_call_on_parent(self):
-        assert self.parent.calls('child').one()
-
-    def should_record_args(self):
-        assert self.parent.calls('child').one().args == ('arg',)
-
-    def should_record_kwargs(self):
-        assert self.parent.calls('child').one().kwargs == {'kwarg': None}
-
-
-class WhenCallingAttributeGrandchild:
-    def setup(self):
-        self.grandparent = Dingus()
-        self.parent = self.grandparent.parent
-        self.child = self.parent.child
-        self.child('arg', kwarg=None)
-
-    def should_not_record_call_on_grandparent(self):
-        assert not self.grandparent.calls('parent.child')
-
-    def should_record_call_on_parent(self):
-        assert self.parent.calls('child').one()
-
-
-class WhenCallingAttributesOfReturnedValues:
-    def setup(self):
-        self.grandparent = Dingus()
-        self.parent = self.grandparent()
-        self.child = self.parent.child
-        self.child('arg', kwarg=None)
-
-    def should_record_call_on_grandparent(self):
-        assert self.grandparent.calls('()').one()
-
-    def should_record_child_call_on_child(self):
-        assert self.child.calls('()').one()
-
-    def should_record_child_call_on_parent(self):
-        assert self.parent.calls('child').one()
-
-    def should_not_record_child_call_on_grandparent(self):
-        assert not self.grandparent.calls('().child')
-
-
-class WhenCallingItemChild:
-    def should_record_call(self):
-        parent = Dingus()
-        parent['child']()
-        assert parent.calls('[child]').one()
-
-
-class WhenCallingListItemOfDingus:
-    def setup(self):
-        self.parent = Dingus()
-        self.child = self.parent[0]
-        self.child()
-
-    def should_record_call_on_parent(self):
-        assert self.parent.calls('[0]').one()
-
-    def should_record_call_on_child(self):
-        assert self.child.calls('()').one()
-
-
-class WhenAccessingMagicAttributes:
-    def should_raise_attribute_error_for_pyobjc_object(self):
-        # PyObjC uses __pyobjc_object__ to get an ObjC object from a Python
-        # object. Returning a Mock will cause a crash.
-        assert_raises(AttributeError, lambda: Dingus().__pyobjc_object__)
-
-
-class WhenApplyingBinaryOperators:
-    operator_names = ['add', 'and_', 'div', 'lshift', 'mod', 'mul', 'or_',
-                      'pow', 'rshift', 'sub', 'xor']
-
-    def assert_returns_new_dingus(self, op):
-        left, right = Dingus.many(2)
-        result = op(left, right)
-        assert result is not left and result is not right
-
-    def should_always_return_new_dingus(self):
-        for operator_name in self.operator_names:
-            op = getattr(operator, operator_name)
-            yield self.assert_returns_new_dingus, op
-
-
-class WhenComputingLength:
-    def should_be_one(self):
-        assert len(Dingus()) == 1
-
-
-class WhenAccessingReturnValueBeforeCalling:
-    def setup(self):
-        self.dingus = Dingus()
-
-    def should_have_return_value_before_calling(self):
-        assert self.dingus.return_value
-
-    def should_return_same_return_value_that_existed_before_calling(self):
-        original_return_value = self.dingus.return_value
-        return_value = self.dingus()
-        assert return_value is original_return_value
-
-    def should_have_same_return_value_before_and_after_calling(self):
-        original_return_value = self.dingus.return_value
-        self.dingus()
-        assert self.dingus.return_value is original_return_value
-
-
-class WhenSettingReturnValue:
-    def setup(self):
-        self.dingus = Dingus()
-        self.return_value = 5
-        self.dingus.return_value = self.return_value
-
-    def should_return_assigned_return_value(self):
-        assert self.dingus() is self.return_value
-
-    def should_have_same_return_value_after_calling(self):
-        self.dingus()
-        assert self.dingus.return_value is self.return_value
-
-
-class WhenSettingAttributes:
-    def setup(self):
-        self.dingus = Dingus()
-        self.attr = Dingus()
-        self.dingus.attr = self.attr
-
-    def should_remember_attr(self):
-        assert self.dingus.attr is self.attr
-
-    def should_not_return_attributes_as_items(self):
-        assert self.dingus['attr'] is not self.attr
-
-    def should_return_distinct_dinguses_for_different_attributes(self):
-        assert self.dingus['attr'] is not self.dingus['attr2']
-
-
-class WhenAccessingItems:
-    def should_log_access(self):
-        dingus = Dingus()
-        dingus['item']
-        assert dingus.calls('__getitem__', 'item').one()
-
-    def should_log_access_after_initial_item_read(self):
-        dingus = Dingus()
-        for _ in range(2):
-            dingus['item']
-        assert len(dingus.calls('__getitem__', 'item')) == 2
-
-
-class WhenSettingItems:
-    def setup(self):
-        self.dingus = Dingus()
-        self.item = Dingus()
-        self.dingus['item'] = self.item
-
-    def should_remember_item(self):
-        assert self.dingus['item'] is self.item
-
-    def should_log_access(self):
-        assert self.dingus.calls('__setitem__', 'item', self.item).one()
-
-    def should_not_return_items_as_attributes(self):
-        assert self.dingus.item is not self.item
-
-    def should_return_distinct_dinguses_for_different_items(self):
-        assert self.dingus['item'] is not self.dingus['item2']
-
-
-class WhenNothingIsSet:
-    def setup(self):
-        self.attribute_name = 'attr'
-        self.dingus = Dingus()
-
-    def should_be_able_to_access_attributes_that_dont_exist(self):
-        assert isinstance(getattr(self.dingus, self.attribute_name), Dingus)
-
-    def should_get_same_attribute_on_every_access(self):
-        get_attr = lambda: getattr(self.dingus, self.attribute_name)
-        assert get_attr() is get_attr()
-
-    def should_be_able_to_acces_items_that_dont_exist(self):
-        assert isinstance(self.dingus[self.attribute_name], Dingus)
-
-    def should_get_same_item_on_every_access(self):
-        get_item = lambda: self.dingus[self.attribute_name]
-        assert get_item() is get_item()
-
-    def should_have_attributes_that_have_not_been_set(self):
-        assert hasattr(self.dingus, self.attribute_name)
-
-
-class WhenSpecifyingAttributesViaKeywordArguments:
-    def should_set_specified_attributes(self):
-        attr = Dingus()
-        object_with_attr = Dingus(attr=attr)
-        assert object_with_attr.attr is attr
-
-
-class WhenCallingInitMethod:
-    def should_record_call(self):
-        dingus = Dingus()
-        dingus.__init__()
-        assert dingus.calls('__init__').one()
-
-
-class WhenCreatingMultipleDinguses:
-    def should_return_a_dingus_when_asked_for_one(self):
-        assert len(Dingus.many(1)) == 1
-
-    def should_return_two_dinguses_when_asked_for_two(self):
-        assert len(Dingus.many(2)) == 2
-
-    def should_return_dingus_instances_when_asked_for_multiple(self):
-        assert all(isinstance(dingus, Dingus) for dingus in Dingus.many(2))
-
-    def should_return_dinguses_in_tuple(self):
-        assert isinstance(Dingus.many(2), tuple)
-
-    def should_return_nothing_when_asked_for_zero_dinguses(self):
-        assert not Dingus.many(0)
-

=== removed file 'tests/test_dingus_test_case.py'
--- tests/test_dingus_test_case.py	2009-10-22 11:00:55 +0000
+++ tests/test_dingus_test_case.py	1970-01-01 00:00:00 +0000
@@ -1,65 +0,0 @@
-import sys
-import new
-
-from dingus import DingusTestCase, Dingus
-
-
-class WhenRunningTestCaseOnAModule(object):
-    def setup(self):
-        self.module = self._create_fake_module()
-        self.class_under_test = self._create_class_under_test()
-        self.test_case_class = self._create_test_case_class()
-
-    def _create_fake_module(self):
-        module = new.module('test_module')
-        module.value = 'value'
-        sys.modules[module.__name__] = module
-        return module
-
-    def _create_class_under_test(self):
-        class ClassThatWouldBeUnderTest:
-            pass
-        ClassThatWouldBeUnderTest.__module__ = self.module.__name__
-        self.module.ClassThatWouldBeUnderTest = ClassThatWouldBeUnderTest
-        return ClassThatWouldBeUnderTest
-
-    def _create_test_case_class(self):
-        class TestCaseClass(DingusTestCase(self.class_under_test)):
-            pass
-        return TestCaseClass
-
-    def teardown(self):
-        del sys.modules[self.module.__name__]
-
-
-class WhenCallingSetupFunction(WhenRunningTestCaseOnAModule):
-    def setup(self):
-        super(WhenCallingSetupFunction, self).setup()
-        self.test_case_instance = self.test_case_class()
-        self.test_case_instance.setup()
-
-    def teardown(self):
-        self.test_case_instance.teardown()
-        super(WhenCallingSetupFunction, self).teardown()
-
-    def should_replace_module_attributes(self):
-        assert isinstance(self.module.value, Dingus)
-
-    def should_leave_class_under_test_intact(self):
-        assert self.module.ClassThatWouldBeUnderTest is self.class_under_test
-
-
-class WhenCallingTeardownFunction(WhenRunningTestCaseOnAModule):
-    def setup(self):
-        super(WhenCallingTeardownFunction, self).setup()
-        self.test_case_object = self.test_case_class()
-        self.original_module_dict = self.module.__dict__.copy()
-        self.test_case_object.setup()
-        self.test_case_object.teardown()
-
-    def should_restore_module_attributes(self):
-        assert self.module.value is 'value'
-
-    def should_leave_globals_as_they_were_before_dingusing(self):
-        assert self.module.__dict__ == self.original_module_dict
-

=== removed file 'tests/test_exception_raiser.py'
--- tests/test_exception_raiser.py	2009-10-22 11:00:55 +0000
+++ tests/test_exception_raiser.py	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-from nose.tools import assert_raises
-from nose.tools import raises
-
-from dingus import exception_raiser
-
-
-class WhenCalled:
-    def setup(self):
-        exception = ValueError()
-        self.raise_exception = exception_raiser(exception)
-
-    def should_raise_provided_exception(self):
-        assert_raises(ValueError, self.raise_exception)
-
-    def should_take_args(self):
-        assert_raises(ValueError, self.raise_exception, 1)
-
-    def should_take_kwargs(self):
-        assert_raises(ValueError, self.raise_exception, kwarg=1)
-