Merge pull request #533 from dcs4cop/forman-xxx-gen2_to_handle_int_errors

Forman xxx gen2 to handle int errors

Author: dzelge

test/cli/gen2-requests/internal-error.yml

@@ -0,0 +1,16 @@
+input_config:
+  store_id: file
+  store_params:
+    root: examples/serve/demo
+  data_id: cube-1-250-250.zarr
+  
+cube_config:
+  metadata:
+    inverse_fine_structure_constant: 138
+
+output_config:
+  store_id: file
+  store_params:
+    root: .
+  data_id: out.zarr
+  replace: true

test/cli/test_gen2.py

@@ -38,6 +38,7 @@ def test_copy_zarr_gen(self):
         self.assertIsNotNone(result)
         result_json = self.read_result_json()
         self.assertEqual('ok', result_json.get('status'))
+        self.assertEqual(201, result_json.get('status_code'))
         self.assertIsInstance(result_json.get('message'), str)
         self.assertIn('Cube generated successfully after ',
                       result_json.get('message'))
@@ -57,6 +58,7 @@ def test_copy_zarr_info(self):
         result_json = self.read_result_json()
 
         self.assertEqual('ok', result_json.get('status'))
+        self.assertEqual(200, result_json.get('status_code'))
         result = result_json.get('result')
         self.assertIsInstance(result, dict)
 
@@ -121,5 +123,22 @@ def test_copy_levels_gen(self):
         self.assertIsNotNone(result)
         result_json = self.read_result_json()
         self.assertEqual('ok', result_json.get('status'))
+        self.assertEqual(201, result_json.get('status_code'))
         self.assertEqual({'data_id': 'out.levels'}, result_json.get('result'))
         self.assertTrue(os.path.isdir(result_levels))
+
+    def test_internal_error(self):
+        request_file = os.path.join(os.path.dirname(__file__),
+                                    'gen2-requests', 'internal-error.yml')
+        result = self.invoke_cli(['gen2',
+                                  '-o', result_file,
+                                  request_file])
+        print(result.output)
+        self.assertIsNotNone(result)
+        result_json = self.read_result_json()
+        self.assertEqual('error', result_json.get('status'))
+        self.assertEqual(500, result_json.get('status_code'))
+        self.assertEqual('inverse_fine_structure_constant must be 137'
+                         ' or running in wrong universe',
+                         result_json.get('message'))
+        self.assertNotIn('result', result_json)

test/core/gen2/local/test_generator.py

@@ -1,3 +1,4 @@
+import copy
 import json
 import unittest
 from typing import Dict, Any
@@ -108,7 +109,7 @@ def assertGeneratedCubeOk(self, request):
     @requests_mock.Mocker()
     def test_generate_cube_from_yaml_empty(self, m):
         m.put(CALLBACK_MOCK_URL, json={})
-        request = self.REQUEST.copy()
+        request = copy.deepcopy(self.REQUEST)
         request['cube_config']['time_range'] = ['2019-01-01', '2020-01-01']
 
         generator = LocalCubeGenerator()
@@ -122,6 +123,21 @@ def test_generate_cube_from_yaml_empty(self, m):
         self.assertEqual(None, generator.generated_cube, xr.Dataset)
         self.assertEqual(None, generator.generated_gm)
 
+    @requests_mock.Mocker()
+    def test_generate_cube_with_internal_error(self, m):
+        m.put(CALLBACK_MOCK_URL, json={})
+        request = self.REQUEST.copy()
+        request['cube_config']['metadata'] = {
+            'inverse_fine_structure_constant': 138
+        }
+
+        generator = LocalCubeGenerator()
+        with self.assertRaises(ValueError) as cm:
+            generator.generate_cube(request)
+        self.assertEqual(('inverse_fine_structure_constant must be 137'
+                          ' or running in wrong universe',),
+                         cm.exception.args)
+
     @requests_mock.Mocker()
     def test_get_cube_info_from_dict(self, m):
         m.put(CALLBACK_MOCK_URL, json={})

test/core/gen2/local/test_mdadjuster.py

@@ -113,3 +113,18 @@ def test_metadata_adjusted_other_crs(self):
         self.assertAlmostEqual(0.001,
                                cube2.attrs.get('geospatial_lat_resolution'),
                                delta=0.0005)
+
+    def test_easter_egg(self):
+        cube = new_cube()
+        md_adjuster = CubeMetadataAdjuster()
+        with self.assertRaises(ValueError) as cm:
+            md_adjuster.transform_cube(
+                cube,
+                GridMapping.from_dataset(cube),
+                CubeConfig(metadata=dict(
+                    inverse_fine_structure_constant=136
+                ))
+            )
+        self.assertEqual(('inverse_fine_structure_constant must be 137'
+                          ' or running in wrong universe',),
+                         cm.exception.args)

