Beispiel #1
0
    def setUp(self):
        mock_clients = self._create_service_mock('conversation_management')

        # Rename to save some typing
        self.mock_create = mock_clients.resource_registry.create
        self.mock_read = mock_clients.resource_registry.read
        self.mock_update = mock_clients.resource_registry.update
        self.mock_delete = mock_clients.resource_registry.delete
        self.mock_create_association = mock_clients.resource_registry.create_association
        self.mock_delete_association = mock_clients.resource_registry.delete_association
        self.mock_find_objects = mock_clients.resource_registry.find_objects
        self.mock_find_resources = mock_clients.resource_registry.find_resources
        self.mock_find_subjects = mock_clients.resource_registry.find_subjects

        self.convo_management_service = ConversationManagementService()
        self.convo_management_service.clients = mock_clients

        # ConversationType
        self.convo_type = Mock()
        self.convo_type.name = 'Generic_RPC'

        # ConversationRole
        self.convo_role = Mock()
        self.convo_role.name = 'provider'
Beispiel #2
0
class TestPolicyManagementService(PyonTestCase):
    def setUp(self):
        mock_clients = self._create_service_mock('conversation_management')

        # Rename to save some typing
        self.mock_create = mock_clients.resource_registry.create
        self.mock_read = mock_clients.resource_registry.read
        self.mock_update = mock_clients.resource_registry.update
        self.mock_delete = mock_clients.resource_registry.delete
        self.mock_create_association = mock_clients.resource_registry.create_association
        self.mock_delete_association = mock_clients.resource_registry.delete_association
        self.mock_find_objects = mock_clients.resource_registry.find_objects
        self.mock_find_resources = mock_clients.resource_registry.find_resources
        self.mock_find_subjects = mock_clients.resource_registry.find_subjects

        self.convo_management_service = ConversationManagementService()
        self.convo_management_service.clients = mock_clients

        # ConversationType
        self.convo_type = Mock()
        self.convo_type.name = 'Generic_RPC'

        # ConversationRole
        self.convo_role = Mock()
        self.convo_role.name = 'provider'

    def test_create_conversation_type(self):
        self.mock_create.return_value = ['123', 1]

        convo_type_id = self.convo_management_service.create_conversation_type(
            self.convo_type)

        assert convo_type_id == '123'
        self.mock_create.assert_called_once_with(self.convo_type)

    def test_read_and_update_conversation_type(self):
        self.mock_read.return_value = self.convo_type

        convo_type = self.convo_management_service.read_conversation_type(
            '123')

        assert convo_type is self.mock_read.return_value
        self.mock_read.assert_called_once_with('123', '')

        convo_type.name = 'New_test_Type'

        self.mock_update.return_value = ['123', 2]

        self.convo_management_service.update_conversation_type(convo_type)

        self.mock_update.assert_called_once_with(convo_type)

    def test_delete_conversation_type(self):
        self.mock_read.return_value = self.convo_type
        self.mock_find_objects.return_value = ([], [])

        self.convo_management_service.delete_conversation_type('123')

        self.mock_delete.assert_called_once_with('123')

    def test_read_conversation_type_not_found(self):
        self.mock_read.return_value = None

        # TEST: Execute the service operation call
        with self.assertRaises(NotFound) as cm:
            self.convo_management_service.read_conversation_type('bad type')

        ex = cm.exception
        self.assertEqual(ex.message,
                         "Conversation Type 'bad type' does not exist")
        self.mock_read.assert_called_once_with('bad type', '')

    def test_delete_conversation_type_not_found(self):
        self.mock_read.return_value = None

        # TEST: Execute the service operation call
        with self.assertRaises(NotFound) as cm:
            self.convo_management_service.delete_conversation_type('bad type')

        ex = cm.exception
        self.assertEqual(ex.message,
                         "Conversation Type 'bad type' does not exist")
        self.mock_read.assert_called_once_with('bad type', '')

    def test_create_conversation_role(self):
        self.mock_create.return_value = ['123', 1]

        convo_role_id = self.convo_management_service.create_conversation_role(
            self.convo_role)

        assert convo_role_id == '123'
        self.mock_create.assert_called_once_with(self.convo_role)

    def test_read_and_update_conversation_role(self):
        self.mock_read.return_value = self.convo_role

        convo_role = self.convo_management_service.read_conversation_role(
            '123')

        assert convo_role is self.mock_read.return_value
        self.mock_read.assert_called_once_with('123', '')

        convo_role.name = 'requester'

        self.mock_update.return_value = ['123', 2]

        self.convo_management_service.update_conversation_role(convo_role)

        self.mock_update.assert_called_once_with(convo_role)

    def test_delete_conversation_role(self):
        self.mock_read.return_value = self.convo_role
        self.mock_find_subjects.return_value = ([], [])

        self.convo_management_service.delete_conversation_role('123')

        self.mock_delete.assert_called_once_with('123')

    def test_read_conversation_role_not_found(self):
        self.mock_read.return_value = None

        # TEST: Execute the service operation call
        with self.assertRaises(NotFound) as cm:
            self.convo_management_service.read_conversation_role('bad role')

        ex = cm.exception
        self.assertEqual(ex.message,
                         "Conversation Role 'bad role' does not exist")
        self.mock_read.assert_called_once_with('bad role', '')

    def test_delete_conversation_role_not_found(self):
        self.mock_read.return_value = None

        # TEST: Execute the service operation call
        with self.assertRaises(NotFound) as cm:
            self.convo_management_service.delete_conversation_role('bad role')

        ex = cm.exception
        self.assertEqual(ex.message,
                         "Conversation Role 'bad role' does not exist")
        self.mock_read.assert_called_once_with('bad role', '')

    def test_not_implemented_methods(self):
        self.convo_management_service.create_conversation()
        self.convo_management_service.update_conversation()
        self.convo_management_service.read_conversation()
        self.convo_management_service.delete_conversation()