def test_sample_template_patch_request(self):
        # Wrong operation operation
        obs = sample_template_patch_request("[email protected]", "add", "/1/columns/season_environment/")
        exp = {"status": "error", "message": 'Operation "add" not supported. ' "Current supported operations: remove"}
        self.assertEqual(obs, exp)
        # Wrong path parameter
        obs = sample_template_patch_request("[email protected]", "remove", "/columns/season_environment/")
        exp = {"status": "error", "message": "Incorrect path parameter"}
        self.assertEqual(obs, exp)
        # No access
        obs = sample_template_patch_request("[email protected]", "remove", "/1/columns/season_environment/")
        exp = {"status": "error", "message": "User does not have access to study"}
        self.assertEqual(obs, exp)
        # Success
        obs = sample_template_patch_request("[email protected]", "remove", "/1/columns/season_environment/")
        exp = {"status": "success", "message": ""}
        self.assertEqual(obs, exp)

        # This is needed so the clean up works - this is a distributed system
        # so we need to make sure that all processes are done before we reset
        # the test database
        obs = r_client.get("sample_template_1")
        self.assertIsNotNone(obs)
        redis_info = loads(r_client.get(loads(obs)["job_id"]))
        while redis_info["status_msg"] == "Running":
            sleep(0.05)
            redis_info = loads(r_client.get(loads(obs)["job_id"]))

        ST = qdb.metadata_template.sample_template.SampleTemplate
        self.assertNotIn("season_environment", ST(1).categories())

 def test_delete_artifact(self):
     response = self.post('/artifact/',
                          {'artifact_id': 2})
     self.assertEqual(response.code, 200)
     # This is needed so the clean up works - this is a distributed system
     # so we need to make sure that all processes are done before we reset
     # the test database
     obs = r_client.get('prep_template_1')
     self.assertIsNotNone(obs)
     redis_info = loads(r_client.get(loads(obs)['job_id']))
     while redis_info['status_msg'] == 'Running':
         sleep(0.05)
         redis_info = loads(r_client.get(loads(obs)['job_id']))

    def test_artifact_delete_req(self):
        obs = artifact_delete_req(3, '[email protected]')
        exp = {'status': 'success', 'message': ''}
        self.assertEqual(obs, exp)

        # This is needed so the clean up works - this is a distributed system
        # so we need to make sure that all processes are done before we reset
        # the test database
        obs = r_client.get('prep_template_1')
        self.assertIsNotNone(obs)
        redis_info = loads(r_client.get(loads(obs)['job_id']))
        while redis_info['status_msg'] == 'Running':
            sleep(0.05)
            redis_info = loads(r_client.get(loads(obs)['job_id']))

    def test_sample_template_delete_req(self):
        obs = sample_template_delete_req(1, "[email protected]")
        exp = {"status": "success", "message": ""}
        self.assertEqual(obs, exp)

        obs = r_client.get("sample_template_1")
        self.assertIsNotNone(obs)

        # This is needed so the clean up works - this is a distributed system
        # so we need to make sure that all processes are done before we reset
        # the test database
        redis_info = loads(r_client.get(loads(obs)["job_id"]))
        while redis_info["status_msg"] == "Running":
            sleep(0.05)
            redis_info = loads(r_client.get(loads(obs)["job_id"]))

    def unlisten_to_node(self, id_):
        """Stop listening to a job

        Parameters
        ----------
        id_ : str
            An ID to remove

        Returns
        --------
        str or None
            The ID removed or None if the ID was not removed
        """
        id_pubsub = _pubsub_key(id_)

        if id_pubsub in self._listening_to:
            del self._listening_to[id_pubsub]
            self.toredis.unsubscribe(id_pubsub)

            parent = json_decode(r_client.get(id_)).get('parent', None)
            if parent is not None:
                r_client.srem(_children_key(parent), id_)
            r_client.srem(self.group_children, id_)

            return id_

    def get(self, job_id):
        details = loads(r_client.get(job_id))

        if details["status_msg"] == "Failed":
            # TODO: something smart
            pass

        self.redirect("/")

 def listen_to_node(self, id_):
     """Attach a callback on the job pubsub if it exists"""
     if r_client.get(id_) is None:
         return
     else:
         self.toredis.subscribe(_pubsub_key(id_), callback=self.callback)
         self._listening_to[_pubsub_key(id_)] = id_
         return id_

