def test_proprietary_product_milestone(self): # Proprietary projects are not listed for people without access to # them. owner = self.factory.makePerson() public_product = self.factory.makeProduct( information_type=InformationType.PUBLIC, project=self.project_group, owner=owner) public_milestone = self.factory.makeMilestone(product=public_product) product = self.factory.makeProduct( information_type=InformationType.PROPRIETARY, project=self.project_group, owner=owner) milestone = self.factory.makeMilestone(product=product, name=public_milestone.name) (group_milestone,) = self.project_group.milestones self.factory.makeSpecification(milestone=public_milestone) with person_logged_in(owner): self.factory.makeSpecification(milestone=milestone) product_name = product.displayname with person_logged_in(None): owner_browser = self.getViewBrowser(group_milestone, user=owner) browser = self.getViewBrowser(group_milestone) self.assertIn(product_name, owner_browser.contents) self.assertIn(public_product.displayname, owner_browser.contents) self.assertNotIn(product_name, browser.contents) self.assertIn(public_product.displayname, browser.contents)
def setUp(self): super(TestTeamLimitedViewAccess, self).setUp() # Make a private team. team_owner = self.factory.makePerson() db_team = self.factory.makeTeam( name='private-team', owner=team_owner, visibility=PersonVisibility.PRIVATE, membership_policy=TeamMembershipPolicy.RESTRICTED) # Create a P3A for the team. with person_logged_in(team_owner): self.factory.makeArchive( owner=db_team, private=True, name='private-ppa') # Create an authorised user with limitedView permission on the team. # We do that by subscribing the team and the user to the same # private bug. self.bug_owner = self.factory.makePerson() bug = self.factory.makeBug( owner=self.bug_owner, information_type=InformationType.USERDATA) self.authorised_person = self.factory.makePerson() with person_logged_in(self.bug_owner): bug.subscribe(db_team, self.bug_owner) bug.subscribe(self.authorised_person, self.bug_owner) self.bug_id = bug.id self.factory.makeProduct(name='some-product', bug_supervisor=db_team) transaction.commit()
def test_mixed_product_projectgroup_milestone(self): # If a milestone is mixed between public and proprietary products, # only the public is shown to people without access. owner = self.factory.makePerson() teammember = self.factory.makePerson() owning_team = self.factory.makeTeam(owner=owner, membership_policy=TeamMembershipPolicy.RESTRICTED) with person_logged_in(owner): owning_team.addMember(teammember, owner) group = self.factory.makeProject(owner=owning_team) private = self.factory.makeProduct( project=group, owner=owner, information_type=InformationType.PROPRIETARY, name='private') public = self.factory.makeProduct( project=group, owner=owner, name='public') private_milestone = self.factory.makeMilestone( product=private, name='1.0') public_milestone = self.factory.makeMilestone( product=public, name='1.0') with person_logged_in(owner): self.factory.makeBug( target=private, owner=owner, milestone=private_milestone, title='This is the private bug') self.factory.makeBug( target=public, owner=owner, milestone=public_milestone, title='This is the public bug') group_milestone = group.milestones[0] browser = self.getViewBrowser( group_milestone, user=self.factory.makePerson()) self.assertTrue("This is the public bug" in browser.contents) self.assertFalse("This is the private bug" in browser.contents)
def test_user_without_launchpad_view(self): # When the user does not have launchpad.View on the context, user = self.factory.makePerson() owner = self.factory.makePerson() with person_logged_in(owner): team = self.factory.makeTeam( displayname='Waffles', owner=owner, visibility=PersonVisibility.PRIVATE) archive = self.factory.makeArchive(private=True, owner=team) archive.newSubscription(user, registrant=owner) with person_logged_in(user): for rootsite, view_name in [ (None, '+index'), ('code', '+branches'), ('bugs', '+bugs'), ('blueprints', '+specs'), ('answers', '+questions'), ('translations', '+translations')]: view = create_initialized_view( team, name=view_name, path_info='', principal=user, server_url=canonical_url(team, rootsite=rootsite), rootsite=rootsite) document = find_tag_by_id(view(), 'document') self.assertIsNone(document.find(True, id='side-portlets')) self.assertIsNone(document.find(True, id='registration')) self.assertEndsWith( extract_text(document.find(True, id='maincontent')), 'The information in this page is not shared with you.')
def test_data_subscription_lp_admin(self): # For a subscription, answercontact_data_js has can_edit # set to true for a Launchpad admin. question = self.factory.makeQuestion() member = self.factory.makePerson() contact = self.factory.makePerson( name='user', displayname='Contact Name') contact.addLanguage(getUtility(ILanguageSet)['en']) with person_logged_in(member): question.target.addAnswerContact(contact, contact) view = create_view(question.target, '+portlet-answercontacts-details') api_request = IWebServiceClientRequest(view.request) expected_result = { 'subscriber': { 'name': 'user', 'display_name': 'Contact Name', 'is_team': False, 'can_edit': True, 'web_link': canonical_url(contact), 'self_link': absoluteURL(contact, api_request) } } # Login as admin admin = getUtility(IPersonSet).find(ADMIN_EMAIL).any() with person_logged_in(admin): self.assertEqual( dumps([expected_result]), view.answercontact_data_js)
def test_referenced_oops_in_urls_bug_663249(self): # Sometimes OOPS ids appears as part of an URL. These should could as # a reference even though they are not formatted specially - this # requires somewhat special handling in the reference calculation # function. oopsid_old = "OOPS-abcdef1234" oopsid_new = "OOPS-4321" bug_old = self.factory.makeBug() bug_new = self.factory.makeBug() with person_logged_in(bug_old.owner): bug_old.description = ( "foo https://lp-oops.canonical.com/oops.py?oopsid=%s bar" % oopsid_old) with person_logged_in(bug_new.owner): bug_new.description = ( "foo https://oops.canonical.com/oops.py?oopsid=%s bar" % oopsid_new) self.store.flush() now = datetime.now(tz=utc) day = timedelta(days=1) self.failUnlessEqual( set([oopsid_old, oopsid_new]), referenced_oops(now - day, now, "product=1", {})) self.failUnlessEqual( set([]), referenced_oops(now + day, now + day, "product=1", {}))
def test_access_to_timeline_of_proprietary_product(self): # ITestTimelineProductSeries instances related to proprietary # products are visible only for person with a policy grant for # the product. owner = self.factory.makePerson() user_with_policy_grant = self.factory.makePerson() product = self.factory.makeProduct( owner=owner, information_type=InformationType.PROPRIETARY) series = self.factory.makeProductSeries(product=product) with person_logged_in(owner): timeline = series.getTimeline() getUtility(IService, 'sharing').sharePillarInformation( product, user_with_policy_grant, owner, {InformationType.PROPRIETARY: SharingPermission.ALL}) # Anonymous users do not have access. with person_logged_in(ANONYMOUS): for name in ( 'name', 'status', 'is_development_focus', 'uri', 'landmarks', 'product'): self.assertRaises(Unauthorized, getattr, timeline, name) # Ordinary users do not have access. with person_logged_in(self.factory.makePerson()): for name in ( 'name', 'status', 'is_development_focus', 'uri', 'landmarks', 'product'): self.assertRaises(Unauthorized, getattr, timeline, name) # Users with a policy grant have access. with person_logged_in(user_with_policy_grant): for name in ( 'name', 'status', 'is_development_focus', 'uri', 'landmarks', 'product'): # No exception is raised when attributes of timeline # are accessed. getattr(timeline, name)
def test_data_team_subscription_member_looks(self): # For a team subscription, answercontact_data_js has can_edit # set to true for team member. question = self.factory.makeQuestion() member = self.factory.makePerson() teamowner = self.factory.makePerson( name="team-owner", displayname="Team Owner") contact = self.factory.makeTeam( name='team', displayname='Team Name', owner=teamowner, members=[member]) contact.addLanguage(getUtility(ILanguageSet)['en']) with person_logged_in(contact.teamowner): question.target.addAnswerContact(contact, contact.teamowner) view = create_view(question.target, '+portlet-answercontacts-details') api_request = IWebServiceClientRequest(view.request) expected_result = { 'subscriber': { 'name': 'team', 'display_name': 'Team Name', 'is_team': True, 'can_edit': True, 'web_link': canonical_url(contact), 'self_link': absoluteURL(contact, api_request) } } with person_logged_in(contact.teamowner): self.assertEqual( dumps([expected_result]), view.answercontact_data_js)
def test_binary_query_counts(self): query_baseline = 40 # Assess the baseline. collector = QueryCollector() collector.register() self.addCleanup(collector.unregister) ppa = self.factory.makeArchive() viewer = self.factory.makePerson() browser = self.getUserBrowser(user=viewer) with person_logged_in(viewer): # The baseline has one package, because otherwise the # short-circuit prevents the packages iteration happening at # all and we're not actually measuring scaling # appropriately. pkg = self.factory.makeBinaryPackagePublishingHistory( archive=ppa) url = canonical_url(ppa) + "/+packages" browser.open(url) self.assertThat(collector, HasQueryCount(LessThan(query_baseline))) expected_count = collector.count # Use all new objects - avoids caching issues invalidating the # gathered metrics. login(ADMIN_EMAIL) ppa = self.factory.makeArchive() viewer = self.factory.makePerson() browser = self.getUserBrowser(user=viewer) with person_logged_in(viewer): for i in range(3): pkg = self.factory.makeBinaryPackagePublishingHistory( archive=ppa, distroarchseries=pkg.distroarchseries) url = canonical_url(ppa) + "/+packages" browser.open(url) self.assertThat(collector, HasQueryCount(Equals(expected_count)))
def test_goal_propose_decline_and_clear(self): # Webservice clients can decline and clear spec series goals. db_spec = self.factory.makeBlueprint(product=self.product, owner=self.proposer) # Propose for series goal with person_logged_in(self.proposer): launchpad = self.factory.makeLaunchpadService(person=self.proposer) spec = ws_object(launchpad, db_spec) series = ws_object(launchpad, self.series) spec.proposeGoal(goal=series) transaction.commit() self.assertEqual(db_spec.goal, self.series) self.assertFalse(spec.has_accepted_goal) with person_logged_in(self.driver): # Decline series goal launchpad = self.factory.makeLaunchpadService(person=self.driver) spec = ws_object(launchpad, db_spec) spec.declineGoal() transaction.commit() self.assertFalse(spec.has_accepted_goal) self.assertEqual(db_spec.goal, self.series) # Clear series goal as a driver spec.proposeGoal(goal=None) transaction.commit() self.assertIsNone(db_spec.goal)
def test_deptree_filters_blocked(self): # dep tree's blocked_specs and dependencies attributes filter # blueprints the user can't see. sharing_policy = SpecificationSharingPolicy.PUBLIC_OR_PROPRIETARY owner = self.factory.makePerson() product = self.factory.makeProduct( owner=owner, specification_sharing_policy=sharing_policy) root = self.factory.makeBlueprint(product=product) proprietary_blocked = self.factory.makeBlueprint( product=product, information_type=InformationType.PROPRIETARY) public_blocked = self.factory.makeBlueprint(product=product) proprietary_blocked.createDependency(root) public_blocked.createDependency(root) # Anonymous can see only the public with anonymous_logged_in(): view = create_view(root, name="+deptree") self.assertEqual([public_blocked], view.all_blocked) self.assertEqual([public_blocked], view.blocked_specs) # The owner can see everything. with person_logged_in(owner): view = create_view(root, name="+deptree") self.assertEqual( [proprietary_blocked, public_blocked], view.all_blocked) self.assertEqual( [proprietary_blocked, public_blocked], view.blocked_specs) # A random person cannot see the propriety dep. with person_logged_in(self.factory.makePerson()): view = create_view(root, name="+deptree") self.assertEqual([public_blocked], view.all_blocked) self.assertEqual([public_blocked], view.blocked_specs)
def test_mute_subscription_link_shown_for_team_subscription(self): # If the person belongs to a team with a structural subscription, # then the mute link will be displayed to them. person = self.factory.makePerson(name="a-person") team_owner = self.factory.makePerson(name="team-owner") team = self.factory.makeTeam(owner=team_owner, name="subscribed-team") with person_logged_in(team_owner): team.addMember(person, team_owner) self.target.addBugSubscription(team, team_owner) with person_logged_in(person): self.assertFalse(self.bug.isMuted(person)) self.assertTrue( self.bug.personIsAlsoNotifiedSubscriber( person), "Person should be a notified subscriber") view = create_initialized_view( self.bug, name="+portlet-subscription") self.assertTrue(view.user_should_see_mute_link, "User should see mute link.") contents = view.render() self.assertTrue('mute_subscription' in contents, "'mute_subscription' not in contents.") self.assertFalse( self._hasCSSClass( contents, 'mute-link-container', 'hidden')) create_initialized_view( self.bug.default_bugtask, name="+mute", form={'field.actions.mute': 'Mute bug mail'}) self.assertTrue(self.bug.isMuted(person))
def test_access_for_user_with_grant_for_private_product(self): # Users with a policy grant for a private product have access # to most attributes of the private product. user = self.factory.makePerson() with person_logged_in(self.proprietary_product_owner): bug = self.factory.makeBug( target=self.proprietary_product, owner=self.proprietary_product_owner) bug.subscribe(user, subscribed_by=self.proprietary_product_owner) with person_logged_in(user): self.assertAccessAuthorized( self.expected_get_permissions[CheckerPublic], self.proprietary_milestone) # They have access to attributes requiring the permission # launchpad.LimitedView of milestones for the private # product. self.assertAccessAuthorized( self.expected_get_permissions['launchpad.LimitedView'], self.proprietary_milestone) # They cannot access other attributes. for permission, names in self.expected_get_permissions.items(): if permission in ( CheckerPublic, 'launchpad.LimitedView'): continue self.assertAccessUnauthorized( names, self.proprietary_milestone) # They cannot change attributes. for names in self.expected_set_permissions.values(): self.assertChangeUnauthorized( names, self.proprietary_milestone)
def test_user_without_launchpad_view(self): # When the user does not have launchpad.View on the context, # base-layout does not render the main slot and side slot. owner = self.factory.makePerson() with person_logged_in(owner): team = self.factory.makeTeam( displayname='Waffles', owner=owner, visibility=PersonVisibility.PRIVATE) archive = self.factory.makeArchive(private=True, owner=team) archive.newSubscription(self.user, registrant=owner) with person_logged_in(self.user): view = self.makeTemplateView('main_side', context=team) content = BeautifulSoup(view()) self.assertIs(None, content.find(text=' Extra head content ')) self.verify_base_layout_html_element(content) self.verify_base_layout_head_parts(view, content) document = find_tag_by_id(content, 'document') self.verify_base_layout_body_parts(document) self.verify_watermark(document) # These parts are unique to the case without launchpad.View. self.assertIsNone(document.find(True, id='side-portlets')) self.assertIsNone(document.find(True, id='registration')) self.assertEndsWith( extract_text(document.find(True, id='maincontent')), 'The information in this page is not shared with you.')
def test_new_security_bug(self): # Structural subscribers are not notified of security bugs. maintainer = self.factory.makePerson(name='maintainer') project = self.factory.makeProduct(name='fnord', owner=maintainer) subscriber = self.factory.makePerson(name='subscriber') with person_logged_in(subscriber): project.addBugSubscription(subscriber, subscriber) transaction.commit() handler = MaloneHandler() with person_logged_in(project.owner): msg = self.factory.makeSignedMessage( body='bad thing\n security yes\n affects fnord', subject='security issue', to_address='*****@*****.**') handler.process(msg, msg['To']) notification = self.getLatestBugNotification() bug = notification.bug self.assertEqual('security issue', bug.title) self.assertTrue(bug.security_related) self.assertEqual(1, len(bug.bugtasks)) self.assertEqual(project, bug.bugtasks[0].target) recipients = set() for notification in BugNotification.select(): for recipient in notification.recipients: recipients.add(recipient.person) self.assertContentEqual([maintainer], recipients)
def test_contact_is_possible(self): # The contact_is_possible property checks has_valid_email_address # and contact_is_allowed. team = self.factory.makeTeam() sender = self.factory.makePerson() with person_logged_in(sender): view = create_initialized_view(team, '+contactuser') self.assertTrue(view.has_valid_email_address) self.assertTrue(view.contact_is_allowed) self.assertTrue(view.contact_is_possible) other_sender = self.makeThrottledSender() with person_logged_in(other_sender): view = create_initialized_view(team, '+contactuser') self.assertTrue(view.has_valid_email_address) self.assertFalse(view.contact_is_allowed) self.assertFalse(view.contact_is_possible) with person_logged_in(team.teamowner): team.teamowner.leave(team) with person_logged_in(sender): view = create_initialized_view(team, '+contactuser') self.assertTrue(view.contact_is_allowed) self.assertFalse(view.has_valid_email_address) self.assertFalse(view.contact_is_possible)
def test_data_subscription_lp_admin(self): # For a subscription, subscriber_data_js has can_edit # set to true for a Launchpad admin. question = self._makeQuestionWithNoSubscribers() member = self.factory.makePerson() subscriber = self.factory.makePerson( name='user', displayname='Subscriber Name') with person_logged_in(member): question.subscribe(subscriber, subscriber) view = create_view(question, '+portlet-subscribers-details') api_request = IWebServiceClientRequest(view.request) expected_result = { 'subscriber': { 'name': 'user', 'display_name': 'Subscriber Name', 'is_team': False, 'can_edit': True, 'web_link': canonical_url(subscriber), 'self_link': absoluteURL(subscriber, api_request) }, 'subscription_level': "Direct", } # Login as admin admin = getUtility(IPersonSet).find(ADMIN_EMAIL).any() with person_logged_in(admin): self.assertEqual( dumps([expected_result]), view.subscriber_data_js)
def setUp(self): super(TestBuildPrivacy, self).setUp() # Add everything we need to create builds. self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL) processor = self.factory.makeProcessor() distroseries = self.factory.makeDistroSeries() das = self.factory.makeDistroArchSeries( distroseries=distroseries, processor=processor, supports_virtualized=True) with person_logged_in(self.admin): publisher = SoyuzTestPublisher() publisher.prepareBreezyAutotest() distroseries.nominatedarchindep = das publisher.addFakeChroots(distroseries=distroseries) self.factory.makeBuilder(processor=processor) self.public_archive = self.factory.makeArchive() self.private_archive = self.factory.makeArchive(private=True) # Create one public and one private build. public_spph = publisher.getPubSource( sourcename=self.factory.getUniqueString(), version="%s.1" % self.factory.getUniqueInteger(), distroseries=distroseries, archive=self.public_archive) [public_build] = public_spph.createMissingBuilds() private_spph = publisher.getPubSource( sourcename=self.factory.getUniqueString(), version="%s.1" % self.factory.getUniqueInteger(), distroseries=distroseries, archive=self.private_archive) with person_logged_in(self.admin): [private_build] = private_spph.createMissingBuilds() self.expected_title = '%s build of %s %s in %s %s RELEASE' % ( das.architecturetag, private_spph.source_package_name, private_spph.source_package_version, distroseries.distribution.name, distroseries.name)
def test_expose_user_subscriptions_to_js__uses_cached_teams(self): # The function expose_user_subscriptions_to_js() uses a # cached list of administrated teams. user = self.factory.makePerson() target = self.factory.makeProduct() request = LaunchpadTestRequest() with person_logged_in(user): sub = target.addBugSubscription(user, user) # The first call requires one query to retrieve the administrated # teams. with StormStatementRecorder() as recorder: expose_user_subscriptions_to_js(user, [sub], request) statements_for_admininstrated_teams = [ statement for statement in recorder.statements if statement.startswith("SELECT *")] self.assertEqual(1, len(statements_for_admininstrated_teams)) # Calling the function a second time does not require an # SQL call to retrieve the administrated teams. with person_logged_in(user): with StormStatementRecorder() as recorder: expose_user_subscriptions_to_js(user, [sub], request) statements_for_admininstrated_teams = [ statement for statement in recorder.statements if statement.startswith("SELECT *")] self.assertEqual(0, len(statements_for_admininstrated_teams))
def test_data_person_subscription_subscriber(self): # For a subscription, subscriber_data_js has can_edit # set to true for the subscriber. bug = self._makeBugWithNoSubscribers() subscriber = self.factory.makePerson( name='user', displayname='Subscriber Name') subscribed_by = self.factory.makePerson( name='someone', displayname='Someone') with person_logged_in(subscriber): bug.subscribe(subscriber, subscribed_by, level=BugNotificationLevel.LIFECYCLE) harness = LaunchpadFormHarness(bug, BugPortletSubscribersWithDetails) api_request = IWebServiceClientRequest(harness.request) expected_result = { 'subscriber': { 'name': 'user', 'display_name': 'Subscriber Name', 'is_team': False, 'can_edit': True, 'web_link': canonical_url(subscriber), 'self_link': absoluteURL(subscriber, api_request), 'display_subscribed_by': 'Subscribed by Someone (someone)', }, 'subscription_level': "Lifecycle", } with person_logged_in(subscribed_by): self.assertEqual( dumps([expected_result]), harness.view.subscriber_data_js)
def test_data_subscription_lp_admin(self): # For a subscription, subscriber_data_js has can_edit # set to true for a Launchpad admin. bug = self._makeBugWithNoSubscribers() member = self.factory.makePerson() subscriber = self.factory.makePerson( name='user', displayname='Subscriber Name') with person_logged_in(member): bug.subscribe(subscriber, subscriber, level=BugNotificationLevel.LIFECYCLE) harness = LaunchpadFormHarness( bug, BugPortletSubscribersWithDetails) api_request = IWebServiceClientRequest(harness.request) expected_result = { 'subscriber': { 'name': 'user', 'display_name': 'Subscriber Name', 'is_team': False, 'can_edit': True, 'web_link': canonical_url(subscriber), 'self_link': absoluteURL(subscriber, api_request), 'display_subscribed_by': 'Self-subscribed', }, 'subscription_level': "Lifecycle", } # Login as admin admin = getUtility(IPersonSet).find(ADMIN_EMAIL).any() with person_logged_in(admin): self.assertEqual( dumps([expected_result]), harness.view.subscriber_data_js)
def test_subscribe_uses_bug_notification_level(self): # When a user subscribes to a bug using the advanced features on # the Bug +subscribe page, the bug notification level they # choose is taken into account. bug = self.factory.makeBug() # We unsubscribe the bug's owner because if we don't there will # be two COMMENTS-level subscribers. with person_logged_in(bug.owner): bug.unsubscribe(bug.owner, bug.owner) displayed_levels = [ level for level in BugNotificationLevel.items] for level in displayed_levels: person = self.factory.makePerson() with person_logged_in(person): harness = LaunchpadFormHarness( bug.default_bugtask, BugSubscriptionSubscribeSelfView) form_data = { 'field.subscription': person.name, 'field.bug_notification_level': level.title, } harness.submit('continue', form_data) subscription = bug.getSubscriptionForPerson(person) self.assertEqual( level, subscription.bug_notification_level, "Bug notification level of subscription should be %s, is " "actually %s." % ( level.title, subscription.bug_notification_level.title))
def test_data_team_subscription_member_looks(self): # For a team subscription, subscriber_data_js has can_edit # set to true for team member. bug = self._makeBugWithNoSubscribers() member = self.factory.makePerson() teamowner = self.factory.makePerson( name="team-owner", displayname="Team Owner") subscriber = self.factory.makeTeam( name='team', displayname='Team Name', owner=teamowner, members=[member]) with person_logged_in(subscriber.teamowner): bug.subscribe(subscriber, subscriber.teamowner, level=BugNotificationLevel.LIFECYCLE) harness = LaunchpadFormHarness( bug, BugPortletSubscribersWithDetails) api_request = IWebServiceClientRequest(harness.request) expected_result = { 'subscriber': { 'name': 'team', 'display_name': 'Team Name', 'is_team': True, 'can_edit': True, 'web_link': canonical_url(subscriber), 'self_link': absoluteURL(subscriber, api_request), 'display_subscribed_by': \ 'Subscribed by Team Owner (team-owner)', }, 'subscription_level': "Lifecycle", } with person_logged_in(subscriber.teamowner): self.assertEqual( dumps([expected_result]), harness.view.subscriber_data_js)
def test_data_team_subscription_member_looks(self): # For a team subscription, subscriber_data_js has can_edit # set to true for team member. question = self._makeQuestionWithNoSubscribers() member = self.factory.makePerson() teamowner = self.factory.makePerson( name="team-owner", displayname="Team Owner") subscriber = self.factory.makeTeam( name='team', displayname='Team Name', owner=teamowner, members=[member]) with person_logged_in(subscriber.teamowner): question.subscribe(subscriber, subscriber.teamowner) view = create_view(question, '+portlet-subscribers-details') api_request = IWebServiceClientRequest(view.request) expected_result = { 'subscriber': { 'name': 'team', 'display_name': 'Team Name', 'is_team': True, 'can_edit': True, 'web_link': canonical_url(subscriber), 'self_link': absoluteURL(subscriber, api_request) }, 'subscription_level': "Direct", } with person_logged_in(subscriber.teamowner): self.assertEqual( dumps([expected_result]), view.subscriber_data_js)
def setUp(self): TestCaseWithFactory.setUp(self) self.owner = self.factory.makePerson() self.product = self.factory.makeProduct( name='bonkers', displayname='Bonkers', owner=self.owner) self.obsolete_productseries = self.factory.makeProductSeries( name='obsolete', product=self.product) with person_logged_in(self.product.owner): self.obsolete_productseries.status = SeriesStatus.OBSOLETE self.dev_productseries = self.factory.makeProductSeries( name='current', product=self.product) with person_logged_in(self.product.owner): self.dev_productseries.status = SeriesStatus.DEVELOPMENT self.distribution = self.factory.makeDistribution( name='youbuntu', displayname='Youbuntu', owner=self.owner) self.distroseries = self.factory.makeDistroSeries( name='busy', distribution=self.distribution) self.sourcepackagename = self.factory.makeSourcePackageName( name='bonkers') self.package = self.factory.makeSourcePackage( sourcepackagename=self.sourcepackagename, distroseries=self.distroseries)
def test_redeem_twice_causes_error(self): # If a voucher is redeemed twice, the second attempt is rejected. commercial_admin = login_celebrity('commercial_admin') voucher_id_1, voucher_id_2 = self.makeVouchers(commercial_admin, 2) project_1 = self.factory.makeProduct(name='p1') project_2 = self.factory.makeProduct(name='p2') url = canonical_url(commercial_admin, view_name='+vouchers') browser = self.getUserBrowser(url, commercial_admin) # A second browser opens the +vouchers page before the first browser # attempts to redeem the voucher. browser2 = self.getUserBrowser(url, commercial_admin) browser.getControl( 'Select the project you wish to subscribe').value = 'p1' browser.getControl( 'Select a voucher').getControl(voucher_id_1).selected = True browser.getControl('Redeem').click() with person_logged_in(commercial_admin): self.assertIsNotNone(project_1.commercial_subscription) browser2.getControl( 'Select the project you wish to subscribe').value = 'p2' browser2.getControl( 'Select a voucher').getControl(voucher_id_1).selected = True browser2.getControl('Redeem').click() with person_logged_in(commercial_admin): self.assertIsNone(project_2.commercial_subscription) error_messages = find_tags_by_class(browser2.contents, 'message') self.assertEqual(extract_text(error_messages[1]), 'Invalid value')
def test_update_dependancies_respects_component(self): # Since main can only utilise packages that are published in main, # dependencies are not satisfied if they are not in main. spph = self.publisher.getPubSource( sourcename=self.factory.getUniqueString(), version="%s.1" % self.factory.getUniqueInteger(), distroseries=self.distroseries, archive=self.archive) [build] = spph.createMissingBuilds() spn = self.factory.getUniqueString() version = "%s.1" % self.factory.getUniqueInteger() with person_logged_in(self.admin): build.updateStatus( BuildStatus.MANUALDEPWAIT, slave_status={'dependencies': unicode(spn)}) [bpph] = self.publisher.getPubBinaries( binaryname=spn, distroseries=self.distroseries, version=version, builder=self.builder, archive=self.archive, status=PackagePublishingStatus.PUBLISHED, component='universe') # Commit to make sure stuff hits the database. transaction.commit() build.updateDependencies() # Since the dependency is in universe, we still can't see it. self.assertEquals(unicode(spn), build.dependencies) with person_logged_in(self.admin): bpph.component = getUtility(IComponentSet)['main'] transaction.commit() # Now that we have moved it main, we can see it. build.updateDependencies() self.assertEquals(u'', build.dependencies)
def test_data_target_owner_answercontact_looks(self): # Answercontact_data_js has can_edit set to true for target owner. distro = self.factory.makeDistribution() question = self.factory.makeQuestion(target=distro) contact = self.factory.makePerson( name='user', displayname='Contact Name') contact.addLanguage(getUtility(ILanguageSet)['en']) with person_logged_in(contact): question.target.addAnswerContact(contact, contact) view = create_view(question.target, '+portlet-answercontacts-details') api_request = IWebServiceClientRequest(view.request) expected_result = { 'subscriber': { 'name': 'user', 'display_name': 'Contact Name', 'is_team': False, 'can_edit': True, 'web_link': canonical_url(contact), 'self_link': absoluteURL(contact, api_request) } } with person_logged_in(distro.owner): self.assertEqual( dumps([expected_result]), view.answercontact_data_js)
def _make_subscription(self, proprietary_subscription=False): subscriber = self.factory.makePerson() subscribed_by = self.factory.makePerson() policy = SpecificationSharingPolicy.PUBLIC_OR_PROPRIETARY product_owner = self.factory.makePerson() product = self.factory.makeProduct(specification_sharing_policy=policy, owner=product_owner) if proprietary_subscription: info_type = InformationType.PROPRIETARY with person_logged_in(product_owner): permissions = {InformationType.PROPRIETARY: SharingPermission.ALL} getUtility(IService, "sharing").sharePillarInformation( product, subscribed_by, product_owner, permissions ) else: info_type = InformationType.PUBLIC if proprietary_subscription: # If the spec is proprietary, subscribed_by must have the # permission launchpad.Edit on the spec in order to # subscribe someone. This permission requires to have a # special role for the specificaiton, like the assignee. assignee = subscribed_by else: assignee = None spec = self.factory.makeSpecification(product=product, information_type=info_type, assignee=assignee) with person_logged_in(subscribed_by): subscription = spec.subscribe(subscriber, subscribed_by) return spec, subscriber, subscribed_by, subscription
def test_access_for_user_with_artifact_grant(self): # Users with an artifact grant related to the parent product # can access properties requring the permission launchpad.LimitedView # of a series. user = self.factory.makePerson() with person_logged_in(self.proprietary_product_owner): bug = self.factory.makeBug( target=self.proprietary_product, owner=self.proprietary_product_owner) bug.subscribe(user, subscribed_by=self.proprietary_product_owner) with person_logged_in(user): self.assertAccessAuthorized( self.expected_get_permissions['launchpad.LimitedView'], self.proprietary_series) # The cannot access other attributes of a series for # private products. for permission, names in self.expected_get_permissions.items(): if permission in (CheckerPublic, 'launchpad.LimitedView'): continue self.assertAccessUnauthorized(names, self.proprietary_series) # They cannot change any attributes. for permission, names in self.expected_set_permissions.items(): self.assertChangeUnauthorized(names, self.proprietary_series)
def test_target_owner_can_edit(self): with person_logged_in(self.bug.default_bugtask.target.owner): self.assertTrue(checkPermission('launchpad.Edit', self.bug))
def test_bug_reporter_can_edit(self): with person_logged_in(self.bug.owner): self.assertTrue(checkPermission('launchpad.Edit', self.bug))
def test_user_with_karma_can_edit(self): person = self.factory.makePerson() self._makeKarmaTotalCache(person, 10) with person_logged_in(person): self.assertTrue(checkPermission('launchpad.Edit', self.bug))
def test_private_bug_non_subscriber_cannot_edit(self): with admin_logged_in() as admin: self.bug.setPrivate(True, admin) with person_logged_in(self.factory.makePerson()): self.assertFalse(checkPermission('launchpad.Edit', self.bug))
def test_person_logged_in(self): # The person_logged_in context manager runs with a person logged in. person = self.factory.makePerson() with person_logged_in(person): self.assertLoggedIn(person)
def test_is_muted_returns_false_for_non_subscribers(self): # Bug.isMuted() will return False if the user has no # subscription. with person_logged_in(self.person): self.assertEqual(False, self.bug.isMuted(self.person))
def test_create_packageset_as_user(self): # Normal users can't create packagesets with person_logged_in(self.factory.makePerson()): self.assertRaises(Unauthorized, getattr, self.ps_set, 'new')
def test_new_untouched(self): bugtask = self.factory.makeBugTask(status=BugTaskStatus.NEW) with person_logged_in(bugtask.owner): bugtask.bug.linkMessage(self.factory.makeMessage()) self.assertEqual(BugTaskStatus.NEW, bugtask.status)
def test_team_logged_in(self): # person_logged_in also works when given teams. team = self.factory.makeTeam() with person_logged_in(team): person = self.getLoggedInPerson() self.assertTrue(person.inTeam(team))
def test_target_bug_supervisor_can_edit(self): person = self.factory.makePerson() removeSecurityProxy(self.bug.default_bugtask.target).bug_supervisor = ( person) with person_logged_in(person): self.assertTrue(checkPermission('launchpad.Edit', self.bug))
def test_is_muted_returns_true_for_muted_users(self): # Bug.isMuted() will return True if the person passed to it is muted. with person_logged_in(self.person): self.bug.mute(self.person, self.person) self.assertEqual(True, self.bug.isMuted(self.person))
def test_checkSubmitConditions_requires_lock_timestamp(self): with person_logged_in(self.factory.makePerson()): view = self._makeView() view.lock_timestamp = None self.assertRaises(UnexpectedFormData, view._checkSubmitConditions)
def test_mute_team_fails(self): # Muting a subscription for an entire team doesn't work. with person_logged_in(self.person): team = self.factory.makeTeam(owner=self.person) self.assertRaises(AssertionError, self.bug.mute, team, team)
def setUp(self): super(TestFAQPermissions, self).setUp() target = self.factory.makeProduct() self.owner = target.owner with person_logged_in(self.owner): self.faq = self.factory.makeFAQ(target=target)
def test_new_user_cannot_edit(self): with person_logged_in(self.factory.makePerson()): self.assertFalse(checkPermission('launchpad.Edit', self.bug))
def getViewContent(view): with person_logged_in(view.request.principal): return view()
def test_disables_current_translation(self): # Resetting the current translation clears its "current" flag. self.assertTrue(self.current_translation.is_current_ubuntu) with person_logged_in(self.factory.makePerson()): self.submitForcedEmptySuggestion() self.assertFalse(self.current_translation.is_current_ubuntu)
def test_checkSubmitConditions_passes(self): with person_logged_in(self.factory.makePerson()): view = self._makeView() view._checkSubmitConditions()
def setup_team(team): super_team = self.factory.makeTeam( owner=team.teamowner, membership_policy=TeamMembershipPolicy.RESTRICTED) with person_logged_in(team.teamowner): super_team.addMember(team, team.teamowner, force_team_add=True)
def setup_team(team): bug = self.factory.makeBug( owner=team.teamowner, information_type=InformationType.USERDATA) with person_logged_in(team.teamowner): bug.default_bugtask.transitionToAssignee(team)
def test_random_person_is_unauthorized(self): dsp = self.factory.makeDistroSeriesParent() person = self.factory.makePerson() with person_logged_in(person): self.assertRaises(Unauthorized, setattr, dsp, "derived_series", dsp.parent_series)
def setup_team(team): with person_logged_in(team.teamowner): team.createPPA()
def makeProductFocus(template): with person_logged_in(template.productseries.product.owner): template.productseries.product.translation_focus = ( template.productseries)
def setupLoggedInRequest(self, user, request, when=None): """Test helper to login a user for a request.""" with person_logged_in(user): view = OpenIDCallbackView(user, request) view.login(user, when)
def _create_items(self, num, factory, **kwargs): items = [] with person_logged_in(self.owner): for n in range(num): items.append(factory(**kwargs)) return items
def test_registry_can_delete(self): # A member of ~registry can delete any FAQ. expert = self.factory.makePerson( member_of=[getUtility(IPersonSet).getByName('registry')]) with person_logged_in(expert): self.assertTrue(check_permission('launchpad.Delete', self.faq))
def test_transitionToInformationType_forbidden(self): """Raise if specified type is not supported.""" spec = self.factory.makeSpecification() with person_logged_in(spec.owner): with ExpectedException(CannotChangeInformationType, '.*'): spec.transitionToInformationType(None, spec.owner)
def assertBuildViewRetryIsExpected(self, build, person, expected): with person_logged_in(person): build_view = getMultiAdapter( (build, self.empty_request), name="+index") self.assertEquals(build_view.user_can_retry_build, expected)
def test_owner_modify_packageset(self): # Packageset owners can modify their packagesets with person_logged_in(self.person): self.modifyPackageset()
def add_structural_subscriber(self): subscriber = self.factory.makePerson() with person_logged_in(subscriber): self.target.addSubscription(subscriber, subscriber)