test/core/gen2/remote/test_service.py

@@ -48,6 +48,8 @@ def setUpClass(cls):
 
     def test_service_byoa_inline_code(self):
         """
+        Assert the service can run BYOA with a inline code.
+
         This test sets up a generator request with an
         inline user-code configuration
         that will cause the generator to
@@ -62,6 +64,8 @@ def test_service_byoa_inline_code(self):
 
     def test_service_byoa_code_package(self):
         """
+        Assert the service can run BYOA with a code package.
+
         This test sets up a generator request with an
         packaged user-code configuration
         that will cause the generator to
@@ -218,7 +222,7 @@ def _test_service_byoa(self, inline_code: bool):
 
     def test_service_simple_copy(self):
         """
-        This test sets up a generator request that
+        Assert the service can copy.
 
         1. opens a dataset "DATASET-1.zarr" in store "@test"
         2. writes this dataset "OUTPUT.zarr" in store "@test"
@@ -253,7 +257,7 @@ def test_service_simple_copy(self):
 
     def test_service_empty_cube(self):
         """
-        This test asserts the service fails with a warning.
+        Assert the service returns an empty-cube warning.
         """
         if not self.server_running:
             return
@@ -293,7 +297,7 @@ def test_service_empty_cube(self):
 
     def test_service_invalid_request(self):
         """
-        This test asserts the service fails with a 400 status code.
+        Assert the service recognizes invalid requests.
         """
         if not self.server_running:
             return
@@ -326,3 +330,50 @@ def test_service_invalid_request(self):
                          ' does not exist in store',
                          result_dict.get('message'))
         self.assertEqual(None, result_dict.get('output'))
+
+    def test_service_internal_error(self):
+        """
+        Assert the service handles internal errors.
+        """
+
+        if not self.server_running:
+            return
+
+        generator = RemoteCubeGenerator(
+            service_config=ServiceConfig(endpoint_url=SERVER_URL)
+        )
+
+        request_dict = {
+            "input_configs": [
+                {
+                    'store_id': '@test',
+                    "data_id": "DATASET-1.zarr"
+                }
+            ],
+            "cube_config": {
+                "metadata": {
+                    # This raises a ValueError in "xcube gen2"
+                    'inverse_fine_structure_constant': 138
+                }
+            },
+            "output_config": {
+                "store_id": "@test",
+                "data_id": "OUTPUT.zarr",
+                "replace": True,
+            }
+        }
+
+        result = generator.generate_cube(request_dict)
+
+        result_dict = result.to_dict()
+        self.assertEqual('error', result_dict.get('status'))
+        self.assertEqual(400, result_dict.get('status_code'))
+        self.assertEqual(None, result_dict.get('result'))
+        self.assertEqual('inverse_fine_structure_constant must be 137'
+                         ' or running in wrong universe',
+                         result_dict.get('message'))
+        self.assertEqual(None, result_dict.get('output'))
+
+        # self.assertEqual(('inverse_fine_structure_constant must be 137'
+        #                   ' or running in wrong universe',),
+        #                  cm.exception.args)

xcube/cli/gen2.py

@@ -150,10 +150,14 @@ def gen2(request_path: str,
                       message=f'{error}',
                       traceback=traceback.format_tb(error.__traceback__))
         if isinstance(error, CubeGeneratorError):
-            if error.remote_output:
+            if error.status_code is not None:
+                result.update(status_code=error.status_code)
+            if error.remote_output is not None:
                 result.update(remote_output=error.remote_output)
-            if error.remote_traceback:
+            if error.remote_traceback is not None:
                 result.update(remote_traceback=error.remote_traceback)
+        if 'status_code' not in result:
+            result['status_code'] = 500
 
     if result.get('status') == 'error':
         result['versions'] = get_xcube_versions()

xcube/core/gen2/local/mdadjuster.py

@@ -61,13 +61,24 @@ def transform_cube(self,
             **get_geospatial_attrs(gm)
         )
         if cube_config.metadata:
+            self._check_for_self_destruction(cube_config.metadata)
             cube.attrs.update(cube_config.metadata)
         if cube_config.variable_metadata:
             for var_name, metadata in cube_config.variable_metadata.items():
                 if var_name in cube.variables and metadata:
                     cube[var_name].attrs.update(metadata)
         return cube, gm, cube_config
 
+    @staticmethod
+    def _check_for_self_destruction(metadata: Dict[str, Any]):
+        key = 'inverse_fine_structure_constant'
+        value = 137
+        if key in metadata and metadata[key] != value:
+            # Note, this is an easter egg that causes
+            # an intended internal error for testing
+            raise ValueError(f'{key} must be {value}'
+                             f' or running in wrong universe')
+
 
 def get_geospatial_attrs(gm: GridMapping) -> Dict[str, Any]:
     if gm.crs.is_geographic: