def setUp(self):
logic.clean_create_tables([KennelDataModel, KennelMemberDataModel, HasherDataModel])
self.kennel_a = KennelLogicModel.create('kennel A', 'KAHHH')
self.kennel_b = KennelLogicModel.create('kennel B', 'KBHHH')
self.hasher1 = HasherLogicModel.create('Hasher 1', self.kennel_a)
self.hasher2 = HasherLogicModel.create('Hasher 2', self.kennel_a)
self.hasher3 = HasherLogicModel.create('Hasher 3', self.kennel_b)
def test_list_members(self):
self.kennel_a.add_member(self.hasher1)
self.kennel_a.add_member(self.hasher2)
self.kennel_b.add_member(self.hasher3)
self.assertListEqual(KennelLogicModel.list_members(self.kennel_a),
[self.hasher1.persistence_object.to_ref(), self.hasher2.persistence_object.to_ref()])
self.assertListEqual(KennelLogicModel.list_members(self.kennel_b), [self.hasher3.persistence_object.to_ref()])
def setUp(self):
logic.clean_create_tables(
[KennelDataModel, KennelMemberDataModel, HasherDataModel])
self.name = 'Test Kennel 1'
self.acronym = 'TK1H3'
self.hash_name = 'Testy Hasher'
kennel = KennelLogicModel.create(self.name, self.acronym)
self.kennel = kennel.persistence_object
hasher = HasherLogicModel.create(self.hash_name, kennel)
self.hasher = hasher.persistence_object
self.joined = datetime.now(tz=timezone.utc)
def setUp(self):
if KennelDataModel.exists():
KennelDataModel.delete_table()
KennelDataModel.create_table(read_capacity_units=1,
write_capacity_units=1,
wait=True)
self.hasher_id = 'test_id'
self.hash_name = 'Testy Cream'
self.mother_kennel = KennelLogicModel.create('Test Kennel 1', 'TK1H3')
if HasherDataModel.exists():
HasherDataModel.delete_table()
HasherDataModel.create_table(read_capacity_units=1,
write_capacity_units=1,
wait=True)
def test_load_members(self):
KennelLogicModel.create_membership(self.kennel_a, self.hasher1)
KennelLogicModel.create_membership(self.kennel_a, self.hasher2)
KennelLogicModel.create_membership(self.kennel_b, self.hasher3)
self.kennel_a.load_members()
self.kennel_b.load_members()
x = self.kennel_a.members
self.assertListEqual(x, [self.hasher1.persistence_object.to_ref(), self.hasher2.persistence_object.to_ref()])
self.assertListEqual(self.kennel_b.members, [self.hasher3.persistence_object.to_ref()])
def test_members(self):
kennels = list()
hashers = list()
for x in range(3):
kennel_model = KennelLogicModel.create(f'kennel_{x}', f'TK{x}H3')
kennel = kennel_model.persistence_object
kennels.append(kennel)
for y in range(5):
hasher_model = HasherLogicModel.create(f'hasher_{x}{y}',
kennel_model)
hasher = hasher_model.persistence_object
hashers.append(hasher)
membership = KennelMemberDataModel(kennel.kennel_id,
hasher.hasher_id,
hasher_ref=hasher.to_ref(),
kennel_ref=kennel.to_ref())
membership.save()
actual = KennelMemberDataModel.members(kennels[1].kennel_id)
actual_names = [hasher.hash_name for hasher in actual]
expected_names = [f'hasher_1{x}' for x in range(5)]
self.assertListEqual(actual_names, expected_names)
def test_create_membership(self):
KennelLogicModel.create_membership(self.kennel_a, self.hasher1)
actual = list(KennelMemberDataModel.query(self.kennel_a.kennel_id))[0]
self.assertEqual(actual.attributes()['kennel_id'], self.kennel_a.kennel_id)
self.assertEqual(actual.attributes()['hasher_id'], self.hasher1.hasher_id)
def test_cant_create_same_name(self):
logic.clean_create_tables([KennelDataModel, ])
KennelLogicModel.create(self.name, self.acronym)
with self.assertRaises(AlreadyExists):
KennelLogicModel.create(self.name, 'xxxhhh')
def test_create(self):
actual = KennelLogicModel.create(self.name, self.acronym)
expected = KennelLogicModel.lookup_by_id(actual.kennel_id)
self.assertEqual(actual, expected)
self.assertEqual(actual.name, self.name)
self.assertEqual(actual.acronym, self.acronym)
def test_lookup_kennel_doesnt_exist(self):
with self.assertRaises(KennelDataModel.DoesNotExist):
KennelLogicModel.lookup_by_id(self.kennel_id)
def test_init_from_ref(self):
orig = KennelLogicModel.create(self.name, self.acronym)
ref = orig.persistence_object.to_ref()
lookup = KennelLogicModel.lookup_by_ref(ref)
self.assertEqual(orig, lookup)
def test_init_from_lookup(self):
KennelDataModel(self.kennel_id, name=self.name, acronym=self.acronym).save()
x = KennelLogicModel.lookup_by_id(self.kennel_id)
self.assertEqual(self.kennel_id, x.kennel_id)
self.assertEqual(self.name, x.name)
self.assertEqual(self.acronym, x.acronym)