class TestResetVotes(TestCase):
yesterday = dateManager.today() + datetime.timedelta(days=-1)
def test_reset_things_from_last_vote_day(self):
team = Team.objects.create(team_name="testTeam")
other_team = Team.objects.create(team_name="otherTeam")
User.objects.all().delete()
Restaurant.objects.all().delete()
Vote.objects.all().delete()
Absence.objects.all().delete()
first = User.objects.create(username="******", team=team)
second = User.objects.create(username="******", team=other_team)
restaurant = Restaurant.objects.create(
restaurant_name="test_restaurant", restaurant_for_team=other_team)
Absence.objects.create(user=first,
absenceFrom=self.yesterday,
absenceTo=self.yesterday,
reason=Reasons.OUT.value)
Vote.objects.create(restaurant=restaurant, user=second)
self.assertEqual(len(User.objects.all()), 2)
self.assertEqual(Restaurant.objects.exists(), True)
self.assertEqual(Absence.objects.exists(), True)
self.assertEqual(Vote.objects.exists(), True)
self.assertEqual(ChoicesOfTheWeek.objects.exists(), False)
resetVotes.reset_things_from_last_vote_day()
self.assertEqual(Absence.objects.exists(), False)
self.assertEqual(Vote.objects.exists(), False)
self.assertEqual(ChoicesOfTheWeek.objects.exists(), True)
class AbsenceFromTest(TestCase):
today = dateManager.today()
tomorrow = dateManager.tomorrow()
yesterday = today + datetime.timedelta(days=-1)
day_before_yesterday = today + datetime.timedelta(days=-2)
def test_absence_form(self):
form_data = {'absenceFrom': self.tomorrow, 'absenceTo': self.today}
form = AbsenceForm(data=form_data)
self.assertFalse(form.is_valid())
form_data = {
'absenceFrom': self.day_before_yesterday,
'absenceTo': self.yesterday
}
form = AbsenceForm(data=form_data)
self.assertFalse(form.is_valid())
form_data = {'absenceFrom': self.today, 'absenceTo': self.tomorrow}
form = AbsenceForm(data=form_data)
self.assertTrue(form.is_valid())
form_data = {'absenceFrom': self.yesterday, 'absenceTo': self.tomorrow}
form = AbsenceForm(data=form_data)
self.assertFalse(form.is_valid())
def update_forecast():
json = get_forecast_json()
today = dateManager.today().strftime("%Y-%m-%d 12:00:00")
tomorrow = dateManager.tomorrow().strftime("%Y-%m-%d 12:00:00")
try:
logger.debug("process forecast information in json")
if json is not None:
for json in json['list']:
if json['dt_txt'] == tomorrow and dateManager.is_after_noon():
save_new_forecast(json)
elif json['dt_txt'] == today and not dateManager.is_after_noon(
):
save_new_forecast(json)
except:
pass
class AbsenceDaoTest(TestCase):
absence_dao = AbsenceDAO()
today = dateManager.today()
def setUp(self):
team = Team.objects.create(team_name="TestTeam")
first_Test_User = User.objects.create(username='******', is_staff=True)
first_Test_User.set_password('12345')
first_Test_User.team = team
first_Test_User.save()
def test_set_absence_for_User(self):
user = User.objects.get(username='******')
self.absence_dao.set_absence_for_user(user, self.today, self.today, Reasons.ABSENT)
user_absence = Absence.objects.filter(user=user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.ABSENT.value)
self.assertEqual(len(user_absence), 1)
def test_delete_absence(self):
user = User.objects.get(username='******')
absence = Absence.objects.filter(user=user)
self.absence_dao.delete_absence(absence)
self.assertEqual(len(Absence.objects.all()), 0)
def test_get_absences_from_user(self):
user = User.objects.get(username='******')
Absence.objects.create(user=user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.ABSENT.value)
absences = Absence.objects.filter(user=user)
self.assertEquals(len(absences), 1)
def test_get_absences_for_reason(self):
user = User.objects.get(username='******')
absence = Absence.objects.create(user=user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.ABSENT.value)
absences_for_reason = self.absence_dao.get_absences_from_team_for_reason(Reasons.ABSENT, user.team)
self.assertEqual(absence, absences_for_reason.get())
class AbsenceLogicTest(TestCase):
absence_logic = AbsenceLogic()
absence_dao = AbsenceDAO()
today = dateManager.today()
tomorrow = dateManager.tomorrow()
yesterday = dateManager.today() + datetime.timedelta(days=-1)
current_vote_date = dateManager.current_vote_day()
def setUp(self):
team = Team.objects.create(team_name="TestTeam")
test_user = User.objects.create(username='******', is_staff=True)
test_user.set_password('12345')
test_user.team = team
test_user.save()
test_user_second = User.objects.create(username='******', is_staff=True)
test_user_second.set_password('12345')
test_user_second.team = team
test_user_second.save()
test_user_third = User.objects.create(username='******', is_staff=True)
test_user_third.set_password('12345')
test_user_third.team = team
test_user_third.save()
Absence.objects.create(user=test_user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.OUT.value)
Absence.objects.create(user=test_user_second,
absenceFrom=self.tomorrow,
absenceTo=self.tomorrow,
reason=Reasons.OUT.value)
Absence.objects.create(user=test_user_third,
absenceFrom=self.yesterday,
absenceTo=self.yesterday,
reason=Reasons.OUT.value)
# other User absence with different team does not effect absences for TestTeam
other_team = Team.objects.create(team_name="other_team")
other_user = User.objects.create(username='******', is_staff=True)
other_user.set_password('12345')
other_user.team = team
Absence.objects.create(user=other_user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.OUT.value)
def test_check_if_a_absence_is_active_for_date(self):
absence = [Absence.objects.get(user__username='******')]
self.assertTrue(self.absence_logic.check_if_a_absence_is_active_for_date(absence, self.today))
self.assertFalse(self.absence_logic.check_if_a_absence_is_active_for_date(absence, self.tomorrow))
def test_delete_old_absence_for_user(self):
absence_first_user = Absence.objects.get(user__username='******')
absence_second_user = Absence.objects.get(user__username='******')
firstUser = User.objects.get(username='******')
secondUser = User.objects.get(username='******')
self.absence_logic.delete_old_and_current_absences_for_user(firstUser)
self.assertNotIn(absence_first_user, self.absence_dao.get_absences_from_user(firstUser))
Absence.objects.create(user=firstUser,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.OUT.value)
self.absence_logic.delete_old_and_current_absences_for_user(firstUser)
self.assertIn(absence_second_user, self.absence_dao.get_absences_from_user(secondUser))
def test_set_todays_absence_for_user(self):
self.refresh_absence_databse()
# User does not have any absence -> is after noon absence for tomorrow else for today / reason does not matter
fresh_user = User.objects.create(username='******', is_staff=True)
fresh_user.set_password('12345')
fresh_user.save()
self.absence_logic.set_vote_absence_for_user(user=fresh_user, reason=Reasons.OUT)
absence_from_fresh_user = Absence.objects.filter(user=fresh_user)
self.assertEqual(absence_from_fresh_user.get().absenceFrom, self.current_vote_date)
self.absence_logic.set_vote_absence_for_user(user=fresh_user, reason=Reasons.OUT)
absence_from_fresh_user = Absence.objects.filter(user=fresh_user)
self.assertEqual(absence_from_fresh_user.filter(user=fresh_user).get().absenceFrom, self.current_vote_date)
# Start with clear database
self.refresh_absence_databse()
self.absence_logic.set_vote_absence_for_user(user=fresh_user, reason=Reasons.OUT)
out_absence = Absence.objects.get(user=fresh_user)
self.absence_logic.set_vote_absence_for_user(user=fresh_user, reason=Reasons.DONOTCARE)
all_absences = Absence.objects.all()
# Old absence should be deleted
self.assertNotIn(out_absence, all_absences)
# New absence should be there
do_not_care_absence = Absence.objects.get(user=fresh_user)
self.assertIn(do_not_care_absence, all_absences)
def test_delete_absences_for_user(self):
absences = Absence.objects.all()
self.assertEqual(len(absences), 4)
for a in absences:
self.absence_logic.delete_absences_for_user(a.user, [a.__str__()])
absences = Absence.objects.all()
self.assertEqual(len(absences), 0)
def test_get_active_absent_absences(self):
team = Team.objects.get(team_name="TestTeam")
user = User.objects.get(username='******')
absent = Absence.objects.create(user=user,
absenceFrom=self.today,
absenceTo=self.tomorrow,
reason=Reasons.ABSENT.value)
active_absences = self.absence_logic.get_active_absent_absences_from_team(team)
self.assertEqual(active_absences, [absent])
def test_delete_all_inactive_absences(self):
first_absence = Absence.objects.get(user__username='******')
second_absence = Absence.objects.get(user__username='******')
third_absence = Absence.objects.get(user__username='******')
other_absence = Absence.objects.get(user__username='******')
self.assertEquals([first_absence, second_absence, third_absence, other_absence], list(Absence.objects.all()))
self.absence_logic.delete_all_inactive_absences()
self.assertIn(second_absence, list(Absence.objects.all()))
def test_get_sorted_absent_absences(self):
team = Team.objects.get(team_name="TestTeam")
user = User.objects.get(username='******')
user_two = User.objects.get(username='******')
absence = Absence.objects.create(user=user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.ABSENT.value)
absence_two = Absence.objects.create(user=user_two,
absenceFrom=self.tomorrow,
absenceTo=self.tomorrow,
reason=Reasons.ABSENT.value)
absences = self.absence_logic.get_sorted_absent_absences_for_team(team)
self.assertEqual(absences, {'test_user': [absence], 'test_user_second': [absence_two]})
def test_delete_vote_absence_for_user(self):
self.refresh_absence_databse()
user = User.objects.get(username='******')
absence = Absence.objects.create(user=user,
absenceFrom=self.today,
absenceTo=self.today,
reason=Reasons.OUT.value)
self.absence_logic.delete_vote_absence_for_user(user, self.yesterday)
self.assertEqual(list(Absence.objects.all()), [])
def refresh_absence_databse(self):
for a in Absence.objects.all():
a.delete()
def test_today(self):
self.assertEqual(dateManager.today(), datetime.date.today())
class AbsenceIndexTest(TestCase):
today = dateManager.today()
tomorrow = dateManager.tomorrow()
yesterday = today + datetime.timedelta(days=-1)
def setUp(self):
Forecast.objects.create(temperature=12, description="sunny")
team = Team.objects.create(team_name="TestTeam")
another_test_user = User.objects.create(username='******',
is_staff=True)
another_test_user.set_password('12345')
another_test_user.team = team
another_test_user.save()
Absence.objects.create(user=another_test_user,
absenceFrom=self.tomorrow,
absenceTo=self.tomorrow,
reason=Reasons.ABSENT.value)
def test_absenceIndex(self):
absence = Absence.objects.get(user__username='******')
self.client.post('/admin/login/?next=/', {
'username': '******',
'password': '******'
})
response = self.client.get(reverse('main:absenceIndex'))
self.assertEquals(response.status_code, 200)
self.assertEquals(
response.context[-1]['weather_context'], {
'temperature_in_c': Decimal('12.00'),
'weather_group': '',
'description': 'sunny',
'icon': ''
})
self.assertEquals(response.context[-1]['absences_from_users'],
{'another_test_user': [absence]})
def test_save_new_absence(self):
user = User.objects.get(username='******')
self.assertEqual(len(Absence.objects.all()), 1)
login = self.client.post('/admin/login/?next=/save_new_absence', {
'username': '******',
'password': '******'
})
self.assertRedirects(login, '/save_new_absence', status_code=302)
response = self.client.post('/save_new_absence', {
'user': user,
'absenceFrom': self.today,
'absenceTo': self.today
})
self.assertEqual(len(Absence.objects.all()), 2)
response = self.client.post(
'/save_new_absence', {
'user': user,
'absenceFrom': self.yesterday,
'absenceTo': self.yesterday
})
self.assertEqual(len(Absence.objects.all()), 2)
def test_delete_absences(self):
user = User.objects.get(username='******')
absence = Absence.objects.get(user__username='******')
self.assertEqual(Absence.objects.all().get(), absence)
self.assertEqual(len(Absence.objects.all()), 1)
login = self.client.post('/admin/login/?next=/delete_absences', {
'username': '******',
'password': '******'
})
self.assertRedirects(login,
'/delete_absences',
status_code=302,
target_status_code=302)
response = self.client.post('/delete_absences', {
'user': user,
'absenceBox': absence.__str__()
})
self.assertEqual(len(Absence.objects.all()), 0)