delete dataset and trait files

4 files changed, 0 insertions, 416 deletions

diff --git a/tests/integration/test_datasets.py b/tests/integration/test_datasets.py
deleted file mode 100644
index f97d970..0000000
--- a/tests/integration/test_datasets.py
+++ /dev/null
@@ -1,41 +0,0 @@
-"""This module contains integration tests for datasets"""
-from unittest import TestCase
-from unittest import mock
-
-from collections import namedtuple
-from gn3.app import create_app
-
-
-class DatasetIntegrationTests(TestCase):
-    """class contains integration tests for datasets"""
-
-    def setUp(self):
-        self.app = create_app().test_client()
-
-    @mock.patch("gn3.api.datasets.create_dataset")
-    def test_create_dataset(self, mock_dataset):
-        """Test for creating dataset object"""
-        mock_dataset_creator = namedtuple(
-            'ProbeSet', ["dataset_name", "dataset_type"])
-        new_dataset = mock_dataset_creator("HC_M2_0606_P", "ProbeSet")
-        mock_dataset.return_value = new_dataset
-        response = self.app.get(
-            "/api/dataset/create/HC_M2_0606_P/", follow_redirects=True)
-        mock_dataset.assert_called_once_with(
-            dataset_type=None, dataset_name="HC_M2_0606_P")
-        results = response.get_json()["dataset"]
-        self.assertEqual(results[1], "ProbeSet")
-        self.assertEqual(response.status_code, 200)
-
-    @mock.patch("gn3.api.datasets.get_traits_data")
-    @mock.patch("gn3.api.datasets.database_connector")
-    def test_fetch_traits_data(self, mock_db, mock_get_trait_data):
-        """Test api/dataset/fetch_traits_data/d_name/d_type"""
-
-        mock_get_trait_data.return_value = {}
-        mock_db.return_value = (mock.Mock(), mock.Mock())
-        response = self.app.get(
-            "/api/dataset/fetch_traits_data/Aging-Brain-UCIPublish/Publish", follow_redirects=True)
-
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.get_json(), {"results": {}})
diff --git a/tests/integration/test_traits.py b/tests/integration/test_traits.py
deleted file mode 100644
index 410ba22..0000000
--- a/tests/integration/test_traits.py
+++ /dev/null
@@ -1,72 +0,0 @@
-"""module contains integration tests for trait endpoints"""
-from unittest import TestCase
-from unittest import mock
-
-from gn3.app import create_app
-
-
-class TraitIntegrationTest(TestCase):
-    """class contains integration tests for\
-    traits"""
-
-    def setUp(self):
-        self.app = create_app().test_client()
-
-    @mock.patch("gn3.api.traits.fetch_trait")
-    @mock.patch("gn3.api.traits.database_connector")
-    def test_create_trait(self, mock_database, mock_fetch_trait):
-        """test the endpoint for creating traits\
-        endpoint requires trait name and dataset name"""
-        mock_database.return_value = (mock.Mock(), mock.Mock())
-        trait_results = {
-            "dataset": None,
-            "trait_name": "1449593_at",
-            "trait_data": {
-                "BXD11": 8.464,
-                "BXD12": 8.414,
-                "BXD13": 8.753,
-                "BXD15": 8.5,
-                "BXD16": 8.832
-            }
-
-        }
-        mock_fetch_trait.return_value = trait_results
-
-        results = self.app.get(
-            "/api/trait/1449593_at/HC_M2_0606_P", follow_redirects=True)
-
-        trait_data = results.get_json()
-
-        self.assertEqual(mock_database.call_count, 1)
-        self.assertEqual(results.status_code, 200)
-        self.assertEqual(trait_data, trait_results)
-
-    @mock.patch("gn3.api.traits.get_trait_info_data")
-    def test_retrieve_trait_info(self, mock_get_trait_info):
-        """integration test for endpoints for retrieving\
-        trait info expects the dataset of trait to have been
-        created"""
-
-        trait_post_data = {
-            "trait": {"trait_name": ""},
-            "trait_dataset": {"dataset_name": ""}
-        }
-
-        expected_api_results = {
-            "description": "trait description",
-            "chr": "",
-            "locus": "",
-            "mb": "",
-            "abbreviation": "trait_abbreviation",
-            "trait_display_name": "trait_name"
-
-        }
-        mock_get_trait_info.return_value = expected_api_results
-
-        trait_info = self.app.post(
-            "/api/trait/trait_info/144_at", json=trait_post_data, follow_redirects=True)
-
-        trait_info_results = trait_info.get_json()
-
-        self.assertEqual(trait_info.status_code, 200)
-        self.assertEqual(trait_info_results, expected_api_results)
diff --git a/tests/unit/computations/test_datasets.py b/tests/unit/computations/test_datasets.py
deleted file mode 100644
index f9e9c2b..0000000
--- a/tests/unit/computations/test_datasets.py
+++ /dev/null
@@ -1,219 +0,0 @@
-"""Module contains tests from datasets"""
-import json
-
-from unittest import TestCase
-from unittest import mock
-
-from collections import namedtuple
-
-from gn3.computations.datasets import retrieve_trait_sample_data
-from gn3.computations.datasets import get_query_for_dataset_sample
-from gn3.computations.datasets import fetch_from_db_sample_data
-from gn3.computations.datasets import create_dataset
-from gn3.computations.datasets import dataset_creator_store
-from gn3.computations.datasets import dataset_type_getter
-from gn3.computations.datasets import fetch_dataset_type_from_gn2_api
-from gn3.computations.datasets import fetch_dataset_sample_id
-from gn3.computations.datasets import divide_into_chunks
-from gn3.computations.datasets import get_traits_data
-
-
-class TestDatasets(TestCase):
-    """Class contains tests for datasets"""
-
-    @mock.patch("gn3.computations.datasets.fetch_from_db_sample_data")
-    def test_retrieve_trait_sample_data(self, mock_fetch_sample_results):
-        """Test  retrieving sample data\
-         for trait from the dataset
-        """
-        trait_name = "1419792_at"
-        dataset_id = "HC_M2_0606_P&"
-        dataset_type = "Publish"
-
-        database = mock.Mock()
-
-        dataset = {
-            "id": dataset_id,
-            "type": dataset_type,
-            "name": dataset_id
-        }
-
-        fetch_results = [('BXD32', 8.001, None, None, 'BXD32')]
-
-        mock_fetch_sample_results.return_value = fetch_results
-
-        results = retrieve_trait_sample_data(
-            dataset, trait_name, database)
-        self.assertEqual(mock_fetch_sample_results.call_count, 1)
-        self.assertEqual(results, fetch_results)
-
-    def test_query_for_dataset_sample(self):
-        """Test for getting query for sample data"""
-
-        no_results = get_query_for_dataset_sample("does not exists")
-
-        query_exists = get_query_for_dataset_sample("Publish")
-
-        self.assertEqual(no_results, None)
-        self.assertIsInstance(query_exists, str)
-
-    def test_fetch_from_db_sample_data(self):
-        """Test for function that fetches sample\
-        results from the database
-        """
-
-        database_results = [('BXD31', 8.001, None, None, 'BXD31'),
-                            ('BXD32', 7.884, None, None, 'BXD32'),
-                            ('BXD42', 7.682, None, None, 'BXD42'),
-                            ('BXD42', 7.682, None, None, 'BXD42'),
-                            ('BXD40', 7.945, None, None, 'BXD40'),
-                            ('BXD43', 7.873, None, None, 'BXD43')
-                            ]
-
-        database = mock.Mock()
-        db_cursor = mock.Mock()
-        db_cursor.execute.return_value = 6
-        db_cursor.fetchall.return_value = database_results
-        database.cursor.return_value = db_cursor
-
-        mock_pheno_query = """
-                    SELECT
-                            Strain.Name, PublishData.value, PublishSE.error,NStrain.count, Strain.Name2
-                    WHERE
-                            PublishXRef.InbredSetId = PublishFreeze.InbredSetId AND
-                            PublishData.Id = PublishXRef.DataId AND PublishXRef.Id = 1419792_at AND
-                            PublishFreeze.Id = '12' AND PublishData.StrainId = Strain.Id
-                    Order BY
-                            Strain.Name
-                    """
-        fetch_results = fetch_from_db_sample_data(mock_pheno_query, database)
-
-        self.assertEqual(fetch_results, database_results)
-
-    @mock.patch("gn3.computations.datasets.dataset_creator_store")
-    @mock.patch("gn3.computations.datasets.dataset_type_getter")
-    def test_create_dataset(self, mock_dataset_type, mock_store):
-        """Test function that creates/fetches required dataset\
-        can either be published phenotype,genotype,Microarray or\
-        user defined ->Temp
-        """
-        probe_name = "HC_M2_0606_P"
-        probe_type = "ProbeSet"
-
-        mock_dataset_creator = namedtuple(
-            'ProbeSet', ["dataset_name", "dataset_type"])
-
-        mock_store.return_value = mock_dataset_creator
-        mock_dataset_type.return_value = probe_type
-        dataset = create_dataset(
-            dataset_type=None, dataset_name=probe_name)
-
-        self.assertEqual(dataset.dataset_name, probe_name)
-        self.assertEqual(dataset.dataset_type, probe_type)
-
-    def test_dataset_creator_store(self):
-        """Test  for functions that actual
-        function to create differerent \
-        datasets
-        """
-        results = dataset_creator_store("ProbeSet")
-
-        self.assertTrue(results)
-
-    def test_dataset_type_getter(self):
-        """Test for fetching type of dataset given\
-        the dataset name
-        """
-
-        redis_instance = mock.Mock()
-        # fetched  in redis
-        redis_instance.get.return_value = "ProbeSet"
-        results = dataset_type_getter("HC_M2_0_P", redis_instance)
-        self.assertEqual(results, "ProbeSet")
-
-    @mock.patch("gn3.computations.datasets.requests")
-    def test_fetch_dataset_type_from_gn2_api(self, mock_request):
-        """Test for function that test fetching\
-        all datasets from gn2 api in order to store\
-        in redis
-        """
-
-        expected_json_results = {"datasets": {
-            "arabidopsis": {
-                "BayXSha": {
-                    "Genotypes": [
-                        [
-                            "None",
-                            "BayXShaGeno",
-                            "BayXSha Genotypes"
-                        ]
-                    ],
-                    "Phenotypes": [
-                        [
-                            "642",
-                            "BayXShaPublish",
-                            "BayXSha Published Phenotypes"
-                        ]
-                    ]
-                }
-            }
-        }}
-
-        request_results = json.dumps(expected_json_results)
-        mock_request.get.return_value.content = request_results
-        results = fetch_dataset_type_from_gn2_api("HC_M2_0_P")
-        expected_results = {
-            "BayXShaGeno": "Geno",
-            "642": "Publish"
-        }
-
-        self.assertEqual(expected_results, results)
-
-    def test_fetch_dataset_sample_id(self):
-        """Get from the database the sample\
-        id if only in the samplelists
-        """
-
-        expected_results = {"B6D2F1": 1, "BXD1": 4, "BXD11": 10,
-                            "BXD12": 11, "BXD13": 12, "BXD15": 14, "BXD16": 15}
-
-        database_instance = mock.Mock()
-        database_cursor = mock.Mock()
-
-        database_cursor.execute.return_value = 5
-        database_cursor.fetchall.return_value = list(expected_results.items())
-        database_instance.cursor.return_value = database_cursor
-        strain_list = ["B6D2F1", "BXD1", "BXD11",
-                       "BXD12", "BXD13", "BXD16", "BXD15"]
-
-        results = fetch_dataset_sample_id(
-            samplelist=strain_list, database=database_instance, species="mouse")
-
-        self.assertEqual(results, expected_results)
-
-    @mock.patch("gn3.computations.datasets.fetch_from_db_sample_data")
-    @mock.patch("gn3.computations.datasets.divide_into_chunks")
-    def test_get_traits_data(self, mock_divide_into_chunks, mock_fetch_samples):
-        """Test for for function to get data\
-        of traits in dataset
-        """
-        _expected_results = {'AT_DSAFDS': [
-            12, 14, 13, 23, 12, 14, 13, 23, 12, 14, 13, 23]}
-        database = mock.Mock()
-        sample_id = [1, 2, 7, 3, 22, 8]
-        mock_divide_into_chunks.return_value = [
-            [1, 2, 7], [3, 22, 8], [5, 22, 333]]
-        mock_fetch_samples.return_value = ("AT_DSAFDS", 12, 14, 13, 23)
-        results = get_traits_data(sample_id, database, "HC_M2", "Publish")
-
-        self.assertEqual({}, dict(results))
-
-    def test_divide_into_chunks(self):
-        """Test for dividing a list into given number of\
-        chunks for example
-        """
-        results = divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 3)
-
-        expected_results = [[1, 2, 7], [3, 22, 8], [5, 22, 333]]
-
-        self.assertEqual(results, expected_results)
diff --git a/tests/unit/computations/test_trait.py b/tests/unit/computations/test_trait.py
deleted file mode 100644
index feb97c6..0000000
--- a/tests/unit/computations/test_trait.py
+++ /dev/null
@@ -1,84 +0,0 @@
-"""Module contains tests for creating traits"""
-from unittest import TestCase
-from unittest import mock
-
-from gn3.computations.traits import fetch_trait
-from gn3.computations.traits import get_trait_sample_data
-from gn3.computations.traits import get_trait_info_data
-
-
-class TestTrait(TestCase):
-    """Class contains tests for creating traits"""
-
-    @mock.patch("gn3.computations.traits.get_trait_sample_data")
-    def test_fetch_trait(self, get_sample_data):
-        """Test for creating/fetching trait"""
-
-        expected_sample_data = {
-            "A/Y": 12.3,
-            "WQC": 11.1
-        }
-
-        database = mock.Mock()
-
-        get_sample_data.return_value = expected_sample_data
-
-        expected_trait = {
-            "trait_name": "AXFDSF_AT",
-            "dataset": None,
-            "trait_data": expected_sample_data
-        }
-        results = fetch_trait(dataset=None,
-                              trait_name="AXFDSF_AT",
-                              database=database)
-
-        self.assertEqual(results, expected_trait)
-        self.assertEqual(get_sample_data.call_count, 1)
-
-    @mock.patch("gn3.computations.traits.retrieve_trait_sample_data")
-    def test_get_trait_sample_data(self, mock_retrieve_sample_data):
-        """Test for getting sample data from  either\
-        the trait's dataset or form redis
-        """
-
-        trait_dataset = mock.Mock()
-        dataset_trait_sample_data = [
-            ('129S1/SvImJ', 7.433, None, None, '129S1/SvImJ'),
-            ('A/J', 7.596, None, None, 'A/J'),
-            ('AKR/J', 7.774, None, None, 'AKR/J'),
-            ('B6D2F1', 7.707, None, None, 'B6D2F1')]
-        mock_retrieve_sample_data.return_value = dataset_trait_sample_data
-
-        trait_name = "1426679_at"
-
-        database = mock.Mock()
-
-        results = get_trait_sample_data(
-            trait_dataset, trait_name, database)
-
-        expected_results = {
-            "129S1/SvImJ": 7.433,
-            "A/J": 7.596,
-            "AKR/J": 7.774,
-            "B6D2F1": 7.707
-        }
-
-        self.assertEqual(results, expected_results)
-
-    def test_get_trait_info_data(self):
-        """Test for getting info data related\
-        to trait
-        """
-
-        results = get_trait_info_data(
-            trait_name="AXSF_AT", trait_dataset=mock.Mock(), database_instance=None)
-        expected_trait_info = {
-            "description": "",
-            "trait_display_name": "",
-            "abbreviation": "",
-            "chr": "",
-            "mb": "",
-            "locus": ""
-        }
-
-        self.assertEqual(results, expected_trait_info)