def test_imgmgr_create_body(self):
     clt = self.client
     mgr = clt._manager
     nm = utils.random_unicode()
     meta = utils.random_unicode()
     body = mgr._create_body(nm, metadata=meta)
     self.assertEqual(body, {"metadata": meta})

 def test_img_update(self):
     img = self.image
     key = utils.random_unicode()
     val = utils.random_unicode()
     img.manager.update = Mock()
     img.update({key: val})
     img.manager.update.assert_called_once_with(img, {key: val})

 def test_claim(self):
     msgs = []
     num = random.randint(1, 9)
     for ii in range(num):
         msg_id = utils.random_unicode()
         claim_id = utils.random_unicode()
         age = utils.random_unicode()
         body = utils.random_unicode()
         ttl = utils.random_unicode()
         href = "http://example.com/%s" % msg_id
         info = {"href": href,
                 "age": age,
                 "body": body,
                 "ttl": ttl,
                 }
         msgs.append(info)
     id_ = _safe_id()
     href = "http://example.com/%s" % id_
     info = {"href": href,
             "messages": msgs,
             }
     mgr = fakes.FakeQueueManager()
     mgr._message_manager = fakes.FakeQueueManager()
     clm = QueueClaim(manager=mgr, info=info)
     self.assertEqual(clm.id, id_)
     self.assertEqual(len(clm.messages), num)

 def test_queue_post_message(self):
     q = self.queue
     q._message_manager.create = Mock()
     body = utils.random_unicode()
     ttl = utils.random_unicode()
     q.post_message(body, ttl)
     q._message_manager.create.assert_called_once_with(body, ttl)

 def test_create_body_volume(self):
     mgr = self.client._manager
     size = random.randint(MIN_SIZE, MAX_SIZE)
     name = utils.random_unicode()
     snapshot_id = utils.random_unicode()
     clone_id = utils.random_unicode()
     display_description = None
     volume_type = None
     metadata = None
     availability_zone = utils.random_unicode()
     fake_body = {"volume": {
             "size": size,
             "snapshot_id": snapshot_id,
             "source_volid": clone_id,
             "display_name": name,
             "display_description": "",
             "volume_type": "SATA",
             "metadata": {},
             "availability_zone": availability_zone,
             }}
     ret = mgr._create_body(name=name, size=size, volume_type=volume_type,
             description=display_description, metadata=metadata,
             snapshot_id=snapshot_id, clone_id=clone_id,
             availability_zone=availability_zone)
     self.assertEqual(ret, fake_body)

 def test_queue_mgr_create_body(self):
     clt = self.client
     mgr = clt._manager
     name = utils.random_unicode()
     metadata = utils.random_unicode()
     ret = mgr._create_body(name, metadata=metadata)
     self.assertEqual(ret, {"metadata": metadata})

 def test_findall(self):
     mgr = self.client._manager
     mgr.findall = Mock()
     prop = utils.random_unicode()
     val = utils.random_unicode()
     self.client.findall(prop=val)
     mgr.findall.assert_called_once_with(prop=val)

 def test_img_member_mgr_create_body(self):
     img = self.image
     mgr = img._member_manager
     nm = utils.random_unicode()
     project_id = utils.random_unicode()
     ret = mgr._create_body(nm, project_id)
     self.assertEqual(ret, {"member": project_id})

 def test_queue_id_property(self):
     q = self.queue
     val = utils.random_unicode()
     q.name = val
     self.assertEqual(q.id, val)
     val = utils.random_unicode()
     q.id = val
     self.assertEqual(q.name, val)

 def test_list_users(self):
     inst = self.instance
     inst._user_manager.list = Mock()
     limit = utils.random_unicode()
     marker = utils.random_unicode()
     inst.list_users(limit=limit, marker=marker)
     inst._user_manager.list.assert_called_once_with(limit=limit,
             marker=marker)

 def test_queue_claim_messages(self):
     q = self.queue
     q._claim_manager.claim = Mock()
     ttl = utils.random_unicode()
     grace = utils.random_unicode()
     count = random.randint(1, 9)
     q.claim_messages(ttl, grace, count=count)
     q._claim_manager.claim.assert_called_once_with(ttl, grace, count=count)

 def test_queue_delete_message(self):
     q = self.queue
     q._message_manager.delete = Mock()
     msg_id = utils.random_unicode()
     claim_id = utils.random_unicode()
     q.delete_message(msg_id, claim_id=claim_id)
     q._message_manager.delete.assert_called_once_with(msg_id,
             claim_id=claim_id)

 def __init__(self, *args, **kwargs):
     info = kwargs.pop("info", {"fake": "fake"})
     info["name"] = utils.random_unicode()
     info["id"] = utils.random_unicode()
     mgr = kwargs.pop("manager", FakeImageManager())
     kwargs["member_manager_class"] = FakeImageMemberManager
     kwargs["tag_manager_class"] = FakeImageTagManager
     super(FakeImage, self).__init__(mgr, info, *args, **kwargs)

 def test_volume_description_property(self):
     vol = self.volume
     nm = utils.random_unicode()
     vol.display_description = nm
     self.assertEqual(vol.description, vol.display_description)
     nm = utils.random_unicode()
     vol.description = nm
     self.assertEqual(vol.description, vol.display_description)

 def test_volume_name_property(self):
     vol = self.volume
     nm = utils.random_unicode()
     vol.display_name = nm
     self.assertEqual(vol.name, vol.display_name)
     nm = utils.random_unicode()
     vol.name = nm
     self.assertEqual(vol.name, vol.display_name)

 def test_create_snapshot(self):
     vol = self.volume
     vol.manager.create_snapshot = Mock()
     name = utils.random_unicode()
     desc = utils.random_unicode()
     vol.create_snapshot(name=name, description=desc, force=False)
     vol.manager.create_snapshot.assert_called_once_with(volume=vol,
             name=name, description=desc, force=False)

 def test_detach_from_instance_fail(self):
     vol = self.volume
     srv_id = utils.random_unicode()
     att_id = utils.random_unicode()
     vol.attachments = [{"server_id": srv_id, "id": att_id}]
     vol._nova_volumes.delete_server_volume = Mock(
             side_effect=Exception("test"))
     self.assertRaises(exc.VolumeDetachmentFailed, vol.detach)

 def test_snapshot_description_property(self):
     snap = self.snapshot
     nm = utils.random_unicode()
     snap.display_description = nm
     self.assertEqual(snap.description, snap.display_description)
     nm = utils.random_unicode()
     snap.description = nm
     self.assertEqual(snap.description, snap.display_description)

 def test_snapshot_name_property(self):
     snap = self.snapshot
     nm = utils.random_unicode()
     snap.display_name = nm
     self.assertEqual(snap.name, snap.display_name)
     nm = utils.random_unicode()
     snap.name = nm
     self.assertEqual(snap.name, snap.display_name)

 def test_list_flavors(self):
     clt = self.client
     clt._flavor_manager.list = Mock()
     limit = utils.random_unicode()
     marker = utils.random_unicode()
     clt.list_flavors(limit=limit, marker=marker)
     clt._flavor_manager.list.assert_called_once_with(limit=limit,
             marker=marker)