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_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_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_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_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