Ejemplo n.º 1
0
 def test_step_two_initialize(self):
     # Step two collects additional license, owner, and packaging info.
     registrant = self.factory.makePerson(name='pting')
     transaction.commit()
     login_person(registrant)
     form = make_product_form(action=1)
     view = create_initialized_view(self.product_set, '+new', form=form)
     owner_widget = view.view.widgets['owner']
     self.assertEqual('pting', view.view.initial_values['owner'])
     self.assertEqual('Select the maintainer', owner_widget.header)
     self.assertIs(True, owner_widget.show_create_team_link)
     disclaim_widget = view.view.widgets['disclaim_maintainer']
     self.assertEqual('subordinate', disclaim_widget.cssClass)
     self.assertEqual(
         ['displayname', 'name', 'title', 'summary', 'description',
          'homepageurl', 'information_type', 'licenses', 'license_info',
          'driver', 'bug_supervisor', 'owner',
          '__visited_steps__'],
         view.view.field_names)
     self.assertEqual(
         ['displayname', 'name', 'title', 'summary', 'description',
          'homepageurl', 'information_type', 'licenses', 'driver',
          'bug_supervisor', 'owner', 'disclaim_maintainer',
          'source_package_name', 'distroseries', '__visited_steps__',
          'license_info'],
         [f.__name__ for f in view.view.form_fields])
 def test_packages_unauthorized(self):
     """A person with no subscription will not be able to view +packages
     """
     login_person(self.fred)
     self.assertRaises(
         Unauthorized, create_initialized_view, self.private_ppa,
         "+packages")
 def setUp(self):
     super(TestQuestionTarget_answer_contacts_with_languages, self).setUp()
     self.answer_contact = self.factory.makePerson()
     login_person(self.answer_contact)
     lang_set = getUtility(ILanguageSet)
     self.answer_contact.addLanguage(lang_set['pt_BR'])
     self.answer_contact.addLanguage(lang_set['en'])
    def _test_teams_with_branch_review_requests(self, private=True):
        # Users who can see a branch can also see private teams for which
        # reviews have been requested.

        # Make the merge proposal.
        login_person(self.priv_owner)
        product = self.factory.makeProduct()
        if private:
            information_type = InformationType.USERDATA
        else:
            information_type = InformationType.PUBLIC
        target_branch = self.factory.makeBranch(
            owner=self.priv_owner, product=product,
            information_type=information_type)
        source_branch = self.factory.makeBranch(
            owner=self.priv_owner, product=product)
        self.factory.makeBranchMergeProposal(
            source_branch=source_branch, target_branch=target_branch,
            reviewer=self.priv_team, registrant=self.priv_owner)

        # All users can see public branches, so in that case, the team is
        # now visible, else team is still not visible.
        some_person = self.factory.makePerson()
        self._check_permission(some_person, not private)
        # Subscribe the user to the branch.
        login_person(self.priv_owner)
        self.factory.makeBranchSubscription(
            branch=target_branch, person=some_person,
            subscribed_by=self.priv_owner)
        # The team is now visible.
        self._check_permission(some_person, True)
 def test_getTermByToken_match(self):
     # Verify the token by lookup.
     bug_tracker = self.factory.makeBugTracker()
     login_person(bug_tracker.owner)
     bug_tracker.name = 'mink'
     term = self.vocab.getTermByToken('mink')
     self.assertEqual(bug_tracker, term.value)
 def test_PersonPickerEntrySourceAdapter_visible_email_logged_in(self):
     # Logged in users can see visible email addresses.
     observer = self.factory.makePerson()
     login_person(observer)
     person = self.factory.makePerson(email='*****@*****.**')
     self.assertEqual(
         '*****@*****.**', get_picker_entry(person, None).description)
 def setUp(self):
     super(TestPersonSpecWorkloadView, self).setUp()
     self.owner = self.factory.makePerson(name='blue')
     login_person(self.owner)
     self.team = self.factory.makeTeam(name='square', owner='blue')
     self.member = self.factory.makePerson(name='green')
     self.team.addMember(self.member, self.owner)
