Implement Notification Service¶

# ---------------------------------------------------------------------------------------------
# Service: Notification Service 🐲 -----------------------------------------------------------
# ---------------------------------------------------------------------------------------------

resource "google_project_service" "required_apis" {
  for_each = toset([
    "artifactregistry.googleapis.com",
    "cloudbuild.googleapis.com",
    "logging.googleapis.com",
    "run.googleapis.com",
  ])

  project            = var.project_id
  service            = each.key
  disable_on_destroy = false
}

# ---------------------------------------------------------------------------------------------
# Service Accounts ----------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------

resource "google_service_account" "sa_spirit_breaker" {
  account_id   = "sa-spirit-breaker"
  display_name = "SA Spirit Breaker"
  description  = "Spirit Breaker - Charges down enemies from anywhere on the map"
}

resource "google_project_iam_member" "sa_spirit_breaker" {
  for_each = toset([
    "roles/run.invoker",
  ])
  project = var.project_id
  role    = each.key
  member  = "serviceAccount:${google_service_account.sa_spirit_breaker.email}"

  depends_on = [
    google_service_account.sa_spirit_breaker,
  ]
}

resource "google_service_account" "sa_techies" {
  account_id   = "sa-techies"
  display_name = "SA Techies"
  description  = "Techies - Surprises enemies with invisible landmines and explosive attacks"
}

resource "google_project_iam_member" "sa_techies" {
  for_each = toset([
    "roles/run.developer",
    "roles/run.invoker",
    "roles/secretmanager.secretAccessor",
    "roles/logging.logWriter",
    "roles/errorreporting.writer",
    "roles/monitoring.metricWriter",
    "roles/serviceusage.serviceUsageViewer",
    "roles/serviceusage.serviceUsageConsumer",
  ])
  project = var.project_id
  role    = each.key
  member  = "serviceAccount:${google_service_account.sa_techies.email}"

  depends_on = [
    google_service_account.sa_techies,
  ]
}

# ---------------------------------------------------------------------------------------------
# Cloud Run -----------------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------

data "google_cloud_run_service" "notification_service" {
  name     = "prod-notification-service"
  location = var.project_region
  project  = var.project_id
}

# ---------------------------------------------------------------------------------------------
# Pubsub --------------------------------------------------------------------------------------
# ---------------------------------------------------------------------------------------------

resource "google_pubsub_topic" "notification_cloudbuild" {
  name    = "cloud-builds" # Cloud Build only push to this name (NOT CHANGE)
  project = var.project_id

  labels = {
    team        = "thuyetbao"
    environment = "production"
  }

  message_retention_duration = "21600s"
}

resource "google_pubsub_subscription" "notification_cloudbuild" {
  name                       = "prod-sub-notification-cloudbuild"
  topic                      = google_pubsub_topic.notification_cloudbuild.id
  message_retention_duration = "21600s"
  retain_acked_messages      = true
  ack_deadline_seconds       = 60

  labels = {
    team        = "thuyetbao"
    environment = "production"
  }

  expiration_policy {
    ttl = "" # The resource never expires
  }

  push_config {
    push_endpoint = "${data.google_cloud_run_service.notification_service.status[0].url}/event/cloudbuild"

    oidc_token {
      service_account_email = google_service_account.sa_spirit_breaker.email
    }
  }

  retry_policy {
    minimum_backoff = "30s"
    maximum_backoff = "600s"
  }

  depends_on = [
    google_service_account.sa_techies,
    google_pubsub_topic.notification_cloudbuild,
  ]
}

_metadata:
  major_version: 2
  minor_version: 1
display_information:
  name: Flycatcher
  long_description: >
    Flycatcher is a Slack notification agent that processes events from the notification service
    and generates interactive, rich messages to manage workflows like Cloud Build updates.
  description: Flycatcher - Agent to delivery message to communication channels
  background_color: "#0b1c4f"
features:
  bot_user:
    display_name: Flycatcher
    always_online: true
oauth_config:
  scopes:
    bot:
      - chat:write
      - chat:write.customize
      - chat:write.public
      # - channels:history
      # - groups:history
      # - groups:read
      # - groups:write
      # - users.profile:read
      # - commands
      # - files:read
      # - files:write
      # - im:history
      # - incoming-webhook
      # - mpim:history
  # redirect_urls:
  #   - https://example.com/slack/auth
