class UserTestCase(TestCase):
def setUp(self):
self.user = User(username="******")
self.user.save()
self.webuser = Webuser.objects.get(user__username="******")
self.bad_user = User(username="******")
self.bad_user.save()
self.bad_webuser = Webuser.objects.get(user=self.bad_user)
def test_post_create(self):
client = APIClient()
client.force_authenticate(user=self.user)
self.assertTrue(self.user.is_authenticated())
response = client.post('/api/posts/', {'text':"Testing text"})
self.assertEqual(response.status_code, 201)
post = Post.objects.get(owner=self.webuser)
def test_post_access(self):
client = APIClient()
client.force_authenticate(user=self.user)
self.assertTrue(self.user.is_authenticated())
response = client.post('/api/posts/', {'text': "Testing text"})
client.force_authenticate(user=self.bad_user)
response = client.put('/api/posts/%d/' % Post.objects.get(text="Testing text").pk, {'text': "Testing text"})
self.assertEqual(response.status_code, 403)
def myblog(request):
if User.is_authenticated():
print(User['username'])
Posts = post.objects.all()
return render(request, 'myblog.html', {
'posts': Posts,
})
def test_matching_current_session_should_responde_with_success(self):
user = User(username='******', is_staff=True)
user.set_password('password')
user.save()
backend = Backend()
request = self.get_view_handler_request(backend, user, 'hearbeat',
'post', '/admin/hearbeat/')
# log user in
user.backend = 'django.contrib.auth.backends.ModelBackend'
auth_login(request, user)
self.assertTrue(user.is_authenticated())
# create session object and patch request
session_key = '123456789123456789123456789123456789'
session = Session.objects.create(
session_key=session_key,
session_data=Session.objects.encode({'_auth_user_id': user.id}),
expire_date=datetime.datetime.now() + datetime.timedelta(days=1))
request.session._session_key = session_key
# run request and verify that we get successful responde
response = backend.run_handler(request, 'heartbeat')
json = decode_json(response.content)
self.assertEqual({'result': 'Success', 'taskInfo': None}, json)
def test_should_redirects_if_user_is_not_logged_in(self):
request = RequestFactory().get("/")
user = User()
user.is_authenticated = lambda: False
request.user = user
result = IndexView.as_view()(request)
self.assertEqual(302, result.status_code)
def get_anon_user():
try:
anon_user = User.objects.filter(username='******')[0]
except IndexError:
anon_user = User(username='******', email_address='*****@*****.**')
anon_user.save()
get_anonymous_group().add_member(anon_user)
anon_user.is_authenticated = lambda: False
return anon_user
def get_anon_user():
try:
anon_user = User.objects.filter(username="******")[0]
except IndexError:
anon_user = User(username="******", email_address="*****@*****.**")
anon_user.save()
get_anonymous_group().add_member(anon_user)
anon_user.is_authenticated = lambda: False
return anon_user
def is_visible(self, user: User):
""" Checks if specified user van ciew this post. E.g. post is published, of user is staff & so on
:param User user: User to be checked
:return: `True` if `User` can view this post, else `False`
:rtype: bool
"""
return self.publish_dttm <= timezone.now() and not self.hidden \
or (user.is_authenticated() and (user.is_superuser or user.is_staff))
def get_or_create_state(self, user: User) -> str:
state_values = self.pattern
if user.is_authenticated():
try:
state = self.riddlestate
state_values = state.values
except ObjectDoesNotExist:
state = RiddleState(user=user, riddle=self, values=self.pattern)
state.save()
state_values = state.values
return state_values
class DjangoUser(UserInterface):
def __init__(self, userobj = None, **kwargs):
if userobj:
self._underlying = userobj
else:
self._underlying = User(**kwargs)
def underlying(self):
return self._underlying
def is_authenticated(self):
return self._underlying.is_authenticated()
def is_active(self):
return self._underlying.is_active
def is_superuser(self):
return self._underlying.is_superuser
def save(self):
return self._underlying.save()
def login(self, request):
return login(request, self._underlying)
@classmethod
def modelclass(cls):
return User
@classmethod
def create(cls, *args, **kwargs):
return User.objects.create_user(*args, **kwargs)
@classmethod
def create_super(cls, *args, **kwargs):
return User.objects.create_superuser(*args, **kwargs)
@classmethod
def authenticate(cls, *args, **kwargs):
user = authenticate(*args, **kwargs)
if not user:
user = AnonymousUser()
return cls(userobj = user)
@classmethod
def logout(cls, request):
return logout(request)
@classmethod
def get(cls, **kwargs):
return User.objects.get(**kwargs)
def get_or_create_state(self, user: User) -> str:
state_values = self.pattern
if user.is_authenticated():
try:
state = self.riddlestate
state_values = state.values
except ObjectDoesNotExist:
state = RiddleState(user=user,
riddle=self,
values=self.pattern)
state.save()
state_values = state.values
return state_values
def test_login_post(self):
user = User()
user.username = "******"
user.set_password("123456")
user.save()
response = self.client.post("/login",
data={
"username": "******",
"password": "******"
})
self.assertEqual(response.status_code, 200)
user = auth.get_user(self.client)
self.assertEqual(user.is_authenticated(), True)
def test_logout_with_session_should_terminate_session_and_redirect_to_login_page(
self):
backend = Backend()
user = User(username='******', is_staff=True)
user.set_password('password')
user.save()
request, response = self.run_view_handler_request(
backend, user, 'logout', 'get', '/admin/logout')
self.assertTrue(user.is_authenticated())
self.assertIsRedirect(response, reverse('cubane.backend.login'))
self.logout(request)
user.delete()
def login(req):
password_is_wrong=''
if req.method == 'POST':
uf = UserForm(req.POST)
if uf.is_valid(): #是否有效
try:
username = uf.cleaned_data['username']
password = uf.cleaned_data['password']
User = auth.authenticate(username=username,password=password)
if User.is_authenticated():
auth.login(req,User)
req.session['username'] = username
return HttpResponseRedirect('/yunwei/')
except:
password_is_wrong = '用户名或密码错误'
return render_to_response('adminlte/login.html',{'uf':uf,'password_is_wrong':password_is_wrong},context_instance=RequestContext(req))
else:
uf = UserForm()
return render_to_response('adminlte/login.html',{'uf':uf,'password_is_wrong':password_is_wrong},context_instance=RequestContext(req))
def get_users_files(user: User) -> tuple:
"""
Path to user data = /ftp-home/$USER/files
This application will need permissions to read those directories...
:param user: The currently logged in user
:return: A tuple of the files and their paths that the user can move to
the GenomeSpace
"""
if not user.is_authenticated():
# should always be authenticated, but...
return tuple()
path = '/ftp-home/%s/files' % user.get_username()
if not os.path.exists(path):
path = BASE_DIRECTORY
logging.error('User %s does not have a home directory! Using: %s' %
(user.get_username(), path))
# should these be html escaped? Check the form library...
result = []
for root, dirs, files in os.walk(path, topdown=True):
for name in files:
if not name.startswith('.'):
full_path = os.path.join(root, name)
offset_path = full_path[len(path):].lstrip('/')
# could be replaced by {{ value|filesizeformat }} ?
size = human_readable(os.path.getsize(full_path))
# the last time modified is returned. Hopefully this is usable
# here
seconds_old = time.time() - os.path.getmtime(full_path)
# 86400 = 60 / 60 / 24 = seconds / minutes / hours per day
days_to_live = int(DAYS_FILES_LIVE_FOR - (seconds_old / 86400))
days_to_live = days_to_live if days_to_live > 0 else 0
status = FileDescriptor.get_status(full_path)
result.append((full_path, '%s\N{NULL}%s\N{NULL}%s\N{NULL}%s' %
(offset_path, size, status, days_to_live)))
return tuple(result)
def GetUserByDjUser(djUser):
userId = djUser.id if djUser and djUser.is_authenticated() else None
users = User.objects.filter(id=userId).all()
return users[0] if users else None
class TestViews(BaseTest, LiveServerTestCase):
def setUp(self):
self.admin = User(
username="******",
email="*****@*****.**",
is_superuser=True,
is_staff=True)
self.admin.set_password('test')
self.admin.save()
def test_can_build_global_preference_form(self):
# We want to display a form with two global preferences
# RegistrationAllowed and MaxUsers
form = global_preference_form_builder(
preferences=['user__registration_allowed', "user__max_users"])()
self.assertEqual(len(form.fields), 2)
self.assertEqual(
form.fields['user__registration_allowed'].initial, False)
def test_can_build_preference_form_from_sections(self):
form = global_preference_form_builder(section='test')()
self.assertEqual(len(form.fields), 3)
def test_can_build_global_preference_form_from_sections(self):
form = global_preference_form_builder(section='test')()
self.assertEqual(len(form.fields), 3)
def test_global_preference_view_requires_staff_member(self):
url = reverse("dynamic_preferences.global")
response = self.client.get(url, follow=True)
self.assertRedirects(response, "/admin/login/?next=/global/")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertRedirects(response, "/admin/login/?next=/global/")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(self.admin.is_authenticated(), True)
self.assertEqual(response.status_code, 200)
def test_global_preference_view_display_form(self):
url = reverse("dynamic_preferences.global")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(len(response.context['form'].fields), 9)
self.assertEqual(
response.context['registry'], registry)
def test_formview_includes_section_in_context(self):
url = reverse(
"dynamic_preferences.global.section", kwargs={"section": 'user'})
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(
response.context['section'], registry.section_objects['user'])
def test_formview_with_bad_section_returns_404(self):
url = reverse(
"dynamic_preferences.global.section", kwargs={"section": 'nope'})
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
def test_global_preference_filters_by_section(self):
self.client.login(username='******', password="******")
url = reverse(
"dynamic_preferences.global.section", kwargs={"section": 'user'})
response = self.client.get(url)
self.assertEqual(len(response.context['form'].fields), 3)
def test_preference_are_updated_on_form_submission(self):
blog_entry = BlogEntry.objects.create(title='test', content='test')
self.client.login(username='******', password="******")
url = reverse("dynamic_preferences.global")
data = {
'user__max_users': 67,
'user__registration_allowed': True,
"user__items_per_page": 12,
'test__TestGlobal1': 'new value',
'test__TestGlobal2': True,
'test__TestGlobal3': True,
'no_section': True,
'blog__featured_entry': blog_entry.pk,
'blog__logo': None,
}
response = self.client.post(url, data)
for key, expected_value in data.items():
try:
section, name = key.split('__')
except ValueError:
section, name = (None, key)
p = GlobalPreferenceModel.objects.get(name=name, section=section)
if name == 'featured_entry':
expected_value = blog_entry
self.assertEqual(p.value, expected_value)
def test_preference_are_updated_on_form_submission_by_section(self):
self.client.login(username='******', password="******")
url = reverse(
"dynamic_preferences.global.section", kwargs={"section": 'user'})
response = self.client.post(
url,
{'user__max_users': 95,
'user__registration_allowed': True,
'user__items_per_page': 12})
self.assertEqual(GlobalPreferenceModel.objects.get(
section="user", name="max_users").value, 95)
self.assertEqual(GlobalPreferenceModel.objects.get(
section="user", name="registration_allowed").value, True)
self.assertEqual(GlobalPreferenceModel.objects.get(
section="user", name="items_per_page").value, 12)
def test_template_gets_global_preferences_via_template_processor(self):
global_preferences = registry.manager()
url = reverse("dynamic_preferences.test.templateview")
response = self.client.get(url)
self.assertEqual(
response.context['global_preferences'], global_preferences.all())
def test_file_preference(self):
blog_entry = BlogEntry.objects.create(title='Hello', content='World')
content = b"hello"
logo = SimpleUploadedFile(
"logo.png", content, content_type="image/png")
self.client.login(username='******', password="******")
url = reverse(
"dynamic_preferences.global.section", kwargs={"section": 'blog'})
response = self.client.post(
url,
{'blog__featured_entry': blog_entry.pk,
'blog__logo': logo})
self.assertEqual(GlobalPreferenceModel.objects.get(
section="blog", name="featured_entry").value, blog_entry)
self.assertEqual(GlobalPreferenceModel.objects.get(
section="blog", name="logo").value.read(), content)
class TestViews(BaseTest, LiveServerTestCase):
def setUp(self):
self.henri = User(username="******", password="******", email="*****@*****.**")
self.henri.set_password("test")
self.henri.save()
self.admin = User(username="******", email="*****@*****.**", is_superuser=True, is_staff=True)
self.admin.set_password("test")
self.admin.save()
def test_can_build_global_preference_form(self):
# We want to display a form with two global preferences
# RegistrationAllowed and MaxUsers
form = global_preference_form_builder(preferences=["user__registration_allowed", "user__max_users"])()
self.assertEqual(len(form.fields), 2)
self.assertEqual(form.fields["user__registration_allowed"].initial, False)
def test_can_build_preference_form_from_sections(self):
form = global_preference_form_builder(section="test")()
self.assertEqual(len(form.fields), 3)
def test_can_build_global_preference_form_from_sections(self):
form = global_preference_form_builder(section="test")()
self.assertEqual(len(form.fields), 3)
def test_can_build_user_preference_form_from_sections(self):
form = user_preference_form_builder(instance=self.admin, section="test")()
self.assertEqual(len(form.fields), 4)
def test_global_preference_view_requires_staff_member(self):
url = reverse("dynamic_preferences.global")
response = self.client.get(url, follow=True)
self.assertRedirects(response, "/admin/login/?next=/global/")
self.client.login(username="******", password="******")
response = self.client.get(url)
self.assertRedirects(response, "/admin/login/?next=/global/")
self.client.login(username="******", password="******")
response = self.client.get(url)
self.assertEqual(self.admin.is_authenticated(), True)
self.assertEqual(response.status_code, 200)
def test_global_preference_view_display_form(self):
url = reverse("dynamic_preferences.global")
self.client.login(username="******", password="******")
response = self.client.get(url)
self.assertEqual(len(response.context["form"].fields), 7)
self.assertEqual(response.context["registry"], global_preferences_registry)
def test_global_preference_filters_by_section(self):
self.client.login(username="******", password="******")
url = reverse("dynamic_preferences.global.section", kwargs={"section": "user"})
response = self.client.get(url)
self.assertEqual(len(response.context["form"].fields), 3)
def test_preference_are_updated_on_form_submission(self):
self.client.login(username="******", password="******")
url = reverse("dynamic_preferences.global.section", kwargs={"section": "user"})
response = self.client.post(
url, {"user__max_users": 95, "user__registration_allowed": True, "user__items_per_page": 12}
)
self.assertEqual(GlobalPreferenceModel.objects.get(section="user", name="max_users").value, 95)
self.assertEqual(GlobalPreferenceModel.objects.get(section="user", name="registration_allowed").value, True)
self.assertEqual(GlobalPreferenceModel.objects.get(section="user", name="items_per_page").value, 12)
def test_user_preference_form_is_bound_with_current_user(self):
self.client.login(username="******", password="******")
self.assertEqual(
UserPreferenceModel.objects.get_or_create(instance=self.henri, section="misc", name="favourite_colour")[
0
].value,
"Green",
)
self.assertEqual(
UserPreferenceModel.objects.get_or_create(instance=self.henri, section="misc", name="is_zombie")[0].value,
True,
)
url = reverse("dynamic_preferences.user.section", kwargs={"section": "misc"})
response = self.client.post(url, {"misc__favourite_colour": "Purple", "misc__is_zombie": False})
self.assertEqual(self.henri.preferences["misc__favourite_colour"], "Purple")
self.assertEqual(self.henri.preferences["misc__is_zombie"], False)
def test_template_gets_global_preferences_via_template_processor(self):
global_preferences = global_preferences_registry.manager()
url = reverse("dynamic_preferences.test.templateview")
response = self.client.get(url)
self.assertEqual(response.context["global_preferences"], global_preferences.all())
class TestViews(BaseTest, LiveServerTestCase):
def setUp(self):
self.admin = User(username="******",
email="*****@*****.**",
is_superuser=True,
is_staff=True)
self.admin.set_password('test')
self.admin.save()
def test_can_build_global_preference_form(self):
# We want to display a form with two global preferences
# RegistrationAllowed and MaxUsers
form = global_preference_form_builder(
preferences=['user__registration_allowed', "user__max_users"])()
self.assertEqual(len(form.fields), 2)
self.assertEqual(form.fields['user__registration_allowed'].initial,
False)
def test_can_build_preference_form_from_sections(self):
form = global_preference_form_builder(section='test')()
self.assertEqual(len(form.fields), 3)
def test_can_build_global_preference_form_from_sections(self):
form = global_preference_form_builder(section='test')()
self.assertEqual(len(form.fields), 3)
def test_global_preference_view_requires_staff_member(self):
url = reverse("dynamic_preferences.global")
response = self.client.get(url, follow=True)
self.assertRedirects(response, "/admin/login/?next=/global/")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertRedirects(response, "/admin/login/?next=/global/")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(self.admin.is_authenticated(), True)
self.assertEqual(response.status_code, 200)
def test_global_preference_view_display_form(self):
url = reverse("dynamic_preferences.global")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(len(response.context['form'].fields), 14)
self.assertEqual(response.context['registry'], registry)
def test_global_preference_view_section_verbose_names(self):
url = reverse(
"admin:dynamic_preferences_globalpreferencemodel_changelist")
self.client.login(username='******', password="******")
response = self.client.get(url)
for key, section in registry.section_objects.items():
if section.name != section.verbose_name:
# Assert verbose_name in table
self.assertTrue(
str(response._container).count(section.verbose_name +
"</td>") >= 1)
# Assert verbose_name in filter link
self.assertTrue(
str(response._container).count(section.verbose_name +
"</a>") >= 1)
def test_formview_includes_section_in_context(self):
url = reverse("dynamic_preferences.global.section",
kwargs={"section": 'user'})
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(response.context['section'],
registry.section_objects['user'])
def test_formview_with_bad_section_returns_404(self):
url = reverse("dynamic_preferences.global.section",
kwargs={"section": 'nope'})
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
def test_global_preference_filters_by_section(self):
self.client.login(username='******', password="******")
url = reverse("dynamic_preferences.global.section",
kwargs={"section": 'user'})
response = self.client.get(url)
self.assertEqual(len(response.context['form'].fields), 3)
def test_preference_are_updated_on_form_submission(self):
blog_entry = BlogEntry.objects.create(title='test', content='test')
self.client.login(username='******', password="******")
url = reverse("dynamic_preferences.global")
data = {
'user__max_users': 67,
'user__registration_allowed': True,
"user__items_per_page": 12,
'test__TestGlobal1': 'new value',
'test__TestGlobal2': True,
'test__TestGlobal3': True,
'no_section': True,
'blog__featured_entry': blog_entry.pk,
'blog__logo': None,
'company__RegistrationDate': date(1976, 4, 1),
'child__BirthDateTime': datetime.now(),
'type__cost': 1,
'exam__duration': timedelta(hours=5),
}
response = self.client.post(url, data)
for key, expected_value in data.items():
try:
section, name = key.split('__')
except ValueError:
section, name = (None, key)
p = GlobalPreferenceModel.objects.get(name=name, section=section)
if name == 'featured_entry':
expected_value = blog_entry
if name == 'BirthDateTime':
expected_value = make_aware(expected_value)
self.assertEqual(p.value, expected_value)
def test_preference_are_updated_on_form_submission_by_section(self):
self.client.login(username='******', password="******")
url = reverse("dynamic_preferences.global.section",
kwargs={"section": 'user'})
response = self.client.post(
url, {
'user__max_users': 95,
'user__registration_allowed': True,
'user__items_per_page': 12
})
self.assertEqual(
GlobalPreferenceModel.objects.get(section="user",
name="max_users").value, 95)
self.assertEqual(
GlobalPreferenceModel.objects.get(
section="user", name="registration_allowed").value, True)
self.assertEqual(
GlobalPreferenceModel.objects.get(section="user",
name="items_per_page").value, 12)
def test_template_gets_global_preferences_via_template_processor(self):
global_preferences = registry.manager()
url = reverse("dynamic_preferences.test.templateview")
response = self.client.get(url)
self.assertEqual(response.context['global_preferences'],
global_preferences.all())
def test_file_preference(self):
blog_entry = BlogEntry.objects.create(title='Hello', content='World')
content = b"hello"
logo = SimpleUploadedFile("logo.png",
content,
content_type="image/png")
self.client.login(username='******', password="******")
url = reverse("dynamic_preferences.global.section",
kwargs={"section": 'blog'})
response = self.client.post(url, {
'blog__featured_entry': blog_entry.pk,
'blog__logo': logo
})
self.assertEqual(
GlobalPreferenceModel.objects.get(section="blog",
name="featured_entry").value,
blog_entry)
self.assertEqual(
GlobalPreferenceModel.objects.get(section="blog",
name="logo").value.read(),
content)
def main(request):
user = User()
user = request.user
if user.is_authenticated():
return render(request, 'appointment/schedule.html', {'user':request.user, 'profile':request.user.profile})
return render(request, 'inicio.html',{})
def GetUserByDjUser(djUser):
userId = djUser.id if djUser and djUser.is_authenticated() else None
users = User.objects.filter(id=userId).all()
return users[0] if users else None
class TestViews(BaseTest, LiveServerTestCase):
def setUp(self):
self.henri = User(username="******",
password="******",
email="*****@*****.**")
self.henri.set_password('test')
self.henri.save()
self.admin = User(username="******",
email="*****@*****.**",
is_superuser=True,
is_staff=True)
self.admin.set_password('test')
self.admin.save()
def test_can_build_global_preference_form(self):
# We want to display a form with two global preferences
# RegistrationAllowed and MaxUsers
form = global_preference_form_builder(
preferences=['user__registration_allowed', "user__max_users"])()
self.assertEqual(len(form.fields), 2)
self.assertEqual(form.fields['user__registration_allowed'].initial,
False)
def test_can_build_preference_form_from_sections(self):
form = global_preference_form_builder(section='test')()
self.assertEqual(len(form.fields), 3)
def test_can_build_global_preference_form_from_sections(self):
form = global_preference_form_builder(section='test')()
self.assertEqual(len(form.fields), 3)
def test_can_build_user_preference_form_from_sections(self):
form = user_preference_form_builder(instance=self.admin,
section='test')()
self.assertEqual(len(form.fields), 4)
def test_global_preference_view_requires_staff_member(self):
url = reverse("dynamic_preferences.global")
response = self.client.get(url, follow=True)
self.assertRedirects(response, "/admin/login/?next=/global/")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertRedirects(response, "/admin/login/?next=/global/")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(self.admin.is_authenticated(), True)
self.assertEqual(response.status_code, 200)
def test_global_preference_view_display_form(self):
url = reverse("dynamic_preferences.global")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(len(response.context['form'].fields), 8)
self.assertEqual(response.context['registry'],
global_preferences_registry)
def test_global_preference_filters_by_section(self):
self.client.login(username='******', password="******")
url = reverse("dynamic_preferences.global.section",
kwargs={"section": 'user'})
response = self.client.get(url)
self.assertEqual(len(response.context['form'].fields), 3)
def test_preference_are_updated_on_form_submission(self):
self.client.login(username='******', password="******")
url = reverse("dynamic_preferences.global.section",
kwargs={"section": 'user'})
response = self.client.post(
url, {
'user__max_users': 95,
'user__registration_allowed': True,
"user__items_per_page": 12
})
self.assertEqual(
GlobalPreferenceModel.objects.get(section="user",
name="max_users").value, 95)
self.assertEqual(
GlobalPreferenceModel.objects.get(
section="user", name="registration_allowed").value, True)
self.assertEqual(
GlobalPreferenceModel.objects.get(section="user",
name="items_per_page").value, 12)
def test_user_preference_form_is_bound_with_current_user(self):
self.client.login(username='******', password="******")
self.assertEqual(
UserPreferenceModel.objects.get_or_create(
instance=self.henri, section="misc",
name='favourite_colour')[0].value, 'Green')
self.assertEqual(
UserPreferenceModel.objects.get_or_create(
instance=self.henri, section="misc",
name='is_zombie')[0].value, True)
url = reverse("dynamic_preferences.user.section",
kwargs={'section': 'misc'})
response = self.client.post(url, {
'misc__favourite_colour': 'Purple',
'misc__is_zombie': False
})
self.assertEqual(self.henri.preferences['misc__favourite_colour'],
'Purple')
self.assertEqual(self.henri.preferences['misc__is_zombie'], False)
def test_template_gets_global_preferences_via_template_processor(self):
global_preferences = global_preferences_registry.manager()
url = reverse("dynamic_preferences.test.templateview")
response = self.client.get(url)
self.assertEqual(response.context['global_preferences'],
global_preferences.all())
class TestViews(LiveServerTestCase):
def setUp(self):
self.henri = User(username="******", password="******", email="*****@*****.**")
self.henri.set_password('test')
self.henri.save()
self.admin = User(username="******", email="*****@*****.**", is_superuser=True, is_staff=True)
self.admin.set_password('test')
self.admin.save()
def test_can_build_global_preference_form(self):
# We want to display a form with two global preferences
# RegistrationAllowed and MaxUsers
form = global_preference_form_builder(preferences=['user.registration_allowed', "user.max_users"])()
self.assertEqual(len(form.fields), 2)
self.assertEqual(form.fields['user.registration_allowed'].initial, False)
def test_can_build_preference_form_from_sections(self):
form = global_preference_form_builder(section='test')()
self.assertEqual(len(form.fields), 3)
def test_can_build_global_preference_form_from_sections(self):
form = global_preference_form_builder(section='test')()
self.assertEqual(len(form.fields), 3)
def test_can_build_user_preference_form_from_sections(self):
form = user_preference_form_builder(user=self.admin, section='test')()
self.assertEqual(len(form.fields), 4)
def test_global_preference_view_requires_staff_member(self):
url = reverse("dynamic_preferences.global")
response = self.client.get(url, follow=True)
self.assertRedirects(response, "/admin/login/?next=/global/")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertRedirects(response, "/admin/login/?next=/global/")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(self.admin.is_authenticated(), True)
self.assertEqual(response.status_code, 200)
def test_global_preference_view_display_form(self):
url = reverse("dynamic_preferences.global")
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(len(response.context['form'].fields), 8)
self.assertEqual(response.context['registry'], global_preferences_registry)
def test_global_preference_filters_by_section(self):
self.client.login(username='******', password="******")
url = reverse("dynamic_preferences.global.section", kwargs={"section": 'user'})
response = self.client.get(url)
self.assertEqual(len(response.context['form'].fields), 4)
def test_preference_are_updated_on_form_submission(self):
self.client.login(username='******', password="******")
url = reverse("dynamic_preferences.global.section", kwargs={"section": 'user'})
self.client.post(url, {'user.max_users': 95, 'user.registration_allowed': True,
'user.favorite_vegetable': "P", "user.items_per_page": 12})
self.assertEqual(global_preferences.get(section="user", name="max_users").value, 95)
self.assertEqual(global_preferences.get(section="user", name="registration_allowed").value, True)
self.assertEqual(global_preferences.get(section="user", name="favorite_vegetable").value, 'P')
def test_user_preference_form_is_bound_with_current_user(self):
self.client.login(username='******', password="******")
self.assertEqual(
user_preferences.get_or_create(user=self.henri, section="misc", name='favourite_colour')[0].value, 'Green')
self.assertEqual(user_preferences.get_or_create(user=self.henri, section="misc", name='is_zombie')[0].value,
True)
url = reverse("dynamic_preferences.user.section", kwargs={'section': 'misc'})
self.client.post(url, {'misc.favourite_colour': 'Purple', 'misc.is_zombie': False})
self.assertEqual(self.henri.preferences.get(section="misc", name='favourite_colour').value, 'Purple')
self.assertEqual(self.henri.preferences.get(section="misc", name='is_zombie').value, False)
def test_preference_model_manager_to_dict(self):
call_command('checkpreferences', verbosity=1, interactive=False)
expected = {u'test': {u'TestGlobal1': u'default value', u'TestGlobal2': False, u'TestGlobal3': False},
None: {u'no_section': False},
u'user': {u'max_users': 100, u'items_per_page': 25, u'registration_allowed': False,
u'favorite_vegetable': u'C'}}
self.assertEqual(global_preferences.to_dict(), expected)
def test_user_preference_model_manager_to_dict(self):
call_command('checkpreferences', verbosity=1, interactive=False)
user = User.objects.get(pk=self.henri.pk)
expected = {u'misc': {u'favourite_colour': u'Green', u'is_zombie': True},
u'test': {u'SUserStringPref': u'Hello world!', u'SiteBooleanPref': False,
u'TestUserPref1': u'default value', u'TestUserPref2': u''}}
self.assertEqual(user_preferences.to_dict(user=user), expected)
def test_template_gets_global_preferences_via_template_processor(self):
call_command('checkpreferences', verbosity=1, interactive=False)
url = reverse("dynamic_preferences.test.templateview")
response = self.client.get(url)
self.assertEqual(response.context['global_preferences'], global_preferences.to_dict())
def test_template_gets_user_preferences_via_template_processor(self):
call_command('checkpreferences', verbosity=1, interactive=False)
user = User.objects.get(pk=self.henri.pk)
self.client.login(username=user.username, password="******")
url = reverse("dynamic_preferences.test.templateview")
response = self.client.get(url)
to_dict = user_preferences.to_dict(user=user)
self.assertEqual(response.context['user_preferences'], to_dict)