def safe_submit(*args, **kwargs):
    """Safe wraper for the submit function

    There are cases in which a race condition may occur: submit returns the
    job id but moi hasn't submitted the job. In some cases this is not
    acceptable, so this wrapper makes sure that the job_id
    is returned only once the job has already been submitted.

    From previous tests, the while loop is executed ~2 times, so there is not
    much time lost in here
    """
    job_id = submit(*args, **kwargs)
    payload = r_client.get(job_id)
    while not payload:
        sleep(0.005)
        payload = r_client.get(job_id)

    return job_id

    def test_sample_template_post_req(self):
        obs = sample_template_post_req(1, '[email protected]', '16S',
                                       'uploaded_file.txt')
        exp = {'status': 'success',
               'message': '',
               'file': 'uploaded_file.txt'}
        self.assertEqual(obs, exp)

        obs = r_client.get('sample_template_1')
        self.assertIsNotNone(obs)

        # This is needed so the clean up works - this is a distributed system
        # so we need to make sure that all processes are done before we reset
        # the test database
        redis_info = loads(r_client.get(loads(obs)['job_id']))
        while redis_info['status_msg'] == 'Running':
            sleep(0.05)
            redis_info = loads(r_client.get(loads(obs)['job_id']))

    def test_status_change(self):
        new_status = 'new status'

        r_client.set(self.test_id, json.dumps(self.test_job_info))

        # _status_change will return the old status
        obs = _status_change(self.test_id, new_status)
        self.assertEqual(obs, self.test_job_info['status'])

        obs = json.loads(r_client.get(self.test_id))
        self.assertEqual(obs['status'], new_status)

    def test__submit(self):
        ctx = ctxs.values()[0]
        cmd = 'echo "hello"'
        id_, pid_ = _submit(ctx, 'no parent', 'test', '/', system_call, cmd)
        self.test_keys.append(id_)
        self.test_keys.append(pid_)
        sleep(2)

        obs = json.loads(r_client.get(id_))
        self.assertEqual(obs['result'], [u"hello\n", u"", 0])
        self.assertEqual(obs['status'], 'Success')
        self.assertNotEqual(obs['date_start'], None)
        self.assertNotEqual(obs['date_end'], None)

    def test_redis_wrap_except(self):
        def foo(a, b, **kwargs):
            return a+b

        with self.assertRaises(TypeError):
            _redis_wrap(self.test_job_info, foo, 1)

        obs = json.loads(r_client.get(self.test_job_info['id']))
        self.assertEqual(obs['result'][0],
                         u'Traceback (most recent call last):\n')
        self.assertEqual(obs['status'], 'Failed')
        self.assertNotEqual(obs['date_start'], None)
        self.assertNotEqual(obs['date_end'], None)

    def test_get_sample_template_processing_status(self):
        key = SAMPLE_TEMPLATE_KEY_FORMAT % 1

        obs_proc, obs_at, obs_am = get_sample_template_processing_status(1)
        self.assertFalse(obs_proc)
        self.assertEqual(obs_at, "")
        self.assertEqual(obs_am, "")

        # Without job id
        r_client.set(key, dumps({"job_id": None, "status": "success", "message": ""}))
        obs_proc, obs_at, obs_am = get_sample_template_processing_status(1)
        self.assertFalse(obs_proc)
        self.assertEqual(obs_at, "success")
        self.assertEqual(obs_am, "")

        # With job id and processing
        r_client.set(key, dumps({"job_id": "test_job_id"}))
        r_client.set("test_job_id", dumps({"status_msg": "Running"}))
        obs_proc, obs_at, obs_am = get_sample_template_processing_status(1)
        self.assertTrue(obs_proc)
        self.assertEqual(obs_at, "info")
        self.assertEqual(obs_am, "This sample template is currently being processed")

        # With job id and success
        r_client.set(key, dumps({"job_id": "test_job_id"}))
        r_client.set(
            "test_job_id", dumps({"status_msg": "Success", "return": {"status": "success", "message": "Some\nwarning"}})
        )
        obs_proc, obs_at, obs_am = get_sample_template_processing_status(1)
        self.assertFalse(obs_proc)
        self.assertEqual(obs_at, "success")
        self.assertEqual(obs_am, "Some</br>warning")
        obs = loads(r_client.get(key))
        self.assertEqual(obs, {"job_id": None, "status": "success", "message": "Some</br>warning"})

        # With job and not success
        r_client.set(key, dumps({"job_id": "test_job_id"}))
        r_client.set(
            "test_job_id", dumps({"status_msg": "Failed", "return": {"status": "error", "message": "Some\nerror"}})
        )
        obs_proc, obs_at, obs_am = get_sample_template_processing_status(1)
        self.assertFalse(obs_proc)
        self.assertEqual(obs_at, "error")
        self.assertEqual(obs_am, "Some</br>error")

        # With job expired
        r_client.set(key, dumps({"job_id": "non_existent_job"}))
        obs_proc, obs_at, obs_am = get_sample_template_processing_status(1)
        self.assertFalse(obs_proc)
        self.assertEqual(obs_at, "")
        self.assertEqual(obs_am, "")

    def wrapper(handler, *args, **kwargs):
        header = handler.request.headers.get('Authorization', None)
        if header is None:
            _oauth_error(handler, 'Oauth2 error: invalid access token',
                         'invalid_request')
            return
        token_info = header.split()
        # Based on RFC6750 if reply is not 2 elements in the format of:
        # ['Bearer', token] we assume a wrong reply
        if len(token_info) != 2 or token_info[0] != 'Bearer':
            _oauth_error(handler, 'Oauth2 error: invalid access token',
                         'invalid_grant')
            return

        token = token_info[1]
        db_token = r_client.hgetall(token)
        if not db_token:
            # token has timed out or never existed
            _oauth_error(handler, 'Oauth2 error: token has timed out',
                         'invalid_grant')
            return
        # Check daily rate limit for key if password style key
        if db_token['grant_type'] == 'password':
            limit_key = '%s_%s_daily_limit' % (db_token['client_id'],
                                               db_token['user'])
            limiter = r_client.get(limit_key)
            if limiter is None:
                # Set limit to 5,000 requests per day
                r_client.setex(limit_key, 5000, 86400)
            else:
                r_client.decr(limit_key)
                if int(r_client.get(limit_key)) <= 0:
                    _oauth_error(
                        handler, 'Oauth2 error: daily request limit reached',
                        'invalid_grant')
                    return

        return f(handler, *args, **kwargs)

    def test_post_artifact(self):
        args = {
            'artifact-type': 'FASTQ',
            'name': 'New Artifact Handler test',
            'prep-template-id': self.prep.id,
            'raw_forward_seqs': [self.fwd_fp],
            'raw_barcodes': [self.barcodes_fp],
            'raw_reverse_seqs': [],
            'import-artifact': ''}
        response = self.post('/study/new_artifact/', args)
        self.assertEqual(response.code, 200)

        # make sure new artifact created
        obs = r_client.get('prep_template_%s' % self.prep.id)
        self.assertIsNotNone(obs)
        redis_info = loads(r_client.get(loads(obs)['job_id']))
        while redis_info['status_msg'] == 'Running':
            sleep(0.05)
            redis_info = loads(r_client.get(loads(obs)['job_id']))
        new_artifact_id = get_count('qiita.artifact')
        artifact = Artifact(new_artifact_id)
        self.assertEqual(artifact.name, 'New Artifact Handler test')
        self._files_to_remove.extend([fp for _, fp, _ in artifact.filepaths])

    def _traverse(self, id_):
        """Traverse groups and yield info dicts for jobs"""

        nodes = r_client.smembers(_children_key(id_))
        while nodes:
            current_id = nodes.pop()

            details = self._decode(r_client.get(current_id))
            if details['type'] == 'group':
                children = r_client.smembers(_children_key(details['id']))
                if children is not None:
                    nodes.update(children)

            yield details

    def test_prep_template_patch_req(self):
        pt = PrepTemplate(1)
        # Update investigation type
        obs = prep_template_patch_req(
            '[email protected]', 'replace', '/1/investigation_type',
            'Cancer Genomics')
        exp = {'status': 'success', 'message': ''}
        self.assertEqual(obs, exp)
        self.assertEqual(pt.investigation_type, 'Cancer Genomics')
        # Update prep template data
        obs = prep_template_patch_req(
            '[email protected]', 'replace', '/1/data', 'update.txt')
        self.assertEqual(obs, exp)
        obs = r_client.get('prep_template_1')
        self.assertIsNotNone(obs)

        # This is needed so the clean up works - this is a distributed system
        # so we need to make sure that all processes are done before we reset
        # the test database
        redis_info = loads(r_client.get(obs))
        while redis_info['status_msg'] == 'Running':
            sleep(0.05)
            redis_info = loads(r_client.get(obs))

    def test_redis_wrap(self):
        def foo(a, b, **kwargs):
            return a+b

        r_client.set(self.test_job_info['id'], json.dumps(self.test_job_info))
        _redis_wrap(self.test_job_info, foo, 1, 2)

        sleep(2)
        obs = json.loads(r_client.get(self.test_job_info['id']))
        self.assertEqual(obs['result'], 3)
        self.assertEqual(obs['status'], 'Success')
        self.assertNotEqual(obs['date_start'], None)
        self.assertNotEqual(obs['date_end'], None)

        r_client.set(self.test_job_info['id'], json.dumps(self.test_job_info))
        _redis_wrap(self.test_job_info, foo, 1, 2, 3)

        sleep(2)
        obs = json.loads(r_client.get(self.test_job_info['id']))
        self.assertEqual(obs['result'][0],
                         u'Traceback (most recent call last):\n')
        self.assertEqual(obs['status'], 'Failed')
        self.assertNotEqual(obs['date_start'], None)
        self.assertNotEqual(obs['date_end'], None)

    def test_submit_nouser(self):
        def foo(a, b, c=10, **kwargs):
            return a+b+c

        id_, pid_ = submit_nouser(foo, 1, 2, c=20)
        self.test_keys.append(id_)
        self.test_keys.append(pid_)

        sleep(2)

        obs = json.loads(r_client.get(id_))
        self.assertEqual(obs['result'], 23)
        self.assertEqual(obs['status'], 'Success')
        self.assertNotEqual(obs['date_start'], None)
        self.assertNotEqual(obs['date_end'], None)

    def test_redis_wrap(self):
        def foo(a, b, **kwargs):
            return a+b

        r_client.set(self.test_job_info['id'], json.dumps(self.test_job_info))
        obs_ret = _redis_wrap(self.test_job_info, foo, 1, 2)

        sleep(1)
        obs = json.loads(r_client.get(self.test_job_info['id']))
        self.assertEqual(obs['result'], 3)
        self.assertEqual(obs_ret, obs['result'])
        self.assertEqual(obs['status'], 'Success')
        self.assertNotEqual(obs['date_start'], None)
        self.assertNotEqual(obs['date_end'], None)

        r_client.set(self.test_job_info['id'], json.dumps(self.test_job_info))