Ejemplo n.º 8
0
 def test_new_source_package_import(self):
     # Test the email for a new sourcepackage import.
     eric = self.factory.makePerson(name='eric')
     distro = self.factory.makeDistribution(name='foobuntu')
     series = self.factory.makeDistroSeries(
         name='manic', distribution=distro)
     fooix = self.factory.makeSourcePackage(
         sourcepackagename='fooix', distroseries=series)
     # Eric needs to be logged in for the mail to be sent.
     login_person(eric)
     code_import = self.factory.makePackageCodeImport(
         git_repo_url='git://git.example.com/fooix.git',
         branch_name='master', sourcepackage=fooix, registrant=eric)
     transaction.commit()
     msg = message_from_string(stub.test_emails[0][2])
     self.assertEqual('code-import', msg['X-Launchpad-Notification-Type'])
     self.assertEqual(
         '~eric/foobuntu/manic/fooix/master', msg['X-Launchpad-Branch'])
     self.assertEqual(
         'A new git code import has been requested '
         'by Eric:\n'
         '    http://code.launchpad.dev/~eric/foobuntu/manic/fooix/master\n'
         'from\n'
         '    git://git.example.com/fooix.git\n'
         '\n'
         '-- \nYou are getting this email because you are a member of the '
         'vcs-imports team.\n', msg.get_payload(decode=True))
 def setUpRegistryExpert(self):
     """Create a registry expert and logs in as them."""
     login_person(self.admin)
     self.expert = self.factory.makePerson()
     getUtility(ILaunchpadCelebrities).registry_experts.addMember(
         self.expert, self.admin)
     login_person(self.expert)
Ejemplo n.º 10
0
 def test_reset_resets(self):
     # Calling reset() on a watch resets all of the attributes of the
     # bug watch.
     admin_user = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
     login_person(admin_user)
     self.bug_watch.reset()
     self._assertBugWatchHasBeenChanged()
Ejemplo n.º 11
0
 def test_validate_passes_for_admin(self):
     # Users in the team that adminsters a blacklisted name may create
     # matching names.
     field = self.makeTestField()
     date_value = u'fnord'
     login_person(self.team.teamowner)
     self.assertEqual(None, field.validate(date_value))
 def test_bug_filing_view_with_dupe_search_enabled(self):
     # When a user files a bug for a product where searching for
     # duplicate bugs is enabled, he is asked to provide a
     # summary of the bug. This summary is used to find possible
     # existing duplicates f this bug.
     product = self.factory.makeProduct()
     login_person(product.owner)
     product.official_malone = True
     product.enable_bugfiling_duplicate_search = True
     user = self.factory.makePerson()
     login_person(user)
     view = create_initialized_view(
         product, name='+filebug', principal=user)
     html = view.render()
     self.assertIsNot(None, find_tag_by_id(html, 'filebug-search-form'))
     # The main bug filing form is rendered but hidden inside an invisible
     # filebug-container.
     main_content = find_main_content(html)
     filebug_form = main_content.find(id='filebug-form')
     self.assertIsNot(None, filebug_form)
     filebug_form_container = filebug_form.findParents(
         id='filebug-form-container')[0]
     class_attrs = [item.strip()
                    for item in filebug_form_container['class'].split(" ")]
     self.assertTrue('hidden' in class_attrs)
 def test_product_no_duplicate_search(self):
     product = self.factory.makeProduct(official_malone=True)
     removeSecurityProxy(product).enable_bugfiling_duplicate_search = False
     user = self.factory.makePerson()
     login_person(user)
     view = create_initialized_view(product, '+filebug', principal=user)
     self._assert_cache_values(view, False)
    def test_bug_filed_acknowlegdgement_notification(self):
        # When a user files a bug, an acknowledgement notification is added
        # to the response.
        product = self.factory.makeProduct()
        login_person(product.owner)
        create_initialized_view(product, name='+filebug')
        form_data = {
            'title': 'A bug title',
            'comment': 'whatever',
            }
        view = create_initialized_view(product, name='+filebug')
        view.submit_bug_action.success(form_data)
        self.assertEqual(
            ['<p class="last">Thank you for your bug report.</p>'],
            [notification.message
             for notification in view.request.response.notifications])

        # This message can be customized.
        product.bug_reported_acknowledgement = (
            u"We really appreciate your bug report")
        view = create_initialized_view(product, name='+filebug')
        view.submit_bug_action.success(form_data)
        self.assertEqual(
            [u'<p class="last">We really appreciate your bug report</p>'],
            [notification.message
             for notification in view.request.response.notifications])
