本文整理汇总了Python中redis.StrictRedis.flushall方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.flushall方法的具体用法?Python StrictRedis.flushall怎么用?Python StrictRedis.flushall使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.flushall方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: TestProjectsStats
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
class TestProjectsStats(Test):
def setUp(self):
super(TestProjectsStats, self).setUp()
self.connection = StrictRedis()
self.connection.flushall()
self.scheduler = Scheduler('test_queue', connection=self.connection)
@with_context
def test_create_dict_job(self):
"""Test JOB create dict job works."""
user = UserFactory.create(pro=True)
app = AppFactory.create(owner=user)
from sqlalchemy.sql import text
from pybossa.core import db
sql = text('''SELECT app.id, app.short_name FROM app, "user"
WHERE app.owner_id="user".id AND "user".pro=True;''')
results = db.slave_session.execute(sql)
jobs = create_dict_jobs(results, get_app_stats, (10 * 60))
err_msg = "There should be only one job"
assert len(jobs) == 1, err_msg
job = jobs[0]
assert 'get_app_stats' in job['name'].__name__
assert job['args'] == [app.id, app.short_name]
assert job['interval'] == 10 * 60
@with_context
def test_get_project_jobs(self):
"""Test JOB get project jobs works."""
user = UserFactory.create(pro=True)
app = AppFactory.create(owner=user)
jobs = get_project_jobs()
err_msg = "There should be only one job"
assert len(jobs) == 1, err_msg
job = jobs[0]
err_msg = "There should have the same name, but it's: %s" % job['name']
assert "get_app_stats" == job['name'].__name__, err_msg
err_msg = "There should have the same args, but it's: %s" % job['args']
assert [app.id, app.short_name] == job['args'], err_msg
err_msg = "There should have the same kwargs, but it's: %s" % job['kwargs']
assert {} == job['kwargs'], err_msg
@with_context
def test_get_project_jobs_for_non_pro_users(self):
"""Test JOB get project jobs works for non pro users."""
AppFactory.create()
jobs = get_project_jobs()
err_msg = "There should be only 0 jobs"
assert len(jobs) == 0, err_msg
示例2: TestSetupScheduledJobs
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
class TestSetupScheduledJobs(object):
"""Tests for setup function '_schedule_job'"""
def setUp(self):
self.connection = StrictRedis()
self.connection.flushall()
self.scheduler = Scheduler('test_queue', connection=self.connection)
def test_adds_scheduled_job_with_interval(self):
a_job['interval'] = 7
_schedule_job(a_job, self.scheduler)
sched_jobs = self.scheduler.get_jobs()
assert len(sched_jobs) == 1, sched_jobs
assert sched_jobs[0].meta['interval'] == 7 , sched_jobs[0].meta
a_job['interval'] = 1
def test_adds_several_jobs_(self):
_schedule_job(a_job, self.scheduler)
_schedule_job(another_job, self.scheduler)
sched_jobs = self.scheduler.get_jobs()
job_func_names = [job.func_name for job in sched_jobs]
module_name = 'test_jobs.test_schedule_jobs'
assert len(sched_jobs) == 2, sched_jobs
assert module_name + '.a_function' in job_func_names, job_func_names
assert module_name + '.another_function' in job_func_names, job_func_names
def test_does_not_add_job_if_already_added(self):
_schedule_job(a_job, self.scheduler)
_schedule_job(a_job, self.scheduler)
sched_jobs = self.scheduler.get_jobs()
assert len(sched_jobs) == 1, sched_jobs
def test_returns_log_messages(self):
success_message = _schedule_job(a_job, self.scheduler)
failure_message = _schedule_job(a_job, self.scheduler)
assert success_message == 'Scheduled a_function([], {}) to run every 1 seconds'
assert failure_message == 'WARNING: Job a_function([], {}) is already scheduled'
def test_failed_attempt_to_schedule_does_not_polute_redis(self):
_schedule_job(a_job, self.scheduler)
_schedule_job(a_job, self.scheduler)
stored_values = self.connection.keys('rq:job*')
assert len(stored_values) == 1, len(stored_values)
示例3: redis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
def redis():
try:
from redis import StrictRedis
from redis.exceptions import ConnectionError
except ImportError:
pytest.skip('redis library not installed')
try:
r = StrictRedis()
r.ping()
except ConnectionError:
pytest.skip('could not connect to redis')
r.flushall()
return r
示例4: TestNews
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
class TestNews(Test):
def setUp(self):
super(TestNews, self).setUp()
self.connection = StrictRedis()
self.connection.flushall()
news = dict(updated='2015-01-01')
@with_context
def test_get_news_empty(self):
news = get_news()
assert len(news) == 0, len(news)
@with_context
def test_get_news_with_score_empty(self):
news = get_news(score=1)
assert len(news) == 0, len(news)
@with_context
def test_get_news(self):
sentinel.master.zadd(myset, 0, pickle.dumps(self.news))
news = get_news()
assert len(news) == 1, len(news)
news[0]['updated'] == self.news['updated'], news
@with_context
def test_get_news_with_score(self):
sentinel.master.zadd(myset, 0, pickle.dumps(self.news))
news = get_news(score=1)
assert len(news) == 0, len(news)
@with_context
def test_notify_news_admins(self):
user = UserFactory.create(admin=True)
notify_news_admins()
key = "notify:admin:%s" % user.id
value = sentinel.slave.get(key)
err_msg = "Key should exist"
assert value == str(1), err_msg
@with_context
def test_notify_news_admins(self):
user = UserFactory.create(admin=False)
user2 = UserFactory.create(admin=False)
notify_news_admins()
key = "notify:admin:%s" % user2.id
value = sentinel.slave.get(key)
err_msg = "Key should not exist"
assert value is None, err_msg
示例5: TestTasksMarkedForContribution
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
class TestTasksMarkedForContribution(object):
def setUp(self):
self.connection = StrictRedis()
self.connection.flushall()
@patch('pybossa.api.get_user_id_or_ip')
def test_mark_task_as_requested_by_user_creates_key_for_auth(self, user):
"""When an authenticated user requests a task, a key is stored in Redis
with his id and task id"""
user.return_value = {'user_id': 33, 'user_ip': None}
task = Task(id=22)
key = 'pybossa:task_requested:user:33:task:22'
mark_task_as_requested_by_user(task, self.connection)
assert key in self.connection.keys(), self.connection.keys()
@patch('pybossa.api.get_user_id_or_ip')
def test_mark_task_as_requested_by_user_creates_key_for_anon(self, user):
"""When an anonymous user requests a task, a key is stored in Redis
with his IP and task id"""
user.return_value = {'user_id': None, 'user_ip': '127.0.0.1'}
task = Task(id=22)
key = 'pybossa:task_requested:user:127.0.0.1:task:22'
mark_task_as_requested_by_user(task, self.connection)
assert key in self.connection.keys(), self.connection.keys()
@patch('pybossa.api.get_user_id_or_ip')
def test_mark_task_as_requested_by_user_sets_expiration_for_key(self, user):
"""When a user requests a task, a key is stored with TTL of 1 hour"""
user.return_value = {'user_id': 33, 'user_ip': None}
task = Task(id=22)
key = 'pybossa:task_requested:user:33:task:22'
mark_task_as_requested_by_user(task, self.connection)
assert self.connection.ttl(key) == 60 * 60, self.connection.ttl(key)
示例6: TestOldProjects
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
class TestOldProjects(Test):
def setUp(self):
super(TestOldProjects, self).setUp()
self.connection = StrictRedis()
self.connection.flushall()
self.scheduler = Scheduler('test_queue', connection=self.connection)
@with_context
def test_get_non_updated_apps_returns_none(self):
"""Test JOB get non updated returns none."""
apps = get_non_updated_apps()
err_msg = "There should not be any outdated project."
assert len(apps) == 0, err_msg
@with_context
def test_get_non_updated_apps_returns_one_project(self):
"""Test JOB get non updated returns one project."""
app = AppFactory.create(updated='2010-10-22T11:02:00.000000')
apps = get_non_updated_apps()
err_msg = "There should be one outdated project."
assert len(apps) == 1, err_msg
assert apps[0].name == app.name, err_msg
@with_context
@patch('pybossa.core.mail')
def test_warn_project_owner(self, mail):
"""Test JOB email is sent to warn project owner."""
# Mock for the send method
send_mock = MagicMock()
send_mock.send.return_value = True
# Mock for the connection method
connection = MagicMock()
connection.__enter__.return_value = send_mock
# Join them
mail.connect.return_value = connection
date = '2010-10-22T11:02:00.000000'
app = AppFactory.create(updated=date)
app_id = app.id
warn_old_project_owners()
err_msg = "mail.connect() should be called"
assert mail.connect.called, err_msg
err_msg = "conn.send() should be called"
assert send_mock.send.called, err_msg
err_msg = "app.contacted field should be True"
assert app.contacted, err_msg
err_msg = "The update date should be different"
assert app.updated != date, err_msg
@with_context
def test_warn_project_owner_two(self):
"""Test JOB email is sent to warn project owner."""
from pybossa.core import mail
with mail.record_messages() as outbox:
date = '2010-10-22T11:02:00.000000'
app = AppFactory.create(updated=date)
app_id = app.id
warn_old_project_owners()
assert len(outbox) == 1, outbox
subject = 'Your PyBossa project: %s has been inactive' % app.name
assert outbox[0].subject == subject
err_msg = "app.contacted field should be True"
assert app.contacted, err_msg
err_msg = "The update date should be different"
assert app.updated != date, err_msg
@with_context
def test_warn_project_owner_limits(self):
"""Test JOB email gets at most 25 projects."""
from pybossa.core import mail
# Create 50 projects with old updated dates
date = '2010-10-22T11:02:00.000000'
apps = []
for i in range(0, 50):
apps.append(AppFactory.create(updated=date))
# The first day that we run the job only 25 emails should be sent
with mail.record_messages() as outbox:
warn_old_project_owners()
err_msg = "There should be only 25 emails."
assert len(outbox) == 25, err_msg
# The second day that we run the job only 25 emails should be sent
with mail.record_messages() as outbox:
warn_old_project_owners()
err_msg = ("There should be only 25 emails, but there are %s."
% len(outbox))
assert len(outbox) == 25, err_msg
# The third day that we run the job only 0 emails should be sent
# as the previous projects have been already contacted.
with mail.record_messages() as outbox:
warn_old_project_owners()
err_msg = "There should be only 0 emails."
assert len(outbox) == 0, err_msg
示例7: StrictRedis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
from redis import StrictRedis, WatchError
import os
import time
import random
import string
import json
from datetime import date
redis = StrictRedis(host=os.environ.get("REDIS_HOST", "localhost"),
port=os.environ.get("REDIS_PORT", 6379),
db=0)
redis.flushall()
olympic_stadium = {
'venue': "Olympic Stadium",
'capacity': 60000,
'events': ["Athletics", "Football"],
'geo': {'long': 139.76632, 'lat': 35.666754},
'transit': ["Toei Odeo Line", "Chuo Main Line"]
}
nippon_budokan = {
'venue': "Nippon Budokan",
'capacity': 12000,
'events': ["Judo", "Karate"],
'geo': {'long': 139.75, 'lat': 35.693333},
'transit':[ "Toei Shinjuku Line", "Tozai Line", "Hanzomon Line"]
}
makuhari_messe = {
'venue': "Makuhari Messe",
示例8: abort
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
if content is None:
abort(404)
resp = make_response(content, 200)
resp.headers['Content-Type'] = 'application/json'
resp.headers['X-Cache-Hit'] = cache_hit
resp.headers['X-Expire-TTL-Seconds'] = cache.ttl(id)
return resp
def fetch_and_render(id):
"""Fetch and render a post from the Github API"""
r = requests.get('https://api.github.com/gists/{}'.format(id))
if r.status_code != 200:
return None
decoded = r.json.copy()
for f in decoded['files'].values():
if f['language'] in RENDERABLE:
f['rendered'] = bleach.clean(markdown(f['content']),
tags=ALLOWED_TAGS, attributes=ALLOWED_ATTRIBUTES)
encoded = json.dumps(decoded)
cache.setex(id, CACHE_EXPIRATION, encoded)
return encoded
if __name__ == '__main__':
if HEROKU:
app.run(host='0.0.0.0', port=PORT)
else:
cache.flushall()
app.run(host='0.0.0.0', debug=True, port=PORT)
示例9: TestWebHooks
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
class TestWebHooks(Test):
def setUp(self):
super(TestWebHooks, self).setUp()
self.connection = StrictRedis()
self.connection.flushall()
@with_context
@patch('pybossa.model.requests')
def test_webhooks(self, mock):
"""Test WEBHOOK works."""
mock.post.return_value = True
err_msg = "The webhook should return True from patched method"
assert webhook('url'), err_msg
err_msg = "The post method should be called"
assert mock.post.called, err_msg
@with_context
@patch('pybossa.model.requests')
def test_webhooks_without_url(self, mock):
"""Test WEBHOOK without url works."""
mock.post.return_value = True
err_msg = "The webhook should return False"
assert webhook(None) is False, err_msg
@with_context
@patch('pybossa.model.task_run.webhook_queue', new=queue)
def test_trigger_webhook_without_url(self):
"""Test WEBHOOK is triggered without url."""
project = ProjectFactory.create()
task = TaskFactory.create(project=project, n_answers=1)
TaskRunFactory.create(project=project, task=task)
assert queue.enqueue.called is False, queue.enqueue.called
queue.reset_mock()
@with_context
@patch('pybossa.model.task_run.webhook_queue', new=queue)
def test_trigger_webhook_with_url_not_completed_task(self):
"""Test WEBHOOK is not triggered for uncompleted tasks."""
import random
project = ProjectFactory.create()
task = TaskFactory.create(project=project)
for i in range(1, random.randrange(2, 5)):
TaskRunFactory.create(project=project, task=task)
assert queue.enqueue.called is False, queue.enqueue.called
assert task.state != 'completed'
queue.reset_mock()
@with_context
@patch('pybossa.model.task_run.webhook_queue', new=queue)
def test_trigger_webhook_with_url(self):
"""Test WEBHOOK is triggered with url."""
url = 'http://server.com'
project = ProjectFactory.create(webhook=url,)
task = TaskFactory.create(project=project, n_answers=1)
TaskRunFactory.create(project=project, task=task)
payload = dict(event='task_completed',
project_short_name=project.short_name,
project_id=project.id,
task_id=task.id,
fired_at=datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"))
assert queue.enqueue.called
assert queue.called_with(webhook, url, payload)
queue.reset_mock()
示例10: DBClient
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
#.........这里部分代码省略.........
try:
servicelist = self.db_conn.smembers(key_ci)
except Exception as exp:
logger.error("[SnmpBooster] [code 1306] [%s] "
"%s" % (host,
str(exp)))
return None
if servicelist is None:
# TODO : Bailout properly
return None
dict_list = []
for service in servicelist:
try:
key = self.build_key(host, service)
data = self.db_conn.get(key)
if data is None:
logger.error("[SnmpBooster] [code 1307] [%s] "
"Unknown service %s", host, service)
continue
dict_list.append(ast.literal_eval(data))
except Exception as exp:
logger.error("[SnmpBooster] [code 1308] [%s] "
"%s" % (host,
str(exp)))
return dict_list
def show_keys(self):
""" Get all database keys """
return self.db_conn.keys()
def get_hosts_from_service(self, service):
""" List hosts with a service which match with the pattern """
results = []
for key in self.db_conn.keys():
if re.search(":.*"+service, key) is None:
# Look for service
continue
results.append(ast.literal_eval(self.db_conn.get(key)))
return results
def get_services_from_host(self, host):
""" List all services from hosts which match the pattern """
results = []
for key in self.db_conn.keys():
if re.search(host+".*:", key)is None:
# Look for host
continue
if re.search(":[0-9]+$", key) is not None:
# we skip host:interval
continue
results.append(ast.literal_eval(self.db_conn.get(key)))
return results
def clear_cache(self):
""" Clear all datas in database """
self.db_conn.flushall()
def get_all_services(self):
""" List all services """
results = []
for key in self.db_conn.keys():
if re.search(":[0-9]*$", key) is None:
host, service = key.split(":", 1)
results.append(self.get_service(host, service))
return results
def get_all_interval_keys(self):
""" List all host:interval keys which match interval pattern """
results = []
for key in self.db_conn.keys():
if re.search(":[0-9]*$", key) is not None:
results.append(key)
return results
def delete_services(self, key_list):
""" Delete services which match keys in key_list """
nb_del = self.db_conn.delete(*[self.build_key(host, service)
for host, service in key_list])
if nb_del > 0:
interval_key = self.get_all_interval_keys()
for host, service in key_list:
for key in [key for key in interval_key if key.startswith(host)]:
self.db_conn.srem(key, service)
return nb_del
def delete_host(self, host):
""" Delete all services in the specified host """
to_del = []
for key in self.db_conn.keys():
if re.search(host+":", key) is not None:
to_del.append(key)
if len(to_del) > 0:
return self.db_conn.delete(*to_del)
示例11: TestNews
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
class TestNews(Test):
d = MagicMock()
d.entries = [dict(updated='2015-01-01')]
def setUp(self):
super(TestNews, self).setUp()
self.connection = StrictRedis()
self.connection.flushall()
self.user = UserFactory.create(admin=True)
def get_notify_users(self):
key = "notify:admin:%s" % self.user.id
return sentinel.master.get(key)
def delete_notify(self):
key = "notify:admin:%s" % self.user.id
return sentinel.master.delete(key)
@with_context
@patch('feedparser.parse')
def test_news(self, feedparser_mock):
"""Test NEWS works."""
feedparser_mock.return_value = self.d
news()
tmp = get_news()
assert len(tmp) == 1, len(tmp)
err_msg = "Notify user should be notified"
assert self.get_notify_users() == '1', err_msg
@with_context
@patch('feedparser.parse')
def test_news_no_new_items(self, feedparser_mock):
"""Test NEWS no new items works."""
feedparser_mock.return_value = self.d
news()
feedparser_mock.return_value = self.d
news()
tmp = get_news()
assert len(tmp) == 1, len(tmp)
err_msg = "Notify user should be notified"
assert self.get_notify_users() == '1', err_msg
@with_context
@patch('feedparser.parse')
def test_news_no_new_items_no_notification(self, feedparser_mock):
"""Test NEWS no new items no notificaton works."""
feedparser_mock.return_value = self.d
news()
self.delete_notify()
feedparser_mock.return_value = self.d
news()
tmp = get_news()
assert len(tmp) == 1, len(tmp)
err_msg = "Notify user should NOT be notified"
assert self.get_notify_users() == None, err_msg
@with_context
@patch('feedparser.parse')
def test_news_check_config_urls(self, feedparser_mock):
"""Test NEWS adds config URLs."""
urls = ['https://github.com/pybossa/pybossa/releases.atom',
'http://scifabric.com/blog/all.atom.xml',
'http://url']
feedparser_mock.return_value = self.d
with patch.dict(self.flask_app.config, {'NEWS_URL': ['http://url']}):
news()
calls = []
for url in urls:
calls.append(call(url))
feedparser_mock.assert_has_calls(calls, any_order=True)
示例12: Redis
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
"userID": line.get('userId'),
"eventID": line.get('eventId'),
"appID": line.get('appId')
}).run()
if __name__ == '__main__':
# dfile = '~/Projects/unified-ETL-pipeline-/data/appEventSample.txt.gz'
dfile = '~/Desktop/9_18_appevent_dump_full.txt.gz'
NUM_REC = 100000
dupes = []
dq = CL.deque([], maxlen=1500)
cxn1 = Redis(db=DB_PARAMS['events_db_id'])
cxn1.flushall()
fh = gzip.open(os.path.expanduser(dfile), 'rt', encoding='utf-8')
# opener(fh, grep1(persist(DB_PARAMS)))
# opener(fh, grep1(persist_rethink(DB_PARAMS)))
# opener(fh, grep1(aggregate(DB_PARAMS)))
opener( fh, grep1(grep2(persist(DB_PARAMS))), num_rec=2*NUM_REC )
# opener(fh, grep1(persist(DB_PARAMS)))
print("number of records persisted: {}".format(len(cxn1.keys('*'))))
print('file handle closed')
示例13: RedisAPICacheStore
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
class RedisAPICacheStore(APICacheStore):
def __init__(self, *args, **kwargs):
self.config = kwargs.get('config', {})
self.ttl = self.config.get('ttl', 300)
super(RedisAPICacheStore, self).__init__(*args, **kwargs)
if self.config.get("use_settings", False):
redis_settings = settings.CACHE_REDIS
else:
redis_settings = self.config.get('parameters')
host = convert_variable_to_env_setting(redis_settings.get('host', "localhost"))
port = redis_settings.get('port', 6379)
db = redis_settings.get('db', 0)
pw = redis_settings.get('password', None)
timeout = redis_settings.get('timeout', .3)
self.redis = StrictRedis(host=host,
port=port,
db=db,
password=pw,
socket_timeout=timeout)
if self.config.get('use_settings'):
logger.info("Configuring Face/Off API cache with REDIS using settings.py")
else:
logger.info("Configuring Face/Off API cache with REDIS using JSON settings")
logger.info("Face/off API cache settings: redis://%s:%s/%s with ttl %s" %
(host, port, db, self.ttl))
def retrieve(self, key):
try:
resp = self.redis.get(key)
if resp is not None:
return pickle.loads(resp)
else:
return None
except ConnectionError as e:
logger.warning("Got a timeout error trying to get from Redis API Cache", exc_info=True)
return None
def store(self, key, value, ttl=None):
if ttl is None:
ttl = self.ttl
try:
self.redis.set(key, pickle.dumps(value))
if ttl > 0:
self.redis.expire(key, ttl)
except ConnectionError as e:
logger.warning("Got a timeout error trying to store into Redis API Cache", exc_info=True)
def invalidate(self, key):
try:
self.redis.delete(key)
except ConnectionError as e:
logger.warning("Got a timeout error trying to store invalidate Redis API Cache", exc_info=True)
def flush(self):
try:
self.redis.flushall()
except ConnectionError as e:
logger.warning("Got a timeout error trying to flush Redis API Cache", exc_info=True)
示例14: TestWebHooks
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
class TestWebHooks(Test):
def setUp(self):
super(TestWebHooks, self).setUp()
self.connection = StrictRedis()
self.connection.flushall()
self.project = ProjectFactory.create()
self.webhook_payload = dict(project_id=self.project.id,
project_short_name=self.project.short_name)
@with_context
@patch('pybossa.jobs.requests.post')
def test_webhooks(self, mock):
"""Test WEBHOOK works."""
mock.return_value = FakeResponse(text=json.dumps(dict(foo='bar')),
status_code=200)
err_msg = "The webhook should return True from patched method"
assert webhook('url', self.webhook_payload), err_msg
err_msg = "The post method should be called"
assert mock.called, err_msg
@with_context
@patch('pybossa.jobs.requests.post')
def test_webhooks_connection_error(self, mock):
"""Test WEBHOOK with connection error works."""
import requests
from pybossa.core import webhook_repo
mock.side_effect = requests.exceptions.ConnectionError
err_msg = "A webhook should be returned"
res = webhook('url', self.webhook_payload)
assert res.response == 'Connection Error', err_msg
assert res.response_status_code == None, err_msg
wh = webhook_repo.get(1)
assert wh.response == res.response, err_msg
assert wh.response_status_code == res.response_status_code, err_msg
@with_context
@patch('pybossa.jobs.requests.post')
def test_webhooks_without_url(self, mock):
"""Test WEBHOOK without url works."""
mock.post.return_value = True
err_msg = "The webhook should return Connection Error"
res = webhook(None, self.webhook_payload, None)
assert res.response == 'Connection Error', err_msg
assert res.response_status_code is None, err_msg
@with_context
@patch('pybossa.model.event_listeners.webhook_queue', new=queue)
def test_trigger_webhook_without_url(self):
"""Test WEBHOOK is triggered without url."""
project = ProjectFactory.create()
task = TaskFactory.create(project=project, n_answers=1)
TaskRunFactory.create(project=project, task=task)
assert queue.enqueue.called is False, queue.enqueue.called
queue.reset_mock()
@with_context
@patch('pybossa.model.event_listeners.webhook_queue', new=queue)
def test_trigger_webhook_with_url_not_completed_task(self):
"""Test WEBHOOK is not triggered for uncompleted tasks."""
import random
project = ProjectFactory.create()
task = TaskFactory.create(project=project)
for i in range(1, random.randrange(2, 5)):
TaskRunFactory.create(project=project, task=task)
assert queue.enqueue.called is False, queue.enqueue.called
assert task.state != 'completed'
queue.reset_mock()
@with_context
@patch('pybossa.model.event_listeners.webhook_queue', new=queue)
def test_trigger_webhook_with_url(self):
"""Test WEBHOOK is triggered with url."""
url = 'http://server.com'
project = ProjectFactory.create(webhook=url,)
task = TaskFactory.create(project=project, n_answers=1)
TaskRunFactory.create(project=project, task=task)
result = result_repo.get_by(project_id=project.id, task_id=task.id)
payload = dict(event='task_completed',
project_short_name=project.short_name,
project_id=project.id,
task_id=task.id,
result_id=result.id,
fired_at=datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"))
assert queue.enqueue.called
assert queue.called_with(webhook, url, payload)
queue.reset_mock()
示例15: TestContributionsGuard
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import flushall [as 别名]
class TestContributionsGuard(object):
def setUp(self):
self.connection = StrictRedis()
self.connection.flushall()
self.guard = ContributionsGuard(self.connection)
self.anon_user = {'user_id': None, 'user_ip': '127.0.0.1'}
self.auth_user = {'user_id': 33, 'user_ip': None}
self.task = Task(id=22)
def test_stamp_registers_specific_user_id_and_task(self):
key = 'pybossa:task_requested:user:33:task:22'
self.guard.stamp(self.task, self.auth_user)
assert key in self.connection.keys(), self.connection.keys()
def test_stamp_registers_specific_user_ip_and_task_if_no_id_provided(self):
key = 'pybossa:task_requested:user:127.0.0.1:task:22'
self.guard.stamp(self.task, self.anon_user)
assert key in self.connection.keys(), self.connection.keys()
def test_stamp_expires_in_one_hour(self):
key = 'pybossa:task_requested:user:33:task:22'
ONE_HOUR = 60 * 60
self.guard.stamp(self.task, self.auth_user)
assert self.connection.ttl(key) == ONE_HOUR, self.connection.ttl(key)
@patch('pybossa.contributions_guard.make_timestamp')
def test_stamp_adds_a_timestamp_when_the_task_is_stamped(self, make_timestamp):
make_timestamp.return_value = "now"
key = 'pybossa:task_requested:user:127.0.0.1:task:22'
self.guard.stamp(self.task, self.anon_user)
assert self.connection.get(key) == 'now'
def test_check_task_stamped_returns_False_for_non_stamped_task(self):
assert self.guard.check_task_stamped(self.task, self.auth_user) is False
def test_check_task_stamped_returns_True_for_auth_user_who_requested_task(self):
self.guard.stamp(self.task, self.auth_user)
assert self.guard.check_task_stamped(self.task, self.auth_user) is True
def test_check_task_stamped_returns_True_for_anon_user_who_requested_task(self):
self.guard.stamp(self.task, self.anon_user)
assert self.guard.check_task_stamped(self.task, self.anon_user) is True
def test_retrieve_timestamp_returns_None_for_non_stamped_task(self):
assert self.guard.retrieve_timestamp(self.task, self.auth_user) is None
@patch('pybossa.contributions_guard.make_timestamp')
def test_retrieve_timestamp_returs_the_timestamp_for_stamped_task(self, make_timestamp):
make_timestamp.return_value = "now"
self.guard.stamp(self.task, self.auth_user)
assert self.guard.retrieve_timestamp(self.task, self.auth_user) == 'now'