def testRun(self):
db = DAL("sqlite:memory:")
db.define_table("t", Field("a"), Field("b", default="x"), Field("c", compute=lambda r: r.a + r.b))
db.commit()
id = db.t.insert(a="z")
self.assertEqual(db.t[id].c, "zx")
db.t.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=["all"])
db.define_table("tt", Field("aa"), Field("bb", default="x"), Field("cc", compute=lambda r: r.aa + r.bb))
db.commit()
id = db.tt.insert(aa="z")
self.assertEqual(db.tt[id].cc, "zx")
db.tt.drop()
db.commit()
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('t', Field('a'), Field('b', default='x'),
Field('c', compute=lambda r: r.a + r.b))
db.commit()
id = db.t.insert(a="z")
self.assertEqual(db.t[id].c, 'zx')
db.t.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'), Field('bb', default='x'),
Field('cc', compute=lambda r: r.aa + r.bb))
db.commit()
id = db.tt.insert(aa="z")
self.assertEqual(db.tt[id].cc, 'zx')
db.tt.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'))
db.commit()
db.tt.insert(aa="test")
class Compute:
def a_upper(row): return row.tt.aa.upper()
db.tt.virtualfields.append(Compute())
assert db(db.tt.id>0).select().first().a_upper == 'TEST'
db.tt.drop()
db.commit()
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('t', Field('a'))
db.commit()
db.t.insert(a="test")
class Compute:
def a_upper(row): return row.t.a.upper()
db.t.virtualfields.append(Compute())
assert db(db.t.id>0).select().first().a_upper == 'TEST'
db.t.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'))
db.commit()
db.tt.insert(aa="test")
class Compute:
def a_upper(row): return row.tt.aa.upper()
db.tt.virtualfields.append(Compute())
assert db(db.tt.id>0).select().first().a_upper == 'TEST'
db.tt.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt',
Field('aa'),
Field('bb',default='x'),
Field('cc',compute=lambda r: r.aa+r.bb))
db.commit()
id = db.tt.insert(aa="z")
self.assertEqual(db.tt[id].cc,'zx')
db.tt.drop()
db.commit()
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('t',
Field('a'),
Field('b',default='x'),
Field('c',compute=lambda r: r.a+r.b))
db.commit()
id = db.t.insert(a="z")
self.assertEqual(db.t[id].c,'zx')
db.t.drop()
db.commit()
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('t', Field('a'))
db.commit()
db.t.insert(a="test")
class Compute:
def a_upper(row): return row.t.a.upper()
db.t.virtualfields.append(Compute())
assert db(db.t.id>0).select().first().a_upper == 'TEST'
db.t.drop()
db.commit()
def testRun(self):
db = DAL("sqlite:memory:")
db.define_table("t", Field("name"), Field("a", "reference t"))
db.commit()
x = db.t.insert(name="max")
assert x.id == 1
assert x["id"] == 1
x.a = x
assert x.a == 1
x.update_record()
y = db.t[1]
assert y.a == 1
assert y.a.a.a.a.a.a.name == "max"
z = db.t.insert(name="xxx", a=y)
assert z.a == y.id
db.t.drop()
db.commit()
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('t', Field('name'), Field('a','reference t'))
db.commit()
x = db.t.insert(name='max')
assert x.id == 1
assert x['id'] == 1
x.a = x
assert x.a == 1
x.update_record()
y = db.t[1]
assert y.a == 1
assert y.a.a.a.a.a.a.name == 'max'
z=db.t.insert(name='xxx', a = y)
assert z.a == y.id
db.t.drop()
db.commit()
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('t', Field('name'), Field('a','reference t'))
db.commit()
x = db.t.insert(name='max')
assert x.id == 1
assert x['id'] == 1
x.a = x
assert x.a == 1
x.update_record()
y = db.t[1]
assert y.a == 1
assert y.a.a.a.a.a.a.name == 'max'
z=db.t.insert(name='xxx', a = y)
assert z.a == y.id
db.t.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=["all"])
db.define_table("tt", Field("name"), Field("aa", "reference tt"))
db.commit()
x = db.tt.insert(name="max")
assert x.id == 1
assert x["id"] == 1
x.aa = x
assert x.aa == 1
x.update_record()
y = db.tt[1]
assert y.aa == 1
assert y.aa.aa.aa.aa.aa.aa.name == "max"
z = db.tt.insert(name="xxx", aa=y)
assert z.aa == y.id
db.tt.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('name'), Field('aa', 'reference tt'))
db.commit()
x = db.tt.insert(name='max')
assert x.id == 1
assert x['id'] == 1
x.aa = x
assert x.aa == 1
x.update_record()
y = db.tt[1]
assert y.aa == 1
assert y.aa.aa.aa.aa.aa.aa.name == 'max'
z = db.tt.insert(name='xxx', aa=y)
assert z.aa == y.id
db.tt.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('name'), Field('aa','reference tt'))
db.commit()
x = db.tt.insert(name='max')
assert x.id == 1
assert x['id'] == 1
x.aa = x
assert x.aa == 1
x.update_record()
y = db.tt[1]
assert y.aa == 1
assert y.aa.aa.aa.aa.aa.aa.name == 'max'
z=db.tt.insert(name='xxx', aa = y)
assert z.aa == y.id
db.tt.drop()
db.commit()
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('t', Field('a'))
db.commit()
db.t.insert(a="test")
rows1 = db(db.t.id>0).select()
rows2 = db(db.t.id>0).select()
rows3 = rows1 & rows2
assert len(rows3) == 2
rows4 = rows1 | rows2
assert len(rows4) == 1
rows5 = rows1.find(lambda row: row.a=="test")
assert len(rows5) == 1
rows6 = rows2.exclude(lambda row: row.a=="test")
assert len(rows6) == 1
rows7 = rows5.sort(lambda row: row.a)
assert len(rows7) == 1
db.t.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'))
db.commit()
db.tt.insert(aa="test")
rows1 = db(db.tt.id>0).select()
rows2 = db(db.tt.id>0).select()
rows3 = rows1 & rows2
assert len(rows3) == 2
rows4 = rows1 | rows2
assert len(rows4) == 1
rows5 = rows1.find(lambda row: row.aa=="test")
assert len(rows5) == 1
rows6 = rows2.exclude(lambda row: row.aa=="test")
assert len(rows6) == 1
rows7 = rows5.sort(lambda row: row.aa)
assert len(rows7) == 1
db.tt.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'))
db.commit()
db.tt.insert(aa="test")
rows1 = db(db.tt.id > 0).select()
rows2 = db(db.tt.id > 0).select()
rows3 = rows1 & rows2
assert len(rows3) == 2
rows4 = rows1 | rows2
assert len(rows4) == 1
rows5 = rows1.find(lambda row: row.aa == "test")
assert len(rows5) == 1
rows6 = rows2.exclude(lambda row: row.aa == "test")
assert len(rows6) == 1
rows7 = rows5.sort(lambda row: row.aa)
assert len(rows7) == 1
db.tt.drop()
db.commit()
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('t', Field('a'))
db.commit()
db.t.insert(a="test")
rows1 = db(db.t.id>0).select()
rows2 = db(db.t.id>0).select()
rows3 = rows1 & rows2
assert len(rows3) == 2
rows4 = rows1 | rows2
assert len(rows4) == 1
rows5 = rows1.find(lambda row: row.a=="test")
assert len(rows5) == 1
rows6 = rows2.exclude(lambda row: row.a=="test")
assert len(rows6) == 1
rows7 = rows5.sort(lambda row: row.a)
assert len(rows7) == 1
db.t.drop()
db.commit()
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('person', Field('name'),Field('uuid'))
db.define_table('pet',Field('friend',db.person),Field('name'))
for n in range(2):
db(db.pet).delete()
db(db.person).delete()
for k in range(10):
id = db.person.insert(name=str(k),uuid=str(k))
db.pet.insert(friend=id,name=str(k))
db.commit()
stream = cStringIO.StringIO()
db.export_to_csv_file(stream)
stream = cStringIO.StringIO(stream.getvalue())
db.import_from_csv_file(stream)
assert db(db.person).count()==10
assert db(db.person.id==db.pet.friend)(db.person.name==db.pet.name).count()==20
db.pet.drop()
db.person.drop()
db.commit()
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('person', Field('name'),Field('uuid'))
db.define_table('pet',Field('friend',db.person),Field('name'))
for n in range(2):
db(db.pet).delete()
db(db.person).delete()
for k in range(10):
id = db.person.insert(name=str(k),uuid=str(k))
db.pet.insert(friend=id,name=str(k))
db.commit()
stream = cStringIO.StringIO()
db.export_to_csv_file(stream)
stream = cStringIO.StringIO(stream.getvalue())
db.import_from_csv_file(stream)
assert db(db.person).count()==10
assert db(db.person.id==db.pet.friend)(db.person.name==db.pet.name).count()==20
db.pet.drop()
db.person.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=["all"])
db.define_table("person", Field("name"), Field("uuid"))
db.define_table("pet", Field("friend", db.person), Field("name"))
for n in range(2):
db(db.pet).delete()
db(db.person).delete()
for k in range(10):
id = db.person.insert(name=str(k), uuid=str(k))
db.pet.insert(friend=id, name=str(k))
db.commit()
stream = StringIO.StringIO()
db.export_to_csv_file(stream)
stream = StringIO.StringIO(stream.getvalue())
db.import_from_csv_file(stream)
assert db(db.person).count() == 10
assert db(db.person.id == db.pet.friend)(db.person.name == db.pet.name).count() == 20
db.pet.drop()
db.person.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('person', Field('name'))
db.define_table('pet',Field('friend',db.person),Field('name'))
for n in range(2):
db(db.pet).delete()
db(db.person).delete()
for k in range(10):
id = db.person.insert(name=str(k))
db.pet.insert(friend=id,name=str(k))
db.commit()
stream = StringIO.StringIO()
db.export_to_csv_file(stream)
db(db.pet).delete()
db(db.person).delete()
stream = StringIO.StringIO(stream.getvalue())
db.import_from_csv_file(stream)
assert db(db.person.id==db.pet.friend)(db.person.name==db.pet.name).count()==10
db.pet.drop()
db.person.drop()
db.commit()
def testRun(self):
db = DAL("sqlite:memory:")
db.define_table("person", Field("name"))
db.define_table("pet", Field("friend", db.person), Field("name"))
for n in range(2):
db(db.pet).delete()
db(db.person).delete()
for k in range(10):
id = db.person.insert(name=str(k))
db.pet.insert(friend=id, name=str(k))
db.commit()
stream = cStringIO.StringIO()
db.export_to_csv_file(stream)
db(db.pet).delete()
db(db.person).delete()
stream = cStringIO.StringIO(stream.getvalue())
db.import_from_csv_file(stream)
assert db(db.person.id == db.pet.friend)(db.person.name == db.pet.name).count() == 10
db.pet.drop()
db.person.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('person', Field('name'))
db.define_table('pet',Field('friend',db.person),Field('name'))
for n in range(2):
db(db.pet).delete()
db(db.person).delete()
for k in range(10):
id = db.person.insert(name=str(k))
db.pet.insert(friend=id,name=str(k))
db.commit()
stream = StringIO.StringIO()
db.export_to_csv_file(stream)
db(db.pet).delete()
db(db.person).delete()
stream = StringIO.StringIO(stream.getvalue())
db.import_from_csv_file(stream)
assert db(db.person.id==db.pet.friend)(db.person.name==db.pet.name).count()==10
db.pet.drop()
db.person.drop()
db.commit()
def testRun(self):
db = DAL("sqlite://.storage.db")
db.define_table("t", Field("a"), migrate=".storage.table")
db.commit()
db = DAL("sqlite://.storage.db")
db.define_table("t", Field("a"), Field("b"), migrate=".storage.table")
db.commit()
db = DAL("sqlite://.storage.db")
db.define_table("t", Field("a"), Field("b", "text"), migrate=".storage.table")
db.commit()
db = DAL("sqlite://.storage.db")
db.define_table("t", Field("a"), migrate=".storage.table")
db.t.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
if DEFAULT_URI.startswith('mssql'):
#multiple cascade gotcha
for key in ['reference','reference FK']:
db._adapter.types[key]=db._adapter.types[key].replace(
'%(on_delete_action)s','NO ACTION')
db.define_table('tt', Field('name'), Field('aa','reference tt'))
db.commit()
x = db.tt.insert(name='max')
assert x.id == 1
assert x['id'] == 1
x.aa = x
assert x.aa == 1
x.update_record()
y = db.tt[1]
assert y.aa == 1
assert y.aa.aa.aa.aa.aa.aa.name == 'max'
z=db.tt.insert(name='xxx', aa = y)
assert z.aa == y.id
db.tt.drop()
db.commit()
def testRun(self):
db = DAL('sqlite://.storage.db')
db.define_table('t', Field('a'), migrate='.storage.table')
db.commit()
db = DAL('sqlite://.storage.db')
db.define_table('t', Field('a'), Field('b'),
migrate='.storage.table')
db.commit()
db = DAL('sqlite://.storage.db')
db.define_table('t', Field('a'), Field('b', 'text'),
migrate='.storage.table')
db.commit()
db = DAL('sqlite://.storage.db')
db.define_table('t', Field('a'), migrate='.storage.table')
db.t.drop()
db.commit()
def testRun(self):
db = DAL('sqlite://.storage.db')
db.define_table('t', Field('a'), migrate='.storage.table')
db.commit()
db = DAL('sqlite://.storage.db')
db.define_table('t', Field('a'), Field('b'),
migrate='.storage.table')
db.commit()
db = DAL('sqlite://.storage.db')
db.define_table('t', Field('a'), Field('b', 'text'),
migrate='.storage.table')
db.commit()
db = DAL('sqlite://.storage.db')
db.define_table('t', Field('a'), migrate='.storage.table')
db.t.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=["all"])
db.define_table("tt", Field("aa"), migrate=".storage.table")
db.commit()
db.close()
db = DAL(DEFAULT_URI, check_reserved=["all"])
db.define_table("tt", Field("aa"), Field("b"), migrate=".storage.table")
db.commit()
db.close()
db = DAL(DEFAULT_URI, check_reserved=["all"])
db.define_table("tt", Field("aa"), Field("b", "text"), migrate=".storage.table")
db.commit()
db.close()
db = DAL(DEFAULT_URI, check_reserved=["all"])
db.define_table("tt", Field("aa"), migrate=".storage.table")
db.tt.drop()
db.commit()
db.close()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'), Field('bb', default='x'),
Field('cc', compute=lambda r: r.aa + r.bb))
db.commit()
id = db.tt.insert(aa="z")
self.assertEqual(db.tt[id].cc, 'zx')
db.tt.drop()
db.commit()
# test checking that a compute field can refer to earlier-defined computed fields
db.define_table('tt', Field('aa'), Field('bb', default='x'),
Field('cc', compute=lambda r: r.aa + r.bb),
Field('dd', compute=lambda r: r.bb + r.cc))
db.commit()
id = db.tt.insert(aa="z")
self.assertEqual(db.tt[id].dd, 'xzx')
db.tt.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'), migrate='.storage.table')
db.commit()
db.close()
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'), Field('b'),
migrate='.storage.table')
db.commit()
db.close()
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'), Field('b', 'text'),
migrate='.storage.table')
db.commit()
db.close()
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'), migrate='.storage.table')
db.tt.drop()
db.commit()
db.close()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'), migrate='.storage.table')
db.commit()
db.close()
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'), Field('b'),
migrate='.storage.table')
db.commit()
db.close()
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'), Field('b', 'text'),
migrate='.storage.table')
db.commit()
db.close()
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt', Field('aa'), migrate='.storage.table')
db.tt.drop()
db.commit()
db.close()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=["all"])
db.define_table("tt", Field("aa"), Field("bb", default="x"), Field("cc", compute=lambda r: r.aa + r.bb))
db.commit()
id = db.tt.insert(aa="z")
self.assertEqual(db.tt[id].cc, "zx")
db.tt.drop()
db.commit()
# test checking that a compute field can refer to earlier-defined computed fields
db.define_table(
"tt",
Field("aa"),
Field("bb", default="x"),
Field("cc", compute=lambda r: r.aa + r.bb),
Field("dd", compute=lambda r: r.bb + r.cc),
)
db.commit()
id = db.tt.insert(aa="z")
self.assertEqual(db.tt[id].dd, "xzx")
db.tt.drop()
db.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('tt',
Field('aa'),
Field('bb',default='x'),
Field('cc',compute=lambda r: r.aa+r.bb))
db.commit()
id = db.tt.insert(aa="z")
self.assertEqual(db.tt[id].cc,'zx')
db.tt.drop()
db.commit()
# test checking that a compute field can refer to earlier-defined computed fields
db.define_table('tt',
Field('aa'),
Field('bb',default='x'),
Field('cc',compute=lambda r: r.aa+r.bb),
Field('dd',compute=lambda r: r.bb + r.cc))
db.commit()
id = db.tt.insert(aa="z")
self.assertEqual(db.tt[id].dd,'xzx')
db.tt.drop()
db.commit()
class TestRegisterPage(FunctionalTest):
def setUp(self):
self.url= ROOT +'/tukker/default/user/register'
get_browser = self.browser.get(self.url)
path_to_database = path.join(path.curdir, "databases")
self.db = DAL('sqlite://storage.sqlite', folder=path_to_database)
self.db.import_table_definitions(path_to_database)
self.db.auth_user.insert(
first_name = 'Duplicate',
last_name = 'Nickname',
email='*****@*****.**',
password = '******',
nickname = 'duplicate'
)
self.db.commit()
def test_can_view_home_page(self):
response_code = self.get_response_code(self.url)
self.assertEqual(response_code, 200)
def test_has_right_title(self):
title=self.browser.title
self.assertEqual('Tukker.Me Registration', title)
def test_put_values_in_register_form(self):
first_name = self.browser.find_element_by_name('first_name')
first_name.send_keys("John")
last_name = self.browser.find_element_by_name('last_name')
last_name.send_keys("Tukker")
email = self.browser.find_element_by_name('email')
email.send_keys("*****@*****.**")
password = self.browser.find_element_by_name('password')
password.send_keys("pass")
verify_password = self.browser.find_element_by_name('password_two')
verify_password.send_keys("pass")
nickname = self.browser.find_element_by_name('nickname')
nickname.send_keys("john")
image = self.browser.find_element_by_name('image')
path_to_image = path.abspath(path.join(path.curdir, "fts/test_image.png"))
image.send_keys(path_to_image)
register_button = self.browser.find_element_by_xpath("//input[@type='submit']")
register_button.click()
welcome_message = self.browser.find_element_by_css_selector(".alert")
self.assertEqual('Welcome to Tukker.Me', welcome_message.text)
self.url = ROOT + '/tukker/default/user/logout'
get_browser = self.browser.get(self.url)
def test_put_values_in_register_form_with_empty_nickname(self):
first_name = self.browser.find_element_by_name('first_name')
first_name.send_keys("John")
last_name = self.browser.find_element_by_name('last_name')
last_name.send_keys("Tukker")
email = self.browser.find_element_by_name('email')
email.send_keys("*****@*****.**")
password = self.browser.find_element_by_name('password')
password.send_keys("pass")
verify_password = self.browser.find_element_by_name('password_two')
verify_password.send_keys("pass")
# nickname = self.browser.find_element_by_name('nickname')
# nickname.send_keys("john")
image = self.browser.find_element_by_name('image')
path_to_image = path.abspath(path.join(path.curdir, "fts/test_image.png"))
image.send_keys(path_to_image)
register_button = self.browser.find_element_by_xpath("//input[@type='submit']")
register_button.click()
error_message = self.browser.find_element_by_id("nickname__error")
self.assertEqual('enter a value', error_message.text)
def test_put_values_in_register_form_nickname_with_24_chars(self):
first_name = self.browser.find_element_by_name('first_name')
first_name.send_keys("John")
last_name = self.browser.find_element_by_name('last_name')
last_name.send_keys("Tukker")
email = self.browser.find_element_by_name('email')
email.send_keys("*****@*****.**")
password = self.browser.find_element_by_name('password')
password.send_keys("pass")
verify_password = self.browser.find_element_by_name('password_two')
verify_password.send_keys("pass")
nickname = self.browser.find_element_by_name('nickname')
nickname.send_keys("012345678901234567890123")
image = self.browser.find_element_by_name('image')
path_to_image = path.abspath(path.join(path.curdir, "fts/test_image.png"))
image.send_keys(path_to_image)
register_button = self.browser.find_element_by_xpath("//input[@type='submit']")
register_button.click()
error_message = self.browser.find_element_by_id("nickname__error")
self.assertEqual('enter from 0 to 20 characters', error_message.text)
def test_put_values_in_register_form_nickname_unique(self):
first_name = self.browser.find_element_by_name('first_name')
first_name.send_keys("John")
last_name = self.browser.find_element_by_name('last_name')
last_name.send_keys("Tukker")
email = self.browser.find_element_by_name('email')
email.send_keys("*****@*****.**")
password = self.browser.find_element_by_name('password')
password.send_keys("pass")
verify_password = self.browser.find_element_by_name('password_two')
verify_password.send_keys("pass")
nickname = self.browser.find_element_by_name('nickname')
nickname.send_keys("duplicate")
image = self.browser.find_element_by_name('image')
path_to_image = path.abspath(path.join(path.curdir, "fts/test_image.png"))
image.send_keys(path_to_image)
register_button = self.browser.find_element_by_xpath("//input[@type='submit']")
register_button.click()
error_message = self.browser.find_element_by_id("nickname__error")
self.assertEqual('value already in database or empty', error_message.text)
def tearDown(self):
self.db.auth_user.truncate()
self.db.commit()
dirPath = path.join(path.curdir, "uploads")
fileList = os.listdir(dirPath)
for fileName in fileList:
os.remove(dirPath + "/" + fileName)
def testRun(self):
db = DAL('sqlite:memory:')
db.define_table('person', Field('name', default="Michael"),Field('uuid'))
db.define_table('pet',Field('friend',db.person),Field('name'))
dbdict = db.as_dict(flat=True, sanitize=False)
assert isinstance(dbdict, dict)
uri = dbdict["uri"]
assert isinstance(uri, basestring) and uri
assert len(dbdict["items"]) == 2
assert len(dbdict["items"]["person"]["items"]) == 3
assert dbdict["items"]["person"]["items"]["name"]["type"] == db.person.name.type
assert dbdict["items"]["person"]["items"]["name"]["default"] == db.person.name.default
assert dbdict
db2 = DAL(dbdict)
assert len(db.tables) == len(db2.tables)
assert hasattr(db2, "pet") and isinstance(db2.pet, Table)
assert hasattr(db2.pet, "friend") and isinstance(db2.pet.friend, Field)
have_serializers = True
try:
import serializers
dbjson = db.as_json(sanitize=False)
assert isinstance(dbjson, basestring) and len(dbjson) > 0
db3 = DAL(serializers.loads_json(dbjson))
assert hasattr(db3, "person") and hasattr(db3.person, "uuid") and\
db3.person.uuid.type == db.person.uuid.type
db3.pet.drop()
db3.person.drop()
db3.commit()
except ImportError:
pass
mpfc = "Monty Python's Flying Circus"
dbdict4 = {"uri": 'sqlite:memory:',
"items":{"staff":{"items": {"name":
{"default":"Michael"},
"food":
{"default":"Spam"}}},
"show":{"items": {"name":
{"default":mpfc},
"rating":
{"type":"double"}}}}}
db4 = DAL(dbdict4)
assert "staff" in db4.tables
assert "name" in db4.staff
assert db4.show.rating.type == "double"
assert db4.show.insert() is not None
assert db4(db4.show).select().first().id == 1
assert db4(db4.show).select().first().name == mpfc
dbdict5 = {"uri": 'sqlite:memory:'}
db5 = DAL(dbdict5)
assert db5.tables in ([], None)
dbdict6 = {"items":{"staff":{},
"show":{"items": {"name": {},
"rating":
{"type":"double"}}}}}
db6 = DAL(dbdict6)
assert len(db6["staff"].fields) == 1
assert "name" in db6["show"].fields
# the following would fail (see issue 1332)
# assert db6.staff.insert() is not None
# assert db6(db6.staff).select().first().id == 1
dbdict7 = {}
db7 = DAL(dbdict7)
db7.tables() in (None, [])
assert not str(db7) in ("", None)
db6.staff.drop()
db6.show.drop()
db6.commit()
db4.staff.drop()
db4.show.drop()
db4.commit()
db2.pet.drop()
db2.person.drop()
db2.commit()
db.pet.drop()
db.person.drop()
db.commit()
class TestRegisterPage(FunctionalTest):
def setUp(self):
self.url = ROOT + '/tukker/default/user/register'
get_browser = self.browser.get(self.url)
path_to_database = path.join(path.curdir, "databases")
self.db = DAL('sqlite://storage.sqlite', folder=path_to_database)
self.db.import_table_definitions(path_to_database)
self.db.auth_user.insert(first_name='Duplicate',
last_name='Nickname',
email='*****@*****.**',
password='******',
nickname='duplicate')
self.db.commit()
def test_can_view_home_page(self):
response_code = self.get_response_code(self.url)
self.assertEqual(response_code, 200)
def test_has_right_title(self):
title = self.browser.title
self.assertEqual('Tukker.Me Registration', title)
def test_put_values_in_register_form(self):
first_name = self.browser.find_element_by_name('first_name')
first_name.send_keys("John")
last_name = self.browser.find_element_by_name('last_name')
last_name.send_keys("Tukker")
email = self.browser.find_element_by_name('email')
email.send_keys("*****@*****.**")
password = self.browser.find_element_by_name('password')
password.send_keys("pass")
verify_password = self.browser.find_element_by_name('password_two')
verify_password.send_keys("pass")
nickname = self.browser.find_element_by_name('nickname')
nickname.send_keys("john")
image = self.browser.find_element_by_name('image')
path_to_image = path.abspath(
path.join(path.curdir, "fts/test_image.png"))
image.send_keys(path_to_image)
register_button = self.browser.find_element_by_xpath(
"//input[@type='submit']")
register_button.click()
welcome_message = self.browser.find_element_by_css_selector(".alert")
self.assertEqual('Welcome to Tukker.Me', welcome_message.text)
self.url = ROOT + '/tukker/default/user/logout'
get_browser = self.browser.get(self.url)
def test_put_values_in_register_form_with_empty_nickname(self):
first_name = self.browser.find_element_by_name('first_name')
first_name.send_keys("John")
last_name = self.browser.find_element_by_name('last_name')
last_name.send_keys("Tukker")
email = self.browser.find_element_by_name('email')
email.send_keys("*****@*****.**")
password = self.browser.find_element_by_name('password')
password.send_keys("pass")
verify_password = self.browser.find_element_by_name('password_two')
verify_password.send_keys("pass")
# nickname = self.browser.find_element_by_name('nickname')
# nickname.send_keys("john")
image = self.browser.find_element_by_name('image')
path_to_image = path.abspath(
path.join(path.curdir, "fts/test_image.png"))
image.send_keys(path_to_image)
register_button = self.browser.find_element_by_xpath(
"//input[@type='submit']")
register_button.click()
error_message = self.browser.find_element_by_id("nickname__error")
self.assertEqual('enter a value', error_message.text)
def test_put_values_in_register_form_nickname_with_24_chars(self):
first_name = self.browser.find_element_by_name('first_name')
first_name.send_keys("John")
last_name = self.browser.find_element_by_name('last_name')
last_name.send_keys("Tukker")
email = self.browser.find_element_by_name('email')
email.send_keys("*****@*****.**")
password = self.browser.find_element_by_name('password')
password.send_keys("pass")
verify_password = self.browser.find_element_by_name('password_two')
verify_password.send_keys("pass")
nickname = self.browser.find_element_by_name('nickname')
nickname.send_keys("012345678901234567890123")
image = self.browser.find_element_by_name('image')
path_to_image = path.abspath(
path.join(path.curdir, "fts/test_image.png"))
image.send_keys(path_to_image)
register_button = self.browser.find_element_by_xpath(
"//input[@type='submit']")
register_button.click()
error_message = self.browser.find_element_by_id("nickname__error")
self.assertEqual('enter from 0 to 20 characters', error_message.text)
def test_put_values_in_register_form_nickname_unique(self):
first_name = self.browser.find_element_by_name('first_name')
first_name.send_keys("John")
last_name = self.browser.find_element_by_name('last_name')
last_name.send_keys("Tukker")
email = self.browser.find_element_by_name('email')
email.send_keys("*****@*****.**")
password = self.browser.find_element_by_name('password')
password.send_keys("pass")
verify_password = self.browser.find_element_by_name('password_two')
verify_password.send_keys("pass")
nickname = self.browser.find_element_by_name('nickname')
nickname.send_keys("duplicate")
image = self.browser.find_element_by_name('image')
path_to_image = path.abspath(
path.join(path.curdir, "fts/test_image.png"))
image.send_keys(path_to_image)
register_button = self.browser.find_element_by_xpath(
"//input[@type='submit']")
register_button.click()
error_message = self.browser.find_element_by_id("nickname__error")
self.assertEqual('value already in database or empty',
error_message.text)
def tearDown(self):
self.db.auth_user.truncate()
self.db.commit()
dirPath = path.join(path.curdir, "uploads")
fileList = os.listdir(dirPath)
for fileName in fileList:
os.remove(dirPath + "/" + fileName)
from dal import DAL, Field
import re
db = DAL('sqlite://doxa.sqlite3')
db.define_table('dict',
Field('word'),
Field('definition'),
Field('related'))
db.dict.truncate()
index = 0
for line in open("words_app.csv"):
if line[0].isdigit() or line.startswith("#"): continue
line = line.rstrip(",\n")
line = line.split(",", 1)
key, val = line[0], line[1]
word = key
if ')' in word:
word = re.sub(r'\s*\(.+?\)\s*', '', word)
db.dict.insert(word=word, definition=key, related=val)
index += 1
db.commit()
print 'inserted %d words' % index
class Runtime(object):
def __init__(self, a):
global LEGAL_CMDS
self.db_name = ''
self.db_pass = ''
self.db_host = ''
self.db_table = ''
self.db_user = ''
self._settings()
self._profiles()
self.propagate()
self.uid = Record().generate()
self.o = Output()
self.type = 'CLIENT'
self.help = 0
self.clean = 0
self.name = "N/A"
for _i in range(0, len(a)):
i = a[_i]
try:
j = a[_i + 1]
except:
j = a[_i]
if i in ['-c', '--client']:
self.type = 'CLIENT'
if i in ['-s', '--server']:
self.type = 'SERVER'
if i in ['-h', '--help']:
self.help = True
if i in ['-b', '--backup']:
self.backup = True
if i in ['-r', '--restore']:
self.restore = True
if i in ['-i', '--ip']:
self.ip = j
if i in ['-p', '--port']:
self.port = j
if i in ['-x', '--compress']:
self.compress = True
if i in ['-e', '--encrypt']:
self.encrypt = True
if i in ['-l', '--local']:
self.local = True
if i in ['-f', '--folder']:
self.folder = j
if i in ['-l', '--list']:
self.list = True
if i in ['-p', '--profiler']:
self.profiler = True
if i in ['-rm', '--remove']:
self.remove = True
if i in ['-n', '--name']:
self.name = j
if i in ['-cl', '--clean']:
self.clean = True
if i in ['-id', '--id']:
self.id = j
if self.help:
self._help()
return
self.o.show("Running in {0} mode".format(self.type))
self.perform()
"""
try to set up the database
"""
def propagate(self):
if self.db_family == 'mysql':
self.db = DAL(self.db_family + '://' + self.db_user + ':' +
self.db_pass + '@' + self.db_host + '/' +
self.db_name,
pool_size=1,
migrate_enabled=False)
self.db.executesql("""
CREATE DATABASE IF NOT EXISTS {0};
""".format(self.db_name))
self.db.executesql("""
CREATE TABLE IF NOT EXISTS {0} (
`id` int,
`uid` varchar(255),
`name` varchar(255),
`time` varchar(255),
`folder` varchar(255),
`size` int,
`local` varchar(255)
); """.format(self.db_table))
else:
self.db = DAL('sqlite://storage.db')
self.db.define_table(self.db_table,
Field('id'),
Field('uid'),
Field('name'),
Field('time'),
Field('folder'),
Field('size'),
Field('local'),
migrate=False)
def perform(self):
is_success = False
if 'folder' in dir(self):
self.size = Util().getFolderSize(self.folder)
if 'profiler' in dir(self):
profiler = Profiler(self.profiles, self.server_ip,
self.server_port, self.ip, self.port, self.db,
self.db_table).run()
if not 'local' in dir(self):
self.isLocal = False
if self.type == 'CLIENT':
client = Client(self.port, self.ip,
dict(ip=self.server_ip, port=self.server_port))
self.o.show("Running on port: {0}, ip: {1}".format(
self.server_port, self.server_ip))
else:
server = Server(self.server_port, self.server_ip, self.db,
self.db_table)
self.o.show("Running on port: {0}, ip: {1}".format(
self.server_port, self.server_ip))
server.run()
# exit now and loop
else:
self.isLocal = True
if 'backup' in dir(self):
if not 'folder' in dir(self):
pass
else:
self.o.show("Gathering files.. this can take awhile")
bkp = Backup(self.uid, self.folder)
bkp.run()
if bkp.status == 1:
self.db[self.db_table].insert(uid=self.uid,
time=time.time(),
folder=self.folder,
size=self.size,
local=self.isLocal,
name=self.name)
self.db.commit()
is_success = True
if self.isLocal:
self.o.show("Backup Ok -- Now saving to disk")
self.o.show(
"Local Backup has been successfully stored")
self.o.show("Transaction ID: " + self.uid)
else:
fc = open(bkp.get(), 'r').read().decode('utf-8')
client.run('BACKUP', self.folder, self.uid, fc,
self.name, self.size)
if client.status:
self.o.show(
"Backup Ok -- Now transferring to server")
fp = client.get()
if len(re.findall("SUCCESS", fp)) > 0:
self.o.show(
"Remote Backup has been successfully transferred"
)
self.o.show("Transaction ID: " + self.uid)
#os.remove(bkp.get())
else:
self.o.show(
"Something went wrong on the server.. couldnt back that folder. Reverting changes"
)
else:
pass
else:
pass
if 'restore' in dir(self):
if 'id' in dir(self):
r = self.db(
self.db[self.db_table].uid == self.id).select().first()
if not r:
self.o.show("ERROR: Backup not found.")
return
self.folder = r['folder']
self.local = r['local']
self.ruid = r['uid']
if self.clean:
self.o.show("Cleaning directory..")
if self.isLocal:
self.o.show("Restore Ok -- Now restoring compartment")
rst = Restore(False, self.folder, self.clean)
rst.run(True, self.ruid)
if rst.status:
self.o.show("Restore has been successfully performed")
else:
self.o.show("Pinging server for restore..")
client.run('RESTORE', self.folder, self.ruid, '')
if client.status:
self.o.show(
"Restore Retrieval Ok -- now attempting to restore"
)
fp = open(LOCAL_BACKUP_DIR + self.ruid + '.zip', 'w+')
fp.write(client.get())
fp.close()
rst = Restore(LOCAL_BACKUP_DIR + self.ruid + '.zip',
self.folder, self.clean)
rst.run(True, self.ruid)
if rst.status:
self.o.show("Restore Successful")
else:
pass
## important to check for success
## on this command
if 'remove' in dir(self) and is_success:
if 'folder' in dir(self):
shutil.rmtree(self.folder)
self.o.show("Directory successfully deleted..")
if 'list' in dir(self):
rows = self.db(self.db[self.db_table].time > 0).select().as_list()
self.o.show("Full list of stored backups")
for i in rows:
print i
def _help(self):
print """
usage: lback [options] required_input required_input2
options:
-c, --client Run a command as a client (required)
-s, --server Initiate a server (required)
-b, --backup Run a backup
-r, --restore Run a restore
-f, --folder Specify a folder (required *) for backups
-i, --id Specify an id (required *) for restores
-n, --name Name for backup (optional)
-rm, --remove Remove a directory on backup
-x, --compress Compress an archive (default)
-l, --list Generate a full list of your backups
-i, --ip Specify an ip (overridden by settings.json if found)
-p, --port Specify a port (overridden by settings.json if found)
-h, --help Print this text
"""
def try_hard_to_find(self):
pass
def _settings(self):
if os.path.isfile("./settings.json"):
settings = json.loads(open("./settings.json").read())
elif os.path.isfile("../settings.json"):
settings = json.loads(open("../settings.json").read())
for i in settings.keys():
setattr(self, i, settings[i])
self.ip = settings['client_ip']
self.port = settings['client_port']
self.server_ip = settings['server_ip']
self.server_port = settings['server_port']
if not 'db_family' in settings.keys():
self.db_family = 'mysql'
else:
self.db_family = settings['db_family']
def _profiles(self):
if os.path.isfile("./profiles.json"):
self.profiles = json.loads(open("./profiles.json").read())
elif os.path.isfile("../profiles.json"):
self.profiles = json.loads(open("../profiles.json").read())
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('person', Field('name', default="Michael"),Field('uuid'))
db.define_table('pet',Field('friend',db.person),Field('name'))
dbdict = db.as_dict(flat=True, sanitize=False)
assert isinstance(dbdict, dict)
uri = dbdict["uri"]
assert isinstance(uri, basestring) and uri
assert len(dbdict["items"]) == 2
assert len(dbdict["items"]["person"]["items"]) == 3
assert dbdict["items"]["person"]["items"]["name"]["type"] == db.person.name.type
assert dbdict["items"]["person"]["items"]["name"]["default"] == db.person.name.default
assert dbdict
db2 = DAL(dbdict, check_reserved=['all'])
assert len(db.tables) == len(db2.tables)
assert hasattr(db2, "pet") and isinstance(db2.pet, Table)
assert hasattr(db2.pet, "friend") and isinstance(db2.pet.friend, Field)
db.pet.drop()
db.commit()
db2.commit()
have_serializers = True
try:
import serializers
dbjson = db.as_json(sanitize=False)
assert isinstance(dbjson, basestring) and len(dbjson) > 0
unicode_keys = True
if sys.version < "2.6.5":
unicode_keys = False
db3 = DAL(serializers.loads_json(dbjson,
unicode_keys=unicode_keys))
assert hasattr(db3, "person") and hasattr(db3.person, "uuid") and\
db3.person.uuid.type == db.person.uuid.type
db3.person.drop()
db3.commit()
except ImportError:
pass
mpfc = "Monty Python's Flying Circus"
dbdict4 = {"uri": DEFAULT_URI,
"items":{"staff":{"items": {"name":
{"default":"Michael"},
"food":
{"default":"Spam"},
"tvshow":
{"type": "reference tvshow"}
}},
"tvshow":{"items": {"name":
{"default":mpfc},
"rating":
{"type":"double"}}}}}
db4 = DAL(dbdict4, check_reserved=['all'])
assert "staff" in db4.tables
assert "name" in db4.staff
assert db4.tvshow.rating.type == "double"
assert (db4.tvshow.insert(), db4.tvshow.insert(name="Loriot"),
db4.tvshow.insert(name="Il Mattatore")) == (1, 2, 3)
assert db4(db4.tvshow).select().first().id == 1
assert db4(db4.tvshow).select().first().name == mpfc
db4.staff.drop()
db4.tvshow.drop()
db4.commit()
dbdict5 = {"uri": DEFAULT_URI}
db5 = DAL(dbdict5, check_reserved=['all'])
assert db5.tables in ([], None)
assert not (str(db5) in ("", None))
dbdict6 = {"uri": DEFAULT_URI,
"items":{"staff":{},
"tvshow":{"items": {"name": {},
"rating":
{"type":"double"}
}
}
}
}
db6 = DAL(dbdict6, check_reserved=['all'])
assert len(db6["staff"].fields) == 1
assert "name" in db6["tvshow"].fields
assert db6.staff.insert() is not None
assert db6(db6.staff).select().first().id == 1
db6.staff.drop()
db6.tvshow.drop()
db6.commit()
def testRun(self):
db = DAL(DEFAULT_URI, check_reserved=['all'])
db.define_table('person', Field('name', default="Michael"),
Field('uuid'))
db.define_table('pet', Field('friend', db.person), Field('name'))
dbdict = db.as_dict(flat=True, sanitize=False)
assert isinstance(dbdict, dict)
uri = dbdict["uri"]
assert isinstance(uri, basestring) and uri
assert len(dbdict["items"]) == 2
assert len(dbdict["items"]["person"]["items"]) == 3
assert dbdict["items"]["person"]["items"]["name"][
"type"] == db.person.name.type
assert dbdict["items"]["person"]["items"]["name"][
"default"] == db.person.name.default
assert dbdict
db2 = DAL(dbdict, check_reserved=['all'])
assert len(db.tables) == len(db2.tables)
assert hasattr(db2, "pet") and isinstance(db2.pet, Table)
assert hasattr(db2.pet, "friend") and isinstance(db2.pet.friend, Field)
db.pet.drop()
db.commit()
db2.commit()
have_serializers = True
try:
import serializers
dbjson = db.as_json(sanitize=False)
assert isinstance(dbjson, basestring) and len(dbjson) > 0
unicode_keys = True
if sys.version < "2.6.5":
unicode_keys = False
db3 = DAL(serializers.loads_json(dbjson,
unicode_keys=unicode_keys))
assert hasattr(db3, "person") and hasattr(db3.person, "uuid") and\
db3.person.uuid.type == db.person.uuid.type
db3.person.drop()
db3.commit()
except ImportError:
pass
mpfc = "Monty Python's Flying Circus"
dbdict4 = {
"uri": DEFAULT_URI,
"items": {
"staff": {
"items": {
"name": {
"default": "Michael"
},
"food": {
"default": "Spam"
},
"tvshow": {
"type": "reference tvshow"
}
}
},
"tvshow": {
"items": {
"name": {
"default": mpfc
},
"rating": {
"type": "double"
}
}
}
}
}
db4 = DAL(dbdict4, check_reserved=['all'])
assert "staff" in db4.tables
assert "name" in db4.staff
assert db4.tvshow.rating.type == "double"
assert (db4.tvshow.insert(), db4.tvshow.insert(name="Loriot"),
db4.tvshow.insert(name="Il Mattatore")) == (1, 2, 3)
assert db4(db4.tvshow).select().first().id == 1
assert db4(db4.tvshow).select().first().name == mpfc
db4.staff.drop()
db4.tvshow.drop()
db4.commit()
dbdict5 = {"uri": DEFAULT_URI}
db5 = DAL(dbdict5, check_reserved=['all'])
assert db5.tables in ([], None)
assert not (str(db5) in ("", None))
dbdict6 = {
"uri": DEFAULT_URI,
"items": {
"staff": {},
"tvshow": {
"items": {
"name": {},
"rating": {
"type": "double"
}
}
}
}
}
db6 = DAL(dbdict6, check_reserved=['all'])
assert len(db6["staff"].fields) == 1
assert "name" in db6["tvshow"].fields
assert db6.staff.insert() is not None
assert db6(db6.staff).select().first().id == 1
db6.staff.drop()
db6.tvshow.drop()
db6.commit()
import re
from dal import DAL, Field
if __name__ == '__main__':
dicti = {'name':12}
bidul = 'bidul'
db = DAL(('sqlite://openbioreactor.sqlite','mysql://*****:*****@localhost/x'),folder=None)
db.executesql("CREATE TABLE TBLB (PersonID int,LastName varchar(255),FirstName varchar(255),Address varchar(255))")
db.executesql("INSERT INTO TBLB (PersonID, LastName, FirstName, Address) VALUES (test, example, tutorial, release)")
db.commit()
class TestProfile(FunctionalTest):
def setUp(self):
path_to_database = path.join(path.curdir, "databases")
self.db = DAL('sqlite://storage.sqlite', folder=path_to_database)
self.db.import_table_definitions(path_to_database)
self.create_user()
self.login()
self.url = ROOT + '/tukker/default/profile/john'
get_browser=self.browser.get(self.url)
def test_can_view_profile(self):
response_code = self.get_response_code(self.url)
self.assertEqual(response_code, 200)
def test_has_right_title(self):
title=self.browser.title
self.assertEqual("john's Profile", title)
def test_has_page_the_needed_elements(self):
# name = self.browser.find_element_by_id('profile-name')
# self.assertEqual(name.text, "john")
nickname = self.browser.find_element_by_id('nickname')
self.assertEqual(nickname.text, "john")
# image = self.browser.find_element_by_id('profile-image')
# self.assertEqual("auth_user.image", image.get_attribute("src"))
def tearDown(self):
self.url = ROOT + '/tukker/default/user/logout'
get_browser=self.browser.get(self.url)
self.db.auth_user.truncate()
self.db.commit()
dirPath = path.join(path.curdir, "uploads")
fileList = os.listdir(dirPath)
for fileName in fileList:
os.remove(dirPath + "/" + fileName)
def create_user(self):
self.url = ROOT + '/tukker/default/user/register'
get_browser = self.browser.get(self.url)
first_name = self.browser.find_element_by_name('first_name')
first_name.send_keys("John")
last_name = self.browser.find_element_by_name('last_name')
last_name.send_keys("Tukker")
email = self.browser.find_element_by_name('email')
email.send_keys("*****@*****.**")
password = self.browser.find_element_by_name('password')
password.send_keys("pass")
verify_password = self.browser.find_element_by_name('password_two')
verify_password.send_keys("pass")
nickname = self.browser.find_element_by_name('nickname')
nickname.send_keys("john")
image = self.browser.find_element_by_name('image')
path_to_image = path.abspath(path.join(path.curdir, "fts/test_image.png"))
image.send_keys(path_to_image)
register_button = self.browser.find_element_by_xpath("//input[@type='submit']")
register_button.click()
self.url = ROOT + '/tukker/default/user/logout'
get_browser = self.browser.get(self.url)
def login(self):
self.url = ROOT + '/tukker/default/user/logout'
get_browser = self.browser.get(self.url)
self.url = ROOT + '/tukker/default/user/login'
get_browser=self.browser.get(self.url)
user_email = self.browser.find_element_by_id("auth_user_email")
user_email.send_keys("*****@*****.**")
user_password = self.browser.find_element_by_id("auth_user_password")
user_password.send_keys("pass")
submit_button = self.browser.find_element_by_xpath("//input[@type='submit']")
submit_button.click()
class Runtime(object):
def __init__(self, a):
global LEGAL_CMDS
self.db_name = ''
self.db_pass = ''
self.db_host = ''
self.db_table = ''
self.db_user = ''
self._settings()
self._profiles()
self.propagate()
self.uid = Record().generate()
self.o = Output()
self.type = 'CLIENT'
self.help = 0
self.clean = 0
self.name = "N/A"
for _i in range(0, len(a)):
i = a[_i]
try:
j = a[_i + 1]
except:
j = a[_i]
if i in ['-c', '--client']:
self.type = 'CLIENT'
if i in ['-s', '--server']:
self.type = 'SERVER'
if i in ['-h', '--help']:
self.help = True
if i in ['-b', '--backup']:
self.backup = True
if i in ['-r', '--restore']:
self.restore = True
if i in ['-i', '--ip']:
self.ip = j
if i in ['-p', '--port']:
self.port = j
if i in ['-x', '--compress']:
self.compress = True
if i in ['-e', '--encrypt']:
self.encrypt = True
if i in ['-l', '--local']:
self.local = True
if i in ['-f', '--folder']:
self.folder = j
if i in ['-l', '--list']:
self.list = True
if i in ['-p', '--profiler']:
self.profiler = True
if i in ['-rm', '--remove']:
self.remove = True
if i in ['-n', '--name']:
self.name = j
if i in ['-cl', '--clean']:
self.clean = True
if i in ['-id', '--id']:
self.id = j
if self.help:
self._help()
return
self.o.show("Running in {0} mode".format(self.type))
self.perform()
"""
try to set up the database
"""
def propagate(self):
if self.db_family == 'mysql':
self.db = DAL(self.db_family + '://' + self.db_user + ':' + self.db_pass + '@' + self.db_host + '/' + self.db_name, pool_size=1, migrate_enabled=False)
self.db.executesql("""
CREATE DATABASE IF NOT EXISTS {0};
""".format(self.db_name))
self.db.executesql("""
CREATE TABLE IF NOT EXISTS {0} (
`id` int,
`uid` varchar(255),
`name` varchar(255),
`time` varchar(255),
`folder` varchar(255),
`size` int,
`local` varchar(255)
); """.format(self.db_table))
else:
self.db = DAL('sqlite://storage.db')
self.db.define_table(
self.db_table,
Field('id'),
Field('uid'),
Field('name'),
Field('time'),
Field('folder'),
Field('size'),
Field('local'),
migrate=False
)
def perform(self):
is_success = False
if 'folder' in dir(self):
self.size = Util().getFolderSize(self.folder)
if 'profiler' in dir(self):
profiler = Profiler(self.profiles,self.server_ip,self.server_port,self.ip,self.port,self.db,self.db_table).run()
if not 'local' in dir(self):
self.isLocal = False
if self.type == 'CLIENT':
client = Client(self.port, self.ip, dict(ip=self.server_ip, port=self.server_port))
self.o.show("Running on port: {0}, ip: {1}".format(self.server_port, self.server_ip))
else:
server = Server(self.server_port, self.server_ip, self.db, self.db_table)
self.o.show("Running on port: {0}, ip: {1}".format(self.server_port, self.server_ip))
server.run()
# exit now and loop
else:
self.isLocal = True
if 'backup' in dir(self):
if not 'folder' in dir(self):
pass
else:
self.o.show("Gathering files.. this can take awhile")
bkp = Backup(self.uid, self.folder)
bkp.run()
if bkp.status == 1:
self.db[self.db_table].insert(uid=self.uid, time=time.time(), folder=self.folder, size=self.size, local=self.isLocal,name=self.name)
self.db.commit()
is_success = True
if self.isLocal:
self.o.show("Backup Ok -- Now saving to disk")
self.o.show("Local Backup has been successfully stored")
self.o.show("Transaction ID: " + self.uid)
else:
fc = open(bkp.get(), 'r').read().decode('utf-8')
client.run('BACKUP', self.folder, self.uid, fc, self.name,self.size)
if client.status:
self.o.show("Backup Ok -- Now transferring to server")
fp = client.get()
if len(re.findall("SUCCESS", fp)) > 0:
self.o.show("Remote Backup has been successfully transferred")
self.o.show("Transaction ID: " + self.uid)
#os.remove(bkp.get())
else:
self.o.show("Something went wrong on the server.. couldnt back that folder. Reverting changes")
else:
pass
else:
pass
if 'restore' in dir(self):
if 'id' in dir(self):
r = self.db(self.db[self.db_table].uid == self.id).select().first()
if not r:
self.o.show("ERROR: Backup not found.")
return
self.folder = r['folder']
self.local = r['local']
self.ruid = r['uid']
if self.clean:
self.o.show("Cleaning directory..")
if self.isLocal:
self.o.show("Restore Ok -- Now restoring compartment")
rst = Restore(False, self.folder, self.clean)
rst.run(True, self.ruid)
if rst.status:
self.o.show("Restore has been successfully performed")
else:
self.o.show("Pinging server for restore..")
client.run('RESTORE', self.folder, self.ruid, '')
if client.status:
self.o.show("Restore Retrieval Ok -- now attempting to restore")
fp = open(LOCAL_BACKUP_DIR + self.ruid + '.zip', 'w+')
fp.write(client.get())
fp.close()
rst = Restore(LOCAL_BACKUP_DIR + self.ruid + '.zip', self.folder, self.clean)
rst.run(True, self.ruid)
if rst.status:
self.o.show("Restore Successful")
else:
pass
## important to check for success
## on this command
if 'remove' in dir(self) and is_success:
if 'folder' in dir(self):
shutil.rmtree(self.folder)
self.o.show("Directory successfully deleted..")
if 'list' in dir(self):
rows = self.db(self.db[self.db_table].time > 0).select().as_list()
self.o.show("Full list of stored backups")
for i in rows:
print i
def _help(self):
print """
usage: lback [options] required_input required_input2
options:
-c, --client Run a command as a client (required)
-s, --server Initiate a server (required)
-b, --backup Run a backup
-r, --restore Run a restore
-f, --folder Specify a folder (required *) for backups
-i, --id Specify an id (required *) for restores
-n, --name Name for backup (optional)
-rm, --remove Remove a directory on backup
-x, --compress Compress an archive (default)
-l, --list Generate a full list of your backups
-i, --ip Specify an ip (overridden by settings.json if found)
-p, --port Specify a port (overridden by settings.json if found)
-h, --help Print this text
"""
def try_hard_to_find(self):
pass
def _settings(self):
if os.path.isfile("./settings.json"):
settings = json.loads(open("./settings.json").read())
elif os.path.isfile("../settings.json"):
settings = json.loads(open("../settings.json").read())
for i in settings.keys():
setattr(self, i, settings[i])
self.ip = settings['client_ip']
self.port = settings['client_port']
self.server_ip = settings['server_ip']
self.server_port = settings['server_port']
if not 'db_family' in settings.keys():
self.db_family = 'mysql'
else:
self.db_family = settings['db_family']
def _profiles(self):
if os.path.isfile("./profiles.json"):
self.profiles = json.loads(open("./profiles.json").read())
elif os.path.isfile("../profiles.json"):
self.profiles = json.loads(open("../profiles.json").read())
def testRun(self):
db = DAL("sqlite:memory:")
db.define_table("person", Field("name", default="Michael"), Field("uuid"))
db.define_table("pet", Field("friend", db.person), Field("name"))
dbdict = db.as_dict(flat=True, sanitize=False)
assert isinstance(dbdict, dict)
uri = dbdict["uri"]
assert isinstance(uri, basestring) and uri
assert len(dbdict["items"]) == 2
assert len(dbdict["items"]["person"]["items"]) == 3
assert dbdict["items"]["person"]["items"]["name"]["type"] == db.person.name.type
assert dbdict["items"]["person"]["items"]["name"]["default"] == db.person.name.default
assert dbdict
db2 = DAL(dbdict)
assert len(db.tables) == len(db2.tables)
assert hasattr(db2, "pet") and isinstance(db2.pet, Table)
assert hasattr(db2.pet, "friend") and isinstance(db2.pet.friend, Field)
have_serializers = True
try:
import serializers
dbjson = db.as_json(sanitize=False)
assert isinstance(dbjson, basestring) and len(dbjson) > 0
db3 = DAL(serializers.loads_json(dbjson))
assert (
hasattr(db3, "person") and hasattr(db3.person, "uuid") and db3.person.uuid.type == db.person.uuid.type
)
db3.pet.drop()
db3.person.drop()
db3.commit()
except ImportError:
pass
mpfc = "Monty Python's Flying Circus"
dbdict4 = {
"uri": "sqlite:memory:",
"items": {
"staff": {
"items": {
"name": {"default": "Michael"},
"food": {"default": "Spam"},
"show": {"type": "reference show"},
}
},
"show": {"items": {"name": {"default": mpfc}, "rating": {"type": "double"}}},
},
}
db4 = DAL(dbdict4)
assert "staff" in db4.tables
assert "name" in db4.staff
assert db4.show.rating.type == "double"
assert (db4.show.insert(), db4.show.insert(name="Loriot"), db4.show.insert(name="Il Mattatore")) == (1, 2, 3)
assert db4(db4.show).select().first().id == 1
assert db4(db4.show).select().first().name == mpfc
dbdict5 = {"uri": "sqlite:memory:"}
db5 = DAL(dbdict5)
assert db5.tables in ([], None)
assert not (str(db5) in ("", None))
dbdict6 = {
"uri": "sqlite:memory:",
"items": {"staff": {}, "show": {"items": {"name": {}, "rating": {"type": "double"}}}},
}
db6 = DAL(dbdict6)
assert len(db6["staff"].fields) == 1
assert "name" in db6["show"].fields
assert db6.staff.insert() is not None
assert db6(db6.staff).select().first().id == 1
db6.staff.drop()
db6.show.drop()
db6.commit()
db4.staff.drop()
db4.show.drop()
db4.commit()
db2.pet.drop()
db2.person.drop()
db2.commit()
db.pet.drop()
db.person.drop()
db.commit()
