Merge lp:~alecu/ubuntu-sso-client/fix-708018 into lp:ubuntu-sso-client

[Alejandro J. Cura]

Create a keyring named "default" if no default keyring found. (LP:#708018)

Create a keyring named "default" if no default keyring found. (LP:#708018)

[Alejandro J. Cura (alecu)]

To test this branch: create a user with "System->Administration->Users and Groups", and check "Don't ask for password on login".

Then log as that user and try to connect to Ubuntu One. After registration or login, a dialog will pop up asking to create a "Default" keyring. Create a keyring, then verify that the connection to Ubuntu One was succesful, and that seahorse shows a new "Default" keyring.

[lp:~alecu/ubuntu-sso-client/fix-708018]

681. By Alejandro J. Cura on 2011-02-03

clean up constants in the test file

[Roberto Alsina (ralsina)]

+1

review: Approve (fieldtest)

[lp:~alecu/ubuntu-sso-client/fix-708018]

682. By Alejandro J. Cura on 2011-02-03

get_collection_by_alias was only used by the tests. removing it

[Natalia Bidart (nataliabidart)]

It works as advertised!

review: Approve

=== modified file 'ubuntu_sso/utils/tests/test_txsecrets.py'
--- ubuntu_sso/utils/tests/test_txsecrets.py	2011-01-18 21:54:35 +0000
+++ ubuntu_sso/utils/tests/test_txsecrets.py	2011-02-03 13:57:14 +0000
@@ -37,6 +37,9 @@
 
 
 ERROR_CREATE_BUT_LOCKED = "Cannot create an item in a locked collection"
+PROMPT_BASE_PATH = "/org/freedesktop/secrets/prompt"
+SESSION_BASE_PATH = "/org/freedesktop/secrets/session"
+COLLECTION_BASE_PATH = "/org/freedesktop/secrets/collection/"
 
 
 class SampleMiscException(Exception):
@@ -66,7 +69,7 @@
             raise SampleMiscException()
         self.collection.items.remove(self)
         if self.delete_prompt:
-            prompt_path = create_object_path("/org/freedesktop/secrets/prompt")
+            prompt_path = create_object_path(PROMPT_BASE_PATH)
             prompt = self.dbus_publish(prompt_path, PromptMock,
                                        result="",
                                        dismissed=self.dismissed)
@@ -146,13 +149,12 @@
         attributes = properties[txsecrets.ATTRIBUTES_PROPERTY]
         item_label = properties[txsecrets.LABEL_PROPERTY]
         session, parameters, value = secret
-        item_path = create_object_path("/org/freedesktop/secrets/collection/" +
-                                                                    self.label)
+        item_path = create_object_path(make_coll_path(self.label))
         item = self.dbus_publish(item_path, ItemMock, self, item_label,
                                  attributes, value)
         self.items.append(item)
         if self.create_item_prompt:
-            prompt_path = create_object_path("/org/freedesktop/secrets/prompt")
+            prompt_path = create_object_path(PROMPT_BASE_PATH)
             prompt = self.dbus_publish(prompt_path, PromptMock,
                                        result=item,
                                        dismissed=self.dismissed)
@@ -160,6 +162,13 @@
         else:
             return item, "/"
 
+    @dbus.service.method(dbus_interface=txsecrets.PROPERTIES_IFACE,
+                         in_signature="ss", out_signature="v")
+    def Get(self, interface, propname):
+        """The only property implemented is Label."""
+        if interface == txsecrets.COLLECTION_IFACE and propname == "Label":
+            return dbus.String(self.label)
+
 
 class SessionMock(dbus.service.Object):
     """A session tracks state between the service and a client application."""
@@ -169,6 +178,11 @@
         """Close this session."""
 
 
+def make_coll_path(label):
+    """Make the path to a collection with its label"""
+    return COLLECTION_BASE_PATH + label
+
+
 class SecretServiceMock(dbus.service.Object):
     """The Secret Service manages all the sessions and collections."""
     create_collection_prompt = False
@@ -181,6 +195,7 @@
         super(SecretServiceMock, self).__init__(*args, **kwargs)
         self.sessions = {}
         self.collections = {}
+        self.aliases = {}
 
     @dbus.service.method(dbus_interface=txsecrets.SERVICE_IFACE,
                          in_signature="sv", out_signature="vo")
@@ -188,15 +203,11 @@
         """Open a unique session for the caller application."""
         if self.open_session_fail:
             raise SampleMiscException()
-        session_path = create_object_path("/org/freedesktop/secrets/session")
+        session_path = create_object_path(SESSION_BASE_PATH)
         session = self.dbus_publish(session_path, SessionMock)
         self.sessions[session_path] = session
         return True, session
 
-    def make_coll_path(self, label):
-        """Make the path to a collection with its label"""
-        return "/org/freedesktop/secrets/collection/" + label
-
     @dbus.service.method(dbus_interface=txsecrets.SERVICE_IFACE,
                          in_signature="a{sv}", out_signature="oo")
     def CreateCollection(self, properties):
@@ -204,15 +215,12 @@
         if self.create_collection_fail:
             raise SampleMiscException()
         label = str(properties[txsecrets.LABEL_PROPERTY])
-        if len(self.collections):
-            coll_path = self.make_coll_path(label)
-        else:
-            coll_path = txsecrets.DEFAULT_COLLECTION
+        coll_path = make_coll_path(label)
         collection = self.dbus_publish(coll_path, CollectionMock, label)
         self.collections[label] = collection
 
         if self.create_collection_prompt:
-            prompt_path = create_object_path("/org/freedesktop/secrets/prompt")
+            prompt_path = create_object_path(PROMPT_BASE_PATH)
             prompt = self.dbus_publish(prompt_path, PromptMock,
                                        result=collection,
                                        dismissed=self.dismissed)
@@ -240,11 +248,15 @@
     def unlock_objects(self, objects):
         """Unlock the objects or its containers."""
         for c in self.collections.values():
-            if c.__dbus_object_path__ in objects:
-                c.locked = False
-            for i in c.items:
-                if i.__dbus_object_path__ in objects:
+            for l in c.locations:
+                path = l[1]
+                if path in objects:
                     c.locked = False
+            for i in c.items:
+                for l in i.locations:
+                    path = l[1]
+                    if path in objects:
+                        c.locked = False
 
     @dbus.service.method(dbus_interface=txsecrets.SERVICE_IFACE,
                          in_signature="ao", out_signature="aoo")
@@ -261,7 +273,7 @@
                     else:
                         unlocked.append(path)
         if locked:
-            prompt_path = create_object_path("/org/freedesktop/secrets/prompt")
+            prompt_path = create_object_path(PROMPT_BASE_PATH)
             self.unlock_objects(objects)
             prompt = self.dbus_publish(prompt_path, PromptMock,
                                        result=locked,
@@ -271,12 +283,25 @@
             self.unlock_objects(objects)
             return objects, "/"
 
-    @dbus.service.method(dbus_interface="org.freedesktop.DBus.Properties",
+    @dbus.service.method(dbus_interface=txsecrets.SERVICE_IFACE,
+                         in_signature="s", out_signature="o")
+    def ReadAlias(self, name):
+        """Get the collection with the given alias."""
+        result = self.aliases.get(name, "/")
+        return result
+
+    @dbus.service.method(dbus_interface=txsecrets.SERVICE_IFACE,
+                         in_signature="so")
+    def SetAlias(self, name, collection_path):
+        """Setup a collection alias."""
+        self.aliases[name] = collection_path
+
+    @dbus.service.method(dbus_interface=txsecrets.PROPERTIES_IFACE,
                          in_signature="ss", out_signature="v")
     def Get(self, interface, propname):
         """The only property implemented is Collections."""
         if interface == txsecrets.SERVICE_IFACE and propname == "Collections":
-            coll_paths = [self.make_coll_path(l) for l in self.collections]
+            coll_paths = [make_coll_path(l) for l in self.collections]
             return dbus.Array(coll_paths, signature="o", variant_level=1)
 
 
@@ -304,14 +329,27 @@
         self.assertNotEqual(name, dbus.bus.REQUEST_NAME_REPLY_EXISTS)
         mock_object = object_class(*args, object_path=object_path,
                                    conn=self.session_bus, **kwargs)
-        self.addCleanup(mock_object.remove_from_connection)
+        self.addCleanup(mock_object.remove_from_connection,
+                        connection=self.session_bus,
+                        path=object_path)
         mock_object.dbus_publish = self.dbus_publish
         return mock_object
 
     @inlineCallbacks
-    def create_sample_collection(self, label):
+    def create_sample_collection(self, label, make_alias=True,
+                                 publish_default_path=False):
         """Create a collection with a given label."""
         coll = yield self.secretservice.create_collection(label)
+        if make_alias:
+            coll_path = make_coll_path(label)
+            self.mock_service.SetAlias("default", coll_path)
+        if publish_default_path:
+            mock_object = self.mock_service.collections[label]
+            mock_object.add_to_connection(self.session_bus,
+                                          txsecrets.DEFAULT_COLLECTION)
+            self.addCleanup(mock_object.remove_from_connection,
+                            connection=self.session_bus,
+                            path=txsecrets.DEFAULT_COLLECTION)
         returnValue(coll)
 
 
@@ -528,16 +566,48 @@
         self.assertEqual(len(result), 3)
 
     @inlineCallbacks
-    def test_get_default_collection(self):
-        """The default collection is returned."""
-        yield self.secretservice.open_session()
-        collection_name = "sample_keyring"
+    def test_get_collections(self):
+        """The list of all collections is returned."""
+        collection_names = ["collection1", "collection2"]
+
+        yield self.secretservice.open_session()
+        for name in collection_names:
+            yield self.create_sample_collection(name)
+        collections = yield self.secretservice.get_collections()
+        self.assertEqual(len(collections), len(collection_names))
+
+    @inlineCallbacks
+    def test_get_default_collection_honours_default_path(self):
+        """The default collection is returned from the default path."""
+        yield self.secretservice.open_session()
+        collection_name = "sample_default_keyring"
+        yield self.create_sample_collection(collection_name, make_alias=False,
+                                            publish_default_path=True)
+        self.assertEqual(len(self.mock_service.collections), 1)
+        yield self.secretservice.get_default_collection()
+        self.assertEqual(len(self.mock_service.collections), 1)
+
+    @inlineCallbacks
+    def test_get_default_collection_honours_readalias(self):
+        """The default collection is returned if default alias set."""
+        yield self.secretservice.open_session()
+        collection_name = "sample_default_keyring"
         yield self.create_sample_collection(collection_name)
         self.assertEqual(len(self.mock_service.collections), 1)
         yield self.secretservice.get_default_collection()
         self.assertEqual(len(self.mock_service.collections), 1)
 
     @inlineCallbacks
+    def test_get_default_collection_created_if_no_default(self):
+        """The default collection is created if there's no default."""
+        yield self.secretservice.open_session()
+        collection_name = "sample_nondefault_keyring"
+        yield self.create_sample_collection(collection_name, make_alias=False)
+        self.assertEqual(len(self.mock_service.collections), 1)
+        yield self.secretservice.get_default_collection()
+        self.assertEqual(len(self.mock_service.collections), 2)
+
+    @inlineCallbacks
     def test_get_default_collection_created_if_nonexistent(self):
         """The default collection is created if it doesn't exist yet."""
         yield self.secretservice.open_session()
@@ -546,7 +616,32 @@
         self.assertEqual(len(self.mock_service.collections), 1)
 
     @inlineCallbacks
-    def test_get_default_collection_is_unlocked(self):
+    def test_get_default_collection_set_as_default_if_nonexistent(self):
+        """The default collection is set as default if it doesn't exist yet."""
+        yield self.secretservice.open_session()
+        yield self.secretservice.get_default_collection()
+        self.assertIn(txsecrets.DEFAULT_LABEL, self.mock_service.aliases)
+
+    @inlineCallbacks
+    def test_get_default_collection_is_unlocked_default_path(self):
+        """The default collection is unlocked before being returned."""
+        yield self.secretservice.open_session()
+        collection_name = "sample_keyring"
+        self.assertEqual(len(self.mock_service.collections), 0)
+        coll = yield self.create_sample_collection(collection_name,
+                                                   make_alias=False,
+                                                   publish_default_path=True)
+        self.assertEqual(len(self.mock_service.collections), 1)
+        mock_collection = self.mock_service.collections[collection_name]
+        mock_collection.locked = True
+        yield self.secretservice.get_default_collection()
+        attr = {"key-type": "Ubuntu 242 credentials"}
+        sample_secret = "secret!"
+        yield coll.create_item("Cucaracha", attr, sample_secret)
+        self.assertEqual(len(mock_collection.items), 1)
+
+    @inlineCallbacks
+    def test_get_default_collection_is_unlocked_readalias(self):
         """The default collection is unlocked before being returned."""
         yield self.secretservice.open_session()
         collection_name = "sample_keyring"
@@ -566,6 +661,16 @@
     """Test the Collection class."""
 
     @inlineCallbacks
+    def test_get_label(self):
+        """The collection gets its own label from the keyring."""
+        yield self.secretservice.open_session()
+        expected_label = "sample_keyring"
+        yield self.create_sample_collection(expected_label)
+        coll = yield self.secretservice.get_default_collection()
+        result = yield coll.get_label()
+        self.assertEqual(result, expected_label)
+
+    @inlineCallbacks
     def test_create_item(self):
         """The collection creates an item."""
         yield self.secretservice.open_session()

=== modified file 'ubuntu_sso/utils/txsecrets.py'
--- ubuntu_sso/utils/txsecrets.py	2011-01-18 21:54:35 +0000
+++ ubuntu_sso/utils/txsecrets.py	2011-02-03 13:57:14 +0000
@@ -40,6 +40,8 @@
 PROPERTIES_IFACE = "org.freedesktop.DBus.Properties"
 SECRETS_SERVICE = "/org/freedesktop/secrets"
 DEFAULT_COLLECTION = "/org/freedesktop/secrets/aliases/default"
+SESSION_COLLECTION = "/org/freedesktop/secrets/collection/session"
+
 ALGORITHM = "plain"
 ALGORITHM_PARAMS = ""
 LABEL_PROPERTY = "Label"
@@ -168,8 +170,25 @@
         d.addCallback(lambda p: Collection(self, p))
         return d
 
+    def get_collections(self):
+        """Return the list of all collections."""
+        d = Deferred()
+
+        def propertyget_handler(collection_paths):
+            """The list of collection paths was retrieved."""
+            result = []
+            for path in collection_paths:
+                collection = Collection(self, path)
+                result.append(collection)
+            d.callback(result)
+
+        self.properties.Get(SERVICE_IFACE, COLLECTIONS_PROPERTY,
+                            reply_handler=propertyget_handler,
+                            error_handler=d.errback)
+        return d
+
     def get_default_collection(self):
-        """The collection were default items should be created."""
+        """The collection where default items should be created."""
         d = Deferred()
 
         def prompt_handle(unlocked):
@@ -186,21 +205,48 @@
             else:
                 d.callback(prompt_handle(unlocked))
 
-        def propertyget_handler(collection_paths):
-            """The list of collection paths was retrieved."""
-            if len(collection_paths) > 0:
+        def set_default_alias(collection):
+            """Set the newly created collection as the default one."""
+            d4 = Deferred()
+            alias_set = lambda: d4.callback(collection)
+            object_path = dbus.ObjectPath(collection.object_path)
+            self.service.SetAlias(DEFAULT_LABEL, object_path,
+                                  reply_handler=alias_set,
+                                  error_handler=d4.errback)
+            return d4
+
+        def readalias_handler(collection_path):
+            """ReadAlias returned."""
+            if collection_path != "/":
                 # The collection was found, make sure it's unlocked
-                objects = dbus.Array([DEFAULT_COLLECTION], signature="o")
+                objects = dbus.Array([collection_path], signature="o")
                 self.service.Unlock(objects,
                                     reply_handler=unlock_handler,
                                     error_handler=d.errback)
             else:
                 # The collection was not found, so create it
-                self.create_collection(DEFAULT_LABEL).chainDeferred(d)
-
-        self.properties.Get(SERVICE_IFACE, COLLECTIONS_PROPERTY,
-                            reply_handler=propertyget_handler,
-                            error_handler=d.errback)
+                d3 = self.create_collection(DEFAULT_LABEL)
+                d3.addCallback(set_default_alias)
+                d3.chainDeferred(d)
+
+        def default_collection_not_found(e):
+            """Try the default alias."""
+            self.service.ReadAlias(DEFAULT_LABEL,
+                                   reply_handler=readalias_handler,
+                                   error_handler=d.errback)
+
+        def found_default_collection(label):
+            """Make sure the default collection is unlocked."""
+            objects = dbus.Array([DEFAULT_COLLECTION], signature="o")
+            self.service.Unlock(objects,
+                                reply_handler=unlock_handler,
+                                error_handler=d.errback)
+
+        collection = Collection(self, DEFAULT_COLLECTION)
+        d0 = collection.get_label()
+        d0.addCallback(found_default_collection)
+        d0.addErrback(default_collection_not_found)
+
         return d
 
 
@@ -210,9 +256,19 @@
     def __init__(self, service, object_path):
         """Initialize a new collection."""
         self.service = service
+        self.object_path = object_path
         collection_object = service.bus.get_object(BUS_NAME, object_path)
         self.collection_iface = dbus.Interface(collection_object,
                                                dbus_interface=COLLECTION_IFACE)
+        self.properties = dbus.Interface(collection_object,
+                                         dbus_interface=PROPERTIES_IFACE)
+
+    def get_label(self):
+        """Return the label for this collection from the keyring."""
+        d = Deferred()
+        self.properties.Get(COLLECTION_IFACE, LABEL_PROPERTY,
+                            reply_handler=d.callback, error_handler=d.errback)
+        return d
 
     def create_item(self, label, attr, value, replace=True):
         """Create an item with the given attributes, secret and label.
@@ -248,6 +304,7 @@
     def __init__(self, service, object_path):
         """Initialize this new Item."""
         self.service = service
+        self.object_path = object_path
         item_object = service.bus.get_object(BUS_NAME, object_path)
         self.item_iface = dbus.Interface(item_object,
                                          dbus_interface=ITEM_IFACE)