Repository: great-expectations/great_expectations

Issue:
Use cleaner solution for non-truncating division in python 2
Prefer `from __future__ import division` to `1.*x/y`


Discussion:
Done inline during improve_partitions push.

Resolving patch:
diff --git a/great_expectations/execution_engine/execution_engine.py b/great_expectations/execution_engine/execution_engine.py
--- a/great_expectations/execution_engine/execution_engine.py
+++ b/great_expectations/execution_engine/execution_engine.py
@@ -301,6 +301,20 @@ def resolve_metric_bundle(self, metric_fn_bundle):
         """Resolve a bundle of metrics with the same compute domain as part of a single trip to the compute engine."""
         raise NotImplementedError
 
+    def get_domain_records(
+        self,
+        domain_kwargs: dict,
+    ) -> Any:
+        """
+        get_domain_records computes the full-access data (dataframe or selectable) for computing metrics based on the
+        given domain_kwargs and specific engine semantics.
+
+        Returns:
+            data corresponding to the compute domain
+        """
+
+        raise NotImplementedError
+
     def get_compute_domain(
         self,
         domain_kwargs: dict,
diff --git a/great_expectations/execution_engine/pandas_execution_engine.py b/great_expectations/execution_engine/pandas_execution_engine.py
--- a/great_expectations/execution_engine/pandas_execution_engine.py
+++ b/great_expectations/execution_engine/pandas_execution_engine.py
@@ -276,35 +276,20 @@ def guess_reader_method_from_path(path):
             f'Unable to determine reader method from path: "{path}".'
         )
 