settings:
  org_deploy_enabled: false
  socket_mode_enabled: false
  token_rotation_enabled: false
  # event_subscriptions:
  #   request_url: https://localhost/event/slack
  #   bot_events:
  #     - message.channels
  #     - message.groups
  #     - message.im
  # interactivity:
  #   is_enabled: true
  #   request_url: https://example.com/slack/message_action

SLACK_BOT_OAUTH_TOKEN=xoxb-11111111111111-99999999999999-xyzxyzxyzxyzxyzxyzxyzxyz

#!/bin/python3

# Global
import json
import random

# External
import structlog
from fastapi import (
    APIRouter,
    Depends,
    status,
)
from fastapi.templating import Jinja2Templates
from jinja2 import Template
from slack_sdk import WebClient as SlackWebClient
from src.google.cloudbuild import CloudBuildStatus

# Internal
import dependencies
from config import __CONFIG__

# Context
from endpoint.events.cloudbuild.model import BuildPushNotificationPayload


router = APIRouter(
    prefix="/event",
    tags=["Event"],
)

# Construct
LOG: structlog.stdlib.BoundLogger = structlog.get_logger()


# The mapping of representation icon based on source
# For keys: ref to <https://docs.cloud.google.com/build/docs/api/reference/rest/v1/projects.builds#Build.Source>
representationIconMapping: dict[str, str] = {
    "gitSource": "https://cdn-icons-png.flaticon.com/512/2111/2111292.png",
    "repoSource": "https://cdn-icons-png.flaticon.com/512/2111/2111292.png",
    "storageSource": " https://cdn-icons-png.flaticon.com/512/1975/1975660.png",
}

# The default channel if not specified
DEFAULT_CHANNEL_ID: str = "C0A6G9EPC11"

# The default maintainer if not specified
DEFAULT_MAINTAINER_MEMBER_ID: str = "U0A6G98D4CB"

# The default image for representation icon
DEFAULT_REPRESENTATION_ICON: str = "https://cdn-icons-png.flaticon.com/512/8637/8637097.png"


@router.post(
    path="/cloudbuild",
    description="Handle state change from Cloud Build",
    summary="Handle state change from Cloud Build",
    status_code=status.HTTP_200_OK,
)
def handleEventFromCloudBuild(
    payload: BuildPushNotificationPayload,
    templates: Jinja2Templates = Depends(dependencies.yield_template),
    client_slack: SlackWebClient = Depends(dependencies.yield_slack_client),
):

    # Filter message at the result
    if payload.message.attributes.status not in CloudBuildStatus.get_result_status():
        return {"status": "ok"}

    # Template
    tpl_build_metadata: Template = templates.get_template(name="event/cloudbuild/build_metadata.jinja")
    tpl_call_maintainer: Template = templates.get_template(name="global/call_maintainer.jinja")

    # Construct
    build_event = payload.load_composite()
    build_status = build_event.status
    build_maintainer = build_event.substitutions.get("_BUILD_MAINTAINER_SLACK_ID", DEFAULT_MAINTAINER_MEMBER_ID)
    build_slack_channel_id = build_event.substitutions.get("_BUILD_SLACK_CHANNEL_ID", DEFAULT_CHANNEL_ID)
    build_representation_icon = representationIconMapping.get(list(build_event.source)[0], DEFAULT_REPRESENTATION_ICON)
    current_thread_ts = None

    # Component
    component = build_event.model_dump() | {
        "attachment_color": build_status.hex_color,
        "message_detail": build_status.message,
        # Source with encrypted the metadata
        "reference_source": (
            build_event.build_source_reference_name()
            .replace(__CONFIG__.GOOGLE_PROJECT_ID, "---")
            .replace(__CONFIG__.GOOGLE_PROJECT_LOCATION, "---")
        ),
        "tags_composite": ", ".join(["`" + x.strip() + "`" for x in build_event.tags]),
        "run_time": {
            "timezone": {
                "type": "UTC",
                "format": "UTC",
            },
            "createTime": build_event.createTime.strftime("%Y-%m-%d"),
            "timeframe": {
                "from_hhmm": build_event.startTime.strftime("%H:%M:%S"),
                "to_hhmm": build_event.finishTime.strftime("%H:%M:%S"),
            },
            "total_seconds": "{:.2f}".format(build_event.total_seconds()) if build_event.total_seconds() is not None else "---",
        },
        "representation_icon": build_representation_icon,
    }
    LOG.debug(f"Event content: {build_event}")

    # Send
    content_build_metadata = tpl_build_metadata.render(**component)
    message_prefix_icon = random.choice(["stars", "milky_way", "sparkles", "package", "building_construction"])
    message_title = f":{message_prefix_icon}: Build *{build_event.id}* has been deployed"
    result_build_metadata = client_slack.chat_postMessage(
        as_user=True,
        channel=build_slack_channel_id,
        text=message_title,
        attachments=json.loads(content_build_metadata, strict=False)
    )
    result_build_metadata.validate()
    current_thread_ts = result_build_metadata["ts"]

    # If exists any failure, trigger call the maintainer of the pipeline
    if all([
        build_status in CloudBuildStatus.get_failure_status(),
        any([
            # Handler tags on production only
            any([tag.lower().startswith("prod") for tag in build_event.tags]),
        ])
    ]):

        # Send
        content_call_maintainer = tpl_call_maintainer.render(user_id=build_maintainer)
        result_call_maintainer = client_slack.chat_postMessage(
            as_user=True,
            channel=build_slack_channel_id,
            thread_ts=current_thread_ts,
            attachments=json.loads(content_call_maintainer, strict=False)
        )
        result_call_maintainer.validate()

    return {"status": "ok"}

