def test_sort_and_select_events_by_timestamp_error():
tracker_store = Mock()
exporter = MockExporter(tracker_store)
# no events given
with pytest.raises(NoEventsInTimeRangeError):
exporter._sort_and_select_events_by_timestamp([])
# supply list of events, apply timestamp constraint and no events survive
exporter.minimum_timestamp = 3.1
events = [random_user_uttered_event(3).as_dict()]
with pytest.raises(NoEventsInTimeRangeError):
exporter._sort_and_select_events_by_timestamp(events)
def test_fetch_events_within_time_range_with_session_events():
conversation_id = "test_fetch_events_within_time_range_with_sessions"
tracker_store = SQLTrackerStore(
dialect="sqlite", db=f"{uuid.uuid4().hex}.db", domain=Domain.empty()
)
events = [
random_user_uttered_event(1),
SessionStarted(2),
ActionExecuted(timestamp=3, action_name=ACTION_SESSION_START_NAME),
random_user_uttered_event(4),
]
tracker = DialogueStateTracker.from_events(conversation_id, evts=events)
tracker_store.save(tracker)
exporter = MockExporter(tracker_store=tracker_store)
# noinspection PyProtectedMember
fetched_events = exporter._fetch_events_within_time_range()
assert len(fetched_events) == len(events)
def prepare_namespace_and_mocked_tracker_store_with_events(
temporary_path: Path, monkeypatch: MonkeyPatch
) -> Tuple[List[UserUttered], argparse.Namespace]:
endpoints_path = write_endpoint_config_to_yaml(
temporary_path,
{
"event_broker": {
"type": "pika"
},
"tracker_store": {
"type": "sql"
}
},
)
# export these conversation IDs
all_conversation_ids = ["id-1", "id-2", "id-3"]
requested_conversation_ids = ["id-1", "id-2"]
# create namespace with a set of cmdline arguments
namespace = argparse.Namespace(
endpoints=endpoints_path,
conversation_ids=",".join(requested_conversation_ids),
minimum_timestamp=1.0,
maximum_timestamp=10.0,
)
# prepare events from different senders and different timestamps
events = [
random_user_uttered_event(timestamp)
for timestamp in [1, 2, 3, 4, 11, 5]
]
events_for_conversation_id = {
all_conversation_ids[0]: [events[0], events[1]],
all_conversation_ids[1]: [events[2], events[3], events[4]],
all_conversation_ids[2]: [events[5]],
}
def _get_tracker(conversation_id: Text) -> DialogueStateTracker:
return DialogueStateTracker.from_events(
conversation_id, events_for_conversation_id[conversation_id])
# mock tracker store
tracker_store = Mock()
tracker_store.keys.return_value = all_conversation_ids
tracker_store.retrieve.side_effect = _get_tracker
monkeypatch.setattr(export, "_get_tracker_store", lambda _: tracker_store)
return events, namespace
def test_sort_and_select_events_by_timestamp():
events = [
event.as_dict()
for event in [
random_user_uttered_event(3),
random_user_uttered_event(2),
random_user_uttered_event(1),
]
]
tracker_store = Mock()
exporter = MockExporter(tracker_store)
selected_events = exporter._sort_and_select_events_by_timestamp(events)
# events are sorted
assert selected_events == list(
sorted(selected_events, key=lambda e: e["timestamp"])
)
# apply minimum timestamp requirement, expect to get only two events back
exporter.minimum_timestamp = 2.0
assert exporter._sort_and_select_events_by_timestamp(events) == [
events[1],
events[0],
]
exporter.minimum_timestamp = None
# apply maximum timestamp requirement, expect to get only one
exporter.maximum_timestamp = 1.1
assert exporter._sort_and_select_events_by_timestamp(events) == [events[2]]
# apply both requirements, get one event back
exporter.minimum_timestamp = 2.0
exporter.maximum_timestamp = 2.1
assert exporter._sort_and_select_events_by_timestamp(events) == [events[1]]
async def test_publishing_error():
# mock event broker so it raises on `publish()`
event_broker = Mock()
event_broker.publish.side_effect = ValueError()
exporter = MockExporter(event_broker=event_broker)
user_event = random_user_uttered_event(1).as_dict()
user_event["sender_id"] = uuid.uuid4().hex
# noinspection PyProtectedMember
exporter._fetch_events_within_time_range = Mock(return_value=[user_event])
# run the export function
with pytest.raises(PublishingError):
await exporter.publish_events()
