def test_cannot_unlock_with_non_matching_keycard4(self):
k1 = Key()
k2 = Key()
k3 = Key()
lock = Lock(k1, k2)
keycard = KeyCard(k3, k1)
assert not lock.can_be_unlocked(keycard)
def test_can_unlock_with_partially_matching_keycard(self):
k1 = Key()
k2 = Key()
k3 = Key()
lock = Lock(k1, k2)
keycard1 = KeyCard(k2, k3)
# can unlock with partial match
assert lock.can_be_unlocked(keycard1)
keycard2 = KeyCard(k2, k1)
# cannot unlock with partial match
assert not lock.can_be_unlocked(keycard2)
def test_keycard_returns_initialized_keycard(self, name, num):
kc = KeyCard(Key(), Key())
assert Guest(name, num, kc).keycard == kc
def test_can_create_lock_with_same_valid_keys(self):
tmp1 = Key()
Lock(tmp1, tmp1)
def test_cannot_create_lock_with_invalid_second_key_type(self, k2):
with pytest.raises(ValueError):
Lock(Key(), k2)
def test_second_key_returns_second_key(self):
k1 = Key()
k2 = Key()
kc = KeyCard(k1, k2)
assert kc.second_key == k2
def test_can_create_keycard_with_same_valid_keys(self):
tmp1 = Key()
KeyCard(tmp1, tmp1)
def test_cannot_create_keycard_with_invalid_second_key_type(self, k2):
with pytest.raises(ValueError):
KeyCard(Key(), k2)
def test_cannot_create_guest_with_invalid_room_number(self, num):
with pytest.raises(ValueError):
Guest("John", num, KeyCard(Key(), Key()))
def test_lock_returns_initialized_lock(self, num):
lock = Lock(Key(), Key())
assert Room(num, lock).lock == lock
def test_room_number_returns_initialized_room_number(self, num):
assert Room(num, Lock(Key(), Key())).room_number == num
def test_can_create_room_with_valid_room_number_and_lock(self, num):
Room(num, Lock(Key(), Key()))
def test_cannot_create_room_with_invalid_room_number(self, num):
with pytest.raises(ValueError):
Room(num, Lock(Key(), Key()))
def test_is_checkedin_fails_with_invalid_hotel_type(self, name, num,
value):
kc = KeyCard(Key(), Key())
g = Guest(name, num, kc)
with pytest.raises(ValueError):
g.is_checkedin(value)
def test_cannot_create_guest_with_invalid_name1(self, name, num):
with pytest.raises(ValueError):
Guest(name, num, KeyCard(Key(), Key()))
def test_cannot_create_keycard_with_invalid_first_key_type(self, k1):
with pytest.raises(ValueError):
KeyCard(k1, Key())
def test_cannot_create_guest_with_invalid_name2(self, name, num):
assume(re.sub(r'[a-zA-Z ]', '', name))
with pytest.raises(ValueError):
Guest(name, num, KeyCard(Key(), Key()))
def test_can_create_keycard_with_distinct_valid_keys(self):
KeyCard(Key(), Key())
def test_key_can_be_created(self):
Key()
def test_first_key_returns_first_key(self):
k1 = Key()
k2 = Key()
kc = KeyCard(k1, k2)
assert kc.first_key == k1
def test_can_create_guest_with_valid_arguments(self, name, num):
Guest(name, num, KeyCard(Key(), Key()))
def test_cannot_create_lock_with_invalid_first_key_type(self, k1):
with pytest.raises(ValueError):
Lock(k1, Key())
def test_guest_name_returns_initialized_name(self, name, num):
assert Guest(name, num, KeyCard(Key(), Key())).guest_name == name
def test_can_create_lock_with_distinct_valid_keys(self):
Lock(Key(), Key())
def test_room_number_returns_initialized_room_number(self, name, num):
assert Guest(name, num, KeyCard(Key(), Key())).room_number == num
def test_cannot_unlock_with_invalid_keycard_type(self, value):
key = Key()
lock = Lock(key, key)
with pytest.raises(ValueError):
lock.can_be_unlocked(value)
def test_can_unlock_with_matching_keycard(self):
k1 = Key()
k2 = Key()
keycard = KeyCard(k1, k2)
lock = Lock(k1, k2)
assert lock.can_be_unlocked(keycard)