def testGetSubscribers(self):
user1 = UserMock()
user2 = UserMock(123460, full_name="Joe Marti", nickname="@pidr")
slave1 = SlaveMock()
slave2 = SlaveMock("slave2")
self._sut.add_user(user1)
self._sut.add_user(user2)
self._sut.add_slave(slave1)
self._sut.add_slave(slave2)
def info_message_ids():
for i in range(4):
yield i + 1
gen = info_message_ids()
for user in self._sut.get_users():
for slave in self._sut.get_slaves():
uid, snick, m = user.telegram_id, slave.slave_nickname, next(
gen)
self._sut.subscribe(uid, snick, m)
self.assertListEqual(self._sut.get_subscriptions(user1.id),
[(slave1.nickname, 1), (slave2.nickname, 2)])
self.assertListEqual(self._sut.get_subscriptions(user2.id),
[(slave1.nickname, 3), (slave2.nickname, 4)])
def testUnsubscribe(self):
telegram_id = 123459
user = UserMock(telegram_id=telegram_id)
self._sut.add_user(user)
self._sut.add_slave(SlaveMock())
self._sut.add_slave(SlaveMock("slave2"))
self._sut.subscribe(telegram_id, "slave1", 11)
self._sut.subscribe(telegram_id, "slave2", 12)
subs = self._sut.get_subscriptions(telegram_id)
self.assertListEqual(subs, [("slave1", 11), ("slave2", 12)])
self._sut.unsubscribe(telegram_id, "slave1")
self._sut.unsubscribe(telegram_id, "slave2")
subs = self._sut.get_subscriptions(telegram_id)
self.assertListEqual(subs, [])
with self.assertRaises(ValueError):
self._sut.unsubscribe(telegram_id, "slave2123123") # no such slave
with self.assertRaises(ValueError):
self._sut.unsubscribe(11, "slave2") # no such user
def testSubscribe(self):
telegram_id = 123459
self._sut.add_user(UserMock(telegram_id=telegram_id))
self._sut.add_slave(SlaveMock())
self._sut.add_slave(SlaveMock("slave2"))
self._sut.subscribe(telegram_id, "slave1", 11)
self._sut.subscribe(telegram_id, "slave2", 12)
subs = self._sut.get_subscriptions(telegram_id)
self.assertListEqual(subs, [("slave1", 11), ("slave2", 12)])
def testUpdateSlave(self):
slave = SlaveMock()
self._sut.add_slave(slave)
slave.password = "******"
self._sut.update_slave(slave)
slaves = self._sut.get_slaves()
slave.password = md5(slave.password.encode()).hexdigest()
self.assertListEqual([slave.to_tuple()], slaves)
def setUp(self):
LoggingServer.getInstance("overseer", test=True)
self._telegram_updater = Mock()
self._update_server = Mock()
self._db_operator = DBOperator("overseer_test",
"inlatexbot",
"inlatexbot",
drop_key="r4jYi1@")
self._users = []
full_names = [
"Alex Korenkov", None, "Joe Marti", "Rob Shel", "Jens Koch",
"Sam Bad", "Chad Riget", "Will Oliver", "John Fowler", "Lena Egor"
]
for i in range(10):
if full_names[i] is not None:
name, surname = full_names[i].split(" ")
nickname = "@%s%s" % (name[0], surname)
else:
nickname = None
user = UserMock(12345 + i,
full_name=full_names[i],
nickname=nickname)
self._users.append(user)
self._db_operator.add_user(user)
self._slaves = []
self._slave_states = {}
self._slave_state_raw_messages = ["TEST", '{"state":"test state", "sent_at":"1996-01-01 00:00:00",' \
' "alerts":["SLAVE failing","","SLAVE died"]}']
state_cycle = itertools.cycle(self._slave_state_raw_messages)
for i in range(10):
slave = SlaveMock("slave%d" % i, "0.0.0.%d" % i)
self._slaves.append(slave)
self._db_operator.add_slave(slave)
self._slave_states[slave.nickname] = SlaveState(
slave.nickname, next(state_cycle))
self._update_server.get_latest_state = MagicMock(
side_effect=lambda x: self._slave_states[x])
# random cross-subscribe
for user in self._users:
slaves_copy = self._slaves.copy()
shuffle(slaves_copy)
slaves_monitored = slaves_copy[:randint(0, 9)]
for slave in slaves_monitored:
self._db_operator.subscribe(user.id, slave.nickname,
randint(0, 100))
self._sut = Broadcaster(self._telegram_updater, self._update_server,
self._db_operator)
def testGetSlave(self):
slave = SlaveMock()
self._sut.add_slave(slave)
slave_from_db = self._sut.get_slave(slave.nickname)
slave.password = md5(slave.password.encode()).hexdigest()
self.assertEqual(slave.to_tuple(), slave_from_db)
try:
self._sut.get_slave("missing_slave")
except ValueError:
return
else:
assert False
def testAddSlaveTwoTimes(self):
slave = SlaveMock()
self._sut.add_slave(slave)
try:
self._sut.add_slave(slave)
except ValueError as e:
self.assertEqual(e.args[0],
"Slave already exists") # TODO:replace with rm
else:
assert False
slaves = self._sut.get_slaves()
slave.password = md5(slave.password.encode()).hexdigest()
self.assertListEqual([slave.to_tuple()], slaves)
def testOnSubscribe(self):
telegram_id = 123456
slave1 = SlaveMock()
slave2 = SlaveMock("slave2", password="******", owner=45678)
self._db_operator.add_slave(slave1)
self._db_operator.add_slave(slave2)
reply_message = MessageMock(message_id=11)
message = MessageMock(telegram_id,
text="/subscribe slave1",
reply_text=Mock(return_value=reply_message))
update = Mock()
update.message = message
self._sut.on_subscribe(None, update)
reply_message.message_id = 12
update.message.text = "/subscribe slave2"
self._sut.on_subscribe(None, update)
self.assertIn(("slave1", 11), self._db_operator.get_subscriptions(telegram_id))
self.assertIn(("slave2", 12), self._db_operator.get_subscriptions(telegram_id))
reply_message.message_id = 13
update.message.text = "/subscribe slave3"
message.reply_text = Mock()
try:
self._sut.on_subscribe(None, update)
except ValueError as e:
self.assertEqual(e.args[0], "Slave slave3 not found")
message.reply_text.assert_called_with(self._rm.get_string("no_slave"))
def testAuthenticateSlave(self):
auth = self._sut._authenticate_slave("test", "test_pass")
self.assertFalse(auth)
slave = SlaveMock()
slave_from_db = SlaveMock(
password=md5(slave.password.encode()).hexdigest())
self._db_operator.get_slave = MagicMock(return_value=slave_from_db)
auth = self._sut._authenticate_slave(slave.nickname, slave.password)
self.assertTrue(auth)
slave = SlaveMock(password="")
slave_from_db = SlaveMock(
password=md5(slave.password.encode()).hexdigest())
auth = self._sut._authenticate_slave(slave.nickname, "")
self.assertFalse(auth)
def testCommunicate(self):
conn = MagicMock()
conn.recv = MagicMock(side_effect=["slave1\r\npass".encode()] +
["state".encode()] * 10 + ["".encode()])
slave = SlaveMock(password="******")
slave_from_db = SlaveMock(
password=md5(slave.password.encode()).hexdigest())
self._db_operator.get_slave = MagicMock(return_value=slave_from_db)
self._sut._communicate(conn, MagicMock())
state = self._sut._latest_states[slave.nickname]
expected_state = SlaveState("slave1", "state")
state._received_at = expected_state._received_at
self.assertEqual(state, expected_state)
conn.recv = MagicMock(side_effect=[
"slave2\r\npassss@".encode(), "state".encode(), "".encode()
])
self._sut._communicate(conn, MagicMock())
self.assertNotIn("slave2", self._sut._latest_states.keys())
def testOnUnsubscribe(self):
telegram_id = 123456
self._db_operator.add_user(UserMock(telegram_id))
self._db_operator.add_slave(SlaveMock())
self._db_operator.subscribe(telegram_id, "slave1", 11)
message = MessageMock(telegram_id,
text="/unsubscribe slave1")
update = Mock()
update.message = message
self._sut.on_unsubscribe(None, update)
self.assertNotIn(("slave1", 11),
self._db_operator.get_subscriptions(telegram_id))
update.message.reply_text.assert_called_with(self._rm.get_string("unsubscribed") % "slave1")
def testAddSlave(self):
slave1 = SlaveMock()
slave2 = SlaveMock("slave2", password="******", owner=45678)
self._sut.add_slave(slave1)
self._sut.add_slave(slave2)
slaves = self._sut.get_slaves()
slave1.password = md5(slave1.password.encode()).hexdigest()
slave2.password = md5(slave2.password.encode()).hexdigest()
self.assertListEqual([slave1.to_tuple(), slave2.to_tuple()], slaves)
slave3 = SlaveMock("a" * 60) # long name
try:
self._sut.add_slave(slave3)
except ValueError as e:
self.assertEqual(e.args[0],
self._rm.get_string("slave_name_too_long"))
else:
assert False