def test_publish_error(self):
dapr = DaprClient(f'localhost:{self.server_port}')
with self.assertRaisesRegex(ValueError, "invalid type for data <class 'int'>"):
dapr.publish_event(
pubsub_name='pubsub',
topic='example',
data=111,
)
def test_wait_timeout(self):
# First, pick an unused port
port = 0
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.bind(('', 0))
port = s.getsockname()[1]
dapr = DaprClient(f'localhost:{port}')
with self.assertRaises(Exception) as context:
dapr.wait(0.1)
self.assertTrue('Connection refused' in str(context.exception))
def test_publish_event(self):
dapr = DaprClient(f'localhost:{self.server_port}')
resp = dapr.publish_event(
pubsub_name='pubsub',
topic='example',
data=b'haha',
)
self.assertEqual(2, len(resp.headers))
self.assertEqual(['haha'], resp.headers['hdata'])
def test_invoke_binding_no_create(self):
dapr = DaprClient(f'localhost:{self.server_port}')
resp = dapr.invoke_binding(
name='binding',
operation='delete',
data=b'haha',
)
self.assertEqual(b'INVALID', resp.data)
self.assertEqual({}, resp.binding_metadata)
self.assertEqual(0, len(resp.headers))
def test_get_secret_metadata_absent(self):
dapr = DaprClient(f'localhost:{self.server_port}')
key1 = 'key_1'
resp = dapr.get_secret(
store_name='store_1',
key=key1,
)
self.assertEqual(1, len(resp.headers))
self.assertEqual([key1], resp.headers['keyh'])
self.assertEqual({key1: "val"}, resp._secret)
def test_invoke_binding_no_metadata(self):
dapr = DaprClient(f'localhost:{self.server_port}')
resp = dapr.invoke_binding(
name='binding',
operation='create',
data=b'haha',
)
self.assertEqual(b'haha', resp.content)
self.assertEqual({}, resp.metadata)
self.assertEqual(0, len(resp.headers))
self.assertEqual(0, len(resp.trailers))
def __init__(self, step_name):
load_dotenv()
self.state_code = os.environ.get("GITHUB_SHA",
self.__default_state_code)
if os.environ.get(
"GENERATE_SHA"
) is not None and self.state_code == self.__default_state_code:
self.state_code = uuid.uuid4().hex
os.environ['GITHUB_SHA'] = self.state_code
self.storename = os.environ.get("STATE_STORE_NAME",
self.__default_storename)
dapr_port = WorkflowContext.get_dapr_port()
self['dapr_port'] = dapr_port
self['dapr_app_port'] = int(dapr_port) + 1
self["dapr_address"] = f"localhost:{dapr_port}"
dict.__init__(self)
with DaprClient(address=self["dapr_address"]) as d:
kv = d.get_state(self.storename, self.state_code)
if kv.data == b"":
kv.data = "{}"
self.rehydrate(kv.data)
self.start_step(step_name)
print("==============================")
print(f"{step_name} Output ")
print("==============================")
def test_invoke_binding_bytes_data(self):
dapr = DaprClient(f'localhost:{self.server_port}')
resp = dapr.invoke_binding(
name='binding',
operation='create',
data=b'haha',
binding_metadata={
'key1': 'value1',
'key2': 'value2',
},
)
self.assertEqual(b'haha', resp.data)
self.assertEqual({'key1': 'value1', 'key2': 'value2'}, resp.binding_metadata)
self.assertEqual(2, len(resp.headers))
self.assertEqual(['value1'], resp.headers['hkey1'])
def test_invoke_service_bytes_data(self):
dapr = DaprClient(f'localhost:{self.server_port}')
resp = dapr.invoke_service(
id='targetId',
method='bytes',
data=b'haha',
content_type="text/plain",
metadata=(
('key1', 'value1'),
('key2', 'value2'),
),
)
self.assertEqual(b'haha', resp.data)
self.assertEqual("text/plain", resp.content_type)
self.assertEqual(3, len(resp.headers))
self.assertEqual(['value1'], resp.headers['hkey1'])
def test_dapr_api_token_insertion(self):
dapr = DaprClient(f'localhost:{self.server_port}')
resp = dapr.invoke_method(
app_id='targetId',
method_name='bytes',
data=b'haha',
content_type="text/plain",
metadata=(
('key1', 'value1'),
('key2', 'value2'),
),
)
self.assertEqual(b'haha', resp.data)
self.assertEqual("text/plain", resp.content_type)
self.assertEqual(4, len(resp.headers))
self.assertEqual(['value1'], resp.headers['hkey1'])
self.assertEqual(['test-token'], resp.headers['hdapr-api-token'])
def __exit__(self, exc_type, exc_value, traceback) -> None:
with DaprClient(address=self["dapr_address"]) as d:
self.end_step()
kv = d.save_state(self.storename, self.state_code,
self.dehydrate())
os.popen(f'dapr stop --app-id {self["current_step_name"]}')
print("==============================")
print(f"Current Context: ")
print("==============================")
self.print_context()
def test_invoke_service_proto_data(self):
dapr = DaprClient(f'localhost:{self.server_port}')
req = common_v1.StateItem(key='test')
resp = dapr.invoke_service(
id='targetId',
method='proto',
data=req,
metadata=(
('key1', 'value1'),
('key2', 'value2'),
),
)
self.assertEqual(3, len(resp.headers))
self.assertEqual(['value1'], resp.headers['hkey1'])
self.assertTrue(resp.is_proto())
# unpack to new protobuf object
new_resp = common_v1.StateItem()
resp.unpack(new_resp)
self.assertEqual('test', new_resp.key)
def test_http_extension(self):
dapr = DaprClient(f'localhost:{self.server_port}')
# Test POST verb without querystring
ext = dapr._get_http_extension('POST')
self.assertEqual(common_v1.HTTPExtension.Verb.POST, ext.verb)
# Test Non-supported http verb
with self.assertRaises(ValueError):
ext = dapr._get_http_extension('')
# Test POST verb with querystring
qs = (
('query1', 'string1'),
('query2', 'string2'),
)
ext = dapr._get_http_extension('POST', qs)
self.assertEqual(common_v1.HTTPExtension.Verb.POST, ext.verb)
for key, val in qs:
self.assertEqual(val, ext.querystring[key])
def test_save_then_get_states(self):
dapr = DaprClient(f'localhost:{self.server_port}')
key = str(uuid.uuid4())
value = str(uuid.uuid4())
another_key = str(uuid.uuid4())
another_value = str(uuid.uuid4())
dapr.save_states(store_name="statestore",
states=[
StateItem(key=key,
value=value,
metadata={"capitalize": "1"}),
StateItem(key=another_key,
value=another_value,
etag="1"),
],
metadata=(("metakey", "metavalue"), ))
resp = dapr.get_states(store_name="statestore",
keys=[key, another_key])
self.assertEqual(resp.items[0].key, key)
self.assertEqual(resp.items[0].data, to_bytes(value.capitalize()))
self.assertEqual(resp.items[1].key, another_key)
self.assertEqual(resp.items[1].data, to_bytes(another_value))
resp = dapr.get_states(store_name="statestore",
keys=[key, another_key],
states_metadata={"upper": "1"})
self.assertEqual(resp.items[0].key, key)
self.assertEqual(resp.items[0].etag, "fake_etag")
self.assertEqual(resp.items[0].data, to_bytes(value.upper()))
self.assertEqual(resp.items[1].key, another_key)
self.assertEqual(resp.items[1].etag, "fake_etag")
self.assertEqual(resp.items[1].data, to_bytes(another_value.upper()))
def test_transaction_then_get_states(self):
dapr = DaprClient(f'localhost:{self.server_port}')
key = str(uuid.uuid4())
value = str(uuid.uuid4())
another_key = str(uuid.uuid4())
another_value = str(uuid.uuid4())
dapr.execute_transaction(
store_name="statestore",
operations=[
TransactionalStateOperation(key=key, data=value),
TransactionalStateOperation(key=another_key,
data=another_value),
],
transactional_metadata={"metakey": "metavalue"})
resp = dapr.get_states(store_name="statestore",
keys=[key, another_key])
self.assertEqual(resp.items[0].key, key)
self.assertEqual(resp.items[0].data, to_bytes(value))
self.assertEqual(resp.items[1].key, another_key)
self.assertEqual(resp.items[1].data, to_bytes(another_value))
resp = dapr.get_states(store_name="statestore",
keys=[key, another_key],
states_metadata={"upper": "1"})
self.assertEqual(resp.items[0].key, key)
self.assertEqual(resp.items[0].data, to_bytes(value.upper()))
self.assertEqual(resp.items[1].key, another_key)
self.assertEqual(resp.items[1].data, to_bytes(another_value.upper()))
def test_get_save_delete_state(self):
dapr = DaprClient(f'localhost:{self.server_port}')
key = "key_1"
value = "value_1"
options = StateOptions(
consistency=Consistency.eventual,
concurrency=Concurrency.first_write,
)
dapr.save_state(store_name="statestore",
key=key,
value=value,
options=options)
resp = dapr.get_state(store_name="statestore", key=key)
self.assertEqual(resp.data, to_bytes(value))
resp = dapr.get_state(store_name="statestore", key="NotValidKey")
self.assertEqual(resp.data, b'')
dapr.delete_state(store_name="statestore", key=key)
resp = dapr.get_state(store_name="statestore", key=key)
self.assertEqual(resp.data, b'')
def test_wait_ok(self):
dapr = DaprClient(f'localhost:{self.server_port}')
dapr.wait(0.1)
def test_get_save_delete_state(self):
dapr = DaprClient(f'localhost:{self.server_port}')
key = "key_1"
value = "value_1"
options = StateOptions(
consistency=Consistency.eventual,
concurrency=Concurrency.first_write,
)
dapr.save_state(store_name="statestore",
key=key,
value=value,
options=options,
state_metadata={"capitalize": "1"})
resp = dapr.get_state(store_name="statestore", key=key)
self.assertEqual(resp.data, to_bytes(value.capitalize()))
self.assertEqual(resp.etag, "fake_etag")
resp = dapr.get_state(store_name="statestore",
key=key,
state_metadata={"upper": "1"})
self.assertEqual(resp.data, to_bytes(value.upper()))
self.assertEqual(resp.etag, "fake_etag")
resp = dapr.get_state(store_name="statestore", key="NotValidKey")
self.assertEqual(resp.data, b'')
self.assertEqual(resp.etag, '')
dapr.delete_state(store_name="statestore", key=key)
resp = dapr.get_state(store_name="statestore", key=key)
self.assertEqual(resp.data, b'')
with self.assertRaises(Exception) as context:
dapr.delete_state(store_name="statestore",
key=key,
state_metadata={"must_delete": "1"})
print(context.exception)
self.assertTrue('delete failed' in str(context.exception))
import time
from uuid import uuid4
from context import WorkflowContext
from dotenv import load_dotenv
from dapr.clients.grpc.client import DaprClient
import json
load_dotenv()
step_name = "step_3_consume"
pubsub_name = "redispubsub"
topic_name = "longRunningTasks"
app = App()
@app.subscribe(pubsub_name=pubsub_name, topic=topic_name)
def longRunningTaskFinished(event: v1.Event) -> None:
time.sleep(5)
print(
f"{step_name}: Long running task finished at {datetime.datetime.now().isoformat()}",
flush=True)
app.stop()
with WorkflowContext(step_name) as context:
with DaprClient() as d:
app.run(20001)
import time
from uuid import uuid4
from context import WorkflowContext
from dotenv import load_dotenv
from dapr.clients.grpc.client import DaprClient
import json
load_dotenv()
step_name = "step_3_publish"
pubsub_name = "redispubsub"
topic_name = "longRunningTasks"
with WorkflowContext(step_name) as context:
with DaprClient(context["dapr_address"]) as d:
context.set_value(f"{step_name}: Random Value", uuid4().hex)
req_data = {'id': 0, 'message': str(uuid4().hex)}
# Create a typed message with content type and body
resp = d.publish_event(
pubsub_name=pubsub_name,
topic=topic_name,
data=json.dumps(req_data),
)
# Print the request
print(req_data, flush=True)
