def test_landing_targets_constant_queries(self): project = self.factory.makeProduct() with person_logged_in(project.owner): source = self.factory.makeBranch(target=project) source_url = api_url(source) webservice = webservice_for_person( project.owner, permission=OAuthPermission.WRITE_PRIVATE) def create_mp(): with admin_logged_in(): branch = self.factory.makeBranch( target=project, stacked_on=self.factory.makeBranch( target=project, information_type=InformationType.PRIVATESECURITY), information_type=InformationType.PRIVATESECURITY) self.factory.makeBranchMergeProposal(source_branch=source, target_branch=branch) def list_mps(): webservice.get(source_url + '/landing_targets') list_mps() recorder1, recorder2 = record_two_runs(list_mps, create_mp, 2) self.assertThat(recorder1, HasQueryCount(LessThan(30))) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_private_team_query_count(self): # Testing visibility of a private team involves checking for # subscriptions to any private PPAs owned by that team. Make sure # that this doesn't involve a query for every archive subscription # the user has. person = self.factory.makePerson() team_owner = self.factory.makePerson() private_team = self.factory.makeTeam( owner=team_owner, visibility=PersonVisibility.PRIVATE) checker = PublicOrPrivateTeamsExistence( removeSecurityProxy(private_team)) def create_subscribed_archive(): with person_logged_in(team_owner): archive = self.factory.makeArchive(owner=private_team, private=True) archive.newSubscription(person, team_owner) def check_team_limited_view(): person.clearInTeamCache() with person_logged_in(person): self.assertTrue( checker.checkAuthenticated(IPersonRoles(person))) recorder1, recorder2 = record_two_runs(check_team_limited_view, create_subscribed_archive, 5) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_query_count(self): # The number of queries required to render the mirror table is # constant in the number of mirrors. person = self.factory.makePerson() distro = self.factory.makeDistribution(owner=person) login_celebrity("admin") distro.supports_mirrors = True login_person(person) distro.mirror_admin = person countries = iter(getUtility(ICountrySet)) def render_mirrors(): text = create_initialized_view( distro, self.view, principal=person).render() self.assertNotIn("We don't know of any", text) return text def create_mirror(): mirror = self.factory.makeMirror( distro, country=next(countries), official_candidate=True) self.configureMirror(mirror) recorder1, recorder2 = record_two_runs( render_mirrors, create_mirror, 10) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_builders_translation_template_build_query_count(self): def create_build(): queue = self.factory.makeTranslationTemplatesBuild().queueBuild() queue.markAsBuilding(self.factory.makeBuilder()) nb_objects = 2 recorder1, recorder2 = record_two_runs(builders_homepage_render, create_build, nb_objects) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_view_query_count(self): # Test that the view bulk loads artifacts. person = self.factory.makePerson() pillarperson = PillarPerson(self.pillar, person) recorder1, recorder2 = record_two_runs( lambda: create_initialized_view(pillarperson, '+index'), lambda: self.makeArtifactGrantee(person, True, True, True, False), 5, login_method=lambda: login_person(self.owner)) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_builders_recipe_build_query_count(self): def create_build(): build = self.createRecipeBuildWithBuilder() queue = build.queueBuild() queue.markAsBuilding(build.builder) nb_objects = 2 recorder1, recorder2 = record_two_runs( builders_homepage_render, create_build, nb_objects) self.assertThat(recorder2, HasQueryCount(Equals(recorder1.count)))
def test_build_history_queries_count_binary_package_builds(self): # Rendering to builder's history issues a constant number of queries # when binary builds are displayed. def builder_history_render(): create_initialized_view(self.builder, '+history').render() recorder1, recorder2 = record_two_runs( builder_history_render, partial(self.createBinaryPackageBuild, builder=self.builder), self.nb_objects) self.assertThat(recorder2, HasQueryCount(Equals(recorder1.count)))
def test_query_count(self): # The query count is constant with number of webhooks. def create_webhook(): self.factory.makeWebhook(target=self.target) # Run once to get things stable, then check that adding more # webhooks doesn't inflate the count. self.makeView("+webhooks")() recorder1, recorder2 = record_two_runs( lambda: self.makeView("+webhooks")(), create_webhook, 10) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_builders_recipe_build_query_count(self): def create_build(): build = self.createRecipeBuildWithBuilder() build.updateStatus(BuildStatus.NEEDSBUILD, force_invalid_transition=True) queue = build.queueBuild() queue.markAsBuilding(build.builder) nb_objects = 2 recorder1, recorder2 = record_two_runs(builders_homepage_render, create_build, nb_objects) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_ppa_index_queries_count(self): def ppa_index_render(): with person_logged_in(self.team.teamowner): view = create_initialized_view(self.private_ppa, '+index', principal=self.team.teamowner) view.page_title = "title" view.render() recorder1, recorder2 = record_two_runs(ppa_index_render, self.createPackage, 2, 3) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_build_history_queries_count_translation_template_builds(self): # Rendering to builder's history issues a constant number of queries # when translation template builds are displayed. def builder_history_render(): create_initialized_view(self.builder, '+history').render() recorder1, recorder2 = record_two_runs( builder_history_render, partial(self.createTranslationTemplateBuildWithBuilder, builder=self.builder), self.nb_objects) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_ppa_index_queries_count(self): def ppa_index_render(): with person_logged_in(self.team.teamowner): view = create_initialized_view( self.private_ppa, '+index', principal=self.team.teamowner) view.page_title = "title" view.render() recorder1, recorder2 = record_two_runs( ppa_index_render, self.createPackage, 2, 3) self.assertThat( recorder2, HasQueryCount(LessThan(recorder1.count + 2)))
def test_build_history_queries_count_view_recipe_builds(self): # The builder's history view creation (i.e. the call to # view.setupBuildList) issues a constant number of queries # when recipe builds are displayed. def builder_history_render(): create_initialized_view(self.builder, '+history').render() recorder1, recorder2 = record_two_runs( builder_history_render, partial(self.createRecipeBuildWithBuilder, builder=self.builder), self.nb_objects) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_builders_translation_template_build_query_count(self): def create_build(): jobset = getUtility(ITranslationTemplatesBuildJobSource) branch = self.factory.makeBranch() specific_job = jobset.create(branch) queue = IStore(BuildQueue).find( BuildQueue, job=specific_job.job).one() queue.markAsBuilding(self.factory.makeBuilder()) nb_objects = 2 recorder1, recorder2 = record_two_runs( builders_homepage_render, create_build, nb_objects) self.assertThat(recorder2, HasQueryCount(Equals(recorder1.count)))
def test_branch_query_count(self): # The number of queries required to render the list of all recipes # for a branch is constant in the number of owners and recipes. person = self.factory.makePerson() branch = self.factory.makeProductBranch(owner=person) def create_recipe(): with person_logged_in(person): self.factory.makeSourcePackageRecipe(branches=[branch]) recorder1, recorder2 = record_two_runs( lambda: self.getMainText(branch, "+recipes"), create_recipe, 5) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_webhooks_query_count(self): def get_webhooks(): representation = self.webservice.get( self.target_url + '/webhooks', api_version='devel').jsonBody() self.assertIn(len(representation['entries']), (0, 2, 4)) def create_webhook(): with person_logged_in(self.owner): self.factory.makeWebhook(target=self.target) get_webhooks() recorder1, recorder2 = record_two_runs(get_webhooks, create_webhook, 2) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_builders_variety_query_count(self): def create_builds(): bqs = [ self.factory.makeBinaryPackageBuild().queueBuild(), self.factory.makeSourcePackageRecipeBuild().queueBuild(), self.factory.makeTranslationTemplatesBuild().queueBuild(), ] for bq in bqs: bq.markAsBuilding(self.factory.makeBuilder()) nb_objects = 2 recorder1, recorder2 = record_two_runs(builders_homepage_render, create_builds, nb_objects) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_build_history_queries_count_binary_package_builds_in_ppa(self): # Rendering to builder's history issues a constant number of queries # when ppa binary builds are displayed. def builder_history_render(): create_initialized_view(self.builder, '+history').render() createBinaryPackageBuildInPPA = partial(self.createBinaryPackageBuild, in_ppa=True, builder=self.builder) recorder1, recorder2 = record_two_runs(builder_history_render, createBinaryPackageBuildInPPA, self.nb_objects) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_deliveries_query_count(self): def get_deliveries(): representation = self.webservice.get( self.webhook_url + '/deliveries', api_version='devel').jsonBody() self.assertIn(len(representation['entries']), (0, 2, 4)) def create_delivery(): with person_logged_in(self.owner): self.webhook.ping() get_deliveries() recorder1, recorder2 = record_two_runs(get_deliveries, create_delivery, 2) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_findTeam_query_count(self): with admin_logged_in(): ws = webservice_for_person(self.factory.makePerson()) def create_match(): with admin_logged_in(): self.factory.makeTeam(displayname='foobar') def find_teams(): ws.named_get('/people', 'findTeam', text="foobar").jsonBody() # Ensure that we're already in a stable cache state. find_teams() recorder1, recorder2 = record_two_runs( find_teams, create_match, 2) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_getPublishedBinaries_query_count(self): # getPublishedBinaries has a query count constant in the number of # packages returned. archive_url = api_url(self.archive) def create_bpph(): with admin_logged_in(): self.factory.makeBinaryPackagePublishingHistory( archive=self.archive) def get_binaries(): LaunchpadWebServiceCaller('consumer', '').named_get( archive_url, 'getPublishedBinaries').jsonBody() recorder1, recorder2 = record_two_runs(get_binaries, create_bpph, 1) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_getAllPermissions_constant_query_count(self): # getAllPermissions has a query count constant in the number of # permissions and people. def create_permission(): with celebrity_logged_in('admin'): ArchivePermission(archive=self.archive, person=self.factory.makePerson(), component=getUtility(IComponentSet)["main"], permission=ArchivePermissionType.UPLOAD) def get_permissions(): list(self.main_archive.getAllPermissions()) recorder1, recorder2 = record_two_runs(get_permissions, create_permission, 1) self.assertThat(recorder2, HasQueryCount(Equals(recorder1.count)))
def test_getAllPermissions_constant_query_count(self): # getAllPermissions has a query count constant in the number of # permissions and people. def create_permission(): with celebrity_logged_in('admin'): ArchivePermission( archive=self.archive, person=self.factory.makePerson(), component=getUtility(IComponentSet)["main"], permission=ArchivePermissionType.UPLOAD) def get_permissions(): list(self.main_archive.getAllPermissions()) recorder1, recorder2 = record_two_runs( get_permissions, create_permission, 1) self.assertThat(recorder2, HasQueryCount(Equals(recorder1.count)))
def test_query_count(self): person = self.factory.makePerson() login_person(person) ITranslationsPerson(person).translations_relicensing_agreement = True product = self.factory.makeProduct(owner=person) product.translationpermission = TranslationPermission.OPEN pofile = self.factory.makePOFile( potemplate=self.factory.makePOTemplate( productseries=product.series[0])) pofile.potemplate.productseries.product potmsgsets = [ self.factory.makePOTMsgSet(pofile.potemplate) for i in range(10)] # Preload a few transaction-crossing caches that would give # extra queries to the first request. getUtility(ILaunchBag).time_zone getUtility(ILaunchpadCelebrities).ubuntu person.inTeam(getUtility(ILaunchpadCelebrities).admin) person.inTeam(getUtility(ILaunchpadCelebrities).rosetta_experts) def create_suggestions(): for potmsgset in potmsgsets: pot = self.factory.makePOTemplate() self.factory.makeCurrentTranslationMessage( potmsgset=self.factory.makePOTMsgSet( singular=potmsgset.msgid_singular.msgid, potemplate=pot), language=pofile.language, translations=[self.factory.getUniqueUnicode()]) # A suggestion only shows up if it's actually in a # POFile. self.factory.makePOFile( potemplate=pot, language=pofile.language) self.factory.makeSuggestion( pofile=pofile, potmsgset=potmsgset) # Ensure that these are valid suggestions. templateset = getUtility(IPOTemplateSet) templateset.wipeSuggestivePOTemplatesCache() templateset.populateSuggestivePOTemplatesCache() nb_objects = 2 recorder1, recorder2 = record_two_runs( lambda: create_initialized_view( pofile, '+translate', principal=person)(), create_suggestions, nb_objects) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_build_history_queries_count_view_recipe_builds(self): # The builder's history view creation (i.e. the call to # view.setupBuildList) issues a constant number of queries # when recipe builds are displayed. def builder_history_render(): create_initialized_view(self.builder, '+history').render() recorder1, recorder2 = record_two_runs( builder_history_render, partial(self.createRecipeBuildWithBuilder, builder=self.builder), self.nb_objects) # XXX: rvb 2011-11-14: The only query remaining is the one that # results from a call to # sourcepackagerecipebuild.buildqueue_record for each recipe build. self.assertThat( recorder2, HasQueryCount(Equals(recorder1.count + 1 * self.nb_objects)))
def test_searchQuestions_query_count(self): webservice = webservice_for_person(self.factory.makePerson()) def create_question(): with admin_logged_in(): self.factory.makeQuestion(title="foobar") def search_questions(): webservice.named_get('/questions', 'searchQuestions', search_text='foobar', api_version='devel').jsonBody() search_questions() recorder1, recorder2 = record_two_runs(search_questions, create_question, 2) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_getSourcePackagePublishing_query_count(self): # Check that the number of queries required to publish source # packages is constant in the number of source packages. def get_index_stanzas(): for spp in self.series.getSourcePackagePublishing( PackagePublishingPocket.RELEASE, self.universe_component, self.series.main_archive): build_source_stanza_fields(spp.sourcepackagerelease, spp.component, spp.section) recorder1, recorder2 = record_two_runs( get_index_stanzas, partial(self.makeSeriesPackage, pocket=PackagePublishingPocket.RELEASE, status=PackagePublishingStatus.PUBLISHED), 5, 5) self.assertThat(recorder1, HasQueryCount(Equals(11))) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_featured_projects_query_count(self): def add_featured_projects(): product = self.factory.makeProduct() project = self.factory.makeProject() distribution = self.factory.makeDistribution() for pillar in product, project, distribution: pillar.icon = self.factory.makeLibraryFileAlias(db_only=True) getUtility(IPillarNameSet).add_featured_project(pillar) root = getUtility(ILaunchpadRoot) user = self.factory.makePerson() recorder1, recorder2 = record_two_runs( lambda: create_initialized_view(root, 'index.html', principal=user) (), add_featured_projects, 5, login_method=login_admin) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_query_count(self): person = self.factory.makePerson() source = self.factory.makeArchive() def create_targets(): self.factory.makeArchive(owner=self.factory.makeTeam( members=[person])) archive = self.factory.makeArchive() with admin_logged_in(): archive.newComponentUploader(person, 'main') nb_objects = 2 login_person(person) recorder1, recorder2 = record_two_runs( lambda: create_initialized_view( source, '+copy-packages', principal=person), create_targets, nb_objects) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_query_count(self): cve = self.getCVE() cve_url = canonical_url(cve) person = self.factory.makePerson() def make_bug_and_tasks(): bug = self.factory.makeBug() self.factory.makeBugTask(bug=bug, target=self.factory.makeProductSeries()) self.factory.makeBugTask(bug=bug, target=self.factory.makeSourcePackage()) bug.linkCVE(cve, person) recorder1, recorder2 = record_two_runs( lambda: self.getUserBrowser(cve_url, person), make_bug_and_tasks, 2, 10, login_method=lambda: login_person(person)) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_getBinaryPackagePublishing_query_count(self): # Check that the number of queries required to publish binary # packages is constant in the number of binary packages. def get_index_stanzas(das): for bpp in self.series.getBinaryPackagePublishing( das.architecturetag, PackagePublishingPocket.RELEASE, self.universe_component, self.series.main_archive): build_binary_stanza_fields(bpp.binarypackagerelease, bpp.component, bpp.section, bpp.priority, bpp.phased_update_percentage, False) das = self.factory.makeDistroArchSeries(distroseries=self.series) recorder1, recorder2 = record_two_runs( partial(get_index_stanzas, das), partial(self.makeSeriesBinaryPackage, das=das, pocket=PackagePublishingPocket.RELEASE, status=PackagePublishingStatus.PUBLISHED), 5, 5) self.assertThat(recorder1, HasQueryCount(Equals(15))) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_binaryFileUrls_include_meta(self): person = self.factory.makePerson() webservice = webservice_for_person( person, permission=OAuthPermission.READ_PUBLIC) bpph, url = self.make_bpph_for(person) def create_file(): self.factory.makeBinaryPackageFile( binarypackagerelease=bpph.binarypackagerelease) def get_urls(): return webservice.named_get(url, 'binaryFileUrls', include_meta=True, api_version='devel') recorder1, recorder2 = record_two_runs(get_urls, create_file, 2, login_method=partial( login_person, person), record_request=True) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1)) response = get_urls() self.assertEqual(200, response.status) info = response.jsonBody() with person_logged_in(person): expected_info = [{ "url": ProxiedLibraryFileAlias(bpf.libraryfile, bpph.archive).http_url, "size": bpf.libraryfile.content.filesize, "sha1": bpf.libraryfile.content.sha1, "sha256": bpf.libraryfile.content.sha256, } for bpf in bpph.binarypackagerelease.files] self.assertContentEqual(expected_info, info)