Get to 100% branch coverage

gcloud/datastore/helpers.py

@@ -60,6 +60,8 @@ def get_protobuf_attribute_and_value(val):
         name, value = 'integer', long(val)  # Always cast to a long.
     elif isinstance(val, basestring):
         name, value = 'string', val
+    else:
+        raise ValueError("Unknown protobuf attr type %s" % type(val))
 
     return name + '_value', value
 

gcloud/datastore/key.py

@@ -66,7 +66,9 @@ def from_protobuf(cls, pb, dataset=None):
             if element.HasField('id'):
                 element_dict['id'] = element.id
 
-            elif element.HasField('name'):
+            # This is safe: we expect proto objects returned will only have
+            # one of `name` or `id` set.
+            if element.HasField('name'):
                 element_dict['name'] = element.name
 
             path.append(element_dict)

gcloud/datastore/test_helpers.py

@@ -83,6 +83,9 @@ def test_unicode(self):
         self.assertEqual(name, 'string_value')
         self.assertEqual(value, u'str')
 
+    def test_object(self):
+        self.assertRaises(ValueError, self._callFUT, object())
+
 
 class Test_get_value_from_protobuf(unittest2.TestCase):
 

gcloud/datastore/test_key.py

@@ -19,8 +19,7 @@ def _makePB(self, dataset_id=None, namespace=None, path=()):
             pb.partition_id.namespace = namespace
         for elem in path:
             added = pb.path_element.add()
-            if 'kind' in elem:
-                added.kind = elem['kind']
+            added.kind = elem['kind']
             if 'id' in elem:
                 added.id = elem['id']
             if 'name' in elem:
@@ -101,9 +100,16 @@ def test_from_protobuf_w_path_in_pb(self):
         pb = self._makePB(_DATASET, _NAMESPACE)
         _PARENT = 'PARENT'
         _CHILD = 'CHILD'
+        _GRANDCHILD = 'GRANDCHILD'
         _ID = 1234
+        _ID2 = 5678
         _NAME = 'NAME'
-        _PATH = [{'kind': _PARENT, 'name': _NAME}, {'kind': _CHILD, 'id': _ID}]
+        _NAME2 = 'NAME2'
+        _PATH = [
+            {'kind': _PARENT, 'name': _NAME},
+            {'kind': _CHILD, 'id': _ID},
+            {'kind': _GRANDCHILD, 'id': _ID2, 'name': _NAME2},
+        ]
         pb = self._makePB(path=_PATH)
         key = self._getTargetClass().from_protobuf(pb)
         self.assertEqual(key.path(), _PATH)
@@ -120,6 +126,13 @@ def test_to_protobuf_defaults(self):
         self.assertEqual(elem.name, '')
         self.assertEqual(elem.id, 0)
 
+    def test_to_protobuf_w_explicit_dataset_empty_id(self):
+        from gcloud.datastore.dataset import Dataset
+        dataset = Dataset('')
+        key = self._makeOne(dataset)
+        pb = key.to_protobuf()
+        self.assertEqual(pb.partition_id.dataset_id, '')
+
     def test_to_protobuf_w_explicit_dataset_no_prefix(self):
         from gcloud.datastore.dataset import Dataset
         _DATASET = 'DATASET'
@@ -155,14 +168,22 @@ def test_to_protobuf_w_explicit_path(self):
         _CHILD = 'CHILD'
         _ID = 1234
         _NAME = 'NAME'
-        _PATH = [{'kind': _PARENT, 'name': _NAME}, {'kind': _CHILD, 'id': _ID}]
+        _PATH = [
+            {'kind': _PARENT, 'name': _NAME},
+            {'kind': _CHILD, 'id': _ID},
+            {},
+        ]
         key = self._makeOne(path=_PATH)
         pb = key.to_protobuf()
         elems = list(pb.path_element)
+        self.assertEqual(len(elems), len(_PATH))
         self.assertEqual(elems[0].kind, _PARENT)
         self.assertEqual(elems[0].name, _NAME)
         self.assertEqual(elems[1].kind, _CHILD)
         self.assertEqual(elems[1].id, _ID)
+        self.assertEqual(elems[2].kind, '')
+        self.assertEqual(elems[2].name, '')
+        self.assertEqual(elems[2].id, 0)
 
     def test_from_path_empty(self):
         key = self._getTargetClass().from_path()
@@ -262,6 +283,15 @@ def test_path_setter(self):
         self.assertEqual(after.namespace(), _NAMESPACE)
         self.assertEqual(after.path(), _PATH)
 
