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)