#!/bin/python3

# External
from pydantic import (
    BaseModel,
    ConfigDict,
    Field,
    field_validator,
    ValidationInfo
)
from src.google.cloudbuild import CloudBuildStatus
from src.google.pubsub import CloudPubSubPushMessage, SubcriptionIdentifier
from src.google.cloudbuild import CloudBuildResouceResult


class CloudPubSubPushNotification(BaseModel):
    """Push notification from Pubsub

    Reference
    ---------
    https://cloud.google.com/build/docs/subscribe-build-notifications#push

    Example
    -------
    {
        "message": {
            "attributes": {
                "buildId": "abcd-efgh...",
                "status": "SUCCESS"
            },
            "data": "SGVsbG8gQ2xvdWQgUHViL1N1YiEgSGVyZSBpcyBteSBtZXNzYWdlIQ==",
            "message_id": "136969346945"
        },
        "subscription": "projects/myproject/subscriptions/mysubscription"
    }
    """
    message: CloudPubSubPushMessage = Field(default=...)
    subscription: SubcriptionIdentifier = Field(default=...)

    @field_validator("subscription", mode="before")
    @classmethod
    def map_subcription_structure(cls, value: str):
        "Parse projects/myproject/subscriptions/mysubscription"
        _, project_id, _, subcription_id = value.split("/")
        value = SubcriptionIdentifier.model_validate({
            "project_id": project_id,
            "subcription_id": subcription_id
        })
        return value

    model_config = ConfigDict(
        json_decoders = {
            SubcriptionIdentifier: lambda v: v.identifier()
        },
    )


class CloudBuildPayload(BaseModel):
    buildId: str = Field(default=..., description="ID of build")
    status: CloudBuildStatus = Field(default=..., description="Status of build event")
    model_config = ConfigDict(extra="allow")

    @field_validator("status", mode="before")
    @classmethod
    def parse_status(cls, values, info: ValidationInfo):
        try:
            return CloudBuildStatus.search(keyword=values)
        except ValueError as exc:
            raise ValueError(f"{info.field_name} has unknown value") from exc


class CloudBuildPushMessage(CloudPubSubPushMessage):
    """CloudBuild messsage for an event

    Usage
    -----
    {
        "message": {
            "attributes": {
                "buildId": "abcd-efgh...",
                "status": "SUCCESS"
            },
            "data": "SGVsbG8gQ2xvdWQgUHViL1N1YiEgSGVyZSBpcyBteSBtZXNzYWdlIQ==",
            "message_id": "136969346945"
        },
        "subscription": "projects/myproject/subscriptions/mysubscription"
    }
    """
    attributes: CloudBuildPayload = Field(default=...)


class BuildPushNotificationPayload(CloudPubSubPushNotification):
    """Payload from subcription from CloudBuild event

    Reference
    ---------
    [Subscribe build notifications](https://cloud.google.com/build/docs/subscribe-build-notifications)
    """
    message: CloudBuildPushMessage = Field(default=..., description="The message of Push payload from CloudBuild")

    def load_composite(self) -> CloudBuildResouceResult:
        metadata = self.message.decode_message_data()
        return CloudBuildResouceResult.model_validate(metadata)