+    def test_kind_getter_empty_path(self):
+        from gcloud.datastore.dataset import Dataset
+        _DATASET = 'DATASET'
+        _NAMESPACE = 'NAMESPACE'
+        dataset = Dataset(_DATASET)
+        key = self._makeOne(dataset, _NAMESPACE)
+        key._path = ()  # edge case
+        self.assertEqual(key.kind(), None)
+
     def test_kind_setter(self):
         from gcloud.datastore.dataset import Dataset
         _DATASET = 'DATASET'
@@ -279,22 +309,14 @@ def test_kind_setter(self):
         self.assertEqual(after.namespace(), _NAMESPACE)
         self.assertEqual(after.path(), [{'kind': _KIND_AFTER, 'name': _NAME}])
 
-    def test_name_setter(self):
+    def test_id_getter_empty_path(self):
         from gcloud.datastore.dataset import Dataset
         _DATASET = 'DATASET'
         _NAMESPACE = 'NAMESPACE'
-        _KIND = 'KIND'
-        _NAME_BEFORE = 'NAME_BEFORE'
-        _NAME_AFTER = 'NAME_AFTER'
-        _PATH = [{'kind': _KIND, 'name': _NAME_BEFORE}]
         dataset = Dataset(_DATASET)
-        key = self._makeOne(dataset, _NAMESPACE, _PATH)
-        after = key.name(_NAME_AFTER)
-        self.assertFalse(after is key)
-        self.assertTrue(isinstance(after, self._getTargetClass()))
-        self.assertTrue(after.dataset() is dataset)
-        self.assertEqual(after.namespace(), _NAMESPACE)
-        self.assertEqual(after.path(), [{'kind': _KIND, 'name': _NAME_AFTER}])
+        key = self._makeOne(dataset, _NAMESPACE)
+        key._path = ()  # edge case
+        self.assertEqual(key.id(), None)
 
     def test_id_setter(self):
         from gcloud.datastore.dataset import Dataset
@@ -313,6 +335,32 @@ def test_id_setter(self):
         self.assertEqual(after.namespace(), _NAMESPACE)
         self.assertEqual(after.path(), [{'kind': _KIND, 'id': _ID_AFTER}])
 
+    def test_name_getter_empty_path(self):
+        from gcloud.datastore.dataset import Dataset
+        _DATASET = 'DATASET'
+        _NAMESPACE = 'NAMESPACE'
+        dataset = Dataset(_DATASET)
+        key = self._makeOne(dataset, _NAMESPACE)
+        key._path = ()  # edge case
+        self.assertEqual(key.name(), None)
+
+    def test_name_setter(self):
+        from gcloud.datastore.dataset import Dataset
+        _DATASET = 'DATASET'
+        _NAMESPACE = 'NAMESPACE'
+        _KIND = 'KIND'
+        _NAME_BEFORE = 'NAME_BEFORE'
+        _NAME_AFTER = 'NAME_AFTER'
+        _PATH = [{'kind': _KIND, 'name': _NAME_BEFORE}]
+        dataset = Dataset(_DATASET)
+        key = self._makeOne(dataset, _NAMESPACE, _PATH)
+        after = key.name(_NAME_AFTER)
+        self.assertFalse(after is key)
+        self.assertTrue(isinstance(after, self._getTargetClass()))
+        self.assertTrue(after.dataset() is dataset)
+        self.assertEqual(after.namespace(), _NAMESPACE)
+        self.assertEqual(after.path(), [{'kind': _KIND, 'name': _NAME_AFTER}])
+
     def test_id_or_name_no_name_or_id(self):
         key = self._makeOne()
         self.assertEqual(key.id_or_name(), None)

gcloud/datastore/test_query.py

@@ -77,6 +77,26 @@ def test_ancestor_w_non_key_non_list(self):
         # XXX s.b. ValueError
         self.assertRaises(TypeError, query.ancestor, object())
 
+    def test_ancester_wo_existing_ancestor_query_w_key_and_propfilter(self):
+        from gcloud.datastore.key import Key
+        _KIND = 'KIND'
+        _ID = 123
+        _NAME = 'NAME'
+        key = Key(path=[{'kind': _KIND, 'id': _ID}])
+        query = self._makeOne().filter('name =', _NAME)
+        after = query.ancestor(key)
+        self.assertFalse(after is query)
+        self.assertTrue(isinstance(after, self._getTargetClass()))
+        q_pb = after.to_protobuf()
+        self.assertEqual(q_pb.filter.composite_filter.operator, 1)  # AND
+        n_pb, f_pb, = list(q_pb.filter.composite_filter.filter)
+        p_pb = n_pb.property_filter
+        self.assertEqual(p_pb.property.name, 'name')
+        self.assertEqual(p_pb.value.string_value, _NAME)
+        p_pb = f_pb.property_filter
+        self.assertEqual(p_pb.property.name, '__key__')
+        self.assertEqual(p_pb.value.key_value, key.to_protobuf())
+
     def test_ancester_wo_existing_ancestor_query_w_key(self):
         from gcloud.datastore.key import Key
         _KIND = 'KIND'