-    def get_compute_domain(
+    def get_domain_records(
         self,
         domain_kwargs: dict,
-        domain_type: Union[str, MetricDomainTypes],
-        accessor_keys: Optional[Iterable[str]] = None,
-    ) -> Tuple[pd.DataFrame, dict, dict]:
-        """Uses a given batch dictionary and domain kwargs (which include a row condition and a condition parser)
-        to obtain and/or query a batch. Returns in the format of a Pandas DataFrame. If the domain is a single column,
-        this is added to 'accessor domain kwargs' and used for later access
+    ) -> pd.DataFrame:
+        """
+        Uses the given domain kwargs (which include row_condition, condition_parser, and ignore_row_if directives) to
+        obtain and/or query a batch. Returns in the format of a Pandas DataFrame.
 
         Args:
             domain_kwargs (dict) - A dictionary consisting of the domain kwargs specifying which data to obtain
-            domain_type (str or MetricDomainTypes) - an Enum value indicating which metric domain the user would
-            like to be using, or a corresponding string value representing it. String types include "identity",
-            "column", "column_pair", "table" and "other". Enum types include capitalized versions of these from the
-            class MetricDomainTypes.
-            accessor_keys (str iterable) - keys that are part of the compute domain but should be ignored when
-            describing the domain and simply transferred with their associated values into accessor_domain_kwargs.
 
         Returns:
-            A tuple including:
-              - a DataFrame (the data on which to compute)
-              - a dictionary of compute_domain_kwargs, describing the DataFrame
-              - a dictionary of accessor_domain_kwargs, describing any accessors needed to
-                identify the domain within the compute domain
+            A DataFrame (the data on which to compute)
         """
-        # Extracting value from enum if it is given for future computation
-        domain_type = MetricDomainTypes(domain_type)
-
         batch_id = domain_kwargs.get("batch_id")
         if batch_id is None:
             # We allow no batch id specified if there is only one batch
@@ -322,7 +307,7 @@ class MetricDomainTypes.
                     f"Unable to find batch with batch_id {batch_id}"
                 )
 
-        # Filtering by row condition
+        # Filtering by row condition.
         row_condition = domain_kwargs.get("row_condition", None)
         if row_condition:
             condition_parser = domain_kwargs.get("condition_parser", None)
@@ -339,6 +324,95 @@ class MetricDomainTypes.
                     drop=True
                 )
 
+        if "column" in domain_kwargs:
+            return data
+
+        if "column_A" in domain_kwargs and "column_B" in domain_kwargs:
+            if "ignore_row_if" in domain_kwargs:
+                # noinspection PyPep8Naming
+                column_A_name = domain_kwargs["column_A"]
+                # noinspection PyPep8Naming
+                column_B_name = domain_kwargs["column_B"]
+
+                ignore_row_if = domain_kwargs["ignore_row_if"]
+                if ignore_row_if == "both_values_are_missing":
+                    data = data.dropna(
+                        axis=0,
+                        how="all",
+                        subset=[column_A_name, column_B_name],
+                    )
+                elif ignore_row_if == "either_value_is_missing":
+                    data = data.dropna(
+                        axis=0,
+                        how="any",
+                        subset=[column_A_name, column_B_name],
+                    )
+                else:
+                    if ignore_row_if != "never":
+                        raise ValueError(
+                            f'Unrecognized value of ignore_row_if ("{ignore_row_if}").'
+                        )
+
+                return data
+
+        if "column_list" in domain_kwargs:
+            if "ignore_row_if" in domain_kwargs:
+                ignore_row_if = domain_kwargs["ignore_row_if"]
+                if ignore_row_if == "all_values_are_missing":
+                    data = data.dropna(
+                        axis=0,
+                        how="all",
+                        subset=domain_kwargs["column_list"],
+                    )
+                elif ignore_row_if == "any_value_is_missing":
+                    data = data.dropna(
+                        axis=0,
+                        how="any",
+                        subset=domain_kwargs["column_list"],
+                    )
+                else:
+                    if ignore_row_if != "never":
+                        raise ValueError(
+                            f'Unrecognized value of ignore_row_if ("{ignore_row_if}").'
+                        )
+
+                return data
+
+        return data
+
+    def get_compute_domain(
+        self,
+        domain_kwargs: dict,
+        domain_type: Union[str, MetricDomainTypes],
+        accessor_keys: Optional[Iterable[str]] = None,
+    ) -> Tuple[pd.DataFrame, dict, dict]:
+        """
+        Uses the given domain kwargs (which include row_condition, condition_parser, and ignore_row_if directives) to
+        obtain and/or query a batch.  Returns in the format of a Pandas DataFrame. If the domain is a single column,
+        this is added to 'accessor domain kwargs' and used for later access
+
+        Args:
+            domain_kwargs (dict) - A dictionary consisting of the domain kwargs specifying which data to obtain
+            domain_type (str or MetricDomainTypes) - an Enum value indicating which metric domain the user would
+            like to be using, or a corresponding string value representing it. String types include "column",
+            "column_pair", "table", and "other".  Enum types include capitalized versions of these from the
+            class MetricDomainTypes.
+            accessor_keys (str iterable) - keys that are part of the compute domain but should be ignored when
+            describing the domain and simply transferred with their associated values into accessor_domain_kwargs.
+
+        Returns:
+            A tuple including:
+              - a DataFrame (the data on which to compute)
+              - a dictionary of compute_domain_kwargs, describing the DataFrame
+              - a dictionary of accessor_domain_kwargs, describing any accessors needed to
+                identify the domain within the compute domain
+        """
+        data = self.get_domain_records(
+            domain_kwargs=domain_kwargs,
+        )
+        # Extracting value from enum if it is given for future computation
+        domain_type = MetricDomainTypes(domain_type)
+
         compute_domain_kwargs = copy.deepcopy(domain_kwargs)
         accessor_domain_kwargs = dict()
         table = domain_kwargs.get("table", None)
@@ -394,112 +468,25 @@ class MetricDomainTypes.
 
         # Else, if column pair values requested
         elif domain_type == MetricDomainTypes.COLUMN_PAIR:
-            # Ensuring that the "column_A" and "column_B" parameters are provided.
-            if not (
-                "column_A" in compute_domain_kwargs
-                and "column_B" in compute_domain_kwargs
-            ):
+            if not ("column_A" in domain_kwargs and "column_B" in domain_kwargs):
                 raise ge_exceptions.GreatExpectationsError(
-                    "column_A or column_B not found within compute_domain_kwargs"
+                    "column_A or column_B not found within domain_kwargs"
                 )
 
             accessor_domain_kwargs["column_A"] = compute_domain_kwargs.pop("column_A")
             accessor_domain_kwargs["column_B"] = compute_domain_kwargs.pop("column_B")
 
-            if "ignore_row_if" in compute_domain_kwargs:
-                # noinspection PyPep8Naming
-                column_A_name = accessor_domain_kwargs["column_A"]
-                # noinspection PyPep8Naming
-                column_B_name = accessor_domain_kwargs["column_B"]
-
-                ignore_row_if = compute_domain_kwargs["ignore_row_if"]
-                if ignore_row_if == "both_values_are_missing":
-                    data = data.dropna(
-                        axis=0, how="all", subset=[column_A_name, column_B_name]
-                    )
-                elif ignore_row_if == "either_value_is_missing":
-                    data = data.dropna(
-                        axis=0, how="any", subset=[column_A_name, column_B_name]
-                    )
-                else:
-                    if ignore_row_if != "never":
-                        raise ValueError(
-                            f'Unrecognized value of ignore_row_if ("{ignore_row_if}").'
-                        )
-
         # Checking if table or identity or other provided, column is not specified. If it is, warning the user
         elif domain_type == MetricDomainTypes.MULTICOLUMN:
-            # Ensuring that the "column_list" parameter is provided.
-            if "column_list" not in compute_domain_kwargs:
+            if "column_list" not in domain_kwargs:
                 raise ge_exceptions.GreatExpectationsError(
-                    "column_list not found within compute_domain_kwargs"
+                    "column_list not found within domain_kwargs"
                 )
 
             accessor_domain_kwargs["column_list"] = compute_domain_kwargs.pop(
                 "column_list"
             )
 
-            if "ignore_row_if" in compute_domain_kwargs:
-                ignore_row_if = compute_domain_kwargs["ignore_row_if"]
-                if ignore_row_if == "all_values_are_missing":
-                    data = data.dropna(
-                        axis=0, how="all", subset=accessor_domain_kwargs["column_list"]
-                    )
-                elif ignore_row_if == "any_value_is_missing":
-                    data = data.dropna(
-                        axis=0, how="any", subset=accessor_domain_kwargs["column_list"]
-                    )
-                else:
-                    if ignore_row_if != "never":
-                        raise ValueError(
-                            f'Unrecognized value of ignore_row_if ("{ignore_row_if}").'
-                        )
-
-        # Filtering if identity
-        # TODO: <Alex>ALEX -- Add handling of "ignore_row_if" for COLUMN_PAIR domain_type and IDENTITY case.</Alex>
-        elif domain_type == MetricDomainTypes.IDENTITY:
-            # If we would like our data to become a single column
-            if "column" in compute_domain_kwargs:
-                data = pd.DataFrame(data[compute_domain_kwargs["column"]])
-
-            # If we would like our data to now become a column pair
-            elif ("column_A" in compute_domain_kwargs) and (
-                "column_B" in compute_domain_kwargs
-            ):
-
-                # TODO: <Alex>ALEX -- Remove the filtering of "data" in IDENTITY -- otherwise, unexpected_rows will not contain all columns.  (See multicolumn implementation below for guidance.)</Alex>
-                # Dropping all not needed columns
-                column_a, column_b = (
-                    compute_domain_kwargs["column_A"],
-                    compute_domain_kwargs["column_B"],
-                )
-                data = pd.DataFrame(
-                    {column_a: data[column_a], column_b: data[column_b]}
-                )
-
-            else:
-                # If we would like our data to become a multicolumn
-                if "column_list" in compute_domain_kwargs:
-                    if "ignore_row_if" in compute_domain_kwargs:
-                        ignore_row_if = compute_domain_kwargs["ignore_row_if"]
-                        if ignore_row_if == "all_values_are_missing":
-                            data = data.dropna(
-                                axis=0,
-                                how="all",
-                                subset=compute_domain_kwargs["column_list"],
-                            )
-                        elif ignore_row_if == "any_value_is_missing":
-                            data = data.dropna(
-                                axis=0,
-                                how="any",
-                                subset=compute_domain_kwargs["column_list"],
-                            )
-                        else:
-                            if ignore_row_if != "never":
-                                raise ValueError(
-                                    f'Unrecognized value of ignore_row_if ("{ignore_row_if}").'
-                                )
-
         return data, compute_domain_kwargs, accessor_domain_kwargs
 
     ### Splitter methods for partitioning dataframes ###
diff --git a/great_expectations/expectations/metrics/map_metric_provider.py b/great_expectations/expectations/metrics/map_metric_provider.py
--- a/great_expectations/expectations/metrics/map_metric_provider.py
+++ b/great_expectations/expectations/metrics/map_metric_provider.py
@@ -688,8 +688,8 @@ def _pandas_column_map_condition_values(
         compute_domain_kwargs,
         accessor_domain_kwargs,
     ) = metrics["unexpected_condition"]
-    df, _, _ = execution_engine.get_compute_domain(
-        domain_kwargs=compute_domain_kwargs, domain_type=MetricDomainTypes.IDENTITY
+    df = execution_engine.get_domain_records(
+        domain_kwargs=compute_domain_kwargs,
     )
 
     ###
@@ -745,14 +745,13 @@ def _pandas_multicolumn_map_condition_values(
         accessor_domain_kwargs,
     ) = metrics["unexpected_condition"]
     """
-    In order to invoke the "ignore_row_if" filtering logic, "execution_engine.get_compute_domain()", called with the
-    "domain_type=MetricDomainTypes.IDENTITY", must be supplied with all of the available "domain_kwargs" keys.
+    In order to invoke the "ignore_row_if" filtering logic, "execution_engine.get_domain_records()" must be supplied
+    with all of the available "domain_kwargs" keys.
     """
     domain_kwargs = copy.deepcopy(compute_domain_kwargs)
     domain_kwargs.update(accessor_domain_kwargs)
-    df, _, _ = execution_engine.get_compute_domain(
+    df = execution_engine.get_domain_records(
         domain_kwargs=domain_kwargs,
-        domain_type=MetricDomainTypes.IDENTITY,
     )
 
     if "column_list" not in accessor_domain_kwargs:
@@ -795,14 +794,13 @@ def _pandas_multicolumn_map_condition_filtered_row_count(
     """Return values from the specified domain that match the map-style metric in the metrics dictionary."""
     _, compute_domain_kwargs, accessor_domain_kwargs = metrics["unexpected_condition"]
     """
-    In order to invoke the "ignore_row_if" filtering logic, "execution_engine.get_compute_domain()", called with the
-    "domain_type=MetricDomainTypes.IDENTITY", must be supplied with all of the available "domain_kwargs" keys.
+    In order to invoke the "ignore_row_if" filtering logic, "execution_engine.get_domain_records()" must be supplied
+    with all of the available "domain_kwargs" keys.
     """
     domain_kwargs = copy.deepcopy(compute_domain_kwargs)
     domain_kwargs.update(accessor_domain_kwargs)
-    df, _, _ = execution_engine.get_compute_domain(
+    df = execution_engine.get_domain_records(
         domain_kwargs=domain_kwargs,
-        domain_type=MetricDomainTypes.IDENTITY,
     )
 
     if "column_list" not in accessor_domain_kwargs:
@@ -848,8 +846,8 @@ def _pandas_column_map_series_and_domain_values(
     assert (
         accessor_domain_kwargs == accessor_domain_kwargs_2
     ), "map_series and condition must have the same accessor kwargs"
-    df, _, _ = execution_engine.get_compute_domain(
-        domain_kwargs=compute_domain_kwargs, domain_type=MetricDomainTypes.IDENTITY
+    df = execution_engine.get_domain_records(
+        domain_kwargs=compute_domain_kwargs,
     )
 
     ###
@@ -911,14 +909,13 @@ def _pandas_map_condition_index(
         accessor_domain_kwargs,
     ) = metrics.get("unexpected_condition")
     """
-    In order to invoke the "ignore_row_if" filtering logic, "execution_engine.get_compute_domain()", called with the
-    "domain_type=MetricDomainTypes.IDENTITY", must be supplied with all of the available "domain_kwargs" keys.
+    In order to invoke the "ignore_row_if" filtering logic, "execution_engine.get_domain_records()" must be supplied
+    with all of the available "domain_kwargs" keys.
     """
     domain_kwargs = copy.deepcopy(compute_domain_kwargs)
     domain_kwargs.update(accessor_domain_kwargs)
-    df, _, _ = execution_engine.get_compute_domain(
+    df = execution_engine.get_domain_records(
         domain_kwargs=domain_kwargs,
-        domain_type=MetricDomainTypes.IDENTITY,
     )
 
     ###
@@ -974,8 +971,8 @@ def _pandas_column_map_condition_value_counts(
         compute_domain_kwargs,
         accessor_domain_kwargs,
     ) = metrics.get("unexpected_condition")
-    df, _, _ = execution_engine.get_compute_domain(
-        domain_kwargs=compute_domain_kwargs, domain_type=MetricDomainTypes.IDENTITY
+    df = execution_engine.get_domain_records(
+        domain_kwargs=compute_domain_kwargs,
     )
 
     ###
@@ -1044,14 +1041,13 @@ def _pandas_map_condition_rows(
         accessor_domain_kwargs,
     ) = metrics.get("unexpected_condition")
     """
-    In order to invoke the "ignore_row_if" filtering logic, "execution_engine.get_compute_domain()", called with the
-    "domain_type=MetricDomainTypes.IDENTITY", must be supplied with all of the available "domain_kwargs" keys.
+    In order to invoke the "ignore_row_if" filtering logic, "execution_engine.get_domain_records()" must be supplied
+    with all of the available "domain_kwargs" keys.
     """
     domain_kwargs = copy.deepcopy(compute_domain_kwargs)
     domain_kwargs.update(accessor_domain_kwargs)
-    df, _, _ = execution_engine.get_compute_domain(
+    df = execution_engine.get_domain_records(
         domain_kwargs=domain_kwargs,
-        domain_type=MetricDomainTypes.IDENTITY,
     )
 
     ###


Test patch:
diff --git a/tests/execution_engine/test_pandas_execution_engine.py b/tests/execution_engine/test_pandas_execution_engine.py
--- a/tests/execution_engine/test_pandas_execution_engine.py
+++ b/tests/execution_engine/test_pandas_execution_engine.py
@@ -53,6 +53,85 @@ def test_reader_fn():
     assert "<function" in str(fn_new)
 
 
+def test_get_domain_records_with_column_domain():
+    engine = PandasExecutionEngine()
+    df = pd.DataFrame(
+        {"a": [1, 2, 3, 4, 5], "b": [2, 3, 4, 5, None], "c": [1, 2, 3, 4, None]}
+    )
+    expected_column_df = df.iloc[:3]
+
+    # Loading batch data
+    engine.load_batch_data(batch_data=df, batch_id="1234")
+    data = engine.get_domain_records(
+        domain_kwargs={
+            "column": "a",
+            "row_condition": "b<5",
+            "condition_parser": "pandas",
+        }
+    )
+    assert data.equals(
+        expected_column_df
+    ), "Data does not match after getting full access compute domain"
+
+
+def test_get_domain_records_with_column_pair_domain():
+    engine = PandasExecutionEngine()
+    df = pd.DataFrame(
+        {
+            "a": [1, 2, 3, 4, 5, 6],
+            "b": [2, 3, 4, 5, None, 6],
+            "c": [1, 2, 3, 4, 5, None],
+        }
+    )
+    expected_column_pair_df = pd.DataFrame(
+        {"a": [2, 3, 4, 6], "b": [3.0, 4.0, 5.0, 6.0], "c": [2.0, 3.0, 4.0, None]}
+    )
+
+    # Loading batch data
+    engine.load_batch_data(batch_data=df, batch_id="1234")
+    data = engine.get_domain_records(
+        domain_kwargs={
+            "column_A": "a",
+            "column_B": "b",
+            "row_condition": "b>2",
+            "condition_parser": "pandas",
+            "ignore_row_if": "either_value_is_missing",
+        }
+    )
+    assert data.equals(
+        expected_column_pair_df
+    ), "Data does not match after getting full access compute domain"
+
+
+def test_get_domain_records_with_multicolumn_domain():
+    engine = PandasExecutionEngine()
+    df = pd.DataFrame(
+        {
+            "a": [1, 2, 3, 4, None, 5],
+            "b": [2, 3, 4, 5, 6, 7],
+            "c": [1, 2, 3, 4, None, 6],
+        }
+    )
+    expected_multicolumn_df = pd.DataFrame(
+        {"a": [2, 3, 4, 5], "b": [3, 4, 5, 7], "c": [2, 3, 4, 6]}, index=[0, 1, 2, 4]
+    )
+
+    # Loading batch data
+    engine.load_batch_data(batch_data=df, batch_id="1234")
+    data = engine.get_domain_records(
+        domain_kwargs={
+            "column_list": ["a", "c"],
+            "row_condition": "b>2",
+            "condition_parser": "pandas",
+            "ignore_row_if": "all_values_are_missing",
+        }
+    )
+    data = data.astype(int)
+    assert data.equals(
+        expected_multicolumn_df
+    ), "Data does not match after getting full access compute domain"
+
+
 def test_get_compute_domain_with_no_domain_kwargs():
     engine = PandasExecutionEngine()
     df = pd.DataFrame({"a": [1, 2, 3, 4], "b": [2, 3, 4, None]})
@@ -60,7 +139,7 @@ def test_get_compute_domain_with_no_domain_kwargs():
     # Loading batch data
     engine.load_batch_data(batch_data=df, batch_id="1234")
     data, compute_kwargs, accessor_kwargs = engine.get_compute_domain(
-        domain_kwargs={}, domain_type="identity"
+        domain_kwargs={}, domain_type="table"
     )
     assert data.equals(df), "Data does not match after getting compute domain"
     assert compute_kwargs == {}, "Compute domain kwargs should be existent"
@@ -78,7 +157,7 @@ def test_get_compute_domain_with_no_domain_kwargs():
 def test_get_compute_domain_with_column_pair_domain():
     engine = PandasExecutionEngine()
     df = pd.DataFrame({"a": [1, 2, 3, 4], "b": [2, 3, 4, 5], "c": [1, 2, 3, 4]})
-    expected_identity = df.drop(columns=["c"])
+    expected_column_pair_df = df.drop(columns=["c"])
 
     # Loading batch data
     engine.load_batch_data(batch_data=df, batch_id="1234")
@@ -92,20 +171,6 @@ def test_get_compute_domain_with_column_pair_domain():
         "column_B": "b",
     }, "Accessor kwargs have been modified"
 
-    # Trying same test with enum form of table domain - should work the same way
-    data, compute_kwargs, accessor_kwargs = engine.get_compute_domain(
-        domain_kwargs={"column_A": "a", "column_B": "b"}, domain_type="identity"
-    )
-
-    assert data.equals(
-        expected_identity
-    ), "Data does not match after getting compute domain"
-    assert compute_kwargs == {
-        "column_A": "a",
-        "column_B": "b",
-    }, "Compute domain kwargs should be existent"
-    assert accessor_kwargs == {}, "Accessor kwargs have been modified"
-
 
 def test_get_compute_domain_with_multicolumn_domain():
     engine = PandasExecutionEngine()
@@ -124,21 +189,10 @@ def test_get_compute_domain_with_multicolumn_domain():
         "column_list": ["a", "b", "c"]
     }, "Accessor kwargs have been modified"
 
-    # Trying same test with enum form of table domain - should work the same way
-    data, compute_kwargs, accessor_kwargs = engine.get_compute_domain(
-        domain_kwargs={"column_list": ["a", "b", "c"]}, domain_type="identity"
-    )
-    assert data.equals(df), "Data does not match after getting compute domain"
-    assert compute_kwargs == {
-        "column_list": ["a", "b", "c"]
-    }, "Compute domain kwargs should be existent"
-    assert accessor_kwargs == {}, "Accessor kwargs have been modified"
-
 
 def test_get_compute_domain_with_column_domain():
     engine = PandasExecutionEngine()
     df = pd.DataFrame({"a": [1, 2, 3, 4], "b": [2, 3, 4, None]})
-    expected_identity = df.drop(columns=["b"])
 
     # Loading batch data
     engine.load_batch_data(batch_data=df, batch_id="1234")
@@ -149,17 +203,6 @@ def test_get_compute_domain_with_column_domain():
     assert compute_kwargs == {}, "Compute domain kwargs should be existent"
     assert accessor_kwargs == {"column": "a"}, "Accessor kwargs have been modified"
 
-    # Doing this using identity domain should yield different results
-    data, compute_kwargs, accessor_kwargs = engine.get_compute_domain(
-        domain_kwargs={"column": "a"}, domain_type=MetricDomainTypes.IDENTITY
-    )
-
-    assert data.equals(
-        expected_identity
-    ), "Data does not match after getting compute domain"
-    assert compute_kwargs == {"column": "a"}, "Compute domain kwargs should be existent"
-    assert accessor_kwargs == {}, "Accessor kwargs have been modified"
-
 
 def test_get_compute_domain_with_row_condition():
     engine = PandasExecutionEngine()
@@ -196,10 +239,11 @@ def test_get_compute_domain_with_unmeetable_row_condition():
 
     data, compute_kwargs, accessor_kwargs = engine.get_compute_domain(
         domain_kwargs={
+            "column": "a",
             "row_condition": "b > 24",
             "condition_parser": "pandas",
         },
-        domain_type="identity",
+        domain_type="column",
     )
     # Ensuring data has been properly queried
     assert data["b"].equals(
@@ -210,7 +254,7 @@ def test_get_compute_domain_with_unmeetable_row_condition():
     assert (
         "row_condition" in compute_kwargs.keys()
     ), "Row condition should be located within compute kwargs"
-    assert accessor_kwargs == {}, "Accessor kwargs have been modified"
+    assert accessor_kwargs == {"column": "a"}, "Accessor kwargs have been modified"
 
 
 # Just checking that the Pandas Execution Engine can perform these in sequence