Ejemplo n.º 15
0
 def test_team_without_super_teams_is_fine(self):
     # A team with no members and no super teams
     # merges without errors.
     test_team = self.factory.makeTeam()
     target_team = self.factory.makeTeam()
     login_person(test_team.teamowner)
     self._do_merge(test_team, target_team, test_team.teamowner)
 def test_user_in_private_teams(self):
     # Private teams are included in the vocabulary.
     user = self.factory.makePerson()
     team = self.factory.makeTeam(
         members=[user], visibility=PersonVisibility.PRIVATE)
     login_person(user)
     self.assertEqual([team], self._vocabTermValues())
 def test_ppa_packages_menu_is_enabled(self):
     joe = self.factory.makePerson()
     ppa = self.factory.makeArchive()
     login_person(joe)
     view = create_initialized_view(ppa, "+index")
     menu = ArchiveNavigationMenu(view)
     self.assertTrue(menu.packages().enabled)
 def test_user_no_private_teams(self):
     # Private teams are shown in the vocabulary.
     team_owner = self.factory.makePerson()
     team = self.factory.makeTeam(
         owner=team_owner, visibility=PersonVisibility.PRIVATE)
     login_person(team_owner)
     self.assertEqual([team_owner, team], self._vocabTermValues())
 def _test_team_assigned_to_bug(self, private=True):
     # Users can see teams assigned to bugs.
     bug_owner = self.factory.makePerson()
     product = self.factory.makeProduct(owner=bug_owner)
     if private:
         information_type = InformationType.USERDATA
     else:
         information_type = InformationType.PUBLIC
     bug = self.factory.makeBug(
         owner=bug_owner, target=product,
         information_type=information_type)
     # Initially no visibility.
     some_person = self.factory.makePerson()
     self._check_permission(some_person, False)
     clear_cache()
     # Assign the private team to a bugtask.
     login_person(bug_owner)
     bug.default_bugtask.transitionToAssignee(self.priv_team)
     # All users can see public bugs, so in that case, the team is
     # now visible, else team is still not visible.
     some_person = self.factory.makePerson()
     self._check_permission(some_person, not private)
     # Subscribe the user to the bug.
     login_person(bug_owner)
     bug.subscribe(some_person, bug_owner)
     # The team is now visible.
     self._check_permission(some_person, True)
 def makeCommentAndSubscriber(self, notification_level=None,
                              body=None, as_reply=False, vote=None,
                              vote_tag=None, subject=None):
     """Return a comment and a subscriber."""
     sender = self.factory.makePerson(
         displayname='Sender', email='*****@*****.**')
     comment = self.factory.makeCodeReviewComment(
         sender, body=body, vote=vote, vote_tag=vote_tag, subject=subject)
     if as_reply:
         comment = self.factory.makeCodeReviewComment(
             sender, body=body, parent=comment, subject=subject)
     subscriber = self.factory.makePerson(
         displayname='Subscriber', email='*****@*****.**')
     if notification_level is None:
         notification_level = CodeReviewNotificationLevel.FULL
     comment.branch_merge_proposal.source_branch.subscribe(
         subscriber, BranchSubscriptionNotificationLevel.NOEMAIL, None,
         notification_level, subscriber)
     # Email is not sent on construction, so fake a root message id on the
     # merge proposal.
     login_person(comment.branch_merge_proposal.registrant)
     comment.branch_merge_proposal.root_message_id = 'fake-id'
     # Log our test user back in.
     login('*****@*****.**')
     return comment, subscriber
Ejemplo n.º 21
0
    def test_query_count(self):
        # The function issues a constant number of queries regardless of
        # team count.
        login_person(self.user)
        context = self.factory.makeProduct(owner=self.user)
        self._setup_teams(self.user)

        IStore(Person).invalidate()
        clear_cache()
        with StormStatementRecorder() as recorder:
            expose_user_administered_teams_to_js(
                self.request, self.user, context,
                absoluteURL=fake_absoluteURL)
        self.assertThat(recorder, HasQueryCount(Equals(4)))

        # Create some new public teams owned by the user, and a private
        # team administered by the user.
        for i in range(3):
            self.factory.makeTeam(owner=self.user)
        pt = self.factory.makeTeam(
            visibility=PersonVisibility.PRIVATE, members=[self.user])
        with person_logged_in(pt.teamowner):
            pt.addMember(
                self.user, pt.teamowner, status=TeamMembershipStatus.ADMIN)

        IStore(Person).invalidate()
        clear_cache()
        del IJSONRequestCache(self.request).objects['administratedTeams']
        with StormStatementRecorder() as recorder:
            expose_user_administered_teams_to_js(
                self.request, self.user, context,
                absoluteURL=fake_absoluteURL)
        self.assertThat(recorder, HasQueryCount(Equals(4)))
 def _test_subscriber_to_branch_subscribed_to_by_team(self, private=True):
     """A person with visibility to any of the branches subscribed to by
     the private team will be granted limited view permission on the team.
     """
     branch_owner = self.factory.makePerson()
     if private:
         information_type = InformationType.USERDATA
     else:
         information_type = InformationType.PUBLIC
     private_branch = self.factory.makeBranch(
         owner=branch_owner, information_type=information_type)
     some_person = self.factory.makePerson()
     # Initially no visibility.
     self._check_permission(some_person, False)
     # Subscribe the team to the branch.
     login_person(branch_owner)
     self.factory.makeBranchSubscription(
         branch=private_branch, person=self.priv_team,
         subscribed_by=branch_owner)
     # All users can see public branches, so in that case, the team is
     # now visible, else team is still not visible.
     self._check_permission(some_person, not private)
     # Subscribe the user to the branch.
     login_person(branch_owner)
     self.factory.makeBranchSubscription(
         branch=private_branch, person=some_person,
         subscribed_by=branch_owner)
     # The team is now visible.
     self._check_permission(some_person, True)
    def setUp(self):
        super(TestBugTrackerWithComponents, self).setUp()

        regular_user = self.factory.makePerson()
        login_person(regular_user)

        self.bug_tracker = self.factory.makeBugTracker()
 def setUp(self):
     TestCaseWithFactory.setUp(self)
     self.user = self.factory.makePerson(name="macadamia")
     login_person(self.user)
     # Use a FakeLogger fixture to prevent Memcached warnings to be
     # printed to stdout while browsing pages.
     self.useFixture(FakeLogger())
 def test_search_name(self):
     # Verify that queries match name text.
     bug_tracker = self.factory.makeBugTracker()
     login_person(bug_tracker.owner)
     bug_tracker.name = 'skunkworks'
     bug_trackers = self.searchForBugTrackers('skunk')
     self.assertEqual([bug_tracker], bug_trackers)
