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_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_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_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_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)
