feat(models): add ActorEndpoints and expand model test coverage

  This commit introduces the ActorEndpoints model, integrating it into
  the system's initial model rebuild process.

  Extensive new test suites have been added to enhance coverage and
  validate the functionality of several models, including:
   - Actor and its various subtypes
   - CryptographicKey, covering PEM and multibase key handling
   - DataIntegrityProof, including datetime conversions and
     serialization
   - Multikey, with multibase encoding/decoding for public and private
     keys
   - Question, validating fields like oneOf, anyOf, and closed
   - Tombstone, verifying formerType and deleted fields
   - ActivityPubModel, testing base class features and context
     aggregation
   - Core key utility functions for multibase encoding/decoding

  Additionally, the datetime serialization in the Question model has
  been updated to consistently use the 'Z' suffix for UTC offsets,
  ensuring standard compliance and predictability. This also includes
  validation for the recently adjusted @context serialization behavior.

Author: AmaseCocoa

src/apmodel/_core/_initial/_rebuild.py

@@ -62,6 +62,7 @@
 from ...vocab.activity.view import View  # noqa: F401
 from ...vocab.actor import (  # noqa: F401
     Actor,
+    ActorEndpoints,
     Application,
     Group,
     Organization,
@@ -87,6 +88,7 @@
     OrderedCollectionPage,
     # Actors
     Actor,
+    ActorEndpoints,
     Application,
     Group,
     Organization,

src/apmodel/vocab/activity/question.py

@@ -53,6 +53,6 @@ def validate_closed(
     @field_serializer("closed", when_used="always")
     def serialize_closed(self, value: Any, _) -> str | bool | Any:
         if isinstance(value, datetime.datetime):
-            return value.isoformat(timespec="seconds")
+            return value.isoformat(timespec="seconds").replace('+00:00', 'Z')
 
         return value

tests/test_actor.py

@@ -0,0 +1,111 @@
+from apmodel.vocab.actor import Actor, Person, Application, Group, Organization, Service, ActorEndpoints
+from apmodel.core.collection import OrderedCollection
+
+
+def test_actor_creation():
+    # Test creating an Actor instance
+    actor = Actor(
+        id="https://example.com/actor/1",
+        name="Test Actor"
+    )
+
+    assert actor.id == "https://example.com/actor/1"
+    assert actor.name == "Test Actor"
+
+
+def test_actor_subtypes():
+    # Test creating different actor subtypes
+    person = Person(id="https://example.com/person/1", name="Test Person")
+    application = Application(id="https://example.com/app/1", name="Test App")
+    group = Group(id="https://example.com/group/1", name="Test Group")
+    organization = Organization(id="https://example.com/org/1", name="Test Org")
+    service = Service(id="https://example.com/service/1", name="Test Service")
+
+    assert person.type == "Person"
+    assert application.type == "Application"
+    assert group.type == "Group"
+    assert organization.type == "Organization"
+    assert service.type == "Service"
+
+
+def test_actor_with_collections():
+    # Test creating an Actor with collection fields
+    actor = Actor(
+        id="https://example.com/actor/1",
+        name="Test Actor",
+        inbox="https://example.com/actor/1/inbox",
+        outbox="https://example.com/actor/1/outbox",
+        followers="https://example.com/actor/1/followers"
+    )
+
+    assert actor.id == "https://example.com/actor/1"
+    assert actor.name == "Test Actor"
+    assert actor.inbox == "https://example.com/actor/1/inbox"
+    assert actor.outbox == "https://example.com/actor/1/outbox"
+    assert actor.followers == "https://example.com/actor/1/followers"
+
+
+def test_actor_with_ordered_collections():
+    # Test creating an Actor with OrderedCollection fields
+    inbox_collection = OrderedCollection(id="https://example.com/actor/1/inbox")
+    actor = Actor(
+        id="https://example.com/actor/1",
+        name="Test Actor",
+        inbox=inbox_collection
+    )
+
+    assert actor.id == "https://example.com/actor/1"
+    assert actor.name == "Test Actor"
+    assert actor.inbox is not None
+    assert hasattr(actor.inbox, 'id')
+
+
+def test_actor_with_additional_properties():
+    # Test creating an Actor with additional properties
+    actor = Actor(
+        id="https://example.com/actor/1",
+        name="Test Actor",
+        preferred_username="testuser",
+        discoverable=True,
+        indexable=False
+    )
+
+    assert actor.id == "https://example.com/actor/1"
+    assert actor.name == "Test Actor"
+    assert actor.preferred_username == "testuser"
+    assert actor.discoverable is True
+    assert actor.indexable is False
+
+
+def test_actor_serialization():
+    # Test serialization of an Actor
+    actor = Actor(
+        id="https://example.com/actor/1",
+        name="Test Actor",
+        preferred_username="testuser",
+        inbox="https://example.com/actor/1/inbox"
+    )
+
+    serialized = actor.model_dump(by_alias=True)
+
+    assert serialized["id"] == "https://example.com/actor/1"
+    assert serialized["name"] == "Test Actor"
+    assert serialized["preferredUsername"] == "testuser"
+    assert serialized["inbox"] == "https://example.com/actor/1/inbox"
+
+
+def test_actor_context_inference():
+    # Test that actor context inference works properly
+    actor = Actor(
+        id="https://example.com/actor/1",
+        name="Test Actor",
+        public_key=None  # This should not trigger security context
+    )
+
+    # Call the _inference_context method to ensure it works
+    result = {"id": "https://example.com/actor/1", "name": "Test Actor"}
+    inferred_result = actor._inference_context(result)
+
+    # The result should have the basic context
+    assert "@context" in inferred_result
+    assert "https://www.w3.org/ns/activitystreams" in inferred_result["@context"]

tests/test_cryptographickey.py

@@ -0,0 +1,184 @@
+import pytest
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+from apmodel.extra.security import CryptographicKey
+
+
+def test_cryptographic_key_creation():
+    # Test creating a CryptographicKey instance
+    key = CryptographicKey(
+        id="did:example:123#key-1",
+        owner="did:example:123"
+    )
+    
+    assert key.id == "did:example:123#key-1"
+    assert key.owner == "did:example:123"
+    assert key.type == "CryptographicKey"
+
+
+def test_cryptographic_key_public_key_property_with_pem_string():
+    # Generate an RSA key pair for testing
+    private_key = rsa.generate_private_key(
+        public_exponent=65537,
+        key_size=2048,
+    )
+    public_key = private_key.public_key()
+    
+    # Get the PEM representation of the public key
+    public_pem = public_key.public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    ).decode("utf-8")
+    
+    # Create a CryptographicKey instance
+    key = CryptographicKey(
+        id="did:example:123#key-1",
+        owner="did:example:123",
+        public_key_pem=public_pem
+    )
+    
+    # Access the public key property
+    retrieved_public_key = key.public_key
+    
+    assert retrieved_public_key is not None
+    assert isinstance(retrieved_public_key, rsa.RSAPublicKey)
+
+
+def test_cryptographic_key_public_key_property_with_pem_bytes():
+    # Generate an RSA key pair for testing
+    private_key = rsa.generate_private_key(
+        public_exponent=65537,
+        key_size=2048,
+    )
+    public_key = private_key.public_key()
+    
+    # Get the PEM representation of the public key as bytes
+    public_pem_bytes = public_key.public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    )
+    
+    # Create a CryptographicKey instance
+    key = CryptographicKey(
+        id="did:example:123#key-1",
+        owner="did:example:123",
+        public_key_pem=public_pem_bytes
+    )
+    
+    # Access the public key property
+    retrieved_public_key = key.public_key
+    
+    assert retrieved_public_key is not None
+    assert isinstance(retrieved_public_key, rsa.RSAPublicKey)
+
+
+def test_cryptographic_key_public_key_property_with_no_pem():
+    # Create a CryptographicKey instance without public key PEM
+    key = CryptographicKey(
+        id="did:example:123#key-1",
+        owner="did:example:123"
+    )
+    
+    # Access the public key property
+    retrieved_public_key = key.public_key
+    
+    assert retrieved_public_key is None
+
+
+def test_cryptographic_key_set_public_key_with_rsa_public_key():
+    # Generate an RSA key pair for testing
+    private_key = rsa.generate_private_key(
+        public_exponent=65537,
+        key_size=2048,
+    )
+    public_key = private_key.public_key()
+    
+    # Create a CryptographicKey instance
+    key = CryptographicKey(
+        id="did:example:123#key-1",
+        owner="did:example:123"
+    )
+    
+    # Set the public key
+    key.set_public_key = public_key
+    
+    # Check that the PEM representation was set
+    assert key.public_key_pem is not None
+    assert isinstance(key.public_key_pem, str)
+    
+    # Check that the public key property returns the correct key
+    retrieved_key = key.public_key
+    assert retrieved_key is not None
+    assert isinstance(retrieved_key, rsa.RSAPublicKey)
+
+
+def test_cryptographic_key_set_public_key_with_rsa_private_key():
+    # Generate an RSA key pair for testing
+    private_key = rsa.generate_private_key(
+        public_exponent=65537,
+        key_size=2048,
+    )
+    
+    # Create a CryptographicKey instance
+    key = CryptographicKey(
+        id="did:example:123#key-1",
+        owner="did:example:123"
+    )
+    
+    # Set the public key using the private key (should extract the public key)
+    key.set_public_key = private_key
+    
+    # Check that the PEM representation was set
+    assert key.public_key_pem is not None
+    assert isinstance(key.public_key_pem, str)
+    
+    # Check that the public key property returns the correct key
+    retrieved_key = key.public_key
+    assert retrieved_key is not None
+    assert isinstance(retrieved_key, rsa.RSAPublicKey)
+
+
+def test_cryptographic_key_invalid_key_type():
+    # Test with an invalid key type that is not RSA
+    class InvalidKeyType:
+        pass
+    
+    key = CryptographicKey(
+        id="did:example:123#key-1",
+        owner="did:example:123",
+        public_key_pem="invalid pem data"
+    )
+    
+    # This should raise a ValueError when accessing public_key
+    with pytest.raises(ValueError):
+        _ = key.public_key
+
+
+def test_cryptographic_key_serialization():
+    # Generate an RSA key pair for testing
+    private_key = rsa.generate_private_key(
+        public_exponent=65537,
+        key_size=2048,
+    )
+    public_key = private_key.public_key()
+    
+    # Get the PEM representation of the public key
+    public_pem = public_key.public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    ).decode("utf-8")
+    
+    # Create a CryptographicKey instance
+    key = CryptographicKey(
+        id="did:example:123#key-1",
+        owner="did:example:123",
+        public_key_pem=public_pem
+    )
+    
+    # Check serialization
+    serialized = key.model_dump(by_alias=True)
+    assert serialized["id"] == "did:example:123#key-1"
+    assert serialized["owner"] == "did:example:123"
+    assert "publicKeyPem" in serialized
+    assert serialized["type"] == "CryptographicKey"