def test_from_dbvalue_ftps(self):
reg = UrlTypeRegistry()
v = AnyUrlValue.from_db_value("ftps://www.example.com/", reg)
self.assertEqual(v.type_prefix, 'http') # http is the constant for external URL types
self.assertEqual(v.type_value, "ftps://www.example.com/")
self.assertEqual(unicode(v), "ftps://www.example.com/")
def test_resolve_anyurlfield(self):
root = SimpleTextPage.objects.create(title="Home", slug="home", status=SimpleTextPage.PUBLISHED, author=self.user, override_url='/')
RedirectNode.objects.create(
title="Redirect", status=RedirectNode.PUBLISHED, author=self.user,
parent=root, slug="redirect", new_url=AnyUrlValue('fluent_pages.urlnode', root.pk))
response = self.client.get('/redirect/')
self.assertRedirects(response, '/')
def test_from_dbvalue(self):
reg = UrlTypeRegistry()
v = AnyUrlValue.from_db_value("http://www.example.com/", reg)
self.assertEqual(v.type_prefix, 'http')
self.assertEqual(v.type_value, "http://www.example.com/")
self.assertEqual(unicode(v), "http://www.example.com/")
def test_from_dbvalue_ftps(self):
reg = UrlTypeRegistry()
v = AnyUrlValue.from_db_value("ftps://www.example.com/", reg)
self.assertEqual(v.type_prefix, 'http') # http is the constant for external URL types
self.assertEqual(v.type_value, "ftps://www.example.com/")
self.assertEqual(unicode(v), "ftps://www.example.com/")
def test_invalid_db_id(self):
reg = UrlTypeRegistry()
urltype = reg.register(PageModel)
v = AnyUrlValue(urltype.prefix, 999999, reg)
# Database state
self.assertEqual(v.type_value, 999999)
self.assertEqual(v.to_db_value(), 'any_urlfield.pagemodel://999999')
# Frontend
self.assertEqual(unicode(v), "#DoesNotExist") # Avoids frontend errors
# Programmer API's
self.assertIs(v.get_model(), PageModel)
self.assertRaises(PageModel.DoesNotExist, lambda: v.get_object())
self.assertFalse(v.exists())
def test_from_model(self):
page2 = RegPageModel.objects.create(pk=1, slug='foo2')
v = AnyUrlValue.from_model(page2)
self.assertEqual(v.url_type.prefix, 'any_urlfield.regpagemodel') # app_label.modelname
self.assertEqual(v.type_value, page2.id)
self.assertEqual(v.to_db_value(), 'any_urlfield.regpagemodel://1')
def test_from_dbvalue(self):
reg = UrlTypeRegistry()
v = AnyUrlValue.from_db_value("http://www.example.com/", reg)
self.assertEqual(v.type_prefix, 'http')
self.assertEqual(v.type_value, "http://www.example.com/")
self.assertEqual(unicode(v), "http://www.example.com/")
def test_bool_empty(self):
"""
Make sure empty value is treated as false.
"""
x = AnyUrlValue.from_db_value('')
self.assertFalse(1 if x else 0)
self.assertFalse(x.exists())
def test_db_pre_save(self):
"""
Make sure saving works
"""
obj = UrlModel(
url=AnyUrlValue.from_db_value('http://www.example.org/'))
obj.save()
self.assertTrue(obj.pk)
def test_pickle(self):
# See if regular fields can be pickled
v1 = AnyUrlValue.from_db_value("http://www.example.com/")
out = StringIO()
pickle.dump(v1, out)
# Unpickle.
out.seek(0)
v2 = pickle.load(out)
self.assertEqual(v1, v2) # Note that __eq__ is overridden for AnyUrlValue
def test_resolve_objects(self):
"""
Make sure ID values are properly stored and serialized.
"""
page3 = RegPageModel.objects.create(slug='foo3')
UrlModel.objects.create(url=AnyUrlValue.from_model(page3))
UrlModel.objects.create(url=AnyUrlValue.from_model(page3))
qs = list(UrlModel.objects.all())
with self.assertNumQueries(1):
AnyUrlField.resolve_objects(qs)
self.assertTrue(qs[0].url._resolved_objects)
self.assertTrue(qs[1].url._resolved_objects)
with self.assertNumQueries(0):
for obj in qs:
self.assertEqual(str(obj.url), '/modelform/')
self.assertTrue(obj.url.exists())
self.assertEqual(obj.url.get_object(), page3)
def test_from_db_value_ftps(self):
"""
Make sure other URLs are properly serialized.
"""
reg = UrlTypeRegistry()
v = AnyUrlValue.from_db_value("ftps://www.example.com/", reg)
self.assertEqual(v.type_prefix,
'http') # http is the constant for external URL types
self.assertEqual(v.type_value, "ftps://www.example.com/")
self.assertEqual(unicode(v), "ftps://www.example.com/")
def test_from_db_value_mailto(self):
"""
Test constructing the value from ID.
"""
reg = UrlTypeRegistry()
v = AnyUrlValue.from_db_value("mailto://[email protected]", reg)
self.assertEqual(v.type_prefix,
'http') # http is the constant for external URL types
self.assertEqual(v.type_value, "mailto://[email protected]")
self.assertEqual(unicode(v), "mailto://[email protected]")
def test_dumpdata(self):
"""
See if the dumpdata routines handle the value properly.
"""
page2 = RegPageModel.objects.create(slug='foo2')
UrlModel.objects.create(
url=AnyUrlValue.from_model(page2)
)
json_data = serializers.serialize("json", UrlModel.objects.all())
data = json.loads(json_data)
self.assertEqual(data, [{"fields": {"url": "any_urlfield.regpagemodel://1"}, "model": "any_urlfield.urlmodel", "pk": 1}])
def test_dumpdata(self):
"""
See if the dumpdata routines handle the value properly.
"""
page2 = RegPageModel.objects.create(slug='foo2')
UrlModel.objects.create(
url=AnyUrlValue.from_model(page2)
)
json_data = serializers.serialize("json", UrlModel.objects.all())
data = json.loads(json_data)
self.assertEqual(data, [{"fields": {"url": "any_urlfield.regpagemodel://1"}, "model": "any_urlfield.urlmodel", "pk": 1}])
def test_from_db_value_id(self):
reg = UrlTypeRegistry()
urltype = reg.register(PageModel)
page = PageModel.objects.create(slug='foo')
v = AnyUrlValue(urltype.prefix, page.id, reg)
# Database state
self.assertTrue(page.id)
self.assertEqual(urltype.prefix, 'any_urlfield.pagemodel') # app_label.modelname
self.assertEqual(v.type_prefix, urltype.prefix)
self.assertEqual(v.type_value, page.id)
self.assertEqual(v.to_db_value(), 'any_urlfield.pagemodel://1')
# Frontend
self.assertEqual(unicode(v), "/foo/") # fetches model and returns get_absolute_url()
# Programmer API's
self.assertIs(v.get_model(), PageModel)
self.assertEqual(v.get_object(), page)
self.assertTrue(v.exists())
def test_form_clean(self):
"""
Basic test of form validation.
"""
reg = UrlTypeRegistry()
reg.register(PageModel)
class ExampleForm(forms.Form):
url = any_urlfield.forms.AnyUrlField(url_type_registry=reg)
# Test 1: basic URL
form = ExampleForm(data={
'url_0': 'http',
'url_1': 'http://examle.org/',
})
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data['url'], AnyUrlValue.from_db_value('http://examle.org/'))
# Test 2: ID field
x = PageModel.objects.create(slug='foo')
form = ExampleForm(data={
'url_0': 'any_urlfield.pagemodel',
'url_1': '',
'url_2': str(x.pk),
})
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data['url'].to_db_value(), 'any_urlfield.pagemodel://{}'.format(x.pk))
self.assertEqual(form.cleaned_data['url'].get_object(), x)
expected = AnyUrlValue.from_db_value('any_urlfield.pagemodel://{}'.format(x.pk), url_type_registry=reg)
self.assertEqual(form.cleaned_data['url'], expected)
# Test 3: invalid ID
x = PageModel.objects.create(slug='foo')
form = ExampleForm(data={
'url_0': 'any_urlfield.pagemodel',
'url_1': '',
'url_2': '-1',
})
self.assertFalse(form.is_valid())
def test_valid_db_id(self):
"""
Make sure ID values are properly stored and serialized.
"""
reg = UrlTypeRegistry()
urltype = reg.register(PageModel)
page = PageModel.objects.create(slug='foo')
v = AnyUrlValue(urltype.prefix, page.id, reg)
# Database state
self.assertTrue(page.id)
self.assertEqual(urltype.prefix,
'any_urlfield.pagemodel') # app_label.modelname
self.assertEqual(v.type_prefix, urltype.prefix)
self.assertEqual(v.type_value, page.id)
self.assertEqual(v.to_db_value(), 'any_urlfield.pagemodel://1')
# Frontend
self.assertEqual(
unicode(v),
"/foo/") # fetches model and returns get_absolute_url()
# Programmer API's
self.assertIs(v.get_model(), PageModel)
self.assertEqual(v.get_object(), page)
self.assertTrue(v.exists())
def test_resolve_values(self):
"""
Make sure ID values are properly stored and serialized.
"""
reg = UrlTypeRegistry()
urltype = reg.register(PageModel)
page = PageModel.objects.create(slug='foo')
valid = AnyUrlValue(urltype.prefix, page.id, reg)
invalid = AnyUrlValue(urltype.prefix, 999999, reg)
with self.assertNumQueries(1):
AnyUrlValue.resolve_values([valid, invalid])
self.assertTrue(valid._resolved_objects)
self.assertTrue(invalid._resolved_objects)
with self.assertNumQueries(0):
self.assertEqual(valid.get_object(), page)
self.assertTrue(valid.exists())
self.assertRaises(PageModel.DoesNotExist,
lambda: invalid.get_object())
self.assertFalse(invalid.exists())
def test_pickle_registry(self):
reg = UrlTypeRegistry()
urltype = reg.register(PageModel)
page = PageModel.objects.create(slug='foo')
# See if custom registries can be pickled
v1 = AnyUrlValue(urltype.prefix, page.id, reg)
out = StringIO()
pickle.dump(v1, out)
# Unpickle.
out.seek(0)
v2 = pickle.load(out)
self.assertEqual(v1, v2) # Note that __eq__ is overridden for AnyUrlValue!
def test_modelform(self):
"""
Testing the model form creation
"""
class UrlModelForm(forms.ModelForm):
class Meta:
model = UrlModel
fields = ('url',)
# Test showing the form
instance = UrlModel.objects.create(url=AnyUrlValue.from_db_value('http://example.org/'))
form = UrlModelForm(instance=instance)
self.assertIsInstance(form.fields['url'], any_urlfield.forms.AnyUrlField)
form.as_p() # Walk through rendering code.
# Test saving URLs
form = UrlModelForm(instance=instance, data={
'url_0': 'http',
'url_1': 'http://example2.org/',
})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(str(instance.url), 'http://example2.org/')
# Test saving IDs
x = RegPageModel.objects.create(slug='modelform')
form = UrlModelForm(instance=instance, data={
'url_0': 'any_urlfield.regpagemodel',
'url_2': str(x.pk),
})
self.assertEqual(form.errors, {})
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(str(instance.url), '/modelform/')
# Test showing IDs
form = UrlModelForm(instance=instance)
assert form.initial['url'].to_db_value() == 'any_urlfield.regpagemodel://{}'.format(x.pk)
form.as_p() # Walk through rendering code.
def test_invalid_db_id(self):
reg = UrlTypeRegistry()
urltype = reg.register(PageModel)
v = AnyUrlValue(urltype.prefix, 999999, reg)
# Database state
self.assertEqual(v.type_value, 999999)
self.assertEqual(v.to_db_value(), 'any_urlfield.pagemodel://999999')
# Frontend
self.assertEqual(unicode(v), "#DoesNotExist") # Avoids frontend errors
# Programmer API's
self.assertIs(v.get_model(), PageModel)
self.assertRaises(PageModel.DoesNotExist, lambda: v.get_object())
self.assertFalse(v.exists())
def test_pickle_registry(self):
"""
Test pickle when the ``AnyUrlValue`` has a custom registry.
"""
reg = UrlTypeRegistry()
urltype = reg.register(PageModel)
page = PageModel.objects.create(slug='foo')
# See if custom registries can be pickled
v1 = AnyUrlValue(urltype.prefix, page.id, reg)
out = StringIO()
pickle.dump(v1, out)
# Unpickle.
out.seek(0)
v2 = pickle.load(out)
self.assertEqual(v1,
v2) # Note that __eq__ is overridden for AnyUrlValue!
# See that the object still works properly
self.assertEqual(v2.get_object(), page)
self.assertEqual(str(v2), '/foo/')
def test_invalid_db_id(self):
reg = UrlTypeRegistry()
urltype = reg.register(PageModel)
v = AnyUrlValue(urltype.prefix, 999999, reg)
# Database state
self.assertEqual(v.type_value, 999999)
self.assertEqual(v.to_db_value(), 'any_urlfield.pagemodel://999999')
# Frontend
from any_urlfield.models.values import logger
logger.warning("NOTE: The following statement will cause a log to output")
self.assertEqual(unicode(v), "#DoesNotExist") # Avoids frontend errors
# Programmer API's
self.assertIs(v.get_model(), PageModel)
self.assertRaises(PageModel.DoesNotExist, lambda: v.get_object())
self.assertFalse(v.exists())
def test_bool_empty(self):
x = AnyUrlValue.from_db_value('')
self.assertFalse(1 if x else 0)
self.assertFalse(x.exists())
def test_db_pre_save(self):
obj = UrlModel(url=AnyUrlValue.from_db_value('http://www.example.org/'))
obj.save()
self.assertTrue(obj.pk)
def test_bool_empty(self):
x = AnyUrlValue.from_db_value('')
self.assertFalse(1 if x else 0)
self.assertFalse(x.exists())
