def test_create_event_process(self):
        """
        Test creating an event process
        """
#        process_definition = ProcessDefinition(name='test')

        mock = Mock()
        mock.definition = 'a_definition'
        mock.detail = 'event_process_detail'
        mock_id = 'a_process_definition_id'

        self.mock_rr_client.read = Mock()
        self.mock_rr_client.read.return_value = mock

        self.mock_rr_client.update = Mock()
        self.mock_rr_client.update = mocksignature(self.mock_rr_client.update)

        self.mock_rr_client.find_objects = Mock()
        self.mock_rr_client.find_objects.return_value = ['stream_id_1'], 'obj_assoc_1'

        self.mock_pd_client.schedule_process = Mock()
        self.mock_pd_client.schedule_process.return_value = 'process_id'

        self.mock_rr_client.create_association = mocksignature(self.mock_rr_client.create_association)

        self.mock_dams_client.register_event_process = mocksignature(self.mock_dams_client.register_event_process)

        pid = self.event_management.create_event_process(process_definition_id=mock_id,
            event_types=['type_1', 'type_2'],
            sub_types=['subtype_1', 'subtype_2'],
            origins=['or_1', 'or_2'],
            origin_types=['t1', 't2'],
            out_data_products={'conductivity': 'id1'}
        )

    def setUp(self):
        abstract_node_class = mocksignature(AbstractNode, AbstractNode)
        selector_class = mocksignature(StaticSelector, StaticSelector)

        self.abstract_node = abstract_node_class(self)
        self.abstract_node.selector = selector_class(self)
        self.root_node = Node(pattern='', parent=None, abstract_node=self.abstract_node)

    def setUp(self):
        def config_get_args(str1, str2):
            if str2 == 'api_root':
                return sentinel.api_root
            else:
                return sentinel.promo_code

        self.config = Mock()
        self.config.get = config_get_args
        

        def testfun_nopromo(api_root, user):
            pass

        def testfun_promo(api_root, user, promo_code):
            pass

        self.testfun_nopromo_mock = Mock()
        self.testfun_nopromo = mocksignature(testfun_nopromo, 
                                             self.testfun_nopromo_mock)
        self.testfun_nopromo.return_value = sentinel.testfun_nopromo

        self.testfun_promo_mock = Mock()
        self.testfun_promo = mocksignature(testfun_promo, 
                                           self.testfun_promo_mock)
        self.testfun_promo.return_value = sentinel.testfun_promo

    def testIntrospection(self):
        def f(a, *args, **kwargs):
            pass
        f2 = mocksignature(f, f)
        self.assertEqual(inspect.getargspec(f), inspect.getargspec(f2))

        def f(a, b=None, c=3, d=object()):
            pass
        f2 = mocksignature(f, f)
        self.assertEqual(inspect.getargspec(f), inspect.getargspec(f2))

    def test_create_event_type(self):
        """
        Test creating an event
        """
        event_type = EventType(name="Test event type")
        self.mock_rr_client.create = mocksignature(self.mock_rr_client.create)
        self.mock_rr_client.create.return_value = ('event_type_id','rev_1')

        self.mock_dams_client.register_process = mocksignature(self.mock_dams_client.register_process)

        event_type_id = self.event_management.create_event_type(event_type)

        self.assertEquals(event_type_id, 'event_type_id')
        self.mock_rr_client.create.assert_called_once_with(event_type)

    def testMockSignatureWithReservedArg(self):
        def f(_mock_):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

        def f(_mock_=None):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

        def f(*_mock_):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

        def f(**_mock_):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

    def test_create_event_process(self):
        """
        Test creating an event process
        """
        process_definition = ProcessDefinition(name='test')
        process_definition.definition = ''

        rrc = ResourceRegistryServiceClient(node = self.container.node)
        process_definition_id = rrc.create(process_definition)

        self.mock_rr_client.find_objects = Mock()
        self.mock_rr_client.find_objects.return_value = ['stream_id_1'], 'obj_assoc_1'

