def test_insertList():
	##Tests to see if multiple Statements can be inserted
	tc = TinCan(USER_NAME,PASSWORD,ENDPOINT)
	statement1Id= str(uuid.uuid1())
	statement2Id= str(uuid.uuid1())
	email1 = 'mailto:[email protected]'
	email2 = 'mailto:[email protected]'
	email3 = 'mailto:[email protected]'
	x={'mbox':[email1]}
	y={'mbox':[email2,email3]}

	now = datetime.datetime.now()
	##Builds statement list
	statementList =	[{
						"id": statement1Id,
						'actor':{'name':['List Test1'],'mbox':[email1]},
						'verb':'passed',
						'object':{'id':str(uuid.uuid1()),'definition':{'name':{"en-US":'you'},'description':{"en-US":'Testing list insertions[1] of statements.'}}}
					},
					{
						"id": statement2Id,
						'actor':{'name':['List Test2'],'mbox':[email2, email3]},
						'verb':'failed',
						'object':{'id':str(uuid.uuid1()),'definition':{'name':{"en-US":'you'},'description':{"en-US":'Testing list insertions[1] of statements.'}}}
					}]
	tc.submitStatementList(statementList)
	time.sleep(10)
	## Fetches previously entered statements
	state1 = tc.getStatementbyID(statement1Id)
	state2 = tc.getStatementbyID(statement2Id)
	##Checks to see if the IDs are the same from inserted and retrieved
	assert state1['id'] == statement1Id
	assert state2['id'] == statement2Id 
def testComplexFilter():
	##Ensures a complex filter returns correct data
	tc = TinCan(USER_NAME,PASSWORD,ENDPOINT)
	whoDid = "Complex Test"
	statement_ID = str(uuid.uuid1())
	whoDidEmail = "*****@*****.**"
	whoDidObject = 'Test Subject'
	didWhat = 'attempted'
	now = datetime.datetime.now()
	x={'mbox':['mailto:'+whoDidEmail]}
	##Inserts object to filter for
	createdJsonObject = {
					'id': statement_ID,
					'actor':{'name':[whoDid],'mbox':['mailto:'+whoDidEmail]},
					'verb':didWhat,
					'object':{'id':str(uuid.uuid1()),'definition':{'name':{"en-US":'with '+whoDidObject},'description':{"en-US":'Inserting a description for a complex filter.'}}}	
				}
	##Inserts statement
	tc.submitStatement(createdJsonObject)
	time.sleep(8)
	results = tc.getFilteredStatements(_verb=didWhat,_actor=x,_limit=1,_sparse=True,_since=str(now))
	for result in results['statements']:
		if result['verb']==didWhat:
			for x in result['actor']['mbox']:
				assert (x == 'mailto:'+whoDidEmail.lower())
def test_filter_statements():
	##Ensures a simple filter request returns the correct information
	tc = TinCan(USER_NAME,PASSWORD,ENDPOINT)
	test_verb = 'created'
	email = '*****@*****.**'
	x={'mbox':['mailto:'+email]}
	results = tc.getFilteredStatements(_actor=x,_limit=5, _sparse=True)
	
	for result in results['statements']:
		for emails in result['actor']['mbox']: 
			if (emails=='mailto:'+email.lower()) :
				assert True
示例#4
0
    def get_for_video_and_user_data(video, user_data, insert_if_missing=False):
        if not user_data:
            return None

        key = UserVideo.get_key_name(video, user_data)
        user_video = UserVideo.get_by_key_name(key)

        if user_video: 
            return user_video
        elif insert_if_missing:
            TinCan.create_media(user_data, "launched", video)
            return UserVideo.get_or_insert(
                        key_name=key,
                        user=user_data.user,
                        video=video,
                        duration=video.duration)
        else:
            return None
def test_submit_statement():
	##Tests to see if a single statement can be inserted
	tc = TinCan(USER_NAME,PASSWORD,ENDPOINT)
	statement_ID = str(uuid.uuid1())
	whoDid = "I"
	whoDidEmail = "*****@*****.**"
	whoDidObject = 'you'
	didWhat = 'created'
	##Build the Tin Can statement
	createdJsonObject ={
					"id": statement_ID,
					'actor':{'name':[whoDid],'mbox':['mailto:'+whoDidEmail]},
					'verb':didWhat,
					'object':{'id':str(uuid.uuid1()),'definition':{'name':{"en-US":whoDidObject},'description':{"en-US":'Testing single insertion of a statement.'}}}

				}
	tc.submitStatement(createdJsonObject)
	##Sleeps to insure the statement is inserted
	time.sleep(10)
	##Gets the statement by the ID used when inserted
	testStatement = tc.getStatementbyID(statement_ID)
	##Ensures the ID when inserted and the ID on the retrieve are the same
	assert (testStatement['id'] == statement_ID)
