add tests

jchate6 · jchate6 · commit c8ca59712908 · 2025-04-14T16:10:07.000-07:00
diff --git a/tom_dataservices/dataservices.py b/tom_dataservices/dataservices.py
@@ -21,17 +21,17 @@ class BaseDataService(ABC):
     # Class variable that can store query results if necessary
     query_results = {}
 
-    @abstractmethod
-    def pre_query_validation(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):
         """
@@ -67,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
+        raise NotImplementedError
diff --git a/tom_dataservices/tests/tests.py b/tom_dataservices/tests/tests.py
@@ -1,18 +1,19 @@
+from abc import ABC
+
 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):
-    """ All brokers must have a form which will be used to construct and save queries
-    to the broker. They should subclass `BaseQueryForm` which includes some required
-    fields and contains logic for serializing and persisting the query parameters to the
-    database. This test form will only have one field.
+    """ 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)
 
@@ -25,27 +26,71 @@ 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 pre_query_validation(self, query_parameters):
-        pass
+    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 to_target(self, query_results):
-        target = super().to_target(query_results)
-        target.name = query_results['name']
-        target.type = query_results['type']
-        target.ra = query_results['ra']
-        target.dec = query_results['dec']
-        return target
+    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 TestDataService.
+    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):
-        target = TestDataService.to_target(self, test_query_results)
+        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)