@@ -109,7 +129,7 @@ def test_ancester_wo_existing_ancestor_query_w_list(self):
         self.assertEqual(p_pb.property.name, '__key__')
         self.assertEqual(p_pb.value.key_value, key.to_protobuf())
 
-    def test_ancester_clears_existing_ancestor_query(self):
+    def test_ancester_clears_existing_ancestor_query_w_only(self):
         _KIND = 'KIND'
         _ID = 123
         query = self._makeOne()
@@ -120,6 +140,21 @@ def test_ancester_clears_existing_ancestor_query(self):
         q_pb = after.to_protobuf()
         self.assertEqual(list(q_pb.filter.composite_filter.filter), [])
 
+    def test_ancester_clears_existing_ancestor_query_w_others(self):
+        _KIND = 'KIND'
+        _ID = 123
+        _NAME = 'NAME'
+        query = self._makeOne().filter('name =', _NAME)
+        between = query.ancestor([_KIND, _ID])
+        after = between.ancestor(None)
+        self.assertFalse(after is query)
+        self.assertTrue(isinstance(after, self._getTargetClass()))
+        q_pb = after.to_protobuf()
+        n_pb, = list(q_pb.filter.composite_filter.filter)
+        p_pb = n_pb.property_filter
+        self.assertEqual(p_pb.property.name, 'name')
+        self.assertEqual(p_pb.value.string_value, _NAME)
+
     def test_kind_setter_wo_existing(self):
         from gcloud.datastore.dataset import Dataset
         _DATASET = 'DATASET'

gcloud/storage/test_acl.py

@@ -153,6 +153,14 @@ def test___iter___non_empty_w_roles(self):
         self.assertEqual(list(acl),
                          [{'entity': '%s-%s' % (TYPE, ID), 'role': ROLE}])
 
+    def test___iter___non_empty_w_empty_role(self):
+        TYPE = 'type'
+        ID = 'id'
+        acl = self._makeOne()
+        entity = acl.entity(TYPE, ID)
+        entity.grant('')
+        self.assertEqual(list(acl), [])
+
     def test_entity_from_dict_allUsers(self):
         ROLE = 'role'
         acl = self._makeOne()

gcloud/storage/test_connection.py

@@ -491,6 +491,41 @@ def test_create_bucket_ok(self):
     def test_delete_bucket_defaults_miss(self):
         _deleted_keys = []
 
+        class _Key(object):
+            pass
+
+        class _Bucket(object):
+
+            def __init__(self, name):
+                self._name = name
+                self.path = '/b/' + name
+
+        PROJECT = 'project'
+        KEY = 'key'
+        conn = self._makeOne(PROJECT)
+        URI = '/'.join([conn.API_BASE_URL,
+                        'storage',
+                        conn.API_VERSION,
+                        'b',
+                        'key?project=%s' % PROJECT,
+                        ])
+        http = conn._http = Http({'status': '200',
+                                  'content-type': 'application/json',
+                                  },
+                                 '{}')
+
+        def _new_bucket(name):
+            return _Bucket(name)
+
+        conn.new_bucket = _new_bucket
+        self.assertEqual(conn.delete_bucket(KEY), True)
+        self.assertEqual(_deleted_keys, [])
+        self.assertEqual(http._called_with['method'], 'DELETE')
+        self.assertEqual(http._called_with['uri'], URI)
+
+    def test_delete_bucket_force_True(self):
+        _deleted_keys = []
+
         class _Key(object):
 
             def __init__(self, name):
@@ -507,6 +542,7 @@ def __init__(self, name):
 
             def __iter__(self):
                 return iter([_Key(x) for x in ('foo', 'bar')])
+
         PROJECT = 'project'
         KEY = 'key'
         conn = self._makeOne(PROJECT)
@@ -523,6 +559,7 @@ def __iter__(self):
 
         def _new_bucket(name):
             return _Bucket(name)
+
         conn.new_bucket = _new_bucket
         self.assertEqual(conn.delete_bucket(KEY, True), True)
         self.assertEqual(_deleted_keys, ['foo', 'bar'])