Ejemplo n.º 1
0
def test_create_method_configs():
    method_configs = config.parse_method_configs(INTERFACE_CONFIG)

    retry, timeout = method_configs["AnnotateVideo"]
    assert retry._predicate(exceptions.DeadlineExceeded(None))
    assert retry._predicate(exceptions.ServiceUnavailable(None))
    assert retry._initial == 1.0
    assert retry._multiplier == 2.5
    assert retry._maximum == 120.0
    assert retry._deadline == 600.0
    assert timeout._initial == 120.0
    assert timeout._multiplier == 1.0
    assert timeout._maximum == 120.0

    retry, timeout = method_configs["Other"]
    assert retry._predicate(exceptions.FailedPrecondition(None))
    assert retry._initial == 1.0
    assert retry._multiplier == 1.0
    assert retry._maximum == 1.0
    assert retry._deadline == 1.0
    assert timeout._initial == 1.0
    assert timeout._multiplier == 1.0
    assert timeout._maximum == 1.0

    retry, timeout = method_configs["Plain"]
    assert retry is None
    assert timeout._timeout == 30.0
Ejemplo n.º 2
0
    def test_execute_integrity_error(self):
        from google.api_core import exceptions
        from google.cloud.spanner_dbapi.exceptions import IntegrityError

        connection = self._make_connection(self.INSTANCE, mock.MagicMock())
        cursor = self._make_one(connection)

        with mock.patch(
            "google.cloud.spanner_dbapi.parse_utils.classify_stmt",
            side_effect=exceptions.AlreadyExists("message"),
        ):
            with self.assertRaises(IntegrityError):
                cursor.execute(sql="sql")

        with mock.patch(
            "google.cloud.spanner_dbapi.parse_utils.classify_stmt",
            side_effect=exceptions.FailedPrecondition("message"),
        ):
            with self.assertRaises(IntegrityError):
                cursor.execute(sql="sql")

        with mock.patch(
            "google.cloud.spanner_dbapi.parse_utils.classify_stmt",
            side_effect=exceptions.OutOfRange("message"),
        ):
            with self.assertRaises(IntegrityError):
                cursor.execute("sql")
    def test_ingest_metadata_on_upsert_entry_failed_precondition_should_not_raise(  # noqa:E501
            self):
        entries = utils \
            .Utils.create_assembled_entries_user_defined_types()

        datacatalog_facade = self.__datacatalog_facade
        datacatalog_facade.upsert_entry.side_effect = \
            exceptions.FailedPrecondition('Failed precondition')

        self.__metadata_ingestor.ingest_metadata(entries, {})

        self.assertEqual(1, datacatalog_facade.create_entry_group.call_count)
        self.assertEqual(2, datacatalog_facade.upsert_entry.call_count)
    def test_upsert_entry_should_return_original_on_failed_precondition(self):
        entry_1 = create_entry('type', 'system', 'display_name', 'name', 'description',
                               'linked_resource_1', 11, 22)

        datacatalog = self.__datacatalog_client
        datacatalog.get_entry.return_value = entry_1
        datacatalog.update_entry.side_effect = \
            exceptions.FailedPrecondition('Failed precondition')

        entry_2 = create_entry('type', 'system', 'display_name', 'name', 'description',
                               'linked_resource_2', 11, 22)

        result = self.__datacatalog_facade.upsert_entry('entry_group_name', 'name', 'entry_id',
                                                        entry_2)

        self.assertEqual(1, datacatalog.get_entry.call_count)
        self.assertEqual(1, datacatalog.update_entry.call_count)
        self.assertEqual(entry_1, result)
    def test_upsert_entry_should_raise_on_failed_precondition(self):
        entry_1 = utils.Utils.create_entry_user_defined_type(
            'type', 'system', 'display_name', 'name', 'description',
            'linked_resource_1', 11, 22)

        datacatalog_client = self.__datacatalog_client
        datacatalog_client.get_entry.return_value = entry_1
        datacatalog_client.update_entry.side_effect = \
            exceptions.FailedPrecondition('Failed precondition')

        entry_2 = utils.Utils.create_entry_user_defined_type(
            'type', 'system', 'display_name', 'name', 'description',
            'linked_resource_2', 11, 22)

        self.assertRaises(exceptions.FailedPrecondition,
                          self.__datacatalog_facade.upsert_entry,
                          'entry_group_name', 'entry_id', entry_2)

        self.assertEqual(1, datacatalog_client.get_entry.call_count)
        self.assertEqual(1, datacatalog_client.update_entry.call_count)
    def test_upsert_entry_nonexistent_on_failed_precondition_should_raise(
            self):

        datacatalog_client = self.__datacatalog_client
        datacatalog_client.get_entry.side_effect = \
            exceptions.PermissionDenied('Entry not found')

        datacatalog_client.create_entry.side_effect = \
            exceptions.FailedPrecondition('Failed precondition')

        entry = utils.Utils.create_entry_user_defined_type(
            'type', 'system', 'display_name', 'name', 'description',
            'linked_resource', 11, 22)

        self.assertRaises(exceptions.FailedPrecondition,
                          self.__datacatalog_facade.upsert_entry,
                          'entry_group_name', 'entry_id', entry)

        self.assertEqual(1, datacatalog_client.get_entry.call_count)
        self.assertEqual(1, datacatalog_client.create_entry.call_count)