Ejemplo n.º 26
0
 def test_join_restricted_team_error(self):
     # Calling join with a Restricted team raises an error.
     team = self.factory.makeTeam(
         membership_policy=TeamMembershipPolicy.RESTRICTED)
     user = self.factory.makePerson()
     login_person(user)
     self.assertRaises(JoinNotAllowed, user.join, team, user)
 def test_search_title(self):
     # Verify that queries match title text.
     bug_tracker = self.factory.makeBugTracker()
     login_person(bug_tracker.owner)
     bug_tracker.title = 'A ferret in your pants'
     bug_trackers = self.searchForBugTrackers('ferret')
     self.assertEqual([bug_tracker], bug_trackers)
 def test_search_summary(self):
     # Verify that queries match summary text.
     bug_tracker = self.factory.makeBugTracker()
     login_person(bug_tracker.owner)
     bug_tracker.summary = 'A badger is a member of the weasel family.'
     bug_trackers = self.searchForBugTrackers('badger')
     self.assertEqual([bug_tracker], bug_trackers)
 def setUp(self):
     super(TestBugSubscriptionFilter, self).setUp()
     self.target = self.factory.makeProduct()
     self.subscriber = self.target.owner
     login_person(self.subscriber)
     self.subscription = self.target.addBugSubscription(
         self.subscriber, self.subscriber)
Ejemplo n.º 30
0
 def makeBranchAndOldMergeProposal(self, timedelta):
     """Make an old  merge proposal and a branch with the same target."""
     bmp = self.factory.makeBranchMergeProposal(
         date_created=datetime.now(utc) - timedelta)
     login_person(bmp.registrant)
     target = bmp.target_branch
     return target, self.factory.makeBranchTargetBranch(target.target)
Ejemplo n.º 31
0
 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')
Ejemplo n.º 32
0
 def test_bug_supervisor_view_attributes(self):
     login_person(self.bug_supervisor)
     view = create_initialized_view(
         self.product, name='+configure-bugtracker')
     label = 'Configure bug tracker'
     self.assertEqual(label, view.label)
     fields = [
         'bugtracker', 'enable_bug_expiration', 'remote_product',
         'bug_reporting_guidelines', 'bug_reported_acknowledgement',
         'enable_bugfiling_duplicate_search']
     self.assertEqual(fields, view.field_names)
     self.assertEqual('http://launchpad.dev/boing', view.next_url)
     self.assertEqual('http://launchpad.dev/boing', view.cancel_url)
Ejemplo n.º 33
0
 def test_cannot_delete_watch_if_linked_to_comment(self):
     # It isn't possible to delete a bug watch that's linked to a bug
     # comment.
     message = getUtility(IMessageSet).fromText(
         "Example message", "With some example content to read.",
         owner=self.person)
     # We need to log in as an admin here as only admins can link a
     # watch to a comment.
     login(ADMIN_EMAIL)
     removeSecurityProxy(self.bug_watch).addComment('comment-id', message)
     login_person(self.person)
     view = create_initialized_view(self.bug_watch, '+edit')
     self.assertFalse(view.bugWatchIsUnlinked(None))
