Merge pull request #1209 from TOMToolkit/1109-create-a-basedataservice-class

establish basic tests for BaseDataService class

Author: jchate6

tom_dataservices/dataservices.py

@@ -1,6 +1,10 @@
 from abc import ABC, abstractmethod
 
 
+class MissingDataException(Exception):
+    pass
+
+
 class BaseDataService(ABC):
     """
     Base class for all Data Services. Data Services are classes that are responsible for querying external services
@@ -17,17 +21,17 @@ class BaseDataService(ABC):
     # Class variable that can store query results if necessary
     query_results = {}
 
-    @abstractmethod
-    def pre_query_validation_service(self, query_parameters):
-        """Same thing as query_service, but a dry run"""
-
     @abstractmethod
     def query_service(self, query_parameters):
         """takes in the serialized data from the query form and actually submits the query to the service"""
 
-    @abstractmethod
+    def pre_query_validation(self, query_parameters):
+        """Same thing as query_service, but a dry run"""
+        raise NotImplementedError
+
     def get_form_class(self):
         """Returns the full form class for querying this service"""
+        raise NotImplementedError
 
     def get_additional_context_data(self):
         """
@@ -63,14 +67,53 @@ def query_targets(self, query_parameters):
         """Set up and run a specialized query for retrieving targets from a DataService."""
         return self.query_service(query_parameters)
 
-    def to_data_product(self, query_results):
+    def to_data_product(self, query_results=None, **kwargs):
+        """
+        Upper level function to create a new DataProduct from the query results
+        Can take either new query results, or use stored results form a recent `query_service()`
+        :param query_results: Query results from the DataService
+        :returns: Target object
+        """
+        query_results = query_results or self.query_results
+        if not query_results:
+            raise MissingDataException('No query results. Did you call query_service()?')
+        else:
+            return self.create_data_product_from_query(query_results, **kwargs)
+
+    def create_data_product_from_query(self, query_results=None, **kwargs):
         """Create a new DataProduct from the query results"""
         raise NotImplementedError
 
-    def to_reduced_datums(self, query_results):
-        """Create a new ReducedDatum of the appropriate type from the query results"""
+    def to_reduced_datums(self, query_results=None, **kwargs):
+        """
+        Upper level function to create a new ReducedDatum from the query results
+        Can take either new query results, or use stored results form a recent `query_service()`
+        :param query_results: Query results from the DataService
+        :returns: Target object
+        """
+        query_results = query_results or self.query_results
+        if not query_results:
+            raise MissingDataException('No query results. Did you call query_service()?')
+        else:
+            return self.create_reduced_datums_from_query(query_results, **kwargs)
+
+    def create_reduced_datums_from_query(self, query_results=None, **kwargs):
+        """Create a new reduced_datum of the appropriate type from the query results"""
         raise NotImplementedError
 
-    def to_target(self, query_results):
+    def to_target(self, query_results=None, **kwargs):
+        """
+        Upper level function to create a new target from the query results
+        Can take either new query results, or use stored results form a recent `query_service()`
+        :param query_results: Query results from the DataService
+        :returns: Target object
+        """
+        target_parameters = query_results or self.query_results
+        if not target_parameters:
+            raise MissingDataException('No query results. Did you call query_service()?')
+        else:
+            return self.create_target_from_query(target_parameters, **kwargs)
+
+    def create_target_from_query(self, query_results, **kwargs):
         """Create a new target from the query results"""
         raise NotImplementedError

tom_dataservices/forms.py

@@ -0,0 +1,14 @@
+from django import forms
+from crispy_forms.helper import FormHelper
+from crispy_forms.layout import Submit
+
+
+class BaseQueryForm(forms.Form):
+    """
+    Form class representing the default form for a dataservice.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.helper = FormHelper()
+        self.helper.add_input(Submit('submit', 'Submit'))

tom_dataservices/tests/__init__.py

@@ -0,0 +1,94 @@
+from django import forms
+from django.test import TestCase
+
+from tom_dataservices.dataservices import BaseDataService, MissingDataException
+from tom_dataservices.forms import BaseQueryForm
+from tom_targets.models import Target
+
+
+test_query_results = {'ra': 24, 'dec': 77, 'name': 'faketarget', 'type': 'SIDEREAL'}
+
+
+class TestDataServiceForm(BaseQueryForm):
+    """ A DataService must implement a form in order to be displayed in a TOM.
+    They should subclass `BaseQueryForm`. This test form will only have one field.
+    """
+    name = forms.CharField(required=True)
+
+
+class TestDataService(BaseDataService):
+    name = 'TEST'
+    service_notes = "This is a test DataService."
+
+    def query_service(self, term):
+        if term == 'notfound':
+            raise MissingDataException
+        self.query_results = test_query_results
+        return
+
+    def get_form_class(self):
+        return TestDataServiceForm
+
+    def create_target_from_query(self, query_results, **kwargs):
+        return Target(**query_results)
+
+
+class EmptyTestDataService(BaseDataService):
+    name = 'TEST'
+    service_notes = "This is a test DataService."
+
+    def query_service(self, term):
+        if term == 'notfound':
+            raise MissingDataException
+        self.query_results = test_query_results
+        return
+
+
+class TestDataServiceClass(TestCase):
+    """
+    Test the functionality of the DataService class via the TestDataService.
+    """
+    def test_query_service(self):
+        new_test_query = TestDataService()
+        self.assertEqual(new_test_query.query_results, {})
+        new_test_query.query_service('mytarget')
+        self.assertEqual(new_test_query.query_results, test_query_results)
+
+    def test_to_target(self):
+        new_test_query = TestDataService()
+        # Show to_target() returns error with no query_results
+        with self.assertRaises(MissingDataException):
+            new_test_query.to_target()
+        # Show to_target() works with the default query_results
+        new_test_query.query_targets('mytarget')
+        target = new_test_query.to_target()
+        self.assertEqual(target.name, test_query_results['name'])
+        # Show to_target() works independently of the query.
+        new_test_query_results = test_query_results.copy()
+        new_test_query_results['name'] = 'target2'
+        target2 = new_test_query.to_target(new_test_query_results)
+        self.assertEqual(target2.name, 'target2')
+
+
+class TestUnimplementedDataServiceClass(TestCase):
+    """
+    Test the functionality of a DataService with unimplemented methods.
+    """
+
+    def test_no_create_data_product_from_query(self):
+        new_test_query = EmptyTestDataService()
+        # Show to_data_product() returns error when create_data_product_from_query undefined
+        with self.assertRaises(NotImplementedError):
+            new_test_query.to_data_product(test_query_results)
+
+    def test_no_create_target_from_query(self):
+        new_test_query = EmptyTestDataService()
+        # Show to_data_product() returns error when create_data_product_from_query undefined
+        with self.assertRaises(NotImplementedError):
+            new_test_query.to_target(test_query_results)
+
+    def test_no_create_reduced_datums_from_query(self):
+        new_test_query = EmptyTestDataService()
+        # Show to_data_product() returns error when create_data_product_from_query undefined
+        with self.assertRaises(NotImplementedError):
+            new_test_query.to_reduced_datums(test_query_results)