def test_equip_item(self):
tophat = Item.from_key('tophat')
alice = CBUser.from_slackid('UALICE', 'alice')
auth_alice = User.objects.get_or_create(username='******')[0]
alice.auth_user = auth_alice
alice.save()
self.client.force_login(auth_alice)
response = self.client.get(reverse('inventory'))
self.assertNotContains(response, tophat.name)
alice.add_item(tophat)
response = self.client.get(reverse('inventory'))
self.assertContains(response, tophat.name)
self.assertNotContains(response, 'Un-equip')
# Try to equip an item through the POST method
response = self.client.post(reverse('equip_item'),
data={'itemkey': tophat.key})
self.assertRedirects(response, reverse('inventory'))
self.assertEquals(CBUser.from_slackid('UALICE', 'alice').hat, tophat)
response = self.client.get(reverse('inventory'))
self.assertContains(response, 'Un-equip')
response = self.client.post(
reverse('unequip_item', kwargs={'item_type': 'hat'}))
self.assertIsNone(CBUser.from_slackid('UALICE', 'alice').hat)
self.assertRedirects(response, reverse('inventory'))
def test_predictor(self):
import crossbot.predictor as p
model = self.run_predictor()
model2 = p.load()
self.assertEqual(model, model2)
users = {m.user: m for m in model[2]}
u1, u2 = CBUser.from_slackid("U1"), CBUser.from_slackid("U2")
self.assertLess(users[u1].skill, users[u2].skill)
def test_wins(self):
alice = CBUser.from_slackid('UALICE', 'alice')
bob = CBUser.from_slackid('UBOB', 'bob')
d = {x: parse_date('2018-01-0' + str(x)) for x in range(1, 6)}
# make sure winners is empty right now
self.assertEqual([], MiniCrosswordTime.winners(d[1]))
# alice wins
_, a1 = alice.add_mini_crossword_time(10, d[1])
_, b1 = bob.add_mini_crossword_time(11, d[1])
# they tie
_, a2 = alice.add_mini_crossword_time(15, d[2])
_, b2 = bob.add_mini_crossword_time(15, d[2])
# bob wins
_, a3 = alice.add_mini_crossword_time(21, d[3])
_, b3 = bob.add_mini_crossword_time(20, d[3])
# alice wins
_, a4 = alice.add_mini_crossword_time(18, d[4])
_, b4 = bob.add_mini_crossword_time(19, d[4])
# check the winners
self.assertEqual([a1], MiniCrosswordTime.winners(d[1]))
self.assertEqual([a2, b2], MiniCrosswordTime.winners(d[2]))
self.assertEqual([b3], MiniCrosswordTime.winners(d[3]))
self.assertEqual([a4], MiniCrosswordTime.winners(d[4]))
# check the winning times
winning_times = MiniCrosswordTime.winning_times()
expected = {d[1]: 10, d[2]: 15, d[3]: 20, d[4]: 18}
self.assertEqual(winning_times, expected)
# check the actual wins
a_wins = MiniCrosswordTime.wins(alice)
self.assertEqual(a_wins, [a1, a2, a4])
b_wins = MiniCrosswordTime.wins(bob)
self.assertEqual(b_wins, [b2, b3])
# check the streaks
a_win_streaks = MiniCrosswordTime.win_streaks(alice)
self.assertEqual(a_win_streaks, [[a1, a2], [a4]])
b_win_streaks = MiniCrosswordTime.win_streaks(bob)
self.assertEqual(b_win_streaks, [[b2, b3]])
# check the win streaks
self.assertEqual({
alice: [a1, a2],
bob: [b2]
}, MiniCrosswordTime.current_win_streaks(d[2]))
self.assertEqual({bob: [b2, b3]},
MiniCrosswordTime.current_win_streaks(d[3]))
self.assertEqual({}, MiniCrosswordTime.current_win_streaks(d[5]))
def test_items(self):
# Just add one item
alice = CBUser.from_slackid('UALICE', 'alice')
tophat = Item.from_key('tophat')
self.assertEqual(tophat.key, 'tophat')
self.assertEqual(alice.quantity_owned(tophat), 0)
alice.add_item(tophat, amount=2)
self.assertEqual(alice.quantity_owned(tophat), 2)
self.assertEqual(alice.quantity_owned(Item.from_key('tophat')), 2)
record = ItemOwnershipRecord.objects.get(owner=alice,
item_key=tophat.key)
self.assertEqual(record.quantity, 2)
self.assertEqual(record.item, tophat)
self.assertTrue(alice.remove_item(tophat, amount=2))
self.assertEqual(alice.quantity_owned(tophat), 0)
try:
ItemOwnershipRecord.objects.get(owner=alice, item_key=tophat.key)
self.fail()
except ItemOwnershipRecord.DoesNotExist:
pass
# Check that the item image actually exists on disk
url = tophat.image_url()
self.assertEqual(settings.STATIC_URL, url[:len(settings.STATIC_URL)])
url = url.replace(settings.STATIC_URL, '', 1)
path = finders.find(url)
self.assertTrue(os.path.isfile(path))
def test_streak(self):
alice = CBUser.from_slackid('UALICE', 'alice')
# set up a broken 10 streak
_, t1 = alice.add_mini_crossword_time(18, parse_date('2018-01-01'))
_, t2 = alice.add_mini_crossword_time(12, parse_date('2018-01-02'))
_, t3 = alice.add_mini_crossword_time(12, parse_date('2018-01-03'))
_, t4 = alice.add_mini_crossword_time(15, parse_date('2018-01-04'))
# t5 is missing
_, t6 = alice.add_mini_crossword_time(15, parse_date('2018-01-06'))
_, t7 = alice.add_mini_crossword_time(15, parse_date('2018-01-07'))
_, t8 = alice.add_mini_crossword_time(15, parse_date('2018-01-08'))
_, t9 = alice.add_mini_crossword_time(15, parse_date('2018-01-09'))
_, t0 = alice.add_mini_crossword_time(18, parse_date('2018-01-10'))
# make sure the streak is broken
streaks = MiniCrosswordTime.participation_streaks(alice)
self.assertListEqual(streaks, [[t1, t2, t3, t4], [t6, t7, t8, t9, t0]])
# fix the broken streak
_, t5 = alice.add_mini_crossword_time(15, parse_date('2018-01-05'))
streaks = MiniCrosswordTime.participation_streaks(alice)
self.assertListEqual(streaks,
[[t1, t2, t3, t4, t5, t6, t7, t8, t9, t0]])
# now break it again with a deleted time (t2)
alice.remove_mini_crossword_time(parse_date('2018-01-02'))
streaks = MiniCrosswordTime.participation_streaks(alice)
self.assertListEqual(streaks, [[t1], [t3, t4, t5, t6, t7, t8, t9, t0]])
def test_add_fail(self):
alice = CBUser.from_slackid('UALICE', 'alice')
a, t = alice.add_mini_crossword_time(-1, parse_date(None))
self.assertTrue(a)
self.assertEqual(t.seconds, -1)
self.assertEqual(t.date, parse_date(None))
self.assertTrue(t.is_fail())
def test_show_title(self):
alice = CBUser.from_slackid('UALICE', 'alice')
key = 'mini_completed3_title'
title = Item.from_key(key)
alice.title_key = key
alice.save()
self.slack_post('add :10 2018-01-1')
self.assertIn(title.name, self.messages[-1])
alice = CBUser.from_slackid('UALICE')
alice.custom_title = 'foobar'
alice.save()
self.slack_post('add :10 2018-01-02')
self.assertNotIn(title.name, self.messages[-1])
self.assertIn('foobar', self.messages[-1])
def test_add_time(self):
alice = CBUser.from_slackid('UALICE', 'alice')
a, t = alice.add_mini_crossword_time(10, parse_date(None))
self.assertTrue(a)
self.assertEqual(t.user, alice)
self.assertEqual(t.seconds, 10)
self.assertEqual(t.date, parse_date(None))
self.assertEqual(alice.get_mini_crossword_time(parse_date(None)), t)
def test_equip_item(self):
alice = CBUser.from_slackid('UALICE', 'alice')
tophat = Item.from_key('tophat')
# try to equip hat without owning one, should fail
self.assertFalse(alice.equip(tophat))
self.assertFalse(alice.is_equipped(tophat))
self.assertIsNone(alice.hat)
# give one and equip it
alice.add_item(tophat)
self.assertTrue(alice.equip(tophat))
self.assertTrue(alice.is_equipped(tophat))
self.assertEqual(alice.hat, tophat)
# make sure the changes persisted
alice = CBUser.from_slackid('UALICE', 'alice')
self.assertTrue(alice.is_equipped(tophat))
self.assertEqual(alice.hat, tophat)
# shouldn't be able to remove it
self.assertFalse(alice.remove_item(tophat))
self.assertEqual(alice.quantity_owned(tophat), 1)
# unequip it both ways
alice.unequip(tophat)
self.assertFalse(alice.is_equipped(tophat))
self.assertIsNone(alice.hat)
alice = CBUser.from_slackid('UALICE', 'alice')
self.assertFalse(alice.is_equipped(tophat))
self.assertIsNone(alice.hat)
self.assertTrue(alice.equip(tophat))
self.assertTrue(alice.is_equipped(tophat))
self.assertEqual(alice.hat, tophat)
alice.unequip_hat()
self.assertFalse(alice.is_equipped(tophat))
self.assertIsNone(alice.hat)
alice = CBUser.from_slackid('UALICE', 'alice')
self.assertFalse(alice.is_equipped(tophat))
self.assertIsNone(alice.hat)
def test_crossbucks_add_remove(self):
# Checks that removing a time actually removes crossbucks
alice = CBUser.from_slackid('UALICE', 'alice')
alice.add_mini_crossword_time(10, parse_date(None))
self.assertEqual(alice.crossbucks, CROSSBUCKS_PER_SOLVE)
alice.add_mini_crossword_time(10, parse_date(None))
self.assertEqual(alice.crossbucks, CROSSBUCKS_PER_SOLVE)
alice.remove_mini_crossword_time(parse_date(None))
self.assertEqual(alice.crossbucks, 0)
alice.remove_mini_crossword_time(parse_date(None))
self.assertEqual(alice.crossbucks, 0)
alice.add_mini_crossword_time(10, parse_date(None))
self.assertEqual(alice.crossbucks, CROSSBUCKS_PER_SOLVE)
def setUp(self):
super().setUp()
self.maxDiff = None
for u, ts in self.data.items():
user = CBUser(slackid=u)
user.save()
for i, t in enumerate(ts):
if t is not None:
user.add_mini_crossword_time(
t, parse_date("2018-01-0" + str(i + 1)))
def test_from_slackid(self):
alice = CBUser.from_slackid('UALICE', 'alice')
self.assertIsInstance(alice, CBUser)
self.assertEqual(alice.slackname, 'alice')
self.assertEqual(alice.slack_fullname, 'Alice')
self.assertEqual(alice.image_url, 'http://example.com/alice.png')
self.assertEqual(alice, CBUser.from_slackid('UALICE', 'bob'))
alice = CBUser.from_slackid('UALICE')
self.assertEqual(CBUser.from_slackid('UALICE').slackname, 'bob')
fake_user = CBUser.from_slackid('UFAKE')
self.assertIsNone(fake_user)
with self.assertRaises(ValueError) as exception_context:
fake_user = CBUser.from_slackid('UFAKE', 'fake_user')
self.assertIn('user_not_found', str(exception_context.exception))
def do(self):
now = timezone.localtime()
CBUser.update_slacknames()
return "Updated slack_users at {}".format(now)
def test_add_user(self):
alice = CBUser.from_slackid('UALICE', 'alice')
self.assertIsInstance(alice, CBUser)
self.assertEqual(alice, CBUser.from_slackid('UALICE', 'bob'))
alice = CBUser.from_slackid('UALICE')
self.assertEqual(CBUser.from_slackid('UALICE').slackname, 'bob')
def test_game_specific_items(self):
alice = CBUser.from_slackid('UALICE', 'alice')
title = Item.from_key('mini_completed3_title')
self.assertEqual(title.key, 'mini_completed3_title')
self.assertEqual(title.name, 'Mini Dabbler')
