feat: Add missing functions and improve retry in beforeAll

Author: exaby73

integration_tests/functions/v2/database_tests.py

@@ -0,0 +1,76 @@
+import json
+
+from firebase_admin import firestore
+from firebase_functions import logger
+from firebase_functions.db_fn import (on_value_created, Event, on_value_deleted,
+                                      on_value_updated, on_value_written,
+                                      Change)
+
+from region import REGION
+
+
+@on_value_created(reference="databaseCreatedTests/{testId}/start",
+                  region=REGION)
+def databaseCreatedTests(event: Event[object]):
+    test_id = event.params['testId']
+
+    firestore.client().collection("databaseCreatedTests").document(test_id).set(
+        {
+            "testId": test_id,
+            "type": event.type,
+            "id": event.id,
+            "time": event.time,
+            "url": event.reference,
+        })
+
+
+@on_value_deleted(reference="databaseDeletedTests/{testId}/start",
+                  region=REGION)
+def databaseDeletedTests(event: Event[object]):
+    test_id = event.params['testId']
+
+    firestore.client().collection("databaseDeletedTests").document(test_id).set(
+        {
+            "testId": test_id,
+            "type": event.type,
+            "id": event.id,
+            "time": event.time,
+            "url": event.reference,
+        })
+
+
+@on_value_updated(reference="databaseUpdatedTests/{testId}/start",
+                  region=REGION)
+def databaseUpdatedTests(event: Event[Change[object]]):
+    test_id = event.params['testId']
+    data = event.data.after
+
+    firestore.client().collection("databaseUpdatedTests").document(test_id).set(
+        {
+            "testId": test_id,
+            "type": event.type,
+            "id": event.id,
+            "time": event.time,
+            "url": event.reference,
+            "data": json.dumps(data if data is not None else {})
+        })
+
+
+@on_value_written(reference="databaseWrittenTests/{testId}/start",
+                  region=REGION)
+def databaseWrittenTests(event: Event[Change[object]]):
+    test_id = event.params['testId']
+    if event.data.after is None:
+        logger.info(
+            f"Event for {test_id} is None; presuming data cleanup, so skipping."
+        )
+        return
+
+    firestore.client().collection("databaseWrittenTests").document(test_id).set(
+        {
+            "testId": test_id,
+            "type": event.type,
+            "id": event.id,
+            "time": event.time,
+            "url": event.reference,
+        })

integration_tests/functions/v2/eventarc_tests.py

@@ -0,0 +1,19 @@
+import json
+
+from firebase_admin import firestore
+from firebase_functions.eventarc_fn import (on_custom_event_published,
+                                            CloudEvent)
+
+
+@on_custom_event_published(event_type="achieved-leaderboard")
+def eventarcOnCustomEventPublishedTests(event: CloudEvent):
+    test_id = event.data["testId"]
+
+    firestore.client().collection(
+        "eventarcOnCustomEventPublishedTests").document(test_id).set({
+            "id": event.id,
+            "type": event.type,
+            "time": event.time,
+            "source": event.source,
+            "data": json.dumps(event.data),
+        })

integration_tests/functions/v2/firestore_tests.py

@@ -1,66 +1,67 @@
 from firebase_admin import firestore
-from firebase_functions import firestore_fn, logger
+from firebase_functions.firestore_fn import (on_document_created, Event,
+                                             DocumentSnapshot,
+                                             on_document_deleted,
+                                             on_document_updated,
+                                             on_document_written)
 from region import REGION
 
 
-@firestore_fn.on_document_created(document='tests/{documentId}',
-                                  region=REGION,
-                                  timeout_sec=540)
-def firestoreOnDocumentCreatedTests(
-        event: firestore_fn.Event[firestore_fn.DocumentSnapshot]):
-    documentId = event.params['documentId']
+@on_document_created(document='tests/{documentId}',
+                     region=REGION,
+                     timeout_sec=540)
+def firestoreOnDocumentCreatedTests(event: Event[DocumentSnapshot]):
+    document_id = event.params['documentId']
 
