Gecko [ 35.178.45.201 ]

Name	Size	Permission
data	[ DIR ]	drwxrwxr-x
migrations	[ DIR ]	drwxrwxr-x
static	[ DIR ]	drwxrwxr-x
templates	[ DIR ]	drwxrwxr-x
__init__.py	0 B	-rw-rw-r--
admin.py	370 B	-rw-rw-r--
apps.py	89 B	-rw-rw-r--
models.py	2.68 KB	-rw-rw-r--
tests.py	6.94 KB	-rw-rw-r--
urls.py	804 B	-rw-rw-r--
views.py	8.78 KB	-rw-rw-r--

Code Editor : tests.py

import datetime

from django.test import TestCase
from django.utils import timezone
from django.urls import reverse
from uuid import uuid4

from .models import Event, Player, EventOption, Bet

def create_event(text, start_days=None, end_days=None, options=False):
	now = timezone.now()
	delta = datetime.timedelta
	start_date = now + delta(start_days) if start_days is not None else now
	end_date = now + delta(end_days) if end_days else now + delta(days=1)
	event = Event.objects.create(name=text, start_date=start_date, end_date=end_date, pub_key=uuid4())
	if options is not False:
		event.eventoption_set.create(name="Team A wins")
		event.eventoption_set.create(name="Team A loses")

return event

new_player1 = {"name": "Obinna Okafor", 
				"username": "reptofrank", 
				"email_address": "obinna.okafor01@gmail.com"}

new_player2 = {"name": "Chidubem", 
				"username": "melzy", 
				"email_address": "chidubememelumadu@gmail.com"}

class EventModelTests(TestCase):

def test_event_end_date_is_in_future(self):
		new_event = Event(name="New Event", pub_key=uuid4())
		self.assertIs(True, new_event.end_date > timezone.now())

def test_event_still_on_with_future_start_date(self):
		now = timezone.now()
		start_date = now + datetime.timedelta(hours=10)
		event = Event(name="New Event", start_date=start_date, pub_key=uuid4())
		self.assertIs(event.still_on(), False)

def test_event_started_with_future_start_date(self):
		now = timezone.now()
		start_date = now + datetime.timedelta(hours=10)
		event = Event(name="New Event", start_date=start_date, pub_key=uuid4())
		self.assertIs(event.started(), False)

def test_event_started_with_past_start_date(self):
		now = timezone.now()
		start_date = now + datetime.timedelta(days=-1)
		event = Event(name="New Event", start_date=start_date, pub_key=uuid4())
		self.assertIs(event.started(), True)

class EventViewTests(TestCase):

def test_get_events(self):
		for x in ['e1', 'e2']:
			x = create_event("Event " + x, None, None)

response = self.client.get(reverse('get_events'))
		self.assertIs(response.status_code, 200)
		self.assertEqual(len(response.context['events']), 2)

def test_get_events_with_no_current_or_future_event(self):
		"""
		get_events view should only return events that are still on
		i.e their end date is in the future
		"""
		past_event = create_event("Past event", start_days=-5, end_days=-1)

response = self.client.get(reverse('get_events'))
		self.assertIs(response.status_code, 200)
		self.assertQuerysetEqual(response.context['events'], [])

def test_get_event(self):
		event = create_event("Past event", start_days=-2, end_days=5, options=True)
		player = Player.objects.create(**new_player1)
		option = event.eventoption_set.all()[0]
		bet = option.bet_set.create(player=player, selection=option, amount=2500, bet_key=uuid4())
		
		response = self.client.get(reverse('event_detail', args=(event.pub_key, )))
		
		self.assertIs(response.status_code, 200)
		self.assertContains(response, event.name)
		self.assertContains(response, option.name)
		# self.assertContains(response, player.name)

def test_get_event_with_options(self):
		event = create_event("Options event", start_days=-2, end_days=5, options=True)
		
		response = self.client.get(reverse('event_detail', args=(event.pub_key, )))
		self.assertIs(response.status_code, 200)
		self.assertContains(response, event.name)
		self.assertContains(response, "wins")

