fix compressed and repeated properties (#290)

* fix compressed and repeated properties

Author: cguardia

packages/google-cloud-ndb/google/cloud/ndb/model.py

@@ -2527,9 +2527,20 @@ def _to_datastore(self, entity, data, prefix="", repeated=False):
             if isinstance(value, _CompressedValue):
                 value = value.z_val
                 data[self._name] = value
-            if value and not value.startswith(_ZLIB_COMPRESSION_MARKER):
-                value = zlib.compress(value)
+
+            if self._repeated:
+                compressed_value = []
+                for rval in value:
+                    if rval and not rval.startswith(_ZLIB_COMPRESSION_MARKER):
+                        rval = zlib.compress(rval)
+                    compressed_value.append(rval)
+                value = compressed_value
                 data[self._name] = value
+            if not self._repeated:
+                if value and not value.startswith(_ZLIB_COMPRESSION_MARKER):
+                    value = zlib.compress(value)
+                    data[self._name] = value
+
             if value:
                 data.setdefault("_meanings", {})[self._name] = (
                     _MEANING_COMPRESSED,

packages/google-cloud-ndb/tests/system/test_crud.py

@@ -361,6 +361,25 @@ class SomeKind(ndb.Model):
     assert retrieved.foo == foo
 
 
+@pytest.mark.usefixtures("client_context")
+def test_compressed_repeated_local_structured_property(dispose_of, ds_client):
+    class Dog(ndb.Model):
+        name = ndb.StringProperty()
+
+    class House(ndb.Model):
+        dogs = ndb.LocalStructuredProperty(Dog, repeated=True, compressed=True)
+
+    entity = House()
+    dogs = [Dog(name="Mika"), Dog(name="Mocha")]
+    entity.dogs = dogs
+
+    key = entity.put()
+    dispose_of(key._key)
+
+    retrieved = key.get()
+    assert retrieved.dogs == dogs
+
+
 @pytest.mark.usefixtures("client_context")
 def test_retrieve_entity_with_legacy_compressed_property(
     ds_entity_with_meanings,

packages/google-cloud-ndb/tests/unit/test_model.py

@@ -1803,6 +1803,25 @@ class ThisKind(model.Model):
         assert ds_entity._meanings["foo"][0] == model._MEANING_COMPRESSED
         assert ds_entity._meanings["foo"][1] == compressed_value
 
+    @staticmethod
+    @pytest.mark.usefixtures("in_context")
+    def test__to_datastore_compressed_repeated():
+        class ThisKind(model.Model):
+            foo = model.BlobProperty(compressed=True, repeated=True)
+
+        uncompressed_value_one = b"abc" * 1000
+        compressed_value_one = zlib.compress(uncompressed_value_one)
+        uncompressed_value_two = b"xyz" * 1000
+        compressed_value_two = zlib.compress(uncompressed_value_two)
+        entity = ThisKind(foo=[uncompressed_value_one, uncompressed_value_two])
+        ds_entity = model._entity_to_ds_entity(entity)
+        assert "foo" in ds_entity._meanings
+        assert ds_entity._meanings["foo"][0] == model._MEANING_COMPRESSED
+        assert ds_entity._meanings["foo"][1] == [
+            compressed_value_one,
+            compressed_value_two,
+        ]
+
     @staticmethod
     @pytest.mark.usefixtures("in_context")
     def test__to_datastore_compressed_uninitialized():
@@ -1861,6 +1880,33 @@ class ThisKind(model.Model):
         ds_entity = model._entity_to_ds_entity(entity)
         assert ds_entity["foo"] == compressed_value
 
+    @staticmethod
+    @pytest.mark.usefixtures("in_context")
+    def test__from_datastore_compressed_repeated_to_compressed():
+        class ThisKind(model.Model):
+            foo = model.BlobProperty(compressed=True, repeated=True)
+
+        key = datastore.Key("ThisKind", 123, project="testing")
+        datastore_entity = datastore.Entity(key=key)
+        uncompressed_value_one = b"abc" * 1000
+        compressed_value_one = zlib.compress(uncompressed_value_one)
+        uncompressed_value_two = b"xyz" * 1000
+        compressed_value_two = zlib.compress(uncompressed_value_two)
+        datastore_entity.update(
+            {"foo": [compressed_value_one, compressed_value_two]}
+        )
+        meanings = {
+            "foo": (
+                model._MEANING_COMPRESSED,
+                [compressed_value_one, compressed_value_two],
+            )
+        }
+        datastore_entity._meanings = meanings
+        protobuf = helpers.entity_to_protobuf(datastore_entity)
+        entity = model._entity_from_protobuf(protobuf)
+        ds_entity = model._entity_to_ds_entity(entity)
+        assert ds_entity["foo"] == [compressed_value_one, compressed_value_two]
+
     @staticmethod
     @pytest.mark.usefixtures("in_context")
     def test__from_datastore_uncompressed_to_uncompressed():
@@ -1893,6 +1939,26 @@ class ThisKind(model.Model):
         ds_entity = model._entity_to_ds_entity(entity)
         assert ds_entity["foo"] == compressed_value
 
+    @staticmethod
+    @pytest.mark.usefixtures("in_context")
+    def test__from_datastore_uncompressed_repeated_to_compressed():
+        class ThisKind(model.Model):
+            foo = model.BlobProperty(compressed=True, repeated=True)
+
+        key = datastore.Key("ThisKind", 123, project="testing")
+        datastore_entity = datastore.Entity(key=key)
+        uncompressed_value_one = b"abc" * 1000
+        compressed_value_one = zlib.compress(uncompressed_value_one)
+        uncompressed_value_two = b"xyz" * 1000
+        compressed_value_two = zlib.compress(uncompressed_value_two)
+        datastore_entity.update(
+            {"foo": [uncompressed_value_one, uncompressed_value_two]}
+        )
+        protobuf = helpers.entity_to_protobuf(datastore_entity)
+        entity = model._entity_from_protobuf(protobuf)
+        ds_entity = model._entity_to_ds_entity(entity)
+        assert ds_entity["foo"] == [compressed_value_one, compressed_value_two]
+
 
 class TestTextProperty:
     @staticmethod