def test_13_index_exists(self):
db = Database(self._db_name)
table = db.table(self._tb_name)
table.index('by_age_name', '{age:03}{name}')
table.index('by_name', '{name}')
table.index('by_age', '{age:03}', duplicates=True)
self.assertTrue(table.exists('by_name'))
db.close()
db = Database(self._db_name)
table = db.table(self._tb_name)
self.assertTrue(table.exists('by_name'))
def test_12_table_reopen(self):
db = Database(self._db_name)
table = db.table(self._tb_name)
table.index('by_age_name', '{age:03}{name}')
table.index('by_name', '{name}')
table.index('by_age', '{age:03}', duplicates=True)
self.generate_data(db, self._tb_name)
db.close()
db = Database(self._db_name)
table = db.table(self._tb_name)
self.assertEqual(['by_age', 'by_age_name', 'by_name'], table.indexes)
def test_08_delete_binlog(self):
db = Database(self._db_name)
db.binlog(True)
self.generate_data(db, self._tb_name)
self.assertEqual(db.tables_all,
['__binlog__', '__metadata__', 'demo1'])
db.close()
db = Database(self._db_name)
db.drop(self._tb_name)
db.drop('__binlog__')
self.assertEqual(db.tables_all, ['__metadata__'])
with self.assertRaises(xTableMissing):
db.drop('fred')
db = Database("MyDatabase") # Open (/create) a database
table = db.table('people') # Open (/create) a table
print('>> Index table by name and age')
table.index('by_name', '{name}')
table.index('by_age', '{age:03}', duplicates=True)
print('>> Adding data')
for item in data:
table.append(item)
print("Count=", table.records)
print('>> Scanning table sequentially')
for record in table.find():
print('{name} is {age} years old'.format(**record))
print('>> Scanning tables in name order [string index]')
for record in table.find('by_name'):
print('{name} sorted alphabetically'.format(**record))
print('>> Scanning table in age order [numerical index]')
for record in table.find('by_age'):
print('{age} - {name} in ascending order of age'.format(**record))
print('>> Scanning on name index with filter')
for record in table.find('by_name', expression=lambda doc: doc['age'] > 40):
print('{name} is {age} years old (filtered age>40)'.format(**record))
db.drop('people')
db.close()
class UnitTests(unittest.TestCase):
def setUp(self):
call(['rm', '-rf', 'databases/test_orm_addressbook'])
self._db = Database('databases/test_orm_addressbook', size=size_mb(10))
self.tbl_address_book = AddressBookModel(table=self._db.table('address_book'))
self.tbl_business = BusinessModel(table=self._db.table('business'))
self.tbl_person = PersonModel(table=self._db.table('person'))
self.tbl_address = AddressModel(table=self._db.table('address'))
ManyToMany(self._db, self.tbl_address_book, self.tbl_business)
ManyToMany(self._db, self.tbl_address_book, self.tbl_person)
ManyToMany(self._db, self.tbl_business, self.tbl_person)
ManyToMany(self._db, self.tbl_business, self.tbl_address)
ManyToMany(self._db, self.tbl_person, self.tbl_address)
def tearDown(self):
self._db.close()
@pytest.fixture(autouse=True)
def capfd(self, capfd):
self.capfd = capfd
def test_01_add_addressbook(self):
self.tbl_address_book.add({'name': 'Personal'}).save()
book = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
self.assertEqual(book.name, 'Personal')
def test_02_add_business(self):
book = self.tbl_address_book.add({'name': 'Personal'})
book.business.append({'name': 'Business#1'}).person.append({'name': 'Person#1'}).address.append({'postcode':'PC001'})
book.business.append({'name': 'Business#2'}).person.append({'name': 'Person#2'}).address.append({'postcode':'PC002'})
book.business.append({'name': 'Business#3'}).person.append({'name': 'Person#3'}).address.append({'postcode':'PC003'})
book.save()
self.assertEqual(book.business[0].name, 'Business#1')
self.assertEqual(book.business[1].name, 'Business#2')
self.assertEqual(book.business[2].name, 'Business#3')
self.assertEqual(book.business[0].person[0].name, 'Person#1')
self.assertEqual(book.business[1].person[0].name, 'Person#2')
self.assertEqual(book.business[2].person[0].name, 'Person#3')
self.assertEqual(book.business[0].person[0].address[0].postcode, 'PC001')
self.assertEqual(book.business[1].person[0].address[0].postcode, 'PC002')
self.assertEqual(book.business[2].person[0].address[0].postcode, 'PC003')
book = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
print(book)
print(book.business)
self.assertEqual(book.business[0].name, 'Business#1')
self.assertEqual(book.business[1].name, 'Business#2')
self.assertEqual(book.business[2].name, 'Business#3')
self.assertEqual(book.business[0].person[0].name, 'Person#1')
self.assertEqual(book.business[1].person[0].name, 'Person#2')
self.assertEqual(book.business[2].person[0].name, 'Person#3')
self.assertEqual(book.business[0].person[0].address[0].postcode, 'PC001')
self.assertEqual(book.business[1].person[0].address[0].postcode, 'PC002')
self.assertEqual(book.business[2].person[0].address[0].postcode, 'PC003')
def test_03_add_multiple_person(self):
book = self.tbl_address_book.add({'name': 'Personal'})
book.business.append({'name': 'Business#1'}).person.append({'name': 'Person#1'}).address.append({'postcode':'PC001'})
book.business.append({'name': 'Business#2'}).person.append({'name': 'Person#2'}).address.append({'postcode':'PC002'})
book.business.append({'name': 'Business#3'}).person.append({'name': 'Person#3'}).address.append({'postcode':'PC003'})
book.save()
business = list(self.tbl_business.find(expression=lambda doc: doc['name'] == 'Business#1'))[0]
business.person.append({'name': 'Appended Person#1'})
business.person.append({'name': 'Appended Person#2'})
business.person.append({'name': 'Appended Person#3'})
self.assertEqual(len(business.person), 4)
business.save()
self.assertEqual(len(business.person), 4)
self.assertEqual(business.person[1].name, 'Appended Person#1')
self.assertEqual(business.person[2].name, 'Appended Person#2')
self.assertEqual(business.person[3].name, 'Appended Person#3')
book = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
self.assertEqual(book.business[0].person[1].name, 'Appended Person#1')
self.assertEqual(book.business[0].person[2].name, 'Appended Person#2')
self.assertEqual(book.business[0].person[3].name, 'Appended Person#3')
def test_04_add_and_delete(self):
book = self.tbl_address_book.add({'name': 'Personal'})
book.business.append({'name': 'Business#1'}).person.append({'name': 'Person#1'}).address.append({'postcode':'PC001'})
book.business.append({'name': 'Business#2'}).person.append({'name': 'Person#2'}).address.append({'postcode':'PC002'})
book.business.append({'name': 'Business#3'}).person.append({'name': 'Person#3'}).address.append({'postcode':'PC003'})
book.save()
business = list(self.tbl_business.find(expression=lambda doc: doc['name'] == 'Business#1'))[0]
business.person.append({'name': 'Appended Person#1'})
business.person.append({'name': 'Appended Person#2'})
business.person.append({'name': 'Appended Person#3'})
business.save()
book = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
del book.business[0].person[2]
book.save()
self.assertEqual(book.business[0].person[1].name, 'Appended Person#1')
self.assertEqual(book.business[0].person[2].name, 'Appended Person#3')
book = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
self.assertEqual(book.business[0].person[1].name, 'Appended Person#1')
self.assertEqual(book.business[0].person[2].name, 'Appended Person#3')
def test_04_add_and_delete_and_add(self):
book = self.tbl_address_book.add({'name': 'Personal'})
book.business.append({'name': 'Business#1'}).person.append({'name': 'Person#1'}).address.append({'postcode': 'PC001'})
book.business.append({'name': 'Business#2'}).person.append({'name': 'Person#2'}).address.append({'postcode': 'PC002'})
book.business.append({'name': 'Business#3'}).person.append({'name': 'Person#3'}).address.append({'postcode': 'PC003'})
book.save()
business = list(self.tbl_business.find(expression=lambda doc: doc['name'] == 'Business#1'))[0]
business.person.append({'name': 'Appended Person#1'})
business.person.append({'name': 'Appended Person#2'})
business.person.append({'name': 'Appended Person#3'})
business.save()
book = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
del book.business[0].person[2]
book.save()
book = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
book.business[0].person.append({'name': 'Appended Person#2'})
book.save()
book = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
self.assertEqual(book.business[0].person[1].name, 'Appended Person#1')
self.assertEqual(book.business[0].person[2].name, 'Appended Person#3')
self.assertEqual(book.business[0].person[3].name, 'Appended Person#2')
self.assertEqual(len(book.business[0].person), 4)
def test_05_traverse(self):
book = self.tbl_address_book.add({'name': 'Personal'})
book.business.append({'name': 'Business#1'}).person.append({'name': 'Person#1'}).address.append({'postcode':'PC001'})
book.business.append({'name': 'Business#2'}).person.append({'name': 'Person#2'}).address.append({'postcode':'PC002'})
book.business.append({'name': 'Business#3'}).person.append({'name': 'Person#3'}).address.append({'postcode':'PC003'})
book.save()
results = ([address.postcode
for book in self.tbl_address_book.find()
for business in book.business
for person in business.person
for address in person.address
])
self.assertEqual(results, ['PC001', 'PC002', 'PC003'])
books = list(set([book.name
for address in self.tbl_address.find()
for person in address.person
for business in person.business
for book in business.address_book
]))
self.assertEqual(books, ['Personal'])
def test_06_sharing_businesses(self):
book1 = self.tbl_address_book.add({'name': 'Personal'})
book1.business.append({'name': 'Business#1'}).person.append({'name': 'Person#1'}).address.append({'postcode':'PC001'})
book1.business.append({'name': 'Business#2'}).person.append({'name': 'Person#2'}).address.append({'postcode':'PC002'})
book1.business.append({'name': 'Business#3'}).person.append({'name': 'Person#3'}).address.append({'postcode':'PC003'})
book1.save()
book2 = self.tbl_address_book.add({'name': 'Business'})
book2.business.append(book1.business[0])
book2.business.append(book1.business[1])
book2.business.append(book1.business[2])
book2.save()
self.tbl_address_book.list()
self.tbl_business.list()
self.tbl_person.list()
self.tbl_address.list()
results = ([address.postcode
for book in self.tbl_address_book.find()
for business in book.business
for person in business.person
for address in person.address
])
self.assertEqual(results, ['PC001', 'PC002', 'PC003', 'PC001', 'PC002', 'PC003'])
books = list(set([book.name
for address in self.tbl_address.find()
for person in address.person
for business in person.business
for book in business.address_book
]))
books.sort()
self.assertEqual(books, ['Business', 'Personal'])
def test_07_crosspatch_book_person(self):
book1 = self.tbl_address_book.add({'name': 'Personal'})
book1.business.append({'name': 'Business#1'}).person.append({'name': 'Person#1'}).address.append({'postcode':'PC001'})
book1.business.append({'name': 'Business#2'}).person.append({'name': 'Person#2'}).address.append({'postcode':'PC002'})
book1.business.append({'name': 'Business#3'}).person.append({'name': 'Person#3'}).address.append({'postcode':'PC003'})
book1.save()
book2 = self.tbl_address_book.add({'name': 'Business'})
book2.business.append(book1.business[0])
book2.business.append(book1.business[1])
book2.business.append(book1.business[2])
book2.save()
book1.person.append(list(self.tbl_person.find(expression=lambda doc: doc['name'] == 'Person#1'))[0])
book1.person.append(list(self.tbl_person.find(expression=lambda doc: doc['name'] == 'Person#3'))[0])
book1.save()
book1 = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
self.assertEqual(book1.person[0].name, "Person#1")
self.assertEqual(book1.person[1].name, "Person#3")
def test_08_amend_crosspatch(self):
book1 = self.tbl_address_book.add({'name': 'Personal'})
book1.business.append({'name': 'Business#1'}).person.append({'name': 'Person#1'}).address.append({'postcode':'PC001'})
book1.business.append({'name': 'Business#2'}).person.append({'name': 'Person#2'}).address.append({'postcode':'PC002'})
book1.business.append({'name': 'Business#3'}).person.append({'name': 'Person#3'}).address.append({'postcode':'PC003'})
book1.save()
book2 = self.tbl_address_book.add({'name': 'Business'})
book2.business.append(book1.business[0])
book2.business.append(book1.business[1])
book2.business.append(book1.business[2])
book2.save()
book1.person.append(list(self.tbl_person.find(expression=lambda doc: doc['name'] == 'Person#1'))[0])
book1.person.append(list(self.tbl_person.find(expression=lambda doc: doc['name'] == 'Person#3'))[0])
book1.save()
book1 = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
book1.person[0].name += "!!"
book1.save()
book1 = list(self.tbl_address_book.find(expression=lambda doc: doc['name'] == 'Personal'))[0]
self.assertEqual(book1.person[0].name, "Person#1!!")
self.assertEqual(book1.business[0].person[0].name, "Person#1!!")
class UnitTests(unittest.TestCase):
def setUp(self):
call(['rm', '-rf', "test_orm"])
self._database = Database('test_orm', {'env': {'map_size': 1024 * 1024 * 10}})
self._user_model = UserModel(table=self._database.table('users'))
self._address_model = AddressModel(table=self._database.table('addresses'))
self._links = ManyToMany(self._database, self._user_model, self._address_model)
def tearDown(self):
self._database.close()
call(['rm', '-rf', "test_orm"])
def generate_data_1(self):
self._user_model.add({"forename":"tom", "surname": "smith", "dob_ddmmyyyy": "01/01/1971", "uid": 1})
self._user_model.add({"forename":"dick", "surname": "smith", "dob_ddmmyyyy": "01/01/1972", "uid": 2})
self._user_model.add({"forename":"harry", "surname": "smith", "dob_ddmmyyyy": "01/01/1973", "uid": 3})
self._user_model.add({"forename":"sally", "surname": "jones", "dob_ddmmyyyy": "01/01/1969", "uid": 4})
self._user_model.add({"forename":"mary", "surname": "jones", "dob_ddmmyyyy": "01/01/1968", "uid": 5})
self._user_model.add({"forename":"sophie", "surname": "jones", "dob_ddmmyyyy": "01/01/1967", "uid": 6})
self._user_model.add({"forename":"joker", "surname": "wildcard", "dob_ddmmyyyy": "01/01/1966", "uid": 7})
self._address_model.add({"line1":"Address line 1 # 1", "line2": "Address line 21","postcode":"CFXX 1AA"})
self._address_model.add({"line1":"Address line 1 # 2", "line2": "Address line 22","postcode":"CFXX 1BB"})
self._address_model.add({"line1":"Address line 1 # 3", "line2": "Address line 23","postcode":"CFXX 1CC"})
self._address_model.add({"line1":"Address line 1 # 4", "line2": "Address line 24","postcode":"CFXX 1DD"})
@pytest.fixture(autouse=True)
def capfd(self, capfd):
self.capfd = capfd
def test_01_check_records(self):
self.generate_data_1()
self.assertEqual(self._user_model._table.records, 7)
self.assertEqual(self._address_model._table.records, 4)
def test_02_add_new_address(self):
self.generate_data_1()
doc = list(self._user_model.find())[0]
doc.addresses.append({"line1": "Address line 1 # 5", "line2": "Address line 25","postcode": "CFXX 1DE"})
doc.save()
doc = list(self._user_model.find())[0]
doc.addresses.append({"line1": "Address line 1 # 6", "line2": "Address line 26", "postcode":"CFXX 1DF"})
doc.save()
doc = list(self._user_model.find())[0]
self.assertEqual(doc.addresses[0].postcode, 'CFXX 1DE')
self.assertEqual(doc.addresses[1].postcode, 'CFXX 1DF')
doc.addresses[0].postcode += '!'
def test_03_update_address(self):
self.generate_data_1()
doc = list(self._user_model.find())[0]
doc.addresses.append({"line1":"Address line 1 # 5", "line2": "Address line 25","postcode":"CFXX 1DE"})
doc.addresses.append({"line1":"Address line 1 # 6", "line2": "Address line 26", "postcode":"CFXX 1DF"})
doc.save()
doc = list(self._user_model.find())[0]
doc.addresses[0].postcode += '!'
doc.addresses[1].postcode += '!'
doc.save()
doc = list(self._user_model.find())[0]
self.assertEqual(doc.addresses[0].postcode, 'CFXX 1DE!')
self.assertEqual(doc.addresses[1].postcode, 'CFXX 1DF!')
def test_04_delete_address(self):
self.generate_data_1()
doc = list(self._user_model.find())[0]
doc.addresses.append({"line1": "Address line 1 # 5", "line2": "Address line 25", "postcode": "CFXX 1DE"})
doc.addresses.append({"line1": "Address line 1 # 6", "line2": "Address line 26", "postcode": "CFXX 1DF"})
doc.save()
doc = list(self._user_model.find())[0]
del doc.addresses[0]
doc.save()
doc = list(self._user_model.find())[0]
self.assertEqual(doc.addresses[0].postcode, 'CFXX 1DF')
self.assertEqual(len(doc.addresses), 1)
def test_05_formatting_function(self):
self.generate_data_1()
self._user_model.list()
out, err = self.capfd.readouterr()
with open('tests/test_orm_table1.txt') as io:
compare = io.read()
self.maxDiff = None
self.assertEqual(compare, out)
def test_06_add_with_linked(self):
self.generate_data_1()
doc = list(self._user_model.find())[0]
doc.addresses.append({'line1': 'NEW LINE', 'postcode': 'NEW'})
doc.addresses.append({'line1': 'NEW LINE1', 'postcode': 'NEW1'})
doc.save()
self.assertEqual(doc.addresses[0].postcode, 'NEW')
self.assertEqual(len(doc.addresses), 2)
doc = list(self._user_model.find())[0]
self.assertEqual(doc.addresses[1].postcode, 'NEW1')
self.assertEqual(len(doc.addresses), 2)
self._database.close()
self._database = Database('test_orm', {'env': {'map_size': 1024 * 1024 * 10}})
self._user_model = UserModel(table=self._database.table('users'))
self._address_model = AddressModel(table=self._database.table('addresses'))
self._links = ManyToMany(self._database, self._user_model, self._address_model)
doc = list(self._user_model.find())[0]
self.assertEqual(doc.addresses[0].postcode, 'NEW')
self.assertEqual(doc.addresses[1].postcode, 'NEW1')
self.assertEqual(len(doc.addresses), 2)
def test_07_complex(self):
self.generate_data_1()
doc = list(self._user_model.find())[0]
doc.addresses.append({'address': 'address1', 'postcode': 'postcode1'})
doc.addresses.append({'address': 'address2', 'postcode': 'postcode2'})
doc.save()
doc = list(self._user_model.find())[0]
self.assertEqual(len(doc.addresses), 2)
del doc.addresses[0]
doc.save()
doc = list(self._user_model.find())[0]
self.assertEqual(len(doc.addresses), 1)
self.assertEqual(doc.addresses[0].postcode, 'postcode2')
address = list(self._address_model.find())[0]
doc.addresses.append(address)
doc.save()
self.assertEqual(len(doc.addresses), 2)
doc = list(self._user_model.find())[0]
doc.addresses[0].postcode="GB"
doc.save()
self._database.close()
self._database = Database('test_orm', {'env': {'map_size': 1024 * 1024 * 10}})
self._user_model = UserModel(table=self._database.table('users'))
self._address_model = AddressModel(table=self._database.table('addresses'))
self._links = ManyToMany(self._database, self._user_model, self._address_model)
doc = list(self._user_model.find())[0]
self.assertEqual(len(doc.addresses), 2)
self.assertEqual(doc.addresses[0].postcode, 'GB')