Ejemplo n.º 34
0
 def test_rejectedOwnCodeReview(self):
     # Rejecting your own merge proposal isn't such a significant event
     # either, and I don't know why someone would, but hey, people are
     # strange.
     reviewer = self.factory.makePerson()
     target_branch = self.factory.makeProductBranch(owner=reviewer)
     proposal = self.factory.makeBranchMergeProposal(
         target_branch=target_branch, registrant=reviewer)
     self.karma_events = []
     login_person(reviewer)
     with BranchMergeProposalNoPreviewDiffDelta.monitor(proposal):
         proposal.rejectBranch(reviewer, "A rev id.")
     self.assertOneKarmaEvent(reviewer, 'branchmergerejectedown')
Ejemplo n.º 35
0
 def setUp(self):
     super(ProjectGroupSearchTestCase, self).setUp()
     self.person = self.factory.makePerson()
     self.project1 = self.factory.makeProject(name="zazzle",
                                              owner=self.person)
     self.project2 = self.factory.makeProject(name="zazzle-dazzle",
                                              owner=self.person)
     self.project3 = self.factory.makeProject(
         name="razzle-dazzle",
         owner=self.person,
         description="Giving 110% at all times.")
     self.projectset = getUtility(IProjectGroupSet)
     login_person(self.person)
 def test_has_logo_without_watermark(self):
     root = getUtility(ILaunchpadRoot)
     user = self.factory.makePerson()
     login_person(user)
     view = create_initialized_view(root, 'index.html', principal=user)
     # Replace the blog posts so the view does not make a network request.
     view.getRecentBlogPosts = lambda: []
     markup = BeautifulSoup(
         view(), parseOnlyThese=SoupStrainer(id='document'))
     self.assertIs(False, view.has_watermark)
     self.assertIs(None, markup.find(True, id='watermark'))
     logo = markup.find(True, id='launchpad-logo-and-name')
     self.assertIsNot(None, logo)
     self.assertEqual('/@@/launchpad-logo-and-name.png', logo['src'])
Ejemplo n.º 37
0
    def setUp(self):
        super(TestArchiveSubscriptionBreadcrumb, self).setUp()

        # Create a private ppa
        self.ppa = self.factory.makeArchive()
        login('*****@*****.**')
        self.ppa.private = True

        owner = self.ppa.owner
        login_person(owner)
        self.ppa_subscription = self.ppa.newSubscription(owner, owner)
        self.ppa_token = self.ppa.newAuthToken(owner)
        self.personal_archive_subscription = PersonalArchiveSubscription(
            owner, self.ppa)
Ejemplo n.º 38
0
    def test_uses_current_user(self):
        # test_traverse performs the traversal as the currently logged
        # in user.
        person = self.factory.makePerson()
        login_person(person)
        users = []

        def record_user():
            users.append(getUtility(ILaunchBag).user)

        context, view, request = test_traverse(
            self.registerViewCallable(record_user))
        self.assertEqual(1, len(users))
        self.assertEqual(person, users[0])
Ejemplo n.º 39
0
    def test_change_information_type_public(self):
        owner = self.factory.makePerson(name='pting')
        product = self.factory.makeProduct(
            name='fnord',
            information_type=InformationType.PROPRIETARY,
            owner=owner)
        login_person(owner)
        form = self._make_product_edit_form(product)
        view = create_initialized_view(product, '+edit', form=form)
        self.assertEqual(0, len(view.errors))

        updated_product = getUtility(IProductSet).getByName('fnord')
        self.assertEqual(InformationType.PUBLIC,
                         updated_product.information_type)
Ejemplo n.º 40
0
 def test_get_structural_subscriptions_level(self):
     # get_structural_subscriptions() respects the given level.
     subscriber = self.factory.makePerson()
     login_person(subscriber)
     product, bug = self.make_product_with_bug()
     subscription = product.addBugSubscription(subscriber, subscriber)
     filter = subscription.bug_filters.one()
     filter.bug_notification_level = BugNotificationLevel.METADATA
     self.assertContentEqual([subscription],
                             get_structural_subscriptions(
                                 bug, BugNotificationLevel.METADATA))
     self.assertContentEqual([],
                             get_structural_subscriptions(
                                 bug, BugNotificationLevel.COMMENTS))
