Add more tests of set_many/get_many

edx_user_state_client/interface.py

@@ -82,7 +82,10 @@ class XBlockUserStateClient(object):
         Returns
             dict: A dictionary mapping field names to values
         """
-        return next(self.get_many(username, [block_key], scope, fields=fields))[1]
+        try:
+            return next(self.get_many(username, [block_key], scope, fields=fields))[1]
+        except StopIteration:
+            raise self.DoesNotExist()
 
     @contract(
         username="basestring",

edx_user_state_client/tests.py

@@ -23,8 +23,6 @@ class UserStateClientTestBase(TestCase):
         return "field{}".format(field_idx)
 
     def get(self, user_idx, block_idx, fields=None):
-        if fields is not None:
-            fields = [self.field(field_idx) for field_idx in fields]
         return self.client.get(
             self.user(user_idx),
             self.block(block_idx),
@@ -40,6 +38,25 @@ class UserStateClientTestBase(TestCase):
             self.scope,
         )
 
+    def set_many(self, user_idx, block_idx_to_state):
+        return self.client.set_many(
+            self.user(user_idx),
+            {
+                self.block(block_idx): state
+                for block_idx, state
+                in block_idx_to_state.items()
+            },
+            self.scope,
+        )
+
+    def get_many(self, user_idx, block_idxs, fields=None):
+        return self.client.get_many(
+            self.user(user_idx),
+            [self.block(block_idx) for block_idx in block_idxs],
+            self.scope,
+            fields,
+        )
+
     def test_set_get(self):
         self.set(0, 0, {'a': 'b'})
         self.assertEquals(self.get(0, 0), {'a': 'b'})
@@ -54,6 +71,31 @@ class UserStateClientTestBase(TestCase):
         self.set(0, 0, {'a': 'c'})
         self.assertEquals(self.get(0, 0), {'a': 'c'})
 
+    def test_set_overlay(self):
+        self.set(0, 0, {'a': 'b'})
+        self.set(0, 0, {'b': 'c'})
+        self.assertEquals(self.get(0, 0), {'a': 'b', 'b': 'c'})
+
+    def test_get_fields(self):
+        self.set(0, 0, {'a': 'b', 'b': 'c'})
+        self.assertEquals(self.get(0, 0, ['a']), {'a': 'b'})
+        self.assertEquals(self.get(0, 0, ['b']), {'b': 'c'})
+        self.assertEquals(self.get(0, 0, ['a', 'b']), {'a': 'b', 'b': 'c'})
+
+    def test_get_missing_block(self):
+        self.set(0, 1, {})
+        with self.assertRaises(self.client.DoesNotExist):
+            self.get(0, 0)
+
+    def test_get_missing_user(self):
+        self.set(1, 0, {})
+        with self.assertRaises(self.client.DoesNotExist):
+            self.get(0, 0)
+
+    def test_get_missing_field(self):
+        self.set(0, 0, {'a': 'b'})
+        self.assertEquals(self.get(0, 0, ['a', 'b']), {'a': 'b'})
+
     def test_set_two_users(self):
         self.set(0, 0, {'a': 'b'})
         self.set(1, 0, {'b': 'c'})
@@ -66,6 +108,21 @@ class UserStateClientTestBase(TestCase):
         self.assertEquals(self.get(0, 0), {'a': 'b'})
         self.assertEquals(self.get(0, 1), {'b': 'c'})
 
+    def test_set_many(self):
+        self.set_many(0, {0: {'a': 'b'}, 1: {'b': 'c'}})
+        self.assertEquals(self.get(0, 0), {'a': 'b'})
+        self.assertEquals(self.get(0, 1), {'b': 'c'})
+
+    def test_get_many(self):
+        self.set_many(0, {0: {'a': 'b'}, 1: {'b': 'c'}})
+        self.assertItemsEqual(
+            self.get_many(0, [0, 1]),
+            [
+                (self.block(0), {'a': 'b'}),
+                (self.block(1), {'b': 'c'})
+            ]
+        )
+
 
 class DictUserStateClient(XBlockUserStateClient):
     def __init__(self):
@@ -73,12 +130,19 @@ class DictUserStateClient(XBlockUserStateClient):
 
     def get_many(self, username, block_keys, scope=Scope.user_state, fields=None):
         for key in block_keys:
+            if (username, key, scope) not in self._data:
+                continue
+
             if fields is None:
-                fields = self._data[(username, key, scope)].keys()
+                current_fields = self._data[(username, key, scope)].keys()
+            else:
+                current_fields = fields
 
+            data = self._data[(username, key, scope)]
             yield (key, {
-                field: self._data[(username, key, scope)][field]
-                for field in fields
+                field: data[field]
+                for field in current_fields
+                if field in data
             })
 
     def set_many(self, username, block_keys_to_state, scope=Scope.user_state):