def test_can_serialize_preference(self):
manager = registry.manager()
pref = manager.get_db_pref(section='user', name='max_users')
serializer = serializers.GlobalPreferenceSerializer(pref)
data = serializer.data
self.assertEqual(data['default'], pref.preference.api_repr(pref.preference.default))
self.assertEqual(data['value'], pref.preference.api_repr(pref.value))
self.assertEqual(data['identifier'], pref.preference.identifier())
self.assertEqual(data['section'], pref.section)
self.assertEqual(data['name'], pref.name)
self.assertEqual(data['verbose_name'], pref.preference.verbose_name)
self.assertEqual(data['help_text'], pref.preference.help_text)
self.assertEqual(data['field']['class'], 'IntegerField')
self.assertEqual(data['field']['input_type'], 'number')
self.assertEqual(data['field']['widget']['class'], 'NumberInput')
pref = manager.get_db_pref(section='exam', name='duration')
serializer = serializers.GlobalPreferenceSerializer(pref)
data = serializer.data
self.assertEqual(data['value'], '03:00:00')
pref = manager.get_db_pref(section='company', name='RegistrationDate')
serializer = serializers.GlobalPreferenceSerializer(pref)
data = serializer.data
self.assertEqual(data['value'], '1998-09-04')
pref = manager.get_db_pref(section='child', name='BirthDateTime')
serializer = serializers.GlobalPreferenceSerializer(pref)
data = serializer.data
self.assertEqual(data['value'], '1992-05-04T03:04:10.000150+05:30')
def preferences(db, cache):
"""
return a dynamic_preferences manager for global_preferences
"""
manager = global_preferences_registry.manager()
manager.all()
yield manager
def test_quickstart(self):
global_preferences = global_preferences_registry.manager()
self.assertEqual(global_preferences['user__registration_allowed'],
False)
global_preferences['user__registration_allowed'] = True
self.assertEqual(global_preferences['user__registration_allowed'],
True)
self.assertEqual(
GlobalPreferenceModel.objects.get(
section="user", name="registration_allowed").value, True)
self.assertEqual(self.henri.preferences['misc__favourite_colour'],
'Green')
self.henri.preferences['misc__favourite_colour'] = 'Blue'
self.assertEqual(self.henri.preferences['misc__favourite_colour'],
'Blue')
self.assertEqual(
UserPreferenceModel.objects.get(section="misc",
name="favourite_colour",
instance=self.henri).value, 'Blue')
def test_preference_model_manager_to_dict(self):
manager = registry.manager()
call_command('checkpreferences', verbosity=1, interactive=False)
expected = {
u'test__TestGlobal1':
u'default value',
u'test__TestGlobal2':
False,
u'test__TestGlobal3':
False,
u'type__cost':
Decimal(0),
u'exam__duration':
timedelta(hours=3),
u'no_section':
False,
u'user__max_users':
100,
u'user__items_per_page':
25,
u'blog__featured_entry':
None,
u'blog__logo':
None,
u'blog__logo2':
None,
u'company__RegistrationDate':
date(1998, 9, 4),
u'child__BirthDateTime':
datetime(1992, 5, 4, 3, 4, 10, 150,
tzinfo=FixedOffset(offset=330)),
u'user__registration_allowed':
False
}
self.assertDictEqual(manager.all(), expected)
def is_during_the_season(value=None, raise_exception=True):
if not value:
value = datetime.date.today()
this_year = datetime.datetime.today().year
if value.year != this_year:
raise ValidationError(
"Orders are only allowed for {}.".format(this_year))
global_preferences = global_preferences_registry.manager()
start_day = global_preferences['season_start_day']
start_month = global_preferences['season_start_month']
end_day = global_preferences['season_end_day']
end_month = global_preferences['season_end_month']
start_of_season = datetime.date(year=this_year,
month=start_month,
day=start_day)
end_of_season = datetime.date(year=this_year, month=end_month, day=end_day)
if value < start_of_season:
if raise_exception:
raise ValidationError(
f"The pick up season starts {start_month}/{start_day}.")
else:
return False
if value > end_of_season:
if raise_exception:
raise ValidationError(
f"The pick up season ends {end_month}/{end_day}.")
else:
return False
return True
def get_context_data(self, **kwargs):
prefs = global_preferences_registry.manager()
context = super().get_context_data(**kwargs)
context.update({'pode_submeter': (
prefs['trabalhos__prazo_submissao'] > now()
)})
return context
def test_can_bypass_cache_in_get(self):
manager = global_preferences_registry.manager()
manager['no_section']
with self.assertNumQueries(3):
manager['no_section']
manager['no_section']
manager['no_section']
def save(self, *args, **kwargs):
self._maintype = "personassociation"
self._type = (
self.type
or global_preferences_registry.manager()["persons__default_associationtype"]
)
super().save(*args, **kwargs)
def get_queryset(self, *args, **kwargs):
# Instanciate default prefs
dynprefs.manager().all()
cases = []
for o in order:
cases.append(
When(section=o.section, name=o.name,
then=Value(order.index(o)))
)
return super(GlobalPreferenceAdmin, self).\
get_queryset(*args, **kwargs).annotate(
pref_order=Case(*cases, output_field=IntegerField())
).order_by('pref_order')
def test_invalidates_cache_when_saving_from_admin(self):
admin = User(
username="******",
email="*****@*****.**",
is_superuser=True,
is_staff=True)
admin.set_password('test')
admin.save()
self.client.login(username='******', password="******")
manager = registry.manager()
pref = manager.get_db_pref(section='test', name='TestGlobal1')
url = reverse(
'admin:dynamic_preferences_globalpreferencemodel_change',
args=(pref.id,)
)
key = manager.get_cache_key('test', 'TestGlobal1')
response = self.client.post(url, {'raw_value': 'reset1'})
self.assertEqual(manager.cache.get(key), 'reset1')
self.assertEqual(manager.all()['test__TestGlobal1'], 'reset1')
response = self.client.post(url, {'raw_value': 'reset2'})
self.assertEqual(manager.cache.get(key), 'reset2')
self.assertEqual(manager.all()['test__TestGlobal1'], 'reset2')
def clean(self):
"""
Sets name to next service ID for internal services. Only expect a user
inputted name for manually named services.
Sets the service class from the service type.
"""
cleaned_data = super(NewServiceForm, self).clean()
# Set service_class depending on service_type.
service_type_ = ServiceType.objects.get(name=cleaned_data.get('service_type'))
cleaned_data['service_class'] = service_type_.service_class.name
# Set name to a generated id if the service is not a manually named service.
name = cleaned_data.get("name")
service_type = cleaned_data.get("service_type")
if self.is_valid():
is_maunal_name = service_type in self.Meta.manually_named_services or cleaned_data['service_class'] in self.Meta.manually_named_services_class
if not name and not is_maunal_name:
try:
global_preferences = global_preferences_registry.manager()
id_generator_name = global_preferences[self.Meta.id_generator_property]
id_generator = UniqueIdGenerator.objects.get(name=id_generator_name)
# id_collection is always the same so we do not need config
cleaned_data['name'] = unique_ids.get_collection_unique_id(id_generator, NordunetUniqueId)
except UniqueIdGenerator.DoesNotExist:
msg = u'UniqueIdGenerator with the name "{}" does not exist'.format(id_generator_name)
raise UniqueIdGenerator.DoesNotExist(msg)
elif not name:
self.add_error('name', 'Missing name for {} service.'.format(service_type))
return cleaned_data
def page_flash(request):
global_preferences = global_preferences_registry.manager()
msg = global_preferences['announcements__page_flash_message']
level = global_preferences['announcements__page_flash_message_level']
if msg == 'None' or msg is None or not msg.strip():
msg = ''
return {'page_flash': {'level': level, 'message': msg}}
def test_model_choice_preference(self):
global_preferences = global_preferences_registry.manager()
global_preferences['blog__featured_entry'] = self.blog_entry
in_db = GlobalPreferenceModel.objects.get(section='blog', name='featured_entry')
self.assertEqual(in_db.value, self.blog_entry)
self.assertEqual(in_db.raw_value, str(self.blog_entry.pk))
def test_file_preference_conflicting_file_names(self):
'''
f2 should have a different file name to f, since Django storage needs
to differentiate between the two
'''
f = SimpleUploadedFile('test_file_c95d02ef-0e5d-4d36-98c0-1b54505860d0.txt', 'hello world'.encode('utf-8'))
f2 = SimpleUploadedFile('test_file_c95d02ef-0e5d-4d36-98c0-1b54505860d0.txt', 'hello world 2'.encode('utf-8'))
p = global_preferences_registry.get(section='blog', name='logo')
manager = global_preferences_registry.manager()
manager['blog__logo'] = f
manager['blog__logo2'] = f2
self.assertEqual(
manager['blog__logo2'].read(),
b'hello world 2')
self.assertEqual(
manager['blog__logo'].read(),
b'hello world')
self.assertNotEqual(
manager['blog__logo'].url,
manager['blog__logo2'].url
)
self.assertNotEqual(
manager['blog__logo'].path,
manager['blog__logo2'].path
)
def dhcp_scan_devices():
global_preferences = global_preferences_registry.manager()
logger.info('+ Start DHCP Scanning network ...')
enabled_dhcp = global_preferences['dhcp_scan__is_enabled']
if not enabled_dhcp:
logger.info('!!! Stopped Scanning! DHCP Scan is Disabled !!!')
return
ip_ranges = global_preferences['dhcp_scan__ip_ranges']
if not ip_ranges:
logger.info(
'!!! Stopped Scanning! No ip_ranges set in dhcp_scan settings !!!')
return
ip_ranges = [ip_range.strip() for ip_range in ip_ranges.split(',')]
auto_add_new = global_preferences['dhcp_scan__auto_add_new']
for ip_range in ip_ranges:
logger.info('*** Scanning ip range: [%s] ...', ip_range)
scan = scan_network_ips(ip_range)
logger.info('*** Checking [%s] discovered devices in range [%s] ...',
len(scan), ip_range)
_check_discovered_devices(scan, auto_add_new=auto_add_new)
logger.info('*** Checking to disable/archive not seen devices ...')
auto_disable_after = global_preferences['dhcp_scan__auto_disable_after']
if auto_disable_after:
_check_disabled_devices(auto_disable_after)
logger.info('+++ Finished DHCP Scanning network ...')
def setUp(self):
"""
Run automatically at the start of any test. Ensure that there's no
library hanging around in our testdata dir, ensure that our base
testing files exist, and then set up the base library path.
"""
for filename in [
'silence-abr.mp3', 'silence-cbr.mp3', 'silence-vbr.mp3',
'invalid-tags.mp3', 'silence.ogg', 'silence.m4a',
'silence.flac', 'silence.opus', 'cover_400.jpg',
'cover_400.gif', 'cover_400.png', 'cover_400.tif',
'cover_100.jpg'
]:
if not os.path.exists(os.path.join(self.testdata_path,
filename)): # pragma: no cover
raise Exception('Required testing file "%s" does not exist!' %
(filename))
self.library_path = tempfile.mkdtemp()
self.prefs = global_preferences_registry.manager()
self.prefs['exordium__base_path'] = self.library_path
self.prefs[
'exordium__media_url_html5'] = 'http://testserver-media/html5music'
self.prefs[
'exordium__media_url_m3u'] = 'http://testserver-media/m3umusic'
# We have one test which alters the following value, which
# will stay changed between tests unless we restore it.
self.saved_album_size = AlbumArt.resolutions[AlbumArt.SZ_ALBUM]
def get_outbound_payload_logger() -> Optional[callable]:
"""
Return a function to log outbound payloads, if enabled in admin preferences.
"""
preferences = global_preferences_registry.manager()
if preferences["admin__log_all_outbound_payloads"]:
return outbound_payload_logger
def test_can_bypass_cache_in_get(self):
manager = global_preferences_registry.manager()
manager['no_section']
with self.assertNumQueries(3):
manager['no_section']
manager['no_section']
manager['no_section']
def test_quickstart(self):
global_preferences = global_preferences_registry.manager()
self.assertFalse(global_preferences['user__registration_allowed'])
global_preferences['user__registration_allowed'] = True
self.assertTrue(global_preferences['user__registration_allowed'])
self.assertTrue(
GlobalPreferenceModel.objects.get(
section="user", name="registration_allowed").value)
self.assertEqual(
self.henri.preferences['misc__favourite_colour'],
'Green')
self.henri.preferences['misc__favourite_colour'] = 'Blue'
self.assertEqual(
self.henri.preferences['misc__favourite_colour'],
'Blue')
self.assertEqual(
UserPreferenceModel.objects.get(
section="misc",
name="favourite_colour",
instance=self.henri).value,
'Blue')
def test_can_serialize_preference(self):
manager = registry.manager()
pref = manager.get_db_pref(section='user', name='max_users')
serializer = serializers.GlobalPreferenceSerializer(pref)
data = serializer.data
self.assertEqual(data['default'],
pref.preference.api_repr(pref.preference.default))
self.assertEqual(data['value'], pref.preference.api_repr(pref.value))
self.assertEqual(data['identifier'], pref.preference.identifier())
self.assertEqual(data['section'], pref.section)
self.assertEqual(data['name'], pref.name)
self.assertEqual(data['verbose_name'], pref.preference.verbose_name)
self.assertEqual(data['help_text'], pref.preference.help_text)
self.assertEqual(data['field']['class'], 'IntegerField')
self.assertEqual(data['field']['input_type'], 'number')
self.assertEqual(data['field']['widget']['class'], 'NumberInput')
pref = manager.get_db_pref(section='exam', name='duration')
serializer = serializers.GlobalPreferenceSerializer(pref)
data = serializer.data
self.assertEqual(data['value'], '03:00:00')
pref = manager.get_db_pref(section='company', name='RegistrationDate')
serializer = serializers.GlobalPreferenceSerializer(pref)
data = serializer.data
self.assertEqual(data['value'], '1998-09-04')
pref = manager.get_db_pref(section='child', name='BirthDateTime')
serializer = serializers.GlobalPreferenceSerializer(pref)
data = serializer.data
self.assertEqual(data['value'], '1992-05-04T03:04:10.000150+05:30')
def totalamount(self):
global_preferences = global_preferences_registry.manager()
return sum([
convert_money(c.amount_formatted(),
global_preferences["contributions__currency"])
for c in self.contributions.all()
])
def get_email_context():
context = {}
context["funkwhale_url"] = settings.FUNKWHALE_URL
manager = global_preferences_registry.manager()
context["funkwhale_site_name"] = (manager["instance__name"]
or settings.FUNKWHALE_HOSTNAME)
context["funkwhale_site_domain"] = settings.FUNKWHALE_HOSTNAME
return context
def test_can_get_preferences_objects_from_manager(self):
manager = registry.manager()
cached_prefs = dict(manager.all())
qs = manager.queryset
self.assertEqual(len(qs), len(cached_prefs))
self.assertEqual(list(qs), list(GlobalPreferenceModel.objects.all()))
def dispatch(self, request, *args, **kwargs):
if request.user.is_authenticated:
return redirect(self.get_authenticated_url())
if "ephios.plugins.guests" not in global_preferences_registry.manager().get(
"general__enabled_plugins"
):
raise PermissionDenied
return super().dispatch(request, *args, **kwargs)
def test_file_preference_api_repr_returns_path(self):
f = SimpleUploadedFile('test_file.txt', 'hello world'.encode('utf-8'))
p = global_preferences_registry.get(section='blog', name='logo')
manager = global_preferences_registry.manager()
manager['blog__logo'] = f
f = manager['blog__logo']
self.assertEqual(p.api_repr(f), f.url)
def test_can_cache_all_preferences(self):
manager = global_preferences_registry.manager()
manager.all()
with self.assertNumQueries(0):
manager.all()
manager.all()
manager.all()
def test_model_choice_preference(self):
global_preferences = global_preferences_registry.manager()
global_preferences['blog__featured_entry'] = self.blog_entry
in_db = GlobalPreferenceModel.objects.get(section='blog',
name='featured_entry')
self.assertEqual(in_db.value, self.blog_entry)
self.assertEqual(in_db.raw_value, str(self.blog_entry.pk))
def test_can_cache_single_preference(self):
manager = global_preferences_registry.manager()
v = manager['no_section']
with self.assertNumQueries(0):
v = manager['no_section']
v = manager['no_section']
v = manager['no_section']
def test_can_cache_single_preference(self):
manager = global_preferences_registry.manager()
v = manager['no_section']
with self.assertNumQueries(0):
v = manager['no_section']
v = manager['no_section']
v = manager['no_section']
def menu_mode():
"""
Adds a the menu items if it's set in the dynamic_preferences
"""
global_preferences = global_preferences_registry.manager()
menu_mode = global_preferences['general__menu_mode']
{'menu_mode': menu_mode}
def test_can_cache_all_preferences(self):
manager = global_preferences_registry.manager()
manager.all()
with self.assertNumQueries(0):
manager.all()
manager.all()
manager.all()
def test_can_cache_all_preferences(self):
blog_entry = BlogEntry.objects.create(title='test', content='test')
manager = global_preferences_registry.manager()
manager.all()
with self.assertNumQueries(3):
# one request each time we retrieve the blog entry
manager.all()
manager.all()
manager.all()
def test_can_delete_file_preference(self):
f = SimpleUploadedFile('test_file.txt', 'hello world'.encode('utf-8'))
p = global_preferences_registry.get(section='blog', name='logo')
manager = global_preferences_registry.manager()
manager['blog__logo'] = f
path = os.path.join(settings.MEDIA_ROOT, p.get_upload_path(), f.name)
self.assertTrue(os.path.exists(path))
manager['blog__logo'].delete()
self.assertFalse(os.path.exists(path))
def get_form(self, form_class=None):
form = SectionBasedConfigurationForm(
self.request.POST or None,
initial={
"sections":
global_preferences_registry.manager()["beachguard__sections"]
})
form.fields = {"sections": Field(widget=HiddenInput, required=False)}
return form
def test_can_get_db_pref_from_manager(self):
manager = registry.manager()
manager.queryset.delete()
pref = manager.get_db_pref(section='test', name='TestGlobal1')
self.assertEqual(pref.section, 'test')
self.assertEqual(pref.name, 'TestGlobal1')
self.assertEqual(
pref.raw_value, registry.get('test__TestGlobal1').default)
def basxconnect_core(request):
return {
"PLATFORMNAME":
mark_safe('basx <span style="font-weight: 600">Connect</span>'),
"COMPANYNAME":
global_preferences_registry.manager()["general__organizationname"],
"SEARCHBAR":
searchbar,
}
def test_can_get_db_pref_from_manager(self):
manager = registry.manager()
manager.queryset.delete()
pref = manager.get_db_pref(section='test', name='TestGlobal1')
self.assertEqual(pref.section, 'test')
self.assertEqual(pref.name, 'TestGlobal1')
self.assertEqual(pref.raw_value,
registry.get('test__TestGlobal1').default)
def test_can_cache_all_preferences(self):
blog_entry = BlogEntry.objects.create(title='test', content='test')
manager = global_preferences_registry.manager()
manager.all()
with self.assertNumQueries(3):
# one request each time we retrieve the blog entry
manager.all()
manager.all()
manager.all()
def get_cost_object(self):
"""
Returns the assigned cost object, if set, otherwise the global default
"""
if self.cost_object:
return self.cost_object
else:
global_preferences = global_preferences_registry.manager()
return CostCenter.objects.get(
pk=global_preferences['Members__division_cost_object'])
def test_deleting_model_also_delete_preference(self):
global_preferences = global_preferences_registry.manager()
global_preferences['blog__featured_entry'] = self.blog_entry
self.assertGreater(len(signals.pre_delete.receivers), 0)
self.blog_entry.delete()
with self.assertRaises(GlobalPreferenceModel.DoesNotExist):
GlobalPreferenceModel.objects.get(section='blog', name='featured_entry')
def test_can_bypass_cache_in_get_all(self):
from django.db import connection
manager = global_preferences_registry.manager()
queries_before = len(connection.queries)
manager.all()
manager_queries = len(connection.queries) - queries_before
manager.all()
self.assertGreater(len(connection.queries), manager_queries)
def clean(self):
cleaned_data = super().clean()
prefs = global_preferences_registry.manager()
if (len(cleaned_data['atividades']) >
prefs['evento__inscricao_atividade_max']):
raise ValidationError(
'Você deve selecionar no máximo %d atividade(s)' %
prefs['evento__inscricao_atividade_max'])
return cleaned_data
def clean(self):
cleaned_data = super().clean()
prefs = global_preferences_registry.manager()
if (len(cleaned_data['atividades']) >
prefs['evento__inscricao_atividade_max']):
raise ValidationError(
'Você deve selecionar no máximo %d atividade(s)' %
prefs['evento__inscricao_atividade_max'])
return cleaned_data
def test_can_bypass_cache_in_get_all(self):
from django.db import connection
manager = global_preferences_registry.manager()
queries_before = len(connection.queries)
manager.all()
manager_queries = len(connection.queries) - queries_before
manager.all()
self.assertGreater(len(connection.queries), manager_queries)
def test_serializer_also_uses_custom_clean_method(self):
manager = registry.manager()
pref = manager.get_db_pref(section='user', name='max_users')
# will fail because of preference cleaning
data = {'value': 1001}
serializer = serializers.GlobalPreferenceSerializer(pref, data=data)
is_valid = serializer.is_valid()
self.assertFalse(is_valid)
self.assertIn('value', serializer.errors)
def test_do_not_restore_default_when_calling_all(self):
manager = registry.manager()
new_value = 'test_new_value'
manager['test__TestGlobal1'] = new_value
self.assertEqual(manager['test__TestGlobal1'], new_value)
caches['default'].clear()
manager.all()
caches['default'].clear()
self.assertEqual(manager['test__TestGlobal1'], new_value)
self.assertEqual(manager.all()['test__TestGlobal1'], new_value)
def test_file_preference_api_repr_returns_path(self):
f = SimpleUploadedFile('test_file.txt', 'hello world'.encode('utf-8'))
p = global_preferences_registry.get(section='blog', name='logo')
manager = global_preferences_registry.manager()
manager['blog__logo'] = f
f = manager['blog__logo']
self.assertEqual(
p.api_repr(f),
f.url
)
def test_do_not_crash_if_preference_is_missing_in_registry(self):
"""see #41"""
manager = global_preferences_registry.manager()
instance = manager.create_db_pref(
section=None, name='bad_pref', value='something')
self.assertTrue(
isinstance(instance.preference, MissingPreference))
self.assertEqual(instance.preference.section, None)
self.assertEqual(instance.preference.name, 'bad_pref')
self.assertEqual(instance.value, 'something')
def test_can_delete_file_preference(self):
f = SimpleUploadedFile('test_file.txt', 'hello world'.encode('utf-8'))
p = global_preferences_registry.get(section='blog', name='logo')
manager = global_preferences_registry.manager()
manager['blog__logo'] = f
path = os.path.join(
settings.MEDIA_ROOT,
p.get_upload_path(),
f.name
)
self.assertTrue(os.path.exists(path))
manager['blog__logo'].delete()
self.assertFalse(os.path.exists(path))
def test_preference_model_manager_to_dict(self):
manager = global_preferences_registry.manager()
call_command('checkpreferences', verbosity=1, interactive=False)
expected = {
u'test__TestGlobal1': u'default value',
u'test__TestGlobal2': False,
u'test__TestGlobal3': False,
u'no_section': False,
u'user__max_users': 100,
u'user__items_per_page': 25,
u'blog__featured_entry': None,
u'user__registration_allowed': False}
self.assertDictEqual(manager.all(), expected)
def test_can_change_preference_value_using_serializer(self):
manager = registry.manager()
pref = manager.get_db_pref(section='user', name='max_users')
data = {'value': 666}
serializer = serializers.GlobalPreferenceSerializer(pref, data=data)
is_valid = serializer.is_valid()
self.assertTrue(is_valid)
serializer.save()
pref = manager.get_db_pref(section='user', name='max_users')
self.assertEqual(pref.value, data['value'])
def test_can_detail_preference(self):
manager = registry.manager()
pref = manager.get_db_pref(section='user', name='max_users')
url = reverse(
'api:global-detail',
kwargs={'pk': pref.preference.identifier()})
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
payload = json.loads(response.content.decode('utf-8'))
self.assertEqual(pref.preference.identifier(), payload['identifier'])
self.assertEqual(pref.value, payload['value'])
def test_can_get_preferences_objects_from_manager(self):
manager = registry.manager()
cached_prefs = dict(manager.all())
qs = manager.queryset
self.assertEqual(
len(qs),
len(cached_prefs)
)
self.assertEqual(
list(qs),
list(GlobalPreferenceModel.objects.all())
)
def test_update_preference_returns_validation_error(self):
manager = registry.manager()
pref = manager.get_db_pref(section='user', name='max_users')
url = reverse(
'api:global-detail',
kwargs={'pk': pref.preference.identifier()})
self.client.login(username='******', password="******")
response = self.client.patch(
url, json.dumps({'value': 1001}), content_type='application/json')
self.assertEqual(response.status_code, 400)
payload = json.loads(response.content.decode('utf-8'))
self.assertEqual(payload['value'], ['Wrong value!'])
def test_can_update_decimal_preference(self):
manager = registry.manager()
pref = manager.get_db_pref(section='type', name='cost')
url = reverse(
'api:global-detail',
kwargs={'pk': pref.preference.identifier()})
self.client.login(username='******', password="******")
response = self.client.patch(
url, json.dumps({'value': '111.11'}), content_type='application/json')
self.assertEqual(response.status_code, 200)
pref = manager.get_db_pref(section='type', name='cost')
self.assertEqual(pref.value, Decimal('111.11'))
def queue_payload(request: HttpRequest, uuid: str=None):
"""
Queue payload for processing.
"""
from socialhome.federate.tasks import receive_task # Circulars
try:
payload = request.body
preferences = global_preferences_registry.manager()
if preferences["admin__log_all_receive_payloads"]:
logger.debug("get_payload_from_request - Payload: %s", payload)
django_rq.enqueue(receive_task, payload, uuid=uuid)
return True
except Exception:
return False
def test_can_list_preferences(self):
manager = registry.manager()
url = reverse('api:global-list')
self.client.login(username='******', password="******")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
payload = json.loads(response.content.decode('utf-8'))
self.assertEqual(len(payload), len(registry.preferences()))
for e in payload:
pref = manager.get_db_pref(section=e['section'], name=e['name'])
serializer = serializers.GlobalPreferenceSerializer(pref)
self.assertEqual(pref.preference.identifier(), e['identifier'])
def test_invalidates_cache_when_saving_database_preference(self):
manager = registry.manager()
caches['default'].clear()
new_value = 'test_new_value'
key = manager.get_cache_key('test', 'TestGlobal1')
manager['test__TestGlobal1'] = new_value
pref = manager.get_db_pref(section='test', name='TestGlobal1')
self.assertEqual(pref.raw_value, new_value)
self.assertEqual(manager.cache.get(key), new_value)
pref.raw_value = 'reset'
pref.save()
self.assertEqual(manager.cache.get(key), 'reset')
def test_cache_invalidate_on_save(self):
manager = global_preferences_registry.manager()
model_instance = manager.create_db_pref(
section=None, name='no_section', value=False)
with self.assertNumQueries(0):
assert not manager['no_section']
manager['no_section']
model_instance.value = True
model_instance.save()
with self.assertNumQueries(0):
assert manager['no_section']
manager['no_section']