def test_get_event_without_private_bet(self):
		event = create_event("Past event", start_days=-2, end_days=5, options=True)
		player = Player.objects.create(**new_player1)
		option = event.eventoption_set.all()[0]
		bet = option.bet_set.create(player=player, selection=option, amount=2500, bet_key=uuid4(), private=True)
		
		response = self.client.get(reverse('event_detail', args=(event.pub_key, )))
		
		self.assertIs(response.status_code, 200)
		self.assertContains(response, event.name)
		self.assertNotContains(response, 2500)

def test_event_not_found(self):
		response = self.client.get(reverse('event_detail', args=('1q2w3efvbg', )))
		self.assertEqual(response.status_code, 404)

class PlayerModelTests(TestCase):

def test_add_player_to_event(self):
		event = create_event("Active event")
		player = Player.objects.create(name="Obinna Okafor", username="reptofrank", email_address="obinna.okafor01@gmail.com")
		player.events.add(event)

self.assertQuerysetEqual(player.events.all(), ['<Event: Active event>'])

# class PlayerViewTests(TestCase):

# 	def test_add_player_to_event(self)
# 		event = create_event("Active event")
# 		player = Player.objects.create(name="Obinna Okafor", username="reptofrank", email_address="obinna.okafor01@gmail.com")
# 		player.events.add(event)

class BetPostTest(TestCase):

def test_post_new_bet(self):
		event = create_event("New Event", options=True)

player = Player.objects.create(name="Obinna Okafor", username="reptofrank", email_address="obinna.okafor01@gmail.com")
		post_data = {
			"amount": 2000,
			"event_option": event.eventoption_set.all()[0].id,
			"player": player.id,
			"private": 'no'
		}

response = self.client.post(reverse('post_bet', args=(event.pub_key, )), data=post_data)
		self.assertEqual(response.status_code, 302)
		self.assertRedirects(response, '/bets/events/' + str(event.pub_key), status_code=302)

def test_post_not_new_bet_event_not_found(self):
		
		player = Player.objects.create(name="Obinna Okafor", username="reptofrank", email_address="obinna.okafor01@gmail.com")
		post_data = {
			"amount": 2000,
			"event_option": 2
		}

response = self.client.post(reverse('post_bet', args=('1q2w3e4r5t', )), data=post_data)

self.assertEqual(response.status_code, 404)

def test_post_new_bet_with_wrong_event_option(self):
		event = create_event("New Event", options=True)

player = Player.objects.create(name="Obinna Okafor", username="reptofrank", email_address="obinna.okafor01@gmail.com")
		post_data = {
			"amount": 2000,
			"event_option": 9
		}

response = self.client.post(reverse('post_bet', args=(str(event.pub_key), )), data=post_data)

self.assertContains(response, "Check your entries and try again")

def test_post_new_bet_with_no_amount(self):
		event = create_event("New Event", options=True)

player = Player.objects.create(**new_player1)
		post_data = {
			"event_option": event.eventoption_set.all()[0].id
		}

response = self.client.post(reverse('post_bet', args=(str(event.pub_key), )), data=post_data)
		self.assertContains(response, "Check your entries and try again")

def test_post_match_bet(self):
		event = create_event("Past event", start_days=-2, end_days=5, options=True)
		player1 = Player.objects.create(**new_player1)
		player2 = Player.objects.create(**new_player2)
		options = event.eventoption_set.all()
		bet = options[0].bet_set.create(player=player1, amount=2500, bet_key=uuid4())

matching_bet = {"option": options[1].id, "player": player2.id, "amount": bet.amount}
		response = self.client.post(reverse('match_bet', args=(str(event.pub_key), str(bet.bet_key))), data=matching_bet)
		self.assertEqual(response.status_code, 302)

${this.title}

Code Editor : tests.py