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")