def setUpContent(self):
pat.login(self.portal, testing.SITE_ADMIN)
self.challenge = helpers.create_challenge(
self.challenges, "a-real-challenge")
for i in range(0, 20):
wsId = "workspace_" + str(i)
wsName = u"Workspace " + str(i)
ws = ws_helpers.create_workspace(self.workspaces,
wsId, title=wsName,
challenges=[relatify(self.challenge)])
modified(ws)
for i in range(0, 5):
projectId = 'project_' + str(i)
projectName = u"Prøjėçt " + str(i)
project = helpers.create_project(
self.workspaces, projectId,
title=projectName,
challenges=[relatify(self.challenge)],
description=u"A lengthy but interesting description",
goals=u"Lorem ipsum. Add goals here.")
ws_helpers.do_action_for(project, 'publish')
for j in range(0,3):
wsId = "project_workspace_" + str(i) + "_" + str(j)
wsName = u"Project-Workspace " + str(i) + " " + str(j)
ws = ws_helpers.create_workspace(self.workspaces,
wsId, title=wsName)
project.add_workspace(ws)
pat.logout()
def test_librarysearch_behavior_assigned(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
helpers.create_workspace(self.portal, 'workspace', title='Workspace')
workspace = self.portal['workspace']
self.assertTrue(library.ILibrarySearch.providedBy(workspace))
def setUpContent(self):
login(self.portal, testing.SITE_ADMIN)
self.project = helpers.create_project(
self.workspaces, 'project', title=u"Project")
self.project_admin = helpers.add_activated_student(
self.people, u"Hörbert M@ier")
self.project.addManager(self.project_admin.id)
self.project_admin2 = helpers.add_activated_student(
self.people, u"Administanator")
self.project.addManager(self.project_admin2.id)
self.ws = ws_helpers.create_workspace(self.workspaces,
"project_workspace_1", title=u"Project-Workspace")
self.ws_member = helpers.add_activated_student(
self.people, u"Workspace Member")
self.ws.addMember(self.ws_member.id)
self.project.add_workspace(self.ws)
self.ws2 = ws_helpers.create_workspace(self.workspaces,
"project_workspace_2", title=u"Project-Workspace")
self.ws_member2 = helpers.add_activated_student(
self.people, u"Another Workspace Member")
self.ws2.addMember(self.ws_member2.id)
self.project.add_workspace(self.ws2)
logout()
def setUpContent(self):
pat.login(self.portal, testing.SITE_ADMIN)
self.member = helpers.add_activated_cnrd_member(
self.people, "Test User 1", "student", uid="test_user_1")
self.c1 = helpers.create_challenge(
self.challenges, "challenge_1", title="Challenge 1")
self.c2 = helpers.create_challenge(
self.challenges, "challenge_2", title="Challenge 2")
self.ws1 = ws_helpers.create_workspace(
self.workspaces, 'ws_1', title=u"Workspace 1",
challenges=[RelationValue(self.c1.intid)])
self.ws1.addMember(self.member.id)
self.ws2 = ws_helpers.create_workspace(
self.workspaces, 'ws_2', title=u"Workspace 2",
challenges=[RelationValue(self.c2.intid)])
self.ws2.addMember(self.member.id)
self.project = helpers.create_project(
self.workspaces, 'project',
title=u"Prøjėçt",
description=u"A lengthy but interesting description",
goals=u"Lorem ipsum. Add goals here.")
ws_helpers.do_action_for(self.project, 'publish')
pat.logout()
def test_librarysearch_criteria_adapter(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
helpers.create_workspace(self.portal, 'workspace', title='Workspace')
workspace = self.portal['workspace']
adapters = getAdapters((workspace, ),
provided=library.ISearchCriteriaProvider)
self.assertIn('basic-criteria', dict(adapters))
def test_project_ws_invite(self):
pat.login(self.portal, testing.STUDENT)
new_ws = ws_helpers.create_workspace(self.workspaces,
"ws_to_be_added_to_project", title=u"Workspace for project")
pat.login(self.portal, self.project_admin.id)
login(self.driver, self.portal, username=self.project_admin.id,
password=testing.PASSWORD)
open(self.driver, self.project.absolute_url())
self.driver.find_elements_by_link_text("Preferences")[1].click()
self.navigate_links(["Members"])
widget = self.driver.find_element(By.CSS_SELECTOR, '#formfield-form-widgets-invited_workspaces-widgets-query input[type=text]')
widget.send_keys("for project")
suggestion = self.driver.find_element(By.CSS_SELECTOR, '.ac_results li')
suggestion.click()
self.driver.find_element_by_id('form-buttons-save').click()
# wait while the page loads
self.find_element_with_text("Changes saved")
transaction.commit()
# check if we see an invitation on the ws info page
open(self.driver, new_ws.absolute_url())
self.assertElementWithText(By.CSS_SELECTOR,
".project-invitation a.title>h1", self.project.title)
def setUpContent(self):
pat.login(self.portal, testing.SITE_ADMIN)
self.challenge = helpers.create_challenge(
self.challenges, "a-real-challenge")
self.ws_owner = helpers.add_activated_student(
self.people, u"Owen Owner")
self.ws_admin = helpers.add_activated_student(
self.people, u"Hörbert M@ier")
self.ws_member = helpers.add_activated_student(
self.people, u"Mandy Membr")
pat.login(self.portal, self.ws_owner.id)
self.ws = ws_helpers.create_workspace(
self.workspaces,
"workspace",
title=u"Workspace",
description=u"A lengthy but interesting description",
goals=u"Lorem ipsum. Add goals here.",
challenges=[relatify(self.challenge)])
ws_helpers.do_action_for(self.ws,
'publish-for-site-members-with-public-decription')
self.ws.addManager(self.ws_admin.id)
self.ws.addMember(self.ws_member.id)
pat.logout()
def setUp(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
self.ws = helpers.create_workspace(self.portal, 'ws', title=u"Workspace")
in_four_days = datetime.now() + timedelta(4)
self.task = helpers.create_task(self.ws, 't', title=u"Turbo Task",
deadline=in_four_days)
setRoles(self.portal, TEST_USER_ID, ())
def setUpContent(self):
login(self.portal, testing.SITE_ADMIN)
self.ws = ws_helpers.create_workspace(self.workspaces,
"test-workspace", title=u"Test Workspace")
self.links = []
self.links_by_group = {}
for i in range(1, 4):
group_label = u"Group {0}".format(i)
group_handle = add_group(self.ws, group_label)
link_id = "link-{0}".format(i)
link_title = u"Link {0}".format(i)
self.ws.invokeFactory('RichLink', link_id, title=link_title,
url="www.ixds.com", rmGroup=group_handle)
self.links.append(self.ws[link_id])
self.links_by_group[group_handle] = self.ws[link_id]
link_id = "link-without-group"
self.ws.invokeFactory('RichLink', link_id, title="Link without Group",
url="www.ixds.com")
self.misc_link = self.ws[link_id]
self.links.append(self.misc_link)
self.links_by_group['Miscellaneous'] = self.misc_link
add_group(self.ws, u"Empty Group")
logout()
def setUpContent(self):
pat.login(self.portal, testing.SITE_ADMIN)
self.ws = ws_helpers.create_workspace(
self.workspaces,
"workspace",
title=u"Workspace",
description=u"A lengthy but interesting description",
goals=u"Lorem ipsum. Add goals here.")
ws_helpers.do_action_for(self.ws,
'publish-for-site-members-with-public-decription')
self.links = []
for i in range(1, 4):
group_label = u"Group {0}".format(i)
group_handle = add_group(self.ws, group_label)
link_id = "link-{0}".format(i)
link_title = u"Link {0}".format(i)
self.ws.invokeFactory('RichLink', link_id, title=link_title,
url="www.ixds.com", rmGroup=group_handle)
self.links.append(self.ws[link_id])
link_id = "link-without-group"
self.ws.invokeFactory('RichLink', link_id, title="Link without Group",
url="www.ixds.com")
self.misc_link = self.ws[link_id]
self.links.append(self.misc_link)
add_group(self.ws, u"Empty Group")
pat.logout()
def test_project_ws_decline_invitation(self):
pat.login(self.portal, testing.STUDENT)
new_ws = ws_helpers.create_workspace(self.workspaces,
"ws_to_be_added_to_project", title=u"Workspace for project")
pat.login(self.portal, self.project_admin.id)
self.project.invite_workspace(new_ws)
login(self.driver, self.portal, username=testing.STUDENT,
password=testing.PASSWORD)
open(self.driver, new_ws.absolute_url())
# decline invitation
self.navigate_links(["Decline invitation"])
# check the portal message
msg = u"You have declined the invitation to ”{project_title}“."
self.assertElementWithText(By.CSS_SELECTOR, ".portalMessage",
msg.format(project_title=self.project.title))
# ensure that there is no invitation on the ws info page anymore
self.assertFalse(self.is_element_present(By.CSS_SELECTOR,
".project-invitation", wait=0))
# assert that the project isn't mentioned next to the ws title
self.assertFalse(self.is_element_present(By.CSS_SELECTOR,
"#page-title .workspace-project", wait=0))
def test_project_ws_accept_invitation(self):
pat.login(self.portal, testing.STUDENT)
new_ws = ws_helpers.create_workspace(self.workspaces,
"ws_to_be_added_to_project", title=u"Workspace for project")
pat.login(self.portal, self.project_admin.id)
self.project.invite_workspace(new_ws)
login(self.driver, self.portal, username=testing.STUDENT,
password=testing.PASSWORD)
open(self.driver, new_ws.absolute_url())
# accept invitation
self.navigate_links(["Join the project"])
# check if ws was added to project
self.assertElementWithText(By.CSS_SELECTOR, ".portalMessage",
u"“{0}” is now part of the project “{1}”.".format(new_ws.title, self.project.title))
page_title_project = self.find_element(
By.CSS_SELECTOR, "#page-title .workspace-project")
self.assertEquals(page_title_project.text, self.project.title)
page_title_project.click()
self.assertElementWithText(By.CSS_SELECTOR,
".project-workspaces h3>a", new_ws.title)
def setUpContent(self):
pat.login(self.portal, testing.SITE_ADMIN)
self.ws = ws_helpers.create_workspace(self.workspaces, 'ws', title=u"Workspace")
m1 = helpers.add_activated_student(self.people, u"Hörbert M@ier")
m2 = helpers.add_activated_student(self.people, u"Karl Heinz")
self.ws.addMember(m1.id)
self.ws.addMember(m2.id)
pat.logout()
def setUp(self):
login(self.portal, testing.SITE_ADMIN)
self.workspaces = self.portal.restrictedTraverse("workspaces")
self.ws = helpers.create_workspace(self.workspaces, 'ws', title=u"Workspace")
self.post = helpers.create_post(self.ws, 'p', title=u"Toast Post")
self.project = create_project(
self.workspaces, 'the-project', title=u"The Project")
self.project_post = helpers.create_post(
self.project, 'project-post', title=u"Project Post")
self.pws = helpers.create_workspace(self.workspaces,
"project_workspace", title=u"Project-Workspace")
self.project.add_workspace(self.pws)
self.pws_post = helpers.create_post(
self.pws, 'pws-post', title=u"PWS Post")
logout()
def test_poll_creation(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
workspaces = self.portal.restrictedTraverse("workspaces")
ws = helpers.create_workspace(workspaces, 'ws1', title=u"Workspace 1")
p = helpers.create_poll(ws, 'p1', title=u"Poll 1")
self.assertTrue('p1' in ws)
self.assertEqual(p, ws['p1'])
def test_reply_creation(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
ws = helpers.create_workspace(self.portal, 'ws1', title=u"Workspace 1")
p = helpers.create_post(ws, 'p1', title=u"Post 1")
p = helpers.publish_post(p)
r = helpers.create_reply(p, 'r1', title=u"Reply 1")
self.assertTrue('r1' in p)
self.assertEqual(r, p['r1'])
def setUpContent(self):
login(self.portal, testing.SITE_ADMIN)
self.ws = ws_helpers.create_workspace(self.workspaces, "test-workspace", title=u"Test Workspace")
link_id = "ixds-website"
self.ws.invokeFactory("RichLink", link_id, title="IXDS Website", url="www.ixds.com", rmAuthor="IXDS")
self.link = self.ws[link_id]
logout()
def test_poll_publishing(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
workspaces = self.portal.restrictedTraverse("workspaces")
ws = helpers.create_workspace(workspaces, 'ws1', title=u"Workspace 1")
p = helpers.create_poll(ws, 'p1', title=u"Poll 1")
fileuploadcapable.publish_post(p)
# polls are renamed when published:
self.assertTrue('poll-1' in ws)
self.assertEqual(p, ws['poll-1'])
def test_post_publishing(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
ws = helpers.create_workspace(self.portal, 'ws1', title=u"Workspace 1")
post = helpers.create_post(ws, 'post-1', title=u"Post 1")
post = helpers.publish_post(post)
self.assertEqual(post, ws['post-1'])
# the post should be published:
pw = getToolByName(self.portal, 'portal_workflow')
self.assertEqual(pw.getInfoFor(post, 'review_state'), 'published')
def setUpContent(self):
pat.login(self.portal, testing.MANAGER)
self.project = helpers.create_project(
self.workspaces, 'project',
title=u"Prøjėçt")
ws_helpers.do_action_for(self.project, 'publish')
self.ws = ws_helpers.create_workspace(self.workspaces,
"project-workspace", title=u"Project Workspace")
self.ws.addMember(testing.STUDENT)
self.project.add_workspace(self.ws)
pat.logout()
def test_thread_sort(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
ws = helpers.create_workspace(self.portal, 'ws1', title=u"Workspace 1")
t1 = helpers.publish_post(helpers.create_task(
ws, 't1', title=u"Task 1",
deadline=datetime.now() + timedelta(1)))
p1 = helpers.publish_post(helpers.create_post(
ws, 'p1', title=u"Post 1",
creation_date=DateTime() - 3))
t2 = helpers.publish_post(helpers.create_task(
ws, 't2', title=u"Task 2",
deadline=datetime.now() - timedelta(4)))
t3 = helpers.publish_post(helpers.create_task(
ws, 't3', title=u"Task 3",
deadline=datetime.now() - timedelta(2)))
p2 = helpers.publish_post(helpers.create_post(
ws, 'p2', title=u"Post 2",
creation_date=DateTime() - 1))
r1 = helpers.create_reply(
p2, 'r1', title=u"Reply 1",
creation_date=DateTime() - 1)
p3 = helpers.publish_post(helpers.create_post(
ws, 'p3', title=u"Post 3",
creation_date=DateTime()))
r2 = helpers.create_reply(
p2, 'r2', title=u"Reply 2",
creation_date=DateTime())
r3 = helpers.create_reply(
p2, 'r3', title=u"Reply 3",
creation_date=DateTime() + 1)
conversation = ws.unrestrictedTraverse('@@conversation')
post_brains = conversation.brains
result = []
for post_brain in post_brains:
post = post_brain.getObject()
result.append(post.id)
thread = post.unrestrictedTraverse('@@thread')
for reply_brain in thread.replies:
result.append(reply_brain.getId)
expected = [t1, p3, p2, r1, r2, r3, t3, p1, t2]
expected = [x.id for x in expected]
self.assertEqual(result, expected)
def test_browse_posts(self):
"""A minimal functional test for posts."""
setRoles(self.portal, TEST_USER_ID, ('Manager',))
# create, publish and join a workspace:
ws = helpers.create_workspace(self.portal, 'ws1', title=u"Workspace 1")
ws.addMember(SITE_MEMBER)
import transaction
transaction.commit()
browser = Browser(self.app)
browser.handleErrors = False
# Log in as a user
browser.addHeader(
'Authorization',
'Basic %s:%s' % (SITE_MEMBER, PASSWORD,))
# go to conversation:
browser.open("%s/conversation" % ws.absolute_url())
# create another post:
browser.getLink(text='Post').click()
title = browser.getControl(name='form.widgets.title')
title.value = "The Post"
text = browser.getControl(name='form.widgets.text')
text.value = "<p>Blah, blah, test.</p>"
browser.getControl(name='form.buttons.save').click()
self.assertIn('the-post', ws)
post = ws['the-post']
# publish the post:
# TODO: we cheat because there is no publishing interface available to
# normal users.
helpers.publish_post(post)
# the post should be published:
pw = getToolByName(self.portal, 'portal_workflow')
self.assertEqual(pw.getInfoFor(post, 'review_state'), 'published')
# we should be send to the posts view now:
self.assertTrue("The Post" in browser.contents)
self.assertTrue("Blah, blah, test." in browser.contents)
# TODO: edit the post:
browser.getLink(text='Edit')
def setUpContent(self):
pat.login(self.portal, testing.SITE_ADMIN)
self.project = helpers.create_project(
self.workspaces, 'project', title=u"Project")
self.project_admin = helpers.add_activated_student(
self.people, u"Herbert Meier")
self.project.addManager(self.project_admin.id)
self.wss = []
for i in range(1, self.number_of_wss + 1):
ws_id = "workspace_{0}".format(i)
ws_title = u"Workspace {0}".format(i)
ws = ws_helpers.create_workspace(
self.workspaces, ws_id, title=ws_title)
ws_member = helpers.add_activated_student(
self.people, u"Workspace {0} Member".format(i))
ws.addMember(ws_member.id)
ws_manager = helpers.add_activated_student(
self.people, u"Workspace {0} Manager".format(i))
ws.addManager(ws_manager.id)
self.project.add_workspace(ws)
self.wss.append(ws)
self.groups = []
self.links = []
def link_params(containers):
for i, container in enumerate(containers):
yield (i*2+1, container, False)
yield (i*2+2, container, True)
for i, parent, featured in link_params([self.project] + self.wss):
label_xtras = u"({0}{1})".format(
parent.title, featured and ", featured" or "")
group_label = u"Group {0} {1}".format(i, label_xtras)
group_handle = add_group(parent, group_label)
self.groups.append((group_handle, group_label))
self.links.append(
self.create_link(
parent,
" ".join(("Link", str(i), label_xtras)),
rmGroup=group_handle,
project_featured=featured))
pat.logout()
def test_invite_workspace_to_project_decline(self):
login(self.portal, testing.STUDENT)
new_ws = ws_helpers.create_workspace(
self.workspaces, "ws_to_be_added_to_project")
login(self.portal, self.project_admin.id)
self.project.invite_workspace(new_ws)
login(self.portal, testing.STUDENT)
# decline invitation
invitations_view = new_ws.restrictedTraverse("@@project_invitations")
invitations_view.request["decline"] = str(self.project.intid)
invitations_view.update()
# check if ws was NOT added to project
self.assertNotIn(new_ws.intid,
[r.to_id for r in self.project.workspace_relations])
def test_invite_workspace_to_project(self):
login(self.portal, testing.STUDENT)
new_ws = ws_helpers.create_workspace(self.workspaces,
"ws_to_be_added_to_project", title=u"Workspace for project")
login(self.portal, self.project_admin.id)
self.project.invite_workspace(new_ws)
login(self.portal, testing.STUDENT)
# check if we recieved an invitation (ws-info)
invitations_view = new_ws.restrictedTraverse("@@project_invitations")
invitations = invitations_view.objects
self.assertEquals(invitations, [self.project])
# TODO check if we recieved an invitation (email)
# accept invitation
invitations_view.request["accept"] = str(self.project.intid)
invitations_view.update()
# check if ws was added to project
msg = IStatusMessage(self.request).show()[-1].message
self.assertEquals(msg, u"“Workspace for project” is now part of the project “Project”.")
self.assertIn(new_ws.intid,
[r.to_id for r in self.project.workspace_relations],
u"Project ws relation missing after joining.")
# the relation should also be refected in the catalog
catalog = component.getUtility(ICatalog)
relations = catalog.findRelations(dict(
to_id=new_ws.intid,
from_interfaces_flattened=interfaces.IProject,
from_attribute='workspace_relations'))
self.assertIn(self.project.intid, [r.from_id for r in relations],
u"Project ws relation not in catalog after joining.")
# but the invitation should be gone
invitations = catalog.findRelations(dict(
to_id=new_ws.intid,
from_interfaces_flattened=interfaces.IProject,
from_attribute='invited_workspaces'))
self.assertNotIn(self.project.intid, [i.from_id for i in invitations],
u"Project ws still invited after joining.")
def test_post_creation_and_deletion(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
ws = helpers.create_workspace(self.portal, 'ws1', title=u"Workspace 1")
ws.addMember(testing.SITE_MEMBER)
login(self.portal, testing.SITE_MEMBER)
# create
helpers.create_post(ws, 'post-1', title=u"Post 1")
self.assertTrue('post-1' in ws)
# delete
newInteraction()
delete_view = ws['post-1'].restrictedTraverse('@@delete_confirmation')
delete_view.request["form.button.Delete"] = 1
delete_view.update()
endInteraction()
self.assertFalse('post-1' in ws)
def setUpContent(self):
pat.login(self.portal, testing.MANAGER)
self.project = helpers.create_project(
self.workspaces, 'project',
title=u"Prøjėçt",
description=u"A lengthy but interesting description",
goals=u"Lorem ipsum. Add goals here.")
ws_helpers.do_action_for(self.project, 'publish')
self.ws = ws_helpers.create_workspace(self.workspaces,
"project-workspace", title=u"Project Workspace")
self.project.add_workspace(self.ws)
self.post_text = richtextify(
u"<p>" + 40*u"<a href="">Rich</a> Text " + u"</p>")
self.project.invokeFactory(
'ixds.Post', "post-in-project", project_featured=True,
title="Post in project",
text=self.post_text)
self.project_post = self.project["post-in-project"]
ws_helpers.do_action_for(self.project_post, 'publish')
self.ws.invokeFactory(
'ixds.Post', "post-in-workspace", project_featured=True,
title="Post in workspace",
text=self.post_text)
self.workspace_post = self.ws["post-in-workspace"]
ws_helpers.do_action_for(self.workspace_post, 'publish')
self.project.invokeFactory(
'ixds.Post', "local-project-post", project_featured=False,
title="Local Project-Post",
text=self.post_text)
self.local_project_post = self.project["local-project-post"]
ws_helpers.do_action_for(self.local_project_post, 'publish')
self.workspace_post.invokeFactory(
'ixds.Reply', "reply-in-workspace",
title="Reply in workspace",
text=self.post_text)
pat.logout()
def test_project_featured_poll_creation(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
workspaces = self.portal.restrictedTraverse("workspaces")
ws = helpers.create_workspace(workspaces, 'ws1', title=u"Workspace 1")
helpers.create_poll(ws, 'p3', title=u"Poll 3",
description=u"lucky poll",
options=["42", "88", "111"],
deadline="2016-07-04",
project_featured=True,
anonymous=False)
self.assertTrue('p3' in ws)
newPoll = ws['p3'];
self.assertEqual(newPoll.id, 'p3');
self.assertEqual(newPoll.title, u"Poll 3");
self.assertEqual(newPoll.description, u"lucky poll");
self.assertEqual(newPoll.options, ["42", "88", "111"]);
self.assertEqual(newPoll.deadline, "2016-07-04");
self.assertEqual(newPoll.project_featured, True);
self.assertEqual(newPoll.anonymous, False);
def setUpContent(self):
pat.login(self.portal, testing.TEACHER)
self.ws = ws_helpers.create_workspace(self.workspaces,
"project_workspace", title=u"Project-Workspace")
pat.login(self.portal, testing.SITE_ADMIN)
self.challenge = helpers.create_challenge(
self.challenges, "a-real-challenge")
self.project = helpers.create_project(
self.workspaces, 'project',
title=u"Prøjėçt",
description=u"A lengthy but interesting description",
goals=u"Lorem ipsum. Add goals here.")
ws_helpers.do_action_for(self.project, 'publish')
self.project_admin = helpers.add_activated_student(
self.people, u"Hörbert M@ier")
self.project.addManager(self.project_admin.id)
self.project.add_workspace(self.ws)
self.project_member = helpers.add_activated_student(
self.people, u"Memberus Projectis")
self.ws.addMember(self.project_member.id)
pat.logout()
def test_batching(self):
setRoles(self.portal, TEST_USER_ID, ('Manager',))
ws = helpers.create_workspace(self.portal, 'ws1', title=u"Workspace 1")
for i in range(23):
helpers.create_post(
ws, 'p%d' % i, title=u"Post %d" % i)
conversation = ws.unrestrictedTraverse('@@conversation')
expected = ['p%d' % i for i in range(23)]
brains = conversation.brains
self.assertEqual([x.getId for x in brains], expected)
batch = conversation.getBatch(b_start=0, b_size=10, b_orphan=0)
self.assertEqual([x.getId for x in batch], expected[:10])
batch = conversation.getBatch(b_start=10, b_size=10, b_orphan=0)
self.assertEqual([x.getId for x in batch], expected[10:20])
batch = conversation.getBatch(b_start=10, b_size=10, b_orphan=3)
self.assertEqual([x.getId for x in batch], expected[10:23])