-    firestore.client().collection('firestoreOnDocumentCreatedTests').document(documentId).set({
-        'time': event.time,
-        'id': event.id,
-        'type': event.type,
-        'source': event.source,
-    })
+    firestore.client().collection('firestoreOnDocumentCreatedTests').document(
+        document_id).set({
+            'time': event.time,
+            'id': event.id,
+            'type': event.type,
+            'source': event.source,
+        })
 
 
-@firestore_fn.on_document_deleted(document='tests/{documentId}',
-                                  region=REGION,
-                                  timeout_sec=540)
-def firestoreOnDocumentDeletedTests(
-        event: firestore_fn.Event[firestore_fn.DocumentSnapshot]):
-    documentId = event.params['documentId']
+@on_document_deleted(document='tests/{documentId}',
+                     region=REGION,
+                     timeout_sec=540)
+def firestoreOnDocumentDeletedTests(event: Event[DocumentSnapshot]):
+    document_id = event.params['documentId']
 
     firestore.client().collection('firestoreOnDocumentDeletedTests').document(
-        documentId).set({
-        'time': event.time,
-        'id': event.id,
-        'type': event.type,
-        'source': event.source,
-    })
+        document_id).set({
+            'time': event.time,
+            'id': event.id,
+            'type': event.type,
+            'source': event.source,
+        })
 
 
-@firestore_fn.on_document_updated(document='tests/{documentId}',
-                                  region=REGION,
-                                  timeout_sec=540)
-def firestoreOnDocumentUpdatedTests(
-        event: firestore_fn.Event[firestore_fn.DocumentSnapshot]):
-    documentId = event.params['documentId']
+@on_document_updated(document='tests/{documentId}',
+                     region=REGION,
+                     timeout_sec=540)
+def firestoreOnDocumentUpdatedTests(event: Event[DocumentSnapshot]):
+    document_id = event.params['documentId']
 
     firestore.client().collection('firestoreOnDocumentUpdatedTests').document(
-        documentId).set({
-        'time': event.time,
-        'id': event.id,
-        'type': event.type,
-        'source': event.source,
-    })
+        document_id).set({
+            'time': event.time,
+            'id': event.id,
+            'type': event.type,
+            'source': event.source,
+        })
 
 
-@firestore_fn.on_document_written(document='tests/{documentId}',
-                                  region=REGION,
-                                  timeout_sec=540)
-def firestoreOnDocumentWrittenTests(
-        event: firestore_fn.Event[firestore_fn.DocumentSnapshot]):
-    documentId = event.params['documentId']
+@on_document_written(document='tests/{documentId}',
+                     region=REGION,
+                     timeout_sec=540)
+def firestoreOnDocumentWrittenTests(event: Event[DocumentSnapshot]):
+    document_id = event.params['documentId']
 
     firestore.client().collection('firestoreOnDocumentWrittenTests').document(
-        documentId).set({
-        'time': event.time,
-        'id': event.id,
-        'type': event.type,
-        'source': event.source,
-    })
+        document_id).set({
+            'time': event.time,
+            'id': event.id,
+            'type': event.type,
+            'source': event.source,
+        })

integration_tests/functions/v2/https_tests.py

@@ -0,0 +1,19 @@
+from firebase_admin import firestore
+from firebase_functions.https_fn import (on_call, CallableRequest, on_request,
+                                         Request)
+
+from region import REGION
+
+
+@on_call(invoker="private", region=REGION)
+def httpsOnCallV2Tests(request: CallableRequest):
+    data = request.data
+    firestore.client().collection("httpsOnCallV2Tests").document(
+        data["testId"]).set(data)
+
+
+@on_request(invoker="private", region=REGION)
+def httpsOnRequestV2Tests(request: Request):
+    data = request.json
+    firestore.client().collection("httpsOnRequestV2Tests").document(
+        data["testId"]).set(data)

integration_tests/functions/v2/identity_tests.py

@@ -0,0 +1,32 @@
+from firebase_admin import firestore
+from firebase_functions.identity_fn import (before_user_created,
+                                            BeforeCreateResponse,
+                                            before_user_signed_in,
+                                            BeforeSignInResponse,
+                                            AuthBlockingEvent)
+
+
+@before_user_created()
+def identityBeforeUserCreatedTests(
+        event: AuthBlockingEvent) -> BeforeCreateResponse:
+    uid = event.data.uid
+
+    firestore.client().collection("identityBeforeUserCreatedTests").document(
+        uid).set({
+            "eventId": event.event_id,
+            "timestamp": event.timestamp,
+        })
+
+    return BeforeCreateResponse(**event.data.__dict__)
+
+
+@before_user_signed_in()
+def identityBeforeUserSignedInTests(
+        event: AuthBlockingEvent) -> BeforeSignInResponse:
+    uid = event.data.uid
+
+    firestore.client().collection("identityBeforeUserSignedInTests").document(
+        uid).set({
+            "eventId": event.event_id,
+            "timestamp": event.timestamp,
+        })

