def test_bigtable_delete_instance(): # [START bigtable_delete_instance] from google.cloud.bigtable import Client client = Client(admin=True) instance_id_to_delete = "inst-my-" + unique_resource_id("-") # [END bigtable_delete_instance] cluster_id = "clus-my-" + unique_resource_id("-") instance = client.instance( instance_id_to_delete, instance_type=PRODUCTION, labels=LABELS ) cluster = instance.cluster( cluster_id, location_id=ALT_LOCATION_ID, serve_nodes=SERVER_NODES, default_storage_type=STORAGE_TYPE, ) operation = instance.create(clusters=[cluster]) # We want to make sure the operation completes. operation.result(timeout=100) # [START bigtable_delete_instance] instance_to_delete = client.instance(instance_id_to_delete) instance_to_delete.delete() # [END bigtable_delete_instance] assert not instance_to_delete.exists()
def test_bigtable_create_instance(): # [START bigtable_create_prod_instance] from google.cloud.bigtable import Client from google.cloud.bigtable import enums my_instance_id = "inst-my-" + unique_resource_id("-") my_cluster_id = "clus-my-" + unique_resource_id("-") location_id = "us-central1-f" serve_nodes = 3 storage_type = enums.StorageType.SSD production = enums.Instance.Type.PRODUCTION labels = {"prod-label": "prod-label"} client = Client(admin=True) instance = client.instance(my_instance_id, instance_type=production, labels=labels) cluster = instance.cluster( my_cluster_id, location_id=location_id, serve_nodes=serve_nodes, default_storage_type=storage_type, ) operation = instance.create(clusters=[cluster]) # We want to make sure the operation completes. operation.result(timeout=100) # [END bigtable_create_prod_instance] assert instance.exists() instance.delete()
def test_create_sink_pubsub_topic(self): from google.cloud import pubsub_v1 SINK_NAME = 'test-create-sink-topic%s' % (_RESOURCE_ID,) TOPIC_NAME = 'logging-systest{}'.format(unique_resource_id('-')) # Create the destination topic, and set up the IAM policy to allow # Stackdriver Logging to write into it. publisher = pubsub_v1.PublisherClient() topic_path = publisher.topic_path(Config.CLIENT.project, TOPIC_NAME) self.to_delete.append(_DeleteWrapper(publisher, topic_path)) publisher.create_topic(topic_path) policy = publisher.get_iam_policy(topic_path) policy.bindings.add( role='roles/owner', members=['group:[email protected]'] ) publisher.set_iam_policy(topic_path, policy) TOPIC_URI = 'pubsub.googleapis.com/%s' % (topic_path,) sink = Config.CLIENT.sink(SINK_NAME, DEFAULT_FILTER, TOPIC_URI) self.assertFalse(sink.exists()) sink.create() self.to_delete.append(sink) self.assertTrue(sink.exists())
def test_watch_query(client, cleanup): db = client doc_ref = db.collection(u"users").document(u"alovelace" + unique_resource_id()) query_ref = db.collection(u"users").where("first", "==", u"Ada") # Initial setting doc_ref.set({u"first": u"Jane", u"last": u"Doe", u"born": 1900}) sleep(1) # Setup listener def on_snapshot(docs, changes, read_time): on_snapshot.called_count += 1 # A snapshot should return the same thing as if a query ran now. query_ran = db.collection(u"users").where("first", "==", u"Ada").stream() assert len(docs) == len([i for i in query_ran]) on_snapshot.called_count = 0 query_ref.on_snapshot(on_snapshot) # Alter document doc_ref.set({u"first": u"Ada", u"last": u"Lovelace", u"born": 1815}) for _ in range(10): if on_snapshot.called_count == 1: return sleep(1) if on_snapshot.called_count != 1: raise AssertionError( "Failed to get exactly one document change: count: " + str(on_snapshot.called_count) )
def test_create_instance_defaults(self): from google.cloud.bigtable import enums ALT_INSTANCE_ID = "ndef" + unique_resource_id("-") instance = Config.CLIENT.instance(ALT_INSTANCE_ID, labels=LABELS) ALT_CLUSTER_ID = ALT_INSTANCE_ID + "-cluster" cluster = instance.cluster( ALT_CLUSTER_ID, location_id=LOCATION_ID, serve_nodes=SERVE_NODES ) operation = instance.create(clusters=[cluster]) # We want to make sure the operation completes. operation.result(timeout=10) # Make sure this instance gets deleted after the test case. self.instances_to_delete.append(instance) # Create a new instance instance and make sure it is the same. instance_alt = Config.CLIENT.instance(ALT_INSTANCE_ID) instance_alt.reload() self.assertEqual(instance, instance_alt) self.assertEqual(instance.display_name, instance_alt.display_name) # Make sure that by default a PRODUCTION type instance is created self.assertIsNone(instance.type_) self.assertEqual(instance_alt.type_, enums.Instance.Type.PRODUCTION)
def test_create_sink_pubsub_topic(self): from google.cloud import pubsub_v1 SINK_NAME = "test-create-sink-topic%s" % (_RESOURCE_ID,) TOPIC_NAME = "logging-systest{}".format(unique_resource_id("-")) # Create the destination topic, and set up the IAM policy to allow # Stackdriver Logging to write into it. publisher = pubsub_v1.PublisherClient() topic_path = publisher.topic_path(Config.CLIENT.project, TOPIC_NAME) self.to_delete.append(_DeleteWrapper(publisher, topic_path)) publisher.create_topic(topic_path) policy = publisher.get_iam_policy(topic_path) policy.bindings.add(role="roles/owner", members=["group:[email protected]"]) publisher.set_iam_policy(topic_path, policy) TOPIC_URI = "pubsub.googleapis.com/%s" % (topic_path,) retry = RetryErrors((Conflict, ServiceUnavailable), max_tries=10) sink = Config.CLIENT.sink(SINK_NAME, DEFAULT_FILTER, TOPIC_URI) self.assertFalse(sink.exists()) retry(sink.create)() self.to_delete.append(sink) self.assertTrue(sink.exists())
def test_collection_group_queries(client, cleanup): collection_group = "b" + unique_resource_id("-") doc_paths = [ "abc/123/" + collection_group + "/cg-doc1", "abc/123/" + collection_group + "/cg-doc2", collection_group + "/cg-doc3", collection_group + "/cg-doc4", "def/456/" + collection_group + "/cg-doc5", collection_group + "/virtual-doc/nested-coll/not-cg-doc", "x" + collection_group + "/not-cg-doc", collection_group + "x/not-cg-doc", "abc/123/" + collection_group + "x/not-cg-doc", "abc/123/x" + collection_group + "/not-cg-doc", "abc/" + collection_group, ] batch = client.batch() for doc_path in doc_paths: doc_ref = client.document(doc_path) batch.set(doc_ref, {"x": 1}) batch.commit() query = client.collection_group(collection_group) snapshots = list(query.stream()) found = [snapshot.id for snapshot in snapshots] expected = ["cg-doc1", "cg-doc2", "cg-doc3", "cg-doc4", "cg-doc5"] assert found == expected
def test_document_get(client, cleanup): now = datetime.datetime.utcnow().replace(tzinfo=UTC) document_id = 'for-get' + unique_resource_id('-') document = client.document('created', document_id) # Add to clean-up before API request (in case ``create()`` fails). cleanup(document) # First make sure it doesn't exist. assert not document.get().exists ref_doc = client.document('top', 'middle1', 'middle2', 'bottom') data = { 'turtle': 'power', 'cheese': 19.5, 'fire': 199099299, 'referee': ref_doc, 'gio': firestore.GeoPoint(45.5, 90.0), 'deep': [ u'some', b'\xde\xad\xbe\xef', ], 'map': { 'ice': True, 'water': None, 'vapor': { 'deeper': now, }, }, } write_result = document.create(data) snapshot = document.get() check_snapshot(snapshot, document, data, write_result) assert_timestamp_less(snapshot.create_time, snapshot.read_time)
def setUpModule(): Config.CLIENT = storage.Client() bucket_name = 'new' + unique_resource_id() # In the **very** rare case the bucket name is reserved, this # fails with a ConnectionError. Config.TEST_BUCKET = Config.CLIENT.bucket(bucket_name) retry_429(Config.TEST_BUCKET.create)()
def test_copy_existing_file_with_user_project(self): new_bucket_name = 'copy-w-requester-pays' + unique_resource_id('-') created = Config.CLIENT.create_bucket( new_bucket_name, requester_pays=True) self.case_buckets_to_delete.append(new_bucket_name) self.assertEqual(created.name, new_bucket_name) self.assertTrue(created.requester_pays) to_delete = [] blob = storage.Blob('simple', bucket=created) blob.upload_from_string(b'DEADBEEF') to_delete.append(blob) try: with_user_project = Config.CLIENT.bucket( new_bucket_name, user_project=USER_PROJECT) new_blob = retry_bad_copy(with_user_project.copy_blob)( blob, with_user_project, 'simple-copy') to_delete.append(new_blob) base_contents = blob.download_as_string() copied_contents = new_blob.download_as_string() self.assertEqual(base_contents, copied_contents) finally: for blob in to_delete: retry_429(blob.delete)()
def test_create_bucket(self): new_bucket_name = 'a-new-bucket' + unique_resource_id('-') self.assertRaises(exceptions.NotFound, Config.CLIENT.get_bucket, new_bucket_name) created = retry_429(Config.CLIENT.create_bucket)(new_bucket_name) self.case_buckets_to_delete.append(new_bucket_name) self.assertEqual(created.name, new_bucket_name)
def test_update_type(self): from google.cloud.bigtable.enums import Instance _DEVELOPMENT = Instance.Type.DEVELOPMENT _PRODUCTION = Instance.Type.PRODUCTION ALT_INSTANCE_ID = "ndif" + unique_resource_id("-") instance = Config.CLIENT.instance( ALT_INSTANCE_ID, instance_type=_DEVELOPMENT, labels=LABELS ) operation = instance.create(location_id=LOCATION_ID, serve_nodes=None) # Make sure this instance gets deleted after the test case. self.instances_to_delete.append(instance) # We want to make sure the operation completes. operation.result(timeout=10) # Unset the display_name instance.display_name = None instance.type_ = _PRODUCTION operation = instance.update() # We want to make sure the operation completes. operation.result(timeout=10) # Create a new instance instance and reload it. instance_alt = Config.CLIENT.instance(ALT_INSTANCE_ID) self.assertIsNone(instance_alt.type_) instance_alt.reload() self.assertEqual(instance_alt.type_, _PRODUCTION)
def test_bigtable_create_additional_cluster(): # [START bigtable_create_cluster] from google.cloud.bigtable import Client from google.cloud.bigtable import enums # Assuming that there is an existing instance with `INSTANCE_ID` # on the server already. # to create an instance see # 'https://cloud.google.com/bigtable/docs/creating-instance' client = Client(admin=True) instance = client.instance(INSTANCE_ID) cluster_id = "clus-my-" + unique_resource_id("-") location_id = "us-central1-a" serve_nodes = 3 storage_type = enums.StorageType.SSD cluster = instance.cluster( cluster_id, location_id=location_id, serve_nodes=serve_nodes, default_storage_type=storage_type, ) operation = cluster.create() # We want to make sure the operation completes. operation.result(timeout=100) # [END bigtable_create_cluster] assert cluster.exists() cluster.delete()
def test_document_integer_field(client, cleanup): document_id = 'for-set' + unique_resource_id('-') document = client.document('i-did-it', document_id) # Add to clean-up before API request (in case ``set()`` fails). cleanup(document) data1 = { '1a': { '2b': '3c', 'ab': '5e'}, '6f': { '7g': '8h', 'cd': '0j'} } document.create(data1) data2 = {'1a.ab': '4d', '6f.7g': '9h'} option2 = client.write_option(exists=True) document.update(data2, option=option2) snapshot = document.get() expected = { '1a': { '2b': '3c', 'ab': '4d'}, '6f': { '7g': '9h', 'cd': '0j'} } assert snapshot.to_dict() == expected
def test_rewrite_rotate_with_user_project(self): BLOB_NAME = 'rotating-keys' file_data = self.FILES['simple'] new_bucket_name = 'rewrite-rotate-up' + unique_resource_id('-') created = Config.CLIENT.create_bucket( new_bucket_name, requester_pays=True) try: with_user_project = Config.CLIENT.bucket( new_bucket_name, user_project=USER_PROJECT) SOURCE_KEY = os.urandom(32) source = with_user_project.blob( BLOB_NAME, encryption_key=SOURCE_KEY) source.upload_from_filename(file_data['path']) source_data = source.download_as_string() DEST_KEY = os.urandom(32) dest = with_user_project.blob(BLOB_NAME, encryption_key=DEST_KEY) token, rewritten, total = dest.rewrite(source) self.assertEqual(token, None) self.assertEqual(rewritten, len(source_data)) self.assertEqual(total, len(source_data)) self.assertEqual(dest.download_as_string(), source_data) finally: retry_429(created.delete)(force=True)
def test_document_set_merge(client, cleanup): document_id = 'for-set' + unique_resource_id('-') document = client.document('i-did-it', document_id) # Add to clean-up before API request (in case ``set()`` fails). cleanup(document) # 0. Make sure the document doesn't exist yet snapshot = document.get() assert not snapshot.exists # 1. Use ``create()`` to create the document. data1 = {'name': 'Sam', 'address': {'city': 'SF', 'state': 'CA'}} write_result1 = document.create(data1) snapshot1 = document.get() assert snapshot1.to_dict() == data1 # Make sure the update is what created the document. assert snapshot1.create_time == snapshot1.update_time assert snapshot1.update_time == write_result1.update_time # 2. Call ``set()`` to merge data2 = {'address': {'city': 'LA'}} write_result2 = document.set(data2, merge=True) snapshot2 = document.get() assert snapshot2.to_dict() == {'name': 'Sam', 'address': {'city': 'LA', 'state': 'CA'}} # Make sure the create time hasn't changed. assert snapshot2.create_time == snapshot1.create_time assert snapshot2.update_time == write_result2.update_time
def test_create_instance(self): from google.cloud.bigtable import enums _DEVELOPMENT = enums.Instance.Type.DEVELOPMENT _STATE = enums.Instance.State.READY ALT_INSTANCE_ID = "new" + unique_resource_id("-") instance = Config.CLIENT.instance( ALT_INSTANCE_ID, instance_type=_DEVELOPMENT, labels=LABELS ) ALT_CLUSTER_ID = ALT_INSTANCE_ID + "-cluster" cluster = instance.cluster(ALT_CLUSTER_ID, location_id=LOCATION_ID) operation = instance.create(clusters=[cluster]) # We want to make sure the operation completes. operation.result(timeout=10) # Make sure this instance gets deleted after the test case. self.instances_to_delete.append(instance) # Create a new instance instance and make sure it is the same. instance_alt = Config.CLIENT.instance(ALT_INSTANCE_ID) instance_alt.reload() self.assertEqual(instance, instance_alt) self.assertEqual(instance.display_name, instance_alt.display_name) self.assertEqual(instance.type_, instance_alt.type_) self.assertEqual(instance_alt.labels, LABELS) self.assertEqual(_STATE, instance_alt.state)
def test_watch_document(client, cleanup): db = client doc_ref = db.collection(u"users").document(u"alovelace" + unique_resource_id()) # Initial setting doc_ref.set({u"first": u"Jane", u"last": u"Doe", u"born": 1900}) sleep(1) # Setup listener def on_snapshot(docs, changes, read_time): on_snapshot.called_count += 1 on_snapshot.called_count = 0 doc_ref.on_snapshot(on_snapshot) # Alter document doc_ref.set({u"first": u"Ada", u"last": u"Lovelace", u"born": 1815}) sleep(1) for _ in range(10): if on_snapshot.called_count == 1: return sleep(1) if on_snapshot.called_count != 1: raise AssertionError( "Failed to get exactly one document change: count: " + str(on_snapshot.called_count) )
def test_watch_collection(client, cleanup): db = client doc_ref = db.collection(u"users").document(u"alovelace" + unique_resource_id()) collection_ref = db.collection(u"users") # Initial setting doc_ref.set({u"first": u"Jane", u"last": u"Doe", u"born": 1900}) # Setup listener def on_snapshot(docs, changes, read_time): on_snapshot.called_count += 1 for doc in [doc for doc in docs if doc.id == doc_ref.id]: on_snapshot.born = doc.get("born") on_snapshot.called_count = 0 on_snapshot.born = 0 collection_ref.on_snapshot(on_snapshot) # delay here so initial on_snapshot occurs and isn't combined with set sleep(1) doc_ref.set({u"first": u"Ada", u"last": u"Lovelace", u"born": 1815}) for _ in range(10): if on_snapshot.born == 1815: break sleep(1) if on_snapshot.born != 1815: raise AssertionError( "Expected the last document update to update born: " + str(on_snapshot.born) )
def test_document_set_merge(client, cleanup): document_id = "for-set" + unique_resource_id("-") document = client.document("i-did-it", document_id) # Add to clean-up before API request (in case ``set()`` fails). cleanup(document) # 0. Make sure the document doesn't exist yet snapshot = document.get() assert not snapshot.exists # 1. Use ``create()`` to create the document. data1 = {"name": "Sam", "address": {"city": "SF", "state": "CA"}} write_result1 = document.create(data1) snapshot1 = document.get() assert snapshot1.to_dict() == data1 # Make sure the update is what created the document. assert snapshot1.create_time == snapshot1.update_time assert snapshot1.update_time == write_result1.update_time # 2. Call ``set()`` to merge data2 = {"address": {"city": "LA"}} write_result2 = document.set(data2, merge=True) snapshot2 = document.get() assert snapshot2.to_dict() == { "name": "Sam", "address": {"city": "LA", "state": "CA"}, } # Make sure the create time hasn't changed. assert snapshot2.create_time == snapshot1.create_time assert snapshot2.update_time == write_result2.update_time
def test_query_unary(client, cleanup): collection_name = "unary" + unique_resource_id("-") collection = client.collection(collection_name) field_name = "foo" _, document0 = collection.add({field_name: None}) # Add to clean-up. cleanup(document0) nan_val = float("nan") _, document1 = collection.add({field_name: nan_val}) # Add to clean-up. cleanup(document1) # 0. Query for null. query0 = collection.where(field_name, "==", None) values0 = list(query0.stream()) assert len(values0) == 1 snapshot0 = values0[0] assert snapshot0.reference._path == document0._path assert snapshot0.to_dict() == {field_name: None} # 1. Query for a NAN. query1 = collection.where(field_name, "==", nan_val) values1 = list(query1.stream()) assert len(values1) == 1 snapshot1 = values1[0] assert snapshot1.reference._path == document1._path data1 = snapshot1.to_dict() assert len(data1) == 1 assert math.isnan(data1[field_name])
def test_document_delete(client, cleanup): document_id = "deleted" + unique_resource_id("-") document = client.document("here-to-be", document_id) # Add to clean-up before API request (in case ``create()`` fails). cleanup(document) document.create({"not": "much"}) # 1. Call ``delete()`` with invalid (in the past) "last timestamp" option. snapshot1 = document.get() timestamp_pb = timestamp_pb2.Timestamp( seconds=snapshot1.update_time.nanos - 3600, nanos=snapshot1.update_time.nanos ) option1 = client.write_option(last_update_time=timestamp_pb) with pytest.raises(FailedPrecondition): document.delete(option=option1) # 2. Call ``delete()`` with invalid (in future) "last timestamp" option. timestamp_pb = timestamp_pb2.Timestamp( seconds=snapshot1.update_time.nanos + 3600, nanos=snapshot1.update_time.nanos ) option2 = client.write_option(last_update_time=timestamp_pb) with pytest.raises(FailedPrecondition): document.delete(option=option2) # 3. Actually ``delete()`` the document. delete_time3 = document.delete() # 4. ``delete()`` again, even though we know the document is gone. delete_time4 = document.delete() assert_timestamp_less(delete_time3, delete_time4)
def test_document_set(client, cleanup): document_id = "for-set" + unique_resource_id("-") document = client.document("i-did-it", document_id) # Add to clean-up before API request (in case ``set()`` fails). cleanup(document) # 0. Make sure the document doesn't exist yet snapshot = document.get() assert snapshot.to_dict() is None # 1. Use ``create()`` to create the document. data1 = {"foo": 88} write_result1 = document.create(data1) snapshot1 = document.get() assert snapshot1.to_dict() == data1 # Make sure the update is what created the document. assert snapshot1.create_time == snapshot1.update_time assert snapshot1.update_time == write_result1.update_time # 2. Call ``set()`` again to overwrite. data2 = {"bar": None} write_result2 = document.set(data2) snapshot2 = document.get() assert snapshot2.to_dict() == data2 # Make sure the create time hasn't changed. assert snapshot2.create_time == snapshot1.create_time assert snapshot2.update_time == write_result2.update_time
def test_bigtable_delete_cluster(): from google.cloud.bigtable import Client client = Client(admin=True) instance = client.instance(INSTANCE_ID) cluster_id = "clus-my-" + unique_resource_id("-") cluster = instance.cluster( cluster_id, location_id=ALT_LOCATION_ID, serve_nodes=SERVER_NODES, default_storage_type=STORAGE_TYPE, ) operation = cluster.create() # We want to make sure the operation completes. operation.result(timeout=1000) # [START bigtable_delete_cluster] from google.cloud.bigtable import Client client = Client(admin=True) instance = client.instance(INSTANCE_ID) cluster_to_delete = instance.cluster(cluster_id) cluster_to_delete.delete() # [END bigtable_delete_cluster] assert not cluster_to_delete.exists()
def test_update_document(client, cleanup): document_id = "for-update" + unique_resource_id("-") document = client.document("made", document_id) # Add to clean-up before API request (in case ``create()`` fails). cleanup(document) # 0. Try to update before the document exists. with pytest.raises(NotFound) as exc_info: document.update({"not": "there"}) assert exc_info.value.message.startswith(MISSING_DOCUMENT) assert document_id in exc_info.value.message # 1. Try to update before the document exists (now with an option). with pytest.raises(NotFound) as exc_info: document.update({"still": "not-there"}) assert exc_info.value.message.startswith(MISSING_DOCUMENT) assert document_id in exc_info.value.message # 2. Update and create the document (with an option). data = {"foo": {"bar": "baz"}, "scoop": {"barn": 981}, "other": True} write_result2 = document.create(data) # 3. Send an update without a field path (no option). field_updates3 = {"foo": {"quux": 800}} write_result3 = document.update(field_updates3) assert_timestamp_less(write_result2.update_time, write_result3.update_time) snapshot3 = document.get() expected3 = { "foo": field_updates3["foo"], "scoop": data["scoop"], "other": data["other"], } assert snapshot3.to_dict() == expected3 # 4. Send an update **with** a field path and a delete and a valid # "last timestamp" option. field_updates4 = {"scoop.silo": None, "other": firestore.DELETE_FIELD} option4 = client.write_option(last_update_time=snapshot3.update_time) write_result4 = document.update(field_updates4, option=option4) assert_timestamp_less(write_result3.update_time, write_result4.update_time) snapshot4 = document.get() expected4 = { "foo": field_updates3["foo"], "scoop": {"barn": data["scoop"]["barn"], "silo": field_updates4["scoop.silo"]}, } assert snapshot4.to_dict() == expected4 # 5. Call ``update()`` with invalid (in the past) "last timestamp" option. assert_timestamp_less(option4._last_update_time, snapshot4.update_time) with pytest.raises(FailedPrecondition) as exc_info: document.update({"bad": "time-past"}, option=option4) # 6. Call ``update()`` with invalid (in future) "last timestamp" option. timestamp_pb = timestamp_pb2.Timestamp( seconds=snapshot4.update_time.nanos + 3600, nanos=snapshot4.update_time.nanos ) option6 = client.write_option(last_update_time=timestamp_pb) with pytest.raises(FailedPrecondition) as exc_info: document.update({"bad": "time-future"}, option=option6)
def test_list_buckets(self): buckets_to_create = [ 'new' + unique_resource_id(), 'newer' + unique_resource_id(), 'newest' + unique_resource_id(), ] created_buckets = [] for bucket_name in buckets_to_create: bucket = Config.CLIENT.bucket(bucket_name) retry_429(bucket.create)() self.case_buckets_to_delete.append(bucket_name) # Retrieve the buckets. all_buckets = Config.CLIENT.list_buckets() created_buckets = [bucket for bucket in all_buckets if bucket.name in buckets_to_create] self.assertEqual(len(created_buckets), len(buckets_to_create))
def setUpModule(): VisionSystemTestBase.client = vision.ImageAnnotatorClient() storage_client = storage.Client() bucket_name = "new" + unique_resource_id() VisionSystemTestBase.test_bucket = storage_client.bucket(bucket_name) # 429 Too Many Requests in case API requests rate-limited. retry_429 = RetryErrors(exceptions.TooManyRequests) retry_429(VisionSystemTestBase.test_bucket.create)()
def test_cannot_use_foreign_key(client, cleanup): document_id = "cannot" + unique_resource_id("-") document = client.document("foreign-key", document_id) # Add to clean-up before API request (in case ``create()`` fails). cleanup(document) other_client = firestore.Client( project="other-prahj", credentials=client._credentials, database="dee-bee" ) assert other_client._database_string != client._database_string fake_doc = other_client.document("foo", "bar") with pytest.raises(InvalidArgument): document.create({"ref": fake_doc})
def test_create_product_set(self): product_set = vision.types.ProductSet(display_name="display name") product_set_id = "set" + unique_resource_id() product_set_path = self.ps_client.product_set_path( project=PROJECT_ID, location=self.location, product_set=product_set_id ) self.product_sets_to_delete.append(product_set_path) response = self.ps_client.create_product_set( parent=self.location_path, product_set=product_set, product_set_id=product_set_id, ) self.assertEqual(response.name, product_set_path)
def test_write_point(self): METRIC_TYPE = ('custom.googleapis.com/tmp/system_test_example' + unique_resource_id()) METRIC_KIND = monitoring.MetricKind.GAUGE VALUE_TYPE = monitoring.ValueType.DOUBLE DESCRIPTION = 'System test example -- DELETE ME!' VALUE = 3.14 client = monitoring.Client() descriptor = client.metric_descriptor( METRIC_TYPE, metric_kind=METRIC_KIND, value_type=VALUE_TYPE, description=DESCRIPTION, ) descriptor.create() metric = client.metric(METRIC_TYPE, {}) resource = client.resource('global', {}) retry_500(client.write_point)(metric, resource, VALUE) def _query_timeseries_with_retries(): MAX_RETRIES = 6 def _has_timeseries(result): return len(list(result)) > 0 retry_result = RetryResult( _has_timeseries, max_tries=MAX_RETRIES, backoff=3)(client.query) return RetryErrors( BadRequest, max_tries=MAX_RETRIES, backoff=3)(retry_result) query = _query_timeseries_with_retries()(METRIC_TYPE, minutes=5) timeseries_list = list(query) self.assertEqual(len(timeseries_list), 1) timeseries = timeseries_list[0] self.assertEqual(timeseries.metric, metric) # project_id label only exists on output. del timeseries.resource.labels['project_id'] self.assertEqual(timeseries.resource, resource) descriptor.delete() with self.assertRaises(NotFound): descriptor.delete()
def test_document_integer_field(client, cleanup): document_id = 'for-set' + unique_resource_id('-') document = client.document('i-did-it', document_id) # Add to clean-up before API request (in case ``set()`` fails). cleanup(document) data1 = {'1a': {'2b': '3c', 'ab': '5e'}, '6f': {'7g': '8h', 'cd': '0j'}} option1 = client.write_option(exists=False) document.set(data1, option=option1) data2 = {'1a.ab': '4d', '6f.7g': '9h'} option2 = client.write_option(create_if_missing=True) document.update(data2, option=option2) snapshot = document.get() expected = {'1a': {'2b': '3c', 'ab': '4d'}, '6f': {'7g': '9h', 'cd': '0j'}} assert snapshot.to_dict() == expected
def test_get_product(self): # Create a Product. product = vision.types.Product(display_name="product display name", product_category="apparel") product_id = "product" + unique_resource_id() product_path = self.ps_client.product_path(project=PROJECT_ID, location=self.location, product=product_id) response = self.ps_client.create_product(parent=self.location_path, product=product, product_id=product_id) self.products_to_delete.append(response.name) self.assertEqual(response.name, product_path) # Get the Product. get_response = self.ps_client.get_product(name=product_path) self.assertEqual(get_response.name, product_path)
def test_listing_project_topics(publisher, project, cleanup): topic_paths = [ publisher.topic_path(project, "topic-{}".format(i) + unique_resource_id(".")) for i in range(1, 4) ] for topic in topic_paths: cleanup.append((publisher.delete_topic, topic)) publisher.create_topic(topic) project_path = publisher.project_path(project) project_topics = publisher.list_topics(project_path) project_topics = set(t.name for t in project_topics) # there might be other topics in the project, thus do a "is subset" check assert set(topic_paths) <= project_topics
def test_bigtable_list_app_profiles(): app_profile = Config.INSTANCE.app_profile( app_profile_id="app-prof-" + unique_resource_id("-"), routing_policy_type=enums.RoutingPolicyType.ANY, ) app_profile = app_profile.create(ignore_warnings=True) # [START bigtable_list_app_profiles] from google.cloud.bigtable import Client client = Client(admin=True) instance = client.instance(INSTANCE_ID) app_profiles_list = instance.list_app_profiles() # [END bigtable_list_app_profiles] assert len(app_profiles_list) > 0
def test_create_instance(self): ALT_INSTANCE_ID = 'new' + unique_resource_id('-') instance = Config.CLIENT.instance(ALT_INSTANCE_ID, LOCATION_ID) operation = instance.create() # Make sure this instance gets deleted after the test case. self.instances_to_delete.append(instance) # We want to make sure the operation completes. operation.result(timeout=10) # Create a new instance instance and make sure it is the same. instance_alt = Config.CLIENT.instance(ALT_INSTANCE_ID, LOCATION_ID) instance_alt.reload() self.assertEqual(instance, instance_alt) self.assertEqual(instance.display_name, instance_alt.display_name)
def test_create_product_set(self): # Create a ProductSet. product_set = vision.types.ProductSet(display_name="display name") product_set_id = "set" + unique_resource_id() product_set_path = self.ps_client.product_set_path( project=PROJECT_ID, location=self.location, product_set=product_set_id) response = self.ps_client.create_product_set( parent=self.location_path, product_set=product_set, product_set_id=product_set_id, ) self.product_sets_to_delete.append(response.name) # Verify the ProductSet was successfully created. self.assertEqual(response.name, product_set_path)
def test_write_point(self): METRIC_TYPE = ('custom.googleapis.com/tmp/system_test_example' + unique_resource_id()) METRIC_KIND = monitoring.MetricKind.GAUGE VALUE_TYPE = monitoring.ValueType.DOUBLE DESCRIPTION = 'System test example -- DELETE ME!' VALUE = 3.14 client = monitoring.Client() descriptor = client.metric_descriptor( METRIC_TYPE, metric_kind=METRIC_KIND, value_type=VALUE_TYPE, description=DESCRIPTION, ) descriptor.create() metric = client.metric(METRIC_TYPE, {}) resource = client.resource('global', {}) retry_500(client.write_point)(metric, resource, VALUE) def _query_timeseries_with_retries(): MAX_RETRIES = 10 def _has_timeseries(result): return len(list(result)) > 0 retry_result = RetryResult(_has_timeseries, max_tries=MAX_RETRIES)(client.query) return RetryErrors(BadRequest, max_tries=MAX_RETRIES)(retry_result) query = _query_timeseries_with_retries()(METRIC_TYPE, minutes=5) timeseries_list = list(query) self.assertEqual(len(timeseries_list), 1) timeseries = timeseries_list[0] self.assertEqual(timeseries.metric, metric) # project_id label only exists on output. del timeseries.resource.labels['project_id'] self.assertEqual(timeseries.resource, resource) descriptor.delete() with self.assertRaises(NotFound): descriptor.delete()
def test_topic_iam_policy(self): from google.cloud.pubsub.iam import PUBSUB_TOPICS_GET_IAM_POLICY self._maybe_emulator_skip() topic_name = 'test-topic-iam-policy-topic' + unique_resource_id('-') topic = Config.CLIENT.topic(topic_name) topic.create() # Retry / backoff up to 7 seconds (1 + 2 + 4) retry = RetryResult(lambda result: result, max_tries=4) retry(topic.exists)() self.to_delete.append(topic) if topic.check_iam_permissions([PUBSUB_TOPICS_GET_IAM_POLICY]): policy = topic.get_iam_policy() policy.viewers.add(policy.user('*****@*****.**')) new_policy = topic.set_iam_policy(policy) self.assertEqual(new_policy.viewers, policy.viewers)
def test_collection_add(client, cleanup): collection1 = client.collection('collek') collection2 = client.collection('collek', 'shun', 'child') explicit_doc_id = 'hula' + unique_resource_id('-') # Auto-ID at top-level. data1 = {'foo': 'bar'} update_time1, document_ref1 = collection1.add(data1) cleanup(document_ref1) snapshot1 = document_ref1.get() assert snapshot1.to_dict() == data1 assert snapshot1.create_time == update_time1 assert snapshot1.update_time == update_time1 assert RANDOM_ID_REGEX.match(document_ref1.id) # Explicit ID at top-level. data2 = {'baz': 999} update_time2, document_ref2 = collection1.add(data2, document_id=explicit_doc_id) cleanup(document_ref2) snapshot2 = document_ref2.get() assert snapshot2.to_dict() == data2 assert snapshot2.create_time == update_time2 assert snapshot2.update_time == update_time2 assert document_ref2.id == explicit_doc_id # Auto-ID for nested collection. data3 = {'quux': b'\x00\x01\x02\x03'} update_time3, document_ref3 = collection2.add(data3) cleanup(document_ref3) snapshot3 = document_ref3.get() assert snapshot3.to_dict() == data3 assert snapshot3.create_time == update_time3 assert snapshot3.update_time == update_time3 assert RANDOM_ID_REGEX.match(document_ref3.id) # Explicit for nested collection. data4 = {'kazaam': None, 'bad': False} update_time4, document_ref4 = collection2.add(data4, document_id=explicit_doc_id) cleanup(document_ref4) snapshot4 = document_ref4.get() assert snapshot4.to_dict() == data4 assert snapshot4.create_time == update_time4 assert snapshot4.update_time == update_time4 assert document_ref4.id == explicit_doc_id
def test_create_and_delete_metric_descriptor(self): METRIC_TYPE = ('custom.googleapis.com/tmp/system_test_example' + unique_resource_id()) METRIC_KIND = monitoring.MetricKind.GAUGE VALUE_TYPE = monitoring.ValueType.DOUBLE DESCRIPTION = 'System test example -- DELETE ME!' client = monitoring.Client() descriptor = client.metric_descriptor( METRIC_TYPE, metric_kind=METRIC_KIND, value_type=VALUE_TYPE, description=DESCRIPTION, ) retry_500(descriptor.create)() retry_404_500(descriptor.delete)()
def test_snapshot_seek_subscriber_permissions_sufficient( self, project, publisher, topic_path, subscriber, subscription_path, cleanup ): snapshot_name = "snap" + unique_resource_id("-") snapshot_path = "projects/{}/snapshots/{}".format(project, snapshot_name) # Make sure the topic and subscription get deleted. cleanup.append((publisher.delete_topic, (), {"topic": topic_path})) cleanup.append( (subscriber.delete_subscription, (), {"subscription": subscription_path}) ) cleanup.append((subscriber.delete_snapshot, (), {"snapshot": snapshot_path})) # Create a topic and subscribe to it. publisher.create_topic(name=topic_path) subscriber.create_subscription( name=subscription_path, topic=topic_path, retain_acked_messages=True ) # A service account granting only the pubsub.subscriber role must be used. filename = os.path.join( os.environ["KOKORO_GFILE_DIR"], "pubsub-subscriber-service-account.json" ) subscriber_only_client = type(subscriber).from_service_account_file(filename) # Publish two messages and create a snapshot inbetween. _publish_messages(publisher, topic_path, batch_sizes=[1]) response = subscriber.pull(subscription=subscription_path, max_messages=10) assert len(response.received_messages) == 1 subscriber.create_snapshot(name=snapshot_path, subscription=subscription_path) _publish_messages(publisher, topic_path, batch_sizes=[1]) response = subscriber.pull(subscription=subscription_path, max_messages=10) assert len(response.received_messages) == 1 # A subscriber-only client should be allowed to seek to a snapshot. seek_request = gapic_types.SeekRequest( subscription=subscription_path, snapshot=snapshot_path ) subscriber_only_client.seek(seek_request) # We should receive one message again, since we sought back to a snapshot. response = subscriber.pull(subscription=subscription_path, max_messages=10) assert len(response.received_messages) == 1
def test_create_document(client, cleanup): now = datetime.datetime.utcnow().replace(tzinfo=UTC) document_id = 'shun' + unique_resource_id('-') document = client.document('collek', document_id) # Add to clean-up before API request (in case ``create()`` fails). cleanup(document) data = { 'now': firestore.SERVER_TIMESTAMP, 'eenta-ger': 11, 'bites': b'\xe2\x98\x83 \xe2\x9b\xb5', 'also': { 'nestednow': firestore.SERVER_TIMESTAMP, 'quarter': 0.25, }, } write_result = document.create(data) updated = _pb_timestamp_to_datetime(write_result.update_time) delta = updated - now # Allow a bit of clock skew, but make sure timestamps are close. assert -300.0 < delta.total_seconds() < 300.0 with pytest.raises(AlreadyExists): document.create(data) # Verify the server times. snapshot = document.get() stored_data = snapshot.to_dict() server_now = stored_data['now'] delta = updated - server_now # NOTE: We could check the ``transform_results`` from the write result # for the document transform, but this value gets dropped. Instead # we make sure the timestamps are close. assert 0.0 <= delta.total_seconds() < 5.0 expected_data = { 'now': server_now, 'eenta-ger': data['eenta-ger'], 'bites': data['bites'], 'also': { 'nestednow': server_now, 'quarter': data['also']['quarter'], }, } assert stored_data == expected_data
def test_create_document(client, cleanup): now = datetime.datetime.utcnow().replace(tzinfo=UTC) document_id = "shun" + unique_resource_id("-") document = client.document("collek", document_id) # Add to clean-up before API request (in case ``create()`` fails). cleanup(document) data = { "now": firestore.SERVER_TIMESTAMP, "eenta-ger": 11, "bites": b"\xe2\x98\x83 \xe2\x9b\xb5", "also": { "nestednow": firestore.SERVER_TIMESTAMP, "quarter": 0.25 }, } write_result = document.create(data) updated = _pb_timestamp_to_datetime(write_result.update_time) delta = updated - now # Allow a bit of clock skew, but make sure timestamps are close. assert -300.0 < delta.total_seconds() < 300.0 with pytest.raises(AlreadyExists): document.create(data) # Verify the server times. snapshot = document.get() stored_data = snapshot.to_dict() server_now = stored_data["now"] delta = updated - server_now # NOTE: We could check the ``transform_results`` from the write result # for the document transform, but this value gets dropped. Instead # we make sure the timestamps are close. assert 0.0 <= delta.total_seconds() < 5.0 expected_data = { "now": server_now, "eenta-ger": data["eenta-ger"], "bites": data["bites"], "also": { "nestednow": server_now, "quarter": data["also"]["quarter"] }, } assert stored_data == expected_data
def test_cannot_use_foreign_key(client, cleanup): document_id = 'cannot' + unique_resource_id('-') document = client.document('foreign-key', document_id) # Add to clean-up before API request (in case ``create()`` fails). cleanup(document) other_client = firestore.Client(project='other-prahj', credentials=client._credentials, database='dee-bee') assert other_client._database_string != client._database_string fake_doc = other_client.document('foo', 'bar') # NOTE: google-gax **does not** raise a GaxError for INVALID_ARGUMENT. with pytest.raises(ValueError) as exc_info: document.create({'ref': fake_doc}) assert len(exc_info.value.args) == 1 err_msg = exc_info.value.args[0] assert err_msg == 'RPC failed'
def test_notification_w_user_project(self): new_bucket_name = 'notification-minimal' + unique_resource_id('-') bucket = retry_429(Config.CLIENT.create_bucket)(new_bucket_name, requester_pays=True) self.case_buckets_to_delete.append(new_bucket_name) with_user_project = Config.CLIENT.bucket(new_bucket_name, user_project=USER_PROJECT) self.assertEqual(list(with_user_project.list_notifications()), []) notification = with_user_project.notification(self.TOPIC_NAME) retry_429(notification.create)() try: self.assertTrue(notification.exists()) self.assertIsNotNone(notification.notification_id) notifications = list(with_user_project.list_notifications()) self.assertEqual(len(notifications), 1) self.assertEqual(notifications[0].topic_name, self.TOPIC_NAME) finally: notification.delete()
def test_create_document_w_subcollection(client, cleanup): document_id = "shun" + unique_resource_id("-") document = client.document("collek", document_id) # Add to clean-up before API request (in case ``create()`` fails). cleanup(document) data = {"now": firestore.SERVER_TIMESTAMP} document.create(data) child_ids = ["child1", "child2"] for child_id in child_ids: subcollection = document.collection(child_id) _, subdoc = subcollection.add({"foo": "bar"}) cleanup(subdoc) children = document.collections() assert sorted(child.id for child in children) == sorted(child_ids)
def test_collection_add(client, cleanup): collection1 = client.collection("collek") collection2 = client.collection("collek", "shun", "child") explicit_doc_id = "hula" + unique_resource_id("-") # Auto-ID at top-level. data1 = {"foo": "bar"} update_time1, document_ref1 = collection1.add(data1) cleanup(document_ref1) snapshot1 = document_ref1.get() assert snapshot1.to_dict() == data1 assert snapshot1.update_time == update_time1 assert RANDOM_ID_REGEX.match(document_ref1.id) # Explicit ID at top-level. data2 = {"baz": 999} update_time2, document_ref2 = collection1.add(data2, document_id=explicit_doc_id) cleanup(document_ref2) snapshot2 = document_ref2.get() assert snapshot2.to_dict() == data2 assert snapshot2.create_time == update_time2 assert snapshot2.update_time == update_time2 assert document_ref2.id == explicit_doc_id # Auto-ID for nested collection. data3 = {"quux": b"\x00\x01\x02\x03"} update_time3, document_ref3 = collection2.add(data3) cleanup(document_ref3) snapshot3 = document_ref3.get() assert snapshot3.to_dict() == data3 assert snapshot3.update_time == update_time3 assert RANDOM_ID_REGEX.match(document_ref3.id) # Explicit for nested collection. data4 = {"kazaam": None, "bad": False} update_time4, document_ref4 = collection2.add(data4, document_id=explicit_doc_id) cleanup(document_ref4) snapshot4 = document_ref4.get() assert snapshot4.to_dict() == data4 assert snapshot4.create_time == update_time4 assert snapshot4.update_time == update_time4 assert document_ref4.id == explicit_doc_id
def test_query_with_order_dot_key(client, cleanup): db = client collection_id = "collek" + unique_resource_id("-") collection = db.collection(collection_id) for index in range(100, -1, -1): doc = collection.document("test_{:09d}".format(index)) data = {"count": 10 * index, "wordcount": {"page1": index * 10 + 100}} doc.set(data) cleanup(doc.delete) query = collection.order_by("wordcount.page1").limit(3) data = [doc.to_dict()["wordcount"]["page1"] for doc in query.stream()] assert [100, 110, 120] == data for snapshot in collection.order_by("wordcount.page1").limit(3).stream(): last_value = snapshot.get("wordcount.page1") cursor_with_nested_keys = {"wordcount": {"page1": last_value}} found = list( collection.order_by("wordcount.page1").start_after( cursor_with_nested_keys).limit(3).stream()) found_data = [ { u"count": 30, u"wordcount": { u"page1": 130 } }, { u"count": 40, u"wordcount": { u"page1": 140 } }, { u"count": 50, u"wordcount": { u"page1": 150 } }, ] assert found_data == [snap.to_dict() for snap in found] cursor_with_dotted_paths = {"wordcount.page1": last_value} cursor_with_key_data = list( collection.order_by("wordcount.page1").start_after( cursor_with_dotted_paths).limit(3).stream()) assert found_data == [snap.to_dict() for snap in cursor_with_key_data]
def test_bucket_update_labels(self): bucket_name = 'update-labels' + unique_resource_id('-') bucket = retry_429(Config.CLIENT.create_bucket)(bucket_name) self.case_buckets_to_delete.append(bucket_name) self.assertTrue(bucket.exists()) updated_labels = {'test-label': 'label-value'} bucket.labels = updated_labels bucket.update() self.assertEqual(bucket.labels, updated_labels) new_labels = {'another-label': 'another-value'} bucket.labels = new_labels bucket.patch() self.assertEqual(bucket.labels, new_labels) bucket.labels = {} bucket.update() self.assertEqual(bucket.labels, {})
def test_batch(client, cleanup): collection_name = "batch" + unique_resource_id("-") document1 = client.document(collection_name, "abc") document2 = client.document(collection_name, "mno") document3 = client.document(collection_name, "xyz") # Add to clean-up before API request (in case ``create()`` fails). cleanup(document1) cleanup(document2) cleanup(document3) data2 = {"some": {"deep": "stuff", "and": "here"}, "water": 100.0} document2.create(data2) document3.create({"other": 19}) batch = client.batch() data1 = {"all": True} batch.create(document1, data1) new_value = "there" batch.update(document2, {"some.and": new_value}) batch.delete(document3) write_results = batch.commit() assert len(write_results) == 3 write_result1 = write_results[0] write_result2 = write_results[1] write_result3 = write_results[2] assert not write_result3.HasField("update_time") snapshot1 = document1.get() assert snapshot1.to_dict() == data1 assert snapshot1.create_time == write_result1.update_time assert snapshot1.update_time == write_result1.update_time snapshot2 = document2.get() assert snapshot2.to_dict() != data2 data2["some"]["and"] = new_value assert snapshot2.to_dict() == data2 assert_timestamp_less(snapshot2.create_time, write_result2.update_time) assert snapshot2.update_time == write_result2.update_time assert not document3.get().exists
def test_log_handler_async(self): LOG_MESSAGE = 'It was the worst of times' handler_name = 'gcp-async' + unique_resource_id('-') handler = CloudLoggingHandler(Config.CLIENT, name=handler_name) # only create the logger to delete, hidden otherwise logger = Config.CLIENT.logger(handler_name) self.to_delete.append(logger) cloud_logger = logging.getLogger(handler.name) cloud_logger.addHandler(handler) cloud_logger.warn(LOG_MESSAGE) handler.flush() entries = _list_entries(logger) expected_payload = { 'message': LOG_MESSAGE, 'python_logger': handler.name } self.assertEqual(len(entries), 1) self.assertEqual(entries[0].payload, expected_payload)
def test_bigtable_create_app_profile(): # [START bigtable_create_app_profile] from google.cloud.bigtable import Client client = Client(admin=True) instance = client.instance(INSTANCE_ID) app_profile_id = "app-prof-" + unique_resource_id('-') description = 'routing policy-multy' routing_policy_type = enums.RoutingPolicyType.ANY app_profile = instance.app_profile(app_profile_id=app_profile_id, routing_policy_type=routing_policy_type, description=description, cluster_id=CLUSTER_ID) app_profile = app_profile.create(ignore_warnings=True) # [END bigtable_create_app_profile] assert app_profile.exists() app_profile.delete(ignore_warnings=True)
def test_bucket_get_blob_with_user_project(self): new_bucket_name = 'w-requester-pays' + unique_resource_id('-') data = b'DEADBEEF' created = Config.CLIENT.create_bucket(new_bucket_name, requester_pays=True) self.case_buckets_to_delete.append(new_bucket_name) self.assertEqual(created.name, new_bucket_name) self.assertTrue(created.requester_pays) with_user_project = Config.CLIENT.bucket(new_bucket_name, user_project=USER_PROJECT) self.assertIsNone(with_user_project.get_blob('nonesuch')) to_add = created.blob('blob-name') to_add.upload_from_string(data) try: found = with_user_project.get_blob('blob-name') self.assertEqual(found.download_as_string(), data) finally: to_add.delete()
def test_create_document_w_subcollection(client, cleanup): document_id = 'shun' + unique_resource_id('-') document = client.document('collek', document_id) # Add to clean-up before API request (in case ``create()`` fails). cleanup(document) data = { 'now': firestore.SERVER_TIMESTAMP, } document.create(data) child_ids = ['child1', 'child2'] for child_id in child_ids: subcollection = document.collection(child_id) _, subdoc = subcollection.add({'foo': 'bar'}) cleanup(subdoc) children = document.collections() assert sorted(child.id for child in children) == sorted(child_ids)
def test_document_set_w_int_field(client, cleanup): document_id = 'set-int-key' + unique_resource_id('-') document = client.document('i-did-it', document_id) # Add to clean-up before API request (in case ``set()`` fails). cleanup(document) # 0. Make sure the document doesn't exist yet snapshot = document.get() assert not snapshot.exists # 1. Use ``create()`` to create the document. before = {'testing': '1'} document.create(before) # 2. Replace using ``set()``. data = {'14': {'status': 'active'}} document.set(data) # 3. Verify replaced data. snapshot1 = document.get() assert snapshot1.to_dict() == data
def test_bigtable_delete_cluster(): # [START bigtable_delete_cluster] from google.cloud.bigtable import Client client = Client(admin=True) instance = client.instance(INSTANCE_ID) cluster_id = "clus-my-" + unique_resource_id('-') # [END bigtable_delete_cluster] cluster = instance.cluster(cluster_id, location_id=ALT_LOCATION_ID, serve_nodes=SERVER_NODES, default_storage_type=STORAGE_TYPE) operation = cluster.create() # We want to make sure the operation completes. operation.result(timeout=1000) # [START bigtable_delete_cluster] cluster_to_delete = instance.cluster(cluster_id) cluster_to_delete.delete() # [END bigtable_delete_cluster] assert not cluster_to_delete.exists()
def test_list_products(self): # Create a Product. product = vision.types.Product(display_name="product display name", product_category="apparel") product_id = "product" + unique_resource_id() product_path = self.ps_client.product_path(project=PROJECT_ID, location=self.location, product=product_id) response = self.ps_client.create_product(parent=self.location_path, product=product, product_id=product_id) self.products_to_delete.append(response.name) self.assertEqual(response.name, product_path) # Verify Products can be listed. products_iterator = self.ps_client.list_products( parent=self.location_path) products_exist = False for product in products_iterator: products_exist = True break self.assertTrue(products_exist)
def test_update_product(self): # Create a Product. product = vision.types.Product(display_name="product display name", product_category="apparel") product_id = "product" + unique_resource_id() product_path = self.ps_client.product_path(project=PROJECT_ID, location=self.location, product=product_id) response = self.ps_client.create_product(parent=self.location_path, product=product, product_id=product_id) self.products_to_delete.append(response.name) self.assertEqual(response.name, product_path) # Update the Product. new_display_name = "updated product name" updated_product_request = vision.types.Product( name=product_path, display_name=new_display_name) update_mask = vision.types.FieldMask(paths=["display_name"]) updated_product = self.ps_client.update_product( product=updated_product_request, update_mask=update_mask) self.assertEqual(updated_product.display_name, new_display_name)
def test_document_set_w_int_field(client, cleanup): document_id = "set-int-key" + unique_resource_id("-") document = client.document("i-did-it", document_id) # Add to clean-up before API request (in case ``set()`` fails). cleanup(document) # 0. Make sure the document doesn't exist yet snapshot = document.get() assert not snapshot.exists # 1. Use ``create()`` to create the document. before = {"testing": "1"} document.create(before) # 2. Replace using ``set()``. data = {"14": {"status": "active"}} document.set(data) # 3. Verify replaced data. snapshot1 = document.get() assert snapshot1.to_dict() == data
def test_collection_group_queries_filters(client): collection_group = "b" + unique_resource_id("-") doc_paths = [ "a/a/" + collection_group + "/cg-doc1", "a/b/a/b/" + collection_group + "/cg-doc2", "a/b/" + collection_group + "/cg-doc3", "a/b/c/d/" + collection_group + "/cg-doc4", "a/c/" + collection_group + "/cg-doc5", collection_group + "/cg-doc6", "a/b/nope/nope", ] batch = client.batch() for index, doc_path in enumerate(doc_paths): doc_ref = client.document(doc_path) batch.set(doc_ref, {"x": index}) batch.commit() query = (client.collection_group(collection_group).where( firestore.field_path.FieldPath.document_id(), ">=", client.document("a/b")).where( firestore.field_path.FieldPath.document_id(), "<=", client.document("a/b0"))) snapshots = list(query.stream()) found = set(snapshot.id for snapshot in snapshots) assert found == set(["cg-doc2", "cg-doc3", "cg-doc4"]) query = (client.collection_group(collection_group).where( firestore.field_path.FieldPath.document_id(), ">", client.document("a/b")).where( firestore.field_path.FieldPath.document_id(), "<", client.document("a/b/{}/cg-doc3".format(collection_group)), )) snapshots = list(query.stream()) found = set(snapshot.id for snapshot in snapshots) assert found == set(["cg-doc2"])