def test_related_feature_info__enabled_feature_with_default_same_value(
self):
# If a view
# * has a non-empty sequence of related feature flags,
# * the default scope and a non-default scope are defined
# and have the same values,
# then is_beta is false.
# Unless related_features forces it to always be beta, and the
# flag is set.
self.useFixture(
FeatureFixture({},
self.makeFeatureFlagDictionaries(u'on', u'on'),
override_scope_lookup=lambda scope_name: True))
request = LaunchpadTestRequest()
view = LaunchpadView(object(), request)
view.related_features = {'test_feature': False}
self.assertEqual(
{
'test_feature': {
'is_beta': False,
'title': 'title',
'url': 'http://wiki.lp.dev/LEP/sample',
'value': 'on',
}
}, view.related_feature_info)
view.related_features['test_feature'] = True
self.assertEqual(
{
'test_feature': {
'is_beta': True,
'title': 'title',
'url': 'http://wiki.lp.dev/LEP/sample',
'value': 'on',
}
}, view.related_feature_info)
self.useFixture(
FeatureFixture({},
self.makeFeatureFlagDictionaries(u'on', u''),
override_scope_lookup=lambda scope_name: True))
self.assertEqual(
{
'test_feature': {
'is_beta': False,
'title': 'title',
'url': 'http://wiki.lp.dev/LEP/sample',
'value': '',
}
}, view.related_feature_info)
def test_fixture_sets_one_flag_and_cleans_up_again(self):
flag = self.getUniqueString()
value_before_fixture_setup = getFeatureFlag(flag)
value_after_fixture_setup = None
fixture = FeatureFixture({flag: 'on'})
fixture.setUp()
value_after_fixture_setup = getFeatureFlag(flag)
fixture.cleanUp()
self.assertEqual(value_after_fixture_setup, 'on')
self.assertEqual(value_before_fixture_setup, getFeatureFlag(flag))
self.assertNotEqual(
value_before_fixture_setup, value_after_fixture_setup)
def test_active_related_features__enabled_feature(self):
# If a view has a non-empty sequence of related feature flags and if
# only a non-default scope is defined and active, the property
# active_related_features contains this feature flag.
self.useFixture(FeatureFixture(
{},
(
{
u'flag': u'test_feature',
u'scope': u'pageid:foo',
u'priority': 0,
u'value': u'on',
},
),
override_scope_lookup=lambda scope_name: True))
request = LaunchpadTestRequest()
view = LaunchpadView(object(), request)
view.related_features = ['test_feature']
self.assertEqual({
'test_feature': {
'is_beta': True,
'title': 'title',
'url': 'http://wiki.lp.dev/LEP/sample',
'value': 'on'}
},
view.related_feature_info)
def test_smoke_admining_team(self):
# Smoke test, primarily for DB permissions needed by queries to work
# with admining users and teams
# Check the oopses in /var/tmp/lperr.test if the assertions fail.
self.useFixture(FeatureFixture({
'jobs.celery.enabled_classes': 'MembershipNotificationJob'
}))
team = self.factory.makeTeam(name='a-team')
with person_logged_in(team.teamowner):
# This implicitly creates a job, but it is not the job under test.
admining_team = self.factory.makeTeam()
team.addMember(
admining_team, team.teamowner, force_team_add=True)
membership = getUtility(ITeamMembershipSet).getByPersonAndTeam(
admining_team, team)
membership.setStatus(
TeamMembershipStatus.ADMIN, team.teamowner)
person = self.factory.makePerson(name='murdock')
with block_on_job(self):
transaction.commit()
pop_remote_notifications()
job = getUtility(IMembershipNotificationJobSource).create(
person, team, team.teamowner,
TeamMembershipStatus.APPROVED, TeamMembershipStatus.ADMIN)
with block_on_job(self):
transaction.commit()
self.assertEqual(JobStatus.COMPLETED, job.status)
(notification,) = pop_remote_notifications()
self.assertIn('murdock made admin by', notification['Subject'])
def test_triggers_webhooks(self):
# Jobs trigger any relevant webhooks when they're enabled.
self.useFixture(FeatureFixture({'code.git.webhooks.enabled': 'on'}))
repository = self.factory.makeGitRepository()
self.factory.makeGitRefs(
repository, paths=['refs/heads/master', 'refs/tags/1.0'])
hook = self.factory.makeWebhook(
target=repository, event_types=['git:push:0.1'])
job = GitRefScanJob.create(repository)
paths = ('refs/heads/master', 'refs/tags/2.0')
self.useFixture(GitHostingFixture(refs=self.makeFakeRefs(paths)))
with dbuser('branchscanner'):
JobRunner([job]).runAll()
delivery = hook.deliveries.one()
sha1 = lambda s: hashlib.sha1(s).hexdigest()
self.assertThat(
delivery,
MatchesStructure(
event_type=Equals('git:push:0.1'),
payload=MatchesDict({
'git_repository': Equals('/' + repository.unique_name),
'git_repository_path': Equals(repository.unique_name),
'ref_changes': Equals({
'refs/tags/1.0': {
'old': {'commit_sha1': sha1('refs/tags/1.0')},
'new': None},
'refs/tags/2.0': {
'old': None,
'new': {'commit_sha1': sha1('refs/tags/2.0')}},
})})))
with dbuser(config.IWebhookDeliveryJobSource.dbuser):
self.assertEqual(
"<WebhookDeliveryJob for webhook %d on %r>" % (
hook.id, hook.target),
repr(delivery))
def test_setUpSubWidgets_dsp_picker_feature_flag(self):
# The DistributionSourcePackageVocabulary is used when the
# disclosure.dsp_picker.enabled is true.
with FeatureFixture({u"disclosure.dsp_picker.enabled": u"on"}):
self.widget.setUpSubWidgets()
self.assertIsInstance(self.widget.package_widget.context.vocabulary,
DistributionSourcePackageVocabulary)
def test_scheduled_start(self):
# Submit four jobs: one in the past, one in the far future, one
# in 10 seconds, and one at any time. Wait up to a minute and
# ensure that the correct three have completed, and that they
# completed in the expected order.
self.useFixture(
FeatureFixture({'jobs.celery.enabled_classes': 'TestJob'}))
now = datetime.now(UTC)
job_past = TestJob(scheduled_start=now - timedelta(seconds=60))
job_past.celeryRunOnCommit()
self.assertTrue(job_past.is_runnable)
job_forever = TestJob(scheduled_start=now + timedelta(seconds=600))
job_forever.celeryRunOnCommit()
self.assertFalse(job_forever.is_runnable)
job_future = TestJob(scheduled_start=now + timedelta(seconds=10))
job_future.celeryRunOnCommit()
self.assertFalse(job_future.is_runnable)
job_whenever = TestJob(scheduled_start=None)
job_whenever.celeryRunOnCommit()
self.assertTrue(job_whenever.is_runnable)
transaction.commit()
count = 0
while (count < 300 and (job_past.is_pending or job_future.is_pending
or job_whenever.is_pending)):
sleep(0.2)
count += 1
transaction.abort()
self.assertEqual(JobStatus.COMPLETED, job_past.status)
self.assertEqual(JobStatus.COMPLETED, job_future.status)
self.assertEqual(JobStatus.COMPLETED, job_whenever.status)
self.assertEqual(JobStatus.WAITING, job_forever.status)
self.assertThat(job_future.date_started,
GreaterThan(job_past.date_started))
def setUp(self):
super(TestSnapBuild, self).setUp()
self.useFixture(FeatureFixture(SNAP_TESTING_FLAGS))
self.pushConfig("snappy",
store_url="http://sca.example/",
store_upload_url="http://updown.example/")
self.build = self.factory.makeSnapBuild()
def setUp(self):
self.useFixture(
FeatureFixture({
'jobs.celery.enabled_classes':
'RemoveArtifactSubscriptionsJob',
}))
super(RemoveArtifactSubscriptionsJobTestCase, self).setUp()
def test_jobs_with_retry_exceptions_are_queued_again(self):
# A job that raises a retry error is automatically queued
# and executed again.
self.useFixture(
FeatureFixture(
{'jobs.celery.enabled_classes': 'TestJobWithRetryError'}))
with block_on_job(self):
job = TestJobWithRetryError()
job.celeryRunOnCommit()
job_id = job.job_id
transaction.commit()
store = IStore(Job)
# block_on_job() is not aware of the Celery request
# issued when the retry exception occurs, but we can
# check the status of the job in the database.
def job_finished():
transaction.abort()
dbjob = store.find(Job, id=job_id)[0]
return (dbjob.status == JobStatus.COMPLETED
and dbjob.attempt_count == 2)
count = 0
while count < 300 and not job_finished():
# We have a maximum wait of one minute. We should not get
# anywhere close to that on developer machines (10 seconds was
# working fine), but when the test suite is run in parallel we
# can need a lot more time (see bug 1007576).
sleep(0.2)
count += 1
dbjob = store.find(Job, id=job_id)[0]
self.assertEqual(2, dbjob.attempt_count)
self.assertEqual(JobStatus.COMPLETED, dbjob.status)
def test_blog_posts(self):
"""Posts from the launchpad blog are shown when feature is enabled"""
self.useFixture(FeatureFixture({'app.root_blog.enabled': True}))
posts = [
self._make_blog_post(1, "A post", "Post contents.", "2002"),
self._make_blog_post(2, "Another post", "More contents.", "2003"),
]
calls = []
def _get_blog_posts():
calls.append('called')
return posts
root = getUtility(ILaunchpadRoot)
with anonymous_logged_in():
view = create_initialized_view(root, 'index.html')
view.getRecentBlogPosts = _get_blog_posts
result = view()
markup = BeautifulSoup(
result, parse_only=SoupStrainer(id='homepage-blogposts'))
self.assertEqual(['called'], calls)
items = markup.findAll('li', 'news')
# Notice about launchpad being opened is always added at the end
self.assertEqual(3, len(items))
a = items[-1].find("a")
self.assertEqual("Launchpad now open source", a.string.strip())
for post, item in zip(posts, items):
a = item.find("a")
self.assertEqual(post['link'], a["href"])
self.assertEqual(post['title'], a.string)
def test_triggers_webhooks(self):
# On tip change, any relevant webhooks are triggered.
self.useFixture(FeatureFixture({"code.bzr.webhooks.enabled": "on"}))
self.syncAndCount()
old_revid = self.db_branch.last_scanned_id
with dbuser(config.launchpad.dbuser):
hook = self.factory.makeWebhook(target=self.db_branch,
event_types=["bzr:push:0.1"])
self.commitRevision()
new_revid = self.bzr_branch.last_revision()
self.makeBzrSync(self.db_branch).syncBranchAndClose()
delivery = hook.deliveries.one()
self.assertThat(
delivery,
MatchesStructure(event_type=Equals("bzr:push:0.1"),
payload=MatchesDict({
"bzr_branch":
Equals("/" + self.db_branch.unique_name),
"bzr_branch_path":
Equals(self.db_branch.shortened_path),
"old":
Equals({"revision_id": old_revid}),
"new":
Equals({"revision_id": new_revid}),
})))
with dbuser(config.IWebhookDeliveryJobSource.dbuser):
self.assertEqual(
"<WebhookDeliveryJob for webhook %d on %r>" %
(hook.id, hook.target), repr(delivery))
def test_run(self):
# A proper test run closes bugs.
self.useFixture(FeatureFixture({
"jobs.celery.enabled_classes": "ProcessAcceptedBugsJob",
}))
distroseries = self.factory.makeDistroSeries()
spr = self.factory.makeSourcePackageRelease(
distroseries=distroseries, changelog_entry="changelog")
bug = self.factory.makeBug()
bugtask = self.factory.makeBugTask(
target=distroseries.getSourcePackage(spr.sourcepackagename),
bug=bug)
self.assertEqual(BugTaskStatus.NEW, bugtask.status)
job = getUtility(IProcessAcceptedBugsJobSource).create(
distroseries, spr, [bug.id])
self.assertEqual(distroseries, job.distroseries)
self.assertEqual(spr, job.sourcepackagerelease)
self.assertEqual([bug.id], job.bug_ids)
with block_on_job(self):
transaction.commit()
self.assertEqual(JobStatus.COMPLETED, job.status)
self.assertEqual(BugTaskStatus.FIXRELEASED, bugtask.status)
def setUp(self):
super(TestFeedSwift, self).setUp()
self.swift_fixture = self.useFixture(SwiftFixture())
self.useFixture(FeatureFixture({'librarian.swift.enabled': True}))
transaction.commit()
self.addCleanup(swift.connection_pool.clear)
# Restart the Librarian so it picks up the OS_* environment
# variables.
LibrarianLayer.librarian_fixture.killTac()
LibrarianLayer.librarian_fixture.setUp()
# Add some files. These common sample files all have their
# modification times set to the past so they will not be
# considered potential in-progress uploads.
the_past = time.time() - 25 * 60 * 60
self.librarian_client = LibrarianClient()
self.contents = [str(i) * i for i in range(1, 5)]
self.lfa_ids = [
self.add_file('file_{0}'.format(i), content, when=the_past)
for i, content in enumerate(self.contents)
]
self.lfas = [
IStore(LibraryFileAlias).get(LibraryFileAlias, lfa_id)
for lfa_id in self.lfa_ids
]
self.lfcs = [lfa.content for lfa in self.lfas]
def test_dkim_disabled(self):
"""With disabling flag set, mail isn't trusted."""
self.useFixture(FeatureFixture({
'mail.dkim_authentication.disabled': 'true'}))
# A test that would normally pass will now fail
self.assertRaises(self.failureException,
self.test_dkim_valid_strict)
def test_import_sourcepackages_skip(self):
# gina can be told to skip particular source versions by setting
# soyuz.gina.skip_source_versions to a space-separated list of
# $DISTRO/$NAME/$VERSION.
series = self.factory.makeDistroSeries()
archive_root = os.path.join(
os.path.dirname(__file__), 'gina_test_archive')
arch_component_items = ArchiveComponentItems(
archive_root, 'lenny', ['main'], [], True)
packages_map = PackagesMap(arch_component_items)
importer_handler = ImporterHandler(
transaction, series.distribution.name, series.name, archive_root,
PackagePublishingPocket.RELEASE, None)
def import_and_get_versions():
import_sourcepackages(
series.distribution.name, packages_map, archive_root,
importer_handler)
return [
p.source_package_version
for p in series.getPublishedSources('archive-copier')]
# Our test archive has archive-copier 0.1.5 and 0.3.6 With
# soyuz.gina.skip_source_versions set to
# '$distro/archive-copier/0.1.5', an import will grab only
# 0.3.6.
skiplist = '%s/archive-copier/0.1.5' % series.distribution.name
with FeatureFixture({'soyuz.gina.skip_source_versions': skiplist}):
self.assertContentEqual(['0.3.6'], import_and_get_versions())
# Importing again without the feature flag removed grabs both.
self.assertContentEqual(['0.1.5', '0.3.6'], import_and_get_versions())
def setUp(self):
super(TestTranslationImportQueueEntryView,
self).setUp('*****@*****.**')
if self.features:
self.useFixture(FeatureFixture(self.features))
self.queue = getUtility(ITranslationImportQueue)
self.uploader = self.factory.makePerson()
def test_getInputValue_package_dsp_dsp_picker_feature_flag(self):
# The field value is the package when the package radio button
# is selected and the package sub field has valid input.
self.widget.request = LaunchpadTestRequest(form=self.form)
with FeatureFixture({u"disclosure.dsp_picker.enabled": u"on"}):
self.widget.setUpSubWidgets()
self.assertEqual(self.package, self.widget.getInputValue())
def test_json_cache_collects_related_features_from_all_views(self):
# A typical page includes data from more than one view,
# for example, from macros. Related features from these sub-views
# are included in the JSON cache.
class TestView(LaunchpadView):
related_features = {'test_feature': False}
class TestView2(LaunchpadView):
related_features = {'test_feature_2': False}
self.useFixture(
FeatureFixture({},
self.makeFeatureFlagDictionaries(u'', u'on'),
override_scope_lookup=lambda scope_name: True))
request = LaunchpadTestRequest()
view = TestView(object(), request)
TestView2(object(), request)
with person_logged_in(self.factory.makePerson()):
self.assertEqual(
'{"related_features": '
'{"test_feature_2": {"url": "http://wiki.lp.dev/LEP/sample2",'
' "is_beta": true, "value": "on", "title": "title"}, '
'"test_feature": {"url": "http://wiki.lp.dev/LEP/sample", '
'"is_beta": true, "value": "on", "title": "title"}}}',
view.getCacheJSON())
def test_GenerateIncrementalDiffJob(self):
"""GenerateIncrementalDiffJob runs under Celery."""
self.useFixture(FeatureFixture(
{'jobs.celery.enabled_classes': 'GenerateIncrementalDiffJob'}))
with block_on_job():
job = make_runnable_incremental_diff_job(self)
transaction.commit()
self.assertEqual(JobStatus.COMPLETED, job.status)
def setUp(self):
super(TestSnapBuildWebservice, self).setUp()
self.useFixture(FeatureFixture(SNAP_TESTING_FLAGS))
self.person = self.factory.makePerson()
self.webservice = webservice_for_person(
self.person, permission=OAuthPermission.WRITE_PRIVATE)
self.webservice.default_api_version = "devel"
login(ANONYMOUS)
def setUp(self):
super(TestLiveFSWebservice, self).setUp()
self.useFixture(FeatureFixture({LIVEFS_FEATURE_FLAG: "on"}))
self.person = self.factory.makePerson(displayname="Test Person")
self.webservice = webservice_for_person(
self.person, permission=OAuthPermission.WRITE_PUBLIC)
self.webservice.default_api_version = "devel"
login(ANONYMOUS)
def setUp(self):
super(WebhookViewTestHelpers, self).setUp()
self.useFixture(FeatureFixture({'webhooks.new.enabled': 'true'}))
self.target = self.makeTarget()
self.owner = self.target.owner
self.webhook = self.factory.makeWebhook(
target=self.target, delivery_url=u'http://example.com/original')
login_person(self.owner)
def test_extraBuildArgs_private(self):
# If the snap is private, extraBuildArgs sends the appropriate
# arguments.
self.useFixture(FeatureFixture({SNAP_PRIVATE_FEATURE_FLAG: "on"}))
job = self.makeJob(private=True)
with dbuser(config.builddmaster.dbuser):
args = yield job.extraBuildArgs()
self.assertTrue(args["private"])
def test_disable_memcache(self):
self.useFixture(FeatureFixture({"code.git.log.disable_memcache":
"on"}))
path = self.ref.repository.getInternalPath()
key = "git.launchpad.dev:git-log:%s:%s" % (path, self.sha1_tip)
getUtility(IMemcacheClient).set(key.encode("UTF-8"), "[]")
self.assertNotEqual([], self.ref.getCommits(self.sha1_tip))
self.assertEqual("[]",
getUtility(IMemcacheClient).get(key.encode("UTF-8")))
def test_ReviewRequestedEmailJob(self):
"""ReviewRequestedEmailJob runs under Celery."""
request = self.factory.makeCodeReviewVoteReference()
self.useFixture(FeatureFixture(
{'jobs.celery.enabled_classes': 'ReviewRequestedEmailJob'}))
with block_on_job():
ReviewRequestedEmailJob.create(request)
transaction.commit()
self.assertEqual(1, len(pop_remote_notifications()))
def setUp(self):
super(TestLiveFSBuildOperations, self).setUp()
self.useFixture(FeatureFixture({LIVEFS_FEATURE_FLAG: "on"}))
self.useFixture(FakeLogger())
self.build = self.factory.makeLiveFSBuild()
self.build_url = canonical_url(self.build)
self.requester = self.build.requester
self.buildd_admin = self.factory.makePerson(
member_of=[getUtility(ILaunchpadCelebrities).buildd_admin])
def test_CodeReviewCommentEmailJob(self):
"""CodeReviewCommentEmailJob runs under Celery."""
comment = self.factory.makeCodeReviewComment()
self.useFixture(FeatureFixture(
{'jobs.celery.enabled_classes': 'CodeReviewCommentEmailJob'}))
with block_on_job():
CodeReviewCommentEmailJob.create(comment)
transaction.commit()
self.assertEqual(2, len(pop_remote_notifications()))
def test_submit_action_bug_supervisor_feature_flag(self):
# A bug supervisor sees the Target action label when the feature
# flag is enabled.
self.useFixture(FeatureFixture(
{'bugs.nominations.bug_supervisors_can_target': 'on'}))
login_person(self.bug_worker)
view = create_initialized_view(self.bug_task, name='+nominate')
action = view.__class__.actions.byname['actions.submit']
self.assertEqual('Target', action.label)
def test_MergeProposalUpdatedEmailJob(self):
"""MergeProposalUpdatedEmailJob runs under Celery."""
bmp = self.factory.makeBranchMergeProposal()
self.useFixture(FeatureFixture(
{'jobs.celery.enabled_classes': 'MergeProposalUpdatedEmailJob'}))
with block_on_job():
MergeProposalUpdatedEmailJob.create(
bmp, 'change', bmp.registrant)
transaction.commit()
self.assertEqual(2, len(pop_remote_notifications()))
def test_newWebhook_permissions(self):
self.useFixture(FeatureFixture({'webhooks.new.enabled': 'true'}))
webservice = LaunchpadWebServiceCaller()
response = webservice.named_post(self.target_url,
'newWebhook',
delivery_url='http://example.com/ep',
event_types=[self.event_type],
api_version='devel')
self.assertEqual(401, response.status)
self.assertIn('launchpad.Edit', response.body)