def test_is_published_with_old_and_recent_question(self):
"""is_published() returns True for questions whose pub_date is in the older or within the last day."""
old_time = timezone.now() - datetime.timedelta(days=1, seconds=1)
new_time = timezone.now() - datetime.timedelta(seconds=1)
old_question = Question(pub_date=old_time)
new_question = Question(pub_date=new_time)
self.assertIs(old_question.is_published(), True)
self.assertIs(new_question.is_published(), True)
def test_published_after_end_time(self):
"""Check that the vote is currently allowed after publication date."""
pub = \
timezone.now() - datetime.timedelta(hours=23, minutes=59)
end = pub + abs(datetime.timedelta(hours=22, minutes=59))
recent_question = Question(pub_date=pub, end_date=end)
self.assertIs(recent_question.is_published(), True)
def test_published_before_pub_time(self):
"""Check the vote is currently allowed before publication date."""
pub = \
timezone.now() + datetime.timedelta(hours=23, minutes=59)
end = pub + abs(datetime.timedelta(days=2))
recent_question = Question(pub_date=pub, end_date=end)
self.assertIs(recent_question.is_published(), False)
def test_is_published_with_future_question(self):
"""
Test published question by future. If yes, return False.
"""
time = timezone.now() + datetime.timedelta(days=30)
future_question = Question(pub_date=time)
self.assertFalse(future_question.is_published())
def test_is_published_with_old_question(self):
"""
Test published question by past. If yes, return True.
"""
time = timezone.now() - datetime.timedelta(days=1, seconds=1)
old_question = Question(pub_date=time)
self.assertTrue(old_question.is_published())
def test_is_published_with_future_question(self):
"""is_published() returns False for questions whose pub_date is in the future."""
time = timezone.now() + datetime.timedelta(days=30)
future_question = Question(pub_date=time)
self.assertFalse(
future_question.is_published(),
"is_published should be False because it's not release yet")
def test_can_vote_before_pub_date(self):
"""The user could not vote before pub date."""
now = timezone.now()
question = Question("Test1", pub_date=now + datetime.timedelta(days=1))
self.assertTrue(now < question.pub_date)
self.assertFalse(question.is_published())
self.assertFalse(question.can_vote())
def test_is_published_with_future_question(self):
"""
is_published() return False for questions whose pub_date
is in the future.
"""
time = timezone.now() + datetime.timedelta(days=30)
future_question = Question(pub_date=time)
self.assertIs(future_question.is_published(), False)
def test_published_between_pub_and_end_time(self):
"""Check the vote is currently allowed\
between publication and end date."""
pub = \
timezone.now() - datetime.timedelta(hours=23, minutes=59)
end = pub + abs(datetime.timedelta(days=2))
recent_question = Question(pub_date=pub, end_date=end)
self.assertIs(recent_question.is_published(), True)
def test_is_published_with_recent_question(self):
"""
Test published question by now. If yes, return True.
"""
time = timezone.now() - datetime.timedelta(
hours=23, minutes=59, seconds=59)
recent_question = Question(pub_date=time)
self.assertTrue(recent_question.is_published())
def test_is_published_after_pub_date(self):
"""The question is not published after pub date."""
now = timezone.now()
question = Question("Test1",
pub_date=now - datetime.timedelta(days=2),
end_date=now - datetime.timedelta(days=1))
self.assertTrue(now > question.end_date)
self.assertTrue(question.is_published())
def test_is_publish_with_one_year_question(self):
"""
is_published() return True for questions whose pub_date
is older than current time no matter how old it is.
"""
time = timezone.now() - datetime.timedelta(days=365)
very_old_question = Question(pub_date=time)
self.assertIs(very_old_question.is_published(), True)
def test_can_vote_after_end_date(self):
"""The user could not vote after end date."""
now = timezone.now()
question = Question("Test1",
pub_date=now - datetime.timedelta(days=2),
end_date=now - datetime.timedelta(days=1))
self.assertTrue(now > question.end_date)
self.assertTrue(question.is_published())
self.assertFalse(question.can_vote())
def test_is_published_on_date(self):
"""The question is published on pub date time."""
now = timezone.now()
question = Question("Test1",
pub_date=now - datetime.timedelta(days=1),
end_date=now + datetime.timedelta(days=3))
self.assertTrue(now >= question.pub_date)
self.assertTrue(now <= question.end_date)
self.assertTrue(question.is_published())
def test_is_published(self):
"""Test if question is published.
Test if the question can vote.
"""
time = timezone.now() + datetime.timedelta(days=-1)
past_question = Question(pub_date=time)
self.assertIs(past_question.is_published(), True)
def test_can_vote(self):
"""The user could vote between pub date and end date interval."""
now = timezone.now()
question = Question("Test1",
pub_date=now - datetime.timedelta(days=1),
end_date=now + datetime.timedelta(days=3))
self.assertTrue(now >= question.pub_date)
self.assertTrue(now <= question.end_date)
self.assertTrue(question.is_published())
self.assertTrue(question.can_vote())
def test_is_published_is_work(self):
"""Test for is_published().
is_published() must returns True for questions
whose pub_date is already published.
"""
time = timezone.now()
day_before = time - self.add_time_one_year
after_day = time + self.add_time_one_year
question1 = Question(pub_date=time, end_date=after_day)
self.assertIs(question1.is_published(), True)
question2 = Question(pub_date=day_before, end_date=after_day)
self.assertIs(question2.is_published(), True)
question3 = Question(pub_date=after_day,
end_date=after_day + self.add_time_one_year)
self.assertIs(question3.is_published(), False)
question4 = Question(pub_date=after_day, end_date=time)
self.assertIs(question4.is_published(), False)
question5 = Question(pub_date=time, end_date=time)
self.assertIs(question5.is_published(), True)
def test_is_published_with_old_question(self):
"""is_published() return True for questions when reach to pub_date."""
time = timezone.now() - datetime.timedelta(days=1, seconds=1)
old_question = Question(pub_date=time)
self.assertIs(old_question.is_published(), True)
def test_is_published_with_recent_question(self):
"""is_published() returns True for questions whose pub_date is in the past."""
time = timezone.now()
future_question = Question(pub_date=time)
self.assertTrue(future_question.is_published(),
"is_published should be True because it's release")
def test_is_published_with_old_question(self):
"""is_published() returns True for questions whose pub_date is in the past."""
time = timezone.now() - datetime.timedelta(days=30)
future_question = Question(pub_date=time)
self.assertTrue(future_question.is_published(),
"is_published should be False because it's release")
def tsst_not_published_question(self):
"""is_published() method will return False if poll not published."""
pub = timezone.now() + datetime.timedelta(days=1)
end = timezone.now() + datetime.timedelta(days=5)
not_published_question = Question(pub_date=pub, end_date=end)
self.assertIs(not_published_question.is_published(), False)
def test_published_question(self):
"""is_published() method will return True if poll already published."""
pub = timezone.now() + datetime.timedelta(days=-1)
end = timezone.now() + datetime.timedelta(days=5)
published_question = Question(pub_date=pub, end_date=end)
self.assertIs(published_question.is_published(), True)
def test_is_published_with_current_date_is_before_publication_date(self):
"""is_published() returns False if current date is before question’s publication date."""
time = timezone.now() + datetime.timedelta(
hours=23, minutes=59, seconds=59)
recent_question = Question(pub_date=time)
self.assertIs(recent_question.is_published(), False)
def test_is_published_with_future_question(self):
""" return False if the current time is before the question was published """
time = timezone + datetime.timedelta(days=30)
future_question = Question(pub_date=time)
self.assertIs(future_question.is_published(), False)
def test_is_published_with_recent_question(self):
"""is_published() return True for questions when reach to pub_date."""
time = timezone.now() - datetime.timedelta(
hours=23, minutes=59, seconds=59)
recent_question = Question(pub_date=time)
self.assertIs(recent_question.is_published(), True)
def test_is_published_with_old_question(self):
"""is_published() return Ture if current date is after question's publication date."""
time = timezone.now() - datetime.timedelta(days=1)
old_question = Question(pub_date=time)
self.assertIs(old_question.is_published(), True)
def test_is_published_with_future_question(self):
"""is_published() return False if current date is before question's publication date."""
time = timezone.now() + datetime.timedelta(days=10)
future_question = Question(pub_date=time)
self.assertIs(future_question.is_published(), False)
def test_is_published_with_not_published_question(self):
"""Check is_published with not published question."""
end_time = timezone.now() + datetime.timedelta(days=1)
question = Question(pub_date=end_time)
self.assertFalse(question.is_published())
def test_is_published_with_present_question(self):
"""is_published() return Ture if current date is on question's publication date."""
time = timezone.now()
present_question = Question(pub_date=time)
self.assertIs(present_question.is_published(), True)
def test_is_published(self):
"""Check for normal is_published."""
time = timezone.now() - datetime.timedelta(days=1)
question = Question(pub_date=time)
self.assertTrue(question.is_published())