def test_content_can_change_its_designated_websites(self):
from woost.models import Website, Publishable
index = Publishable.per_website_publication_index
p1 = Publishable()
p1.insert()
w1 = Website()
w1.insert()
w2 = Website()
w2.insert()
assert list(index.items()) == [(None, p1.id)]
p1.websites = [w1]
assert list(index.items()) == [(w1.id, p1.id)]
p1.websites = [w2]
assert list(index.items()) == [(w2.id, p1.id)]
p1.websites = [w1, w2]
assert set(index.items()) == set([(w1.id, p1.id), (w2.id, p1.id)])
p1.websites = []
assert list(index.items()) == [(None, p1.id)]
def test_index_is_updated_after_deleting_website(self):
from woost.models import Website, Publishable
index = Publishable.per_website_publication_index
w1 = Website()
w1.insert()
w2 = Website()
w2.insert()
p1 = Publishable()
p1.websites = [w1]
p1.insert()
p2 = Publishable()
p2.websites = [w1, w2]
p2.insert()
w1.delete()
assert set(index.items()) == set([(None, p1.id), (w2.id, p2.id)])
w2.delete()
assert set(index.items()) == set([(None, p1.id), (None, p2.id)])
def test_permission_expression(self):
from woost.models import (Item, Publishable, User, ReadPermission,
PermissionExpression)
self.everybody_role.permissions.append(
ReadPermission(matching_items={
"type": "woost.models.publishable.Publishable"
},
authorized=True))
i1 = Item()
i2 = Item()
d1 = Publishable()
d2 = Publishable()
i1.insert()
i2.insert()
d1.insert()
d2.insert()
results = set(
Item.select(
filters=[PermissionExpression(User(), ReadPermission)]))
assert results == set([d1, d2])
def test_unlink(self):
template = list(Template.select())[0]
publishable = Publishable()
publishable.set("enabled", True, "en")
publishable.template = template
publishable.insert()
datastore.commit()
browser.open("/en/cms/content/%d/fields" % publishable.id)
admin_login()
assert not browser.is_element_present(
"css=.template_field .control .new")
assert not browser.is_element_present(
"css=.template_field .control .delete")
browser.click("css=.template_field .control .unlink")
browser.wait_for_page_to_load(10000)
val = browser.get_value("edited_item_template")
assert not browser.get_value("edited_item_template")
def test_translation_enabled(self):
from cocktail.translations import language_context
from woost.models import (Publishable, ReadPermission,
ReadTranslationPermission)
self.everybody_role.permissions.append(
ReadPermission(matching_items={
"type": "woost.models.publishable.Publishable"
}))
self.everybody_role.permissions.append(ReadTranslationPermission())
self.config.languages = ["en"]
self.config.published_languages = []
with language_context("en"):
a = Publishable()
a.per_language_publication = True
a.translation_enabled = True
a.insert()
b = Publishable()
b.per_language_publication = True
b.translation_enabled = False
b.insert()
c = Publishable()
c.per_language_publication = True
c.translation_enabled = True
c.insert()
d = Publishable()
d.per_language_publication = True
d.set("translation_enabled", True, "de")
d.insert()
e = Publishable()
e.per_language_publication = False
e.enabled = True
e.insert()
accessible = self.accessible_items()
print a in accessible
print b in accessible
print c in accessible
print d in accessible
print e in accessible
assert self.accessible_items() == set([a, c, e])
self.config.published_languages = ["en"]
assert self.accessible_items() == set([a, c, e])
with language_context("de"):
self.config.published_languages = ["de"]
assert self.accessible_items() == set([d, e])
def test_content_is_not_indexed_until_website_is_inserted(self):
from woost.models import Website, Publishable
index = Publishable.per_website_publication_index
w1 = Website()
p1 = Publishable()
p1.insert()
p1.websites = [w1]
assert (w1.id, p1.id) not in list(index.items())
def test_enabled(self):
from woost.models import Publishable, ReadPermission
self.everybody_role.permissions.append(
ReadPermission(matching_items={
"type": "woost.models.publishable.Publishable"
}))
a = Publishable()
a.enabled = True
a.insert()
b = Publishable()
b.enabled = False
b.insert()
c = Publishable()
c.enabled = True
c.insert()
d = Publishable()
d.enabled = False
d.insert()
assert self.accessible_items() == set([a, c])
def test_current(self):
from woost.models import Publishable, ReadPermission
from datetime import datetime, timedelta
self.everybody_role.permissions.append(
ReadPermission(matching_items={
"type": "woost.models.publishable.Publishable"
}))
now = datetime.now()
a = Publishable()
a.enabled = True
a.insert()
b = Publishable()
b.enabled = True
b.start_date = now
b.end_date = now + timedelta(days=1)
b.insert()
c = Publishable()
c.enabled = True
c.start_date = now + timedelta(days=1)
c.insert()
d = Publishable()
d.enabled = True
d.end_date = now - timedelta(days=1)
d.insert()
assert self.accessible_items() == set([a, b])
def test_content_is_published_for_all_websites_by_default(self):
from woost.models import Website, Publishable
index = Publishable.per_website_publication_index
w1 = Website()
w1.insert()
p1 = Publishable()
p1.insert()
assert list(index.items()) == [(None, p1.id)]
p2 = Publishable()
p2.insert()
assert set(index.items()) == set([(None, p1.id), (None, p2.id)])
def test_translation_permitted(self):
from cocktail.translations import language_context
from woost.models import (Publishable, ReadPermission,
ReadTranslationPermission, set_current_user)
set_current_user(self.user)
self.everybody_role.permissions.append(
ReadPermission(matching_items={
"type": "woost.models.publishable.Publishable"
}))
self.everybody_role.permissions.append(
ReadTranslationPermission(matching_languages=["ca", "es"]))
self.everybody_role.permissions.append(
ReadTranslationPermission(matching_languages=["en"],
authorized=False))
self.config.languages = ["ca", "es", "en"]
self.config.published_languages = []
a = Publishable()
a.per_language_publication = True
a.insert()
b = Publishable()
b.per_language_publication = False
b.insert()
with language_context("ca"):
a.translation_enabled = True
assert a.is_accessible()
assert b.is_accessible()
assert self.accessible_items() == set([a, b])
for language in "es", "en", "de":
with language_context(language):
assert not a.is_accessible()
assert b.is_accessible()
assert self.accessible_items() == set([b])
def test_index_is_updated_after_deleting_publishable(self):
from woost.models import Website, Publishable
index = Publishable.per_website_publication_index
p1 = Publishable()
p1.insert()
p1.delete()
assert (None, p1.id) not in list(index.items())
w1 = Website()
w1.insert()
p2 = Publishable()
p2.websites = [w1]
p2.insert()
p2.delete()
assert not list(index.items())
def test_allowed(self):
from woost.models import Publishable, ReadPermission
a = Publishable()
a.enabled = True
a.insert()
b = Publishable()
b.enabled = True
b.insert()
self.everybody_role.permissions.append(
ReadPermission(
matching_items={
"type": "woost.models.publishable.Publishable",
"filter": "member-id",
"filter_operator0": "ne",
"filter_value0": str(b.id)
}))
assert self.accessible_items() == set([a])