Mock

Create a new `Mock` object. `Mock` takes several optional arguments
that specify the behaviour of the Mock object:

* `spec`: This can be either a list of strings or an existing object (a
  class or instance) that acts as the specification for the mock object. If
  you pass in an object then a list of strings is formed by calling dir on
  the object (excluding unsupported magic attributes and methods). Accessing
  any attribute not in this list will raise an `AttributeError`.

  If `spec` is an object (rather than a list of strings) then
  `mock.__class__` returns the class of the spec object. This allows mocks
  to pass `isinstance` tests.

* `spec_set`: A stricter variant of `spec`. If used, attempting to *set*
  or get an attribute on the mock that isn't on the object passed as
  `spec_set` will raise an `AttributeError`.

* `side_effect`: A function to be called whenever the Mock is called. See
  the `side_effect` attribute. Useful for raising exceptions or
  dynamically changing return values. The function is called with the same
  arguments as the mock, and unless it returns `DEFAULT`, the return
  value of this function is used as the return value.

  If `side_effect` is an iterable then each call to the mock will return
  the next value from the iterable. If any of the members of the iterable
  are exceptions they will be raised instead of returned.

* `return_value`: The value returned when the mock is called. By default
  this is a new Mock (created on first access). See the
  `return_value` attribute.

* `unsafe`: By default, accessing any attribute whose name starts with
  *assert*, *assret*, *asert*, *aseert*, or *assrt* raises an AttributeError.
  Additionally, an AttributeError is raised when accessing
  attributes that match the name of an assertion method without the prefix
  `assert_`, e.g. accessing `called_once` instead of `assert_called_once`.
  Passing `unsafe=True` will allow access to these attributes.

* `wraps`: Item for the mock object to wrap. If `wraps` is not None then
  calling the Mock will pass the call through to the wrapped object
  (returning the real result). Attribute access on the mock will return a
  Mock object that wraps the corresponding attribute of the wrapped object
  (so attempting to access an attribute that doesn't exist will raise an
  `AttributeError`).

  If the mock has an explicit `return_value` set then calls are not passed
  to the wrapped object and the `return_value` is returned instead.

* `name`: If the mock has a name then it will be used in the repr of the
  mock. This can be useful for debugging. The name is propagated to child
  mocks.

Mocks can also be called with arbitrary keyword arguments. These will be
used to set attributes on the mock after it is created.