# Note: Bullseye is the latest Debien published at 2021
FROM python:3.12.8-bullseye

# Run in non-interactive mode
ARG DEBIAN_FRONTEND=noninteractive

# the language of a Linux system
ENV LANG=C.UTF-8

# Overrides the encoding used for stdin/stdout/stderr
ENV PYTHONIOENCODING=utf-8

# Prevent Python from writing pyc files to disc
ARG PYTHONDONTWRITEBYTECODE=1

# Prevent Python from buffering stdout and stderr
ARG PYTHONUNBUFFERED=1

# Using default bash shell
# ref: https://deepsource.io/directory/analyzers/docker/issues/DOK-DL4005
SHELL ["/bin/bash", "-c"]

# The commit ID associated with your build
ARG REVISION_ID

# The first seven characters of COMMIT_SHA
ARG SHORT_SHA

# The full name of your repository, including either the user or organization
ARG REPO_FULL_NAME

# Config for deployment environment state
ENV DEPLOYMENT_ENVIRONMENT_STATE=development

# Metdata
LABEL com.service.notification.service.name="notification-service"
LABEL com.service.notification.service.version="1.14.14"
LABEL com.service.notification.service.maintainer="trthuyetbao@gmail.com"
LABEL com.service.notification.service.contributors="trthuyetbao@gmail.com"
LABEL com.service.notification.service.tags="notification-service|supported-on:slack-email-sms"
LABEL com.service.notification.image.repo_full_name="$REPO_FULL_NAME"
LABEL com.service.notification.image.short_sha="$SHORT_SHA"
LABEL com.service.notification.image.revision_id="$REVISION_ID"

# Set working directory
WORKDIR /usr/bin/notification-service/

# Transfer
COPY ./backend/requirements.txt ./requirements.txt
COPY ./backend/requirements-dev.txt ./requirements-dev.txt

# Dependencies
RUN pip install --upgrade pip>=25.3;
RUN pip install --no-cache-dir -r requirements.txt --default-timeout 100;

# Tool
RUN if [[ \
  "$DEPLOYMENT_ENVIRONMENT_STATE" == "development" ]]; then \
  pip install -r requirements-dev.txt --default-timeout 100; \
  fi;

# Sync application
COPY ./backend/ ./

# Cloud Run control $PORT
EXPOSE $PORT

# Exec
ENTRYPOINT [ "/bin/bash", "-l", "-c", "uvicorn entrypoint:app --host 0.0.0.0 --port $PORT --workers 1" ]

# Run by: sa-nature-prophet@$PROJECT_ID.iam.gserviceaccount.com

tags: ["$_BUILD_ENV", "$_BUILD_ACTION", "sha-$SHORT_SHA"]

substitutions:
  _BUILD_ENV: "production"
  _BUILD_ACTION: "deploy-notification-service"
  _BUILD_POOL: "private-pool-build-workers"
  _BUILD_SERVICE_ACCOUNT_NAME: "sa-nature-prophet"
  _BUILD_MAINTAINER_SLACK_ID: "U0A6G98D4CB" # thuyetbao
  _BUILD_SLACK_CHANNEL_ID: "C0A6NLB2WRG" # Channel #all-thuyetbao
  _ARTIFACT_REGISTRY_REPOSITORY_NAME: "dock-artifact-registry"
  _RUN_APPLICATION_NAME: "prod-notification-service"
  _RUN_APPLLICATION_LOCATION: "${LOCATION}"
  _RUN_APPLICATION_DESCRIPTION: "[Notification] (Production) Flycatcher - Serverless notification service"
  _RUN_IMAGE_NAME: "${_RUN_APPLICATION_NAME}"
  _RUN_SERVICE_ACCOUNT_NAME: "sa-techies"

