def setup(self):
""" create clean local registries, make sure it's used globally """
super(BaseSpokeTemplateTest, self).setup()
self.reg = TemplateRegistry()
template_registry.set(self.reg)
self.root = Node.root()
def setup(self):
""" a registry to test on """
self.reg = TemplateRegistry()
class TestTemplateRegistry(object):
""" Test the registry """
def setup(self):
""" a registry to test on """
self.reg = TemplateRegistry()
def test_empty(self):
""" if it's empty """
assert self.reg.get(Type1) is None
def test_single_nodefault(self):
""" A single entry without default """
self.reg.register(Type1Type, "foo/bar", "foo bar")
assert self.reg.get(Type1) == [("foo/bar", "foo bar")]
assert self.reg.defaults.get(Type1) is None
def test_double(self):
""" Two entries for a Spoke """
self.reg.register(Type1Type, "foo/bar", "foo bar")
self.reg.register(Type1Type, "foo/bar2", "foo bar2")
assert self.reg.get(Type1) == [("foo/bar", "foo bar"),
("foo/bar2", "foo bar2")]
def test_empty_default(self):
""" An empty registry has no defaults """
assert self.reg.defaults.get(Type1) is None
def test_single_default(self):
""" It does if you set one """
self.reg.register(Type1Type, "foo/bar", "foo bar", default=True)
assert self.reg.get(Type1) == [("foo/bar", "foo bar")]
assert self.reg.defaults.get(Type1) == "foo/bar"
def test_valid(self):
""" Registered templates are valid """
self.reg.register(Type1Type, "foo/bar", "foo bar")
assert self.reg.valid_for_model(Type1, "foo/bar")
def test_invalid(self):
""" Unregistered aren't, not even when registered on different Spoke """
self.reg.register(Type1Type, "foo/bar", "foo bar")
self.reg.register(Type2Type, "foo/bar2", "foo bar2")
assert not self.reg.valid_for_model(Type1, "foo/bar2")
class BaseSpokeTemplateTest(BaseLocalRegistry):
"""
Test template related validation/behaviour
"""
def valid_data(self):
""" return formdata required for validation to succeed """
return {}
def valid_files(self):
""" return formdata files required for validation to succeed """
return {}
def setup(self):
""" create clean local registries, make sure it's used globally """
super(BaseSpokeTemplateTest, self).setup()
self.reg = TemplateRegistry()
template_registry.set(self.reg)
self.root = Node.root()
def test_empty(self, client):
""" An empty registry """
form = self.type.form(parent=self.root)
assert 'template' not in form.fields
model = self.type.model()
model.save()
assert self.type(model).view_template() == DEFAULT
def test_single(self, client):
""" An single template registered """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
form = self.type.form(parent=self.root)
assert 'template' in form.fields
assert form.fields['template'].choices == [('foo/bar', 'foo bar')]
model = self.type.model()
model.save()
assert self.type(model).view_template() == 'foo/bar'
def test_default(self, client):
""" If there's a default, it should be used """
model = self.type.model()
model.save()
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
self.reg.register(self.type, "foo/bar2", "foo bar", default=True)
self.reg.register(self.type, "foo/bar3", "foo bar", default=False)
assert self.type(model).view_template() == "foo/bar2"
def test_explicit(self, client):
""" unless there's an explicit other selection """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
self.reg.register(self.type, "foo/bar2", "foo bar", default=True)
self.reg.register(self.type, "foo/bar3", "foo bar", default=False)
model = self.type.model(template="foo/bar3")
model.save()
assert self.type(model).view_template() == "foo/bar3"
def test_form_excluded(self, client):
""" verify certain fields are excluded from the form """
form = self.type.form(parent=self.root, data={'template':"bar/foo"})
assert 'node' not in form.fields
assert 'meta_type' not in form.fields
assert 'owner' not in form.fields
assert 'classess' not in form.fields
def test_form_validation_fail(self, client):
""" Only registered templates are allowed """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
form = self.type.form(parent=self.root, data={'template':"bar/foo",
'language':'en'})
assert not form.is_valid()
assert 'template' in form.errors
def test_form_validation_language(self, client):
""" language is required """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
data = self.valid_data()
data['template'] = 'foo/bar'
form = self.type.form(parent=self.root, data=data)
assert not form.is_valid()
assert 'language' in form.errors
def test_form_validation_success(self, client):
""" In the end it should succeed """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
self.reg.register(self.type, "foo/bar2", "foo bar", default=True)
self.reg.register(self.type, "foo/bar3", "foo bar", default=False)
p = Node.root()
data = self.valid_data()
data['slug'] = 's'
data['title'] = 't'
data['template'] = 'foo/bar3'
data['language'] = 'en'
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['template'] == "foo/bar3"
def test_slug_exists(self, client):
""" a slug has been chosen that's already in use """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
p.add('foo')
data = self.valid_data()
data['slug'] = 'foo'
data['title'] = 't'
data['template'] = 'foo/bar'
data['language'] = 'en'
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert not form.is_valid()
assert 'slug' in form.errors
assert form.errors['slug'].pop() == 'Name in use' ## fragile
def test_slug_generate(self, client):
""" test slug generation """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data()
data['title'] = 'Hello World'
data['template'] = 'foo/bar'
data['language'] = 'en'
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
def test_slug_generate_dashes(self, client):
""" test slug generation """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data()
data['title'] = 'foo -- bar - cccc'
data['template'] = 'foo/bar'
data['language'] = 'en'
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug'] == "foo-bar-cccc"
def test_slug_generate_stopwords(self, client):
""" test slug generation """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data()
data['title'] = 'a world the are'
data['template'] = 'foo/bar'
data['language'] = 'en' ## use english stopwords
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug'] == "world"
def test_slug_generate_stopwords_empty(self, client):
""" test slug generation - only stopwords """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data()
data['title'] = 'are'
data['template'] = 'foo/bar'
data['language'] = 'en' ## use english stopwords
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug']
def test_slug_generate_stopwords_empty_dashes(self, client):
""" test slug generation - only stopwords """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data()
data['title'] = 'are - a - they'
data['template'] = 'foo/bar'
data['language'] = 'en' ## use english stopwords
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug']
def test_slug_generate_complex(self, client):
""" test slug generation """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data()
data['title'] = 'Hello World, What\'s up?'
data['slug'] = ''
data['template'] = 'foo/bar'
data['language'] = 'en'
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug'] == 'hello-world-what-s-up'
def test_slug_generate_conflict(self, client):
""" slug generation should not create duplicate slugs """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
p.add('foo')
data = self.valid_data()
data['slug'] = ''
data['title'] = 'foo'
data['template'] = 'foo/bar'
data['language'] = 'en'
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug'] == 'foo1'
def test_slug_reserved(self, client):
"""
An explicitly specified slug that matches a reserved word
should result in a validation error
"""
p = Node.root()
data = self.valid_data()
data['slug'] = 'foobar'
data['title'] = 'foo'
data['template'] = 'foo/bar'
data['language'] = 'en'
form = self.type.form(parent=p, data=data, files=self.valid_files(),
reserved=["foobar"])
assert not form.is_valid()
assert 'slug' in form.errors
assert form.errors['slug'].pop() == 'This is a reserved name' ## fragile
def test_slug_notreserved(self, client):
"""
An explicitly specified slug that doesn't match a reserved keyword
should be accepted.
"""
p = Node.root()
data = self.valid_data()
data['slug'] = 'foobar1'
data['title'] = 'foo'
data['template'] = 'foo/bar'
data['language'] = 'en'
form = self.type.form(parent=p, data=data, files=self.valid_files(),
reserved=["foobar"])
assert form.is_valid()
def test_slug_generate_reserved(self, client):
""" slug generation should not create reserved names """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data()
data['slug'] = ''
data['title'] = 'foo'
data['template'] = 'foo/bar'
data['language'] = 'en'
form = self.type.form(parent=p, data=data, files=self.valid_files(),
reserved=["foo"])
assert form.is_valid()
assert form.cleaned_data['slug'] == 'foo1'
def test_slug_generate_reserved_existing(self, client):
""" slug generation should not create reserved names or existing
names, combined """
self.reg.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
p.add('foo')
data = self.valid_data()
data['slug'] = ''
data['title'] = 'foo'
data['template'] = 'foo/bar'
data['language'] = 'en'
form = self.type.form(parent=p, data=data, files=self.valid_files(),
reserved=["foo1"])
assert form.is_valid()
assert form.cleaned_data['slug'] == 'foo2'
def test_context(self, client):
""" a context method can be stored in the registry """
def ctx(ins):
return dict(a="1")
self.reg.register(self.type, "foo/bar", "foo bar",
default=False, context=ctx)
context_method = self.reg.context.get((self.type, "foo/bar"))
assert context_method
assert context_method(None) == dict(a="1")