integration_tests/functions/v2/pubsub_tests.py

@@ -0,0 +1,29 @@
+import json
+
+from firebase_admin import firestore
+from firebase_functions import logger
+from firebase_functions.pubsub_fn import (on_message_published, CloudEvent,
+                                          MessagePublishedData)
+
+from region import REGION
+
+
+@on_message_published(topic="custom_message_tests", region=REGION)
+def pubsubOnMessagePublishedTests(
+        event: CloudEvent[MessagePublishedData[dict]]) -> None:
+    json_data = event.data.message.json
+    if json_data is None:
+        logger.error("Message is not JSON")
+        return
+
+    test_id = json_data["testId"]
+
+    firestore.client().collection("pubsubOnMessagePublishedTests").document(
+        test_id).set({
+            "id": event.id,
+            "source": event.source,
+            "subject": event.subject,
+            "time": event.time,
+            "type": event.type,
+            "message": json.dumps(event.data.message),
+        })

integration_tests/functions/v2/remote_config_tests.py

@@ -0,0 +1,19 @@
+from firebase_admin import firestore
+from firebase_functions.remote_config_fn import (on_config_updated, CloudEvent,
+                                                 ConfigUpdateData)
+
+from region import REGION
+
+
+@on_config_updated(region=REGION)
+def remoteConfigOnConfigUpdatedTests(
+        event: CloudEvent[ConfigUpdateData]) -> None:
+    test_id = event.data.description
+
+    firestore.client().collection("remoteConfigOnConfigUpdatedTests").document(
+        test_id).set({
+            "testId": test_id,
+            "type": event.type,
+            "id": event.id,
+            "time": event.time,
+        })

integration_tests/functions/v2/scheduler_tests.py

@@ -0,0 +1,16 @@
+from firebase_admin import firestore
+from firebase_functions import logger
+from firebase_functions.scheduler_fn import (on_schedule, ScheduledEvent)
+
+from region import REGION
+
+
+@on_schedule(schedule="every 10 hours", region=REGION)
+def schedule(event: ScheduledEvent):
+    test_id = event.job_name
+    if test_id is None:
+        logger.error("TestId not found for scheduled function execution")
+        return
+
+    firestore.client().collection("schedulerOnScheduleV2Tests").document(
+        test_id).set({"success": True})

integration_tests/functions/v2/storage_tests.py

@@ -0,0 +1,56 @@
+from firebase_admin import firestore
+from firebase_functions import logger
+from firebase_functions.storage_fn import (on_object_deleted,
+                                           on_object_finalized,
+                                           on_object_metadata_updated,
+                                           CloudEvent, StorageObjectData)
+
+from region import REGION
+
+
+@on_object_deleted(region=REGION)
+def storageOnDeleteTests(event: CloudEvent[StorageObjectData]) -> None:
+    test_id = event.data.name.split(".")[0]
+    if test_id is None:
+        logger.error("TestId not found for storage onObjectDeleted")
+        return
+
+    firestore.client().collection("storageOnObjectDeletedTests").document(
+        test_id).set({
+            "id": event.id,
+            "time": event.time,
+            "type": event.type,
+            "source": event.source,
+        })
+
+
+@on_object_finalized(region=REGION)
+def storageOnFinalizeTests(event: CloudEvent[StorageObjectData]) -> None:
+    test_id = event.data.name.split(".")[0]
+    if test_id is None:
+        logger.error("TestId not found for storage onObjectFinalized")
+        return
+
+    firestore.client().collection("storageOnObjectFinalizedTests").document(
+        test_id).set({
+            "id": event.id,
+            "time": event.time,
+            "type": event.type,
+            "source": event.source,
+        })
+
+
+@on_object_metadata_updated(region=REGION)
+def storageOnMetadataUpdateTests(event: CloudEvent[StorageObjectData]) -> None:
+    test_id = event.data.name.split(".")[0]
+    if test_id is None:
+        logger.error("TestId not found for storage onObjectMetadataUpdated")
+        return
+
+    firestore.client().collection(
+        "storageOnObjectMetadataUpdatedTests").document(test_id).set({
+            "id": event.id,
+            "time": event.time,
+            "type": event.type,
+            "source": event.source,
+        })