Ejemplo n.º 41
0
 def test_submit_action_unauthorised(self):
     # An unauthorised user sees an error on the bug target page.
     login_person(None)
     view = create_initialized_view(self.bug_task, name='+nominate')
     self.assertEqual(
         canonical_url(self.bug_task),
         view.request.response.getHeader('Location'))
     notifications = view.request.notifications
     self.assertEqual(1, len(notifications))
     self.assertEqual(
         BrowserNotificationLevel.ERROR, notifications[0].level)
     self.assertEqual(
         "You do not have permission to nominate this bug.",
         notifications[0].message)
Ejemplo n.º 42
0
 def test_package_with_upstream_launchpad_project(self):
     upstream_project = self._makeBugTargetProduct(bug_tracker='launchpad',
                                                   packaging=True)
     login_person(upstream_project.owner)
     bug_target = self._getBugTarget(
         upstream_project.distrosourcepackages[0])
     view = create_initialized_view(bug_target,
                                    '+bugs',
                                    principal=upstream_project.owner)
     self.assertEqual(upstream_project, view.upstream_launchpad_project)
     self.assertEqual(upstream_project, view.upstream_project)
     content = find_tag_by_id(view.render(), 'also-in-upstream')
     link = canonical_url(upstream_project, rootsite='bugs')
     self.assertEqual(link, content.a['href'])
Ejemplo n.º 43
0
 def test_workitems_text_with_implicit_and_explicit_milestone_reverse(self):
     spec = self.factory.makeSpecification()
     milestone = self.factory.makeMilestone(product=spec.product)
     login_person(spec.owner)
     work_item1 = self.factory.makeSpecificationWorkItem(specification=spec,
         title=u'Work item with set milestone',
         status=SpecificationWorkItemStatus.TODO,
         milestone=milestone)
     work_item2 = self.factory.makeSpecificationWorkItem(specification=spec,
         title=u'Work item with default milestone',
         status=SpecificationWorkItemStatus.TODO,
         milestone=None)
     items = [milestone, work_item1, self.wi_header, work_item2]
     self.assertWorkItemsTextContains(spec, items)
Ejemplo n.º 44
0
 def test_traversal_to_nonexistent_bugtask(self):
     # Test that a traversing to a non-existent bugtask redirects to the
     # bug's default bugtask.
     bug = self.factory.makeBug()
     bugtask = self.factory.makeBugTask(bug=bug)
     bugtask_url = canonical_url(bugtask, rootsite='bugs')
     login_person(bugtask.owner)
     bugtask.delete()
     obj, view, request = test_traverse(bugtask_url)
     view()
     naked_view = removeSecurityProxy(view)
     self.assertEqual(301, request.response.getStatus())
     self.assertEqual(naked_view.target,
                      canonical_url(bug.default_bugtask, rootsite='bugs'))
Ejemplo n.º 45
0
 def test_authenticated_view(self):
     # Authenticated users can see private assignees or subscribers.
     bug, assignee, subscriber = self._makeBug()
     request = LaunchpadTestRequest()
     bug_view = create_view(bug, name='+text', request=request)
     any_person = self.factory.makePerson()
     login_person(any_person, request)
     bug_view.initialize()
     view_text = bug_view.render()
     naked_subscriber = removeSecurityProxy(subscriber)
     self.assertIn("assignee: %s" % assignee.unique_displayname, view_text)
     self.assertTextMatchesExpressionIgnoreWhitespace(
         "subscribers:\n.*%s \(%s\)" %
         (naked_subscriber.displayname, naked_subscriber.name), view_text)
Ejemplo n.º 46
0
 def test_execute_bug_id_new(self):
     user = self.factory.makePerson()
     login_person(user)
     message = self.factory.makeSignedMessage(
         body='borked\n affects fnord',
         subject='title borked',
         to_address='*****@*****.**')
     filealias = self.factory.makeLibraryFileAlias()
     command = BugEmailCommand('bug', ['new'])
     params, event = command.execute(message, filealias)
     self.assertEqual(None, event)
     self.assertEqual(user, params.owner)
     self.assertEqual('title borked', params.title)
     self.assertEqual(message['Message-Id'], params.msg.rfc822msgid)
Ejemplo n.º 47
0
 def test_getBugTarget_project_group_error(self):
     owner = self.factory.makePerson()
     login_person(owner)
     project_group = self.factory.makeProject(name='fnord', owner=owner)
     project_1 = self.factory.makeProduct(name='pting', owner=owner)
     project_1.projectgroup = project_group
     project_2 = self.factory.makeProduct(name='snarf', owner=owner)
     project_2.projectgroup = project_group
     message = (
         "fnord is a group of projects. To report a bug, you need to "
         "specify which of these projects the bug applies to: "
         "pting, snarf")
     self.assertRaisesWithContent(BugTargetNotFound, message,
                                  AffectsEmailCommand.getBugTarget, 'fnord')
