def test_notify_delete_table_async(self, mock_table_info_repo):
        self.cleanup_test_notifier()

        context = mock.Mock(tenant='fake_tenant')
        table_name = 'fake_table'

        mock_storage_driver = mock.Mock()
        mock_storage_driver.delete_table.return_value = True

        class FakeTableInfo:
            status = models.TableMeta.TABLE_STATUS_ACTIVE
            name = table_name
            id = None
            schema = None
            creation_date_time = None

        mock_table_info_repo = mock.Mock()
        mock_table_info_repo.get.return_value = FakeTableInfo()

        storage_manager = AsyncSimpleStorageManager(mock_storage_driver,
                                                    mock_table_info_repo)
        storage_manager.delete_table(context, table_name)

        # wait for async delete table call to finish
        for i in range(10):
            if (mock_table_info_repo.delete.called and
                    len(self.get_notifications()) == 2):
                # delete_table method of mock_storage_driver has been called
                break
            else:
                time.sleep(1)
        else:
            self.fail("Couldn't wait for async request completion")

        # delete method of mock_table_info_repo has been called
        self.assertTrue(mock_table_info_repo.delete.called)

        # check notification queue
        self.assertEqual(len(self.get_notifications()), 2)

        start_event = self.get_notifications()[0]
        end_event = self.get_notifications()[1]

        self.assertEqual(start_event['priority'], 'INFO')
        self.assertEqual(start_event['event_type'],
                         notifier.EVENT_TYPE_TABLE_DELETE_START)
        self.assertEqual(start_event['payload'], table_name)

        self.assertEqual(end_event['priority'], 'INFO')
        self.assertEqual(end_event['event_type'],
                         notifier.EVENT_TYPE_TABLE_DELETE_END)
        self.assertEqual(end_event['payload'], table_name)

        time_start = datetime.datetime.strptime(
            start_event['timestamp'], DATETIMEFORMAT)
        time_end = datetime.datetime.strptime(
            end_event['timestamp'], DATETIMEFORMAT)
        self.assertTrue(time_start < time_end,
                        "start event is later than end event")
