def setUp(self): # If a Survol agent does not run on this machine with this port, this script starts a local one. _supervisor_reset() lib_kbase.clear_all_events() self._rdf_test_agent, self._agent_url = start_cgiserver(RemoteRdf2TestServerPort) print("AgentUrl=", self._agent_url) lib_kbase.set_storage_style("IOMemory",)
def setUp(self): """ https://www.sqlite.org/inmemorydb.html The most common way to force an SQLite database to exist purely in memory is to open the database using the special filename ":memory:". In other words, instead of passing the name of a real disk file, pass in the string ":memory:". When this is done, no disk file is opened. Instead, a new database is created purely in memory. The database ceases to exist as soon as the database connection is closed. Every :memory: database is distinct from every other. So, opening two database connections each with the filename ":memory:" will create two independent in-memory databases. In-memory databases are allowed to use shared cache if they are opened using a URI filename. If the unadorned ":memory:" name is used to specify the in-memory database, then that database always has a private cache and is this only visible to the database connection that originally opened it. However, the same in-memory database can be opened by two or more database connections as follows: rc = sqlite3_open("file::memory:?cache=shared", &db); If two or more distinct but shareable in-memory databases are needed in a single process, then the mode=memory query parameter can be used with a URI filename to create a named in-memory database: rc = sqlite3_open("file:memdb1?mode=memory&cache=shared", &db); https://stackoverflow.com/questions/27910829/sqlalchemy-and-sqlite-shared-cache """ lib_kbase.set_storage_style("SQLAlchemy", self.sqlite_path)
def tearDown(self): lib_kbase.set_storage_style(None, ) # This destroys the database file so all tests are completely isolated. # TODO: Does not work with multiprocessing. assert os.path.exists(self.database_path) os.unlink(self.database_path) assert not os.path.exists(self.database_path)
def set_events_credentials(): """This sets the global parameter telling where the events are stored.""" storage_credential = lib_credentials.GetCredentials("Storage", "Events") if not storage_credential: credentials_filename = lib_credentials.credentials_filename() raise Exception("No storage credential in:%s" % credentials_filename) storage_style, storage_url = storage_credential lib_kbase.set_storage_style(storage_style, storage_url)
def tearDown(self): stop_cgiserver(self._rdf_test_agent) lib_kbase.clear_all_events() lib_kbase.set_storage_style(None,)
def setUp(self): self.database_path = create_temporary_sqlite_filename() self.sqlite_path = r"sqlite:///%s" % self.database_path lib_kbase.set_storage_style("SQLAlchemy", self.sqlite_path)
def tearDown(self): lib_kbase.set_storage_style(None, )
def _connect_then_read_all_events_from_graph(expected_triple_numbers, pqueue, sqlite_path): lib_kbase.set_storage_style("SQLAlchemy", sqlite_path) _read_all_events_from_graph(expected_triple_numbers, pqueue)
def setUp(self): lib_kbase.set_storage_style("IOMemory", )