steps:
  # Docker Build
  - name: "gcr.io/cloud-builders/docker"
    id: build_docker_image
    dir: project/sandbox/notification-service
    entrypoint: bash
    args:
      - "-c"
      - |

        # Setting
        set -e

        # On context
        DOCKER_BUILDKIT=1 \
          docker build \
          --build-arg DEPLOYMENT_ENVIRONMENT_STATE=$_BUILD_ENV \
          --build-arg REPO_FULL_NAME=$REPO_FULL_NAME \
          --build-arg SHORT_SHA=$SHORT_SHA \
          --build-arg REVISION_ID=$REVISION_ID \
          -t $LOCATION-docker.pkg.dev/$PROJECT_ID/$_ARTIFACT_REGISTRY_REPOSITORY_NAME/$_RUN_IMAGE_NAME:latest \
          -f ./Dockerfile .

  # Docker push to Google Artifact Registry
  - name: "gcr.io/cloud-builders/docker"
    id: push_artifact_registry
    waitFor:
      - build_docker_image
    args:
      [
        "push",
        "$LOCATION-docker.pkg.dev/$PROJECT_ID/$_ARTIFACT_REGISTRY_REPOSITORY_NAME/$_RUN_IMAGE_NAME:latest",
      ]

  # Service status
  - name: "gcr.io/cloud-builders/gcloud"
    id: verify_run_deployment_status
    waitFor:
      - push_artifact_registry
    entrypoint: "bash"
    args:
      - "-c"
      - |

        # Setting
        set -e

        # Get Status
        declare service_status=$(gcloud run services list \
          --region=$LOCATION \
          --filter="metadata.name=$_RUN_APPLICATION_NAME" \
          --format="value(name)" \
          --verbosity=none \
        );

        # Check run service exist
        # If exist, then remove services for new deployment
        if [[ ! -z "$service_status" ]];
        then
          gcloud run services delete $_RUN_APPLICATION_NAME \
            --region=$LOCATION \
            --verbosity=none \
            --quiet;
        fi;

  # Deploy to Cloud Run
  - name: "gcr.io/cloud-builders/gcloud"
    waitFor:
      - verify_run_deployment_status
    args:
      [
        "run",
        "deploy",
        "$_RUN_APPLICATION_NAME",
        "--description=$_RUN_APPLICATION_DESCRIPTION",
        "--execution-environment=gen2",
        "--allow-unauthenticated",
        "--no-cpu-throttling",
        "--region=$_RUN_APPLLICATION_LOCATION",
        "--image=$LOCATION-docker.pkg.dev/$PROJECT_ID/$_ARTIFACT_REGISTRY_REPOSITORY_NAME/$_RUN_IMAGE_NAME:latest",
        "--service-account=$_RUN_SERVICE_ACCOUNT_NAME@$PROJECT_ID.iam.gserviceaccount.com",
        "--cpu=1",
        "--memory=512Mi",
        # "--startup-probe=timeoutSeconds=10,httpGet.port=15555",
        "--ingress=all",
        "--min-instances=1",
        "--max-instances=1",
        "--concurrency=20",
        "--timeout=5m",
        "--set-env-vars=DEPLOYMENT_ENVIRONMENT_STATE=production",
        "--set-env-vars=APPLICATION_LOGGING_LEVEL=INFO",
        "--set-env-vars=APPLICATION_DEBUG_MODE=0",
        "--set-env-vars=GOOGLE_PROJECT_ID=$PROJECT_ID",
        "--set-env-vars=GOOGLE_PROJECT_LOCATION=$LOCATION",
        # "--set-secrets=GOOGLE_PROJECT_ID=$PROJECT_ID",
        # "--set-secrets=GOOGLE_PROJECT_LOCATION=$LOCATION",
        "--set-secrets=SLACK_BOT_OAUTH_TOKEN=SLACK_BOT_OAUTH_TOKEN:latest",
        "--set-secrets=SLACK_SIGNING_SECRET=SLACK_SIGNING_SECRET:latest",
        "--set-secrets=SENDGRID_API_KEY=SENDGRID_API_KEY:latest",
        "--labels=repository=$REPO_NAME,on_commit=$SHORT_SHA,team=thuyetbao,managed_by=cloudbuild,slack=flycatcher",
        "--tag=latest",
      ]

timeout: "1200s"
logsBucket: "gs://dock-internal-store"
images:
  - "$LOCATION-docker.pkg.dev/$PROJECT_ID/$_ARTIFACT_REGISTRY_REPOSITORY_NAME/$_RUN_IMAGE_NAME:latest"

options:
  dynamicSubstitutions: true
  logStreamingOption: "STREAM_ON"
  pool:
    name: "projects/$PROJECT_ID/locations/$LOCATION/workerPools/$_BUILD_POOL"