def test_GetAllStatements():
	tc = TinCan(USER_NAME,PASSWORD,ENDPOINT)
	statementlist = tc.getAllStatements()
	print statementlist
	for x in statementlist['statements']:
		assert 'id' in x
示例#7
0
    def add_entry(user_data, video, seconds_watched, last_second_watched, detect_cheat=True):

        # TODO(csilvers): get rid of circular dependency here
        import badges.last_action_cache
        user_video = UserVideo.get_for_video_and_user_data(video, user_data, insert_if_missing=True)

        # Cap seconds_watched at duration of video
        seconds_watched = max(0, min(seconds_watched, video.duration))

        video_points_previous = points.VideoPointCalculator(user_video)

        action_cache = badges.last_action_cache.LastActionCache.get_for_user_data(user_data)

        last_video_log = action_cache.get_last_video_log()

        # If the last video logged is not this video and the times being credited
        # overlap, don't give points for this video. Can only get points for one video
        # at a time.
        if (detect_cheat and
                last_video_log and
                last_video_log.key_for_video() != video.key()):
            dt_now = datetime.datetime.now()
            other_video_time = last_video_log.time_watched
            this_video_time = dt_now - datetime.timedelta(seconds=seconds_watched)
            if other_video_time > this_video_time:
                logging.warning("Detected overlapping video logs " +
                                "(user may be watching multiple videos?)")
                return (None, None, 0, False)

        video_log = VideoLog()
        video_log.user = user_data.user
        video_log.video = video
        video_log.video_title = video.title
        video_log.youtube_id = video.youtube_id
        video_log.seconds_watched = seconds_watched
        video_log.last_second_watched = last_second_watched

        if seconds_watched > 0:
            # TODO(csilvers): get rid of circular dependencies here
            import badges.util_badges
            import topic_models

            if user_video.seconds_watched == 0:
                gae_bingo.gae_bingo.bingo([
                    "video_started_binary", # Core metric
                    "video_started_count",]) # Core metric

                user_data.uservideocss_version += 1
                UserVideoCss.set_started(user_data, user_video.video, user_data.uservideocss_version)

            user_video.seconds_watched += seconds_watched
            user_data.total_seconds_watched += seconds_watched

            # Update seconds_watched of all associated topics
            video_topics = db.get(video.topic_string_keys)

            first_topic = True
            for topic in video_topics:
                user_topic = topic_models.UserTopic.get_for_topic_and_user_data(topic, user_data, insert_if_missing=True)
                user_topic.title = topic.standalone_title
                user_topic.seconds_watched += seconds_watched
                user_topic.last_watched = datetime.datetime.now()
                user_topic.put()

                video_log.playlist_titles.append(user_topic.title)

                if first_topic:
                    action_cache.push_video_log(video_log)

                badges.util_badges.update_with_user_topic(
                        user_data,
                        user_topic,
                        include_other_badges=first_topic,
                        action_cache=action_cache)

                first_topic = False

        user_video.last_second_watched = last_second_watched
        user_video.last_watched = datetime.datetime.now()
        user_video.duration = video.duration

        user_data.record_activity(user_video.last_watched)

        video_points_total = points.VideoPointCalculator(user_video)
        video_points_received = video_points_total - video_points_previous

        just_finished_video = False
        if not user_video.completed and video_points_total >= consts.VIDEO_POINTS_BASE:
            just_finished_video = True
            user_video.completed = True
            user_data.videos_completed = -1
            TinCan.create_media(user_data, "completed", video, user_video)

            user_data.uservideocss_version += 1
            UserVideoCss.set_completed(user_data, user_video.video, user_data.uservideocss_version)

            gae_bingo.gae_bingo.bingo([
                'struggling_videos_finished',
                'video_completed_binary', # Core metric
                'video_completed_count' # Core metric
                ])

        video_log.is_video_completed = user_video.completed

        goals_updated = goals.models.GoalList.update_goals(user_data,
            lambda goal: goal.just_watched_video(user_data, user_video, just_finished_video))

        if video_points_received > 0:
            video_log.points_earned = video_points_received
            user_data.add_points(video_points_received)
            TinCan.create_media(user_data, "progressed", video, user_video)

        db.put([user_video, user_data])

        # Defer the put of VideoLog for now, as we think it might be causing hot tablets
        # and want to shift it off to an automatically-retrying task queue.
        # http://ikaisays.com/2011/01/25/app-engine-datastore-tip-monotonically-increasing-values-are-bad/
        deferred.defer(_commit_video_log, video_log,
                       _queue="video-log-queue",
                       _url="/_ah/queue/deferred_videolog")


        if user_data is not None and user_data.coaches:
            # Making a separate queue for the log summaries so we can clearly see how much they are getting used
            deferred.defer(commit_log_summary_coaches, video_log, user_data.coaches,
                _queue="log-summary-queue",
                _url="/_ah/queue/deferred_log_summary")

        return (user_video, video_log, video_points_total, goals_updated)