Esempio n. 1
0
    def testQuestionAcknowledge(self):
        Twitter = TwitterMockup()
        today = datetime.date.today()
        current_time = int(time.time())
        
        u = self.createUser("da_zbur","enabled",10)
        u.use_questions = "yes"
        u.put()

        d1 = self.createDictEntry("da_zbur",2,"lucrative",\
            u"profitable, moneymaking, remunerative","[LOO-kruh-tiv]")
        d2 = self.createDictEntry("da_zbur",2,"ferociously(en)",\
            u"жестоко, яростно, свирепо, дико, неистово. Ужасно, невыносимо.")

        l1 = self.createLearnListItem("da_zbur",d1,today,current_time)
        l2 = self.createLearnListItem("da_zbur",d2,today,current_time)        
        
        # forcing question to be asked        
        l1.total_served = 4
        l2.total_served = 6
        l2.put()
        l1.put()
       
        buildDailyList(today, logging)
        # Keep in mind building daily list means serve times will be 
        # randomly distributed throighout the day!
        l1.next_serve_time = current_time
        l2.next_serve_time = current_time
        l2.put()
        l1.put()

        messages_generator = sendMessagesGenerator(Twitter, logging)
        m_list = []
        while True:
            try:
                message = messages_generator.next()
            except StopIteration:
                break
            m_list.append(message)

        # Now imagine those question didn't get answers before next daily
        # list is build
        acknowledgeQuestions(today)

        unack_count = Question.all().filter("answer_received =", None).count()
        self.assertEqual(0, unack_count) 
Esempio n. 2
0
 def testQuestionAdding(self):
     # This is testing buildDailyList method to make sure that
     # every second serving a Question opbject is added. 
     today = datetime.date.today()
     u = self.createUser("da_zbur","enabled",10)
     d1 = self.createDictEntry("da_zbur",2,"dog",u"собачка")
     lli = self.createLearnListItem("da_zbur",d1,today)
     u.use_questions = "yes"
     u.put()
     lli.total_served = 6 
     lli.put()
     buildDailyList(today, logging)
     question_list = []
     for q in Question.all().filter("lli_ref =", lli):
         question_list.append(q)
     self.assertEqual(1, len(question_list))
     self.assertEqual(d1.key(), question_list[0].lli_ref.dict_entry.key())
Esempio n. 3
0
    def testSendQuestion(self):
        Twitter = TwitterMockup()
        today = datetime.date.today()
        current_time = int(time.time())
        
        u = self.createUser("da_zbur","enabled",10)
        u.use_questions = "yes"
        u.put()

        d1 = self.createDictEntry("da_zbur",2,"lucrative",\
            u"profitable, moneymaking, remunerative","[LOO-kruh-tiv]")
        d2 = self.createDictEntry("da_zbur",2,"ferociously(en)",\
            u"жестоко, яростно, свирепо, дико, неистово. Ужасно, невыносимо.")

        l1 = self.createLearnListItem("da_zbur",d1,today,current_time)
        l2 = self.createLearnListItem("da_zbur",d2,today,current_time)        
        
        # forcing question to be asked        
        l1.total_served = 4
        l1.put()
       
        buildDailyList(today, logging)
        # Keep in mind building daily list means serve times will be 
        # randomly distributed throighout the day!
        l1.next_serve_time = current_time
        l2.next_serve_time = current_time
        l2.put()
        l1.put()

        messages_generator = sendMessagesGenerator(Twitter, logging)
        m_list = []
        while True:
            try:
                message = messages_generator.next()
            except StopIteration:
                break
            m_list.append(message)
        # Testing that proper Question entity was created
        q = Question.all().fetch(1)[0]
        self.assertEqual(2653, q.question_message_id)
        self.assertEqual(today, q.question_sent)
        self.assertEqual(4, l1.total_served)
        self.assertEqual(sys.maxint, q.lli_ref.next_serve_time)
        self.assertEqual("lucrative[LOO-kruh-tiv]:? [4]", m_list[0])
