def test_phase_1(self):
#There's a tag that affects phase 1 so we put the tests into a function
#and call it twice here
Tag.setTag('ask_about_duplicate_accounts', value='true')
self.phase_1()
Tag.setTag('ask_about_duplicate_accounts', value='false')
self.phase_1()
def test_grade_range_popup(self):
# Login the teacher
self.failUnless(
self.client.login(username=self.teacher.username,
password='******'),
"Couldn't log in as teacher %s" % self.teacher.username)
# Try editing the class
response = self.client.get('%smakeaclass' %
self.program.get_teach_url())
self.failUnless("check_grade_range" in response.content)
# Add a tag that specifically removes this functionality
Tag.setTag('grade_range_popup', self.program, 'False')
# Try editing the class
response = self.client.get('%smakeaclass' %
self.program.get_teach_url())
self.failUnless(not "check_grade_range" in response.content)
# Change the grade range of the program and reset the tag
self.program.grade_min = 7
self.program.grade_max = 8
self.program.save()
Tag.setTag('grade_range_popup', self.program, 'True')
# Try editing the class
response = self.client.get('%smakeaclass' %
self.program.get_teach_url())
self.failUnless(not "check_grade_range" in response.content)
def test_phase_1(self):
#There's a tag that affects phase 1 so we put the tests into a function
#and call it twice here
Tag.setTag('ask_about_duplicate_accounts',value='true')
self.phase_1()
Tag.setTag('ask_about_duplicate_accounts',value='false')
self.phase_1()
def testTagGetSet(self):
"""
Test that the get and set methods for tags, work.
Note that at this time, I assume that GenericForeignKeys work
and are invoked correctly on this class.
"""
# Dump any existing Tag cache
Tag._getTag.delete_all()
self.assertFalse(bool(Tag.getTag("test")), "Retrieved a tag for key 'test' but we haven't set one yet!")
self.assertFalse(Tag.getTag("test"), "getTag() created a retrievable value for key 'test'!")
self.assertEqual(Tag.getTag("test",default="the default"),"the default")
self.assertEqual(Tag.getTag("test",default="the default"),"the default")
Tag.setTag("test", value="frobbed")
self.assertEqual(Tag.getTag("test"), "frobbed", "Failed to set tag 'test' to value 'frobbed'!")
self.assertEqual(Tag.getTag("test"), "frobbed", "Tag was created, but didn't stick!")
self.assertEqual(Tag.getTag("test",default="the default"), "frobbed", "Defaulting is borked!")
self.assertEqual(Tag.getTag("test",default="the default"), "frobbed", "Defaulting is borked!")
Tag.unSetTag("test")
self.assertFalse(Tag.getTag("test"), "Retrieved a tag for key 'test' but we just deleted it!")
self.assertFalse(Tag.getTag("test"), "unSetTag() deletes don't appear to be persistent!")
self.assertEqual(Tag.getTag("test",default="the default"),"the default")
self.assertEqual(Tag.getTag("test",default="the default"),"the default")
Tag.setTag("test")
self.assertTrue(Tag.getTag("test"), "Error: Setting a tag with an unspecified value must yield a tag whose value evaluates to True!")
self.assertNotEqual(Tag.getTag("test",default="the default"),"the default","If the tag is set, even to EMPTY_TAG, we shouldn't return the default.")
def testBooleanTag(self):
'''Test the logic of getBooleanTag in a bunch of different conditions, assuming that the underlying getProgramTag works.'''
# Dump any existing Tag cache
Tag._getTag.delete_all()
self.assertFalse(Tag.getBooleanTag("test_bool"))
self.assertFalse(Tag.getBooleanTag("test_bool"))
self.assertFalse(Tag.getBooleanTag("test_bool", program=None))
self.assertFalse(Tag.getBooleanTag("test_bool", program=None))
self.assertFalse(Tag.getBooleanTag("test_bool", program=self.program))
self.assertFalse(Tag.getBooleanTag("test_bool", program=self.program))
for b in [True, False]:
self.assertEqual(Tag.getBooleanTag("test_bool", default=b), b)
self.assertEqual(Tag.getBooleanTag("test_bool", default=b), b)
self.assertEqual(
Tag.getBooleanTag("test_bool", program=None, default=b), b)
self.assertEqual(
Tag.getBooleanTag("test_bool", program=None, default=b), b)
self.assertEqual(
Tag.getBooleanTag("test_bool", program=self.program,
default=b), b)
self.assertEqual(
Tag.getBooleanTag("test_bool", program=self.program,
default=b), b)
for true_val in [True, "True", "true", "1", 1]:
Tag.setTag("test_bool", target=self.program, value=true_val)
self.assertEqual(
Tag.getBooleanTag("test_bool", program=self.program), True)
self.assertEqual(
Tag.getBooleanTag("test_bool", program=self.program), True)
for b in [True, False]:
self.assertEqual(
Tag.getBooleanTag("test_bool",
program=self.program,
default=b), True)
self.assertEqual(
Tag.getBooleanTag("test_bool",
program=self.program,
default=b), True)
for false_val in [False, "False", "false", "0", 0]:
Tag.setTag("test_bool", target=self.program, value=false_val)
self.assertEqual(
Tag.getBooleanTag("test_bool", program=self.program), False)
self.assertEqual(
Tag.getBooleanTag("test_bool", program=self.program), False)
for b in [True, False]:
self.assertEqual(
Tag.getBooleanTag("test_bool",
program=self.program,
default=b), False)
self.assertEqual(
Tag.getBooleanTag("test_bool",
program=self.program,
default=b), False)
def set_template_settings(self, data):
# Merge with the existing settings so you don't forget anything
initial_data = self.get_template_settings()
initial_data.update(data)
now = datetime.datetime.now()
mtime = {'year': now.year, 'month': now.month, 'day': now.day,
'hour': now.hour, 'minute': now.minute,
'second': now.second, 'microsecond': now.microsecond}
initial_data.update({'mtime': mtime})
Tag.setTag('theme_template_control', value=json.dumps(initial_data))
def customize_theme(self, vars):
if themes_settings.THEME_DEBUG: print 'Customizing theme with variables: %s' % vars
self.compile_css(self.get_current_theme(), vars, self.css_filename)
vars_available = self.find_less_variables(self.get_current_theme(), flat=True)
vars_diff = {}
for key in vars:
if key in vars_available and len(vars[key].strip()) > 0 and vars[key] != vars_available[key]:
if themes_settings.THEME_DEBUG: print 'Customizing: %s -> %s' % (key, vars[key])
vars_diff[key] = vars[key]
if themes_settings.THEME_DEBUG: print 'Customized %d variables for theme %s' % (len(vars_diff), self.get_current_theme())
Tag.setTag('current_theme_params', value=json.dumps(vars_diff))
def testTagGetSet(self):
"""
Test that the get and set methods for tags, work.
Note that at this time, I assume that GenericForeignKeys work
and are invoked correctly on this class.
"""
# Dump any existing Tag cache
Tag._getTag.delete_all()
self.assertFalse(
bool(Tag.getTag("test")),
"Retrieved a tag for key 'test' but we haven't set one yet!")
self.assertFalse(
Tag.getTag("test"),
"getTag() created a retrievable value for key 'test'!")
self.assertEqual(Tag.getTag("test", default="the default"),
"the default")
self.assertEqual(Tag.getTag("test", default="the default"),
"the default")
Tag.setTag("test", value="frobbed")
self.assertEqual(Tag.getTag("test"), "frobbed",
"Failed to set tag 'test' to value 'frobbed'!")
self.assertEqual(Tag.getTag("test"), "frobbed",
"Tag was created, but didn't stick!")
self.assertEqual(Tag.getTag("test", default="the default"), "frobbed",
"Defaulting is borked!")
self.assertEqual(Tag.getTag("test", default="the default"), "frobbed",
"Defaulting is borked!")
Tag.unSetTag("test")
self.assertFalse(
Tag.getTag("test"),
"Retrieved a tag for key 'test' but we just deleted it!")
self.assertFalse(Tag.getTag("test"),
"unSetTag() deletes don't appear to be persistent!")
self.assertEqual(Tag.getTag("test", default="the default"),
"the default")
self.assertEqual(Tag.getTag("test", default="the default"),
"the default")
Tag.setTag("test")
self.assertTrue(
Tag.getTag("test"),
"Error: Setting a tag with an unspecified value must yield a tag whose value evaluates to True!"
)
self.assertNotEqual(
Tag.getTag("test", default="the default"), "the default",
"If the tag is set, even to EMPTY_TAG, we shouldn't return the default."
)
def customize_theme(self, vars):
logger.debug('Customizing theme with variables: %s', vars)
self.compile_css(self.get_current_theme(), vars, self.css_filename)
vars_available = self.find_less_variables(self.get_current_theme(), flat=True)
vars_diff = {}
for key in vars:
if key in vars_available and len(vars[key].strip()) > 0 and vars[key] != vars_available[key]:
logger.debug('Customizing: %s -> %s', key, vars[key])
vars_diff[key] = vars[key]
logger.debug('Customized %d variables for theme %s', len(vars_diff), self.get_current_theme())
Tag.setTag('current_theme_params', value=json.dumps(vars_diff))
# Clear the Varnish cache
varnish.purge_all()
def testTagGetSet(self):
"""
Test that the get and set methods for tags, work.
Note that at this time, I assume that GenericForeignKeys and the caching API
work as specified, and are invoked correctly on this class.
"""
# Dump any existing Tag cache
Tag.getTag.delete_all()
self.failIf(bool(Tag.getTag("test")), "Retrieved a tag for key 'test' but we haven't set one yet!")
self.failIf(Tag.getTag("test"), "getTag() created a retrievable value for key 'test'!")
Tag.setTag("test", value="frobbed")
self.assertEqual(Tag.getTag("test"), "frobbed", "Failed to set tag 'test' to value 'frobbed'!")
self.assertEqual(Tag.getTag("test"), "frobbed", "Tag was created, but didn't stick!")
Tag.unSetTag("test")
self.failIf(Tag.getTag("test"), "Retrieved a tag for key 'test' but we just deleted it!")
self.failIf(Tag.getTag("test"), "unSetTag() deletes don't appear to be persistent!")
Tag.setTag("test")
self.failUnless(Tag.getTag("test"), "Error: Setting a tag with an unspecified value must yield a tag whose value evaluates to True!")
user, created = User.objects.get_or_create(username="******", email="*****@*****.**", password="")
self.failIf(Tag.getTag("test", user), "Retrieved a tag for key 'test' target '%s', but we haven't set one yet!" % (user))
Tag.setTag("test", user, "frobbed again")
self.assertEqual(Tag.getTag("test", user), "frobbed again")
Tag.setTag("test", user)
self.assertEqual(Tag.getTag("test", user), Tag.EMPTY_TAG)
Tag.unSetTag("test", user)
self.failIf(Tag.getTag("test", user), "unSetTag() didn't work for per-row tags!")
def load_theme(self, theme_name, **kwargs):
# Create template overrides using data provided (our models handle versioning)
logger.debug('Loading theme: %s', theme_name)
for template_name in self.get_template_names(theme_name):
# Read default template override contents provided by theme
to = TemplateOverride(name=template_name)
template_filename = os.path.join(self.base_dir(theme_name),
'templates', template_name)
template_file = open(template_filename, 'r')
to.content = template_file.read()
# Add a Django template comment tag indicating theme type to the main.html override (for tests)
if to.name == 'main.html':
to.content += (
'\n{%% comment %%} Theme: %s {%% endcomment %%}\n' %
theme_name)
to.save()
logger.debug('-- Created template override: %s', template_name)
# Clear template override cache
TemplateOverrideLoader.get_template_hash.delete_all()
# Collect LESS files from appropriate sources and compile CSS
self.compile_css(theme_name, {}, self.css_filename)
# Copy images and script files to the active theme directory
img_src_dir = os.path.join(self.base_dir(theme_name), 'images')
if os.path.exists(img_src_dir):
img_dest_dir = os.path.join(settings.MEDIA_ROOT, 'images', 'theme')
distutils.dir_util.copy_tree(img_src_dir, img_dest_dir)
script_src_dir = os.path.join(self.base_dir(theme_name), 'scripts')
if os.path.exists(script_src_dir):
script_dest_dir = os.path.join(settings.MEDIA_ROOT, 'scripts',
'theme')
distutils.dir_util.copy_tree(script_src_dir, script_dest_dir)
# If files need to be restored, copy them back to the desired locations.
if kwargs.get('backup_info', None) is not None:
self.restore_files(settings.MEDIA_ROOT, kwargs['backup_info'])
Tag.setTag('current_theme_name', value=theme_name)
Tag.setTag('current_theme_params', value='{}')
Tag.unSetTag('current_theme_palette')
self.unset_current_customization()
# Clear the Varnish cache
varnish.purge_all()
def lottery(self, prog, role):
# Run lottery algorithm.
# Get grade caps
grade_caps_str = prog.grade_caps()
grade_caps = {
int(key[0]): value
for key, value in grade_caps_str.iteritems()
}
#Get lottery records and randomize them
records = PhaseZeroRecord.objects.filter(program=prog).order_by('?')
###############################################################################
# The lottery algorithm is run, with randomization and processing in order.
# If any one in the group doesn't get in (due to cap size), no one in that group gets in.
counts = {key: 0 for key in grade_caps}
winners, _ = Group.objects.get_or_create(name=role)
for i in records:
sibs = i.user.all()
newcounts = copy.copy(counts)
for j in sibs:
newcounts[j.getGrade(prog)] += 1
cpass = not any(newcounts[c] > grade_caps[c] for c in counts)
if cpass:
winners.user_set.add(*sibs)
counts = newcounts
###############################################################################
# Post lottery, assign permissions to people in the lottery winners group
# Assign OverridePhaseZero permission and Student/All permissions
override_perm = Permission(permission_type='OverridePhaseZero',
role=winners,
start_date=datetime.datetime.now(),
program=prog)
studentAll_perm = Permission(permission_type='Student/All',
role=winners,
start_date=datetime.datetime.now(),
program=prog)
override_perm.save()
studentAll_perm.save()
# Add tag to indicate student lottery has been run
Tag.setTag('student_lottery_run', target=prog, value='True')
return True
def testTagWithTarget(self):
'''Test getting and setting of tags with targets.'''
# Delete any existing tags that might interfere
Tag.objects.filter(key="test").delete()
# Dump any existing Tag cache
Tag._getTag.delete_all()
user, created = User.objects.get_or_create(username="******", email="*****@*****.**", password="")
self.assertFalse(Tag.getTag("test", user), "Retrieved a tag for key 'test' target '%s', but we haven't set one yet!" % (user))
Tag.setTag("test", user, "frobbed again")
self.assertEqual(Tag.getTag("test", user), "frobbed again")
Tag.setTag("test", user)
self.assertEqual(Tag.getTag("test", user), Tag.EMPTY_TAG)
Tag.unSetTag("test", user)
self.assertFalse(Tag.getTag("test", user), "unSetTag() didn't work for per-row tags!")
def setVisibleRegistrationTypeNames(cls, display_names, prog):
if not (prog and isinstance(prog, (Program, int))):
return False
if isinstance(prog, int):
try:
prog = Program.objects.get(pk=prog)
except Exception:
return False
try:
if "All" in display_names:
display_names = cls.default_names + ["All"]
Tag.setTag(key=cls.key,
target=prog,
value=simplejson.dumps(display_names))
return True
except Exception:
return False
def load_theme(self, theme_name, **kwargs):
# Create template overrides using data provided (our models handle versioning)
if themes_settings.THEME_DEBUG: print 'Loading theme: %s' % theme_name
for template_name in self.get_template_names(theme_name):
# Read default template override contents provided by theme
to = TemplateOverride(name=template_name)
template_filename = os.path.join(self.base_dir(theme_name),
'templates', template_name)
template_file = open(template_filename, 'r')
to.content = template_file.read()
# Add a Django template comment tag indicating theme type to the main.html override (for tests)
if to.name == 'main.html':
to.content += (
'\n{%% comment %%} Theme: %s {%% endcomment %%}\n' %
theme_name)
# print 'Template override %s contents: \n%s' % (to.name, to.content)
to.save()
if themes_settings.THEME_DEBUG:
print '-- Created template override: %s' % template_name
# Clear template override cache
TemplateOverrideLoader.get_template_hash.delete_all()
# Collect LESS files from appropriate sources and compile CSS
self.compile_css(theme_name, {}, self.css_filename)
# Copy images and script files to the active theme directory
img_src_dir = os.path.join(self.base_dir(theme_name), 'images')
if os.path.exists(img_src_dir):
img_dest_dir = os.path.join(settings.MEDIA_ROOT, 'images', 'theme')
distutils.dir_util.copy_tree(img_src_dir, img_dest_dir)
script_src_dir = os.path.join(self.base_dir(theme_name), 'scripts')
if os.path.exists(script_src_dir):
script_dest_dir = os.path.join(settings.MEDIA_ROOT, 'scripts',
'theme')
distutils.dir_util.copy_tree(script_src_dir, script_dest_dir)
Tag.setTag('current_theme_name', value=theme_name)
Tag.setTag('current_theme_params', value='{}')
Tag.unSetTag('current_theme_palette')
self.unset_current_customization()
def testTagWithTarget(self):
'''Test getting and setting of tags with targets.'''
# Delete any existing tags that might interfere
Tag.objects.filter(key="test").delete()
# Dump any existing Tag cache
Tag._getTag.delete_all()
user, created = User.objects.get_or_create(username="******",
email="*****@*****.**",
password="")
self.assertFalse(
Tag.getTag("test", user),
"Retrieved a tag for key 'test' target '%s', but we haven't set one yet!"
% (user))
Tag.setTag("test", user, "frobbed again")
self.assertEqual(Tag.getTag("test", user), "frobbed again")
Tag.setTag("test", user)
self.assertEqual(Tag.getTag("test", user), Tag.EMPTY_TAG)
Tag.unSetTag("test", user)
self.assertFalse(Tag.getTag("test", user),
"unSetTag() didn't work for per-row tags!")
def testBooleanTag(self):
'''Test the logic of getBooleanTag in a bunch of different conditions, assuming that the underlying getProgramTag works.'''
# Dump any existing Tag cache
Tag._getTag.delete_all()
self.assertFalse(Tag.getBooleanTag("test_bool"))
self.assertFalse(Tag.getBooleanTag("test_bool"))
self.assertFalse(Tag.getBooleanTag("test_bool", program=None))
self.assertFalse(Tag.getBooleanTag("test_bool", program=None))
self.assertFalse(Tag.getBooleanTag("test_bool", program=self.program))
self.assertFalse(Tag.getBooleanTag("test_bool", program=self.program))
for b in [True,False]:
self.assertEqual(Tag.getBooleanTag("test_bool",default=b),b)
self.assertEqual(Tag.getBooleanTag("test_bool",default=b),b)
self.assertEqual(Tag.getBooleanTag("test_bool",program=None,default=b),b)
self.assertEqual(Tag.getBooleanTag("test_bool",program=None,default=b),b)
self.assertEqual(Tag.getBooleanTag("test_bool",program=self.program,default=b),b)
self.assertEqual(Tag.getBooleanTag("test_bool",program=self.program,default=b),b)
for true_val in [True,"True","true","1",1]:
Tag.setTag("test_bool",target=self.program,value=true_val)
self.assertEqual(Tag.getBooleanTag("test_bool", program=self.program), True)
self.assertEqual(Tag.getBooleanTag("test_bool", program=self.program), True)
for b in [True,False]:
self.assertEqual(Tag.getBooleanTag("test_bool", program=self.program, default=b), True)
self.assertEqual(Tag.getBooleanTag("test_bool", program=self.program, default=b), True)
for false_val in [False,"False","false","0",0]:
Tag.setTag("test_bool",target=self.program,value=false_val)
self.assertEqual(Tag.getBooleanTag("test_bool", program=self.program), False)
self.assertEqual(Tag.getBooleanTag("test_bool", program=self.program), False)
for b in [True,False]:
self.assertEqual(Tag.getBooleanTag("test_bool", program=self.program, default=b), False)
self.assertEqual(Tag.getBooleanTag("test_bool", program=self.program, default=b), False)
def test_grade_range_popup(self):
# Login the teacher
self.assertTrue(self.client.login(username=self.teacher.username, password='******'), "Couldn't log in as teacher %s" % self.teacher.username)
# Try editing the class
response = self.client.get('%smakeaclass' % self.program.get_teach_url())
self.assertTrue("grade_range_popup" in response.content)
# Add a tag that specifically removes this functionality
Tag.setTag('grade_range_popup', self.program, 'False')
# Try editing the class
response = self.client.get('%smakeaclass' % self.program.get_teach_url())
self.assertTrue(not "grade_range_popup" in response.content)
# Change the grade range of the program and reset the tag
self.program.grade_min = 7
self.program.grade_max = 8
self.program.save()
Tag.setTag('grade_range_popup', self.program, 'True')
# Try editing the class
response = self.client.get('%smakeaclass' % self.program.get_teach_url())
self.assertTrue(not "check_grade_range" in response.content)
def test_phase_2(self):
#similarly to phase_1, call helper function twice with tag settings
Tag.setTag('require_email_validation', value='True')
self.phase_2()
Tag.setTag('require_email_validation', value='False')
self.phase_2()
def set_current_customization(self, theme_name):
Tag.setTag('prev_theme_customization', value=theme_name)
def set_palette(self, palette):
Tag.setTag('current_theme_palette', value=json.dumps(palette))
def testTagCaching(self):
'''Test that tag values are being cached.'''
# Delete any existing tags that might interfere
Tag.objects.filter(key="test").delete()
# Dump any existing Tag cache
Tag._getTag.delete_all()
user1, created = User.objects.get_or_create(username="******", email="*****@*****.**", password="")
user2, created = User.objects.get_or_create(username="******", email="*****@*****.**", password="")
for target in [None,user1,user2]:
self.assertFalse(Tag.getTag("test",target=target))
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test",target=target))
self.assertFalse(Tag.getTag("test",target=target))
Tag.setTag("test",value="tag value")
for target in [user1,user2]:
self.assertFalse(Tag.getTag("test",target=target)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test",target=target))
self.assertFalse(Tag.getTag("test",target=target))
self.assertEqual(Tag.getTag("test"),"tag value")
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test"),"tag value")
self.assertEqual(Tag.getTag("test"),"tag value")
for target in [user1,user2]:
self.assertFalse(Tag.getTag("test",target=target)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test",target=target))
self.assertFalse(Tag.getTag("test",target=target))
Tag.setTag("test",value="tag value 2")
for target in [user1,user2]:
self.assertFalse(Tag.getTag("test",target=target)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test",target=target))
self.assertFalse(Tag.getTag("test",target=target))
self.assertEqual(Tag.getTag("test"),"tag value 2")
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test"),"tag value 2")
self.assertEqual(Tag.getTag("test"),"tag value 2")
for target in [user1,user2]:
self.assertFalse(Tag.getTag("test",target=target)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test",target=target))
self.assertFalse(Tag.getTag("test",target=target))
Tag.setTag("test",target=user1,value="tag value user1")
self.assertFalse(Tag.getTag("test",target=user2)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test",target=user2))
self.assertFalse(Tag.getTag("test",target=user2))
self.assertEqual(Tag.getTag("test"),"tag value 2") #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test"),"tag value 2")
self.assertEqual(Tag.getTag("test"),"tag value 2")
self.assertEqual(Tag.getTag("test",target=user1),"tag value user1")
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test",target=user1),"tag value user1")
self.assertEqual(Tag.getTag("test",target=user1),"tag value user1")
self.assertEqual(Tag.getTag("test"),"tag value 2") #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test"),"tag value 2")
self.assertEqual(Tag.getTag("test"),"tag value 2")
self.assertFalse(Tag.getTag("test",target=user2)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test",target=user2))
self.assertFalse(Tag.getTag("test",target=user2))
Tag.unSetTag("test")
self.assertEqual(Tag.getTag("test",target=user1),"tag value user1") #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test",target=user1),"tag value user1")
self.assertEqual(Tag.getTag("test",target=user1),"tag value user1")
self.assertFalse(Tag.getTag("test",target=user2)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test",target=user2))
self.assertFalse(Tag.getTag("test",target=user2))
self.assertFalse(Tag.getTag("test"))
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test"))
self.assertFalse(Tag.getTag("test"))
self.assertEqual(Tag.getTag("test",target=user1),"tag value user1") #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test",target=user1),"tag value user1")
self.assertEqual(Tag.getTag("test",target=user1),"tag value user1")
self.assertFalse(Tag.getTag("test",target=user2)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test",target=user2))
self.assertFalse(Tag.getTag("test",target=user2))
def test_phase_2(self):
#similarly to phase_1, call helper function twice with tag settings
Tag.setTag('require_email_validation',value='True')
self.phase_2()
Tag.setTag('require_email_validation',value='False')
self.phase_2()
def editor(request):
tc = ThemeController()
if request.method == 'POST':
# Handle form submission
vars = None
palette = None
if 'save' in request.POST:
if request.POST['saveThemeName'] == '':
theme_name = Tag.getTag('prev_theme_customization',
default='None')
if theme_name == 'None':
# Generate a temporary theme name
random_slug = ''.join(
random.choice(string.lowercase) for i in range(4))
theme_name = 'theme-%s-%s' % (
datetime.now().strftime('%Y%m%d'), random_slug)
else:
theme_name = request.POST['saveThemeName']
vars = request.POST.dict()
palette = request.POST.getlist('palette')
tc.save_customizations(theme_name, vars=vars, palette=palette)
Tag.setTag('prev_theme_customization', value=theme_name)
elif 'load' in request.POST:
(vars,
palette) = tc.load_customizations(request.POST['loadThemeName'])
Tag.setTag('prev_theme_customization',
value=request.POST['loadThemeName'])
elif 'delete' in request.POST:
tc.delete_customizations(request.POST['loadThemeName'])
elif 'apply' in request.POST:
vars = request.POST.dict()
palette = request.POST.getlist('palette')
# Re-generate the CSS for the current theme given the supplied settings
if vars:
tc.customize_theme(vars)
if palette:
tc.set_palette(palette)
# Get current theme and customization settings
current_theme = tc.get_current_theme()
context = tc.find_less_variables(flat=True)
context.update(tc.get_current_params())
context['palette'] = tc.get_palette()
# Get list of available customizations
context['available_themes'] = tc.get_customization_names()
context['last_used_setting'] = Tag.getTag('prev_theme_customization',
default='None')
# Load a bunch of preset fonts
context['sans_fonts'] = sorted(
themes_settings.sans_serif_fonts.iteritems())
# Load the theme-specific options
adv_vars = tc.find_less_variables(current_theme, theme_only=True)
context['adv_vars'] = {}
for filename in adv_vars:
category_name = os.path.basename(filename)[:-5]
category_vars = {}
for key in adv_vars[filename]:
# Detect type of variable based on default value
initial_val = adv_vars[filename][key]
if key in context:
initial_val = context[key]
if initial_val.startswith('#'):
category_vars[key] = ('color', initial_val)
elif initial_val.endswith('px') or initial_val.endswith('em'):
category_vars[key] = ('length', initial_val)
else:
category_vars[key] = ('text', initial_val)
context['adv_vars'][category_name] = category_vars
return render_to_response('themes/editor.html', request, context)
def set_template_settings(self, data):
# Merge with the existing settings so you don't forget anything
initial_data = self.get_template_settings()
initial_data.update(data)
Tag.setTag('theme_template_control', value=json.dumps(initial_data))
def testProgramTag(self):
'''Test the logic of getProgramTag in a bunch of different conditions.'''
# Delete any existing tags that might interfere
Tag.objects.filter(key="test").delete()
# Dump any existing Tag cache
Tag._getTag.delete_all()
#Caching is hard, so what the hell, let's run every assertion twice.
self.assertFalse(Tag.getProgramTag("test", program=self.program))
self.assertFalse(Tag.getProgramTag("test", program=self.program))
self.assertFalse(Tag.getProgramTag("test", program=None))
self.assertFalse(Tag.getProgramTag("test", program=None))
self.assertEqual(
Tag.getProgramTag("test",
program=self.program,
default="the default"), "the default")
self.assertEqual(
Tag.getProgramTag("test",
program=self.program,
default="the default"), "the default")
self.assertEqual(
Tag.getProgramTag("test", program=None, default="the default"),
"the default")
self.assertEqual(
Tag.getProgramTag("test", program=None, default="the default"),
"the default")
# Set the program-specific tag
Tag.setTag("test", target=self.program, value="program tag value")
self.assertFalse(Tag.getProgramTag("test", program=None))
self.assertFalse(Tag.getProgramTag("test", program=None))
self.assertEqual(
Tag.getProgramTag("test", program=None, default="the default"),
"the default")
self.assertEqual(
Tag.getProgramTag("test", program=None, default="the default"),
"the default")
self.assertEqual(Tag.getProgramTag("test", program=self.program),
"program tag value")
self.assertEqual(Tag.getProgramTag("test", program=self.program),
"program tag value")
self.assertEqual(
Tag.getProgramTag("test",
program=self.program,
default="the default"), "program tag value")
self.assertEqual(
Tag.getProgramTag("test",
program=self.program,
default="the default"), "program tag value")
# Now set the general tag
Tag.setTag("test", target=None, value="general tag value")
self.assertEqual(Tag.getProgramTag("test", program=None),
"general tag value")
self.assertEqual(Tag.getProgramTag("test", program=None),
"general tag value")
self.assertEqual(
Tag.getProgramTag("test", program=None, default="the default"),
"general tag value")
self.assertEqual(
Tag.getProgramTag("test", program=None, default="the default"),
"general tag value")
self.assertEqual(Tag.getProgramTag("test", program=self.program),
"program tag value")
self.assertEqual(Tag.getProgramTag("test", program=self.program),
"program tag value")
self.assertEqual(
Tag.getProgramTag("test",
program=self.program,
default="the default"), "program tag value")
self.assertEqual(
Tag.getProgramTag("test",
program=self.program,
default="the default"), "program tag value")
# Now unset the program-specific tag
Tag.unSetTag("test", target=self.program)
self.assertEqual(Tag.getProgramTag("test", program=None),
"general tag value")
self.assertEqual(Tag.getProgramTag("test", program=None),
"general tag value")
self.assertEqual(
Tag.getProgramTag("test", program=None, default="the default"),
"general tag value")
self.assertEqual(
Tag.getProgramTag("test", program=None, default="the default"),
"general tag value")
self.assertEqual(Tag.getProgramTag("test", program=self.program),
"general tag value")
self.assertEqual(Tag.getProgramTag("test", program=self.program),
"general tag value")
self.assertEqual(
Tag.getProgramTag("test",
program=self.program,
default="the default"), "general tag value")
self.assertEqual(
Tag.getProgramTag("test",
program=self.program,
default="the default"), "general tag value")
#just to clean up
Tag.unSetTag("test", target=None)
self.assertFalse(Tag.getProgramTag("test", program=self.program))
self.assertFalse(Tag.getProgramTag("test", program=self.program))
self.assertFalse(Tag.getProgramTag("test", program=None))
self.assertFalse(Tag.getProgramTag("test", program=None))
self.assertEqual(
Tag.getProgramTag("test",
program=self.program,
default="the default"), "the default")
self.assertEqual(
Tag.getProgramTag("test",
program=self.program,
default="the default"), "the default")
self.assertEqual(
Tag.getProgramTag("test", program=None, default="the default"),
"the default")
self.assertEqual(
Tag.getProgramTag("test", program=None, default="the default"),
"the default")
def testTagCaching(self):
'''Test that tag values are being cached.'''
# Delete any existing tags that might interfere
Tag.objects.filter(key="test").delete()
# Dump any existing Tag cache
Tag._getTag.delete_all()
user1, created = User.objects.get_or_create(username="******",
email="*****@*****.**",
password="")
user2, created = User.objects.get_or_create(username="******",
email="*****@*****.**",
password="")
for target in [None, user1, user2]:
self.assertFalse(Tag.getTag("test", target=target))
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test", target=target))
self.assertFalse(Tag.getTag("test", target=target))
Tag.setTag("test", value="tag value")
for target in [user1, user2]:
self.assertFalse(Tag.getTag(
"test", target=target)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test", target=target))
self.assertFalse(Tag.getTag("test", target=target))
self.assertEqual(Tag.getTag("test"), "tag value")
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test"), "tag value")
self.assertEqual(Tag.getTag("test"), "tag value")
for target in [user1, user2]:
self.assertFalse(Tag.getTag(
"test", target=target)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test", target=target))
self.assertFalse(Tag.getTag("test", target=target))
Tag.setTag("test", value="tag value 2")
for target in [user1, user2]:
self.assertFalse(Tag.getTag(
"test", target=target)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test", target=target))
self.assertFalse(Tag.getTag("test", target=target))
self.assertEqual(Tag.getTag("test"), "tag value 2")
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test"), "tag value 2")
self.assertEqual(Tag.getTag("test"), "tag value 2")
for target in [user1, user2]:
self.assertFalse(Tag.getTag(
"test", target=target)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test", target=target))
self.assertFalse(Tag.getTag("test", target=target))
Tag.setTag("test", target=user1, value="tag value user1")
self.assertFalse(Tag.getTag(
"test", target=user2)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test", target=user2))
self.assertFalse(Tag.getTag("test", target=user2))
self.assertEqual(Tag.getTag("test"),
"tag value 2") #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test"), "tag value 2")
self.assertEqual(Tag.getTag("test"), "tag value 2")
self.assertEqual(Tag.getTag("test", target=user1), "tag value user1")
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test", target=user1),
"tag value user1")
self.assertEqual(Tag.getTag("test", target=user1),
"tag value user1")
self.assertEqual(Tag.getTag("test"),
"tag value 2") #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test"), "tag value 2")
self.assertEqual(Tag.getTag("test"), "tag value 2")
self.assertFalse(Tag.getTag(
"test", target=user2)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test", target=user2))
self.assertFalse(Tag.getTag("test", target=user2))
Tag.unSetTag("test")
self.assertEqual(Tag.getTag("test", target=user1),
"tag value user1") #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test", target=user1),
"tag value user1")
self.assertEqual(Tag.getTag("test", target=user1),
"tag value user1")
self.assertFalse(Tag.getTag(
"test", target=user2)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test", target=user2))
self.assertFalse(Tag.getTag("test", target=user2))
self.assertFalse(Tag.getTag("test"))
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test"))
self.assertFalse(Tag.getTag("test"))
self.assertEqual(Tag.getTag("test", target=user1),
"tag value user1") #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertEqual(Tag.getTag("test", target=user1),
"tag value user1")
self.assertEqual(Tag.getTag("test", target=user1),
"tag value user1")
self.assertFalse(Tag.getTag(
"test", target=user2)) #remove after Issue #866 is fixed
with self.assertNumQueries(0):
self.assertFalse(Tag.getTag("test", target=user2))
self.assertFalse(Tag.getTag("test", target=user2))
def testProgramTag(self):
'''Test the logic of getProgramTag in a bunch of different conditions.'''
# Delete any existing tags that might interfere
Tag.objects.filter(key="test").delete()
# Dump any existing Tag cache
Tag._getTag.delete_all()
#Caching is hard, so what the hell, let's run every assertion twice.
self.assertFalse(Tag.getProgramTag("test",program=self.program))
self.assertFalse(Tag.getProgramTag("test",program=self.program))
self.assertFalse(Tag.getProgramTag("test",program=None))
self.assertFalse(Tag.getProgramTag("test",program=None))
self.assertEqual(Tag.getProgramTag("test",program=self.program,default="the default"),"the default")
self.assertEqual(Tag.getProgramTag("test",program=self.program,default="the default"),"the default")
self.assertEqual(Tag.getProgramTag("test",program=None,default="the default"),"the default")
self.assertEqual(Tag.getProgramTag("test",program=None,default="the default"),"the default")
# Set the program-specific tag
Tag.setTag("test",target=self.program,value="program tag value")
self.assertFalse(Tag.getProgramTag("test",program=None))
self.assertFalse(Tag.getProgramTag("test",program=None))
self.assertEqual(Tag.getProgramTag("test",program=None,default="the default"),"the default")
self.assertEqual(Tag.getProgramTag("test",program=None,default="the default"),"the default")
self.assertEqual(Tag.getProgramTag("test",program=self.program),"program tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program),"program tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program,default="the default"),"program tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program,default="the default"),"program tag value")
# Now set the general tag
Tag.setTag("test",target=None,value="general tag value")
self.assertEqual(Tag.getProgramTag("test",program=None),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=None),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=None,default="the default"),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=None,default="the default"),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program),"program tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program),"program tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program,default="the default"),"program tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program,default="the default"),"program tag value")
# Now unset the program-specific tag
Tag.unSetTag("test",target=self.program)
self.assertEqual(Tag.getProgramTag("test",program=None),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=None),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=None,default="the default"),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=None,default="the default"),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program,default="the default"),"general tag value")
self.assertEqual(Tag.getProgramTag("test",program=self.program,default="the default"),"general tag value")
#just to clean up
Tag.unSetTag("test",target=None)
self.assertFalse(Tag.getProgramTag("test",program=self.program))
self.assertFalse(Tag.getProgramTag("test",program=self.program))
self.assertFalse(Tag.getProgramTag("test",program=None))
self.assertFalse(Tag.getProgramTag("test",program=None))
self.assertEqual(Tag.getProgramTag("test",program=self.program,default="the default"),"the default")
self.assertEqual(Tag.getProgramTag("test",program=self.program,default="the default"),"the default")
self.assertEqual(Tag.getProgramTag("test",program=None,default="the default"),"the default")
self.assertEqual(Tag.getProgramTag("test",program=None,default="the default"),"the default")