Python StrictRedis.flushall方法代码示例

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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

# 需要导入模块: 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",

# 需要导入模块: 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)

# 需要导入模块: 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()

# 需要导入模块: 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)

# 需要导入模块: 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)

# 需要导入模块: 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')

# 需要导入模块: 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)

# 需要导入模块: 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()

# 需要导入模块: 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'