name : test_launchpad.py # Copyright 2008 Canonical Ltd. # This file is part of launchpadlib. # # launchpadlib is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # launchpadlib is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with launchpadlib. If not, see # <http://www.gnu.org/licenses/>. from datetime import datetime from testresources import ResourcedTestCase from launchpadlib.testing.launchpad import ( FakeLaunchpad, FakeResource, FakeRoot, IntegrityError, ) from launchpadlib.testing.resources import ( FakeLaunchpadResource, get_application, ) class FakeRootTest(ResourcedTestCase): def test_create_root_resource(self): root_resource = FakeRoot(get_application()) self.assertTrue(isinstance(root_resource, FakeResource)) class FakeResourceTest(ResourcedTestCase): resources = [("launchpad", FakeLaunchpadResource())] def test_repr_entry(self): """A custom C{__repr__} is provided for L{FakeEntry}s.""" bug = dict() self.launchpad.bugs = dict(entries=[bug]) [bug] = list(self.launchpad.bugs) self.assertEqual( "<FakeEntry bug object at %s>" % hex(id(bug)), repr(bug) ) def test_repr_collection(self): """A custom C{__repr__} is provided for L{FakeCollection}s.""" branches = dict(total_size="test-branch") self.launchpad.me = dict(getBranches=lambda statuses: branches) branches = self.launchpad.me.getBranches([]) obj_id = hex(id(branches)) self.assertEqual( "<FakeCollection branch-page-resource object at %s>" % obj_id, repr(branches), ) def test_repr_with_name(self): """ If the fake has a C{name} property it's included in the repr string to make it easier to figure out what it is. """ self.launchpad.me = dict(name="foo") person = self.launchpad.me self.assertEqual( "<FakeEntry person foo at %s>" % hex(id(person)), repr(person) ) def test_repr_with_id(self): """ If the fake has an C{id} property it's included in the repr string to make it easier to figure out what it is. """ bug = dict(id="1", title="Bug #1") self.launchpad.bugs = dict(entries=[bug]) [bug] = list(self.launchpad.bugs) self.assertEqual("<FakeEntry bug 1 at %s>" % hex(id(bug)), repr(bug)) class FakeLaunchpadTest(ResourcedTestCase): resources = [("launchpad", FakeLaunchpadResource())] def test_wb_instantiate_without_application(self): """ The builtin WADL definition is used if the C{application} is not provided during instantiation. """ credentials = object() launchpad = FakeLaunchpad(credentials) self.assertEqual(credentials, launchpad.credentials) self.assertEqual(get_application(), launchpad._application) def test_instantiate_with_everything(self): """ L{FakeLaunchpad} takes the same parameters as L{Launchpad} during instantiation, with the addition of an C{application} parameter. The optional parameters are discarded when the object is instantiated. """ credentials = object() launchpad = FakeLaunchpad( credentials, service_root=None, cache=None, timeout=None, proxy_info=None, application=get_application(), ) self.assertEqual(credentials, launchpad.credentials) def test_instantiate_with_credentials(self): """A L{FakeLaunchpad} can be instantiated with credentials.""" credentials = object() launchpad = FakeLaunchpad(credentials, application=get_application()) self.assertEqual(credentials, launchpad.credentials) def test_instantiate_without_credentials(self): """ A L{FakeLaunchpad} instantiated without credentials has its C{credentials} attribute set to C{None}. """ self.assertIsNone(self.launchpad.credentials) def test_set_undefined_property(self): """ An L{IntegrityError} is raised if an attribute is set on a L{FakeLaunchpad} instance that isn't present in the WADL definition. """ self.assertRaises( IntegrityError, setattr, self.launchpad, "foo", "bar" ) def test_get_undefined_resource(self): """ An L{AttributeError} is raised if an attribute is accessed on a L{FakeLaunchpad} instance that doesn't exist. """ self.launchpad.me = dict(display_name="Foo") self.assertRaises(AttributeError, getattr, self.launchpad.me, "name") def test_string_property(self): """ Sample data can be created by setting L{FakeLaunchpad} attributes with dicts that represent objects. Plain string values can be represented as C{str} values. """ self.launchpad.me = dict(name="foo") self.assertEqual("foo", self.launchpad.me.name) def test_unicode_property(self): """ Sample data can be created by setting L{FakeLaunchpad} attributes with dicts that represent objects. Plain string values can be represented as C{unicode} strings. """ self.launchpad.me = dict(name=u"foo") self.assertEqual(u"foo", self.launchpad.me.name) def test_datetime_property(self): """ Attributes that represent dates are set with C{datetime} instances. """ now = datetime.utcnow() self.launchpad.me = dict(date_created=now) self.assertEqual(now, self.launchpad.me.date_created) def test_invalid_datetime_property(self): """ Only C{datetime} values can be set on L{FakeLaunchpad} instances for attributes that represent dates. """ self.assertRaises( IntegrityError, setattr, self.launchpad, "me", dict(date_created="now"), ) def test_multiple_string_properties(self): """ Sample data can be created by setting L{FakeLaunchpad} attributes with dicts that represent objects. """ self.launchpad.me = dict(name="foo", display_name="Foo") self.assertEqual("foo", self.launchpad.me.name) self.assertEqual("Foo", self.launchpad.me.display_name) def test_invalid_property_name(self): """ Sample data set on a L{FakeLaunchpad} instance is validated against the WADL definition. If a key is defined on a resource that doesn't match a related parameter, an L{IntegrityError} is raised. """ self.assertRaises( IntegrityError, setattr, self.launchpad, "me", dict(foo="bar") ) def test_invalid_property_value(self): """ The types of sample data values set on L{FakeLaunchpad} instances are validated against types defined in the WADL definition. """ self.assertRaises( IntegrityError, setattr, self.launchpad, "me", dict(name=102) ) def test_callable(self): """ A callable set on a L{FakeLaunchpad} instance is validated against the WADL definition, to make sure a matching method exists. """ branches = dict(total_size="test-branch") self.launchpad.me = dict(getBranches=lambda statuses: branches) self.assertNotEqual(None, self.launchpad.me.getBranches([])) def test_invalid_callable_name(self): """ An L{IntegrityError} is raised if a method is defined on a resource that doesn't match a method defined in the WADL definition. """ self.assertRaises( IntegrityError, setattr, self.launchpad, "me", dict(foo=lambda: None), ) def test_callable_object_return_type(self): """ The result of a fake method is a L{FakeResource}, automatically created from the object used to define the return object. """ branches = dict(total_size="8") self.launchpad.me = dict(getBranches=lambda statuses: branches) branches = self.launchpad.me.getBranches([]) self.assertTrue(isinstance(branches, FakeResource)) self.assertEqual("8", branches.total_size) def test_invalid_callable_object_return_type(self): """ An L{IntegrityError} is raised if a method returns an invalid result. """ branches = dict(total_size=8) self.launchpad.me = dict(getBranches=lambda statuses: branches) self.assertRaises(IntegrityError, self.launchpad.me.getBranches, []) def test_callable_object_return_None(self): """ A fake method passes through a return value of None rather than trying to create a L{FakeResource}. """ self.launchpad.branches = dict(getByUniqueName=lambda name: None) self.assertIsNone(self.launchpad.branches.getByUniqueName("foo")) def test_callable_object_no_response_representation(self): """ If the WADL definition of a method does not include a response representation, then fake versions of that method just pass through the return value. """ branch = dict(canBeDeleted=lambda: True) self.launchpad.branches = dict(getByUniqueName=lambda name: branch) branch = self.launchpad.branches.getByUniqueName("foo") self.assertTrue(branch.canBeDeleted()) def test_entry_property(self): """ Attributes that represent links to other objects are set using a dict representing the object. """ bug = dict(owner=dict(name="test-person")) self.launchpad.bugs = dict(entries=[bug]) bug = self.launchpad.bugs[0] self.assertEqual("test-person", bug.owner.name) def test_invalid_entry_property(self): """ Sample data for linked entries is validated. """ bug = dict(owner=dict(foo="bar")) self.assertRaises( IntegrityError, setattr, self.launchpad, "bugs", dict(entries=[bug]), ) def test_top_level_collection_property(self): """ Sample top-level collections can be set on L{FakeLaunchpad} instances. They are validated the same way other sample data is validated. """ branch = dict(name="foo") self.launchpad.branches = dict(getByUniqueName=lambda name: branch) branch = self.launchpad.branches.getByUniqueName("foo") self.assertEqual("foo", branch.name) def test_collection_property(self): """ Attributes that represent links to collections of other objects are set using a dict representing the collection. """ bug = dict(id="1") branch = dict(linked_bugs=dict(entries=[bug])) self.launchpad.branches = dict(getByUniqueName=lambda name: branch) branch = self.launchpad.branches.getByUniqueName("foo") [bug] = list(branch.linked_bugs) self.assertEqual("1", bug.id) def test_iterate_collection(self): """ Data for a sample collection set on a L{FakeLaunchpad} instance can be iterated over if an C{entries} key is defined. """ bug = dict(id="1", title="Bug #1") self.launchpad.bugs = dict(entries=[bug]) bugs = list(self.launchpad.bugs) self.assertEqual(1, len(bugs)) bug = bugs[0] self.assertEqual("1", bug.id) self.assertEqual("Bug #1", bug.title) def test_top_level_collection_with_invalid_entries(self): """ Sample data for each entry in a collection is validated when it's set on a L{FakeLaunchpad} instance. """ bug = dict(foo="bar") self.assertRaises( IntegrityError, setattr, self.launchpad, "bugs", dict(entries=[bug]), ) def test_collection_with_invalid_entries(self): """ Sample data for each entry in a collection is validated when it's set on an attribute representing a link to a collection of objects. """ bug = dict(foo="bar") branch = dict(linked_bugs=dict(entries=[bug])) self.launchpad.branches = dict(getByUniqueName=lambda name: branch) self.assertRaises( IntegrityError, self.launchpad.branches.getByUniqueName, "foo", ) def test_slice_collection(self): """ Data for a sample collection set on a L{FakeLaunchpad} instance can be sliced if an C{entries} key is defined. """ bug1 = dict(id="1", title="Bug #1") bug2 = dict(id="2", title="Bug #2") bug3 = dict(id="3", title="Bug #3") self.launchpad.bugs = dict(entries=[bug1, bug2, bug3]) bugs = self.launchpad.bugs[1:3] self.assertEqual(2, len(bugs)) self.assertEqual("2", bugs[0].id) self.assertEqual("3", bugs[1].id) def test_slice_collection_with_negative_start(self): """ A C{ValueError} is raised if a negative start value is used when slicing a sample collection set on a L{FakeLaunchpad} instance. """ bug1 = dict(id="1", title="Bug #1") bug2 = dict(id="2", title="Bug #2") self.launchpad.bugs = dict(entries=[bug1, bug2]) self.assertRaises(ValueError, lambda: self.launchpad.bugs[-1:]) self.assertRaises(ValueError, lambda: self.launchpad.bugs[-1:2]) def test_slice_collection_with_negative_stop(self): """ A C{ValueError} is raised if a negative stop value is used when slicing a sample collection set on a L{FakeLaunchpad} instance. """ bug1 = dict(id="1", title="Bug #1") bug2 = dict(id="2", title="Bug #2") self.launchpad.bugs = dict(entries=[bug1, bug2]) self.assertRaises(ValueError, lambda: self.launchpad.bugs[:-1]) self.assertRaises(ValueError, lambda: self.launchpad.bugs[0:-1]) def test_subscript_operator_out_of_range(self): """ An C{IndexError} is raised if an invalid index is used when retrieving data from a sample collection. """ bug1 = dict(id="1", title="Bug #1") self.launchpad.bugs = dict(entries=[bug1]) self.assertRaises(IndexError, lambda: self.launchpad.bugs[2]) def test_replace_property(self): """Values already set on fake resource objects can be replaced.""" self.launchpad.me = dict(name="foo") person = self.launchpad.me self.assertEqual("foo", person.name) person.name = "bar" self.assertEqual("bar", person.name) self.assertEqual("bar", self.launchpad.me.name) def test_replace_method(self): """Methods already set on fake resource objects can be replaced.""" branch1 = dict(name="foo", bzr_identity="lp:~user/project/branch1") branch2 = dict(name="foo", bzr_identity="lp:~user/project/branch2") self.launchpad.branches = dict(getByUniqueName=lambda name: branch1) self.launchpad.branches.getByUniqueName = lambda name: branch2 branch = self.launchpad.branches.getByUniqueName("foo") self.assertEqual("lp:~user/project/branch2", branch.bzr_identity) def test_replace_property_with_invalid_value(self): """Values set on fake resource objects are validated.""" self.launchpad.me = dict(name="foo") person = self.launchpad.me self.assertRaises(IntegrityError, setattr, person, "name", 1) def test_replace_resource(self): """Resources already set on L{FakeLaunchpad} can be replaced.""" self.launchpad.me = dict(name="foo") self.assertEqual("foo", self.launchpad.me.name) self.launchpad.me = dict(name="bar") self.assertEqual("bar", self.launchpad.me.name) def test_add_property(self): """Sample data set on a L{FakeLaunchpad} instance can be added to.""" self.launchpad.me = dict(name="foo") person = self.launchpad.me person.display_name = "Foo" self.assertEqual("foo", person.name) self.assertEqual("Foo", person.display_name) self.assertEqual("foo", self.launchpad.me.name) self.assertEqual("Foo", self.launchpad.me.display_name) def test_add_property_to_empty_object(self): """An empty object can be used when creating sample data.""" self.launchpad.me = dict() self.assertRaises(AttributeError, getattr, self.launchpad.me, "name") self.launchpad.me.name = "foo" self.assertEqual("foo", self.launchpad.me.name) def test_login(self): """ L{FakeLaunchpad.login} ignores all parameters and returns a new instance using the builtin WADL definition. """ launchpad = FakeLaunchpad.login("name", "token", "secret") self.assertTrue(isinstance(launchpad, FakeLaunchpad)) def test_get_token_and_login(self): """ L{FakeLaunchpad.get_token_and_login} ignores all parameters and returns a new instance using the builtin WADL definition. """ launchpad = FakeLaunchpad.get_token_and_login("name") self.assertTrue(isinstance(launchpad, FakeLaunchpad)) def test_login_with(self): """ L{FakeLaunchpad.login_with} ignores all parameters and returns a new instance using the builtin WADL definition. """ launchpad = FakeLaunchpad.login_with("name") self.assertTrue(isinstance(launchpad, FakeLaunchpad)) def test_lp_save(self): """ Sample object have an C{lp_save} method that is a no-op by default. """ self.launchpad.me = dict(name="foo") self.assertTrue(self.launchpad.me.lp_save()) def test_custom_lp_save(self): """A custom C{lp_save} method can be set on a L{FakeResource}.""" self.launchpad.me = dict(name="foo", lp_save=lambda: "custom") self.assertEqual("custom", self.launchpad.me.lp_save()) def test_set_custom_lp_save(self): """ A custom C{lp_save} method can be set on a L{FakeResource} after its been created. """ self.launchpad.me = dict(name="foo") self.launchpad.me.lp_save = lambda: "custom" self.assertEqual("custom", self.launchpad.me.lp_save())