Esempio n. 4
0
    def testCheckForAnswer(self):
        # I should collapse this code into something reusable
        Twitter = TwitterMockup()
        today = datetime.date.today()
        current_time = int(time.time())
        
        u = self.createUser("da_zbur","enabled",10)
        u.use_questions = "yes"
        u.put()

        d1 = self.createDictEntry("da_zbur",2,"lucrative",\
            u"profitable, moneymaking, remunerative","[LOO-kruh-tiv]")
        
        l1 = self.createLearnListItem("da_zbur",d1,today,current_time)
        
        # forcing question to be asked        
        l1.total_served = 4
        l1.put()
       
        buildDailyList(today, logging)
        # Keep in mind building daily list means serve times will be 
        # randomly distributed throighout the day!
        l1.next_serve_time = current_time
        l1.put()

        messages_generator = sendMessagesGenerator(Twitter, logging)
        m_list = []
        while True:
            try:
                message = messages_generator.next()
            except StopIteration:
                break
            m_list.append(message)

        q = Question.all().fetch(1)[0]

        # Question for word d1 was genereated and sent
        # Now user prepares an answer
        answer = "lucrative: moneymaking, profitable"
        m = Twitter.api.PostUpdate(answer, in_reply_to_s_id=q.question_message_id)
        parsed_dict = parseMessage(m.text)
        q2 = checkForAnswer(parsed_dict, u.twitter)
        self.assertEqual(q.key(), q2.key())
Esempio n. 5
0
    def testAnswersIntegration(self):
        # I should collapse this code into something reusable

        # This is a big integration test for question/answers
        # Idea is that there are two answers: good and bad
        # Need to check if messages are being properly rescheduled and send

        Twitter = TwitterMockup()
        today = datetime.date.today()
        current_time = int(time.time())
        
        u = self.createUser("da_zbur","enabled",10)
        u.use_questions = "yes"
        u.put()

        d1 = self.createDictEntry("da_zbur",2,"lucrative",\
            u"profitable, moneymaking, remunerative","[LOO-kruh-tiv]")
        d2 = self.createDictEntry("da_zbur",2,"ferociously(en)",\
            u"жестоко, яростно, свирепо, дико, неистово. Ужасно, невыносимо.")
        d3 = self.createDictEntry("da_zbur",2,"confounder",\
            u"искажающий результаты фактор")

        l1 = self.createLearnListItem("da_zbur",d1,today,current_time)
        l2 = self.createLearnListItem("da_zbur",d2,today,current_time)        
        l3 = self.createLearnListItem("da_zbur",d3,today,current_time)

        # forcing question to be asked        
        l1.total_served = 4
        l2.total_served = 6
        l3.total_served = 8
        l1.interval_days = 3.2
        l1.efactor = 1.3
        l2.interval_days = 7.4
        l2.efactor = 0.98
        l3.interval_days = 17.4
        l3.efactor = 1.98
        l1.put()
        l2.put()
        l3.put()
       
        buildDailyList(today, logging)
        # Keep in mind building daily list means serve times will be 
        # randomly distributed throighout the day!
        l1.next_serve_time = current_time
        l2.next_serve_time = current_time
        l3.next_serve_time = current_time

        l2.put()
        l1.put()
        l3.put()

        messages_generator = sendMessagesGenerator(Twitter, logging)
        m_list = []
        while True:
            try:
                message = messages_generator.next()
            except StopIteration:
                break
            m_list.append(message)
       
        q1 = Question.all().fetch(3)[0]
        q2 = Question.all().fetch(3)[1]
        q3 = Question.all().fetch(3)[2]


        # This is a good answer
        a1 = "lucrative: moneymaking, profitable"
        # This is crappy answer
        a2 = u"ferociously(en): ---"
        # This is multiword answer
        a3 = u"Confounder: искажающий результаты фактор"
        m1 = Twitter.api.PostDirectMessage("LangBotStage", a1, "da_zbur")
        m2 = Twitter.api.PostDirectMessage("LangBotStage", a2, "da_zbur")
        m3 = Twitter.api.PostDirectMessage("LangBotStage", a3, "da_zbur")
        processMessage(m1)
        processMessage(m2)
        processMessage(m3)

        q1 = Question.all().fetch(3)[0]
        q2 = Question.all().fetch(3)[1]
        q3 = Question.all().fetch(3)[2]

        # For good question
        self.assertEqual(today, q1.answer_received)
        self.assertEqual(6, q1.answer_rating)
        self.assertEqual(6, q1.lli_ref.latest_answer_rating)
        self.assertEqual(sys.maxint, q1.lli_ref.next_serve_time)
        self.assertEqual(1.6, q1.lli_ref.efactor)
        self.assertEqual(3.2*1.3, q1.lli_ref.interval_days)
        self.assertEqual("moneymaking, profitable", q1.answer_text)

        # For bad question
        self.assertEqual(today, q2.answer_received)
        self.assertEqual(-2, q2.answer_rating)
        self.assertEqual(-2, q2.lli_ref.latest_answer_rating)
        self.assertEqual(0, q2.lli_ref.next_serve_time)
        self.assertEqual(today, q2.lli_ref.next_serve_date)
        self.assertEqual("---", q2.answer_text)

        # For multiword answer
        self.assertEqual(today, q3.answer_received)
        self.assertEqual(2, q3.answer_rating)
        self.assertEqual(2, q3.lli_ref.latest_answer_rating)
        self.assertEqual(sys.maxint, q3.lli_ref.next_serve_time)
        self.assertEqual(u"искажающий результаты фактор", q3.answer_text)

        # Check total user points, assuming he had 0
        self.assertEqual(6
            , User.all().filter("twitter =","da_zbur").\
            get().total_points)
