adding tests to qiita pet

Author: antgonza

qiita_db/metadata_template/base_metadata_template.py

@@ -772,54 +772,6 @@ def _add_common_creation_steps_to_queue(cls, md_template, obj_id,
                                       ', '.join(["%s"] * len(headers))),
             values, many=True)
 
-    @classmethod
-    def delete(cls, id_):
-        r"""Deletes the table from the database
-
-        Parameters
-        ----------
-        id_ : obj
-            The object identifier
-
-        Raises
-        ------
-        QiitaDBUnknownIDError
-            If no metadata_template with id id_ exists
-        """
-        cls._check_subclass()
-        if not cls.exists(id_):
-            raise QiitaDBUnknownIDError(id_, cls.__name__)
-
-        table_name = cls._table_name(id_)
-        conn_handler = SQLConnectionHandler()
-
-        # Delete the sample template filepaths
-        queue = "delete_sample_template_%d" % id_
-        conn_handler.create_queue(queue)
-
-        conn_handler.add_to_queue(
-            queue,
-            "DELETE FROM qiita.sample_template_filepath WHERE study_id = %s",
-            (id_, ))
-
-        conn_handler.add_to_queue(
-            queue,
-            "DROP TABLE qiita.{0}".format(table_name))
-
-        conn_handler.add_to_queue(
-            queue,
-            "DELETE FROM qiita.{0} where {1} = %s".format(cls._table,
-                                                          cls._id_column),
-            (id_,))
-
-        conn_handler.add_to_queue(
-            queue,
-            "DELETE FROM qiita.{0} where {1} = %s".format(cls._column_table,
-                                                          cls._id_column),
-            (id_,))
-
-        conn_handler.execute_queue(queue)
-
     @classmethod
     def exists(cls, obj_id):
         r"""Checks if already exists a MetadataTemplate for the provided object

qiita_db/metadata_template/sample_template.py

@@ -17,7 +17,7 @@
 
 from qiita_core.exceptions import IncompetentQiitaDeveloperError
 from qiita_db.exceptions import (QiitaDBDuplicateError, QiitaDBError,
-                                 QiitaDBWarning)
+                                 QiitaDBWarning, QiitaDBUnknownIDError)
 from qiita_db.sql_connection import SQLConnectionHandler
 from qiita_db.util import (get_table_cols, get_required_sample_info_status,
                            get_mountpoint, scrub_data)
@@ -152,6 +152,63 @@ def create(cls, md_template, study):
 
         return st
 
+    @classmethod
+    def delete(cls, id_):
+        r"""Deletes the table from the database
+
+        Parameters
+        ----------
+        id_ : integer
+            The object identifier
+
+        Raises
+        ------
+        QiitaDBUnknownIDError
+            If no sample template with id id_ exists
+        QiitaDBError
+            If the study that owns this sample template has raw datas
+        """
+        cls._check_subclass()
+
+        if not cls.exists(id_):
+            raise QiitaDBUnknownIDError(id_, cls.__name__)
+
+        raw_datas = [str(rd) for rd in Study(cls(id_).study_id).raw_data()]
+        if raw_datas:
+            raise QiitaDBError("Sample template can not be erased because "
+                               "there are raw datas (%s) associated." %
+                               ', '.join(raw_datas))
+
+        table_name = cls._table_name(id_)
+        conn_handler = SQLConnectionHandler()
+
+        # Delete the sample template filepaths
+        queue = "delete_sample_template_%d" % id_
+        conn_handler.create_queue(queue)
+
+        conn_handler.add_to_queue(
+            queue,
+            "DELETE FROM qiita.sample_template_filepath WHERE study_id = %s",
+            (id_, ))
+
+        conn_handler.add_to_queue(
+            queue,
+            "DROP TABLE qiita.{0}".format(table_name))
+
+        conn_handler.add_to_queue(
+            queue,
+            "DELETE FROM qiita.{0} where {1} = %s".format(cls._table,
+                                                          cls._id_column),
+            (id_,))
+
+        conn_handler.add_to_queue(
+            queue,
+            "DELETE FROM qiita.{0} where {1} = %s".format(cls._column_table,
+                                                          cls._id_column),
+            (id_,))
+
+        conn_handler.execute_queue(queue)
+
     @property
     def study_id(self):
         """Gets the study id with which this sample template is associated

