def test_settings_form_should_hide_directory_settings_if_no_directory_is_used(
self):
form = SettingsForm(self._create_settings_data())
request = fake_request(path='')
form.configure(request, None, edit=False)
self.assertFalse(form.has_tab('Directory'))
self.assertIsNone(form.fields.get('order_mode'))
def test_settings_form(self):
s = Settings()
s.save()
form = SettingsForm(self._create_settings_data(s))
request = fake_request(path='')
form.configure(request, s, edit=True)
self.assertTrue(form.is_valid())
def test_cms_api_view_publish_should_raise_value_error_on_http404(
self, publish):
publish.side_effect = Http404
view = CmsApiView()
request = fake_request(path='/')
with self.assertRaises(ValueError):
response = view.publish(request)
def test_cms_api_view_publish_returns_dict(self):
view = CmsApiView()
request = fake_request(path='/')
response = view.publish(request)
self.assertIsInstance(response, dict)
cms = get_cms()
cms.invalidate()
def test_settings_form_without_child_page_choices_should_remove_pagination_fields(
self, get_child_page_model_choices):
get_child_page_model_choices.return_value = []
form = SettingsForm(self._create_settings_data())
request = fake_request(path='')
form.configure(request, None, edit=False)
self.assertFalse(form.has_tab('Pagination'))
self.assertIsNone(form.fields.get('page_size'))
self.assertIsNone(form.fields.get('max_page_size'))
def test_settings_form_should_raise_error_if_closing_time_specified_without_opening_time(
self):
form = SettingsForm(
self._create_settings_data(None,
{'monday_close': datetime.time()}))
request = fake_request(path='')
form.configure(request, None, edit=False)
self.assertFalse(form.is_valid())
self.assertEqual(
{'monday_start': [SettingsForm.ERROR_OPENING_TIME_REQUIRED]},
form.errors)
def test_settings_form_should_parse_page_size_as_integer(self):
s = Settings()
s.save()
form = SettingsForm(
self._create_settings_data(s, {
'page_size': '10',
'max_page_size': '100'
}))
request = fake_request(path='')
form.configure(request, s, edit=True)
self.assertTrue(form.is_valid())
self.assertEqual(10, form.cleaned_data.get('page_size'))
self.assertEqual(100, form.cleaned_data.get('max_page_size'))
def test_settings_form_should_raise_error_if_enquiry_email_and_reply_to_address_are_the_same(
self):
s = Settings()
s.save()
form = SettingsForm(
self._create_settings_data(
s, {
'enquiry_email': '*****@*****.**',
'enquiry_from': '*****@*****.**',
'enquiry_reply': '*****@*****.**'
}))
request = fake_request(path='')
form.configure(request, s, edit=True)
self.assertFalse(form.is_valid())
self.assertFormFieldError(
form, 'enquiry_from',
SettingsForm.ERROR_FROM_EMAIL_CANNOT_BE_THE_SAME_AS_ENQUIRY_EMAIL)
def test_settings_form_should_fail_if_max_page_size_it_lower_than_page_size(
self):
s = Settings()
s.save()
form = SettingsForm(
self._create_settings_data(s, {
'page_size': '10',
'max_page_size': '5'
}))
request = fake_request(path='')
form.configure(request, s, edit=True)
self.assertFalse(form.is_valid())
self.assertEqual(
{
'max_page_size':
['Max. page size needs to be at least the page size of 10.']
}, form.errors)
def test_settings_form_should_raise_error_if_closing_time_is_before_opening_time(
self):
form = SettingsForm(
self._create_settings_data(
None, {
'monday_start': datetime.time(17, 0, 0),
'monday_close': datetime.time(9, 0, 0)
}))
request = fake_request(path='')
form.configure(request, None, edit=False)
self.assertFalse(form.is_valid())
self.assertEqual(
{
'monday_start': [
SettingsForm.
ERROR_OPENING_TIME_MUST_COME_BEFORE_CLOSING_TIME
]
}, form.errors)
def _create_form(self,
page=None,
edit=False,
is_duplicate=False,
slug='page',
identifier=None):
form = PageForm({
'slug':
slug,
'template':
'testapp/page.html',
'title':
'Page 1',
'identifier':
identifier,
'_cubane_instance_checksum':
page.get_checksum() if page else None
})
request = fake_request(path='')
form.is_duplicate = is_duplicate
form.configure(request, page, edit=edit)
return form
def _create_form(self,
child_page=None,
page=None,
edit=False,
is_duplicate=False,
slug='child-page-1',
title='Child Page 1',
template='testapp/page.html'):
form = BlogPostForm({
'page':
page.pk if page else None,
'_cubane_instance_checksum':
child_page.get_checksum() if child_page else None,
'slug':
slug,
'template':
template,
'title':
title
})
request = fake_request(path='')
form.is_duplicate = is_duplicate
form.configure(request, child_page, edit=edit)
return form
def setUp(self):
self.request = fake_request(path='')
def _get_request(self):
request = fake_request(path='/')
request.user = User(is_staff=True, is_superuser=True)
return request
def _publish_content(self, verbose=False):
"""
Publish cms content.
"""
from cubane.cms.views import fake_request
# add all pages
start = time.time()
for page in self.cms.get_pages():
if self.quit:
break
# determine type of page
is_homepage = self.cms.settings.homepage_id == page.id
is_contact_page = self.cms.settings.contact_page_id == page.id
# skip contact page if CSRF is enabled, since we would not
# be able to generate a dynamic CSRF token if this page is cached
if 'django.middleware.csrf.CsrfViewMiddleware' in settings.MIDDLEWARE_CLASSES and is_contact_page:
continue
# add page
self.process_page(page=page, verbose=verbose)
# add paginated pages
entity_model = page.get_entity_model()
if entity_model and self.cms.settings.paging_enabled_for(
entity_model):
# get all available pages, starting with page number 2
# and continue as long as we do not get 404...
i = 2
has_pages = True
# adding an upper bound of max_pages
child_page_count = entity_model.objects.count()
while has_pages and child_page_count > 0:
page_part = 'page-%d' % i
slug = '/%s/%s/' % (page.slug, page_part)
# render page
has_pages = self.process_page_by_slug(slug=slug,
verbose=verbose)
i += 1
child_page_count -= 1
# add all child pages
for model in self.cms.get_child_page_models():
if self.quit:
break
# if a page is assigned to this child_page_model
pages = self.cms.get_pages().filter(entity_type=model.__name__)
pages = self.cms.filter_out_childpages_on_sitemap(pages)
if pages.count() > 0:
for child_page in self.cms.filter_out_childpages_on_sitemap(
self.cms.get_child_pages_for_model(model)):
page = child_page.page
# ignore child page with parent reference
if page == None:
continue
# ignore, if parent page does not support entity type
if page.entity_type != model.__name__:
continue
# add child page to cache
self.process_page(page=child_page, verbose=verbose)
# give other modules a place to do something with the cache
self.cms.on_generate_cache(self, verbose)
# add non-cms pages
for custom_page in self.cms.custom_sitemap.cached_pages():
if self.quit: break
local_url = custom_page.local_url
request = fake_request(local_url, self.cms)
view, args, kwargs = resolve(local_url)
kwargs['request'] = request
# render page
try:
response = view(*args, **kwargs)
# generate cache entry
if response and response.status_code == 200:
path = os.path.join(local_url.lstrip('/'), 'index.html')
self.add_to_cache(path,
custom_page.lastmod,
None,
response.content,
verbose=verbose)
except Http404:
pass
# generate cache index file, even if we are forced to quit...
self.cache.write()
self.cache.cleanup()
# present a message that we got terminated by another process
if self.quit:
out('- TERMINATED -', verbose=verbose)
end = time.time()
return (self.cache.items, self.cache.size, end - start)