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_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_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 test_requestBuild_not_owner(self):
# If the requester is not the owner or a member of the owner team,
# build requests are rejected.
other_team = self.factory.makeTeam(displayname="Other Team")
distroseries = self.factory.makeDistroSeries(registrant=self.person)
distroarchseries = self.factory.makeDistroArchSeries(
distroseries=distroseries, owner=self.person)
distroarchseries_url = api_url(distroarchseries)
archive_url = api_url(distroseries.main_archive)
other_webservice = webservice_for_person(
other_team.teamowner, permission=OAuthPermission.WRITE_PUBLIC)
other_webservice.default_api_version = "devel"
login(ANONYMOUS)
livefs, _ = self.makeLiveFS(owner=other_team,
distroseries=distroseries,
webservice=other_webservice)
response = self.webservice.named_post(
livefs["self_link"],
"requestBuild",
archive=archive_url,
distro_arch_series=distroarchseries_url,
pocket="Release")
self.assertEqual(401, response.status)
self.assertEqual(
"Test Person cannot create live filesystem builds owned by Other "
"Team.", response.body)
def test_requestBuild_rejects_repeats(self):
# Build requests are rejected if already pending.
distroseries = self.factory.makeDistroSeries(registrant=self.person)
distroarchseries = self.factory.makeDistroArchSeries(
distroseries=distroseries, owner=self.person)
distroarchseries_url = api_url(distroarchseries)
archive_url = api_url(distroseries.main_archive)
livefs, _ = self.makeLiveFS(distroseries=distroseries)
response = self.webservice.named_post(
livefs["self_link"],
"requestBuild",
archive=archive_url,
distro_arch_series=distroarchseries_url,
pocket="Release")
self.assertEqual(201, response.status)
response = self.webservice.named_post(
livefs["self_link"],
"requestBuild",
archive=archive_url,
distro_arch_series=distroarchseries_url,
pocket="Release")
self.assertEqual(400, response.status)
self.assertEqual(
"An identical build of this live filesystem image is already "
"pending.", response.body)
def test_set_target(self):
old_target = self.factory.makeProduct()
spec = self.factory.makeSpecification(product=old_target, name='foo')
new_target = self.factory.makeProduct(displayname='Fooix')
spec_url = api_url(spec)
new_target_url = api_url(new_target)
webservice = webservice_for_person(
old_target.owner, permission=OAuthPermission.WRITE_PRIVATE)
response = webservice.patch(spec_url,
"application/json",
json.dumps(
dict(target_link=new_target_url)),
api_version='devel')
self.assertEqual(301, response.status)
with admin_logged_in():
self.assertEqual(new_target, spec.target)
# Moving another spec with the same name fails.
other_spec = self.factory.makeSpecification(product=old_target,
name='foo')
other_spec_url = api_url(other_spec)
response = webservice.patch(other_spec_url,
"application/json",
json.dumps(
dict(target_link=new_target_url)),
api_version='devel')
self.assertEqual(400, response.status)
self.assertEqual("There is already a blueprint named foo for Fooix.",
response.body)
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_checkPermissions(self):
[ref] = self.factory.makeGitRefs()
owner = ref.owner
grantees = [self.factory.makePerson() for _ in range(2)]
self.factory.makeGitRuleGrant(repository=ref.repository,
ref_pattern=ref.path,
grantee=grantees[0],
can_create=True)
self.factory.makeGitRuleGrant(repository=ref.repository,
ref_pattern="*",
grantee=grantees[1],
can_force_push=True)
with person_logged_in(owner):
ref_url = api_url(ref)
owner_url = api_url(owner)
grantee_urls = [api_url(grantee) for grantee in grantees]
webservice = webservice_for_person(
owner, permission=OAuthPermission.WRITE_PUBLIC)
webservice.default_api_version = "devel"
response = webservice.named_get(ref_url,
"checkPermissions",
person=owner_url)
self.assertEqual(["create", "push"], json.loads(response.body))
response = webservice.named_get(ref_url,
"checkPermissions",
person=grantee_urls[0])
self.assertEqual(["create"], json.loads(response.body))
response = webservice.named_get(ref_url,
"checkPermissions",
person=grantee_urls[1])
self.assertEqual(["push", "force-push"], json.loads(response.body))
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_add_duplicate_bugtask_for_project_gives_bad_request(self):
bug = self.factory.makeBug()
product = self.factory.makeProduct()
product_url = api_url(product)
self.factory.makeBugTask(bug=bug, target=product)
launchpad = launchpadlib_for('test', bug.owner)
lp_bug = launchpad.load(api_url(bug))
self.assertRaises(BadRequest, lp_bug.addTask, target=product_url)
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_add_duplicate_bugtask_for_project_gives_bad_request(self):
bug = self.factory.makeBug()
product = self.factory.makeProduct()
product_url = api_url(product)
self.factory.makeBugTask(bug=bug, target=product)
launchpad = launchpadlib_for('test', bug.owner)
lp_bug = launchpad.load(api_url(bug))
self.assertRaises(
BadRequest, lp_bug.addTask, target=product_url)
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 setUp(self):
super(TestWebhookDelivery, self).setUp()
target = self.factory.makeGitRepository()
self.owner = target.owner
with person_logged_in(self.owner):
self.webhook = self.factory.makeWebhook(
target=target, delivery_url=u'http://example.com/ep')
self.webhook_url = api_url(self.webhook)
self.delivery = self.webhook.ping()
self.delivery_url = api_url(self.delivery)
self.webservice = webservice_for_person(
self.owner, permission=OAuthPermission.WRITE_PRIVATE)
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_setGrants(self):
[ref] = self.factory.makeGitRefs()
owner = ref.owner
grantee = self.factory.makePerson()
with person_logged_in(owner):
ref_url = api_url(ref)
grantee_url = api_url(grantee)
webservice = webservice_for_person(
owner, permission=OAuthPermission.WRITE_PUBLIC)
webservice.default_api_version = "devel"
response = webservice.named_post(ref_url,
"setGrants",
grants=[
{
"grantee_type":
"Repository owner",
"can_create": True,
"can_force_push": True,
},
{
"grantee_type": "Person",
"grantee_link": grantee_url,
"can_push": True,
},
])
self.assertEqual(200, response.status)
with person_logged_in(owner):
self.assertThat(
list(ref.repository.rules),
MatchesListwise([
MatchesStructure(
repository=Equals(ref.repository),
ref_pattern=Equals(ref.path),
creator=Equals(owner),
grants=MatchesSetwise(
MatchesStructure(
grantor=Equals(owner),
grantee_type=Equals(
GitGranteeType.REPOSITORY_OWNER),
grantee=Is(None),
can_create=Is(True),
can_push=Is(False),
can_force_push=Is(True)),
MatchesStructure(grantor=Equals(owner),
grantee_type=Equals(
GitGranteeType.PERSON),
grantee=Equals(grantee),
can_create=Is(False),
can_push=Is(True),
can_force_push=Is(False)))),
]))
def test_landing_targets(self):
bmp_db = self.factory.makeBranchMergeProposalForGit()
with person_logged_in(bmp_db.registrant):
bmp_url = api_url(bmp_db)
ref_url = api_url(bmp_db.source_git_ref)
webservice = webservice_for_person(
bmp_db.registrant, permission=OAuthPermission.READ_PUBLIC)
webservice.default_api_version = "devel"
ref = webservice.get(ref_url).jsonBody()
landing_targets = webservice.get(
ref["landing_targets_collection_link"]).jsonBody()
self.assertEqual(1, len(landing_targets["entries"]))
self.assertThat(landing_targets["entries"][0]["self_link"],
EndsWith(bmp_url))
def make_spph_for(self, person):
with person_logged_in(person):
spr = self.factory.makeSourcePackageRelease()
self.factory.makeSourcePackageReleaseFile(sourcepackagerelease=spr)
spph = self.factory.makeSourcePackagePublishingHistory(
sourcepackagerelease=spr)
return spph, api_url(spph)
def makeAPITarget(self, bug_policy):
project = self.factory.makeProduct(
licenses=[License.OTHER_PROPRIETARY])
target_url = api_url(project)
with person_logged_in(project.owner):
project.setBugSharingPolicy(bug_policy)
return target_url
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 test_creation_honor_product_sharing_policy(self):
# `ISpecificationSet.createSpecification` respect product
# specification_sharing_policy.
user = self.factory.makePerson()
product = self.factory.makeProduct(
owner=user,
specification_sharing_policy=(
SpecificationSharingPolicy.PROPRIETARY))
product_url = api_url(product)
webservice = webservice_for_person(
user, permission=OAuthPermission.WRITE_PRIVATE)
spec_name = 'test-prop'
response = webservice.named_post('/specs',
'createSpecification',
name=spec_name,
title='Proprietary',
specurl='http://test.com',
definition_status='Approved',
summary='A summary',
target=product_url,
api_version='devel')
self.assertEqual(201, response.status)
# The new specification was created as PROPROETARY.
response = webservice.get('%s/+spec/%s' % (product_url, spec_name))
self.assertEqual(200, response.status)
self.assertEqual('Proprietary',
response.jsonBody()['information_type'])
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_attributes(self):
[master] = self.factory.makeGitRefs(paths=["refs/heads/master"])
webservice = webservice_for_person(
master.repository.owner, permission=OAuthPermission.READ_PUBLIC)
webservice.default_api_version = "devel"
with person_logged_in(ANONYMOUS):
repository_url = api_url(master.repository)
master_url = api_url(master)
response = webservice.get(master_url)
self.assertEqual(200, response.status)
result = response.jsonBody()
self.assertThat(result["repository_link"], EndsWith(repository_url))
self.assertEqual("refs/heads/master", result["path"])
self.assertEqual(
unicode(hashlib.sha1("refs/heads/master").hexdigest()),
result["commit_sha1"])
def test_write_without_permission_gives_Unauthorized(self):
distro = self.factory.makeDistribution()
endInteraction()
lp = launchpadlib_for("anonymous-access")
lp_distro = lp.load(api_url(distro))
lp_distro.active = False
self.assertRaises(Unauthorized, lp_distro.lp_save)
def test_landing_targets_constant_queries(self):
project = self.factory.makeProduct()
with person_logged_in(project.owner):
source = self.factory.makeBranch(target=project)
source_url = api_url(source)
webservice = webservice_for_person(
project.owner, permission=OAuthPermission.WRITE_PRIVATE)
def create_mp():
with admin_logged_in():
branch = self.factory.makeBranch(
target=project,
stacked_on=self.factory.makeBranch(
target=project,
information_type=InformationType.PRIVATESECURITY),
information_type=InformationType.PRIVATESECURITY)
self.factory.makeBranchMergeProposal(source_branch=source,
target_branch=branch)
def list_mps():
webservice.get(source_url + '/landing_targets')
list_mps()
recorder1, recorder2 = record_two_runs(list_mps, create_mp, 2)
self.assertThat(recorder1, HasQueryCount(LessThan(30)))
self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
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_dependent_landings(self):
[ref] = self.factory.makeGitRefs()
bmp_db = self.factory.makeBranchMergeProposalForGit(
prerequisite_ref=ref)
with person_logged_in(bmp_db.registrant):
bmp_url = api_url(bmp_db)
ref_url = api_url(ref)
webservice = webservice_for_person(
bmp_db.registrant, permission=OAuthPermission.READ_PUBLIC)
webservice.default_api_version = "devel"
ref = webservice.get(ref_url).jsonBody()
dependent_landings = webservice.get(
ref["dependent_landings_collection_link"]).jsonBody()
self.assertEqual(1, len(dependent_landings["entries"]))
self.assertThat(dependent_landings["entries"][0]["self_link"],
EndsWith(bmp_url))
def test_representation(self):
with admin_logged_in():
faq = self.factory.makeFAQ(title="Nothing works")
with notify_modified(faq, ['keywords', 'content'], user=faq.owner):
faq.keywords = "foo bar"
faq.content = "It is all broken."
faq_url = api_url(faq)
webservice = webservice_for_person(self.factory.makePerson())
repr = webservice.get(faq_url, api_version='devel').jsonBody()
with admin_logged_in():
self.assertThat(
repr,
ContainsDict({
"id":
Equals(faq.id),
"title":
Equals("Nothing works"),
"keywords":
Equals("foo bar"),
"content":
Equals("It is all broken."),
"date_created":
MatchesRegex("\d\d\d\d-\d\d-\d\dT.*"),
"date_last_updated":
MatchesRegex("\d\d\d\d-\d\d-\d\dT.*"),
"last_updated_by_link":
Contains("/devel/~%s" % faq.owner.name),
"target_link":
Contains("/devel/%s" % faq.target.name),
}))
def make_bpph_for(self, person):
with person_logged_in(person):
bpr = self.factory.makeBinaryPackageRelease()
self.factory.makeBinaryPackageFile(binarypackagerelease=bpr)
bpph = self.factory.makeBinaryPackagePublishingHistory(
binarypackagerelease=bpr)
return bpph, api_url(bpph)
def setUp(self):
super(TestWebhookTargetBase, self).setUp()
self.target = self.makeTarget()
self.owner = self.target.owner
self.target_url = api_url(self.target)
self.webservice = webservice_for_person(
self.owner, permission=OAuthPermission.WRITE_PRIVATE)
def test_write_without_permission_gives_Unauthorized(self):
distro = self.factory.makeDistribution()
endInteraction()
lp = launchpadlib_for("anonymous-access")
lp_distro = lp.load(api_url(distro))
lp_distro.active = False
self.assertRaises(Unauthorized, lp_distro.lp_save)
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_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 makeAPITarget(self, bug_policy):
project = self.factory.makeProduct(
licenses=[License.OTHER_PROPRIETARY])
target_url = api_url(project)
with person_logged_in(project.owner):
project.setBugSharingPolicy(bug_policy)
return target_url
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_setAccountStatus(self):
person = self.factory.makePerson()
registrar = self.factory.makePerson(
name='registrar',
member_of=[getUtility(IPersonSet).getByName('registry')])
person_url = api_url(person)
# A normal user cannot set even their own account status.
webservice = webservice_for_person(
person, permission=OAuthPermission.WRITE_PRIVATE)
response = webservice.named_post(
person_url, 'setAccountStatus', status='Suspended',
comment='Go away', api_version='devel')
self.assertEqual(401, response.status)
# A member of ~registry can do what they wish.
webservice = webservice_for_person(
registrar, permission=OAuthPermission.WRITE_PRIVATE)
response = webservice.named_post(
person_url, 'setAccountStatus', status='Suspended',
comment='Go away', api_version='devel')
self.assertEqual(200, response.status)
with admin_logged_in():
self.assertEqual(AccountStatus.SUSPENDED, person.account_status)
self.assertEndsWith(
person.account_status_history,
'registrar: Active -> Suspended: Go away\n')
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 assertScoreReadableByAnyone(self, obj):
"""An object's build score is readable by anyone."""
with person_logged_in(obj.owner):
obj_url = api_url(obj)
removeSecurityProxy(obj).relative_build_score = 100
webservice = webservice_for_person(
self.factory.makePerson(), permission=OAuthPermission.WRITE_PUBLIC)
entry = webservice.get(obj_url, api_version="devel").jsonBody()
self.assertEqual(100, entry["relative_build_score"])
def test_add_invalid_bugtask_to_proprietary_bug_gives_bad_request(self):
# Test we get an error when we attempt to invalidly add a bug task to
# a proprietary bug. In this case, we cannot mark a proprietary bug
# as affecting more than one project.
owner = self.factory.makePerson()
product1 = self.factory.makeProduct(
bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
product2 = self.factory.makeProduct(
bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
product2_url = api_url(product2)
bug = self.factory.makeBug(
target=product1, owner=owner,
information_type=InformationType.PROPRIETARY)
login_person(owner)
launchpad = launchpadlib_for('test', owner)
lp_bug = launchpad.load(api_url(bug))
self.assertRaises(
BadRequest, lp_bug.addTask, target=product2_url)
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_add_attachment_with_bad_filename_raises_exception(self):
# Test that addAttachment raises BadRequest when the filename given
# contains slashes.
owner = self.factory.makePerson()
bug = self.factory.makeBug(owner=owner)
login_person(owner)
launchpad = launchpadlib_for('test', owner)
lp_bug = launchpad.load(api_url(bug))
self.assertRaises(
BadRequest, lp_bug.addAttachment, comment='foo', data='foo',
filename='/home/foo/bar.txt')
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_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_createMergeProposal_fails_if_source_and_target_are_equal(self):
source = self.factory.makeBranch()
source_url = api_url(source)
lp = launchpadlib_for("test", source.owner.name)
source = lp.load(source_url)
exception = self.assertRaises(
BadRequest, source.createMergeProposal,
target_branch=source, initial_comment='Merge\nit!',
needs_review=True, commit_message='It was merged!\n')
self.assertEquals(
exception.content,
'Source and target branches must be different.')
def test_createMergeProposal_fails_if_reviewers_and_review_types_are_different_sizes(self):
source = self.factory.makeBranch(name='rock')
source_url = api_url(source)
target = self.factory.makeBranch(
owner=source.owner, product=source.product,
name="roll")
target_url = api_url(target)
lp = launchpadlib_for("test", source.owner.name)
source = lp.load(source_url)
target = lp.load(target_url)
exception = self.assertRaises(
BadRequest, source.createMergeProposal,
target_branch=target, initial_comment='Merge\nit!',
needs_review=True, commit_message='It was merged!\n',
reviewers=[source.owner.self_link], review_types=[])
self.assertEquals(
exception.content,
'reviewers and review_types must be equal length.')
def assertScoreWriteableByTeam(self, obj, team):
"""Members of TEAM can change an object's build score."""
with person_logged_in(obj.owner):
obj_url = api_url(obj)
person = self.factory.makePerson(member_of=[team])
webservice = webservice_for_person(
person, permission=OAuthPermission.WRITE_PUBLIC)
entry = webservice.get(obj_url, api_version="devel").jsonBody()
response = webservice.patch(
entry["self_link"], "application/json",
dumps(dict(relative_build_score=100)))
self.assertEqual(209, response.status)
self.assertEqual(100, response.jsonBody()["relative_build_score"])
def test_messages(self):
# When one of the messages on a bug is linked to a parent that
# isn't linked to the bug, the webservice should still include
# that message in the bug's associated messages.
bug = self.webservice.load(api_url(self.bug))
messages = bug.messages
latest_message = [message for message in messages][-1]
self.failUnlessEqual(self.message2.subject, latest_message.subject)
# The parent_link for the latest message should be None
# because the parent is not a member of this bug's messages
# collection itself.
self.failUnlessEqual(None, latest_message.parent)
def assertScoreNotWriteableByOwner(self, obj):
"""Being an object's owner does not allow changing its build score.
This affects a site-wide resource, and is thus restricted to
launchpad-buildd-admins.
"""
with person_logged_in(obj.owner):
obj_url = api_url(obj)
webservice = webservice_for_person(
obj.owner, permission=OAuthPermission.WRITE_PUBLIC)
entry = webservice.get(obj_url, api_version="devel").jsonBody()
response = webservice.patch(
entry["self_link"], "application/json",
dumps(dict(relative_build_score=100)))
self.assertEqual(401, response.status)
new_entry = webservice.get(obj_url, api_version="devel").jsonBody()
self.assertEqual(0, new_entry["relative_build_score"])
def test_getBuildersForQueue(self):
g1 = self.factory.makeProcessor('g1')
quantum = self.factory.makeProcessor('quantum')
self.factory.makeBuilder(
processor=quantum, name='quantum_builder1')
self.factory.makeBuilder(
processor=quantum, name='quantum_builder2')
self.factory.makeBuilder(
processor=quantum, name='quantum_builder3', virtualized=False)
self.factory.makeBuilder(
processor=g1, name='g1_builder', virtualized=False)
logout()
results = self.webservice.named_get(
'/builders', 'getBuildersForQueue',
processor=api_url(quantum), virtualized=True,
api_version='devel').jsonBody()
self.assertEquals(
['quantum_builder1', 'quantum_builder2'],
sorted(builder['name'] for builder in results['entries']))
def test_many_subscribers(self):
# Many subscriptions do not cause an OOPS for IBug POSTs.
bug = self.factory.makeBug()
real_hard_limit_for_snapshot = snapshot.HARD_LIMIT_FOR_SNAPSHOT
snapshot.HARD_LIMIT_FOR_SNAPSHOT = 3
webservice = launchpadlib_for('test', 'salgado')
try:
login(ADMIN_EMAIL)
for count in range(snapshot.HARD_LIMIT_FOR_SNAPSHOT + 1):
person = self.factory.makePerson()
bug.subscribe(person, person)
logout()
lp_bug = webservice.load(api_url(bug))
# Adding one more subscriber through the web service
# doesn't cause an OOPS.
person_to_subscribe = webservice.load('/~name12')
lp_bug.subscribe(person=person_to_subscribe)
finally:
snapshot.HARD_LIMIT_FOR_SNAPSHOT = real_hard_limit_for_snapshot