createTime: '2018-02-22T14:49:54.066666971Z'
finishTime: '2018-02-22T14:50:05.463758Z'
id: bcdb9c48-d92c-4489-a3cb-08d0f0795a0b
images:
- us-east1-docker.pkg.dev/gcb-docs-project/quickstart-image
logUrl: https://console.cloud.google.com/cloud-build/builds/bcdb9c48-d92c-4489-a3cb-08d0f0795a0b?project=gcb-docs-project
logsBucket: gs://404889597380.cloudbuild-logs.googleusercontent.com
projectId: gcb-docs-project
results:
    buildStepImages:
    - sha256:a4363bc75a406c4f8c569b12acdd86ebcf18b6004b4f163e8e6293171462a79d
    images:
    - digest: sha256:1b2a237e74589167e4a54a8824f0d03d9f66d3c7d9cd172b36daa5ac42e94eb9
      name: us-east1-docker.pkg.dev/gcb-docs-project/quickstart-image
      pushTiming:
          endTime: '2018-02-22T14:50:04.731919081Z'
          startTime: '2018-02-22T14:50:00.874058710Z'
      - digest: sha256:1b2a237e74589167e4a54a8824f0d03d9f66d3c7d9cd172b36daa5ac42e94eb9
        name: us-east1-docker.pkg.dev/gcb-docs-project/quickstart-image:latest
        pushTiming:
            endTime: '2018-02-22T14:50:04.731919081Z'
            startTime: '2018-02-22T14:50:00.874058710Z'
source:
    storageSource:
        bucket: gcb-docs-project_cloudbuild
        generation: '1519310993665963'
        object: source/1519310992.2-8465b08c79e14e89bee09adc8203c163.tgz
sourceProvenance:
    fileHashes:
        gs://gcb-docs-project_cloudbuild/source/1519310992.2-8465b08c79e14e89bee09adc8203c163.tgz#1519310993665963:
        fileHash:
        - value: -aRYrWp2mtfKhHSyWn6KNQ==
    resolvedStorageSource:
        bucket: gcb-docs-project_cloudbuild
        generation: '1519310993665963'
        object: source/1519310992.2-8465b08c79e14e89bee09adc8203c163.tgz
startTime: '2018-02-22T14:49:54.966308841Z'
status: SUCCESS
steps:
- args:
  - build
  - --no-cache
  - -t
  - us-east1-docker.pkg.dev/gcb-docs-project/quickstart-image
  - .
  name: gcr.io/cloud-builders/docker
  status: SUCCESS
  timing:
      endTime: '2018-02-22T14:50:00.813257422Z'
      startTime: '2018-02-22T14:50:00.102600442Z'
timeout: 600s
timing:
    BUILD:
        endTime: '2018-02-22T14:50:00.873604173Z'
        startTime: '2018-02-22T14:50:00.102589403Z'
    FETCHSOURCE:
        endTime: '2018-02-22T14:50:00.087286880Z'
        startTime: '2018-02-22T14:49:56.962717504Z'
    PUSH:
        endTime: '2018-02-22T14:50:04.731958202Z'
        startTime: '2018-02-22T14:50:00.874057159Z'

ERROR: (gcloud.run.deploy) The user-provided container failed to start and listen on the port defined provided by the PORT=5000 environment variable within the allocated timeout. This can happen when the container port is misconfigured or if the timeout is too short. The health check timeout can be extended. Logs for this revision might contain more information.

#!/bin/python3

# External
from fastapi.testclient import TestClient
import structlog
import pytest
import base64
import json
import uuid

# Construct
LOG: structlog.stdlib.BoundLogger = structlog.get_logger()
structlog.contextvars.bind_contextvars(name="notification", pipeline="build.event")


@pytest.fixture
def on_path() -> str:
    return "/event/cloudbuild"