qiita_db/metadata_template/test/test_base_metadata_template.py

@@ -64,12 +64,5 @@ def test_clean_validate_template(self):
             MetadataTemplate._clean_validate_template(None, 1, None, None)
 
 
-@qiita_test_checker()
-class TestMetadataTemplateReadWrite(TestCase):
-    def test_delete(self):
-        """delete raises an error because it's not called from a subclass"""
-        with self.assertRaises(IncompetentQiitaDeveloperError):
-            MetadataTemplate.delete(1)
-
 if __name__ == '__main__':
     main()

qiita_db/metadata_template/test/test_sample_template.py

@@ -1229,20 +1229,26 @@ def test_create_already_prefixed_samples(self):
 
     def test_delete(self):
         """Deletes Sample template 1"""
-        SampleTemplate.create(self.metadata, self.new_study)
-        SampleTemplate.delete(2)
+        st = SampleTemplate.create(self.metadata, self.new_study)
+        SampleTemplate.delete(st.id)
+
         obs = self.conn_handler.execute_fetchall(
             "SELECT * FROM qiita.required_sample_info WHERE study_id=2")
         exp = []
         self.assertEqual(obs, exp)
+
         obs = self.conn_handler.execute_fetchall(
             "SELECT * FROM qiita.study_sample_columns WHERE study_id=2")
         exp = []
         self.assertEqual(obs, exp)
+
         with self.assertRaises(QiitaDBExecutionError):
             self.conn_handler.execute_fetchall(
                 "SELECT * FROM qiita.sample_2")
 
+        with self.assertRaises(QiitaDBError):
+            SampleTemplate.delete(1)
+
     def test_delete_unkonwn_id_error(self):
         """Try to delete a non existent prep template"""
         with self.assertRaises(QiitaDBUnknownIDError):

qiita_pet/test/test_study_handlers.py

@@ -389,29 +389,50 @@ def test_delete_sample_template(self):
                               'action': 'delete_sample_template'})
         self.assertEqual(response.code, 200)
 
+        # checking that the action was sent
+        self.assertIn("Sample template can not be erased because there are "
+                      "raw datas", response.body)
+
     def test_delete_raw_data(self):
         response = self.post('/study/description/1',
                              {'raw_data_id': 1,
                               'action': 'delete_raw_data'})
         self.assertEqual(response.code, 200)
 
+        # checking that the action was sent
+        self.assertIn("Raw data 1 has prep template(s) associated so it can't "
+                      "be erased", response.body)
+
     def test_delete_prep_template(self):
         response = self.post('/study/description/1',
                              {'prep_template_id': 1,
                               'action': 'delete_prep_template'})
         self.assertEqual(response.code, 200)
 
+        # checking that the action was sent
+        self.assertIn('Cannot remove prep template 1 because a preprocessed '
+                      'data has been already generated using it.',
+                      response.body)
+
     def test_delete_preprocessed_data(self):
         response = self.post('/study/description/1',
                              {'preprocessed_data_id': 1,
                               'action': 'delete_preprocessed_data'})
         self.assertEqual(response.code, 200)
 
+        # checking that the action was sent
+        self.assertIn('Illegal operation on non sandboxed preprocessed data',
+                      response.body)
+
     def test_delete_processed_data(self):
         response = self.post('/study/description/1',
                              {'processed_data_id': 1,
                               'action': 'delete_processed_data'})
         self.assertEqual(response.code, 200)
 
+        # checking that the action was sent
+        self.assertIn('Illegal operation on non sandboxed processed data',
+                      response.body)
+
 if __name__ == "__main__":
     main()