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/core/expectation_configuration.py b/great_expectations/core/expectation_configuration.py
--- a/great_expectations/core/expectation_configuration.py
+++ b/great_expectations/core/expectation_configuration.py
@@ -903,7 +903,14 @@ class ExpectationConfiguration(SerializableDictDot):
 
     runtime_kwargs = ["result_format", "include_config", "catch_exceptions"]
 
-    def __init__(self, expectation_type, kwargs, meta=None, success_on_last_run=None):
+    def __init__(
+        self,
+        expectation_type,
+        kwargs,
+        meta=None,
+        success_on_last_run=None,
+        ge_cloud_id=None,
+    ):
         if not isinstance(expectation_type, str):
             raise InvalidExpectationConfigurationError(
                 "expectation_type must be a string"
@@ -921,6 +928,7 @@ def __init__(self, expectation_type, kwargs, meta=None, success_on_last_run=None
         ensure_json_serializable(meta)
         self.meta = meta
         self.success_on_last_run = success_on_last_run
+        self._ge_cloud_id = ge_cloud_id
 
     def process_evaluation_parameters(
         self, evaluation_parameters, interactive_evaluation=True, data_context=None
@@ -982,6 +990,14 @@ def patch(self, op: str, path: str, value: Any) -> "ExpectationConfiguration":
         patch.apply(self.kwargs, in_place=True)
         return self
 
+    @property
+    def ge_cloud_id(self):
+        return self._ge_cloud_id
+
+    @ge_cloud_id.setter
+    def ge_cloud_id(self, value):
+        self._ge_cloud_id = value
+
     @property
     def expectation_type(self):
         return self._expectation_type
@@ -1289,6 +1305,7 @@ class ExpectationConfigurationSchema(Schema):
     )
     kwargs = fields.Dict()
     meta = fields.Dict()
+    ge_cloud_id = fields.UUID(required=False, allow_none=True)
 
     # noinspection PyUnusedLocal
     @post_load
diff --git a/great_expectations/core/expectation_suite.py b/great_expectations/core/expectation_suite.py
--- a/great_expectations/core/expectation_suite.py
+++ b/great_expectations/core/expectation_suite.py
@@ -1,6 +1,7 @@
 import datetime
 import json
 import logging
+import uuid
 from copy import deepcopy
 from typing import Any, Dict, List, Optional, Union
 
@@ -12,6 +13,7 @@
 from great_expectations.core.expectation_configuration import (
     ExpectationConfiguration,
     ExpectationConfigurationSchema,
+    expectationConfigurationSchema,
 )
 from great_expectations.core.util import (
     convert_to_json_serializable,
@@ -263,15 +265,16 @@ def append_expectation(self, expectation_config):
 
     def remove_expectation(
         self,
-        expectation_configuration: ExpectationConfiguration,
+        expectation_configuration: Optional[ExpectationConfiguration] = None,
         match_type: str = "domain",
         remove_multiple_matches: bool = False,
+        ge_cloud_id: Optional[Union[str, uuid.UUID]] = None,
     ) -> List[ExpectationConfiguration]:
         """
 
         Args:
             expectation_configuration: A potentially incomplete (partial) Expectation Configuration to match against for
-                for the removal of expectations.
+                the removal of expectations.
             match_type: This determines what kwargs to use when matching. Options are 'domain' to match based
                 on the data evaluated by that expectation, 'success' to match based on all configuration parameters
                  that influence whether an expectation succeeds based on a given batch of data, and 'runtime' to match
@@ -283,8 +286,15 @@ def remove_expectation(
             No match
             More than 1 match, if remove_multiple_matches = False
         """
+        if expectation_configuration is None and ge_cloud_id is None:
+            raise TypeError(
+                "Must provide either expectation_configuration or ge_cloud_id"
+            )
+
         found_expectation_indexes = self.find_expectation_indexes(
-            expectation_configuration, match_type
+            expectation_configuration=expectation_configuration,
+            match_type=match_type,
+            ge_cloud_id=ge_cloud_id,
         )
         if len(found_expectation_indexes) < 1:
             raise ValueError("No matching expectation was found.")
@@ -324,10 +334,14 @@ def remove_all_expectations_of_type(
 
     def find_expectation_indexes(
         self,
-        expectation_configuration: ExpectationConfiguration,
+        expectation_configuration: Optional[ExpectationConfiguration] = None,
         match_type: str = "domain",
+        ge_cloud_id: str = None,
     ) -> List[int]:
         """
+        Find indexes of Expectations matching the given ExpectationConfiguration on the given match_type.
+        If a ge_cloud_id is provided, match_type is ignored and only indexes of Expectations
+        with matching ge_cloud_id are returned.
 
         Args:
             expectation_configuration: A potentially incomplete (partial) Expectation Configuration to match against to
@@ -336,6 +350,7 @@ def find_expectation_indexes(
                 on the data evaluated by that expectation, 'success' to match based on all configuration parameters
                  that influence whether an expectation succeeds based on a given batch of data, and 'runtime' to match
                  based on all configuration parameters
+            ge_cloud_id: Great Expectations Cloud id
 
         Returns: A list of indexes of matching ExpectationConfiguration
 
@@ -343,34 +358,108 @@ def find_expectation_indexes(
             InvalidExpectationConfigurationError
 
         """
-        if not isinstance(expectation_configuration, ExpectationConfiguration):
+        if expectation_configuration is None and ge_cloud_id is None:
+            raise TypeError(
+                "Must provide either expectation_configuration or ge_cloud_id"
+            )
+        if expectation_configuration and not isinstance(
+            expectation_configuration, ExpectationConfiguration
+        ):
             raise InvalidExpectationConfigurationError(
                 "Ensure that expectation configuration is valid."
             )
         match_indexes = []
         for idx, expectation in enumerate(self.expectations):
-            if expectation.isEquivalentTo(expectation_configuration, match_type):
-                match_indexes.append(idx)
+            if ge_cloud_id is not None:
+                if str(expectation.ge_cloud_id) == str(ge_cloud_id):
+                    match_indexes.append(idx)
+            else:
+                if expectation.isEquivalentTo(expectation_configuration, match_type):
+                    match_indexes.append(idx)
 
         return match_indexes
 
     def find_expectations(
         self,
-        expectation_configuration: ExpectationConfiguration,
+        expectation_configuration: Optional[ExpectationConfiguration] = None,
         match_type: str = "domain",
+        ge_cloud_id: Optional[str] = None,
     ) -> List[ExpectationConfiguration]:
+        """
+        Find Expectations matching the given ExpectationConfiguration on the given match_type.
+        If a ge_cloud_id is provided, match_type is ignored and only Expectations with matching
+        ge_cloud_id are returned.
+
+        Args:
+            expectation_configuration: A potentially incomplete (partial) Expectation Configuration to match against to
+                find the index of any matching Expectation Configurations on the suite.
+            match_type: This determines what kwargs to use when matching. Options are 'domain' to match based
+                on the data evaluated by that expectation, 'success' to match based on all configuration parameters
+                 that influence whether an expectation succeeds based on a given batch of data, and 'runtime' to match
+                 based on all configuration parameters
+            ge_cloud_id: Great Expectations Cloud id
+
+        Returns: A list of matching ExpectationConfigurations
+        """
+
+        if expectation_configuration is None and ge_cloud_id is None:
+            raise TypeError(
+                "Must provide either expectation_configuration or ge_cloud_id"
+            )
         found_expectation_indexes = self.find_expectation_indexes(
-            expectation_configuration, match_type
+            expectation_configuration, match_type, ge_cloud_id
         )
         if len(found_expectation_indexes) > 0:
-            return [
-                expectation
-                for idx, expectation in enumerate(self.expectations)
-                if idx in found_expectation_indexes
-            ]
+            return [self.expectations[idx] for idx in found_expectation_indexes]
         else:
             return []
 
+    def replace_expectation(
+        self,
+        new_expectation_configuration: Union[ExpectationConfiguration, dict],
+        existing_expectation_configuration: Optional[ExpectationConfiguration] = None,
+        match_type: str = "domain",
+        ge_cloud_id: Optional[str] = None,
+    ):
+        """
+        Find Expectations matching the given ExpectationConfiguration on the given match_type.
+        If a ge_cloud_id is provided, match_type is ignored and only Expectations with matching
+        ge_cloud_id are returned.
+
+        Args:
+            expectation_configuration: A potentially incomplete (partial) Expectation Configuration to match against to
+                find the index of any matching Expectation Configurations on the suite.
+            match_type: This determines what kwargs to use when matching. Options are 'domain' to match based
+                on the data evaluated by that expectation, 'success' to match based on all configuration parameters
+                 that influence whether an expectation succeeds based on a given batch of data, and 'runtime' to match
+                 based on all configuration parameters
+            ge_cloud_id: Great Expectations Cloud id
+
+        Returns: A list of matching ExpectationConfigurations
+        """
+        if existing_expectation_configuration is None and ge_cloud_id is None:
+            raise TypeError(
+                "Must provide either existing_expectation_configuration or ge_cloud_id"
+            )
+
+        if isinstance(new_expectation_configuration, dict):
+            new_expectation_configuration = expectationConfigurationSchema.load(
+                new_expectation_configuration
+            )
+
+        found_expectation_indexes = self.find_expectation_indexes(
+            existing_expectation_configuration, match_type, ge_cloud_id
+        )
+        if len(found_expectation_indexes) > 1:
+            raise ValueError(
+                "More than one matching expectation was found. Please be more specific with your search "
+                "criteria"
+            )
+        elif len(found_expectation_indexes) == 0:
+            raise ValueError("No matching Expectation was found.")
+
+        self.expectations[found_expectation_indexes[0]] = new_expectation_configuration
+
     def patch_expectation(
         self,
         expectation_configuration: ExpectationConfiguration,
diff --git a/great_expectations/core/util.py b/great_expectations/core/util.py
--- a/great_expectations/core/util.py
+++ b/great_expectations/core/util.py
@@ -69,23 +69,37 @@
 
 
 def nested_update(
-    d: Union[Iterable, dict], u: Union[Iterable, dict], dedup: bool = False
+    d: Union[Iterable, dict],
+    u: Union[Iterable, dict],
+    dedup: bool = False,
+    concat_lists: bool = True,
 ):
-    """update d with items from u, recursively and joining elements"""
+    """
+    Update d with items from u, recursively and joining elements. By default, list values are
+    concatenated without de-duplication. If concat_lists is set to False, lists in u (new dict)
+    will replace those in d (base dict).
+    """
     for k, v in u.items():
         if isinstance(v, Mapping):
             d[k] = nested_update(d.get(k, {}), v, dedup=dedup)
         elif isinstance(v, set) or (k in d and isinstance(d[k], set)):
             s1 = d.get(k, set())
             s2 = v or set()
-            d[k] = s1 | s2
+
+            if concat_lists:
+                d[k] = s1 | s2
+            else:
+                d[k] = s2
         elif isinstance(v, list) or (k in d and isinstance(d[k], list)):
             l1 = d.get(k, [])
             l2 = v or []
-            if dedup:
-                d[k] = list(set(l1 + l2))
+            if concat_lists:
+                if dedup:
+                    d[k] = list(set(l1 + l2))
+                else:
+                    d[k] = l1 + l2
             else:
-                d[k] = l1 + l2
+                d[k] = l2
         else:
             d[k] = v
     return d


Test patch:
diff --git a/tests/core/test_expectation_suite_crud_methods.py b/tests/core/test_expectation_suite_crud_methods.py
--- a/tests/core/test_expectation_suite_crud_methods.py
+++ b/tests/core/test_expectation_suite_crud_methods.py
@@ -215,6 +215,24 @@ def suite_with_column_pair_and_table_expectations(
     return suite
 
 
+@pytest.fixture
+def ge_cloud_id():
+    # Fake id but adheres to the format required of a UUID
+    return "731ee1bd-604a-4851-9ee8-bca8ffb32bce"
+
+
+@pytest.fixture
+def ge_cloud_suite(ge_cloud_id, exp1, exp2, exp3):
+    for exp in (exp1, exp2, exp3):
+        exp.ge_cloud_id = ge_cloud_id
+    return ExpectationSuite(
+        expectation_suite_name="warning",
+        expectations=[exp1, exp2, exp3],
+        meta={"notes": "This is an expectation suite."},
+        ge_cloud_id=ge_cloud_id,
+    )
+
+
 def test_find_expectation_indexes_on_empty_suite(exp1, empty_suite):
     assert empty_suite.find_expectation_indexes(exp1, "domain") == []
 
@@ -247,6 +265,34 @@ def test_find_expectation_indexes(
         )
 
 
+def test_find_expectation_indexes_with_ge_cloud_suite(ge_cloud_suite, ge_cloud_id):
+    # All expectations in `ge_cloud_suite` have our desired id
+    res = ge_cloud_suite.find_expectation_indexes(ge_cloud_id=ge_cloud_id)
+    assert res == [0, 1, 2]
+
+    # Wrong `ge_cloud_id` will fail to match with any expectations
+    res = ge_cloud_suite.find_expectation_indexes(ge_cloud_id="my_fake_id")
+    assert res == []
+
+
+def test_find_expectation_indexes_without_necessary_args(ge_cloud_suite):
+    with pytest.raises(TypeError) as err:
+        ge_cloud_suite.find_expectation_indexes(
+            expectation_configuration=None, ge_cloud_id=None
+        )
+    assert (
+        str(err.value) == "Must provide either expectation_configuration or ge_cloud_id"
+    )
+
+
+def test_find_expectation_indexes_with_invalid_config_raises_error(ge_cloud_suite):
+    with pytest.raises(InvalidExpectationConfigurationError) as err:
+        ge_cloud_suite.find_expectation_indexes(
+            expectation_configuration={"foo": "bar"}
+        )
+    assert str(err.value) == "Ensure that expectation configuration is valid."
+
+
 def test_find_expectations(
     exp1, exp2, exp3, exp4, exp5, domain_success_runtime_suite, single_expectation_suite
 ):
@@ -278,6 +324,16 @@ def test_find_expectations(
     )
 
 
+def test_find_expectations_without_necessary_args(ge_cloud_suite):
+    with pytest.raises(TypeError) as err:
+        ge_cloud_suite.find_expectations(
+            expectation_configuration=None, ge_cloud_id=None
+        )
+    assert (
+        str(err.value) == "Must provide either expectation_configuration or ge_cloud_id"
+    )
+
+
 def test_remove_expectation(
     exp1, exp2, exp3, exp4, exp5, single_expectation_suite, domain_success_runtime_suite
 ):
@@ -315,6 +371,16 @@ def test_remove_expectation(
     assert domain_success_runtime_suite.isEquivalentTo(single_expectation_suite)
 
 
+def test_remove_expectation_without_necessary_args(single_expectation_suite):
+    with pytest.raises(TypeError) as err:
+        single_expectation_suite.remove_expectation(
+            expectation_configuration=None, ge_cloud_id=None
+        )
+    assert (
+        str(err.value) == "Must provide either expectation_configuration or ge_cloud_id"
+    )
+
+
 def test_patch_expectation_replace(exp5, exp6, domain_success_runtime_suite):
     assert domain_success_runtime_suite.expectations[4] is exp5
 
@@ -428,3 +494,74 @@ def test_remove_all_expectations_of_type(
     assert suite_with_table_and_column_expectations.isEquivalentTo(
         suite_with_column_pair_and_table_expectations
     )
+
+
+def test_replace_expectation_replaces_expectation(ge_cloud_suite, ge_cloud_id, exp1):
+    # The state of the first expectation before update
+    expectation_before_update = ge_cloud_suite.expectations[0]
+    assert expectation_before_update["kwargs"]["column"] == "a"
+    assert expectation_before_update["kwargs"]["value_set"] == [1, 2, 3]
+    assert expectation_before_update["meta"]["notes"] == "This is an expectation."
+
+    new_expectation_configuration = ExpectationConfiguration(
+        expectation_type="expect_column_values_to_be_in_set",
+        kwargs={"column": "b", "value_set": [4, 5, 6], "result_format": "BASIC"},
+        meta={"notes": "This is an updated expectation."},
+        ge_cloud_id=ge_cloud_id,
+    )
+    ge_cloud_suite.replace_expectation(
+        new_expectation_configuration=new_expectation_configuration,
+        existing_expectation_configuration=exp1,
+    )
+
+    # The state of the first expectation after update
+    expectation_after_update = ge_cloud_suite.expectations[0]
+    assert expectation_after_update["kwargs"]["column"] == "b"
+    assert expectation_after_update["kwargs"]["value_set"] == [4, 5, 6]
+    assert (
+        expectation_after_update["meta"]["notes"] == "This is an updated expectation."
+    )
+
+
+def test_replace_expectation_without_necessary_args(ge_cloud_suite):
+    with pytest.raises(TypeError) as err:
+        ge_cloud_suite.replace_expectation(
+            new_expectation_configuration={},
+            existing_expectation_configuration=None,
+            ge_cloud_id=None,
+        )
+    assert (
+        str(err.value)
+        == "Must provide either existing_expectation_configuration or ge_cloud_id"
+    )
+
+
+def test_replace_expectation_finds_too_many_matches(ge_cloud_suite, exp1, ge_cloud_id):
+    new_expectation_configuration = ExpectationConfiguration(
+        expectation_type="expect_column_values_to_be_in_set",
+        kwargs={"column": "b", "value_set": [4, 5, 6], "result_format": "BASIC"},
+        meta={"notes": "This is a new expectation."},
+    )
+    with pytest.raises(ValueError) as err:
+        ge_cloud_suite.replace_expectation(
+            new_expectation_configuration=new_expectation_configuration,
+            existing_expectation_configuration=None,
+            ge_cloud_id=ge_cloud_id,
+        )
+    assert (
+        str(err.value)
+        == "More than one matching expectation was found. Please be more specific with your search criteria"
+    )
+
+
+def test_replace_expectation_finds_no_matches(ge_cloud_suite, ge_cloud_id, exp4):
+    with pytest.raises(ValueError) as err:
+        ge_cloud_suite.replace_expectation(
+            new_expectation_configuration=exp4,
+            existing_expectation_configuration=None,
+            ge_cloud_id=ge_cloud_id,
+        )
+    assert (
+        str(err.value)
+        == "More than one matching expectation was found. Please be more specific with your search criteria"
+    )
diff --git a/tests/profile/test_jsonschema_profiler.py b/tests/profile/test_jsonschema_profiler.py
--- a/tests/profile/test_jsonschema_profiler.py
+++ b/tests/profile/test_jsonschema_profiler.py
@@ -289,6 +289,7 @@ def test_profile_simple_schema(empty_data_context, simple_schema):
             "kwargs": {"column": "first_name"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -297,16 +298,19 @@ def test_profile_simple_schema(empty_data_context, simple_schema):
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "first_name"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "age"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -315,11 +319,13 @@ def test_profile_simple_schema(empty_data_context, simple_schema):
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "age"},
             "meta": {},
+            "ge_cloud_id": None,
         },
     ]
     context = empty_data_context
@@ -336,6 +342,7 @@ def test_profile_boolean_schema(empty_data_context, boolean_types_schema):
             "meta": {},
             "kwargs": {"column": "active"},
             "expectation_type": "expect_column_to_exist",
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -344,21 +351,25 @@ def test_profile_boolean_schema(empty_data_context, boolean_types_schema):
                 "type_list": list(ProfilerTypeMapping.BOOLEAN_TYPE_NAMES),
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "kwargs": {"column": "active", "value_set": [True, False]},
             "expectation_type": "expect_column_values_to_be_in_set",
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "active"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "kwargs": {"column": "optional"},
             "expectation_type": "expect_column_to_exist",
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -367,11 +378,13 @@ def test_profile_boolean_schema(empty_data_context, boolean_types_schema):
                 "type_list": list(ProfilerTypeMapping.BOOLEAN_TYPE_NAMES),
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "kwargs": {"column": "optional", "value_set": [True, False]},
             "expectation_type": "expect_column_values_to_be_in_set",
+            "ge_cloud_id": None,
         },
     ]
     context = empty_data_context
@@ -388,6 +401,7 @@ def test_profile_enum_schema(empty_data_context, enum_types_schema):
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "shirt-size"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -396,16 +410,19 @@ def test_profile_enum_schema(empty_data_context, enum_types_schema):
                 "column": "shirt-size",
                 "value_set": ["XS", "S", "M", "XL", "XXL"],
             },
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "shirt-size"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "optional-color"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -414,11 +431,13 @@ def test_profile_enum_schema(empty_data_context, enum_types_schema):
                 "column": "optional-color",
                 "value_set": ["red", "green", "blue"],
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "optional-hat"},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -427,6 +446,7 @@ def test_profile_enum_schema(empty_data_context, enum_types_schema):
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -435,11 +455,13 @@ def test_profile_enum_schema(empty_data_context, enum_types_schema):
                 "column": "optional-hat",
                 "value_set": ["red", "green", "blue"],
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "optional-answer"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -448,6 +470,7 @@ def test_profile_enum_schema(empty_data_context, enum_types_schema):
                 "column": "optional-answer",
                 "value_set": ["yes", "no"],
             },
+            "ge_cloud_id": None,
         },
     ]
     context = empty_data_context
