def test_properties(self):
# The basic properties of a SnapBuild are sensible.
db_build = self.factory.makeSnapBuild(requester=self.person,
date_created=datetime(
2014,
4,
25,
10,
38,
0,
tzinfo=pytz.UTC))
build_url = api_url(db_build)
logout()
build = self.webservice.get(build_url).jsonBody()
with person_logged_in(self.person):
self.assertEqual(self.getURL(self.person), build["requester_link"])
self.assertEqual(self.getURL(db_build.snap), build["snap_link"])
self.assertEqual(self.getURL(db_build.archive),
build["archive_link"])
self.assertEqual(self.getURL(db_build.distro_arch_series),
build["distro_arch_series_link"])
self.assertEqual(db_build.distro_arch_series.architecturetag,
build["arch_tag"])
self.assertEqual("Updates", build["pocket"])
self.assertIsNone(build["channels"])
self.assertIsNone(build["score"])
self.assertFalse(build["can_be_rescored"])
self.assertFalse(build["can_be_cancelled"])
def test_attachments_query_counts_constant(self):
# XXX j.c.sackett 2010-09-02 bug=619017
# This test was being thrown off by the reference bug. To get around
# the problem, flush and reset are called on the bug storm cache
# before each call to the webservice. When lp's storm is updated
# to release the committed fix for this bug, please see about
# updating this test.
login(USER_EMAIL)
self.bug = self.factory.makeBug()
store = Store.of(self.bug)
self.factory.makeBugAttachment(self.bug)
self.factory.makeBugAttachment(self.bug)
webservice = LaunchpadWebServiceCaller('launchpad-library',
'salgado-change-anything')
collector = RequestTimelineCollector()
collector.register()
self.addCleanup(collector.unregister)
url = '/bugs/%d/attachments?ws.size=75' % self.bug.id
# First request.
store.flush()
store.reset()
response = webservice.get(url)
self.assertThat(collector, HasQueryCount(LessThan(24)))
with_2_count = collector.count
self.assertEqual(response.status, 200)
login(USER_EMAIL)
for i in range(5):
self.factory.makeBugAttachment(self.bug)
logout()
# Second request.
store.flush()
store.reset()
response = webservice.get(url)
self.assertThat(collector, HasQueryCount(Equals(with_2_count)))
def test_getBuildQueueSizes(self):
logout()
results = self.webservice.named_get('/builders',
'getBuildQueueSizes',
api_version='devel')
self.assertEquals(['nonvirt', 'virt'],
sorted(results.jsonBody().keys()))
def test_login_as_team(self):
# login_as() logs in as a member of a team if it's given a team.
team = self.factory.makeTeam()
logout()
login_as(team)
person = self.getLoggedInPerson()
self.assertTrue(person.inTeam(team))
def test_cancel_build(self):
"""An admin can cancel a build."""
queue = self.factory.makeSourcePackageRecipeBuildJob()
build = queue.specific_job.build
transaction.commit()
build_url = canonical_url(build)
logout()
browser = self.getUserBrowser(build_url, user=self.admin)
browser.getLink('Cancel build').click()
self.assertEqual(
browser.getLink('Cancel').url,
build_url)
browser.getControl('Cancel build').click()
self.assertEqual(
browser.url,
build_url)
login(ANONYMOUS)
self.assertEqual(
BuildStatus.SUPERSEDED,
build.status)
def test_rescore_build(self):
"""An admin can rescore a build."""
queue = self.factory.makeSourcePackageRecipeBuildJob()
build = queue.specific_job.build
transaction.commit()
build_url = canonical_url(build)
logout()
browser = self.getUserBrowser(build_url, user=self.admin)
browser.getLink('Rescore build').click()
self.assertEqual(
browser.getLink('Cancel').url,
build_url)
browser.getControl('Score').value = '1024'
browser.getControl('Rescore build').click()
self.assertEqual(
browser.url,
build_url)
login(ANONYMOUS)
self.assertEqual(
build.buildqueue_record.lastscore,
1024)
def tearDown(self):
"""Zero out the gpg database"""
# XXX Stuart Bishop 2005-10-27:
# This should be a zope test cleanup thing per SteveA.
self.gpg_handler.resetLocalState()
logout()
super(TestImportKeyRing, self).tearDown()
def test_new_duplicate_name(self):
# An attempt to create a SnapBase with a duplicate name is rejected.
person = self.factory.makeRegistryExpert()
distroseries = self.factory.makeDistroSeries()
distroseries_url = api_url(distroseries)
webservice = webservice_for_person(
person, permission=OAuthPermission.WRITE_PUBLIC)
webservice.default_api_version = "devel"
logout()
response = webservice.named_post(
"/+snap-bases",
"new",
name="dummy",
display_name="Dummy",
distro_series=distroseries_url,
build_channels={"snapcraft": "stable"})
self.assertEqual(201, response.status)
response = webservice.named_post(
"/+snap-bases",
"new",
name="dummy",
display_name="Dummy",
distro_series=distroseries_url,
build_channels={"snapcraft": "stable"})
self.assertEqual(400, response.status)
self.assertEqual("name: dummy is already in use by another base.",
response.body)
def __init__(self,
oauth_consumer_key=None,
oauth_access_key=None,
oauth_access_secret=None,
handle_errors=True,
domain='api.launchpad.dev',
protocol='http'):
"""Create a LaunchpadWebServiceCaller.
:param oauth_consumer_key: The OAuth consumer key to use.
:param oauth_access_key: The OAuth access key to use for the request.
:param handle_errors: Should errors raise exception or be handled by
the publisher. Default is to let the publisher handle them.
Other parameters are passed to the HTTPCaller used to make the calls.
"""
if oauth_consumer_key is not None and oauth_access_key is not None:
# XXX cjwatson 2016-01-25: Callers should be updated to pass
# Unicode directly, but that's a big change.
oauth_consumer_key = six.ensure_text(oauth_consumer_key)
self.consumer = OAuthConsumer(oauth_consumer_key, u'')
if oauth_access_secret is None:
oauth_access_secret = SAMPLEDATA_ACCESS_SECRETS.get(
oauth_access_key, u'')
self.access_token = OAuthToken(oauth_access_key,
oauth_access_secret)
# This shouldn't be here, but many old tests expect it.
logout()
else:
self.consumer = None
self.access_token = None
self.handle_errors = handle_errors
WebServiceCaller.__init__(self, handle_errors, domain, protocol)
def tearDown(self):
"""Zero out the gpg database"""
# XXX Stuart Bishop 2005-10-27:
# This should be a zope test cleanup thing per SteveA.
self.gpg_handler.resetLocalState()
logout()
super(TestImportKeyRing, self).tearDown()
def test_builder_index_public(self):
build = self.makeBuildingLiveFS()
builder_url = canonical_url(build.builder)
logout()
browser = self.getNonRedirectingBrowser(url=builder_url,
user=ANONYMOUS)
self.assertIn("tail of the log", browser.contents)
def test_login_celebrity(self):
# login_celebrity logs in a celebrity.
logout()
login_celebrity('vcs_imports')
vcs_imports = getUtility(ILaunchpadCelebrities).vcs_imports
person = self.getLoggedInPerson()
self.assertTrue(person.inTeam(vcs_imports))
def test_new(self):
# A registry expert can create a SnapBase.
person = self.factory.makeRegistryExpert()
distroseries = self.factory.makeDistroSeries()
distroseries_url = api_url(distroseries)
webservice = webservice_for_person(
person, permission=OAuthPermission.WRITE_PUBLIC)
webservice.default_api_version = "devel"
logout()
response = webservice.named_post(
"/+snap-bases",
"new",
name="dummy",
display_name="Dummy",
distro_series=distroseries_url,
build_channels={"snapcraft": "stable"})
self.assertEqual(201, response.status)
snap_base = webservice.get(response.getHeader("Location")).jsonBody()
with person_logged_in(person):
self.assertThat(
snap_base,
ContainsDict({
"registrant_link":
Equals(webservice.getAbsoluteUrl(api_url(person))),
"name":
Equals("dummy"),
"display_name":
Equals("Dummy"),
"distro_series_link":
Equals(webservice.getAbsoluteUrl(distroseries_url)),
"build_channels":
Equals({"snapcraft": "stable"}),
"is_default":
Is(False),
}))
def test_login_as_team(self):
# login_as() logs in as a member of a team if it's given a team.
team = self.factory.makeTeam()
logout()
login_as(team)
person = self.getLoggedInPerson()
self.assertTrue(person.inTeam(team))
def test_can_be_cancelled_is_exported(self):
# Check that the can_be_cancelled property is exported.
expected = self.build.can_be_cancelled
entry_url = api_url(self.build)
logout()
entry = self.webservice.get(entry_url, api_version='devel').jsonBody()
self.assertEqual(expected, entry['can_be_cancelled'])
def test_login_celebrity(self):
# login_celebrity logs in a celebrity.
logout()
login_celebrity('vcs_imports')
vcs_imports = getUtility(ILaunchpadCelebrities).vcs_imports
person = self.getLoggedInPerson()
self.assertTrue(person.inTeam(vcs_imports))
def test_security(self):
# Attributes can only be set by buildd admins.
builder = self.factory.makeBuilder()
user = self.factory.makePerson()
user_webservice = webservice_for_person(
user, permission=OAuthPermission.WRITE_PUBLIC)
patch = dumps({'clean_status': 'Cleaning'})
logout()
# A normal user is unauthorized.
response = user_webservice.patch(api_url(builder),
'application/json',
patch,
api_version='devel')
self.assertEqual(401, response.status)
# But a buildd admin can set the attribute.
with admin_logged_in():
buildd_admins = getUtility(IPersonSet).getByName(
'launchpad-buildd-admins')
buildd_admins.addMember(user, buildd_admins.teamowner)
response = user_webservice.patch(api_url(builder),
'application/json',
patch,
api_version='devel')
self.assertEqual(209, response.status)
self.assertEqual('Cleaning', response.jsonBody()['clean_status'])
def test_properties(self):
# The basic properties of a LiveFSBuild are sensible.
db_build = self.factory.makeLiveFSBuild(
requester=self.person,
unique_key="foo",
metadata_override={"image_format": "plain"},
date_created=datetime(2014, 4, 25, 10, 38, 0, tzinfo=pytz.UTC))
build_url = api_url(db_build)
logout()
build = self.webservice.get(build_url).jsonBody()
with person_logged_in(self.person):
self.assertEqual(self.getURL(self.person), build["requester_link"])
self.assertEqual(self.getURL(db_build.livefs),
build["livefs_link"])
self.assertEqual(self.getURL(db_build.archive),
build["archive_link"])
self.assertEqual(self.getURL(db_build.distro_arch_series),
build["distro_arch_series_link"])
self.assertEqual("Release", build["pocket"])
self.assertEqual("foo", build["unique_key"])
self.assertEqual({"image_format": "plain"},
build["metadata_override"])
self.assertEqual("20140425-103800", build["version"])
self.assertIsNone(build["score"])
self.assertFalse(build["can_be_rescored"])
self.assertFalse(build["can_be_cancelled"])
def test_login_team_with_person(self):
# Calling login_team() with a person instead of a team raises a nice
# error.
person = self.factory.makePerson()
logout()
e = self.assertRaises(ValueError, login_team, person)
self.assertEqual(str(e), "Got person, expected team: %r" % (person,))
def test_login_with_email(self):
# login() logs a person in by email.
email = '*****@*****.**'
person = self.factory.makePerson(email=email)
logout()
login(email)
self.assertLoggedIn(person)
def test_login_team_with_person(self):
# Calling login_team() with a person instead of a team raises a nice
# error.
person = self.factory.makePerson()
logout()
e = self.assertRaises(ValueError, login_team, person)
self.assertEqual(str(e), "Got person, expected team: %r" % (person, ))
def test_login_with_email(self):
# login() logs a person in by email.
email = '*****@*****.**'
person = self.factory.makePerson(email=email)
logout()
login(email)
self.assertLoggedIn(person)
def test_can_be_cancelled_is_exported(self):
# Check that the can_be_cancelled property is exported.
expected = self.build.can_be_cancelled
entry_url = api_url(self.build)
logout()
entry = self.webservice.get(entry_url, api_version='devel').jsonBody()
self.assertEqual(expected, entry['can_be_cancelled'])
def test_attachments(self):
# A bug's attachments and the union of its messages' attachments
# are the same set.
with admin_logged_in():
bug = self.factory.makeBug()
created_attachment_ids = set(
self.factory.makeBugAttachment(bug).id for i in range(3))
bug_url = api_url(bug)
self.assertThat(created_attachment_ids, HasLength(3))
logout()
webservice = LaunchpadWebServiceCaller('test', None)
bug_attachments = webservice.get(
bug_url + '/attachments').jsonBody()['entries']
bug_attachment_ids = set(
int(att['self_link'].rsplit('/', 1)[1]) for att in bug_attachments)
self.assertContentEqual(created_attachment_ids, bug_attachment_ids)
messages = webservice.get(bug_url + '/messages').jsonBody()['entries']
message_attachments = []
for message in messages[1:]:
attachments_url = message['bug_attachments_collection_link']
attachments = webservice.get(attachments_url).jsonBody()['entries']
self.assertThat(attachments, HasLength(1))
message_attachments.append(attachments[0])
message_attachment_ids = set(
int(att['self_link'].rsplit('/', 1)[1])
for att in message_attachments)
self.assertContentEqual(bug_attachment_ids, message_attachment_ids)
def test_messages_query_counts_constant(self):
# XXX Robert Collins 2010-09-15 bug=619017
# This test may be thrown off by the reference bug. To get around the
# problem, flush and reset are called on the bug storm cache before
# each call to the webservice. When lp's storm is updated to release
# the committed fix for this bug, please see about updating this test.
login(USER_EMAIL)
bug = self.factory.makeBug()
store = Store.of(bug)
self.factory.makeBugComment(bug)
self.factory.makeBugComment(bug)
self.factory.makeBugComment(bug)
webservice = LaunchpadWebServiceCaller(
'launchpad-library', 'salgado-change-anything')
collector = QueryCollector()
collector.register()
self.addCleanup(collector.unregister)
url = '/bugs/%d/messages?ws.size=75' % bug.id
# First request.
store.flush()
store.reset()
response = webservice.get(url)
self.assertThat(collector, HasQueryCount(LessThan(24)))
with_2_count = collector.count
self.failUnlessEqual(response.status, 200)
login(USER_EMAIL)
for i in range(50):
self.factory.makeBugComment(bug)
self.factory.makeBugAttachment(bug)
logout()
# Second request.
store.flush()
store.reset()
response = webservice.get(url)
self.assertThat(collector, HasQueryCount(Equals(with_2_count)))
def test_messages_query_counts_constant(self):
# XXX Robert Collins 2010-09-15 bug=619017
# This test may be thrown off by the reference bug. To get around the
# problem, flush and reset are called on the bug storm cache before
# each call to the webservice. When lp's storm is updated to release
# the committed fix for this bug, please see about updating this test.
login(USER_EMAIL)
bug = self.factory.makeBug()
store = Store.of(bug)
self.factory.makeBugComment(bug)
self.factory.makeBugComment(bug)
self.factory.makeBugComment(bug)
webservice = LaunchpadWebServiceCaller('launchpad-library',
'salgado-change-anything')
collector = QueryCollector()
collector.register()
self.addCleanup(collector.unregister)
url = '/bugs/%d/messages?ws.size=75' % bug.id
# First request.
store.flush()
store.reset()
response = webservice.get(url)
self.assertThat(collector, HasQueryCount(LessThan(24)))
with_2_count = collector.count
self.failUnlessEqual(response.status, 200)
login(USER_EMAIL)
for i in range(50):
self.factory.makeBugComment(bug)
self.factory.makeBugAttachment(bug)
logout()
# Second request.
store.flush()
store.reset()
response = webservice.get(url)
self.assertThat(collector, HasQueryCount(Equals(with_2_count)))
def test_not_owner(self):
# If the registrant is not the owner or a member of the owner team,
# LiveFS creation fails.
other_person = self.factory.makePerson(displayname="Other Person")
other_team = self.factory.makeTeam(owner=other_person,
displayname="Other Team")
distroseries = self.factory.makeDistroSeries(registrant=self.person)
transaction.commit()
other_person_url = api_url(other_person)
other_team_url = api_url(other_team)
distroseries_url = api_url(distroseries)
logout()
response = self.webservice.named_post("/livefses",
"new",
owner=other_person_url,
distro_series=distroseries_url,
name="dummy",
metadata={})
self.assertEqual(401, response.status)
self.assertEqual(
"Test Person cannot create live filesystems owned by Other "
"Person.", response.body)
response = self.webservice.named_post("/livefses",
"new",
owner=other_team_url,
distro_series=distroseries_url,
name="dummy",
metadata={})
self.assertEqual(401, response.status)
self.assertEqual("Test Person is not a member of Other Team.",
response.body)
def makeLiveFS(self,
owner=None,
distroseries=None,
metadata=None,
webservice=None):
if owner is None:
owner = self.person
if distroseries is None:
distroseries = self.factory.makeDistroSeries(registrant=owner)
if metadata is None:
metadata = {"project": "flavour"}
if webservice is None:
webservice = self.webservice
transaction.commit()
distroseries_url = api_url(distroseries)
owner_url = api_url(owner)
logout()
response = webservice.named_post("/livefses",
"new",
owner=owner_url,
distro_series=distroseries_url,
name="flavour-desktop",
metadata=metadata)
self.assertEqual(201, response.status)
livefs = webservice.get(response.getHeader("Location")).jsonBody()
return livefs, distroseries_url
def test_renders_with_product_branch(self):
branch = self.factory.makeBranch()
login_person(branch.product.owner)
branch.product.development_focus.branch = branch
branch.updateScannedDetails(None, 0)
logout()
lp = launchpadlib_for("test")
list(lp.branches)
def _getBrowser(self, user=None):
if user is None:
browser = setupBrowser()
logout()
return browser
else:
login_person(user)
return setupBrowserForUser(user=user)
def test_getByName(self):
self.factory.makeProcessor(name='transmeta')
logout()
processor = self.webservice.named_get(
'/+processors', 'getByName', name='transmeta',
api_version='devel').jsonBody()
self.assertEquals('transmeta', processor['name'])
def setUp(self):
super(AddNominationTestMixin, self).setUp()
login('*****@*****.**')
self.user = self.factory.makePerson(name='ordinary-user')
self.bug_supervisor = self.factory.makePerson(name='no-ordinary-user')
self.owner = self.factory.makePerson(name='extraordinary-user')
self.setUpTarget()
logout()
def add_bug(self, count):
login_person(self.owner)
for i in range(count):
bug = self.factory.makeBug(target=self.product_milestone.product)
bug.bugtasks[0].transitionToMilestone(self.product_milestone, self.owner)
# This is necessary to test precaching of assignees.
bug.bugtasks[0].transitionToAssignee(self.factory.makePerson())
logout()
def test_person_logged_in_restores_logged_out(self):
# If we are logged out before the person_logged_in context, then we
# are logged out afterwards.
person = self.factory.makePerson()
logout()
with person_logged_in(person):
pass
self.assertLoggedOut()
def test_renders_with_product_branch(self):
branch = self.factory.makeBranch()
login_person(branch.product.owner)
branch.product.development_focus.branch = branch
branch.updateScannedDetails(None, 0)
logout()
lp = launchpadlib_for("test")
list(lp.branches)
def setUp(self):
super(AddNominationTestMixin, self).setUp()
login("*****@*****.**")
self.user = self.factory.makePerson(name="ordinary-user")
self.bug_supervisor = self.factory.makePerson(name="no-ordinary-user")
self.owner = self.factory.makePerson(name="extraordinary-user")
self.setUpTarget()
logout()
def _getBrowser(self, user=None):
if user is None:
browser = setupBrowser()
logout()
return browser
else:
login_person(user)
return setupBrowserForUser(user=user)
def test_exports_processor(self):
processor = self.factory.makeProcessor('s1')
builder = self.factory.makeBuilder(processor=processor)
logout()
entry = self.webservice.get(
api_url(builder), api_version='devel').jsonBody()
self.assertEndsWith(entry['processor_link'], '/+processors/s1')
def test_exports_processor(self):
processor = self.factory.makeProcessor('s1')
builder = self.factory.makeBuilder(processor=processor)
logout()
entry = self.webservice.get(api_url(builder),
api_version='devel').jsonBody()
self.assertEndsWith(entry['processor_link'], '/+processors/s1')
def test_person_logged_in_restores_logged_out(self):
# If we are logged out before the person_logged_in context, then we
# are logged out afterwards.
person = self.factory.makePerson()
logout()
with person_logged_in(person):
pass
self.assertLoggedOut()
def test_more_private_bugs_query_count_is_constant(self):
# This test tests that as we add more private bugs to a milestone
# index page, the number of queries issued by the page does not
# change. It also sets a cap on the queries for this page: if the
# baseline were to increase, the test would fail. As the baseline
# is very large already, if the test fails due to such a change,
# please cut some more of the existing fat out of it rather than
# increasing the cap.
page_query_limit = 37
product = self.factory.makeProduct()
product_owner = product.owner
login_person(product.owner)
milestone = self.factory.makeMilestone(productseries=product.development_focus)
bug1 = self.factory.makeBug(target=product, information_type=InformationType.USERDATA, owner=product.owner)
bug1.bugtasks[0].transitionToMilestone(milestone, product.owner)
# We look at the page as someone who is a member of a team and the
# team is subscribed to the bugs, so that we don't get trivial
# shortcuts avoiding queries : test the worst case.
subscribed_team = self.factory.makeTeam(membership_policy=TeamMembershipPolicy.MODERATED)
viewer = self.factory.makePerson()
with person_logged_in(subscribed_team.teamowner):
subscribed_team.addMember(viewer, subscribed_team.teamowner)
bug1.subscribe(subscribed_team, product.owner)
bug1_url = canonical_url(bug1)
milestone_url = canonical_url(milestone)
browser = self.getUserBrowser(user=viewer)
# Seed the cookie cache and any other cross-request state we may gain
# in future. See lp.services.webapp.serssion: _get_secret.
browser.open(milestone_url)
collector = QueryCollector()
collector.register()
self.addCleanup(collector.unregister)
browser.open(milestone_url)
# Check that the test found the bug
self.assertTrue(bug1_url in browser.contents)
self.assertThat(collector, HasQueryCount(LessThan(page_query_limit)))
with_1_private_bug = collector.count
with_1_queries = ["%s: %s" % (pos, stmt[3]) for (pos, stmt) in enumerate(collector.queries)]
login_person(product_owner)
bug2 = self.factory.makeBug(target=product, information_type=InformationType.USERDATA, owner=product.owner)
bug2.bugtasks[0].transitionToMilestone(milestone, product.owner)
bug2.subscribe(subscribed_team, product.owner)
bug2_url = canonical_url(bug2)
bug3 = self.factory.makeBug(target=product, information_type=InformationType.USERDATA, owner=product.owner)
bug3.bugtasks[0].transitionToMilestone(milestone, product.owner)
bug3.subscribe(subscribed_team, product.owner)
logout()
browser.open(milestone_url)
self.assertTrue(bug2_url in browser.contents)
self.assertThat(collector, HasQueryCount(LessThan(page_query_limit)))
with_3_private_bugs = collector.count
with_3_queries = ["%s: %s" % (pos, stmt[3]) for (pos, stmt) in enumerate(collector.queries)]
self.assertEqual(
with_1_private_bug,
with_3_private_bugs,
"different query count: \n%s\n******************\n%s\n"
% ("\n".join(with_1_queries), "\n".join(with_3_queries)),
)
def add_bug(self, count):
login_person(self.owner)
for i in range(count):
bug = self.factory.makeBug(target=self.product_milestone.product)
bug.bugtasks[0].transitionToMilestone(self.product_milestone,
self.owner)
# This is necessary to test precaching of assignees.
bug.bugtasks[0].transitionToAssignee(self.factory.makePerson())
logout()
def requestJobByUserWithDisplayName(self, code_import_id, displayname):
"""Record a request for the job by a user with the given name."""
self.factory.loginAsAnyone()
try:
getUtility(ICodeImportJobWorkflow).requestJob(
getUtility(ICodeImportSet).get(code_import_id).import_job,
self.factory.makePerson(displayname=displayname))
finally:
logout()
def test_login_different_person_overrides(self):
# Calling login_person a second time with a different person changes
# the currently logged in user.
a = self.factory.makePerson()
b = self.factory.makePerson()
logout()
login_person(a)
login_person(b)
self.assertLoggedIn(b)
def setupBrowserForUser(user):
"""Setup a browser grabbing details from a user.
:param user: The user to use.
"""
naked_user = removeSecurityProxy(user)
email = naked_user.preferredemail.email
logout()
return setupBrowser(auth="Basic %s:test" % str(email))
def test_builder_is_exported(self):
# The builder property is exported.
self.build.updateStatus(
BuildStatus.FULLYBUILT, builder=self.factory.makeBuilder())
build_url = api_url(self.build)
builder_url = api_url(self.build.builder)
logout()
entry = self.webservice.get(build_url, api_version='devel').jsonBody()
self.assertEndsWith(entry['builder_link'], builder_url)
def setupBrowserForUser(user):
"""Setup a browser grabbing details from a user.
:param user: The user to use.
"""
naked_user = removeSecurityProxy(user)
email = naked_user.preferredemail.email
logout()
return setupBrowser(auth="Basic %s:test" % str(email))
def test_builder_is_exported(self):
# The builder property is exported.
self.build.updateStatus(
BuildStatus.FULLYBUILT, builder=self.factory.makeBuilder())
build_url = api_url(self.build)
builder_url = api_url(self.build.builder)
logout()
entry = self.webservice.get(build_url, api_version='devel').jsonBody()
self.assertEndsWith(entry['builder_link'], builder_url)
def test_login_different_person_overrides(self):
# Calling login_person a second time with a different person changes
# the currently logged in user.
a = self.factory.makePerson()
b = self.factory.makePerson()
logout()
login_person(a)
login_person(b)
self.assertLoggedIn(b)
def test_xhtml_email_address_obfuscated(self):
# Email addresses are obfuscated in the XML representation for
# anonymous users.
bug = self._makeBug()
logout()
webservice = LaunchpadWebServiceCaller()
result = webservice(
ws_url(bug), headers={'Accept': 'application/xhtml+xml'})
self.assertNotIn(self.email_address, result.body)
self.assertIn(self.email_address_obfuscated_escaped, result.body)
def test_xhtml_email_address_obfuscated(self):
# Email addresses are obfuscated in the XML representation for
# anonymous users.
bug = self._makeBug()
logout()
webservice = LaunchpadWebServiceCaller()
result = webservice(ws_url(bug),
headers={'Accept': 'application/xhtml+xml'})
self.assertNotIn(self.email_address, result.body)
self.assertIn(self.email_address_obfuscated_escaped, result.body)
def test_change_status_does_update(self):
# Changing the status of a bugtask does change date_last_updated.
(bug, owner, webservice) = self.make_old_bug()
task_url = api_url(bug.default_bugtask)
date_last_updated = bug.date_last_updated
logout()
response = webservice.patch(
task_url, 'application/json', dumps(dict(status='Invalid')))
self.assertEqual(209, response.status)
with person_logged_in(owner):
self.assertNotEqual(date_last_updated, bug.date_last_updated)
def test_cancel_security(self):
# Check that unauthorised users cannot call cancel()
build_url = api_url(self.build)
webservice = webservice_for_person(
self.factory.makePerson(), permission=OAuthPermission.WRITE_PUBLIC)
logout()
entry = webservice.get(build_url, api_version='devel').jsonBody()
response = webservice.named_post(
entry['self_link'], 'cancel', api_version='devel')
self.assertEqual(401, response.status)
def test_display_no_request(self):
# If there is no request, there is no reason to show a message in
# the browser.
product, user = self.make_product_user([License.GNU_GPL_V2])
# Using the proxied product leads to an exeception when
# notification.display() below is called because the permission
# checks product require an interaction.
notification = LicenseNotification(removeSecurityProxy(product))
logout()
result = notification.display()
self.assertIs(False, result)
def test_cancel_is_exported(self):
# Check that the cancel() named op is exported.
build_url = api_url(self.build)
self.build.queueBuild()
logout()
entry = self.webservice.get(build_url, api_version='devel').jsonBody()
response = self.webservice.named_post(
entry['self_link'], 'cancel', api_version='devel')
self.assertEqual(200, response.status)
entry = self.webservice.get(build_url, api_version='devel').jsonBody()
self.assertEqual(BuildStatus.CANCELLED.title, entry['buildstate'])
def test_delete_branch_with_stacked_branch_errors(self):
# When trying to delete a branch that cannot be deleted, the
# error is raised across the webservice instead of oopsing.
login_person(self.branch_owner)
self.factory.makeBranch(
stacked_on=self.branch, owner=self.branch_owner)
logout()
target_branch = self.lp.branches.getByUniqueName(
unique_name='~jimhenson/fraggle/rock')
api_error = self.assertRaises(BadRequest, target_branch.lp_delete)
self.assertIn('Cannot delete', api_error.content)
def test_view_filters_security_wisely(self):
# There are bugs in the sharingdetails view that not everyone with
# `launchpad.Driver` -- the permission level for the page -- should be
# able to see.
pillarperson = self.getPillarPerson(security=True)
logout()
login_person(self.driver)
view = create_initialized_view(pillarperson, '+index')
# The page loads
self.assertEqual(pillarperson.person.displayname, view.page_title)
# The bug, which is not shared with the driver, is not included.
self.assertEqual(0, view.shared_bugs_count)
def test_subscribe_does_not_update(self):
# Calling subscribe over the API does not update date_last_updated.
(bug, owner, webservice) = self.make_old_bug()
subscriber = self.factory.makePerson()
date_last_updated = bug.date_last_updated
api_sub = api_url(subscriber)
bug_url = api_url(bug)
logout()
response = webservice.named_post(bug_url, 'subscribe', person=api_sub)
self.assertEqual(200, response.status)
with person_logged_in(owner):
self.assertEqual(date_last_updated, bug.date_last_updated)
def test_email_address_obfuscated(self):
# Email addresses are obfuscated for anonymous users.
bug = self._makeBug()
logout()
webservice = LaunchpadWebServiceCaller()
result = webservice(ws_url(bug)).jsonBody()
self.assertEqual(
self.bug_title % self.email_address_obfuscated,
result['title'])
self.assertEqual(
self.bug_description % self.email_address_obfuscated,
result['description'])
