Fixing tests

qiita_pet/handlers/api_proxy/prep_template.py

@@ -127,7 +127,7 @@ def prep_template_ajax_get_req(user_id, prep_id):
             alert_msg = job.log.msg.replace('\n', '</br>')
         else:
             alert_type = job_info['alert_type']
-            alert_msg = job_info['alert_msg']
+            alert_msg = job_info['alert_msg'].replace('\n', '</br>')
 
     artifact_attached = pt.artifact is not None
     study_id = pt.study_id

qiita_pet/handlers/api_proxy/sample_template.py

@@ -209,7 +209,7 @@ def get_sample_template_processing_status(st_id):
             alert_msg = job.log.msg.replace('\n', '</br>')
         else:
             alert_type = job_info['alert_type']
-            alert_msg = job_info['alert_msg']
+            alert_msg = job_info['alert_msg'].replace('\n', '</br>')
 
     return processing, alert_type, alert_msg
 
@@ -541,7 +541,7 @@ def sample_template_patch_request(user_id, req_op, req_path, req_value=None,
             cmd, values_dict={'obj_class': 'SampleTemplate',
                               'obj_id': int(st_id), 'sample_or_col': attribute,
                               'name': attr_id})
-        job = ProcessingJob(User(user_id), params)
+        job = ProcessingJob.create(User(user_id), params)
 
         # Store the job id attaching it to the sample template id
         r_client.set(SAMPLE_TEMPLATE_KEY_FORMAT % st_id,

qiita_pet/handlers/api_proxy/tests/test_prep_template.py

@@ -10,14 +10,14 @@
 from os.path import join, exists
 from string import ascii_letters
 from random import choice
-from time import sleep
 from json import loads
 
 import pandas as pd
 import numpy.testing as npt
 
 from qiita_core.util import qiita_test_checker
 from qiita_core.qiita_settings import r_client
+from qiita_core.testing import wait_for_processing_job
 from qiita_db.artifact import Artifact
 from qiita_db.metadata_template.prep_template import PrepTemplate
 from qiita_db.ontology import Ontology
@@ -288,10 +288,7 @@ def _wait_for_parallel_job(self, key):
         # so we need to make sure that all processes are done before we reset
         # the test database
         obs = r_client.get(key)
-        redis_info = loads(r_client.get(loads(obs)['job_id']))
-        while redis_info['status_msg'] == 'Running':
-            sleep(0.5)
-            redis_info = loads(r_client.get(loads(obs)['job_id']))
+        wait_for_processing_job(loads(obs)['job_id'])
 
     def test_prep_template_graph_get_req(self):
         obs = prep_template_graph_get_req(1, 'test@foo.bar')

qiita_pet/handlers/api_proxy/tests/test_sample_template.py

@@ -8,11 +8,11 @@
 from unittest import TestCase, main
 from os import remove, mkdir
 from os.path import join, exists
-from time import sleep
 from json import loads, dumps
 
 from qiita_core.util import qiita_test_checker
 from qiita_core.qiita_settings import r_client
+from qiita_core.testing import wait_for_processing_job
 import qiita_db as qdb
 from qiita_pet.handlers.api_proxy.sample_template import (
     sample_template_summary_get_req, sample_template_post_req,
@@ -140,55 +140,42 @@ def test_get_sample_template_processing_status(self):
         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'}))
+        qiita_plugin = qdb.software.Software.from_name_and_version('Qiita',
+                                                                   'alpha')
+        cmd = qiita_plugin.get_command('update_sample_template')
+        params = qdb.software.Parameters.load(
+            cmd, values_dict={'study': 1, 'template_fp': 'ignored'})
+        job = qdb.processing_job.ProcessingJob.create(
+            qdb.user.User('test@foo.bar'), params)
+        job._set_status('running')
+        r_client.set(key, dumps({'job_id': job.id}))
         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'}}))
+        job._set_status('success')
+        r_client.set(key, dumps({'job_id': job.id, 'alert_type': 'warning',
+                                 'alert_msg': '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_at, "warning")
         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'}}))
+        job = qdb.processing_job.ProcessingJob.create(
+            qdb.user.User('test@foo.bar'), params)
+        job._set_status('running')
+        job._set_error('Some\nerror')
+        r_client.set(key, dumps({'job_id': job.id}))
         obs_proc, obs_at, obs_am = get_sample_template_processing_status(1)
         self.assertFalse(obs_proc)
-        self.assertEqual(obs_at, "error")
+        self.assertEqual(obs_at, "danger")
         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 test_sample_template_summary_get_req(self):
         obs = sample_template_summary_get_req(1, 'test@foo.bar')
         exp = {
@@ -396,10 +383,7 @@ def test_sample_template_post_req(self):
         # 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.5)
-            redis_info = loads(r_client.get(loads(obs)['job_id']))
+        wait_for_processing_job(loads(obs)['job_id'])
 
     def test_sample_template_post_req_no_access(self):
         obs = sample_template_post_req(1, 'demo@microbio.me', '16S',
@@ -422,10 +406,7 @@ def test_sample_template_put_req(self):
         # 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.5)
-            redis_info = loads(r_client.get(loads(obs)['job_id']))
+        wait_for_processing_job(loads(obs)['job_id'])
 
     def test_sample_template_put_req_no_access(self):
         obs = sample_template_put_req(1, 'demo@microbio.me', 'filepath')
@@ -452,10 +433,7 @@ def test_sample_template_delete_req(self):
         # 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.5)
-            redis_info = loads(r_client.get(loads(obs)['job_id']))
+        wait_for_processing_job(loads(obs)['job_id'])
 
     def test_sample_template_delete_req_no_access(self):
         obs = sample_template_delete_req(1, 'demo@microbio.me')
@@ -552,10 +530,7 @@ def test_sample_template_patch_request(self):
         # 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.5)
-            redis_info = loads(r_client.get(loads(obs)['job_id']))
+        wait_for_processing_job(loads(obs)['job_id'])
 
         ST = qdb.metadata_template.sample_template.SampleTemplate
         self.assertNotIn("season_environment", ST(1).categories())