Ejemplo n.º 48
0
 def assertNotifications(self, ppa, notification, person=None):
     # Assert that while requesting a 'ppa' page as 'person', the
     # 'notification' appears.
     if person is not None:
         login_person(ppa.owner)
         principal = LaunchpadPrincipal(ppa.owner.account.id,
                                        ppa.owner.displayname,
                                        ppa.owner.displayname, ppa.owner)
     else:
         principal = None
     page = create_initialized_view(ppa, "+packages",
                                    principal=principal).render()
     notifications = get_feedback_messages(page)
     self.assertIn(notification, notifications)
Ejemplo n.º 49
0
 def test_admin_livefs(self):
     # Admins can change require_virtualized.
     login("*****@*****.**")
     ppa_admin = self.factory.makePerson(
         member_of=[getUtility(ILaunchpadCelebrities).ppa_admin])
     login_person(self.person)
     livefs = self.factory.makeLiveFS(registrant=self.person)
     self.assertTrue(livefs.require_virtualized)
     browser = self.getViewBrowser(livefs, user=ppa_admin)
     browser.getLink("Administer live filesystem").click()
     browser.getControl("Require virtualized builders").selected = False
     browser.getControl("Update live filesystem").click()
     login_person(self.person)
     self.assertFalse(livefs.require_virtualized)
Ejemplo n.º 50
0
 def test_rejectFromInvalidStates(self):
     """Test that reject() cannot be called when the question status is
     not one of OPEN or NEEDSINFO.
     """
     valid_statuses = [status.name for status in QuestionStatus.items
                       if status.name != 'INVALID']
     # Reject user must be an answer contact, (or admin, or product owner).
     # Answer contacts must speak a language
     self.answerer.addLanguage(getUtility(ILanguageSet)['en'])
     self.ubuntu.addAnswerContact(self.answerer, self.answerer)
     login_person(self.answerer)
     self._testInvalidTransition(
         valid_statuses, self.question.reject,
         self.answerer, "This is lame.", datecreated=self.nowPlus(1))
Ejemplo n.º 51
0
 def add_bug(self, count):
     login_person(self.owner)
     for i in range(count):
         bug = self.factory.makeBug(target=self.ubuntu)
         distrosourcepackage = self.factory.makeDistributionSourcePackage(
             distribution=self.ubuntu)
         self.factory.makeSourcePackagePublishingHistory(
             distroseries=self.ubuntu.currentseries,
             sourcepackagename=distrosourcepackage.sourcepackagename)
         bug.bugtasks[0].transitionToTarget(distrosourcepackage, self.owner)
         bug.bugtasks[0].transitionToMilestone(self.milestone, self.owner)
         # This is necessary to test precaching of assignees.
         bug.bugtasks[0].transitionToAssignee(self.factory.makePerson())
     logout()
Ejemplo n.º 52
0
    def test_partner_admin_can_accept_partner_upload(self):
        # A person with queue admin access for partner
        # can accept uploads to the partner archive.
        login_person(self.partner_queue_admin)
        self.assertTrue(
            self.partner_archive.canAdministerQueue(
                self.partner_queue_admin, self.partner_spr.component))

        package_upload_id = self.partner_spr.package_upload.id
        self.form['QUEUE_ID'] = [package_upload_id]
        request = LaunchpadTestRequest(form=self.form)
        request.method = 'POST'
        self.setupQueueView(request)
        self.assertStatus(package_upload_id, PackageUploadStatus.DONE)
Ejemplo n.º 53
0
 def test_merge_with_duplicated_branches(self):
     # If both the from and to people have branches with the same name,
     # merging renames the duplicate from the from person's side.
     product = self.factory.makeProduct()
     from_branch = self.factory.makeBranch(name='foo', product=product)
     to_branch = self.factory.makeBranch(name='foo', product=product)
     mergee = to_branch.owner
     duplicate = from_branch.owner
     self._do_premerge(duplicate, mergee)
     login_person(mergee)
     duplicate, mergee = self._do_merge(duplicate, mergee)
     branches = [b.name for b in mergee.getBranches()]
     self.assertEqual(2, len(branches))
     self.assertContentEqual([u'foo', u'foo-1'], branches)
