def test_sql_additional_events_with_session_start(
domain: Domain, retrieve_events_from_previous_conversation_sessions):
sender = "test_sql_additional_events_with_session_start"
tracker_store = SQLTrackerStore(
domain,
retrieve_events_from_previous_conversation_sessions=(
retrieve_events_from_previous_conversation_sessions),
)
tracker = _saved_tracker_with_multiple_session_starts(
tracker_store, sender)
tracker.update(UserUttered("hi2"), domain)
# make sure only new events are returned
with tracker_store.session_scope() as session:
# noinspection PyProtectedMember
additional_events = list(
tracker_store._additional_events(session, tracker))
assert len(additional_events) == 1
assert isinstance(additional_events[0], UserUttered)
def __init__(
self,
dialect: Text = "sqlite",
host: Optional[Text] = None,
port: Optional[int] = None,
db: Text = "events.db",
username: Optional[Text] = None,
password: Optional[Text] = None,
) -> None:
from rasa.core.tracker_store import SQLTrackerStore
import sqlalchemy.orm
engine_url = SQLTrackerStore.get_db_url(dialect, host, port, db,
username, password)
logger.debug(
f"SQLEventBroker: Connecting to database: '{engine_url}'.")
self.engine = sqlalchemy.create_engine(engine_url)
self.Base.metadata.create_all(self.engine)
self.sessionmaker = sqlalchemy.orm.sessionmaker(bind=self.engine)
async def test_load_sessions(tmp_path):
"""Tests loading a tracker with multiple sessions."""
domain = Domain.empty()
store = SQLTrackerStore(domain, db=os.path.join(tmp_path, "temp.db"))
tracker = DialogueStateTracker("test123", None)
tracker.update_with_events(
[
UserUttered("0"),
UserUttered("1"),
SessionStarted(),
UserUttered("2"),
UserUttered("3"),
],
domain,
)
await store.save(tracker)
loader = MarkerTrackerLoader(store, STRATEGY_ALL)
result = [tracker async for tracker in loader.load()]
assert len(result) == 1 # contains only one tracker
assert len(result[0].events) == len(tracker.events)
def test_sql_tracker_store_with_login_db(
postgres_login_db_connection: sa.engine.Connection, ):
tracker_store = SQLTrackerStore(
dialect="postgresql",
host=POSTGRES_HOST,
port=POSTGRES_PORT,
username=POSTGRES_USER,
password=POSTGRES_PASSWORD,
db=POSTGRES_TRACKER_STORE_DB,
login_db=POSTGRES_LOGIN_DB,
)
matching_rows = (postgres_login_db_connection.execution_options(
isolation_level="AUTOCOMMIT"
).execute(
sa.text(
"SELECT 1 FROM pg_catalog.pg_database WHERE datname = :database_name"
),
database_name=POSTGRES_TRACKER_STORE_DB,
).rowcount)
assert matching_rows == 1
assert tracker_store.engine.url.database == POSTGRES_TRACKER_STORE_DB
tracker_store.engine.dispose()
def test_db_get_url_with_sqlite():
expected = "sqlite:///rasa.db"
assert str(SQLTrackerStore.get_db_url(dialect="sqlite", db="rasa.db")) == expected
def test_get_db_url_with_fully_specified_url(full_url: Text):
assert SQLTrackerStore.get_db_url(host=full_url) == full_url
def test_login_db_with_no_postgresql(tmp_path: Path):
with pytest.warns(UserWarning):
SQLTrackerStore(db=str(tmp_path / "rasa.db"), login_db="other")
def _get_rasa_x_tracker_store() -> SQLTrackerStore:
return SQLTrackerStore(Domain.empty(), db="tracker.db")
def test_sql_tracker_store_with_token_serialisation(
domain: Domain, response_selector_agent: Agent
):
tracker_store = SQLTrackerStore(domain, **{"host": "sqlite:///"})
prepare_token_serialisation(tracker_store, response_selector_agent, "sql")
def _get_rasa_x_tracker_store(endpoints_file: Optional[Text]) -> TrackerStore:
if endpoints_file and os.path.exists(endpoints_file):
return _get_tracker_store_from_endpoints_config(endpoints_file)
else:
return SQLTrackerStore(Domain.empty(), db="tracker.db")
def stores_to_be_tested():
temp = tempfile.mkdtemp()
return [MockRedisTrackerStore(domain),
InMemoryTrackerStore(domain),
SQLTrackerStore(domain,
db=os.path.join(temp, 'rasa.db'))]
