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_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_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_person_activereviews_query_count(self): base_bmps = 3 added_bmps = 4 recorder1, view1 = self.createUserBMPsAndRecordQueries(base_bmps) self.assertEqual(base_bmps, view1.proposal_count) self.addDetail("r1tb", Content(UTF8_TEXT, lambda: [str(recorder1)])) recorder2, view2 = self.createUserBMPsAndRecordQueries(base_bmps + added_bmps) self.assertEqual(base_bmps + added_bmps, view2.proposal_count) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
def test_product_activereviews_query_count(self): # We keep the number of bmps created small (3 and 7), see above. base_bmps = 3 added_bmps = 4 recorder1, view1 = self.createProductBMPsAndRecordQueries(base_bmps) self.assertEqual(base_bmps, view1.proposal_count) self.addDetail("r1tb", Content(UTF8_TEXT, lambda: [str(recorder1)])) recorder2, view2 = self.createProductBMPsAndRecordQueries(base_bmps + added_bmps) self.assertEqual(base_bmps + added_bmps, view2.proposal_count) self.assertThat(recorder2, HasQueryCount.byEquality(recorder1))
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_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.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_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_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_getSpecificJobs_sql_queries_count(self): # getSpecificJobs issues a constant number of queries. builds = self.createBuilds() build_farm_jobs = [build.build_farm_job for build in builds] flush_database_updates() with StormStatementRecorder() as recorder: getSpecificJobs(build_farm_jobs) builds2 = self.createBuilds() build_farm_jobs.extend([build.build_farm_job for build in builds2]) flush_database_updates() with StormStatementRecorder() as recorder2: getSpecificJobs(build_farm_jobs) self.assertThat(recorder, HasQueryCount.byEquality(recorder2))
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_getAllPermissions_constant_query_count(self): # getAllPermissions has a query count constant in the number of # permissions and people. def create_permission(): with admin_logged_in(): 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.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_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_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_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_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_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): 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_byEquality(self): old_collector = RequestTimelineCollector() old_collector.count = 2 old_collector.queries = [ (0, 1, "SQL-main-slave", "SELECT 1 FROM Person", None), (2, 3, "SQL-main-slave", "SELECT 1 FROM Product", None), ] new_collector = RequestTimelineCollector() new_collector.count = 3 new_collector.queries = [ (0, 1, "SQL-main-slave", "SELECT 1 FROM Person", None), (2, 3, "SQL-main-slave", "SELECT 1 FROM Product", None), (4, 5, "SQL-main-slave", "SELECT 1 FROM Distribution", None), ] matcher = HasQueryCount.byEquality(old_collector) mismatch = matcher.match(new_collector) self.assertThat(mismatch, Not(Is(None))) details = mismatch.get_details() old_lines = [] new_lines = [] self.assertThat(details, KeysEqual("queries", "other_queries")) self.assertEqual("text", details["other_queries"].content_type.type) old_lines.append("".join(details["other_queries"].iter_text())) self.assertEqual("text", details["queries"].content_type.type) new_lines.append("".join(details["queries"].iter_text())) separator = "-" * 70 expected_old_lines = [ "0-1@SQL-main-slave SELECT 1 FROM Person\n" + separator + "\n" + "2-3@SQL-main-slave SELECT 1 FROM Product\n" + separator, ] expected_new_lines = [ "0-1@SQL-main-slave SELECT 1 FROM Person\n" + separator + "\n" + "2-3@SQL-main-slave SELECT 1 FROM Product\n" + separator + "\n" + "4-5@SQL-main-slave SELECT 1 FROM Distribution\n" + separator, ] self.assertEqual(expected_old_lines, old_lines) self.assertEqual(expected_new_lines, new_lines) self.assertEqual( "queries do not match: %s" % (Equals(2).match(3).describe(),), mismatch.describe())
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)