@pytest.fixture
def payload() -> dict:
    return {
        "createTime": "2018-02-22T14:49:54.066666971Z",
        "finishTime": "2018-02-22T14:50:05.463758Z",
        "id": "bcdb9c48-d92c-4489-a3cb-08d0f0795a0b",
        "images": [
            "us-east1-docker.pkg.dev/space/notification-service"
        ],
        "logUrl": "https://console.cloud.google.com/cloud-build/builds/bcdb9c48-d92c-4489-a3cb-08d0f0795a0b?project=space",
        "logsBucket": "gs://404889597380.cloudbuild-logs.googleusercontent.com",
        "projectId": "space",
        "results": {
            "buildStepImages": [
                {
                    "sha256": "a4363bc75a406c4f8c569b12acdd86ebcf18b6004b4f163e8e6293171462a79d"
                }
            ],
            "images": [
                {
                    "digest": "sha256:1b2a237e74589167e4a54a8824f0d03d9f66d3c7d9cd172b36daa5ac42e94eb9",
                    "name": "us-east1-docker.pkg.dev/space/notification-service"
                },
                {
                    "digest": "sha256:1b2a237e74589167e4a54a8824f0d03d9f66d3c7d9cd172b36daa5ac42e94eb9",
                    "name": "us-east1-docker.pkg.dev/space/notification-service:latest"
                }
            ]
        },
        "source": {
            "repoSource": {
                "projectId": "thuyetbao",
                "repoName": "space",
                "branchName": "master",
                "commitSha": "8465b08c79e14e89bee09adc8203c163"
            }
        },
        "sourceProvenance": {
            "fileHashes": {
                "gs://space_cloudbuild/source/1519310992.2-8465b08c79e14e89bee09adc8203c163.tgz#1519310993665963": {
                    "fileHash": {
                        "value": "-aryrWp2mtfKhHSyWn6KNQ=="
                    }
                }
            },
            "resolvedStorageSource": {
                "bucket": "space-cloudbuild",
                "generation": "1519310993665963",
                "object": "source/1519310992.2-8465b08c79e14e89bee09adc8203c163.tgz"
            }
        },
        "startTime": "2018-02-22T14:49:54.966308841Z",
        "status": "SUCCESS",
        "steps": [
            {
                "args": [
                    "build",
                    "--no-cache",
                    "-t",
                    "us-east1-docker.pkg.dev/space/build-notification-service",
                    "."
                ],
                "name": "gcr.io/cloud-builders/docker",
                "status": "SUCCESS",
                "timing": {
                    "endTime": "2018-02-22T14:50:00.813257422Z",
                    "startTime": "2018-02-22T14:50:00.102600442Z"
                }
            }
        ],
        "timeout": "600s",
        "timing": {
            "BUILD": {
                "endTime": "2018-02-22T14:50:00.873604173Z",
                "startTime": "2018-02-22T14:50:00.102589403Z"
            },
            "FETCHSOURCE": {
                "endTime": "2018-02-22T14:50:00.087286880Z",
                "startTime": "2018-02-22T14:49:56.962717504Z"
            },
            "PUSH": {
                "endTime": "2018-02-22T14:50:04.731958202Z",
                "startTime": "2018-02-22T14:50:00.874057159Z"
            }
        }
    }


def test_push_success(client: TestClient, on_path: str, payload: dict):

    on_status = "SUCCESS"
    payload["status"] = on_status
    message = {
        "message": {
            "attributes": {
                "buildId": payload["id"],
                "status": on_status,
                "additionalProp1": {}
            },
            "data": base64.b64encode(json.dumps(payload).encode()).decode(),
            "message_id": uuid.uuid4().hex,
            "additionalProp1": {}
        },
        "subscription": "projects/{}/subscriptions/{}".format(
            payload["projectId"],
            "sub-cloudbuild-notification"
        )
    }

    resp = client.post(
        url=on_path,
        headers={"Content-Type": "application/json"},
        json=message
    )

    assert resp.status_code == 200
    assert resp.json() == {"status": "ok"}


def test_push_failure(client: TestClient, on_path: str, payload: dict):

    on_status = "FAILURE"
    payload["status"] = on_status
    payload["tags"] = ["production"] # To trigger call maintainer in production only
    message = {
        "message": {
            "attributes": {
                "buildId": payload["id"],
                "status": on_status,
                "additionalProp1": {}
            },
            "data": base64.b64encode(json.dumps(payload).encode()).decode(),
            "message_id": uuid.uuid4().hex,
            "additionalProp1": {}
        },
        "subscription": "projects/{}/subscriptions/{}".format(
            payload["projectId"],
            "sub-cloudbuild-notification"
        )
    }

    resp = client.post(
        url=on_path,
        headers={"Content-Type": "application/json"},
        json=message
    )

    assert resp.status_code == 200
    assert resp.json() == {"status": "ok"}