def test_add_all(self):
fs = []
for i in range(10):
fs.append(FooBase(name="testSession " + str(i)))
self.__session.add_all(fs)
self.__session.commit()
self.assertEqual(len(self.__session.query(FooBase).all()), 10)
def run(self):
thread_session = SQLManager.instance().get_session()
for i in range(1000):
foo = FooBase(name="string " + str(i))
thread_session.add(foo)
thread_session.rollback()
thread_session.close()
def test_get_or_create(self):
fs = []
for i in range(10):
fs.append(FooBase(name="testSession " + str(i)))
self.__session.add_all(fs)
self.__session.commit()
self.assertEqual(self.__session.get_or_create(FooBase, name="testSession 0")[0], fs[0])
self.__session.delete(fs[0])
self.assertNotEqual(self.__session.get_or_create(FooBase, name="testSession 0")[0], fs[0])
def setUp(self):
OptionManager.initial_test_setup() # Set tests arguments
SQLManager.instance().create_all() # Create database with tables
[
SQLManager.instance().get_session().add(
FooBase(name="foo " + str(i))) for i in range(10000)
]
SQLManager.instance().get_session().commit()
def test_delete(self):
fs = []
for i in range(10):
fs.append(FooBase(name="testSession " + str(i)))
self.__session.add_all(fs)
self.__session.commit()
for i in range(5):
f = self.__session.query(FooBase).filter(FooBase.name == "testSession " + str(i)).first()
self.__session.delete(f)
self.assertEqual(len(self.__session.query(FooBase).all()), 5)
def test_something(self):
fs = []
for i in range(10):
fs.append(FooBase(name="testSession " + str(i)))
self.__session.add_all(fs)
self.assertTrue(self.__session.something())
self.__session.commit()
self.assertFalse(self.__session.something())
for i in range(10):
self.__session.query(FooBase).filter(FooBase.name == "testSession " + str(i)).first().name = "sessionTest " + str(i)
self.assertTrue(self.__session.something())
def test_are_inputs_ready(self):
self.assertTrue(self.__toolwrapper_ready.are_inputs_ready())
self.assertFalse(self.__toolwrapper_not_ready.are_inputs_ready())
SQLManager.instance().get_session().add_all([FooBase(name="test_bak " + str(i)) for i in range(5)])
SQLManager.instance().get_session().commit()
t1 = TableInputOutputInformation(model_py_path="FooBase", table_key="FooBase", table_name="FooBase")
t1.set_table(FooBase)
t1.model_declarative_meta = FooBase
t1.relation_file_or_tableioinfo_to_typeio = self.input_entry
toolwrapper_ready2 = FooWrapper2(rule_name="rule2")
toolwrapper_ready2.relation_toolwrapper_to_tableioinfo.append(t1)
self.assertTrue(toolwrapper_ready2.are_inputs_ready())
# this tests does not work with mysql and postgresql
if not SQLManager.instance().engine.url.drivername in ['mysql', 'postgresql']:
SQLManager.instance().drop(FooBase.__tablename__)
self.assertFalse(toolwrapper_ready2.are_inputs_ready())
def setUp(self):
self.test_path = PathManager.get_test_path()
OptionManager.initial_test_setup() # Set tests arguments
SQLManager.instance().create_all() # Create database with tables
self.__local_session = SQLManager.instance().get_session()
try:
for i in range(10):
self.__local_session.add(FooBase(name="testIODB " + str(i)))
self.__local_session.commit()
except Exception as e:
self.__local_session.rollback()
self.__local_session.close()
raise e
self.__io_base_existing = TableInputOutputInformation(model_py_path="FooBase", table_key="FooBase", table_name="FooBase")
self.__io_base_existing.set_table(FooBase)
self.__io_base_existing2 = TableInputOutputInformation(model_py_path="FooBase", table_key="FooBase", table_name="FooBase")
self.__io_base_existing2.set_table(FooBase)
self.__io_base_existing3 = TableInputOutputInformation(model_py_path="FooBase2", table_key="FooBase2", table_name="FooBase2")
self.__io_base_existing3.set_table(FooBase2)
def test_query(self):
fs = []
for i in range(10):
fs.append(FooBase(name="testSession " + str(i)))
self.__session.add_all(fs)
self.__session.commit()
self.assertEqual(len(self.__session.query(FooBase).all()), 10)
with self.assertRaises(MultipleResultsFound):
self.assertEqual(self.__session.query(FooBase).one().name, "testSession 0")
self.assertEqual(self.__session.query(FooBase).filter(FooBase.name == "testSession 0").one().name, "testSession 0")
self.assertEqual(self.__session.query(FooBase).count(), 10)
self.assertEqual(self.__session.query(FooBase).first().name, "testSession 0")
self.assertIsNone(self.__session.query(FooBase).filter(FooBase.name == "existepas").one_or_none())
self.assertIsNone(self.__session.query(FooBase).filter(FooBase.name == "existepas").scalar())
self.assertEqual(self.__session.query(FooBase.name).filter(FooBase.name == "testSession 0").scalar(), "testSession 0")
with self.assertRaises(MultipleResultsFound):
self.assertEqual(self.__session.query(FooBase.name).scalar(), "testSession 0")
def test_rollback(self):
for i in range(10):
f = FooBase(name="testSession " + str(i))
self.__session.add(f)
self.__session.rollback()
self.assertEqual(len(self.__session.query(FooBase).all()), 0)
def test_commit_query_add(self):
for i in range(10):
f = FooBase(name="testSession " + str(i))
self.__session.add(f)
self.__session.commit()
self.assertEqual(len(self.__session.query(FooBase).all()), 10)