Esempio n. 6
0
    def testBuildDailyList(self):
        # Prepare 4 users: 3 active one disabled, one with 
        # limit of messages per day
        self.createUser("ny_blin","enabled",10)
        u = self.createUser("da_zbur","enabled",10)
        # Change timezone for da_zbur
        u.utc_offset = -5
        u.put()

        self.createUser("mr_qizz","disabled",10)
        self.createUser("mr_2_per_day","enabled",2)

        d1 = self.createDictEntry("ny_blin",1,"cat",u"котик")
        d2 = self.createDictEntry("da_zbur",2,"dog",u"собачка")
        d3 = self.createDictEntry("da_zbur",3,"heron",u"цапля")
        d4 = self.createDictEntry("mr_qizz",4,"raccoon",u"енотик")

        today = datetime.date.today()
        tomorrow = today + datetime.timedelta(days=1)
        current_timestamp = int(time.time())

        self.createLearnListItem("ny_blin",d1,today)
        self.createLearnListItem("da_zbur",d2,today)
        self.createLearnListItem("da_zbur",d3,today)
        self.createLearnListItem("da_zbur",d4,tomorrow)
        self.createLearnListItem("mr_qizz",d4,today)
        self.createLearnListItem("mr_2_per_day",d1,today)
        self.createLearnListItem("mr_2_per_day",d2,today)
        self.createLearnListItem("mr_2_per_day",d3,today)
        self.createLearnListItem("mr_2_per_day",d4,today)
        
        buildDailyList(today, logging)
        dailyList = []
        for i in  LearnList.all().filter("next_serve_date =",today).run():
            dailyList.append(i)
        self.assertEqual(6, len(dailyList))
        
        self.assertEqual("ny_blin", dailyList[0].twitter_user)
        self.assertEqual(d1.key(), dailyList[0].dict_entry.key())
        self.assertNotEqual(0, dailyList[0].next_serve_time)
        self.assertTrue(current_timestamp < dailyList[0].next_serve_time)
        
        self.assertEqual("da_zbur", dailyList[1].twitter_user)
        self.assertEqual(d2.key(), dailyList[1].dict_entry.key())
        self.assertNotEqual(0, dailyList[1].next_serve_time)

        self.assertEqual("da_zbur", dailyList[2].twitter_user)
        self.assertEqual(d3.key(), dailyList[2].dict_entry.key())
        self.assertNotEqual(0, dailyList[2].next_serve_time)

        self.assertEqual("mr_qizz", dailyList[3].twitter_user)
        self.assertEqual(0, dailyList[3].next_serve_time)
        
        self.assertEqual("mr_2_per_day", dailyList[4].twitter_user)
        self.assertEqual(d1.key(), dailyList[4].dict_entry.key())
        self.assertNotEqual(0, dailyList[4].next_serve_time)

        self.assertEqual("mr_2_per_day", dailyList[5].twitter_user)
        self.assertEqual(d2.key(), dailyList[5].dict_entry.key())
        self.assertNotEqual(0, dailyList[5].next_serve_time)

        # Now let's check if 2 messages for mr_2_per day got rescheduled 
        # for tomorrow. Plus there is a message for da_zbur scheduled for
        # tomorrow as well
        buildDailyList(tomorrow, logging)
        dailyList = []
        for i in  LearnList.all().filter("next_serve_date =",tomorrow).run():
            dailyList.append(i)
        self.assertEqual(3, len(dailyList))

        self.assertEqual("da_zbur", dailyList[0].twitter_user)
        self.assertEqual(d4.key(), dailyList[0].dict_entry.key())
        self.assertNotEqual(0, dailyList[0].next_serve_time)
        

        self.assertEqual("mr_2_per_day", dailyList[1].twitter_user)
        self.assertEqual(d3.key(), dailyList[1].dict_entry.key())
        self.assertNotEqual(0, dailyList[1].next_serve_time)

        self.assertEqual("mr_2_per_day", dailyList[2].twitter_user)
        self.assertEqual(d4.key(), dailyList[2].dict_entry.key())
        self.assertNotEqual(0, dailyList[2].next_serve_time)

        # Finally let's check that building tomorrow's list didn't screw up
        # the today's list        
        dailyList = []
        for i in  LearnList.all().filter("next_serve_date =",today).run():
            dailyList.append(i)
        self.assertEqual(6, len(dailyList))