@@ -464,6 +487,7 @@ def test_profile_string_lengths_schema(empty_data_context, string_lengths_schema
             "kwargs": {"column": "comments-no-constraints"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -472,16 +496,19 @@ def test_profile_string_lengths_schema(empty_data_context, string_lengths_schema
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "comments-no-constraints"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "state-abbreviation-equal-min-max"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -490,21 +517,25 @@ def test_profile_string_lengths_schema(empty_data_context, string_lengths_schema
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "state-abbreviation-equal-min-max", "value": 2},
             "expectation_type": "expect_column_value_lengths_to_equal",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "state-abbreviation-equal-min-max"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "ICD10-code-3-7"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -513,21 +544,25 @@ def test_profile_string_lengths_schema(empty_data_context, string_lengths_schema
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "ICD10-code-3-7", "min_value": 3, "max_value": 7},
             "expectation_type": "expect_column_value_lengths_to_be_between",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "ICD10-code-3-7"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "name-no-max"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -536,21 +571,25 @@ def test_profile_string_lengths_schema(empty_data_context, string_lengths_schema
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "name-no-max", "min_value": 1},
             "expectation_type": "expect_column_value_lengths_to_be_between",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "name-no-max"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "password-max-33"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -559,21 +598,25 @@ def test_profile_string_lengths_schema(empty_data_context, string_lengths_schema
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "password-max-33", "max_value": 33},
             "expectation_type": "expect_column_value_lengths_to_be_between",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "password-max-33"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "optional-min-1"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -582,11 +625,13 @@ def test_profile_string_lengths_schema(empty_data_context, string_lengths_schema
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "optional-min-1", "min_value": 1},
             "expectation_type": "expect_column_value_lengths_to_be_between",
             "meta": {},
+            "ge_cloud_id": None,
         },
     ]
     context = empty_data_context
@@ -603,6 +648,7 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "favorite-number"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -611,16 +657,19 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
                 "column": "favorite-number",
                 "type_list": list(ProfilerTypeMapping.INT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "favorite-number"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "age-0-130"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -629,21 +678,25 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
                 "column": "age-0-130",
                 "type_list": list(ProfilerTypeMapping.INT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_values_to_be_between",
             "kwargs": {"column": "age-0-130", "min_value": 0, "max_value": 130},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "age-0-130"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "wheel-count-0-plus"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -652,21 +705,25 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
                 "column": "wheel-count-0-plus",
                 "type_list": list(ProfilerTypeMapping.INT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_values_to_be_between",
             "kwargs": {"column": "wheel-count-0-plus", "min_value": 0},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "wheel-count-0-plus"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "rpm-max-7000"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -675,21 +732,25 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
                 "column": "rpm-max-7000",
                 "type_list": list(ProfilerTypeMapping.INT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_values_to_be_between",
             "kwargs": {"column": "rpm-max-7000", "max_value": 7000},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "rpm-max-7000"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "lake-depth-max-minus-100"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -698,21 +759,25 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
                 "column": "lake-depth-max-minus-100",
                 "type_list": list(ProfilerTypeMapping.INT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_values_to_be_between",
             "kwargs": {"column": "lake-depth-max-minus-100", "max_value": -100},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "lake-depth-max-minus-100"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "floor-exclusive-min-0"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -721,6 +786,7 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
                 "column": "floor-exclusive-min-0",
                 "type_list": list(ProfilerTypeMapping.INT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -730,16 +796,19 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
                 "min_value": 0,
                 "strict_min": True,
             },
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "floor-exclusive-min-0"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "floor-exclusive-max-100"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -748,6 +817,7 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
                 "column": "floor-exclusive-max-100",
                 "type_list": list(ProfilerTypeMapping.INT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -757,16 +827,19 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
                 "max_value": 100,
                 "strict_max": True,
             },
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "floor-exclusive-max-100"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "gear-exclusive-0-6"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -775,6 +848,7 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -786,16 +860,19 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
             },
             "expectation_type": "expect_column_values_to_be_between",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "gear-exclusive-0-6"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "optional-min-1"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -804,6 +881,7 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -812,6 +890,7 @@ def test_profile_integer_ranges_schema(empty_data_context, integer_ranges_schema
             },
             "expectation_type": "expect_column_values_to_be_between",
             "meta": {},
+            "ge_cloud_id": None,
         },
     ]
     context = empty_data_context
@@ -828,6 +907,7 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "favorite-number"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -836,16 +916,19 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
                 "column": "favorite-number",
                 "type_list": list(ProfilerTypeMapping.FLOAT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "favorite-number"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "age-0-130"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -854,21 +937,25 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
                 "column": "age-0-130",
                 "type_list": list(ProfilerTypeMapping.FLOAT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_values_to_be_between",
             "kwargs": {"column": "age-0-130", "min_value": 0.5, "max_value": 130.5},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "age-0-130"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "wheel-count-0-plus"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -877,21 +964,25 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
                 "column": "wheel-count-0-plus",
                 "type_list": list(ProfilerTypeMapping.FLOAT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_values_to_be_between",
             "kwargs": {"column": "wheel-count-0-plus", "min_value": 0.5},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "wheel-count-0-plus"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "rpm-max-7000"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -900,21 +991,25 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
                 "column": "rpm-max-7000",
                 "type_list": list(ProfilerTypeMapping.FLOAT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_values_to_be_between",
             "kwargs": {"column": "rpm-max-7000", "max_value": 7000.5},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "rpm-max-7000"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "lake-depth-max-minus-100"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -923,21 +1018,25 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
                 "column": "lake-depth-max-minus-100",
                 "type_list": list(ProfilerTypeMapping.FLOAT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_values_to_be_between",
             "kwargs": {"column": "lake-depth-max-minus-100", "max_value": -100.5},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "lake-depth-max-minus-100"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "floor-exclusive-min-0"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -946,6 +1045,7 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
                 "column": "floor-exclusive-min-0",
                 "type_list": list(ProfilerTypeMapping.FLOAT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -955,16 +1055,19 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
                 "min_value": 0.5,
                 "strict_min": True,
             },
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "floor-exclusive-min-0"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "floor-exclusive-max-100"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -973,6 +1076,7 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
                 "column": "floor-exclusive-max-100",
                 "type_list": list(ProfilerTypeMapping.FLOAT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -982,16 +1086,19 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
                 "max_value": 100.5,
                 "strict_max": True,
             },
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "floor-exclusive-max-100"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "gear-exclusive-0-6"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -1000,6 +1107,7 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -1011,16 +1119,19 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
             },
             "expectation_type": "expect_column_values_to_be_between",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "gear-exclusive-0-6"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {"column": "optional-min-half"},
             "expectation_type": "expect_column_to_exist",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -1029,6 +1140,7 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
             },
             "expectation_type": "expect_column_values_to_be_in_type_list",
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "kwargs": {
@@ -1037,6 +1149,7 @@ def test_profile_number_ranges_schema(empty_data_context, number_ranges_schema):
             },
             "expectation_type": "expect_column_values_to_be_between",
             "meta": {},
+            "ge_cloud_id": None,
         },
     ]
     context = empty_data_context
@@ -1060,6 +1173,7 @@ def test_has_profile_create_expectations_from_complex_schema(
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "post-office-box"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_be_in_type_list",
@@ -1068,16 +1182,19 @@ def test_has_profile_create_expectations_from_complex_schema(
                 "type_list": list(ProfilerTypeMapping.STRING_TYPE_NAMES),
             },
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "post-office-box"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "street-name"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_be_in_type_list",
@@ -1086,11 +1203,13 @@ def test_has_profile_create_expectations_from_complex_schema(
                 "type_list": list(ProfilerTypeMapping.STRING_TYPE_NAMES),
             },
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "street-name"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_to_exist",
@@ -1101,6 +1220,7 @@ def test_has_profile_create_expectations_from_complex_schema(
                     "content": ["### Description:\nOnly the address number."],
                 }
             },
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_be_in_type_list",
@@ -1109,16 +1229,19 @@ def test_has_profile_create_expectations_from_complex_schema(
                 "type_list": list(ProfilerTypeMapping.INT_TYPE_NAMES),
             },
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "street-number"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "locality"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_be_in_type_list",
@@ -1127,16 +1250,19 @@ def test_has_profile_create_expectations_from_complex_schema(
                 "type_list": list(ProfilerTypeMapping.STRING_TYPE_NAMES),
             },
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "locality"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "region"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_be_in_type_list",
@@ -1145,16 +1271,19 @@ def test_has_profile_create_expectations_from_complex_schema(
                 "type_list": list(ProfilerTypeMapping.STRING_TYPE_NAMES),
             },
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "region"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "postal-code"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_be_in_type_list",
@@ -1163,16 +1292,19 @@ def test_has_profile_create_expectations_from_complex_schema(
                 "type_list": list(ProfilerTypeMapping.STRING_TYPE_NAMES),
             },
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "postal-code"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "country-name"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_be_in_type_list",
@@ -1181,11 +1313,13 @@ def test_has_profile_create_expectations_from_complex_schema(
                 "type_list": list(ProfilerTypeMapping.STRING_TYPE_NAMES),
             },
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_not_be_null",
             "kwargs": {"column": "country-name"},
             "meta": {},
+            "ge_cloud_id": None,
         },
     ]
     context = empty_data_context
@@ -1202,16 +1336,19 @@ def test_null_fields_schema(empty_data_context, null_fields_schema):
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "null"},
+            "ge_cloud_id": None,
         },
         {
             "expectation_type": "expect_column_values_to_be_null",
             "kwargs": {"column": "null"},
             "meta": {},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "string-or-null"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -1220,11 +1357,13 @@ def test_null_fields_schema(empty_data_context, null_fields_schema):
                 "column": "string-or-null",
                 "type_list": list(ProfilerTypeMapping.STRING_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "int-or-null"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -1233,11 +1372,13 @@ def test_null_fields_schema(empty_data_context, null_fields_schema):
                 "column": "int-or-null",
                 "type_list": list(ProfilerTypeMapping.INT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "number-or-null"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -1246,11 +1387,13 @@ def test_null_fields_schema(empty_data_context, null_fields_schema):
                 "column": "number-or-null",
                 "type_list": list(ProfilerTypeMapping.FLOAT_TYPE_NAMES),
             },
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
             "expectation_type": "expect_column_to_exist",
             "kwargs": {"column": "enum-or-null"},
+            "ge_cloud_id": None,
         },
         {
             "meta": {},
@@ -1259,6 +1402,7 @@ def test_null_fields_schema(empty_data_context, null_fields_schema):
                 "column": "enum-or-null",
                 "value_set": ["a", "b", "c"],
             },
+            "ge_cloud_id": None,
         },
     ]
     context = empty_data_context