#        self.mock_pd_client.schedule_process = Mock()
#        self.mock_pd_client.schedule_process.return_value = 'process_id'

        self.mock_rr_client.create_association = mocksignature(self.mock_rr_client.create_association)

        pid = self.event_management.create_event_process(process_definition_id=process_definition_id,
            event_types=['type_1', 'type_2'],
            sub_types=['subtype_1', 'subtype_2'],
            origins=['or_1', 'or_2'],
            origin_types=['t1', 't2'],
            out_data_products={'conductivity': 'id1'}
        )

    def test_side_effect_from_existing_mock(self):
        mock = Mock(side_effect=KeyError)
        func = mocksignature(f, mock)
        self.assertRaises(KeyError, func, 1, 2, 3)

        mock.side_effect = NameError
        self.assertRaises(NameError, func, 1, 2, 3)

    def test_return_value_from_existing_mock(self):
        mock = Mock(return_value='foo')
        func = mocksignature(f, mock)
        self.assertEqual(func(1, 2, 3), 'foo')

        mock.return_value = 'bar'
        self.assertEqual(func(1, 2, 3), 'bar')

 def _create_service_mock(self, service_name):
     # set self.clients if not already set
     clients = Mock(name='clients')
     base_service = get_service_registry().get_service_base(service_name)
     # Save it to use in test_verify_service
     self.base_service = base_service
     self.addCleanup(delattr, self, 'base_service')
     dependencies = base_service.dependencies
     for dep_name in dependencies:
         dep_service = get_service_registry().get_service_base(dep_name)
         # Force mock service to use interface
         mock_service = Mock(name='clients.%s' % dep_name,
                 spec=dep_service)
         setattr(clients, dep_name, mock_service)
         # set self.dep_name for convenience
         setattr(self, dep_name, mock_service)
         self.addCleanup(delattr, self, dep_name)
         iface = list(implementedBy(dep_service))[0]
         names_and_methods = iface.namesAndDescriptions()
         for func_name, _ in names_and_methods:
             mock_func = mocksignature(getattr(dep_service, func_name),
                     mock=Mock(name='clients.%s.%s' % (dep_name,
                         func_name)), skipfirst=True)
             setattr(mock_service, func_name, mock_func)
     return clients

    def test_mocksignature_with_reserved_arg(self):
        def f(_mock_):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

        def f(_mock_=None):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

        def f(*_mock_):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

        def f(**_mock_):
            pass
        self.assertRaises(AssertionError, lambda: mocksignature(f))

    def test_load_cards(self):
        fbb = [u"Foo", u"Bar", u"Baz"]

        parse = mock.mocksignature(p.parse)

        for l, f in itertools.izip_longest(p.load_cards(S, _parse=parse), fbb):
            self.assertEqual(list(parse.mock.call_args[0][0]), [f] * 3)

    def test_delete_event_process(self):
        """
        Test deleting an event process
        """
        self.mock_rr_client.delete = mocksignature(self.mock_rr_client.delete)
        self.event_management.delete_event_process('event_process_id')

        self.mock_rr_client.delete.assert_called_once_with('event_process_id')

    def test_delete_event_type(self):
        """
        Test updating an event
        """
        self.mock_rr_client.delete = mocksignature(self.mock_rr_client.delete)

        self.event_management.delete_event_type(event_type_id='event_type_id')
        self.mock_rr_client.delete.assert_called_once_with('event_type_id')

def test_get_pod_files():
    mock_os_listdir = Mock(return_value = ['foo', 'bar', 'baz'])
    mock_pod_executable_file_p = mocksignature(barker.pod.executable_file_p)
    mock_pod_executable_file_p.return_value = True
    with patch.object(barker.pod.os, 'listdir', mock_os_listdir):
        with patch.object(barker.pod, "executable_file_p", mock_pod_executable_file_p):
            assert_equals(list(barker.pod.get_pod_files('/barker-tests')),
                          ['/barker-tests/foo', '/barker-tests/bar', '/barker-tests/baz'])

    def test_get_nodes(self):
        selector = ModelSelector(projection="%(label)s", model_class=Thing)

        abstract_node_class = mocksignature(AbstractNode, AbstractNode)
        abstract_node = abstract_node_class(self)
        nodes = selector.get_nodes(abstract_node)

        self.assertIsInstance(nodes, list)
        self.assertGreater(len(nodes), 0)

    def test_read_event_process(self):
        """
        Test reading an event process
        """
        event_process = Mock()
        self.mock_rr_client.read = mocksignature(self.mock_rr_client.read)
        self.mock_rr_client.read.return_value = event_process

        result = self.event_management.read_event_process('event_process_id')
        self.assertEquals(result, event_process)

    def testMockSignatureClass(self):
        MockedSomething = mocksignature(Something)

        result = MockedSomething(5, 23)
        self.assertIs(result, MockedSomething.mock.return_value)

        MockedSomething(1)
        MockedSomething.mock.assert_caled_with(1, 10)

        self.assertRaises(TypeError, MockedSomething)

    def test_read_event_process_definition(self):
        """
        Test reading an event process definition
        """
        event_process_def = Mock()
        self.mock_rr_client.read = mocksignature(self.mock_rr_client.read)
        self.mock_rr_client.read.return_value = event_process_def

        result = self.event_management.read_event_process_definition()
        self.assertEquals(result, event_process_def)

    def testMockSignatureCallable(self):
        mocked_something = mocksignature(something)

        result = mocked_something(5, 23)
        self.assertIs(result, mocked_something.mock.return_value)

        mocked_something(1)
        mocked_something.mock.assert_caled_with(1, 5)

        self.assertRaises(TypeError, mocked_something)