Address Copilot comments

Signed-off-by: Sergio Herrera <627709+seherv@users.noreply.github.com>

Author: seherv

tests/examples/test_crypto.py

@@ -16,7 +16,7 @@
 
 
 @pytest.fixture()
-def crypto_artifacts():
+def cleanup_crypto_outputs():
     """Clean up output files written by the crypto example on teardown.
 
     Example RSA and AES keys are in ``examples/crypto/keys/``.
@@ -27,7 +27,7 @@ def crypto_artifacts():
 
 
 @pytest.mark.example_dir('crypto')
-def test_crypto(dapr, crypto_artifacts):
+def test_crypto(dapr, cleanup_crypto_outputs):
     output = dapr.run(
         '--app-id crypto --resources-path ./components/ -- python3 crypto.py',
         timeout=30,
@@ -38,7 +38,7 @@ def test_crypto(dapr, crypto_artifacts):
 
 
 @pytest.mark.example_dir('crypto')
-def test_crypto_async(dapr, crypto_artifacts):
+def test_crypto_async(dapr, cleanup_crypto_outputs):
     output = dapr.run(
         '--app-id crypto-async --resources-path ./components/ -- python3 crypto-async.py',
         timeout=30,

tests/integration/AGENTS.md

@@ -27,12 +27,12 @@ tox -e integration -- test_state_store.py -k test_save_and_get
 
 ```
 tests/integration/
-├── conftest.py              # DaprTestEnvironment + fixtures (dapr_env, apps_dir, components_dir)
+├── conftest.py              # DaprTestEnvironment + fixtures (dapr_env, apps_dir, resources_dir, crypto_keys)
 ├── test_*.py                # Test files (one per building block)
 ├── apps/                    # Helper apps started alongside sidecars
 │   ├── invoke_receiver.py   # gRPC method handler for invoke tests
 │   └── pubsub_subscriber.py # Subscriber that persists messages to state store
-├── components/              # Dapr component YAMLs loaded by all sidecars
+├── resources/               # Dapr component YAMLs loaded by all sidecars
 │   ├── statestore.yaml      # state.redis (also configured as actor state store)
 │   ├── pubsub.yaml          # pubsub.redis
 │   ├── lockstore.yaml       # lock.redis
@@ -41,7 +41,7 @@ tests/integration/
 │   ├── localbinding.yaml    # bindings.localstorage (rootPath=./.binding-data)
 │   ├── cryptostore.yaml     # crypto.dapr.localstorage (path=./keys)
 │   └── conversation.yaml    # conversation.echo
-├── keys/                    # RSA + symmetric keys for cryptostore
+├── keys/                    # RSA + symmetric keys for cryptostore (generated at test time, gitignored)
 ├── secrets.json             # Secrets file for localsecretstore component
 └── .binding-data/           # Created on demand for localbinding rootPath (gitignored)
 ```
@@ -54,15 +54,22 @@ Sidecar and client fixtures are **module-scoped** — one sidecar per test file.
 |---------|-------|------|-------------|
 | `dapr_env` | module | `DaprTestEnvironment` | Manages sidecar lifecycle; call `start_sidecar()` to get a client |
 | `apps_dir` | module | `Path` | Path to `tests/integration/apps/` |
-| `components_dir` | module | `Path` | Path to `tests/integration/components/` |
-| `wait_until` | session | `Callable` | Polling helper `(predicate, timeout=10, interval=0.1)` for eventual-consistency assertions |
-| `wait_until_async` | session | `Callable` | Async counterpart of `wait_until` for awaitable predicates |
+| `resources_dir` | module | `Path` | Path to `tests/integration/resources/` |
+| `crypto_keys` | session | `Path` | Generates ephemeral RSA + AES keys under `tests/integration/keys/` for the cryptostore component (see `tests/crypto_utils.py`) |
 | `flush_redis` | session | `None` | Side-effect fixture that clears the `dapr_redis` container once per session |
-| `redis_set` | session | `Callable` | Returns `set(key, value, version=1)` that seeds a Dapr configuration value into Redis (`value||version`) |
+| `redis_set_config` | session | `Callable` | Returns `_set(key, value, version=1)` that seeds a Dapr configuration value into Redis (`value||version`) |
 
-All four are session-scoped (defined in `tests/conftest.py`) so that module-scoped fixtures can depend on them.
+`flush_redis` and `redis_set_config` are session-scoped (defined in `tests/conftest.py`) so module-scoped fixtures can depend on them.
 
-Each test file defines its own module-scoped `client` fixture that calls `dapr_env.start_sidecar(...)`.
+Polling helpers are **plain functions**, not fixtures — import them directly:
+
+```python
+from tests.wait_utils import wait_until, wait_until_async
+```
+
+Both have signature `(condition, timeout=10.0, interval=0.1)` and raise `TimeoutError` if the deadline elapses. `wait_until_async` awaits an awaitable condition.
+
+Each test file defines its own module-scoped fixture (`client` or `sidecar`) that calls `dapr_env.start_sidecar(...)`.
 
 ## Building blocks covered
 
@@ -116,7 +123,7 @@ Some building blocks (invoke, pubsub) require an app process running alongside t
 
 1. Create `test_<building_block>.py`
 2. Add a module-scoped `client` fixture that calls `dapr_env.start_sidecar(app_id='test-<name>')`
-3. If the building block needs a new Dapr component, add a YAML to `components/`
+3. If the building block needs a new Dapr component, add a YAML to `resources/`
 4. If the building block needs a running app, add it to `apps/` and pass `app_cmd` / `app_port` to `start_sidecar()`
 5. Use unique keys/resource IDs per test to avoid interference (the sidecar is shared within a module)
 6. Assert on SDK return types and gRPC status codes, not on string output

tests/integration/test_conversation.py

@@ -0,0 +1,71 @@
+import pytest
+
+from dapr.clients.grpc.conversation import (
+    ConversationInput,
+    ConversationInputAlpha2,
+    create_assistant_message,
+    create_system_message,
+    create_user_message,
+)
+
+COMPONENT = 'echo'
+
+
+@pytest.fixture(scope='module')
+def client(dapr_env):
+    return dapr_env.start_sidecar(app_id='test-conversation')
+
+
+def test_converse_alpha1_echoes_input(client):
+    response = client.converse_alpha1(
+        name=COMPONENT,
+        inputs=[ConversationInput(content='sync hello', role='user')],
+    )
+    assert response.outputs[0].result == 'sync hello'
+
+
+def test_converse_alpha1_with_multiple_inputs(client):
+    response = client.converse_alpha1(
+        name=COMPONENT,
+        inputs=[
+            ConversationInput(content='one', role='user'),
+            ConversationInput(content='two', role='user'),
+        ],
+    )
+    results = [out.result for out in response.outputs]
+    # The echo component concatenates all inputs into a single newline-joined output
+    # rather than echoing each input individually.
+    assert results == ['one\ntwo']
+
+
+def test_converse_alpha1_with_temperature(client):
+    response = client.converse_alpha1(
+        name=COMPONENT,
+        inputs=[ConversationInput(content='warm', role='user')],
+        temperature=0.7,
+    )
+    assert response.outputs[0].result == 'warm'
+
+
+def test_converse_alpha2_echoes_user_message(client):
+    response = client.converse_alpha2(
+        name=COMPONENT,
+        inputs=[ConversationInputAlpha2(messages=[create_user_message('sync world')])],
+    )
+    assert response.outputs[0].choices[0].message.content == 'sync world'
+
+
+def test_converse_alpha2_with_mixed_messages(client):
+    response = client.converse_alpha2(
+        name=COMPONENT,
+        inputs=[
+            ConversationInputAlpha2(
+                messages=[
+                    create_system_message('be brief'),
+                    create_user_message('hi'),
+                    create_assistant_message('hello'),
+                ]
+            )
+        ],
+    )
+    assert response.outputs[0].choices[0].message.content

tests/integration/test_crypto.py

@@ -0,0 +1,96 @@
+import pytest
+
+from dapr.clients.grpc._crypto import DecryptOptions, EncryptOptions
+
+CRYPTO_COMPONENT = 'cryptostore'
+RSA_KEY = 'rsa-private-key.pem'
+SYMMETRIC_KEY = 'symmetric-key-256'
+
+# The crypto API re-emits the alpha warnings on every test run.
+pytestmark = pytest.mark.filterwarnings('ignore::UserWarning')
+
+
+@pytest.fixture(scope='module')
+def client(dapr_env, crypto_keys):
+    return dapr_env.start_sidecar(app_id='test-crypto')
+
+
+def test_rsa_round_trip(client):
+    plaintext = b'sync crypto secret'
+
+    encrypted_stream = client.encrypt(
+        data=plaintext,
+        options=EncryptOptions(
+            component_name=CRYPTO_COMPONENT,
+            key_name=RSA_KEY,
+            key_wrap_algorithm='RSA',
+        ),
+    )
+    encrypted = encrypted_stream.read()
+    assert encrypted != plaintext
+
+    decrypted_stream = client.decrypt(
+        data=encrypted,
+        options=DecryptOptions(component_name=CRYPTO_COMPONENT, key_name=RSA_KEY),
+    )
+    assert decrypted_stream.read() == plaintext
+
+
+def test_aes_round_trip(client):
+    plaintext = b'A' * (32 * 1024)
+
+    encrypted_stream = client.encrypt(
+        data=plaintext,
+        options=EncryptOptions(
+            component_name=CRYPTO_COMPONENT,
+            key_name=SYMMETRIC_KEY,
+            key_wrap_algorithm='AES',
+        ),
+    )
+    encrypted = encrypted_stream.read()
+
+    decrypted_stream = client.decrypt(
+        data=encrypted,
+        options=DecryptOptions(component_name=CRYPTO_COMPONENT, key_name=SYMMETRIC_KEY),
+    )
+    assert decrypted_stream.read() == plaintext
+
+
+def test_string_input_round_trip(client):
+    plaintext = 'hello dapr crypto'
+
+    encrypted_stream = client.encrypt(
+        data=plaintext,
+        options=EncryptOptions(
+            component_name=CRYPTO_COMPONENT,
+            key_name=RSA_KEY,
+            key_wrap_algorithm='RSA',
+        ),
+    )
+    encrypted = encrypted_stream.read()
+
+    decrypted_stream = client.decrypt(
+        data=encrypted,
+        options=DecryptOptions(component_name=CRYPTO_COMPONENT, key_name=RSA_KEY),
+    )
+    assert decrypted_stream.read().decode() == plaintext
+
+
+def test_encrypt_with_blank_component_raises(client):
+    with pytest.raises(ValueError):
+        client.encrypt(
+            data=b'payload',
+            options=EncryptOptions(
+                component_name='',
+                key_name=RSA_KEY,
+                key_wrap_algorithm='RSA',
+            ),
+        )
+
+
+def test_decrypt_with_blank_component_raises(client):
+    with pytest.raises(ValueError):
+        client.decrypt(
+            data=b'payload',
+            options=DecryptOptions(component_name='', key_name=RSA_KEY),
+        )

tests/integration/test_invoke_binding.py

@@ -0,0 +1,92 @@
+import uuid
+from pathlib import Path
+
+import pytest
+
+BINDING = 'localbinding'
+BINDING_ROOT = Path(__file__).resolve().parent / '.binding-data'
+
+
+@pytest.fixture(scope='module')
+def client(dapr_env):
+    return dapr_env.start_sidecar(app_id='test-invoke-binding')
+
+
+def test_create_writes_file_to_disk(client):
+    file_name = f'binding-{uuid.uuid4().hex[:8]}.txt'
+    payload = b'hello from sync invoke_binding'
+
+    client.invoke_binding(
+        binding_name=BINDING,
+        operation='create',
+        data=payload,
+        binding_metadata={'fileName': file_name},
+    )
+
+    assert (BINDING_ROOT / file_name).read_bytes() == payload
+
+
+def test_create_then_get_round_trip(client):
+    file_name = f'binding-{uuid.uuid4().hex[:8]}.txt'
+    payload = b'sync round-trip payload'
+
+    client.invoke_binding(
+        binding_name=BINDING,
+        operation='create',
+        data=payload,
+        binding_metadata={'fileName': file_name},
+    )
+    response = client.invoke_binding(
+        binding_name=BINDING,
+        operation='get',
+        binding_metadata={'fileName': file_name},
+    )
+
+    assert response.data == payload
+
+
+def test_create_with_string_payload(client):
+    file_name = f'binding-{uuid.uuid4().hex[:8]}.txt'
+    payload = 'sync string payload'
+
+    client.invoke_binding(
+        binding_name=BINDING,
+        operation='create',
+        data=payload,
+        binding_metadata={'fileName': file_name},
+    )
+
+    assert (BINDING_ROOT / file_name).read_text() == payload
+
+
+def test_delete_removes_file(client):
+    file_name = f'binding-{uuid.uuid4().hex[:8]}.txt'
+    file_path = BINDING_ROOT / file_name
+
+    client.invoke_binding(
+        binding_name=BINDING,
+        operation='create',
+        data=b'to be deleted',
+        binding_metadata={'fileName': file_name},
+    )
+    assert file_path.exists()
+
+    client.invoke_binding(
+        binding_name=BINDING,
+        operation='delete',
+        binding_metadata={'fileName': file_name},
+    )
+    assert not file_path.exists()
+
+
+def test_list_includes_created_file(client):
+    file_name = f'binding-{uuid.uuid4().hex[:8]}.txt'
+    client.invoke_binding(
+        binding_name=BINDING,
+        operation='create',
+        data=b'listed',
+        binding_metadata={'fileName': file_name},
+    )
+
+    response = client.invoke_binding(binding_name=BINDING, operation='list')
+    assert file_name in response.data.decode()