class TestDatabase(unittest.TestCase):
def setUp(self):
self.db = Db()
self.db.execute('CREATE TABLE testtable ( id INTEGER PRIMARY KEY, name VARCHAR ) ')
pass
def test_can_create_db_object(self):
db = Db()
self.assertIsNotNone(db, "Database is not None")
def test_can_execute_sql(self):
self.db.execute('SELECT * FROM "main".sqlite_master')
self.db.commit()
def test_can_execute(self):
self.db.execute("INSERT INTO testtable ( id, name ) VALUES ( null, 'name')")
self.db.execute("INSERT INTO testtable ( id, name ) VALUES ( null, ?)", 'name')
self.db.execute("INSERT INTO testtable ( id, name ) VALUES ( null, :name)", name='name')
self.db.commit()
def test_can_fetch_one_object_by_id(self):
id = self.db.execute("INSERT INTO testtable ( id, name ) VALUES ( null, 'name')")
self.db.commit()
obj = self.db.one(TestObject, "SELECT * from testtable WHERE id=?", id)
def test_can_fetch_many_objects(self):
for x in range(1000,1010):
self.db.execute("INSERT INTO testtable ( id, name ) VALUES ( null, :name)", name="name"+ str(x))
self.db.commit()
objs = self.db.many(TestObject, "SELECT * FROM testtable WHERE name LIKE :name", name="name1%")
self.assertEqual(10, len(objs), '10==len(Returned)')
counter = 1000
for obj in objs:
self.assertEqual(obj.name, 'name%s' % counter, 'Name matches')
counter += 1
def test_can_fetch_one_by_unnamed(self):
id = self.db.execute("INSERT INTO testtable ( id, name ) VALUES ( null, 'name')")
self.db.commit()
fetched = self.db.one(TestObject, "SELECT * FROM testtable WHERE id=?", id)
self.assertIsNotNone(fetched , 'fetched is not none')
self.assertEqual(fetched.name, 'name', 'name==name')
def test_can_fetch_one_by_named(self):
id = self.db.execute("INSERT INTO testtable ( id, name ) VALUES ( null, 'name')")
self.db.commit()
fetched = self.db.one(TestObject, "SELECT * FROM testtable WHERE id=:id", id=id)
self.assertIsNotNone(fetched , 'fetched is not none')
self.assertEqual(fetched.name, 'name', 'name==name')
def test_can_fetch_scalar(self):
self.db.execute("INSERT INTO testtable ( id, name ) VALUES ( null, 'name')")
self.db.execute("INSERT INTO testtable ( id, name ) VALUES ( null, 'name')")
self.db.execute("INSERT INTO testtable ( id, name ) VALUES ( null, 'name')")
self.db.commit()
result = self.db.scalar("SELECT COUNT(*) FROM testtable")
self.assertIsNotNone(result, "Scalar fetched")
self.assertEqual(result, 3, "Count==3")
class TestTermService(unittest.TestCase):
def setUp(self):
self.db = Db(Application.connectionString)
self.userService = UserService()
self.languageService = LanguageService()
self.termService = TermService()
self.user = User()
self.user.username = str(uuid.uuid1())
self.user = self.userService.save(self.user)
self.language = Language()
self.languageService.save(self.language)
Application.user = self.user
def test_can_get_term_by_id(self):
term = Term()
term.languageId = self.language.languageId
original = self.termService.save(term)
saved = self.termService.findOne(original.termId)
self.assertEqual(original.termId, saved.termId, "Saved termId==Original termId")
def test_can_update_term(self):
term = Term()
term.languageId = self.language.languageId
term = self.termService.save(term)
self.assertEqual(term.basePhrase, "", "Name is empty")
time.sleep(0.5)
term.basePhrase = 'Bob'
original = self.termService.save(term)
saved = self.termService.findOne(original.termId)
self.assertEqual(saved.basePhrase, term.basePhrase, "Updated basePhrase")
self.assertGreater(saved.modified, term.created, "Modified>Created")
def test_can_delete_term(self):
term = Term()
term.languageId = self.language.languageId
term = self.termService.save(term)
self.assertGreater(term.termId, 0, "Term is saved")
self.termService.delete(term.termId)
saved = self.termService.findOne(term.termId)
self.assertIsNone(saved, "Term is deleted")
def test_can_get_term_by_phrase_and_language(self):
term = Term()
term.phrase = "PHRASE"
term.languageId = self.language.languageId
original = self.termService.save(term)
saved = self.termService.fineOneByPhraseAndLanguage("Phrase", self.language.languageId)
self.assertEqual(original.termId, saved.termId, "Saved termId==Original termId")
def test_can_save_term(self):
term = Term()
term.languageId = self.language.languageId
original = self.termService.save(term)
saved = self.termService.findOne(original.termId)
self.assertIsNotNone(term, "term is not None")
self.assertGreater(saved.termId, 0, "termId is >0")
self.assertEqual(original.termId, saved.termId, "Saved PK is retrieved PK")
self.assertEqual(saved.userId, Application.user.userId, "term has Application UserId")
self.assertGreaterEqual(saved.created, saved.modified, "Created and modified udpated")
def test_term_log_entry_is_added_with_create(self):
term = Term()
term.languageId = self.language.languageId
term = self.termService.save(term)
result = self.db.scalar("SELECT COUNT(*) as count FROM termlog WHERE termId=:termId AND type=:type", termId=term.termId, type=TermType.Create)
self.assertEqual(result, 1, "Create entry found")
def test_term_log_entry_is_added_with_update(self):
term = Term()
term.languageId = self.language.languageId
term = self.termService.save(term)
result = self.db.scalar("SELECT COUNT(*) as count FROM termlog WHERE termId=:termId AND type=:type", termId=term.termId, type=TermType.Modify)
self.assertEqual(result, 0, "Modify entry not found")
term = self.termService.save(term)
result = self.db.scalar("SELECT COUNT(*) as count FROM termlog WHERE termId=:termId AND type=:type", termId=term.termId, type=TermType.Modify)
self.assertEqual(result, 1, "Modify entry found")
def test_term_log_entry_is_added_with_delete(self):
term = Term()
term.languageId = self.language.languageId
term = self.termService.save(term)
result = self.db.scalar("SELECT COUNT(*) as count FROM termlog WHERE termId=:termId AND type=:type", termId=term.termId, type=TermType.Delete)
self.assertEqual(result, 0, "Delete entry not found")
self.termService.delete(term.termId)
result = self.db.scalar("SELECT COUNT(*) as count FROM termlog WHERE termId=:termId AND type=:type", termId=term.termId, type=TermType.Delete)
self.assertEqual(result, 1, "Delete entry found")