Example #2
0
    def test_notify_delete_table_async(self, mock_table_info_repo):
        self.cleanup_test_notifier()

        context = mock.Mock(tenant='fake_tenant')
        table_name = 'fake_table'

        mock_storage_driver = mock.Mock()
        mock_storage_driver.delete_table.return_value = True

        class FakeTableInfo:
            status = models.TableMeta.TABLE_STATUS_ACTIVE
            name = table_name
            id = None
            schema = None
            creation_date_time = None

        mock_table_info_repo = mock.Mock()
        mock_table_info_repo.get.return_value = FakeTableInfo()

        storage_manager = AsyncSimpleStorageManager(mock_storage_driver,
                                                    mock_table_info_repo)
        storage_manager.delete_table(context, table_name)

        # wait for async delete table call to finish
        for i in range(10):
            if (mock_table_info_repo.delete.called
                    and len(self.get_notifications()) == 2):
                # delete_table method of mock_storage_driver has been called
                break
            else:
                time.sleep(1)
        else:
            self.fail("Couldn't wait for async request completion")

        # delete method of mock_table_info_repo has been called
        self.assertTrue(mock_table_info_repo.delete.called)

        # check notification queue
        self.assertEqual(len(self.get_notifications()), 2)

        start_event = self.get_notifications()[0]
        end_event = self.get_notifications()[1]

        self.assertEqual(start_event['priority'], 'INFO')
        self.assertEqual(start_event['event_type'],
                         notifier.EVENT_TYPE_TABLE_DELETE_START)
        self.assertEqual(start_event['payload'], table_name)

        self.assertEqual(end_event['priority'], 'INFO')
        self.assertEqual(end_event['event_type'],
                         notifier.EVENT_TYPE_TABLE_DELETE_END)
        self.assertEqual(end_event['payload'], table_name)

        time_start = datetime.datetime.strptime(start_event['timestamp'],
                                                DATETIMEFORMAT)
        time_end = datetime.datetime.strptime(end_event['timestamp'],
                                              DATETIMEFORMAT)
        self.assertTrue(time_start < time_end,
                        "start event is later than end event")
    def test_create_table_async(self, mock_table_info_repo):
        context = mock.Mock(tenant='fake_tenant')
        table_name = 'fake_table'
        table_schema = 'fake_table_schema'

        mock_storage_driver = mock.Mock()
        mock_storage_driver.create_table.return_value = "fake_internal_name"

        table_info_save_args_list = []

        def side_effect(*args):
            table_info_save_args_list.append(deepcopy(args))

        mock_table_info_repo.save.side_effect = side_effect

        storage_manager = AsyncSimpleStorageManager(mock_storage_driver,
                                                    mock_table_info_repo)
        storage_manager.create_table(context, table_name, table_schema)

        # called once, length of call_args_list indicates number of calls
        self.assertEqual(1, len(table_info_save_args_list))

        # CallList is tuple of Mock and TableInfo
        self.assertEqual(2, len(table_info_save_args_list[0]))

        # TableInfo status should be creating initially when
        # table_info_repo.save is called
        self.assertEquals(models.TableMeta.TABLE_STATUS_CREATING,
                          table_info_save_args_list[0][1].status)

        # wait for async create table call to finish
        for i in range(10):
            if mock_table_info_repo.update.called:
                table_info_update_args_list = (
                    mock_table_info_repo.update.call_args_list
                )

                # called once
                # length of call_args_list indicates number of calls
                self.assertEqual(1, len(table_info_update_args_list))

                self.assertEqual(2, len(table_info_update_args_list[0]))

                # tuple of Mock, TableInfo, and status list
                self.assertEqual(3, len(table_info_update_args_list[0][0]))

                # TableInfo status should be active by now
                self.assertEqual(models.TableMeta.TABLE_STATUS_ACTIVE,
                                 table_info_update_args_list[0][0][1].status)
                break
            else:
                time.sleep(1)

        # create_table method has been called
        self.assertTrue(mock_storage_driver.create_table.called)
    def test_create_table_async(self, mock_table_info_repo):
        context = mock.Mock(tenant='fake_tenant')
        table_name = 'fake_table'
        table_schema = 'fake_table_schema'

        mock_storage_driver = mock.Mock()
        mock_storage_driver.create_table.return_value = "fake_internal_name"

        table_info_save_args_list = []

        def side_effect(*args):
            table_info_save_args_list.append(deepcopy(args))

        mock_table_info_repo.save.side_effect = side_effect

        storage_manager = AsyncSimpleStorageManager(mock_storage_driver,
                                                    mock_table_info_repo)
        storage_manager.create_table(context, table_name, table_schema)

        # called once, length of call_args_list indicates number of calls
        self.assertEqual(1, len(table_info_save_args_list))

        # CallList is tuple of Mock and TableInfo
        self.assertEqual(2, len(table_info_save_args_list[0]))

        # TableInfo status should be creating initially when
        # table_info_repo.save is called
        self.assertEquals(models.TableMeta.TABLE_STATUS_CREATING,
                          table_info_save_args_list[0][1].status)

        # wait for async create table call to finish
        for i in range(10):
            if mock_table_info_repo.update.called:
                table_info_update_args_list = (
                    mock_table_info_repo.update.call_args_list)

                # called once
                # length of call_args_list indicates number of calls
                self.assertEqual(1, len(table_info_update_args_list))

                self.assertEqual(2, len(table_info_update_args_list[0]))

                # tuple of Mock, TableInfo, and status list
                self.assertEqual(3, len(table_info_update_args_list[0][0]))

                # TableInfo status should be active by now
                self.assertEqual(models.TableMeta.TABLE_STATUS_ACTIVE,
                                 table_info_update_args_list[0][0][1].status)
                break
            else:
                time.sleep(1)

        # create_table method has been called
        self.assertTrue(mock_storage_driver.create_table.called)
    def test_notify_create_table_async(self, mock_table_info_repo):
        TestNotify.cleanup_test_notifier()

        context = mock.Mock(tenant='fake_tenant')
        table_name = 'fake_table'
        table_schema = 'fake_table_schema'

        mock_storage_driver = mock.Mock()
        mock_storage_driver.create_table.return_value = True

        storage_manager = AsyncSimpleStorageManager(mock_storage_driver,
                                                    mock_table_info_repo)
        storage_manager.create_table(context, table_name, table_schema)

        # wait for async create table call to finish
        for i in range(10):
            if (mock_table_info_repo.update.called and
                    len(test_notifier.NOTIFICATIONS) == 2):
                break
            else:
                time.sleep(1)
        else:
            self.fail("Couldn't wait for async request completion")

        # create_table method has been called
        self.assertTrue(mock_storage_driver.create_table.called)

        # check notification queue
        self.assertEqual(len(test_notifier.NOTIFICATIONS), 2)

        start_event = test_notifier.NOTIFICATIONS[0]
        end_event = test_notifier.NOTIFICATIONS[1]

        self.assertEqual(start_event['priority'],
                         cfg.CONF.default_notification_level)
        self.assertEqual(start_event['event_type'],
                         notifier.EVENT_TYPE_TABLE_CREATE_START)
        self.assertEqual(start_event['payload'], table_schema)

        self.assertEqual(end_event['priority'],
                         cfg.CONF.default_notification_level)
        self.assertEqual(end_event['event_type'],
                         notifier.EVENT_TYPE_TABLE_CREATE_END)
        self.assertEqual(end_event['payload'], table_schema)

        time_start = datetime.datetime.strptime(
            start_event['timestamp'], DATETIMEFORMAT)
        time_end = datetime.datetime.strptime(
            end_event['timestamp'], DATETIMEFORMAT)
        self.assertTrue(time_start < time_end,
                        "start event is later than end event")
    def test_notify_create_table_async(self, mock_table_info_repo):
        self.cleanup_test_notifier()

        context = mock.Mock(tenant='fake_tenant')
        table_name = 'fake_table'
        table_schema = 'fake_table_schema'

        mock_storage_driver = mock.Mock()
        mock_storage_driver.create_table.return_value = True

        storage_manager = AsyncSimpleStorageManager(mock_storage_driver,
                                                    mock_table_info_repo)
        storage_manager.create_table(context, table_name, table_schema)

        # wait for async create table call to finish
        for i in range(10):
            if (mock_table_info_repo.update.called and
                    len(self.get_notifications()) == 2):
                break
            else:
                time.sleep(1)
        else:
            self.fail("Couldn't wait for async request completion")

        # create_table method has been called
        self.assertTrue(mock_storage_driver.create_table.called)

        # check notification queue
        self.assertEqual(len(self.get_notifications()), 2)

        start_event = self.get_notifications()[0]
        end_event = self.get_notifications()[1]

        self.assertEqual(start_event['priority'], 'INFO')
        self.assertEqual(start_event['event_type'],
                         notifier.EVENT_TYPE_TABLE_CREATE_START)
        self.assertEqual(start_event['payload'], table_schema)

        self.assertEqual(end_event['priority'], 'INFO')
        self.assertEqual(end_event['event_type'],
                         notifier.EVENT_TYPE_TABLE_CREATE_END)
        self.assertEqual(end_event['payload'], table_schema)

        time_start = datetime.datetime.strptime(
            start_event['timestamp'], DATETIMEFORMAT)
        time_end = datetime.datetime.strptime(
            end_event['timestamp'], DATETIMEFORMAT)
        self.assertTrue(time_start < time_end,
                        "start event is later than end event")
    def test_delete_table_async(self, mock_table_info_repo):
        context = mock.Mock(tenant='fake_tenant')
        table_name = 'fake_table'

        mock_storage_driver = mock.Mock()
        mock_storage_driver.delete_table.return_value = True

        class FakeTableInfo:
            status = models.TableMeta.TABLE_STATUS_ACTIVE
            name = table_name
            id = None
            schema = None
            creation_date_time = None

        mock_table_info_repo = mock.Mock()
        mock_table_info_repo.get.return_value = FakeTableInfo()

        storage_manager = AsyncSimpleStorageManager(mock_storage_driver,
                                                    mock_table_info_repo)
        storage_manager.delete_table(context, table_name)

        table_info_update_args_list = (
            mock_table_info_repo.update.call_args_list
        )

        # called once, length of call_args_list indicates number of calls
        self.assertEqual(1, len(table_info_update_args_list))

        self.assertEqual(2, len(table_info_update_args_list[0]))

        # tuple of Mock, TableInfo, and status list
        self.assertEqual(3, len(table_info_update_args_list[0][0]))

        # TableInfo status should be deleting
        self.assertEqual(models.TableMeta.TABLE_STATUS_DELETING,
                         table_info_update_args_list[0][0][1].status)

        for i in range(10):
            if mock_table_info_repo.delete.called:
                # delete_table method of mock_storage_driver has been called
                self.assertTrue(mock_storage_driver.delete_table.called)
                break
            else:
                time.sleep(1)

        # delete method of mock_table_info_repo has been called
        self.assertTrue(mock_table_info_repo.delete.called)
    def test_delete_table_async(self, mock_table_info_repo):
        context = mock.Mock(tenant='fake_tenant')
        table_name = 'fake_table'

        mock_storage_driver = mock.Mock()
        mock_storage_driver.delete_table.return_value = True

        class FakeTableInfo:
            status = models.TableMeta.TABLE_STATUS_ACTIVE
            name = table_name
            id = None
            schema = None
            creation_date_time = None

        mock_table_info_repo = mock.Mock()
        mock_table_info_repo.get.return_value = FakeTableInfo()

        storage_manager = AsyncSimpleStorageManager(mock_storage_driver,
                                                    mock_table_info_repo)
        storage_manager.delete_table(context, table_name)

        table_info_update_args_list = (
            mock_table_info_repo.update.call_args_list)

        # called once, length of call_args_list indicates number of calls
        self.assertEqual(1, len(table_info_update_args_list))

        self.assertEqual(2, len(table_info_update_args_list[0]))

        # tuple of Mock, TableInfo, and status list
        self.assertEqual(3, len(table_info_update_args_list[0][0]))

        # TableInfo status should be deleting
        self.assertEqual(models.TableMeta.TABLE_STATUS_DELETING,
                         table_info_update_args_list[0][0][1].status)

        for i in range(10):
            if mock_table_info_repo.delete.called:
                # delete_table method of mock_storage_driver has been called
                self.assertTrue(mock_storage_driver.delete_table.called)
                break
            else:
                time.sleep(1)

        # delete method of mock_table_info_repo has been called
        self.assertTrue(mock_table_info_repo.delete.called)