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 setUp(self):
OptionManager.initial_test_setup()
SQLManager.instance().create_all()
[
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_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 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 = IODbPut(model="FooBase", tablename="FooBase")
t1.set_table(FooBase)
t1.type = self.input_entry
toolwrapper_ready2 = FooWrapper2(rule_name="rule2")
toolwrapper_ready2.tables.append(t1)
self.assertTrue(toolwrapper_ready2.are_inputs_ready())
SQLManager.instance().drop(FooBase.__tablename__)
self.assertFalse(toolwrapper_ready2.are_inputs_ready())
def setUp(self):
self.s_root_path = PathFinder.get_module_path()
OptionManager.initial_test_setup()
print(OptionManager.instance()["--log"])
SQLManager.instance().create_all()
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 = IODbPut(model="FooBase", tablename="FooBase")
self.__io_base_existing.set_table(FooBase)
self.__io_base_existing2 = IODbPut(model="FooBase",
tablename="FooBase")
self.__io_base_existing2.set_table(FooBase)
self.__io_base_existing3 = IODbPut(model="FooBase2",
tablename="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)