okdata-aws 2.2.0__tar.gz → 3.0.1__tar.gz

{okdata-aws-2.2.0 → okdata-aws-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: okdata-aws
-Version: 2.2.0
+Version: 3.0.1
 Summary: Collection of helpers for working with AWS
 Home-page: https://github.com/oslokommune/okdata-aws
 Author: Oslo Origo

okdata-aws-3.0.1/okdata/aws/status/model.py

@@ -0,0 +1,98 @@
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from json import dumps, JSONEncoder
+from typing import Dict, Optional, List
+
+
+class TraceStatus(str, Enum):
+    STARTED = "STARTED"
+    CONTINUE = "CONTINUE"
+    FINISHED = "FINISHED"
+
+
+class TraceEventStatus(str, Enum):
+    OK = "OK"
+    FAILED = "FAILED"
+
+
+class StatusJSONEncoder(JSONEncoder):
+    def default(self, obj, *args, **kwargs):
+        if isinstance(obj, Exception):
+            return str(obj)
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        return super().default(obj)
+
+
+class BaseModel:
+    def dict(self, exclude_none=False):
+        if exclude_none:
+            return asdict(
+                self,
+                dict_factory=lambda d: {k: v for (k, v) in d if v is not None},
+            )
+        return asdict(self)
+
+    def json(self, exclude_none=False, **kwargs):
+        return dumps(
+            self.dict(exclude_none=exclude_none),
+            cls=StatusJSONEncoder,
+            **kwargs,
+        )
+
+    @classmethod
+    def parse_obj(cls, obj):
+        return cls(**obj)
+
+
+@dataclass
+class StatusMeta(BaseModel):
+    function_name: Optional[str] = None
+    function_version: Optional[str] = None
+    function_stage: Optional[str] = None
+    function_api_id: Optional[str] = None
+    git_rev: Optional[str] = None
+    git_branch: Optional[str] = None
+
+
+# TODO: Rework optional vs required and defaults when currents users are updated
+# and if to be used as a basis for the status api. Both trace_id (for new traces)
+# and trace_event_id are currently generated in status-api.
+@dataclass
+class StatusData(BaseModel):
+    trace_id: Optional[str] = None  # TODO: Generate here as default?
+    # trace_event_id: UUID = None  # = Field(default_factory=uuid4)
+    domain: str = "N/A"  # TODO: Temporary default (required)
+    domain_id: Optional[str] = None
+    start_time: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    end_time: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    trace_status: TraceStatus = TraceStatus.CONTINUE
+    trace_event_status: TraceEventStatus = TraceEventStatus.OK
+    user: Optional[str] = None
+    component: str = "N/A"  # TODO: Temporary default (required)
+    operation: Optional[str] = None
+    status_body: Optional[Dict] = None
+    meta: Optional[StatusMeta] = None
+    s3_path: Optional[str] = None
+    duration: Optional[int] = None
+    exception: Optional[str] = None
+    errors: Optional[List] = None
+
+    def __setattr__(self, name, value):
+        # Validate and ensure format of errors
+        if name == "errors" and value is not None:
+            if not isinstance(value, list):
+                raise TypeError("`errors` must be provided as a list.")
+
+            for error in value:
+                if not isinstance(error, dict):
+                    raise TypeError(f"{error} is not a dict.")
+                if "message" not in error:
+                    raise ValueError("Missing key 'message'.")
+                if not isinstance(error["message"], dict):
+                    raise TypeError("error['message'] is not a dict.")
+                if "nb" not in error["message"]:
+                    raise ValueError("Missing key 'nb' in error['message'].")
+
+        super().__setattr__(name, value)

{okdata-aws-2.2.0 → okdata-aws-3.0.1}/okdata/aws/status/wrapper.py

@@ -5,7 +5,12 @@ from functools import wraps
 
 from requests.exceptions import HTTPError
 
-from .model import StatusData, TraceStatus, TraceEventStatus
+from .model import (
+    StatusData,
+    StatusMeta,
+    TraceEventStatus,
+    TraceStatus,
+)
 from .sdk import Status
 
 _status_logger = None
@@ -57,13 +62,13 @@ def _status_from_lambda_context(event, context):
             "trace_id": event.get("execution_name"),
             "user": authorizer.get("principalId"),
             "component": os.getenv("SERVICE_NAME"),
-            "meta": {
-                "function_name": getattr(context, "function_name", None),
-                "function_version": getattr(context, "function_version", None),
-                "function_stage": request_context.get("stage"),
-                "function_api_id": request_context.get("apiId"),
-                "git_rev": os.getenv("GIT_REV"),
-                "git_branch": os.getenv("GIT_BRANCH"),
-            },
+            "meta": StatusMeta(
+                function_name=getattr(context, "function_name", None),
+                function_version=getattr(context, "function_version", None),
+                function_stage=request_context.get("stage"),
+                function_api_id=request_context.get("apiId"),
+                git_rev=os.getenv("GIT_REV"),
+                git_branch=os.getenv("GIT_BRANCH"),
+            ),
         }
     )

