added system tests

google/cloud/bigtable/client.py

@@ -772,9 +772,11 @@ async def check_and_mutate_row(
             true_case_mutations = [true_case_mutations]
         if isinstance(false_case_mutations, Mutation):
             false_case_mutations = [false_case_mutations]
+        true_case_mutations = [m._to_dict() for m in true_case_mutations or []]
+        false_case_mutations = [m._to_dict() for m in false_case_mutations or []]
         if predicate is not None and not isinstance(predicate, dict):
-            predicate = predicate._to_dict()
-        return await self.client._gapic_client.check_and_mutate_row(
+            predicate = predicate.to_dict()
+        result = await self.client._gapic_client.check_and_mutate_row(
             table_name=self.table_name,
             row_key=row_key,
             predicate_filter=predicate,
@@ -783,6 +785,7 @@ async def check_and_mutate_row(
             app_profile_id=self.app_profile_id,
             timeout=operation_timeout,
         )
+        return result.predicate_matched
 
     async def read_modify_write_row(
         self,

tests/system/test_system.py

@@ -310,3 +310,35 @@ async def test_read_modify_write_row_chained(client, table, temp_rows):
     assert result[0].column_qualifier == qualifier
     # result should be a bytes number string for the IncrementRules, followed by the AppendValueRule values
     assert result[0].value == (start_amount+increment_amount).to_bytes(8, "big", signed=True) +  b"helloworld!"
+
+@pytest.mark.parametrize("start_val,predicate_range,expected_result", [
+    (1, (0,2), True),
+    (-1, (0,2), False),
+])
+@pytest.mark.asyncio
+async def test_check_and_mutate(client, table, temp_rows, start_val, predicate_range, expected_result):
+    """
+    test that check_and_mutate_row works applies the right mutations, and returns the right result
+    """
+    from google.cloud.bigtable.mutations import SetCell
+    from google.cloud.bigtable.row_filters import ValueRangeFilter
+    row_key = b"test-row-key"
+    family = TEST_FAMILY
+    qualifier = b"test-qualifier"
+
+    await temp_rows.add_row(row_key, value=start_val, family=family, qualifier=qualifier)
+
+    false_mutation_value = -99
+    false_mutation_result = SetCell(
+        family=TEST_FAMILY, qualifier=qualifier, new_value=false_mutation_value
+    )
+    true_mutation_value = 55
+    true_mutation_result = SetCell(
+        family=TEST_FAMILY, qualifier=qualifier, new_value=true_mutation_value
+    )
+    predicate = ValueRangeFilter(predicate_range[0], predicate_range[1])
+    result = await table.check_and_mutate_row(
+        row_key, predicate, [false_mutation_result], [true_mutation_result]
+    )
+    assert result == expected_result
+    #TODO: add read_row assertions to verify the mutation was applied

tests/unit/test_client.py

@@ -1372,6 +1372,7 @@ def _make_client(self, *args, **kwargs):
     @pytest.mark.parametrize("gapic_result", [True, False])
     @pytest.mark.asyncio
     async def test_check_and_mutate(self, gapic_result):
+        from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
         app_profile = "app_profile_id"
         async with self._make_client() as client:
             async with client.get_table(
@@ -1380,11 +1381,11 @@ async def test_check_and_mutate(self, gapic_result):
                 with mock.patch.object(
                     client._gapic_client, "check_and_mutate_row"
                 ) as mock_gapic:
-                    mock_gapic.return_value = gapic_result
+                    mock_gapic.return_value = CheckAndMutateRowResponse(predicate_matched=gapic_result)
                     row_key = b"row_key"
                     predicate = None
-                    true_mutations = [object()]
-                    false_mutations = [object(), object()]
+                    true_mutations = [{}]
+                    false_mutations = [{}, {}]
                     operation_timeout = 0.2
                     found = await table.check_and_mutate_row(
                         row_key,
@@ -1422,13 +1423,14 @@ async def test_check_and_mutate_bad_timeout(self):
     async def test_check_and_mutate_single_mutations(self):
         """if single mutations are passed, they should be internally wrapped in a list"""
         from google.cloud.bigtable.mutations import SetCell
+        from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
 
         async with self._make_client() as client:
             async with client.get_table("instance", "table") as table:
                 with mock.patch.object(
                     client._gapic_client, "check_and_mutate_row"
                 ) as mock_gapic:
-                    mock_gapic.return_value = True
+                    mock_gapic.return_value = CheckAndMutateRowResponse(predicate_matched=True)
                     true_mutation = SetCell("family", b"qualifier", b"value")
                     false_mutation = SetCell("family", b"qualifier", b"value")
                     await table.check_and_mutate_row(
@@ -1438,30 +1440,57 @@ async def test_check_and_mutate_single_mutations(self):
                         false_mutation,
                     )
                     kwargs = mock_gapic.call_args[1]
-                    assert kwargs["true_mutations"] == [true_mutation]
-                    assert kwargs["false_mutations"] == [false_mutation]
+                    assert kwargs["true_mutations"] == [true_mutation._to_dict()]
+                    assert kwargs["false_mutations"] == [false_mutation._to_dict()]
 
     @pytest.mark.asyncio
     async def test_check_and_mutate_predicate_object(self):
         """predicate object should be converted to dict"""
+        from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
         mock_predicate = mock.Mock()
         fake_dict = {"fake": "dict"}
-        mock_predicate._to_dict.return_value = fake_dict
+        mock_predicate.to_dict.return_value = fake_dict
         async with self._make_client() as client:
             async with client.get_table("instance", "table") as table:
                 with mock.patch.object(
                     client._gapic_client, "check_and_mutate_row"
                 ) as mock_gapic:
-                    mock_gapic.return_value = True
+                    mock_gapic.return_value = CheckAndMutateRowResponse(predicate_matched=True)
                     await table.check_and_mutate_row(
                         b"row_key",
                         mock_predicate,
                         None,
-                        [object(), object()],
+                        [{}, {}],
                     )
                     kwargs = mock_gapic.call_args[1]
                     assert kwargs["predicate_filter"] == fake_dict
-                    assert mock_predicate._to_dict.call_count == 1
+                    assert mock_predicate.to_dict.call_count == 1
+
+    @pytest.mark.asyncio
+    async def test_check_and_mutate_mutations_parsing(self):
+        """mutations objects should be converted to dicts"""
+        from google.cloud.bigtable_v2.types import CheckAndMutateRowResponse
+        from google.cloud.bigtable.mutations import DeleteAllFromRow
+        mutations = [mock.Mock() for _ in range(5)]
+        for idx, mutation in enumerate(mutations):
+            mutation._to_dict.return_value = {"fake": idx}
+        mutations.append(DeleteAllFromRow())
+        async with self._make_client() as client:
+            async with client.get_table("instance", "table") as table:
+                with mock.patch.object(
+                    client._gapic_client, "check_and_mutate_row"
+                ) as mock_gapic:
+                    mock_gapic.return_value = CheckAndMutateRowResponse(predicate_matched=True)
+                    await table.check_and_mutate_row(
+                        b"row_key",
+                        None,
+                        mutations[0:2],
+                        mutations[2:],
+                    )
+                    kwargs = mock_gapic.call_args[1]
+                    assert kwargs["true_mutations"] == [{"fake": 0}, {"fake": 1}]
+                    assert kwargs["false_mutations"] == [{"fake": 2}, {"fake": 3}, {"fake": 4}, {"delete_from_row": {}}]
+                    assert all(mutation._to_dict.call_count == 1 for mutation in mutations[:5])
 
 
 class TestReadModifyWriteRow: