def test_was_published_recently_with_future_question(self): """ was_published_recently() should 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.assertEqual(future_question.was_published_recently(), False) def test_was_published_recently_with_old_question(self): """ was_published_recently() should return False for questions whose pub_date is older than 1 day """ time = timezone.now() - datetime.timedelta(days=30) old_question = Question(pub_date=time) self.assertEqual(old_question.was_published_recently(), False) def test_was_published_recently_with_recent_question(self): """ was_published_recently() should return True for questions whose pub_date is within the last day """ time = timezone.now() - datetime.timedelta(hours=1) recent_question = Question(pub_date=time) self.assertEqual(recent_question.was_published_recently(), True)
def test_was_published_recently_with_future_question(self): """ was_published_recently() should 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.assertEqual(future_question.was_published_recently(), False)
def test_was_published_recently_with_old_question(self): """ should return False if the question is older than a day """ time = timezone.now() - datetime.timedelta(days=1) past_question = Question(pub_date=time) self.assertEqual(past_question.was_published_recently(), False)
def test_was_published_recently_with_recent_question(self): """ was_published_recently() should return True for q's whose pub_dates are within the last day """ one_hour_ago = timezone.now() - datetime.timedelta(hours=1) # one hour ago recent_question = Question(pub_date=one_hour_ago) self.assertEqual(recent_question.was_published_recently(), True)
class QuestionModelTest(TestCase): def setUp(self): self.q1 = Question() self.q1.question_text = "What is your question?" self.q1.pub_date = timezone.now() self.q1.save() self.q2 = Question() self.q2.question_text = "What is your next question?" self.q2.pub_date = timezone.now() self.q2.save() def tearDown(self): pass def test_save_and_retrieve_Question(self): saved_items = Question.objects.all() self.assertEqual(saved_items.count(), 2) self.assertEqual(saved_items[0].question_text, self.q1.question_text) self.assertEqual(saved_items[1].question_text, self.q2.question_text) def test_save_and_retrieve_Choice(self): self.q1.choice_set.create(choice_text = 'Choice 1', votes=0) self.q1.choice_set.create(choice_text = "Choice 2", votes=1) saved_items = Choice.objects.all() self.assertEqual(saved_items.count(), 2) self.assertEqual(saved_items[0].choice_text, "Choice 1") self.assertEqual(saved_items[1].choice_text, "Choice 2")
def test_was_published_recently_with_old_question(self): """ was_published_recently should return False for questions whose pub_date is older than 1 day """ time = timezone.now() - datetime.timedelta(days=30) old_question = Question(pub_date=time) self.assertEqual(old_question.was_published_recently(), False)
def test_view_can_handle_votes_via_POST(self): # set up a poll with choices poll1 = Question(question_text='6 times 7', pub_date=timezone.now()) poll1.save() choice1 = Choice(question=poll1, choice_text='42', votes=1) choice1.save() choice2 = Choice(question=poll1, choice_text='The Ultimate Answer', votes=3) choice2.save() # set up our POST data - keys and values are strings post_data = {'choice': str(choice2.id)} # make our request to the view poll_url = '/polls/%d/vote/' % (poll1.id,) response = self.client.post(poll_url, data=post_data) #URL to redirect redirect_url = '/polls/%d/results/' % (poll1.id,) # retrieve the updated choice from the database choice_in_db = Choice.objects.get(pk=choice2.id) # check it's votes have gone up by 1 self.assertEquals(choice_in_db.votes, 4) # always redirect after a POST - even if, in this case, we go back # to the same page. self.assertRedirects(response, redirect_url)
def test_was_published_recently_with_recent_question(self): """ was_published_recently() shoudl return True for questions whose pub_date is within a day old. """ time = timezone.now() current_question = Question(pub_date=time) self.assertEqual(current_question.was_published_recently(), True)
def write_new(request, methods=['POST']): if request.POST['question'] and request.POST['choice1'] and request.POST['choice2']: q=Question() q.title=request.POST['question'] q.save() c1=Choice() c1.questions=q c1.options=request.POST['choice1'] c1.save() c2=Choice() c2.questions=q c2.options=request.POST['choice2'] c2.save() if request.POST['choice3']: c3=Choice() c3.questions=q c3.options=request.POST['choice3'] c3.save() if request.POST['choice4']: c4=Choice() c4.questions=q c4.options=request.POST['choice4'] c4.save() if request.POST['choice5']: c5=Choice() c5.questions=q c5.options=request.POST['choice5'] c5.save() return HttpResponseRedirect('/poll/')
def test_was_published_recently_with_old_question(self): """ was_published_recently() should return False for questions whose pub_date is over a day in the past """ time = timezone.now() - datetime.timedelta(days=2) past_question = Question(pub_date=time) self.assertEqual(past_question.was_published_recently(), False)
def create_question(request): """ Create Question """ if request.method == 'POST': form = CreateQuestionForm(request.POST) if form.is_valid(): data = form.cleaned_data # Get Question Text (Required) question_text = data.get('question_text') # Create a empty list to group the choice text choices = [] for k, v in data.iteritems(): if k != 'question_text' and v != '': choices.append(v) # Instance and save a Question question = Question(question_text=question_text) question.save() # Create choices for question for choice_text in choices: question.choice_set.create(choice_text=choice_text) return HttpResponseRedirect(reverse('polls:index')) else: form = CreateQuestionForm() context = {'form': form} return render(request, 'polls/create.html', context)
def test_was_published_recently_with_recent_question(self): """ should return true """ time = timezone.now() - datetime.timedelta(hours=1) recent_question = Question(pub_date=time) self.assertEqual(recent_question.was_published_recently(), True)
def test_was_published_recently_with_future_poll(self): """ was_published_recently() should return False for polls whose pub_date is in the future """ future_poll = Question(pub_date=timezone.now() + datetime.timedelta(days=30)) self.assertEqual(future_poll.was_published_recently(), False)
def test_was_published_recently_with_old_questions(self): """ was_published_recently() should return False for questions more than a day old. """ time = timezone.now() - datetime.timedelta(days=30) old_question = Question(pub_date=time) self.assertIs(old_question.was_published_recently(), False)
def test_was_published_recently_with_recent_questions(self): """ was_published_recently() should return True for questions whose pub_date is within the last day """ time = timezone.now() - datetime.timedelta(hours=1) recent_question = Question(pub_date=time) self.assertEqual(recent_question.was_published_recently(), True)
def randomQuestionGenerator(users, tags): user = User.objects.get(id=random.randint(1, users - 1)) filename = "/home/nikita/web/ask_chizhikov/polls/management/commands/" + "q" + str(random.randint(1, 5)) + ".txt" f = open(filename, 'r') title = "" text = "" help = 0 for line in f: if line == "\n": help = 1 if help == 0: title += line else: text += line added_at = parse_datetime("2012-02-21 10:28:45") ##### q = Question(author=user, text=text, title=title, rating=random.randint(0, 50), added_at=added_at, answers=random.randint(0, 1000)) q.save() for i in range(0, 5): random_tag_id = random.randint(1, tags-1) q.tag.add(Tag.objects.get(id=random_tag_id)) q.save()
def test_was_published_recently_with_recent_question(self): """ was_published_recently() should return true for questions less than a day old in the past. """ time = timezone.now() - datetime.timedelta(hours=1) recent_question = Question(pub_date=time) self.assertIs(recent_question.was_published_recently(), True)
def generate_elements(count=1): """ this guy generates db elements for testing """ for k in range(count): question = "" for i in range(choice((2, 3, 4, 5, 6, 7))): question = " ".join((question, choice(WORDS))) question = question[1:] + "?" question = question[0].upper() + question[1:] q = Question(question_text=question, pub_date=timezone.now()) q.save() print(q.id, q.question_text) for choicecount in range(choice((2, 3))): choicetxt = "" for choicewords in range(choice((2, 3, 4, 5))): choicetxt = " ".join((choicetxt, choice(WORDS))) choicetxt = choicetxt[1:] choicetxt = choicetxt[0].upper() + choicetxt[1:] + "." # print('\t', choicetxt) ch = Choice(question=q, choice_text=choicetxt, votes=choice((0, 1, 2, 3, 4, 5))) ch.save() print("\t", ch.question.id, ch.choice_text)
def add_question(request): if 'Submit' in request.POST: new_question_title = request.POST['question_title'] new_question_text = request.POST['question_text'] new_question = Question(question_text=new_question_text, pub_date=timezone.now(), author=request.user, modification_time=timezone.now(), question_title=new_question_title) tag_string = request.POST['tags'] tags = tag_string.split(',') new_question.save() for new_tag in tags: new_tag_object = Tags(tag=new_tag) #new_tag_object.save() if Tags.objects.filter(tag=new_tag): new_question.tags.add(Tags.objects.get(tag=new_tag)) else: #print "not exists" #print Tags.objects.get(tag=new_tag) # print Tags.objects.get(tag=new_tag) # new_tag_object = Tags.objects.get(tag=new_tag) # print "get successfully" # new_question.tags.add(new_tag_object) # print "add successfully" new_tag_object.save() new_question.tags.add(new_tag_object) print "out of for" new_question.save() #print new_question.tags.all() return HttpResponseRedirect(reverse('polls:index')) elif 'Cancel' in request.POST: return HttpResponseRedirect(reverse('polls:ask')) else: return HttpResponse("Submit new question error")
def test_was_publishsed_recently_with_future_question(self): """ was_published_recently() should return false for future questions """ time = timezone.now() + timezone.timedelta(days=30) future_question = Question(pub_date=time) self.assertEqual(future_question.was_published_recently(), False)
def test_was_published_recently_with_old_question(self): """ was_published_recently() should return False for questions whose pub_date is older than 1 day """ time = timezone.now() - datetime.timedelta(days=30) old_question = Question(pub_date=time) self.assertEqual(old_question.was_published_recently(), False) def test_was_published_recently_with_recent_question(self): """ was_published_recently() should return True for questions whose pub_date is within the last day """ time = timezone.now() - datetime.timedelta(hours=1) recent_question = Question(pub_date=time) self.assertEqual(recent_question.was_published_recently(), True) ### inserted def create_question(question_text, days): """ Creates a question with the given `question_text` published the given number of `days` offset to now (negative for questions published in the past, positive for questions that have yet to be published). """ time = timezone.now() + datetime.timedelta(days=days) return Question.objects.create(question_text=question_text, pub_date=time)
def get_question(request): # if this is a POST request we need to process the form data if request.method == 'POST': # create a form instance and populate it with data from the request: form = QuestionForm(request.POST) # check whether it's valid: if form.is_valid(): question_body = request.POST.get('your_question', '') new_question = Question(question_text=question_body, pub_date=timezone.now()) new_question.save() characters = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w', 'x','y','z'] for i in range(0, 5): answer_text = 'your_answer_' + characters[i] new_answer = request.POST.get(answer_text, '') if new_answer != '': new_choice = Choice(question=new_question, choice_text=new_answer, votes=0) new_choice.save() # process the data in form.cleansed_data as required # ... # redirect to a new URL: return HttpResponseRedirect('/polls/') # if a GET (or any other method) we'll create a blank form else: form = QuestionForm() return render(request, 'polls/question.html', {'form': form})
def test_was_published_recently_with_old_question(self): """ was_published_recently() should return false if the pub_date is older than 1 day """ time = timezone.now() - datetime.timedelta(days=2) old_question = Question(pub_date=time) self.assertEquals(old_question.was_published_recently(), False, "Question posted 2 days ago")
def test_was_published_recently_with_old_question(self): """ was_published_recently should return False if its pub_date is not within the last day. """ time = timezone.now() - datetime.timedelta(days = 5) old_question = Question(pub_date = time) self.assertEqual(old_question.was_published_recently(), False)
def create_question(self, question_text, choice_texts): question = Question(question_text=question_text) question.save() for choice_text in choice_texts: Choice(question=question, choice_text=choice_text).save() return question
def test_was_published_recently_with_recent_question(self): """ was_published_recently() should return true if the pub_date is within 1 Day """ time = timezone.now() - datetime.timedelta(hours=1) recent_question = Question(pub_date=time) self.assertEqual(recent_question.was_published_recently(), True, "Question posted 1 hour ago")
def test_was_published_recently_with_future_question(self): #pass """docstring for QuestionMethodTest"TestCasef __init__(self, arg): def test_was_published_recently_with_future_question(self): pass""" time = timezone.now() + datetime.timedelta(days=30) future_question = Question(pub_date = time) self.assertEqual(future_question.was_published_recently(),False)
def test_was_published_recently_with_old_questions(self): """ was_published_recently() should return flase for question published older that 1 day """ time = timezone.now() - timezone.timedelta(days=2) old_question = Question(pub_date=time) self.assertEqual(old_question.was_published_recently(), False)
def test_new_poll(self): #creating a poll object poll = Question() poll.question_text = "Shall we begin?" poll.pub_date = timezone.now() poll.save() self.assertEquals(poll.question_text, "Shall we begin?")
def test_was_published_recently_with_normal_question(self): """ was_published_recently() should return true for question published less than 1 day ago """ time = timezone.now() - timezone.timedelta(hours=2) normal_question = Question(pub_date = time) self.assertEqual(normal_question.was_published_recently(), True)
def test_was_published_recently_with_old_question(self): """ was_published_recently() returns False for question whose Pub_date is olded than 1 day """ time = timezone.now() - datetime.timedelta(days=1, seconds=1) # old_question = mixer.blend('polls.Question', pub_date=time) old_question = Question(pub_date=time) assert old_question.was_published_recently() == False
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_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_was_published_recently_with_recent_question(self): """ 1天内的问卷返回True :return: boolean """ time = timezone.now() - datetime.timedelta( hours=23, minutes=59, seconds=59) recent_question = Question(pub_date=time) self.assertIs(recent_question.was_published_recently(), True)
def test_was_published_recently_with_future_question(self): """ was_published_recently() should 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.assertEqual(future_question.was_published_recently(), False)
def test_was_published_recently_with_old_question(self): """Test was published recently with old question. was_published_recently() returns False for questions whose pub_date is older than 1 day. """ time = timezone.now() - datetime.timedelta(days=1, seconds=1) old_question = Question(pub_date=time) self.assertIs(old_question.was_published_recently(), False)
def test_was_published_recently_with_recent_question(self): """ was_published_recently() returns True for questions whose pub_date is within the last day. """ time = timezone.now() - datetime.timedelta( hours=23, minutes=59, seconds=59) recent_question = Question(pub_date=time) self.assertIs(recent_question.was_published_recently(), True)
def test_was_published_recently_with_recent_question(self): """ was_published_recenlty() should return True for questions whose pub_date is within the last day """ time = timezone.now() - datetime.timedelta(hours=1) recent_question = Question(pub_date=time) self.assertEqual(recent_question.was_published_recently(), True)
def test_was_published_recently_with_future_question(self): """Test was published recently with future question. was_published_recently() 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.assertIs(future_question.was_published_recently(), False)
def test_can_vote_with_open_question(self): """ can_vote() return True for questions whose still open. pub_date is in the past and end_date is in the future. """ pub_date_time = timezone.now() - datetime.timedelta(days=1) end_date_time = timezone.now() + datetime.timedelta(days=1) open_question = Question(pub_date=pub_date_time, end_date=end_date_time) self.assertIs(open_question.can_vote(), True)
def test_was_published_recently_with_recent_question(self): """Test for was_published_recently(). was_published_recently() must returns True for questions whose pub_date is within the last day. """ delta = datetime.timedelta(hours=23, minutes=59, seconds=59) time = timezone.now() - delta end_time = time + self.add_time_one_year recent_question = Question(pub_date=time, end_date=end_time) self.assertIs(recent_question.was_published_recently(), True)
def test_was_published_recently_with_recent_question(self): """Test if recent question is published recently. Test if recent question is published recently. """ time = timezone.now() - datetime.timedelta( hours=23, minutes=59, seconds=59) recent_question = Question(pub_date=time) self.assertIs(recent_question.was_published_recently(), True)
def test_create_choice(self): q = Question(question_text="What day is it?", pub_date=timezone.now()) q.save() c1 = Choice(choice_text="Monday", question=q) c2 = Choice(choice_text="Tuesday", question=q) c3 = Choice(choice_text="Sunday", question=q) c1.save() c2.save() c3.save() self.assertEqual(3, len(q.choice_set.all()))
def test_was_published_recently_with_recent_question(self): """ It should return True if a question was published until 1 day ago. """ recent_date = timezone.now() - datetime.timedelta( hours=23, minutes=59, seconds=59) recent_question = Question(pub_date=recent_date) self.assertIs(recent_question.was_published_recently(), True)
def questions(request): from polls.models import Question from datetime import datetime q = Question(question_text='How do you fel today?', pub_date=datetime.now()) q.save() questions = Question.objects.all() return render(request, 'questions.html', context={'questions': questions})
def test_can_vote_with_closed_question(self): """ can_vote() return False for questions whose end_date is already pass. """ pub_date_time = timezone.now() - datetime.timedelta(days=7) end_date_time = timezone.now() - datetime.timedelta(days=1) closed_question = Question(pub_date=pub_date_time, end_date=end_date_time) self.assertIs(closed_question.can_vote(), False)
def pubStatusOfQuestion(self, theQuestionP, timePublishedP, pubStatusP): aQuestion = Question(question_text = theQuestionP, pub_date = timePublishedP) #aQuestion is created, but as it is not saved it is no put in the #db.sqlite3 database pubStatusP[0] = aQuestion.was_published_recently() #print aQuestion.id #print aQuestion.question_text #print aQuestion.pub_date #print " pubStatusOfQuestion: ", pubStatusP[0], pubStatusP, " ", return 0
def test_was_published_recently_with_future_question(self): """ was_published_recently() returns False for questions whose pub_date is in the future. """ time = timezone.now() + datetime.timedelta(days=30) future_question = Question(pub_date=time) # Assert future question will return false, otherwise, there is a bug self.assertIs(future_question.was_published_recently(), False)
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 index(request): # if this is a POST request we need to process the form data if request.method == 'POST': # create a form instance and populate it with data from the request: form = InputForm(request.POST) # check whether it's valid: if form.is_valid(): location = form.cleaned_data['location'] fromdate = form.cleaned_data['fromdate'] todate = form.cleaned_data['todate'] if (location == '1'): madrigalUrl = 'http://isr.sri.com/madrigal' else: madrigalUrl = 'http://madrigal.haystack.mit.edu/madrigal' user_fullname = 'Ashaki Gumbs' user_email = '*****@*****.**' user_affiliation = 'Boston University' testData = madrigalWeb.MadrigalData(madrigalUrl) expList = testData.getExperiments(61, fromdate.year, fromdate.month, fromdate.day, 0, 0, 0, todate.year, todate.month, todate.day, 0, 0, 0, local=1) # newcgiurl = madrigalWeb.MadrigalData(madrigalUrl) # expList = newcgiurl.getExperiments(61, fromdate.year,fromdate.month,fromdate.day,0,0,0, # todate.year,todate.month,todate.day,0,0,0, local=1) Question.objects.all().delete() for i in range(len(expList)): q = Question(pub_date=timezone.now(), madrigalUrl=expList[i].madrigalUrl, name=expList[i].name, realUrl=expList[i].realUrl, url=expList[i].url, madid=expList[i].id) q.save() # process the data in form.cleaned_data as required # ... # redirect to a new URL: return HttpResponseRedirect('/polls/listexp/') # if a GET (or any other method) we'll create a blank form else: form = InputForm() return render(request, 'polls/inputinfo.html', {'form': form})
def test_list_question_relation(self): q = Question( question_text="question_text_006", pub_date=timezone.now()) q.save() c = Choice(question=q, choice_text="006_001") c.save() response = self.client.get( reverse("polls:choice-list"), **self.auth_headers) self.assertEqual(q.id, json.loads(response.content)[0]["question"])
def test_was_published_recently_with_future_question(self): # 미래의 datetime객체를 time변수에 할당 time = timezone.now() + datetime.timedelta(days=30) # 새 Question인스턴스를 생성, pub_date값에 미래시간을 주어줌 future_question = Question(pub_date=time) # 주어진 2개의 객체가 같아야 할 것(is)으로 기대함 # 같지 않은면 실패 self.assertIs( future_question.was_published_recently(), False, )
def test_was_published_recently_with_old_question(self): """ was_published_recently() returns False for a question with pub_date older than one day the past """ for step_back in [ timezone.timedelta(days=1, seconds=1), timezone.timedelta(days=2), ]: past_time = timezone.now() - step_back past_question = Question(pub_date=past_time) self.assertFalse(past_question.was_published_recently())
def save(self, owner, options): data = self.cleaned_data time = timezone.now() q = Question(question_text=data['question_text'], pub_date=time, owner=owner) q.save() for i in range(len(options)): Options.objects.create(question=q, option_text=options[i]['option_text'], votes=0) return q
def index(request): q = get_object_or_404(Question, id=1) try: q = Question.objects.get(id=2) except Question.DoesNotExist: q = Question() q.question_text = "" q.save() return HttpResponse("Hello, world. New Resposne ")
def setUp(self): self.url = 'http://localhost:8000/api/polls/' self.url_question = 'http://localhost:8000/api/polls/1/' self.name = "My entry title" self.new_name = "Update entry title" self.date = "2018-12-24T13:45:25Z" self.pk = 1 # create question db method self.movie = Question(question_text=self.name, pub_date=self.date) self.movie.save() self.assertEqual(Question.objects.count(), 1)
def test_add_choice_to_question(): """ Test if we can add a choice to a question safely """ pub_date = timezone.now() question = Question(question_text="Test question", pub_date=pub_date) question.save() choice = Choice(question_id=question.id, choice_text="Test choice", votes=23) choice.save() assert choice.choice_text == "Test choice" assert choice.votes == 23
def post(self, request): question = Question() question.question_text = "the question is what?" question.pub_date = timezone.now() # 序列化方法1 serializer = QuestionSerializer(question) print(serializer.data) #反序列化 stream = io.BytesIO(JSONRenderer().render(serializer.data)) data = JSONParser().parse(stream) print(QuestionSerializer(data).data) return Response(serializer.data)
def add(request): question = request.POST.get('question') choice1 = request.POST.get('choice1') choice2 = request.POST.get('choice2') q = Question(question_text=question, pub_date=timezone.now()) q.save() c = Choice(question=q, choice_text=choice1) c.save() c = Choice(question=q, choice_text=choice2) c.save() return HttpResponseRedirect(reverse('polls:index'))
def test_was_published_recently_with_recent_question(self): """ was_published_recently() returns True for a question with pub_date within one day the past """ for step_back in [ timezone.timedelta(hours=23, minutes=59, seconds=59), timezone.timedelta(hours=12), timezone.timedelta(seconds=1), timezone.timedelta(seconds=0), ]: past_time = timezone.now() - step_back past_question = Question(pub_date=past_time) self.assertTrue(past_question.was_published_recently())