def test_access_for_persons_with_special_permissions(self): # Admins have access all products, including inactive and propretary # products. with celebrity_logged_in('admin'): self.check_admin_access() # Commercial admins have access to all products. with celebrity_logged_in('commercial_admin'): self.check_admin_access()
def test_celebrity_logged_in(self): # celebrity_logged_in runs in a context where a celebrity is logged # in. vcs_imports = getUtility(ILaunchpadCelebrities).vcs_imports with celebrity_logged_in('vcs_imports'): person = self.getLoggedInPerson() self.assertTrue(person.inTeam(vcs_imports))
def test_inGoodStanding(self): self.factory.makePerson(email='*****@*****.**') yes_person = self.factory.makePerson(email='*****@*****.**') with celebrity_logged_in('admin'): yes_person.personal_standing = PersonalStanding.GOOD self.assertIs(True, self.api.inGoodStanding('*****@*****.**')) self.assertIs(False, self.api.inGoodStanding('*****@*****.**'))
def test_close_bugs_for_sourcepackagerelease_with_private_bug(self): """close_bugs_for_sourcepackagerelease works with private bugs.""" changes_file_template = "Format: 1.7\nLaunchpad-bugs-fixed: %s\n" # changelog_entry is required for an assertion inside the function # we're testing. spr = self.factory.makeSourcePackageRelease(changelog_entry="blah") archive_admin = self.factory.makePerson() series = spr.upload_distroseries dsp = series.distribution.getSourcePackage(spr.sourcepackagename) bug = self.factory.makeBug( target=dsp, information_type=InformationType.USERDATA) changes = StringIO(changes_file_template % bug.id) with person_logged_in(archive_admin): # The archive admin user can't normally see this bug. self.assertRaises(ForbiddenAttribute, bug, 'status') # But the bug closure should work. close_bugs_for_sourcepackagerelease(series, spr, changes) # Rather than closing the bugs immediately, this creates a # ProcessAcceptedBugsJob. with celebrity_logged_in("admin"): self.assertEqual(BugTaskStatus.NEW, bug.default_bugtask.status) job_source = getUtility(IProcessAcceptedBugsJobSource) [job] = list(job_source.iterReady()) self.assertEqual(series, job.distroseries) self.assertEqual(spr, job.sourcepackagerelease) self.assertEqual([bug.id], job.bug_ids)
def create_child(factory): processor = factory.makeProcessor() parent = factory.makeDistroSeries() parent_das = factory.makeDistroArchSeries(distroseries=parent, processor=processor) lf = factory.makeLibraryFileAlias() # Since the LFA needs to be in the librarian, commit. transaction.commit() parent_das.addOrUpdateChroot(lf) with celebrity_logged_in("admin"): parent_das.supports_virtualized = True parent.nominatedarchindep = parent_das publisher = SoyuzTestPublisher() publisher.prepareBreezyAutotest() packages = {"udev": "0.1-1", "libc6": "2.8-1"} for package in packages.keys(): publisher.getPubBinaries( distroseries=parent, binaryname=package, version=packages[package], status=PackagePublishingStatus.PUBLISHED, ) test1 = getUtility(IPackagesetSet).new(u"test1", u"test 1 packageset", parent.owner, distroseries=parent) test1_packageset_id = str(test1.id) test1.addSources("udev") parent.updatePackageCount() child = factory.makeDistroSeries() getUtility(ISourcePackageFormatSelectionSet).add(child, SourcePackageFormat.FORMAT_1_0) # Make sure everything hits the database, switching db users aborts. transaction.commit() return parent, child, test1_packageset_id
def test_subscribeGrantsVisibility(self): # When a user is subscribed to a bug, they are granted access. user = self.factory.makePerson() self.assertFalse(self.bug.userCanView(user)) with celebrity_logged_in('admin'): self.bug.subscribe(user, self.owner) self.assertTrue(self.bug.userCanView(user))
def set_service_usage(pillar_name, **kw): factory = LaunchpadObjectFactory() with celebrity_logged_in('admin'): pillar = getUtility(IPillarNameSet)[pillar_name] for attr, service_usage_name in kw.items(): service_usage = getattr(ServiceUsage, service_usage_name) if attr == 'bug_tracking_usage': pillar.official_malone = ( service_usage == ServiceUsage.LAUNCHPAD) if service_usage == ServiceUsage.EXTERNAL: pillar.bugtracker = factory.makeBugTracker() # if we're setting codehosting on product things get trickier. elif attr == 'codehosting_usage' and IProduct.providedBy(pillar): if service_usage == ServiceUsage.LAUNCHPAD: branch = factory.makeProductBranch(product=pillar) product_series = factory.makeProductSeries( product=pillar, branch=branch) pillar.development_focus = product_series elif service_usage == ServiceUsage.EXTERNAL: branch = factory.makeProductBranch( product=pillar, branch_type=BranchType.MIRRORED) product_series = factory.makeProductSeries( product=pillar, branch=branch) pillar.development_focus = product_series elif service_usage == ServiceUsage.UNKNOWN: branch = factory.makeProductBranch(product=pillar) product_series = factory.makeProductSeries( product=pillar) pillar.development_focus = product_series else: setattr(pillar, attr, service_usage)
def _do_premerge(self, from_person, to_person): # Do the pre merge work performed by the LoginToken. with celebrity_logged_in('admin'): email = from_person.preferredemail email.status = EmailAddressStatus.NEW email.person = to_person transaction.commit()
def test_celebrity_logged_in_restores_person(self): # Once outside of the celebrity_logged_in context, the originally # logged-in person is re-logged in. person = self.factory.makePerson() login_as(person) with celebrity_logged_in('vcs_imports'): pass self.assertLoggedIn(person)
def test_admin_can_set_visible(self): # Admins can set question comment # visibility. with celebrity_logged_in('admin') as admin: person = admin question = self._get_question_for_user(person) self._set_visibility(question) self.assertFalse(self.message.visible)
def test_registry_admin_can_set_visible(self): # Members of registry experts can set question comment # visibility. with celebrity_logged_in('registry_experts') as registry: person = registry question = self._get_question_for_user(person) self._set_visibility(question) self.assertFalse(self.message.visible)
def test_inactive_product_groups_are_excluded(self): # Inactive project groups are not in the vocabulary. with celebrity_logged_in("registry_experts"): self.project_group.active = False terms = self.vocabulary.searchForTerms("snark") result = [term.value for term in terms] self.assertEqual([self.product, self.distribution], result) self.assertFalse(self.project_group in self.vocabulary)
def test_inaccessible_private_bug_not_found(self): # Private bugs don't acknowledge their existence to non-subscribers. with celebrity_logged_in('admin'): getUtility(IBugSet).get(4).setPrivate( True, self.factory.makePerson()) message = self.getFailureForMessage('*****@*****.**') self.assertIn( "There is no such bug in Launchpad: 4", message)
def test_privateBugUnsubscribeRevokesVisibility(self): # A person unsubscribed from a private bug can no longer see it. user = self.factory.makePerson() with celebrity_logged_in('admin'): self.bug.subscribe(user, self.owner) self.assertTrue(self.bug.userCanView(user)) self.bug.unsubscribe(user, self.owner) self.assertFalse(self.bug.userCanView(user))
def makeHiddenMessage(self): """Required by the mixin.""" with celebrity_logged_in('admin'): bug = self.factory.makeBug() comment = self.factory.makeBugComment( bug=bug, body=self.comment_text) comment.visible = False return bug
def test_links_admin(self): # An admin can change details and administer a project group. with celebrity_logged_in('admin'): user = getUtility(ILaunchBag).user view = create_initialized_view( self.project_group, '+index', principal=user) contents = view.render() self.assertThat(contents, Contains("Change details")) self.assertThat(contents, Contains("Administer"))
def test_bugs_answers_usage_bugs(self): # The dict values are True for bugs and either. with celebrity_logged_in('admin'): self.dsp.distribution.official_malone = True view = create_view(self.dsp, '+index') self.assertTrue(view.bugs_answers_usage['uses_bugs']) self.assertFalse(view.bugs_answers_usage['uses_answers']) self.assertFalse(view.bugs_answers_usage['uses_both']) self.assertTrue(view.bugs_answers_usage['uses_either'])
def test_privileged_users_can_approve(self): product = self.factory.makeProduct(driver=self.factory.makePerson()) series = self.factory.makeProductSeries(product=product) with celebrity_logged_in("admin"): series.driver = self.factory.makePerson() nomination = self.factory.makeBugNomination(target=series) self.assertTrue(nomination.canApprove(product.owner)) self.assertTrue(nomination.canApprove(product.driver)) self.assertTrue(nomination.canApprove(series.driver))
def test_bugs_answers_usage_answers(self): # The dict values are True for answers and either. with celebrity_logged_in('admin'): self.dsp.distribution.answers_usage = ServiceUsage.LAUNCHPAD view = create_view(self.dsp, '+index') self.assertFalse(view.bugs_answers_usage['uses_bugs']) self.assertTrue(view.bugs_answers_usage['uses_answers']) self.assertFalse(view.bugs_answers_usage['uses_both']) self.assertIs(True, view.bugs_answers_usage['uses_either'])
def test_getBranchesWithVisibleBugs_hides_private_bugs_from_anon(self): # getBranchesWithVisibleBugs does not show private bugs to users # who aren't logged in. branch = self.factory.makeBranch() bug = self.factory.makeBug(information_type=InformationType.USERDATA) with celebrity_logged_in('admin'): bug.linkBranch(branch, self.factory.makePerson()) utility = getUtility(IBugBranchSet) self.assertContentEqual( [], utility.getBranchesWithVisibleBugs([branch], None))
def test_bugs_answers_usage_both(self): # The dict values are all True. with celebrity_logged_in('admin'): self.dsp.distribution.official_malone = True self.dsp.distribution.answers_usage = ServiceUsage.LAUNCHPAD view = create_view(self.dsp, '+index') self.assertTrue(view.bugs_answers_usage['uses_bugs']) self.assertTrue(view.bugs_answers_usage['uses_answers']) self.assertTrue(view.bugs_answers_usage['uses_both']) self.assertTrue(view.bugs_answers_usage['uses_either'])
def test_getBranchesWithVisibleBugs_shows_private_bugs_to_admins(self): # getBranchesWithVisibleBugs will show private bugs to admins. branch = self.factory.makeBranch() bug = self.factory.makeBug(information_type=InformationType.USERDATA) with celebrity_logged_in('admin'): bug.linkBranch(branch, self.factory.makePerson()) utility = getUtility(IBugBranchSet) admin = getUtility(ILaunchpadCelebrities).admin self.assertContentEqual( [branch.id], utility.getBranchesWithVisibleBugs([branch], admin))
def test_getBranchesWithVisibleBugs_shows_public_bugs_to_anon(self): # getBranchesWithVisibleBugs shows public bugs to anyone, # including anonymous users. branch = self.factory.makeBranch() bug = self.factory.makeBug() with celebrity_logged_in('admin'): bug.linkBranch(branch, self.factory.makePerson()) utility = getUtility(IBugBranchSet) self.assertContentEqual( [branch.id], utility.getBranchesWithVisibleBugs([branch], None))
def test_any_component_uploader_can_approve_for_no_package(self): # An uploader for any component can approve a nomination without # a package. series = self.factory.makeDistroSeries() with celebrity_logged_in("admin"): perm = series.main_archive.newComponentUploader(self.factory.makePerson(), self.factory.makeComponent()) nomination = self.factory.makeBugNomination(target=series) self.assertFalse(nomination.canApprove(self.factory.makePerson())) self.assertTrue(nomination.canApprove(perm.person))
def test_links_registry_expert(self): # A registry expert cannot change details but can administer a project # group. with celebrity_logged_in('registry_experts'): user = getUtility(ILaunchBag).user view = create_initialized_view( self.project_group, '+index', principal=user) contents = view.render() self.assertThat(contents, Not(Contains("Change details"))) self.assertThat(contents, Contains("Administer"))
def test_non_subscriber_with_good_standing_is_approved(self): # Non-subscribers with good standing are approved to post. with celebrity_logged_in('admin'): self.lp_user.personal_standing = PersonalStanding.GOOD message = self.makeMailmanMessage( self.mm_list, self.lp_user_email, 'subject', 'any content.') msg_data = {} silence = LPStanding.process(self.mm_list, message, msg_data) self.assertEqual(None, silence) self.assertTrue(msg_data['approved'])
def setUp(self): super(TestQuestionRepresentation, self).setUp() with celebrity_logged_in('admin'): self.question = self.factory.makeQuestion( title="This is a question") self.target_name = self.question.target.name self.webservice = LaunchpadWebServiceCaller( 'launchpad-library', 'salgado-change-anything') self.webservice.default_api_version = 'devel'
def test_getBranchesWithVisibleBugs_ignores_extra_bugs(self): # getBranchesWithVisibleBugs reports a branch only once even if # it's liked to multiple bugs. branch = self.factory.makeBranch() user = self.factory.makePerson() with celebrity_logged_in('admin'): self.factory.makeBug().linkBranch(branch, user) self.factory.makeBug().linkBranch(branch, user) utility = getUtility(IBugBranchSet) self.assertContentEqual( [branch.id], utility.getBranchesWithVisibleBugs([branch], user))
def test_redirect_name_success(self): # The view redirects to the bug when it is found. bug = self.factory.makeBug() with celebrity_logged_in('admin'): bug.name = 'bingo' form = dict(id='bingo') view = create_initialized_view( self.application, name='+index', layer=BugsLayer, form=form) self.assertEqual(None, view.error_message) self.assertEqual( canonical_url(bug), view.request.response.getHeader('Location'))
def test_provides_commercial_subscription_expired(self): product = self.factory.makeProduct(name='fnord') self.factory.makeCommercialSubscription(product) import datetime import pytz then = datetime.datetime(2005, 6, 15, 0, 0, 0, 0, pytz.UTC) with celebrity_logged_in('admin'): product.commercial_subscription.date_expires = then self.assertEqual( 'Commercial Subscription: Expired', self.getPickerEntry(product).details[1])
def test_getReviewableTranslationFiles_project_deactivated(self): # Deactive project are excluded from the list. from lp.testing import celebrity_logged_in with celebrity_logged_in('admin'): self.product.active = False self.assertEqual([], self._getReviewables())
def test_privateBugSubscriber(self): # A person subscribed to a private bug can see it. user = self.factory.makePerson() with celebrity_logged_in('admin'): self.bug.subscribe(user, self.owner) self.assertTrue(self.bug.userCanView(user))
def test_inactive_products_are_excluded(self): # Inactive products are not in the vocabulary. with celebrity_logged_in('registry_experts'): self.product.active = False result = self.vocabulary.search('bedbugs') self.assertEqual([], list(result))
def test_rosetta_expert_can_configure_translations(self): product = self.factory.makeProduct() with celebrity_logged_in('rosetta_experts'): view = create_view(product, '+translations') self.assertEqual(True, view.can_configure_translations())
def create_permission(): with celebrity_logged_in('admin'): ArchivePermission(archive=self.archive, person=self.factory.makePerson(), component=getUtility(IComponentSet)["main"], permission=ArchivePermissionType.UPLOAD)
def test_private(self): with celebrity_logged_in('commercial_admin') as person: ppa = person.createPPA(private=True) self.assertEqual(True, ppa.private)