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)