def test_site_config(self, org_list, exclude_orgs, expected_message_count, mock_schedule_send, mock_ace):
filtered_org = 'filtered_org'
unfiltered_org = 'unfiltered_org'
site1 = SiteFactory.create(domain='foo1.bar', name='foo1.bar')
limited_config = SiteConfigurationFactory.create(values={'course_org_filter': [filtered_org]}, site=site1)
site2 = SiteFactory.create(domain='foo2.bar', name='foo2.bar')
unlimited_config = SiteConfigurationFactory.create(values={'course_org_filter': []}, site=site2)
for config in (limited_config, unlimited_config):
ScheduleConfigFactory.create(site=config.site)
ScheduleFactory.create(
start=datetime.datetime(2017, 8, 2, 17, 44, 30, tzinfo=pytz.UTC),
enrollment__course__org=filtered_org,
)
for _ in range(2):
ScheduleFactory.create(
start=datetime.datetime(2017, 8, 2, 17, 44, 30, tzinfo=pytz.UTC),
enrollment__course__org=unfiltered_org,
)
test_time_str = serialize(datetime.datetime(2017, 8, 2, 17, tzinfo=pytz.UTC))
with self.assertNumQueries(2):
tasks.recurring_nudge_schedule_hour(
limited_config.site.id, 3, test_time_str, org_list=org_list, exclude_orgs=exclude_orgs,
)
self.assertEqual(mock_schedule_send.apply_async.call_count, expected_message_count)
self.assertFalse(mock_ace.send.called)
def setUp(self):
super(SiteMixin, self).setUp()
self.site = SiteFactory.create()
self.site_configuration = SiteConfigurationFactory.create(
site=self.site,
values={
"SITE_NAME": self.site.domain,
"course_email_from_addr": "*****@*****.**",
"course_email_template_name": "fake_email_template",
"course_org_filter": "fakeX"
}
)
self.site_other = SiteFactory.create(
domain='testserver.fakeother',
name='testserver.fakeother'
)
self.site_configuration_other = SiteConfigurationFactory.create(
site=self.site_other,
values={
"SITE_NAME": self.site_other.domain,
"SESSION_COOKIE_DOMAIN": self.site_other.domain,
"course_org_filter": "fakeOtherX",
"ENABLE_MKTG_SITE": True,
"SHOW_ECOMMERCE_REPORTS": True,
"MKTG_URLS": {
"ROOT": "https://marketing.fakeother",
"ABOUT": "/fake-about"
}
}
)
# Initialize client with default site domain
self.use_site(self.site)
def test_set_policy_match_site_over_mode(self):
"""
Verify that, when both a mode-agnostic policy matching the site of a created entitlement and a site-agnostic
policy matching the mode of a created entitlement exist but no policy matching both the site and mode of the
created entitlement exists, the site-specific (mode-agnostic) policy matching the entitlement is selected over
the mode-specific (site-agnostic) policy.
"""
course_uuid = uuid.uuid4()
entitlement_data = self._get_data_set(self.user, str(course_uuid))
self.client.post(
self.entitlements_list_url,
data=json.dumps(entitlement_data),
content_type='application/json',
)
course_entitlement = CourseEntitlement.objects.get(
user=self.user,
course_uuid=course_uuid
)
policy_site = SiteFactory.create()
policy = CourseEntitlementPolicy.objects.create(mode=None, site=policy_site)
CourseEntitlementPolicy.objects.create(mode=entitlement_data['mode'], site=None)
set_entitlement_policy(course_entitlement, policy_site)
assert course_entitlement.policy == policy
def setUp(self):
self.sender = mock.Mock()
self.user = mock.Mock()
self.post = mock.Mock()
self.post.thread.course_id = 'course-v1:edX+DemoX+Demo_Course'
self.site = SiteFactory.create()
def setUp(self):
super(VerifiedUpgradeToolTest, self).setUp()
self.course_verified_mode = CourseModeFactory(
course_id=self.course.id,
mode_slug=CourseMode.VERIFIED,
expiration_datetime=self.now + datetime.timedelta(days=30),
)
patcher = patch('openedx.core.djangoapps.schedules.signals.get_current_site')
mock_get_current_site = patcher.start()
self.addCleanup(patcher.stop)
mock_get_current_site.return_value = SiteFactory.create()
DynamicUpgradeDeadlineConfiguration.objects.create(enabled=True)
ScheduleConfigFactory.create(
site=mock_get_current_site.return_value,
create_schedules=True
)
self.enrollment = CourseEnrollmentFactory(
course_id=self.course.id,
mode=CourseMode.AUDIT,
course=self.course_overview,
)
self.request = RequestFactory().request()
self.request.user = self.enrollment.user
crum.set_current_request(self.request)
def test_context(self, mock_get_enterprise_customer_for_learner):
self.request.site = SiteFactory.create()
mock_get_enterprise_customer_for_learner.return_value = {}
context = account_settings_context(self.request)
user_accounts_api_url = reverse("accounts_api", kwargs={'username': self.user.username})
self.assertEqual(context['user_accounts_api_url'], user_accounts_api_url)
user_preferences_api_url = reverse('preferences_api', kwargs={'username': self.user.username})
self.assertEqual(context['user_preferences_api_url'], user_preferences_api_url)
for attribute in self.FIELDS:
self.assertIn(attribute, context['fields'])
self.assertEqual(
context['user_accounts_api_url'], reverse("accounts_api", kwargs={'username': self.user.username})
)
self.assertEqual(
context['user_preferences_api_url'], reverse('preferences_api', kwargs={'username': self.user.username})
)
self.assertEqual(context['duplicate_provider'], 'facebook')
self.assertEqual(context['auth']['providers'][0]['name'], 'Facebook')
self.assertEqual(context['auth']['providers'][1]['name'], 'Google')
self.assertEqual(context['sync_learner_profile_data'], False)
self.assertEqual(context['edx_support_url'], settings.SUPPORT_SITE_LINK)
self.assertEqual(context['enterprise_name'], None)
self.assertEqual(
context['enterprise_readonly_account_fields'], {'fields': settings.ENTERPRISE_READONLY_ACCOUNT_FIELDS}
)
def test_set_policy_site_and_mode_specific(self):
"""
Verify that, when there exists a policy matching both the mode and site of the a given course entitlement,
it is selected over appropriate site- and mode-specific (mode- and site-agnostic) policies and the default
policy for assignment to the entitlement.
"""
course_uuid = uuid.uuid4()
entitlement_data = self._get_data_set(self.user, str(course_uuid))
entitlement_data['mode'] = CourseMode.PROFESSIONAL
self.client.post(
self.entitlements_list_url,
data=json.dumps(entitlement_data),
content_type='application/json',
)
course_entitlement = CourseEntitlement.objects.get(
user=self.user,
course_uuid=course_uuid
)
policy_site = SiteFactory.create()
policy = CourseEntitlementPolicy.objects.create(mode=entitlement_data['mode'], site=policy_site)
CourseEntitlementPolicy.objects.create(mode=entitlement_data['mode'], site=None)
CourseEntitlementPolicy.objects.create(mode=None, site=policy_site)
set_entitlement_policy(course_entitlement, policy_site)
assert course_entitlement.policy == policy
def setUp(self):
ScheduleFactory.create(start=datetime.datetime(2017, 8, 1, 15, 44, 30, tzinfo=pytz.UTC))
ScheduleFactory.create(start=datetime.datetime(2017, 8, 1, 17, 34, 30, tzinfo=pytz.UTC))
ScheduleFactory.create(start=datetime.datetime(2017, 8, 2, 15, 34, 30, tzinfo=pytz.UTC))
site = SiteFactory.create()
self.site_config = SiteConfigurationFactory.create(site=site)
ScheduleConfigFactory.create(site=self.site_config.site)
def setUp(self):
super(TestScheduleOverrides, self).setUp()
patcher = patch('openedx.core.djangoapps.schedules.signals.get_current_site')
mock_get_current_site = patcher.start()
self.addCleanup(patcher.stop)
mock_get_current_site.return_value = SiteFactory.create()
def test_create_schedule_error(self, mock_create_schedule, mock_log, mock_get_current_site):
site = SiteFactory.create()
mock_get_current_site.return_value = site
ScheduleConfigFactory.create(site=site)
mock_create_schedule.side_effect = ValueError('Fake error')
self.assert_schedule_not_created()
mock_log.assert_called_once()
assert 'Encountered error in creating a Schedule for CourseEnrollment' in mock_log.call_args[0][0]
def test_schedule_config_creation_enabled_instructor_paced(self, mock_get_current_site):
site = SiteFactory.create()
mock_get_current_site.return_value = site
ScheduleConfigFactory.create(site=site, enabled=True, create_schedules=True)
course = _create_course_run(self_paced=False)
enrollment = CourseEnrollmentFactory(course_id=course.id, mode=CourseMode.AUDIT)
with self.assertRaises(Schedule.DoesNotExist):
enrollment.schedule
def setUp(self):
super(TestSendRecurringNudge, self).setUp()
ScheduleFactory.create(start=datetime.datetime(2017, 8, 1, 15, 44, 30, tzinfo=pytz.UTC))
ScheduleFactory.create(start=datetime.datetime(2017, 8, 1, 17, 34, 30, tzinfo=pytz.UTC))
ScheduleFactory.create(start=datetime.datetime(2017, 8, 2, 15, 34, 30, tzinfo=pytz.UTC))
site = SiteFactory.create()
self.site_config = SiteConfigurationFactory.create(site=site)
ScheduleConfigFactory.create(site=self.site_config.site)
def test_get_course_org_filter_exclude(self, course_org_filter, expected_org_list):
resolver = self.setup_resolver()
self.other_site = SiteFactory.create()
self.other_site_config = SiteConfigurationFactory.create(
site=self.other_site,
values={'course_org_filter': course_org_filter},
)
exclude_orgs, org_list = resolver.get_course_org_filter()
assert exclude_orgs
self.assertItemsEqual(org_list, expected_org_list)
def setUp(self):
super(ScheduleSendEmailTestMixin, self).setUp()
site = SiteFactory.create()
self.site_config = SiteConfigurationFactory.create(site=site)
ScheduleConfigFactory.create(site=self.site_config.site)
DynamicUpgradeDeadlineConfiguration.objects.create(enabled=True)
CommerceConfiguration.objects.create(checkout_on_ecommerce_service=True)
self._courses_with_verified_modes = set()
def _create_ssl_request(self, url):
"""Creates a basic request for SSL use."""
request = self.factory.get(url)
request.META['SSL_CLIENT_S_DN'] = self.AUTH_DN.format(self.USER_NAME, self.USER_EMAIL)
request.site = SiteFactory.create()
request.user = AnonymousUser()
middleware = SessionMiddleware()
middleware.process_request(request)
request.session.save()
with patch('edxmako.request_context.get_current_request', return_value=request):
yield request
def setUp(self):
super(TestSendRecurringNudge, self).setUp()
ScheduleFactory.create(start=datetime.datetime(2017, 8, 1, 15, 44, 30, tzinfo=pytz.UTC))
ScheduleFactory.create(start=datetime.datetime(2017, 8, 1, 17, 34, 30, tzinfo=pytz.UTC))
ScheduleFactory.create(start=datetime.datetime(2017, 8, 2, 15, 34, 30, tzinfo=pytz.UTC))
site = SiteFactory.create()
self.site_config = SiteConfigurationFactory.create(site=site)
ScheduleConfigFactory.create(site=self.site_config.site)
DynamicUpgradeDeadlineConfiguration.objects.create(enabled=True)
def test_site_config(self, org_list, exclude_orgs, expected_message_count, mock_schedule_send, mock_ace):
filtered_org = 'filtered_org'
unfiltered_org = 'unfiltered_org'
site1 = SiteFactory.create(domain='foo1.bar', name='foo1.bar')
limited_config = SiteConfigurationFactory.create(values={'course_org_filter': [filtered_org]}, site=site1)
site2 = SiteFactory.create(domain='foo2.bar', name='foo2.bar')
unlimited_config = SiteConfigurationFactory.create(values={'course_org_filter': []}, site=site2)
for config in (limited_config, unlimited_config):
ScheduleConfigFactory.create(site=config.site)
user1 = UserFactory.create(id=tasks.RECURRING_NUDGE_NUM_BINS)
user2 = UserFactory.create(id=tasks.RECURRING_NUDGE_NUM_BINS * 2)
ScheduleFactory.create(
start=datetime.datetime(2017, 8, 3, 17, 44, 30, tzinfo=pytz.UTC),
enrollment__course__org=filtered_org,
enrollment__user=user1,
)
ScheduleFactory.create(
start=datetime.datetime(2017, 8, 3, 17, 44, 30, tzinfo=pytz.UTC),
enrollment__course__org=unfiltered_org,
enrollment__user=user1,
)
ScheduleFactory.create(
start=datetime.datetime(2017, 8, 3, 17, 44, 30, tzinfo=pytz.UTC),
enrollment__course__org=unfiltered_org,
enrollment__user=user2,
)
test_datetime = datetime.datetime(2017, 8, 3, 17, tzinfo=pytz.UTC)
test_datetime_str = serialize(test_datetime)
with self.assertNumQueries(NUM_QUERIES_WITH_MATCHES, table_blacklist=WAFFLE_TABLES):
tasks.recurring_nudge_schedule_bin(
limited_config.site.id, target_day_str=test_datetime_str, day_offset=-3, bin_num=0,
org_list=org_list, exclude_orgs=exclude_orgs,
)
self.assertEqual(mock_schedule_send.apply_async.call_count, expected_message_count)
self.assertFalse(mock_ace.send.called)
def setUp(self):
super(TestBinnedSchedulesBaseResolver, self).setUp()
self.site = SiteFactory.create()
self.site_config = SiteConfigurationFactory(site=self.site)
self.schedule_config = ScheduleConfigFactory.create(site=self.site)
self.resolver = BinnedSchedulesBaseResolver(
async_send_task=Mock(name='async_send_task'),
site=self.site,
target_datetime=datetime.datetime.now(),
day_offset=3,
bin_num=2,
)
def set_up_site(self, domain, site_configuration_values):
"""
Create Site and SiteConfiguration models and initialize test client with the created site
"""
site = SiteFactory.create(
domain=domain,
name=domain
)
__ = SiteConfigurationFactory.create(
site=site,
values=site_configuration_values
)
self.use_site(site)
def setUp(self):
super(SessionCookieDomainSiteConfigurationOverrideTests, self).setUp()
# Create a test client, and log it in so that it will save some session data.
self.user = UserFactory.create()
self.user.set_password('password')
self.user.save()
self.site = SiteFactory.create(
domain='testserver.fake',
name='testserver.fake'
)
self.site_configuration = SiteConfigurationFactory.create(
site=self.site,
values={
"SESSION_COOKIE_DOMAIN": self.site.domain,
}
)
self.client = Client()
self.client.login(username=self.user.username, password="******")
def _build_and_run_request(self, user, fields):
"""
Generate a request and invoke the view, returning the response.
The request will be a POST request from the given `user`, with the given
`fields` in the POST body.
"""
req = self._request_factory.post(
"/submit_feedback",
data=fields,
HTTP_REFERER=TEST_REQUEST_HEADERS["HTTP_REFERER"],
HTTP_USER_AGENT=TEST_REQUEST_HEADERS["HTTP_USER_AGENT"],
REMOTE_ADDR=TEST_REQUEST_HEADERS["REMOTE_ADDR"],
SERVER_NAME=TEST_REQUEST_HEADERS["SERVER_NAME"],
)
req.site = SiteFactory.create()
req.user = user
return views.submit_feedback(req)
def test_context(self, mock_get_enterprise_customer_for_learner):
self.request.site = SiteFactory.create()
UserPreferenceFactory(user=self.user, key='pref-lang', value='lt-lt')
DarkLangConfig(
released_languages='en',
changed_by=self.user,
enabled=True,
beta_languages='lt-lt',
enable_beta_languages=True
).save()
mock_get_enterprise_customer_for_learner.return_value = {}
with override_settings(LANGUAGES=[EN, LT_LT], LANGUAGE_CODE='en'):
context = account_settings_context(self.request)
user_accounts_api_url = reverse("accounts_api", kwargs={'username': self.user.username})
self.assertEqual(context['user_accounts_api_url'], user_accounts_api_url)
user_preferences_api_url = reverse('preferences_api', kwargs={'username': self.user.username})
self.assertEqual(context['user_preferences_api_url'], user_preferences_api_url)
for attribute in self.FIELDS:
self.assertIn(attribute, context['fields'])
self.assertEqual(
context['user_accounts_api_url'], reverse("accounts_api", kwargs={'username': self.user.username})
)
self.assertEqual(
context['user_preferences_api_url'], reverse('preferences_api', kwargs={'username': self.user.username})
)
self.assertEqual(context['duplicate_provider'], 'facebook')
self.assertEqual(context['auth']['providers'][0]['name'], 'Facebook')
self.assertEqual(context['auth']['providers'][1]['name'], 'Google')
self.assertEqual(context['sync_learner_profile_data'], False)
self.assertEqual(context['edx_support_url'], settings.SUPPORT_SITE_LINK)
self.assertEqual(context['enterprise_name'], None)
self.assertEqual(
context['enterprise_readonly_account_fields'], {'fields': settings.ENTERPRISE_READONLY_ACCOUNT_FIELDS}
)
expected_beta_language = {'code': 'lt-lt', 'name': settings.LANGUAGE_DICT.get('lt-lt')}
self.assertEqual(context['beta_language'], expected_beta_language)
def setUp(self):
patcher = patch('openedx.core.djangoapps.ace_common.templatetags.ace.get_current_request')
self.mock_get_current_request = patcher.start()
self.addCleanup(patcher.stop)
self.fake_request = HttpRequest()
self.fake_request.user = UserFactory.create()
self.fake_request.site = SiteFactory.create()
self.fake_request.site.domain = 'example.com'
self.mock_get_current_request.return_value = self.fake_request
self.message = Message(
app_label='test_app_label',
name='test_name',
recipient=Recipient(username='******'),
context={},
send_uuid=uuid.uuid4(),
)
self.context = {
'message': self.message
}
def test_ext_auth_password_length_too_short(self):
"""
Tests that even if password policy is enforced, ext_auth registrations aren't subject to it
"""
self.url_params['password'] = u'aaa' # shouldn't pass validation
request = self.request_factory.post(self.url, self.url_params)
request.site = SiteFactory.create()
# now indicate we are doing ext_auth by setting 'ExternalAuthMap' in the session.
request.session = import_module(settings.SESSION_ENGINE).SessionStore() # empty session
extauth = ExternalAuthMap(external_id='*****@*****.**',
external_email='*****@*****.**',
internal_password=self.url_params['password'],
external_domain='shib:https://idp.stanford.edu/')
request.session['ExternalAuthMap'] = extauth
request.user = AnonymousUser()
with patch('edxmako.request_context.get_current_request', return_value=request):
response = create_account(request)
self.assertEqual(response.status_code, 200)
obj = json.loads(response.content)
self.assertTrue(obj['success'])
def test_set_custom_site_policy_on_create(self):
"""
Verify that, when there does not exist a course entitlement policy with the same mode and site as
a created entitlement, but there does exist a policy with the same site and a null mode,
that policy is assigned to the entitlement.
"""
course_uuid = uuid.uuid4()
entitlement_data = self._get_data_set(self.user, str(course_uuid))
self.client.post(
self.entitlements_list_url,
data=json.dumps(entitlement_data),
content_type='application/json',
)
course_entitlement = CourseEntitlement.objects.get(
user=self.user,
course_uuid=course_uuid
)
policy_site = SiteFactory.create()
policy = CourseEntitlementPolicy.objects.create(mode=None, site=policy_site)
set_entitlement_policy(course_entitlement, policy_site)
assert course_entitlement.policy == policy
def get_request_and_strategy(self, auth_entry=None, redirect_uri=None):
"""Gets a fully-configured request and strategy.
These two objects contain circular references, so we create them
together. The references themselves are a mixture of normal __init__
stuff and monkey-patching done by python-social-auth. See, for example,
social_django.utils.strategy().
"""
request = self.request_factory.get(
pipeline.get_complete_url(self.backend_name) +
'?redirect_state=redirect_state_value&code=code_value&state=state_value')
request.site = SiteFactory.create()
request.user = auth_models.AnonymousUser()
request.session = cache.SessionStore()
request.session[self.backend_name + '_state'] = 'state_value'
if auth_entry:
request.session[pipeline.AUTH_ENTRY_KEY] = auth_entry
strategy = social_utils.load_strategy(request=request)
request.social_strategy = strategy
request.backend = social_utils.load_backend(strategy, self.backend_name, redirect_uri)
return request, strategy
def setUp(self):
self.site = SiteFactory.create()
self.site.domain = 'example.com'
super(TestAbsoluteUrl, self).setUp()
def test_schedule_config_disabled_waffle_disabled(self, mock_get_current_site):
site = SiteFactory.create()
mock_get_current_site.return_value = site
ScheduleConfigFactory.create(site=site, create_schedules=False)
self.assert_schedule_not_created()
def test_site_config(self, org_list, exclude_orgs, expected_message_count,
mock_schedule_send, mock_ace):
filtered_org = 'filtered_org'
unfiltered_org = 'unfiltered_org'
site1 = SiteFactory.create(domain='foo1.bar', name='foo1.bar')
limited_config = SiteConfigurationFactory.create(
values={'course_org_filter': [filtered_org]}, site=site1)
site2 = SiteFactory.create(domain='foo2.bar', name='foo2.bar')
unlimited_config = SiteConfigurationFactory.create(
values={'course_org_filter': []}, site=site2)
for config in (limited_config, unlimited_config):
ScheduleConfigFactory.create(site=config.site)
user1 = UserFactory.create(id=tasks.UPGRADE_REMINDER_NUM_BINS)
user2 = UserFactory.create(id=tasks.UPGRADE_REMINDER_NUM_BINS * 2)
ScheduleFactory.create(
upgrade_deadline=datetime.datetime(2017,
8,
3,
17,
44,
30,
tzinfo=pytz.UTC),
enrollment__course__org=filtered_org,
enrollment__user=user1,
)
ScheduleFactory.create(
upgrade_deadline=datetime.datetime(2017,
8,
3,
17,
44,
30,
tzinfo=pytz.UTC),
enrollment__course__org=unfiltered_org,
enrollment__user=user1,
)
ScheduleFactory.create(
upgrade_deadline=datetime.datetime(2017,
8,
3,
17,
44,
30,
tzinfo=pytz.UTC),
enrollment__course__org=unfiltered_org,
enrollment__user=user2,
)
test_time = datetime.datetime(2017, 8, 3, 17, tzinfo=pytz.UTC)
test_time_str = serialize(test_time)
with self.assertNumQueries(3):
tasks.upgrade_reminder_schedule_bin(
limited_config.site.id,
target_day_str=test_time_str,
day_offset=2,
bin_num=0,
org_list=org_list,
exclude_orgs=exclude_orgs,
)
self.assertEqual(mock_schedule_send.apply_async.call_count,
expected_message_count)
self.assertFalse(mock_ace.send.called)
def test_create_schedule_course_updates_experience(self, mock_course_has_highlights, mock_get_current_site):
site = SiteFactory.create()
mock_course_has_highlights.return_value = True
mock_get_current_site.return_value = site
self.assert_schedule_created(experience_type=ScheduleExperience.EXPERIENCES.course_updates)
def setUp(self):
self.site = SiteFactory.create()
self.site.domain = 'example.com'
super(TestAbsoluteUrl, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
def setUp(self):
super(TestProgramProgressMeter, self).setUp()
self.user = UserFactory()
self.site = SiteFactory()
def setUp(self):
super(TestCredentialsSignalsUtils, self).setUp()
self.site = SiteFactory()
self.course_run = CourseRunFactory()
course = CourseFactory(course_runs=[self.course_run])
self.data = [ProgramFactory(courses=[course])]
def setUp(self):
super().setUp()
self.site = SiteFactory.create()
self.site_config = SiteConfigurationFactory(site=self.site)
self.schedule_config = ScheduleConfigFactory.create(site=self.site)
def setUp(self):
super().setUp()
self.site = SiteFactory()
def test_schedule_config_disabled_waffle_disabled(self, mock_get_current_site):
site = SiteFactory.create()
mock_get_current_site.return_value = site
ScheduleConfigFactory.create(site=site, create_schedules=False)
self.assert_schedule_not_created()
def setUp(self):
self.site = SiteFactory.create()
self.site.domain = 'example.com'
def setUp(self):
super().setUp()
self.site = SiteFactory.create()
ScheduleConfigFactory.create(site=self.site)
DynamicUpgradeDeadlineConfiguration.objects.create(
enabled=True, deadline_days=self.VERIFICATION_DEADLINE_DAYS)
def setUp(self):
super(TestGetPrograms, self).setUp()
self.site = SiteFactory()
def setUp(self):
super(TestScheduleMessageBaseTask, self).setUp()
self.site = SiteFactory.create()
self.schedule_config = ScheduleConfigFactory.create(site=self.site)
self.basetask = ScheduleMessageBaseTask
def setUp(self):
super(UpdateScheduleTests, self).setUp()
self.site = SiteFactory.create()
ScheduleConfigFactory.create(site=self.site)
DynamicUpgradeDeadlineConfiguration.objects.create(enabled=True, deadline_days=self.VERIFICATION_DEADLINE_DAYS)
def test_create_schedule(self, mock_get_current_site):
site = SiteFactory.create()
mock_get_current_site.return_value = site
ScheduleConfigFactory.create(site=site)
self.assert_schedule_created()
def setUp(self):
super(SchedulesResolverTestMixin, self).setUp()
self.site = SiteFactory.create()
self.site_config = SiteConfigurationFactory(site=self.site)
self.schedule_config = ScheduleConfigFactory.create(site=self.site)
def setUp(self):
super(TestScheduleMessageBaseTask, self).setUp()
self.site = SiteFactory.create()
self.schedule_config = ScheduleConfigFactory.create(site=self.site)
self.basetask = ScheduleMessageBaseTask
def setUp(self):
super(TestGetPrograms, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments
self.site = SiteFactory()
def setUp(self): # lint-amnesty, pylint: disable=super-method-not-called
self.command = SendEmailBaseCommand()
self.site = SiteFactory()
self.site_config = SiteConfigurationFactory.create(site=self.site)
def setUp(self):
super(TestGetPathways, self).setUp()
self.site = SiteFactory()
