def test_purge_tasks_with_queue_names_provided(self, ctime): """When a list of queue_names is provided, ensure purge_tasks() clears the tasks and none are left to execute. Ensure the number of tasks cleared is correct. """ from furious.async import Async from furious.batcher import Message from furious.test_stubs.appengine.queues import run as run_queues from furious.test_stubs.appengine.queues import purge_tasks # Enqueue a couple of tasks async = Async(target='time.ctime') async.start() async2 = Async(target='time.ctime') async2.start() Message(queue='default-pull').insert() num_cleared = purge_tasks(self.taskqueue_service, ['default']) # Run the tasks to check if tasks remain run_queues(self.taskqueue_service) # Ensure two tasks from the default queue were cleared. self.assertEqual(2, num_cleared) # Ensure no tasks were run self.assertEqual(0, ctime.call_count)
def test_purge_tasks_with_string_passed_to_queue_names(self, ctime): """If a single queue_name is passed to purge_tasks() instead of a list, ensure that the queue specified is still cleared. Ensure the number of tasks cleared is correct. """ from furious.async import Async from furious.batcher import Message from furious.test_stubs.appengine.queues import run as run_queues from furious.test_stubs.appengine.queues import purge_tasks # Enqueue a couple of tasks async = Async(target='time.ctime') async.start() async2 = Async(target='time.ctime') async2.start() # Insert a pull task Message(queue='default-pull').insert() num_cleared = purge_tasks(self.taskqueue_service, 'default') # Run the tasks to check if tasks remain run_queues(self.taskqueue_service) # Ensure two tasks from the default queue were cleared. self.assertEqual(2, num_cleared) # Ensure no tasks were run self.assertEqual(0, ctime.call_count)
def test_purge_tasks_with_queue_names_provided(self, ctime): """When a list of queue_names is provided, ensure purge_tasks() clears the tasks and none are left to execute. Ensure the number of tasks cleared is correct. """ from furious.async import Async from furious.batcher import Message from furious.test_stubs.appengine.queues import run as run_queues from furious.test_stubs.appengine.queues import purge_tasks # Enqueue a couple of tasks async = Async(target='time.ctime') async.start() async2 = Async(target='time.ctime') async2.start() Message(queue='default-pull').insert() num_cleared = purge_tasks(self.taskqueue_service, ['default']) # Run the tasks to check if tasks remain run_queues(self.taskqueue_service) # Ensure two tasks from the default queue were cleared. self.assertEqual(2, num_cleared) # Ensure no tasks were run self.assertEqual(0, ctime.call_count)
def test_purge_tasks_with_tasks(self, ctime): """After queues are run, ensure no tasks are left to execute. Ensure the number of tasks cleared is correct. """ from furious.async import Async from furious.batcher import Message from furious.test_stubs.appengine.queues import run as run_queues from furious.test_stubs.appengine.queues import purge_tasks # Enqueue a couple of tasks async = Async(target='time.ctime') async.start() async2 = Async(target='time.ctime') async2.start() Message(queue='default-pull').insert() num_cleared = purge_tasks(self.taskqueue_service) # Run the tasks to check if tasks remain run_queues(self.taskqueue_service) # Ensure three tasks were cleared, from 'default' and 'default-pull'. self.assertEqual(3, num_cleared) # Ensure no tasks were run self.assertEqual(0, ctime.call_count)
def test_purge_tasks_with_string_passed_to_queue_names(self, ctime): """If a single queue_name is passed to purge_tasks() instead of a list, ensure that the queue specified is still cleared. Ensure the number of tasks cleared is correct. """ from furious.async import Async from furious.batcher import Message from furious.test_stubs.appengine.queues import run as run_queues from furious.test_stubs.appengine.queues import purge_tasks # Enqueue a couple of tasks async = Async(target='time.ctime') async.start() async2 = Async(target='time.ctime') async2.start() # Insert a pull task Message(queue='default-pull').insert() num_cleared = purge_tasks(self.taskqueue_service, 'default') # Run the tasks to check if tasks remain run_queues(self.taskqueue_service) # Ensure two tasks from the default queue were cleared. self.assertEqual(2, num_cleared) # Ensure no tasks were run self.assertEqual(0, ctime.call_count)
def test_purge_tasks_with_tasks(self, ctime): """After queues are run, ensure no tasks are left to execute. Ensure the number of tasks cleared is correct. """ from furious.async import Async from furious.batcher import Message from furious.test_stubs.appengine.queues import run as run_queues from furious.test_stubs.appengine.queues import purge_tasks # Enqueue a couple of tasks async = Async(target='time.ctime') async.start() async2 = Async(target='time.ctime') async2.start() Message(queue='default-pull').insert() num_cleared = purge_tasks(self.taskqueue_service) # Run the tasks to check if tasks remain run_queues(self.taskqueue_service) # Ensure three tasks were cleared, from 'default' and 'default-pull'. self.assertEqual(3, num_cleared) # Ensure no tasks were run self.assertEqual(0, ctime.call_count)
def test_run(self, ctime): """Ensure tasks are run when run_queues is called.""" from furious.async import Async from furious.test_stubs.appengine.queues import run as run_queues # Enqueue a couple of tasks async = Async(target='time.ctime') async.start() async2 = Async(target='time.ctime') async2.start() # Run the tasks in the queue run_queues(self.taskqueue_service) self.assertEqual(2, ctime.call_count)
def test_run(self, ctime): """Ensure tasks are run when run_queues is called.""" from furious.async import Async from furious.test_stubs.appengine.queues import run as run_queues # Enqueue a couple of tasks async = Async(target='time.ctime') async.start() async2 = Async(target='time.ctime') async2.start() # Run the tasks in the queue run_queues(self.taskqueue_service) self.assertEqual(2, ctime.call_count)
def test_happy_path(self, mock_verify_origin, mock_request, mock_get_commit): """Ensure process_github_push creates Commit and CommitHunk entities. """ from kaput.repository import Commit from kaput.repository import CommitHunk mock_verify_origin.return_value = True mock_request.data = self.push_payload mock_get_commit.return_value = self.commit repo = Repository(id='github_16896925', name='webhook-test', description='webhook test', owner=self.user.key, enabled=True) repo.put() commit = Commit.get_by_id(self.commit.sha, parent=repo.key) self.assertIsNone(commit) controller.process_github_push() run_queues(self.queue_service) commit = Commit.get_by_id(self.commit.sha, parent=repo.key) self.assertEqual(repo.key, commit.key.parent()) self.assertIsNone(commit.author) self.assertEqual('Tyler Treat', commit.author_name) self.assertEqual('*****@*****.**', commit.author_email) self.assertEqual(datetime(2014, 5, 26, 5, 12, 9), commit.author_date) self.assertIsNone(commit.committer) self.assertEqual('Tyler Treat', commit.committer_name) self.assertEqual('*****@*****.**', commit.committer_email) self.assertEqual(datetime(2014, 5, 26, 5, 12, 9), commit.committer_date) self.assertEqual('Delete another newline', commit.message) hunks = CommitHunk.query(ancestor=commit.key).fetch() self.assertEqual(1, len(hunks)) hunk = hunks[0] self.assertEqual(commit.key, hunk.key.parent()) self.assertEqual(commit.key, hunk.commit) self.assertEqual('main.py', hunk.filename) self.assertEqual([35, 36, 37], hunk.lines) self.assertEqual(datetime(2014, 5, 26, 5, 12, 9), hunk.timestamp)
def test_add_async_and_message_tasks(self, ctime): """Ensure taskqueue.Task() instances from furious Asyncs and Messages can be added. """ from google.appengine.api import taskqueue from furious. async import Async from furious.batcher import Message from furious.test_stubs.appengine.queues import add_tasks from furious.test_stubs.appengine.queues import run as run_queues # Create asyncs async = Async(target='time.ctime') async2 = Async(target='time.ctime') # Create a message options = {'task_args': {'payload': 'abcdefg'}} message = Message(payload='abc', **options) message_task = message.to_task() task_dict = { 'default': [async .to_task(), async2.to_task()], 'default-pull': [message_task] } num_added = add_tasks(self.queue_service, task_dict) # Ensure three tasks were added. self.assertEqual(3, num_added) # Run the tasks to make sure they were inserted correctly. run_queues(self.queue_service) # Ensure both push queue tasks were executed. self.assertEqual(2, ctime.call_count) # Lease the pull queue task and make sure it has the correct payload. tasks = taskqueue.Queue('default-pull').lease_tasks(3600, 100) returned_task_message = tasks[0] # Ensure pull queue task payload is the same as the original. self.assertEqual(returned_task_message.payload, message_task.payload)
def test_add_async_and_message_tasks(self, ctime): """Ensure taskqueue.Task() instances from furious Asyncs and Messages can be added. """ from google.appengine.api import taskqueue from furious.async import Async from furious.batcher import Message from furious.test_stubs.appengine.queues import add_tasks from furious.test_stubs.appengine.queues import run as run_queues # Create asyncs async = Async(target='time.ctime') async2 = Async(target='time.ctime') # Create a message options = {'task_args': {'payload': 'abcdefg'}} message = Message(payload='abc', **options) message_task = message.to_task() task_dict = {'default': [async.to_task(), async2.to_task()], 'default-pull': [message_task]} num_added = add_tasks(self.queue_service, task_dict) # Ensure three tasks were added. self.assertEqual(3, num_added) # Run the tasks to make sure they were inserted correctly. run_queues(self.queue_service) # Ensure both push queue tasks were executed. self.assertEqual(2, ctime.call_count) # Lease the pull queue task and make sure it has the correct payload. tasks = taskqueue.Queue('default-pull').lease_tasks(3600, 100) returned_task_message = tasks[0] # Ensure pull queue task payload is the same as the original. self.assertEqual(returned_task_message.payload, message_task.payload)
def test_run_with_retries(self, ctime): """ Ensure tasks are retries when they raise an exception. Ensure 10 retries are made - 11 total calls. """ from furious. async import Async from furious.test_stubs.appengine.queues import run as run_queues # Count the task runs. global call_count call_count = 0 def task_call(): """The function our task will call.""" num_retries = int( os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT')) global call_count # Ensure the num_retries env var is incremented each time. self.assertEqual(num_retries, call_count) call_count += 1 # Raise an Exception to retry until max retries are reached. raise Exception() ctime.side_effect = task_call # Enqueue our task that will fail. async = Async(target='time.ctime') async .start() # Run the tasks in the queue run_queues(self.taskqueue_service, enable_retries=True) # By default app engine will run the task 11 times. 10 retries # after the # initial run. self.assertEqual(11, call_count)
def test_run_with_retries(self, ctime): """ Ensure tasks are retries when they raise an exception. Ensure 10 retries are made - 11 total calls. """ from furious.async import Async from furious.test_stubs.appengine.queues import run as run_queues # Count the task runs. global call_count call_count = 0 def task_call(): """The function our task will call.""" num_retries = int(os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT')) global call_count # Ensure the num_retries env var is incremented each time. self.assertEqual(num_retries, call_count) call_count += 1 # Raise an Exception to retry until max retries are reached. raise Exception() ctime.side_effect = task_call # Enqueue our task that will fail. async = Async(target='time.ctime') async.start() # Run the tasks in the queue run_queues(self.taskqueue_service, enable_retries=True) # By default app engine will run the task 11 times. 10 retries # after the # initial run. self.assertEqual(11, call_count)
def test_run_with_retries_and_retries_reset(self, accept2dyear, asctime, ctime): """ Ensure tasks retry counts are separate between asyncs. Ensure tasks retry counts are reset once an Async is successful. """ from furious.async import Async from furious.test_stubs.appengine.queues import run as run_queues # Count the task runs. self.async1_call_count = 0 self.async2_call_count = 0 self.async3_call_count = 0 self.async1_retries_env = 0 self.async2_retries_env = 0 self.async3_retries_env = 0 def task_call_task1(): """The function task1 will call.""" int(os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT')) self.async1_call_count += 1 if self.async1_call_count < 2: # Fail once. raise Exception() self.async1_retries_env = int( os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT')) def task_call_task3(): """The function task3 will call.""" self.async3_call_count += 1 self.async3_retries_env = int( os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT')) def task_call_task2(): """The function task2 will call.""" self.async2_call_count += 1 if self.async2_call_count < 3: # Fail twice. raise Exception() self.async2_retries_env = int( os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT')) async3 = Async(target='time.accept2dyear') async3.start() ctime.side_effect = task_call_task1 asctime.side_effect = task_call_task2 accept2dyear.side_effect = task_call_task3 # Enqueue our task that will fail. async1 = Async(target='time.ctime') async1.start() async2 = Async(target='time.asctime') async2.start() # Run the tasks in the queue run_queues(self.taskqueue_service, enable_retries=True) self.assertEqual(self.async1_call_count, 2) self.assertEqual(self.async2_call_count, 3) self.assertEqual(self.async3_call_count, 1) self.assertEqual(self.async1_retries_env, 1) self.assertEqual(self.async2_retries_env, 2) self.assertEqual(self.async3_retries_env, 0) # Clear del self.async1_call_count del self.async2_call_count del self.async3_call_count del self.async1_retries_env del self.async2_retries_env del self.async3_retries_env
def test_run_with_retries_and_retries_reset(self, accept2dyear, asctime, ctime): """ Ensure tasks retry counts are separate between asyncs. Ensure tasks retry counts are reset once an Async is successful. """ from furious. async import Async from furious.test_stubs.appengine.queues import run as run_queues # Count the task runs. self.async1_call_count = 0 self.async2_call_count = 0 self.async3_call_count = 0 self.async1_retries_env = 0 self.async2_retries_env = 0 self.async3_retries_env = 0 def task_call_task1(): """The function task1 will call.""" int(os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT')) self.async1_call_count += 1 if self.async1_call_count < 2: # Fail once. raise Exception() self.async1_retries_env = int( os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT')) def task_call_task3(): """The function task3 will call.""" self.async3_call_count += 1 self.async3_retries_env = int( os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT')) def task_call_task2(): """The function task2 will call.""" self.async2_call_count += 1 if self.async2_call_count < 3: # Fail twice. raise Exception() self.async2_retries_env = int( os.environ.get('HTTP_X_APPENGINE_TASKRETRYCOUNT')) async3 = Async(target='time.accept2dyear') async3.start() ctime.side_effect = task_call_task1 asctime.side_effect = task_call_task2 accept2dyear.side_effect = task_call_task3 # Enqueue our task that will fail. async1 = Async(target='time.ctime') async1.start() async2 = Async(target='time.asctime') async2.start() # Run the tasks in the queue run_queues(self.taskqueue_service, enable_retries=True) self.assertEqual(self.async1_call_count, 2) self.assertEqual(self.async2_call_count, 3) self.assertEqual(self.async3_call_count, 1) self.assertEqual(self.async1_retries_env, 1) self.assertEqual(self.async2_retries_env, 2) self.assertEqual(self.async3_retries_env, 0) # Clear del self.async1_call_count del self.async2_call_count del self.async3_call_count del self.async1_retries_env del self.async2_retries_env del self.async3_retries_env
def test_happy_path(self, mock_verify_origin, mock_request): """Ensure that process_github_release creates a Release entity and correctly tags Commits. """ from kaput.repository import Commit from kaput.repository import Release mock_verify_origin.return_value = True mock_request.data = self.release_payload repo = Repository(id='github_16896925', name='webhook-test', description='webhook test', owner=self.user.key, enabled=True) repo.put() old_release = Release(id='github_123', parent=repo.key, tag_name='v0.0.1', name='release', url='url', description='description', prerelease=False, created=datetime.utcnow(), published=datetime.utcnow()) old_release.put() tagged_commit = Commit(id='abc', parent=repo.key, author_name='Tyler Treat', author_email='*****@*****.**', author_date=datetime.utcnow(), committer_name='Tyler Treat', committer_email='*****@*****.**', committer_date=datetime.utcnow(), release=old_release.key) tagged_commit.put() untagged_commit = Commit(id='def', parent=repo.key, author_name='Tyler Treat', author_email='*****@*****.**', author_date=datetime.utcnow(), committer_name='Tyler Treat', committer_email='*****@*****.**', committer_date=datetime.utcnow()) untagged_commit.put() controller.process_github_release() run_queues(self.queue_service) release = Release.get_by_id('github_339538', parent=repo.key) self.assertEqual(repo.key, release.key.parent()) self.assertEqual('github_339538', release.key.id()) self.assertEqual('v0.0.4', release.tag_name) self.assertEqual('Another Test Release', release.name) self.assertEqual('Testing 123', release.description) self.assertFalse(release.prerelease) self.assertEqual(datetime(2014, 5, 26, 5, 12, 9), release.created) self.assertEqual(datetime(2014, 5, 26, 5, 14, 46), release.published) self.assertEqual( 'https://github.com/tylertreat/webhook-test/releases/tag/v0.0.4', release.url ) commits = Commit.query().fetch() self.assertEqual(2, len(commits)) self.assertEqual(old_release.key, commits[0].release) self.assertEqual(release.key, commits[1].release)