aws-python-helper 1.9.0__tar.gz → 1.9.2__tar.gz

{aws_python_helper-1.9.0 → aws_python_helper-1.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-python-helper
-Version: 1.9.0
+Version: 1.9.2
 Summary: AWS Python Helper Framework
 Author-email: Fabian Claros <neufabiae@gmail.com>
 License-Expression: MIT

{aws_python_helper-1.9.0 → aws_python_helper-1.9.2}/aws_python_helper/repository/audit.py

@@ -124,6 +124,23 @@ def _merge_into_set(update: Dict[str, Any], values: Dict[str, Any], operator: st
         section.setdefault(key, value)
 
 
+def _written_elsewhere(update: Dict[str, Any], key: str, operator: str) -> bool:
+    """Si otro operador de esta misma actualización ya escribe ese campo.
+
+    Mongo rechaza el update entero si dos operadores tocan la misma ruta —
+    `$set: {status}` junto a `$setOnInsert: {status}` da "would create a
+    conflict at 'status'" — y el sello no tiene por qué ser el que lo provoque.
+    Si el llamador ya escribe el campo, el insert va a quedar con su valor, así
+    que el sello ahí sobra.
+    """
+    for other, section in update.items():
+        if other == operator or not other.startswith('$') or not isinstance(section, dict):
+            continue
+        if key in section:
+            return True
+    return False
+
+
 def stamp_update(
     update: Union[Dict[str, Any], List[Dict[str, Any]]],
     upsert: bool = False,
@@ -164,6 +181,11 @@ def stamp_update(
         born = {CREATED_AT: now, CREATED_BY: who}
         if statuses:
             born[STATUS] = default_status or statuses[0]
+        born = {
+            key: value
+            for key, value in born.items()
+            if not _written_elsewhere(update, key, '$setOnInsert')
+        }
         _merge_into_set(update, born, '$setOnInsert')
     return update
 

{aws_python_helper-1.9.0 → aws_python_helper-1.9.2}/aws_python_helper/sns/publisher.py

@@ -276,13 +276,18 @@ class SNSPublisher(ABC):
         
         return formatted
     
-    def _format_message(self, message: Dict[str, Any], index: int) -> Dict[str, Any]:
+    def _format_message(
+        self, message: Dict[str, Any], index: Optional[int] = None
+    ) -> Dict[str, Any]:
         """
         Formats the message for SNS
-        
+
         Args:
             message: Message to format
-        
+            index: Position inside a batch. `publish_batch` needs an `Id` per
+                entry; plain `publish` does not take one at all, so a single
+                message leaves it out.
+
         Returns:
             Formatted message
         """
@@ -305,10 +310,9 @@ class SNSPublisher(ABC):
                 session_json = self._serialize_message(session_dict)
                 attributes['session'] = base64.b64encode(session_json.encode('utf-8')).decode('utf-8')
 
-        params = {
-            'Id': str(index),
-            'Message': content
-        }
+        params: Dict[str, Any] = {'Message': content}
+        if index is not None:
+            params['Id'] = str(index)
         
         # Add subject if exists
         if subject:

{aws_python_helper-1.9.0 → aws_python_helper-1.9.2}/aws_python_helper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-python-helper
-Version: 1.9.0
+Version: 1.9.2
 Summary: AWS Python Helper Framework
 Author-email: Fabian Claros <neufabiae@gmail.com>
 License-Expression: MIT

{aws_python_helper-1.9.0 → aws_python_helper-1.9.2}/aws_python_helper.egg-info/SOURCES.txt

@@ -55,4 +55,6 @@ aws_python_helper/sqs/handler.py
 aws_python_helper/utils/__init__.py
 aws_python_helper/utils/json_encoder.py
 aws_python_helper/utils/response.py
-aws_python_helper/utils/serializer.py
+aws_python_helper/utils/serializer.py
+tests/test_audit_stamp.py
+tests/test_sns_publisher.py

{aws_python_helper-1.9.0 → aws_python_helper-1.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aws-python-helper"
-version = "1.9.0"
+version = "1.9.2"
 description = "AWS Python Helper Framework"
 readme = "README.md"
 requires-python = ">=3.9"

aws_python_helper-1.9.2/tests/test_audit_stamp.py

@@ -0,0 +1,88 @@
+"""What the audit stamp must never do to a write.
+
+Runs on its own, no dependencies:
+
+    python tests/test_audit_stamp.py
+
+These are here because the stamp broke a write in production once: an upsert
+that set `status` itself collided with the `$setOnInsert` the stamp added, and
+Mongo refused the whole update with "would create a conflict at 'status'". It
+failed at runtime, on one endpoint, in a log nobody was reading.
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from aws_python_helper.repository.audit import stamp_update  # noqa: E402
+
+STATUSES = ["active", "inactive"]
+
+failures = []
+
+
+def check(label, condition, detail=""):
+    mark = "ok  " if condition else "FAIL"
+    print(f"  {mark} {label}{'  ' + detail if detail else ''}")
+    if not condition:
+        failures.append(label)
+
+
+def conflicts(update):
+    """Los campos que dos operadores de un mismo update escriben a la vez.
+
+    Es lo que Mongo rechaza, y rechaza el update entero: no escribe nada.
+    """
+    sections = [
+        (name, section) for name, section in update.items()
+        if name.startswith("$") and isinstance(section, dict)
+    ]
+    clash = set()
+    for index, (_, first) in enumerate(sections):
+        for _, second in sections[index + 1:]:
+            clash |= set(first) & set(second)
+    return clash
+
+
+print("no two operators may write the same path")
+for label, update in [
+    ("upsert that sets status itself", {"$set": {"name": "ct", "status": "active"}}),
+    ("upsert that sets created_at itself", {"$set": {"created_at": "fixed"}}),
+    ("upsert that sets created_by itself", {"$set": {"created_by": {"name": "x"}}}),
+    ("plain upsert", {"$set": {"name": "ct"}}),
+    ("upsert with $inc alongside", {"$set": {"name": "ct"}, "$inc": {"hits": 1}}),
+]:
+    result = stamp_update(dict(update), upsert=True, statuses=STATUSES, default_status="active")
+    found = conflicts(result)
+    check(label, not found, f"conflicts={sorted(found)}" if found else "")
+
+print("\nthe stamp is still complete when nothing conflicts")
+result = stamp_update({"$set": {"name": "ct"}}, upsert=True, statuses=STATUSES, default_status="active")
+check("status on insert", result["$setOnInsert"].get("status") == "active")
+check("created_at on insert", "created_at" in result["$setOnInsert"])
+check("created_by on insert", "created_by" in result["$setOnInsert"])
+check("updated_at always", "updated_at" in result["$set"])
+
+print("\nthe caller's own value wins")
+result = stamp_update({"$set": {"status": "inactive"}}, upsert=True, statuses=STATUSES, default_status="active")
+check("status stays what the caller set", result["$set"]["status"] == "inactive")
+check("no default forced on top", "status" not in result.get("$setOnInsert", {}))
+
+print("\nwithout upsert there is no insert stamp")
+result = stamp_update({"$set": {"status": "inactive"}}, upsert=False, statuses=STATUSES)
+check("no $setOnInsert", "$setOnInsert" not in result)
+
+print("\nwithout a vocabulary no status is invented")
+result = stamp_update({"$set": {"name": "ct"}}, upsert=True, statuses=None)
+check("no status", "status" not in result.get("$setOnInsert", {}))
+
+print("\na pipeline update takes stages, not operators")
+result = stamp_update([{"$set": {"name": "ct"}}], upsert=True, statuses=STATUSES)
+check("still a list", isinstance(result, list))
+check("stamp appended last", result[-1]["$set"].get("updated_at") is not None)
+
+if failures:
+    print(f"\n{len(failures)} failed: {failures}")
+    raise SystemExit(1)
+print("\nall good")

aws_python_helper-1.9.2/tests/test_sns_publisher.py

@@ -0,0 +1,125 @@
+"""What the publisher must hand to boto3.
+
+Runs on its own, no dependencies:
+
+    python tests/test_sns_publisher.py
+
+These exist because a single publish crashed in production with
+`_format_message() missing 1 required positional argument: 'index'`. Every test
+until then mocked `publish` itself, so the code that builds the boto3 call was
+never executed — the mock was above the bug.
+
+So here the fake is the **boto3 client**, not the publisher: everything the
+publisher actually does runs.
+"""
+
+import asyncio
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from aws_python_helper.sns.publisher import MAX_BATCH_ENTRIES, SNSPublisher  # noqa: E402
+
+failures = []
+
+
+def check(label, condition, detail=""):
+    print(f"  {'ok  ' if condition else 'FAIL'} {label}{'  ' + detail if detail else ''}")
+    if not condition:
+        failures.append(label)
+
+
+class FakeSNS:
+    """Se queja igual que boto3 ante un parámetro que SNS no acepta."""
+
+    VALID_PUBLISH = {"TopicArn", "Message", "Subject", "MessageAttributes",
+                     "MessageStructure", "MessageDeduplicationId", "MessageGroupId"}
+
+    def __init__(self):
+        self.published = []
+        self.batches = []
+
+    def publish(self, **kwargs):
+        extra = set(kwargs) - self.VALID_PUBLISH
+        if extra:
+            raise TypeError(f"Unknown parameter in input: {sorted(extra)}")
+        self.published.append(kwargs)
+        return {"MessageId": f"m{len(self.published)}"}
+
+    def publish_batch(self, TopicArn, PublishBatchRequestEntries):
+        if len(PublishBatchRequestEntries) > MAX_BATCH_ENTRIES:
+            raise Exception("TooManyEntriesInBatchRequest")
+        for entry in PublishBatchRequestEntries:
+            if "Id" not in entry:
+                raise Exception("An entry in a batch needs an Id")
+        self.batches.append(PublishBatchRequestEntries)
+        return {"Successful": [{"MessageId": f"b{i}"} for i in range(len(PublishBatchRequestEntries))],
+                "Failed": []}
+
+
+class Publisher(SNSPublisher):
+    pass
+
+
+def publisher():
+    p = Publisher("arn:aws:sns:us-east-2:1:Topic-dev")
+    p._sns_client = FakeSNS()
+    return p
+
+
+async def main():
+    print("a single message")
+    p = publisher()
+    result = await p.publish({"content": {"run_id": "abc", "status": "launched"}})
+    sent = p._sns_client.published[0]
+    check("it publishes", len(p._sns_client.published) == 1)
+    check("no Id, which publish does not accept", "Id" not in sent)
+    check("the body travels", json.loads(sent["Message"])["run_id"] == "abc")
+    check("returns the message id", result == "m1")
+
+    print("\na single message with attributes and subject")
+    p = publisher()
+    await p.publish({
+        "content": {"x": 1},
+        "attributes": {"service": "business"},
+        "subject": "hello",
+    })
+    sent = p._sns_client.published[0]
+    check("subject", sent.get("Subject") == "hello")
+    check("attributes", "MessageAttributes" in sent)
+
+    print("\na batch")
+    p = publisher()
+    ok, failed = await p.publish([{"content": {"n": i}} for i in range(188)])
+    check("split into tens", len(p._sns_client.batches) == 19,
+          f"batches={len(p._sns_client.batches)}")
+    check("none over the limit", all(len(b) <= MAX_BATCH_ENTRIES for b in p._sns_client.batches))
+    check("every entry has an Id", all("Id" in e for b in p._sns_client.batches for e in b))
+    check("ids unique inside each call",
+          all(len({e["Id"] for e in b}) == len(b) for b in p._sns_client.batches))
+    check("all reported published", len(ok) == 188 and not failed)
+
+    print("\na batch of one still goes as a batch")
+    p = publisher()
+    await p.publish([{"content": {"n": 1}}])
+    check("one call", len(p._sns_client.batches) == 1)
+    check("nothing through publish()", not p._sns_client.published)
+
+    print("\na message with no content is refused, not sent")
+    p = publisher()
+    try:
+        await p.publish({"attributes": {"service": "business"}})
+        check("raises", False)
+    except ValueError:
+        check("raises", True)
+    check("nothing published", not p._sns_client.published)
+
+
+asyncio.run(main())
+
+if failures:
+    print(f"\n{len(failures)} failed: {failures}")
+    raise SystemExit(1)
+print("\nall good")