Ejemplo n.º 54
0
 def test_context_uses_answers(self):
     # If a target doesn't use answers, it doesn't provide the form.
     #logout()
     owner = removeSecurityProxy(self.question_target).owner
     with person_logged_in(owner):
         self.question_target.answers_usage = ServiceUsage.NOT_APPLICABLE
     login_person(self.user)
     view = create_initialized_view(self.question_target,
                                    name='+addquestion',
                                    principal=self.user)
     self.assertFalse(view.context_uses_answers)
     contents = view.render()
     msg = "<strong>does not use</strong> Launchpad as its answer forum"
     self.assertIn(msg, contents)
Ejemplo n.º 55
0
 def test_execute_bug_params_many_subscriber(self):
     user = self.factory.makePerson()
     login_person(user)
     subscriber_1 = self.factory.makePerson()
     subscriber_2 = self.factory.makePerson()
     bug_params = CreateBugParams(title='bug title',
                                  owner=user,
                                  subscribers=[subscriber_1])
     command = SubscribeEmailCommand('subscribe', [subscriber_2.name])
     dummy_event = object()
     params, event = command.execute(bug_params, dummy_event)
     self.assertEqual(bug_params, params)
     self.assertContentEqual([subscriber_1, subscriber_2],
                             bug_params.subscribers)
     self.assertEqual(dummy_event, event)
Ejemplo n.º 56
0
 def test_execute_bug_params_with_security(self):
     # BugSet.createBug() requires new security bugs to be private.
     user = self.factory.makePerson()
     login_person(user)
     bug_params = CreateBugParams(
         title='bug title',
         owner=user,
         information_type=InformationType.PRIVATESECURITY)
     command = PrivateEmailCommand('private', ['no'])
     dummy_event = object()
     params, event = command.execute(bug_params, dummy_event)
     self.assertEqual(bug_params, params)
     self.assertEqual(InformationType.PRIVATESECURITY,
                      bug_params.information_type)
     self.assertEqual(dummy_event, event)
Ejemplo n.º 57
0
 def test_execute_bug_params_distribution(self):
     user = self.factory.makePerson()
     login_person(user)
     distribution = self.factory.makeDistribution(name='fnord')
     message = self.factory.makeMessage(subject='bug title',
                                        content='borked\n affects fnord')
     command = AffectsEmailCommand('affects', ['fnord'])
     bug_params = CreateBugParams(title='bug title',
                                  msg=message,
                                  owner=user)
     bugtask, bugtask_event, bug_event = command.execute(bug_params, None)
     self.assertEqual(distribution, bugtask.target)
     self.assertEqual('bug title', bugtask.bug.title)
     self.assertTrue(IObjectCreatedEvent.providedBy(bugtask_event))
     self.assertTrue(IObjectCreatedEvent.providedBy(bug_event))
Ejemplo n.º 58
0
 def test_retarget_with_other_changed(self):
     # Retargeting must be the last change made to the question
     # to ensure that user permission do not change while there
     # are more changes to make.
     target = self.factory.makeProduct()
     question = self.factory.makeQuestion(target=target)
     other_target = self.factory.makeProduct()
     login_person(target.owner)
     form = self.getForm(question)
     form['field.whiteboard'] = 'comment'
     form['field.target.product'] = other_target.name
     view = create_initialized_view(question, name='+edit', form=form)
     self.assertEqual([], view.errors)
     self.assertEqual(other_target, question.target)
     self.assertEqual('comment', question.whiteboard)
Ejemplo n.º 59
0
 def assertSubscriptionMerges(self, target):
     # Given a subscription target, we want to make sure that subscriptions
     # that the duplicate person made are carried over to the merged
     # account.
     duplicate = self.factory.makePerson()
     with person_logged_in(duplicate):
         target.addSubscription(duplicate, duplicate)
     person = self.factory.makePerson()
     self._do_premerge(duplicate, person)
     login_person(person)
     duplicate, person = self._do_merge(duplicate, person)
     # The merged person has the subscription, and the duplicate person
     # does not.
     self.assertTrue(target.getSubscription(person) is not None)
     self.assertTrue(target.getSubscription(duplicate) is None)
Ejemplo n.º 60
0
 def assert_bugtasks_query_count(self, milestone, bugtask_count,
                                 query_limit):
     # Assert that the number of queries run by view.bugtasks is low.
     self.add_bug(bugtask_count)
     login_person(self.owner)
     view = create_initialized_view(milestone, '+index')
     # Eliminate permission check for the admin team from the
     # recorded queries by loading it now. If the test ever breaks,
     # the person fixing it won't waste time trying to track this
     # query down.
     getUtility(ILaunchpadCelebrities).admin
     with StormStatementRecorder() as recorder:
         bugtasks = list(view.bugtasks)
     self.assertThat(recorder, HasQueryCount(LessThan(query_limit)))
     self.assertEqual(bugtask_count, len(bugtasks))