def testPageCorrectness(self):
self.client.logout()
# Check that QSD with desired URL does not exist
response = self.client.get(self.url)
self.assertEqual(response.status_code, 404)
# Create QSD with desired URL
qsd_rec_new = QuasiStaticData()
qsd_rec_new.url = 'learn/foo'
qsd_rec_new.name = "learn:foo"
qsd_rec_new.author = self.author
qsd_rec_new.nav_category = NavBarCategory.default()
qsd_rec_new.content = "Testing 123"
qsd_rec_new.title = "Test QSD page"
qsd_rec_new.description = ""
qsd_rec_new.keywords = ""
qsd_rec_new.save()
# Check that page now exists and has proper content
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTrue('Testing 123' in response.content)
# Edit QSD and check that page content has updated
qsd_rec_new.content = "Testing 456"
qsd_rec_new.save()
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTrue('Testing 456' in response.content)
def render(self, context):
try:
user = self.user_variable.resolve(context)
except template.VariableDoesNotExist:
user = None
try:
anchor = template.Variable(self.input_anchor)
anchor = anchor.resolve(context)
except:
anchor = GetNode(self.input_anchor)
try:
qsd = template.Variable(self.qsd_name)
qsd = qsd.resolve(context)
except:
qsd = self.qsd_name
edit_bits = UserBit.UserHasPerms(user, anchor, DataTree.get_by_uri('V/Administer/Edit'))
qsd_obj = QuasiStaticData.objects.get_by_path__name(anchor, qsd)
if qsd_obj == None:
new_qsd = QuasiStaticData()
new_qsd.path = anchor
new_qsd.name = qsd
new_qsd.title = qsd
new_qsd.content = self.nodelist.render(context)
if getattr(user, 'id', False):
new_qsd.author = user
new_qsd.save()
qsd_obj = new_qsd
return render_to_response("inclusion/qsd/render_qsd_inline.html", {'qsdrec': qsd_obj, 'edit_bits': edit_bits}, context_instance=context).content
def testInlineCorrectness(self):
self.client.logout()
# Create an inline QSD
qsd_rec_new = QuasiStaticData()
qsd_rec_new.url = 'learn/bar'
qsd_rec_new.name = "learn:bar"
qsd_rec_new.author = self.author
qsd_rec_new.nav_category = NavBarCategory.default()
qsd_rec_new.content = "Inline Testing 123"
qsd_rec_new.title = "Test QSD page"
qsd_rec_new.description = ""
qsd_rec_new.keywords = ""
qsd_rec_new.save()
# Render a template that uses the inline_qsd template tag
template_data = """
{% load render_qsd %}
{% render_inline_qsd "learn/bar" %}
"""
template = Template(template_data)
response_content = template.render(Context({}))
self.assertTrue("Inline Testing 123" in response_content)
# Update the template and check again
qsd_rec_new.content = "Inline Testing 456"
qsd_rec_new.save()
response_content = template.render(Context({}))
self.assertTrue("Inline Testing 456" in response_content)
response_content = template.render(Context({}))
self.assertTrue("Inline Testing 456" in response_content)
def setUp(self):
SeleniumTestCase.setUp(self)
# Make Q/Web public
UserBit.objects.create(verb=GetNode('V/Flags/Public'),
qsc=GetNode('Q/Web'))
# Make our users
self.admin_user, created = ESPUser.objects.get_or_create(
username='******', first_name='Harry', last_name='Alborez')
self.admin_user.set_password(self.PASSWORD_STRING)
make_user_admin(self.admin_user)
self.qsd_user, created = ESPUser.objects.get_or_create(
username='******', first_name='Aylik', last_name='Kewesd')
self.qsd_user.set_password(self.PASSWORD_STRING)
self.qsd_user.userbit_set.add(
UserBit(verb=GetNode('V/Administer/Edit'),
qsc=GetNode('Q'),
recursive=True))
self.qsd_user.save()
# Check that a NavBarCategory exists
if len(NavBarCategory.objects.all()) < 1:
nbc = NavBarCategory()
nbc.name = 'default'
nbc.save()
# Make our test page
qsd_rec_new = QuasiStaticData()
qsd_rec_new.path = GetNode('Q/Web')
qsd_rec_new.name = 'test'
qsd_rec_new.author = self.admin_user
qsd_rec_new.nav_category = NavBarCategory.default()
qsd_rec_new.content = ''
qsd_rec_new.title = 'Test page'
qsd_rec_new.description = ''
qsd_rec_new.keywords = ''
qsd_rec_new.save()
# Set the port that the webdriver will try to access
self.driver.testserver_port = settings.VARNISH_PORT
# Add the varnish_purge tag
Tag.objects.get_or_create(key='varnish_purge', value='true')
# Set up the correct site
site = Site.objects.get_current()
site.domain = settings.VARNISH_HOST + ":" + str(settings.VARNISH_PORT)
site.save()
def setUp(self):
super(NoVaryOnCookieTest, self).setUp()
# Create a QSD page associated with the program
from esp.qsd.models import QuasiStaticData
from esp.web.models import NavBarCategory
qsd_rec_new = QuasiStaticData()
qsd_rec_new.name = "learn:index"
qsd_rec_new.author = self.admins[0]
qsd_rec_new.nav_category = default_navbarcategory()
qsd_rec_new.content = "This is the content of the test QSD page"
qsd_rec_new.title = "Test QSD page"
qsd_rec_new.description = ""
qsd_rec_new.keywords = ""
qsd_rec_new.save()
def setUp(self):
SeleniumTestCase.setUp(self)
# Make our users
self.admin_user, created = ESPUser.objects.get_or_create(
username='******', first_name='Harry', last_name='Alborez')
self.admin_user.set_password(self.PASSWORD_STRING)
self.admin_user.makeAdmin()
self.qsd_user, created = ESPUser.objects.get_or_create(
username='******', first_name='Aylik', last_name='Kewesd')
self.qsd_user.set_password(self.PASSWORD_STRING)
self.qsd_user.save()
# Check that a NavBarCategory exists
if len(NavBarCategory.objects.all()) < 1:
nbc = NavBarCategory()
nbc.name = 'default'
nbc.save()
# Make our test page
qsd_rec_new = QuasiStaticData()
qsd_rec_new.url = 'test'
qsd_rec_new.name = 'test'
qsd_rec_new.author = self.admin_user
qsd_rec_new.nav_category = default_navbarcategory()
qsd_rec_new.content = ''
qsd_rec_new.title = 'Test page'
qsd_rec_new.description = ''
qsd_rec_new.keywords = ''
qsd_rec_new.save()
# Set the port that the webdriver will try to access
self._old_port = self.driver.testserver_port
self.driver.testserver_port = settings.VARNISH_PORT
# Add the varnish_purge tag
Tag.objects.get_or_create(key='varnish_purge', value='true')
# Set up the correct site
site = Site.objects.get_current()
site.domain = settings.VARNISH_HOST + ":" + str(settings.VARNISH_PORT)
site.save()
def testInlineCorrectness(self):
for user in self.users:
if user is None:
self.client.logout()
else:
self.client.logout()
self.client.login(username=user[0], password=user[1])
# Create an inline QSD
qsd_rec_new = QuasiStaticData()
qsd_rec_new.url = 'learn/bar'
qsd_rec_new.name = "learn:bar"
qsd_rec_new.author = self.author
qsd_rec_new.nav_category = default_navbarcategory()
qsd_rec_new.content = "Inline Testing 123"
qsd_rec_new.title = "Test QSD page"
qsd_rec_new.description = ""
qsd_rec_new.keywords = ""
qsd_rec_new.save()
# Render a template that uses the inline_qsd template tag
template_data = """
{% load render_qsd %}
{% render_inline_qsd "learn/bar" %}
"""
template = Template(template_data)
response_content = template.render(Context({}))
self.assertTrue("Inline Testing 123" in response_content)
# Update the template and check again
qsd_rec_new.content = "Inline Testing 456"
qsd_rec_new.save()
response_content = template.render(Context({}))
self.assertTrue("Inline Testing 456" in response_content)
response_content = template.render(Context({}))
self.assertTrue("Inline Testing 456" in response_content)
# Delete it so we can start again
qsd_rec_new.delete()
def setUp(self):
SeleniumTestCase.setUp(self)
# Make our users
self.admin_user, created = ESPUser.objects.get_or_create(username='******', first_name='Harry', last_name='Alborez')
self.admin_user.set_password(self.PASSWORD_STRING)
self.admin_user.makeAdmin()
self.qsd_user, created = ESPUser.objects.get_or_create(username='******', first_name='Aylik', last_name='Kewesd')
self.qsd_user.set_password(self.PASSWORD_STRING)
self.qsd_user.save()
# Check that a NavBarCategory exists
if len(NavBarCategory.objects.all()) < 1:
nbc = NavBarCategory()
nbc.name = 'default'
nbc.save()
# Make our test page
qsd_rec_new = QuasiStaticData()
qsd_rec_new.url = 'test'
qsd_rec_new.name = 'test'
qsd_rec_new.author = self.admin_user
qsd_rec_new.nav_category = default_navbarcategory()
qsd_rec_new.content = ''
qsd_rec_new.title = 'Test page'
qsd_rec_new.description = ''
qsd_rec_new.keywords = ''
qsd_rec_new.save()
# Set the port that the webdriver will try to access
self._old_port = self.driver.testserver_port
self.driver.testserver_port = settings.VARNISH_PORT
# Add the varnish_purge tag
Tag.objects.get_or_create(key='varnish_purge', value='true')
# Set up the correct site
site = Site.objects.get_current()
site.domain = settings.VARNISH_HOST+":"+str(settings.VARNISH_PORT)
site.save()
def backwards(self, orm):
print "Converting from reversion format to separate-QSD format (this may take a while)..."
# go through each QuasiStaticData, get reversions, and create new objects for each reversion
# then delete the object
qsdObjects = QuasiStaticData.objects.all()
counter = 0
for qsd in qsdObjects:
# reversion.get_for_object will return in descending order by create date
# but we want to create these objects in the reverse order
for qsdRevision in reversed(reversion.get_for_object(qsd)):
if all(k in qsdRevision.field_dict
for k in ('url', 'author', 'content', 'title',
'description', 'nav_category', 'keywords',
'disabled', 'create_date')):
qsdCopy = QuasiStaticData()
qsdCopy.url = qsdRevision.field_dict['url']
qsdCopy.author = ESPUser.objects.get(
id=qsdRevision.field_dict['author'])
qsdCopy.content = qsdRevision.field_dict['content']
qsdCopy.title = qsdRevision.field_dict['title']
qsdCopy.description = qsdRevision.field_dict['description']
qsdCopy.nav_category = NavBarCategory.objects.get(
id=qsdRevision.field_dict['nav_category'])
qsdCopy.keywords = qsdRevision.field_dict['keywords']
qsdCopy.disabled = qsdRevision.field_dict['disabled']
qsdCopy.create_date = qsdRevision.revision.date_created
qsdCopy.save()
qsd.delete()
counter += 1
if counter % 50 == 0:
print "... " + str(counter) + "/" + str(len(qsdObjects))
print "Finished QSD conversion"
def testPageCorrectness(self):
for user in self.users:
if user is None:
self.client.logout()
else:
self.client.logout()
self.client.login(username=user[0], password=user[1])
# Check that QSD with desired URL does not exist
response = self.client.get(self.url)
self.assertEqual(response.status_code, 404)
# Create QSD with desired URL
qsd_rec_new = QuasiStaticData()
qsd_rec_new.url = 'learn/foo'
qsd_rec_new.name = "learn:foo"
qsd_rec_new.author = self.author
qsd_rec_new.nav_category = default_navbarcategory()
qsd_rec_new.content = "Testing 123"
qsd_rec_new.title = "Test QSD page"
qsd_rec_new.description = ""
qsd_rec_new.keywords = ""
qsd_rec_new.save()
# Check that page now exists and has proper content
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTrue('Testing 123' in response.content)
# Edit QSD and check that page content has updated
qsd_rec_new.content = "Testing 456"
qsd_rec_new.save()
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertTrue('Testing 456' in response.content)
# Delete the new QSD so we can start again.
qsd_rec_new.delete()
def render(self, context):
try:
user = self.user_variable.resolve(context) if self.user_variable is not None else None
except template.VariableDoesNotExist:
user = None
try:
program = self.program_variable.resolve(context) if self.program_variable is not None else None
except template.VariableDoesNotExist:
program = None
# Accept literal string url argument if it is quoted; otherwise expect a template variable.
if not self.url.startswith('"'):
url_resolved = template.Variable(self.url).resolve(context)
else:
url_resolved = self.url.strip('"')
if program is not None:
url = QuasiStaticData.prog_qsd_url(program,url_resolved)
else:
url = url_resolved
#probably should have an error message if variable was not None and prog was
edit_bits = Permission.user_can_edit_qsd(user, url)
qsd_obj = QuasiStaticData.objects.get_by_url(url)
if qsd_obj == None:
new_qsd = QuasiStaticData()
new_qsd.url = url
new_qsd.title = url
new_qsd.content = self.nodelist.render(context)
if getattr(user, 'id', False):
new_qsd.author = user
new_qsd.save()
qsd_obj = new_qsd
return render_to_response("inclusion/qsd/render_qsd_inline.html", {'qsdrec': qsd_obj, 'edit_bits': edit_bits}, context_instance=context).content
def qsd(request, branch, name, section, action):
READ_VERB = 'V/Flags/Public'
EDIT_VERB = 'V/Administer/Edit/QSD'
if action == 'read':
base_url = request.path[:-5]
else:
base_url = request.path[:(-len(action) - 6)]
# Detect edit authorizations
have_read = True
if not have_read and action == 'read':
raise Http403, "You do not have permission to access this page."
# Fetch the QSD object
try:
qsd_rec = QuasiStaticData.objects.get_by_path__name(branch, name)
if qsd_rec == None:
raise QuasiStaticData.DoesNotExist
if qsd_rec.disabled:
raise QuasiStaticData.DoesNotExist
except QuasiStaticData.DoesNotExist:
have_edit = UserBit.UserHasPerms(request.user, branch, EDIT_VERB)
if have_edit:
if action in (
'edit',
'create',
):
qsd_rec = QuasiStaticData()
qsd_rec.path = branch
qsd_rec.name = name
qsd_rec.nav_category = NavBarCategory.default()
qsd_rec.title = 'New Page'
qsd_rec.content = 'Please insert your text here'
qsd_rec.create_date = datetime.now()
qsd_rec.keywords = ''
qsd_rec.description = ''
action = 'edit'
if (action == 'read'):
edit_link = base_url + '.edit.html'
return render_to_response('qsd/nopage_edit.html',
request, (branch, section),
{'edit_link': edit_link},
use_request_context=False)
else:
if action == 'read':
raise Http404, 'This page does not exist.'
else:
raise Http403, 'Sorry, you can not modify <tt>%s</tt>.' % request.path
if action == 'create':
action = 'edit'
# Detect the standard read verb
if action == 'read':
if not have_read:
raise Http403, 'You do not have permission to read this page.'
# Render response
response = render_to_response(
'qsd/qsd.html',
request,
(branch, section),
{
'title': qsd_rec.title,
'nav_category': qsd_rec.nav_category,
'content': qsd_rec.html(),
'qsdrec': qsd_rec,
'have_edit':
True, ## Edit-ness is determined client-side these days
'edit_url': base_url + ".edit.html"
},
use_request_context=False)
# patch_vary_headers(response, ['Cookie'])
# if have_edit:
# add_never_cache_headers(response)
# patch_cache_control(response, no_cache=True, no_store=True)
# else:
patch_cache_control(response, max_age=3600, public=True)
return response
# Detect POST
if request.POST.has_key('post_edit'):
have_edit = UserBit.UserHasPerms(request.user, branch, EDIT_VERB)
if not have_edit:
raise Http403, "Sorry, you do not have permission to edit this page."
# Arguably, this should retrieve the DB object, use the .copy()
# method, and then update it. Doing it this way saves a DB call
# (and requires me to make fewer changes).
qsd_rec_new = QuasiStaticData()
qsd_rec_new.path = branch
qsd_rec_new.name = name
qsd_rec_new.author = request.user
qsd_rec_new.nav_category = NavBarCategory.objects.get(
id=request.POST['nav_category'])
qsd_rec_new.content = request.POST['content']
qsd_rec_new.title = request.POST['title']
qsd_rec_new.description = request.POST['description']
qsd_rec_new.keywords = request.POST['keywords']
qsd_rec_new.save()
# We should also purge the cache
purge_page(qsd_rec_new.url())
qsd_rec = qsd_rec_new
# If any files were uploaded, save them
for name, file in request.FILES.iteritems():
m = Media()
# Strip "media/" from FILE, and strip the file name; just return the path
path = dirname(name[9:])
if path == '':
m.anchor = qsd_rec.path
else:
m.anchor = GetNode('Q/' + dirname(name))
# Do we want a better/manual mechanism for setting friendly_name?
m.friendly_name = basename(name)
m.format = ''
local_filename = name
if name[:9] == 'qsdmedia/':
local_filename = name[9:]
m.handle_file(file, local_filename)
m.save()
# Detect the edit verb
if action == 'edit':
have_edit = UserBit.UserHasPerms(request.user, branch, EDIT_VERB)
# Enforce authorizations (FIXME: SHOW A REAL ERROR!)
if not have_edit:
raise ESPError(
False), "You don't have permission to edit this page."
m = ESPMarkdown(qsd_rec.content, media={})
m.toString()
# assert False, m.BrokenLinks()
# Render an edit form
return render_to_response(
'qsd/qsd_edit.html',
request, (branch, section), {
'title': qsd_rec.title,
'content': qsd_rec.content,
'keywords': qsd_rec.keywords,
'description': qsd_rec.description,
'nav_category': qsd_rec.nav_category,
'nav_categories': NavBarCategory.objects.all(),
'qsdrec': qsd_rec,
'qsd': True,
'missing_files': m.BrokenLinks(),
'target_url': base_url.split("/")[-1] + ".edit.html",
'return_to_view': base_url.split("/")[-1] + ".html"
},
use_request_context=False)
# Operation Complete!
raise Http404('Unexpected QSD operation')