{okdata-aws-2.2.0 → okdata-aws-3.0.1}/okdata_aws.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: okdata-aws
-Version: 2.2.0
+Version: 3.0.1
 Summary: Collection of helpers for working with AWS
 Home-page: https://github.com/oslokommune/okdata-aws
 Author: Oslo Origo

{okdata-aws-2.2.0 → okdata-aws-3.0.1}/okdata_aws.egg-info/SOURCES.txt

@@ -14,7 +14,4 @@ okdata_aws.egg-info/SOURCES.txt
 okdata_aws.egg-info/dependency_links.txt
 okdata_aws.egg-info/namespace_packages.txt
 okdata_aws.egg-info/requires.txt
-okdata_aws.egg-info/top_level.txt
-tests/test_logging.py
-tests/test_model.py
-tests/test_status.py
+okdata_aws.egg-info/top_level.txt

{okdata-aws-2.2.0 → okdata-aws-3.0.1}/okdata_aws.egg-info/requires.txt

@@ -1,6 +1,5 @@
 boto3
 okdata-sdk<4,>=3
-pydantic<2
 requests
 starlette<1.0.0,>=0.25.0
 structlog

{okdata-aws-2.2.0 → okdata-aws-3.0.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="okdata-aws",
-    version="2.2.0",
+    version="3.0.1",
     author="Oslo Origo",
     author_email="dataplattform@oslo.kommune.no",
     description="Collection of helpers for working with AWS",
@@ -30,7 +30,6 @@ setuptools.setup(
     install_requires=[
         "boto3",
         "okdata-sdk>=3,<4",
-        "pydantic<2",
         "requests",
         "starlette>=0.25.0,<1.0.0",
         "structlog",

okdata-aws-2.2.0/okdata/aws/status/model.py

@@ -1,72 +0,0 @@
-from enum import Enum
-from typing import Dict, Optional, List
-from datetime import datetime, timezone
-from pydantic import BaseModel, Field, validator
-
-
-class TraceStatus(str, Enum):
-    STARTED = "STARTED"
-    CONTINUE = "CONTINUE"
-    FINISHED = "FINISHED"
-
-
-class TraceEventStatus(str, Enum):
-    OK = "OK"
-    FAILED = "FAILED"
-
-
-class StatusMeta(BaseModel):
-    function_name: Optional[str] = None
-    function_version: Optional[str] = None
-    function_stage: Optional[str] = None
-    function_api_id: Optional[str] = None
-    git_rev: Optional[str] = None
-    git_branch: Optional[str] = None
-
-
-# TODO: Rework optional vs required and defaults when currents users are updated
-# and if to be used as a basis for the status api. Both trace_id (for new traces)
-# and trace_event_id are currently generated in status-api.
-class StatusData(BaseModel):
-    trace_id: Optional[str] = None  # TODO: Generate here as default?
-    # trace_event_id: UUID = None  # = Field(default_factory=uuid4)
-    domain: str = "N/A"  # TODO: Temporary default (required)
-    domain_id: Optional[str] = None
-    start_time: datetime = Field(
-        default_factory=lambda: datetime.now(timezone.utc), str=datetime.isoformat
-    )
-    end_time: datetime = Field(
-        default_factory=lambda: datetime.now(timezone.utc), str=datetime.isoformat
-    )
-    trace_status: TraceStatus = TraceStatus.CONTINUE
-    trace_event_status: TraceEventStatus = TraceEventStatus.OK
-    user: Optional[str] = None
-    component: str = "N/A"  # TODO: Temporary default (required)
-    operation: Optional[str] = None
-    status_body: Optional[Dict] = None
-    meta: Optional[StatusMeta] = None
-    s3_path: Optional[str] = None
-    duration: Optional[int] = None
-    exception: Optional[str] = None
-    errors: Optional[List] = None
-
-    class Config:
-        validate_assignment = True
-
-    @validator("exception", pre=True)
-    def ensure_exception_data_is_string(cls, v):
-        if isinstance(v, Exception):
-            return str(v)
-        return v
-
-    @validator("errors", each_item=True)
-    def ensure_format_of_errors(cls, v):
-        if not isinstance(v, dict):
-            raise TypeError(f"{v} is not a dict.")
-        if "message" not in v:
-            raise ValueError("Missing key 'message'.")
-        if not isinstance(v["message"], dict):
-            raise TypeError("error['message'] is not a dict.")
-        if "nb" not in v["message"]:
-            raise ValueError("Missing key 'nb' in error['message'].")
-        return v

okdata-aws-2.2.0/tests/test_logging.py

@@ -1,318 +0,0 @@
-import json
-import os
-from time import sleep
-
-from okdata.aws.logging import hide_suffix, log_duration, log_dynamodb, logging_wrapper
-
-empty_event = {}
-empty_context = None
-
-
-def empty_handler(event, context):
-    return {}
-
-
-def ok_handler(event, context):
-    return {"statusCode": 200, "body": "OK"}
-
-
-def user_error_handler(event, context):
-    return {"statusCode": 400, "body": "Bad Request"}
-
-
-def server_error_handler(event, context):
-    return {"statusCode": 500, "body": "Internal Server Error"}
-
-
-def throwing_handler(event, context):
-    raise Exception("fail!")
-
-
-def timed_operation(raise_exception=False):
-    sleep(0.01)
-    if raise_exception:
-        raise Exception("fail!")
-    else:
-        return 201
-
-
-def timing_handler(event, context):
-    result = log_duration(timed_operation, "my_timer")
-    return {"statusCode": result}
-
-
-def throwing_timing_handler(event, context):
-    log_duration(lambda: timed_operation(raise_exception=True), "my_timer")
-
-
-def non_rest_handler(event, context):
-    return None
-
-
-class RequestContext:
-    def __init__(
-        self, function_name, function_version, aws_request_id, memory_limit_in_mb
-    ):
-        self.function_name = function_name
-        self.function_version = function_version
-        self.aws_request_id = aws_request_id
-        self.memory_limit_in_mb = memory_limit_in_mb
-
-
-def test_log_service_name_from_env(capsys):
-    os.environ["SERVICE_NAME"] = "my_other_service"
-
-    wrapper = logging_wrapper(empty_handler)
-    wrapper(empty_event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["service_name"] == "my_other_service"
-    assert log["handler_method"] == "empty_handler"
-    assert log["function_name"] == ""
-
-
-def test_log_empty_event_and_context(capsys):
-    decorator = logging_wrapper(service_name="my_service")
-    wrapper = decorator(empty_handler)
-    wrapper(empty_event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["service_name"] == "my_service"
-    assert log["handler_method"] == "empty_handler"
-    assert log["function_name"] == ""
-
-
-def test_log_none_headers(capsys):
-    decorator = logging_wrapper(service_name="my_service")
-    wrapper = decorator(empty_handler)
-    wrapper({"headers": None}, empty_context)
-
-
-def test_legacy_wrapper(capsys):
-    decorator = logging_wrapper("my_old_service")
-    wrapper = decorator(empty_handler)
-    wrapper(empty_event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["service_name"] == "my_old_service"
-    assert log["handler_method"] == "empty_handler"
-    assert log["function_name"] == ""
-
-
-def test_handler_name(capsys):
-    wrapper = logging_wrapper(empty_handler)
-
-    assert wrapper.__name__ == empty_handler.__name__
-
-
-def test_log_event_data(capsys):
-    wrapper = logging_wrapper(empty_handler)
-    event = {
-        "path": "my_path",
-        "pathParameters": {"my_path_param": "my_value"},
-        "requestContext": {
-            "accountId": "1234567890",
-            "stage": "my_stage",
-            "apiId": "my_api_id",
-            "domainName": "my_domain",
-            "identity": {"sourceIp": "1.2.3.4"},
-        },
-        "resource": "my_resource",
-        "httpMethod": "my_method",
-        "queryStringParameters": {
-            "my_query_param": "my_query_value",
-            "token": "secret-stuff",
-            "secretToken": "secret-stuff",
-        },
-    }
-    wrapper(event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["function_stage"] == "my_stage"
-    assert log["function_api_id"] == "my_api_id"
-    assert log["aws_account_id"] == "1234567890"
-    assert log["source_ip"] == "1.2.3.x"
-    assert log["request_domain_name"] == "my_domain"
-    assert log["request_resource"] == "my_resource"
-    assert log["request_path"] == "my_path"
-    assert log["request_method"] == "my_method"
-    assert log["request_path_parameters"] == {"my_path_param": "my_value"}
-    assert log["request_query_string_parameters"] == {
-        "my_query_param": "my_query_value"
-    }
-    assert event["queryStringParameters"] == {
-        "my_query_param": "my_query_value",
-        "token": "secret-stuff",
-        "secretToken": "secret-stuff",
-    }
-
-
-def test_log_headers(capsys):
-    wrapper = logging_wrapper(empty_handler)
-
-    event = {"headers": {"X-Amzn-Trace-Id": "my-trace-id"}}
-    wrapper(event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["aws_trace_id"] == "my-trace-id"
-
-
-def test_log_context(capsys):
-    wrapper = logging_wrapper(empty_handler)
-
-    context = RequestContext(
-        function_name="my_function",
-        function_version="my_function_version",
-        aws_request_id="my_request_id",
-        memory_limit_in_mb=1024,
-    )
-    wrapper(empty_event, context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["function_name"] == "my_function"
-    assert log["function_version"] == "my_function_version"
-    assert log["aws_request_id"] == "my_request_id"
-    assert log["memory_limit_in_mb"] == 1024
-
-
-def test_log_authenticated(capsys):
-    event = {"requestContext": {"authorizer": {"principalId": "abc123456"}}}
-    wrapper = logging_wrapper(ok_handler)
-    wrapper(event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["principal_id"] == "abc123xxx"
-    assert log["logged_in"] is True
-
-
-def test_log_unauthenticated(capsys):
-    wrapper = logging_wrapper(ok_handler)
-    wrapper(empty_event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["logged_in"] is False
-
-
-def test_log_response_ok(capsys):
-    wrapper = logging_wrapper(ok_handler)
-    wrapper(empty_event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["response_status_code"] == 200
-    assert "response_body" not in log
-    assert log["level"] == "info"
-
-
-def test_log_user_error(capsys):
-    wrapper = logging_wrapper(user_error_handler)
-    wrapper(empty_event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["response_status_code"] == 400
-    assert log["response_body"] == "Bad Request"
-    assert log["level"] == "info"
-
-
-def test_log_server_error(capsys):
-    wrapper = logging_wrapper(server_error_handler)
-    wrapper(empty_event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["response_status_code"] == 500
-    assert log["response_body"] == "Internal Server Error"
-    assert log["level"] == "error"
-
-
-def test_log_exception(capsys):
-    wrapper = logging_wrapper(throwing_handler)
-    try:
-        wrapper(empty_event, empty_context)
-        assert False
-    except Exception:
-        pass
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["level"] == "error"
-    assert "Exception: fail!" in log["exception"]
-
-
-def test_log_duration(capsys):
-    wrapper = logging_wrapper(timing_handler)
-    wrapper(empty_event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["my_timer"] > 10.0
-    assert log["response_status_code"] == 201
-
-
-def test_log_duration_exception(capsys):
-    wrapper = logging_wrapper(throwing_timing_handler)
-    try:
-        wrapper(empty_event, empty_context)
-        assert False
-    except Exception:
-        pass
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["my_timer"] > 10.0
-    assert log["level"] == "error"
-    assert "Exception: fail!" in log["exception"]
-
-
-def test_log_non_rest_response(capsys):
-    wrapper = logging_wrapper(non_rest_handler)
-    wrapper(empty_event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["level"] == "info"
-
-
-def test_hide_suffix():
-    username = "jon-blund"
-
-    assert hide_suffix(username) == "jon-blxxx"
-    assert hide_suffix(username, 5) == "jon-xxxxx"
-    assert hide_suffix(username, 20) == "xxxxxxxxx"
-
-
-def dynamodb_handler(event, context):
-    dynamodb_response = {"ResponseMetadata": {"HTTPStatusCode": 200}}
-    if "Count" in event:
-        dynamodb_response["Count"] = event["Count"]
-
-    log_dynamodb(lambda: dynamodb_response)
-
-
-def test_log_dynamodb(capsys):
-    wrapper = logging_wrapper(dynamodb_handler)
-    wrapper(empty_event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert "dynamodb_duration_ms" in log
-    assert log["dynamodb_status_code"] == 200
-
-
-def test_log_dynamodb_item_count(capsys):
-    event = {"Count": 123}
-    wrapper = logging_wrapper(dynamodb_handler)
-    wrapper(event, empty_context)
-
-    log = json.loads(capsys.readouterr().out)
-
-    assert log["dynamodb_item_count"] == 123

okdata-aws-2.2.0/tests/test_model.py

@@ -1,29 +0,0 @@
-import pytest
-from pydantic.error_wrappers import ValidationError
-
-from okdata.aws.status.model import StatusData
-
-OK_ERROR = {"message": {"nb": "Det er et problem", "en": "There is a problem"}}
-
-
-class TestStatusData:
-    def test_errors_entry_valid(self):
-        params = {"errors": [OK_ERROR, OK_ERROR]}
-        result = StatusData(**params)
-        assert isinstance(result, StatusData)
-        assert result.errors[0] == OK_ERROR
-
-    def test_errors_entry_not_dict(self):
-        params = {"errors": [OK_ERROR, "This is string, not a dict."]}
-        with pytest.raises(ValidationError):
-            StatusData(**params)
-
-    def test_errors_entry_no_message(self):
-        params = {"errors": [OK_ERROR, {"Bad key": {}}]}
-        with pytest.raises(ValueError):
-            StatusData(**params)
-
-    def test_errors_entry_no_nb(self):
-        params = {"errors": [OK_ERROR, {"message": {"Bad key": "foo", "en": "bar"}}]}
-        with pytest.raises(ValueError):
-            StatusData(**params)

okdata-aws-2.2.0/tests/test_status.py

@@ -1,131 +0,0 @@
-import re
-from copy import deepcopy
-from unittest.mock import patch
-
-import pytest
-from freezegun import freeze_time
-from okdata.sdk.config import Config
-
-from okdata.aws.status.model import StatusData, TraceStatus, TraceEventStatus
-from okdata.aws.status.sdk import Status
-from okdata.aws.status.wrapper import _status_from_lambda_context
-
-
-utc_now = "2020-10-10T08:55:01+00:00"
-trace_id = "my-trace-id"
-mock_token_response = {
-    "access_token": "access",
-    "refresh_token": "refresh",
-    "token_type": "bearer",
-}
-mock_status_data = {
-    "trace_id": trace_id,
-    "trace_status": "CONTINUE",
-    "trace_event_status": "OK",
-    "domain": "dataset",
-    "domain_id": "my-dataset/1",
-    "status_body": None,
-    "user": "someuser",
-    "component": "system32",
-}
-mock_status_response = {"trace_id": trace_id}
-
-
-class MockLambdaContext:
-    function_name = "my_lambda_function"
-    function_version = 123
-
-
-@pytest.fixture(scope="function")
-def mock_openid(requests_mock):
-    openid_matcher = re.compile("openid-connect")
-    requests_mock.register_uri(
-        "POST",
-        openid_matcher,
-        json=mock_token_response,
-        status_code=200,
-    )
-
-
-@pytest.fixture(scope="function")
-def mock_status_api(requests_mock):
-    matcher = re.compile("mock-status-api")
-    requests_mock.register_uri(
-        "POST", matcher, json=mock_status_response, status_code=200
-    )
-
-
-class TestStatusClass:
-    def test_status_data_from_trace_id(self):
-        s = Status(trace_id)
-        assert s.status_data.trace_id == trace_id
-
-    def test_status_data_from_dict(self):
-        s = Status(mock_status_data)
-        assert s.status_data.trace_id == trace_id
-
-    def test_status_data_from_object(self):
-        status_data = StatusData.parse_obj(mock_status_data)
-        s = Status(status_data)
-        assert s.status_data.trace_id == trace_id
-
-    def test_status_with_sdk_config(self):
-        config = Config(config={"foo": "bar"})
-        # Mock out the `Authenticate` class so that the SDK doesn't try to set
-        # up authentication with a malformed config.
-        with patch("okdata.sdk.sdk.Authenticate"):
-            s = Status(trace_id, config)
-        assert s._sdk.config.config == {"foo": "bar"}
-
-    def test_status_data_from_lambda(self):
-        lambda_context = MockLambdaContext()
-        s = _status_from_lambda_context(
-            event={
-                "requestContext": {"authorizer": {"principalId": "someuser"}},
-                "execution_name": trace_id,
-            },
-            context=lambda_context,
-        )
-        assert s.trace_id == trace_id
-        assert s.meta.function_name == lambda_context.function_name
-        assert s.user == "someuser"
-
-    @freeze_time(utc_now)
-    def test_status_done(self, requests_mock, mock_openid, mock_status_api):
-        requests_mock.register_uri("POST", f"/status-api/status/{trace_id}", json={})
-        s = Status(StatusData.parse_obj(mock_status_data))
-        s.done()
-
-        last_request = requests_mock.last_request
-        assert last_request.method == "POST"
-        assert last_request.url.endswith(f"/status/{trace_id}")
-
-        payload = last_request.json()
-        assert payload["trace_id"] == trace_id
-        assert payload["start_time"] == utc_now
-        assert payload["end_time"] == utc_now
-        assert payload["domain"] == "dataset"
-        assert payload["domain_id"] == "my-dataset/1"
-        assert payload["user"] == "someuser"
-        assert payload["component"] == "system32"
-        assert payload["trace_status"] == TraceStatus.CONTINUE
-        assert payload["trace_event_status"] == TraceEventStatus.OK
-
-    def test_status_optional_fields(self):
-        status_data = deepcopy(mock_status_data)
-        status_data["domain_id"] = None
-        status_data["user"] = None
-        s = StatusData.parse_obj(status_data)
-        assert s.domain_id is None
-        assert s.user is None
-
-        status_data.pop("domain_id")
-        status_data.pop("user")
-        s = StatusData.parse_obj(status_data)
-        assert s.domain_id is None
-        assert s.user is None
-
-    def test_add_status_data_payload(self, mock_openid, mock_status_api):
-        s = Status(mock_status_data)
-        s.add(domain_id="my-domain-id")
-        assert s.status_data.domain_id == "my-domain-id"