def cmfCreateNews(self, parent_url):
# return the doc_url
lipsum = Lipsum()
doc_id = lipsum.getUniqWord().lower()
params = [["type_name", "News Item"], ["id", doc_id], ["add", "Add"]]
self.post("%s/folder_factories" % parent_url,
params,
description="Create an empty news")
params = [["allow_discussion", "default"],
["title", lipsum.getSubject()],
["description:text",
lipsum.getParagraph()], ["subject:lines",
lipsum.getWord()],
["format", "text/plain"],
["change_and_view", "Change and View"]]
doc_url = "%s/%s" % (parent_url, doc_id)
self.post("%s/metadata_edit_form" % doc_url,
params,
description="Set metadata")
self.assert_('Metadata changed.' in self.getBody())
params = [["text_format", "plain"],
["description:text",
lipsum.getParagraph()], ["text:text",
lipsum.getMessage()],
["change_and_view", "Change and View"]]
self.post("%s/newsitem_edit_form" % doc_url,
params,
description="Set news content")
self.assert_('News Item changed.' in self.getBody())
return doc_url
def test_buy_tickets(self):
get_request = self.get(self.site_url + '/get')
self.assert_(get_request.code == 200, "expecting a 200")
item = Lipsum().getWord()
id_ = Lipsum().getUniqWord()
post_request = self.post(self.site_url + '/post',
params=[['item', item],
['id', id_]])
self.assert_(post_request.code == 200, "expecting a 200")
put_request = self.put(self.site_url + '/put',
params=[['item', item],
['id', id_]])
self.assert_(put_request.code == 200, "expecting a 200")
def setUp(self):
"""Setting up test."""
self.server_url = self.conf_get('main', 'url')
credential_host = self.conf_get('credential', 'host')
credential_port = self.conf_getInt('credential', 'port')
self.username, self.pwd = xmlrpc_get_credential(
credential_host, credential_port, "group1")
self.lipsum = Lipsum()
def test_exampleGuestBook(self):
server_url = self.zope_url
self.get("%s/Examples/GuestBook" % server_url)
server_url = self.zope_url
self.setBasicAuth(self.admin_id, self.admin_pwd)
lipsum = Lipsum()
self.get("%s/Examples/GuestBook/addEntry.html" % server_url)
params = [["guest_name", lipsum.getWord().capitalize()],
["comments", lipsum.getParagraph()]]
self.post("%s/Examples/GuestBook/addEntry" % server_url, params)
self.clearBasicAuth()
def test_basic_navigation(self):
# The description should be set in the configuration file
server_url = self.server_url
# begin of test ---------------------------------------------
# /var/folders/0n/nbbtwsqs6zl3z6k91czbkkvr0000gn/T/tmp6np8jv_funkload/watch0001.request
self.get(server_url + "/", description="Get /")
self.assert_('Typography' in self.getBody(),
"Home page loading failure")
# /var/folders/0n/nbbtwsqs6zl3z6k91czbkkvr0000gn/T/tmp6np8jv_funkload/watch0042.request
self.get(server_url + "/news", description="Get /news")
self.assert_('List of news' in self.getBody(),
"News list loading failure")
# store the number of news
# nb_news_before = len(self.listHref(content_pattern='View article'))
# /var/folders/0n/nbbtwsqs6zl3z6k91czbkkvr0000gn/T/tmp6np8jv_funkload/watch0078.request
self.get(server_url + "/news/create", description="Get /news/create")
self.assert_('Create a news item' in self.getBody(),
"News form loading failure")
# /var/folders/0n/nbbtwsqs6zl3z6k91czbkkvr0000gn/T/tmp6np8jv_funkload/watch0097.request
title = Lipsum().getSubject(uniq=True)
self.post(server_url + "/news/create",
params=[['title', title], ['text',
Lipsum().getParagraph()],
['submit', 'Create news item']],
description="Post /news/create")
self.assert_('Congrats' in self.getBody(), "News creation failure")
# /var/folders/0n/nbbtwsqs6zl3z6k91czbkkvr0000gn/T/tmp6np8jv_funkload/watch0099.request
self.get(server_url + "/news", description="Get /news")
# do we have one more news ?
news_links = self.listHref(content_pattern='View article')
# nb_news_after = len(news_links)
# self.assert_(nb_news_after == nb_news_before + 1, "New news not listed")
# /var/folders/0n/nbbtwsqs6zl3z6k91czbkkvr0000gn/T/tmp6np8jv_funkload/watch0101.request
last_news = news_links[-1]
self.get(server_url + "/%s" % last_news, description="Get new news")
class Webengine(FunkLoadTestCase):
"""Basic test of nuxeo webengine"""
server_url = None
_lipsum = Lipsum()
ws_title = "FLNXTEST Webengine workspace"
ws_id = "FLNXTEST Webengine works"
dir_title = "FLNXTEST Page folder"
dir_id = "FLNXTEST Page folder"
tag = "FLNXTEST"
def setUp(self):
self.server_url = self.conf_get('main', 'url')
self.credential_host = self.conf_get('credential', 'host')
self.credential_port = self.conf_getInt('credential', 'port')
self.cred_admin = xmlrpc_get_credential(self.credential_host,
self.credential_port, 'admin')
self.cred_member = xmlrpc_get_credential(self.credential_host,
self.credential_port,
'members')
self.logd("setUp")
def test_testWebengine(self):
# begin of test ---------------------------------------------
p = WebenginePage(self)
(p.home().login(*self.cred_admin).admin().user_management())
ws_path = '/'.join(('workspaces', self.ws_id))
if p.viewDocumentPath(ws_path, raiseOn404=False) is None:
p.createDocument('workspaces', self.ws_title, doc_type="Workspace")
parent = '/'.join((ws_path, self.dir_id))
if p.viewDocumentPath(parent, raiseOn404=False) is None:
p.createDocument(ws_path, self.dir_title, doc_type="Folder")
p.viewDocumentPath(parent)
p.deleteDocument(ws_path)
p.createUser('john', 'tiger', groups='members')
p.logout()
(p.home().login('john', 'tiger').home().logout())
(p.home().login(*self.cred_admin).deleteUser('john').logout())
# end of test -----------------------------------------------
def tearDown(self):
"""Setting up test."""
self.logd("tearDown.")
def test_05_verifyUsers(self):
server_url = self.server_url
user_mail = self.conf_get('test_05_verifyUsers', 'mail')
lipsum = Lipsum()
self.setBasicAuth(*self.cred_admin)
for user_id, user_pwd in xmlrpc_list_credentials(
self.credential_host, self.credential_port, 'FL_Member'):
params = [["member_id", user_id], ["member_email", user_mail],
["password", user_pwd], ["confirm", user_pwd],
["add", "Register"]]
self.post("%s/join_form" % server_url, params)
html = self.getBody()
self.assert_(
'Member registered' in html
or 'The login name you selected is already in use' in html,
"Member %s not created" % user_id)
self.clearBasicAuth()
class CMF(NuxeoTestCase):
"""CMF
This test use a configuration file CMF.conf.
"""
_lipsum = Lipsum()
usersWithTasks = []
def setUp(self):
"""Setting up test."""
self.logd("setUp")
NuxeoTestCase.setUp(self)
self.memberList = xmlrpc_list_credentials(self.credential_host,
self.credential_port,
'members')
def createCaseItem(self, user, passwd, case, caseItem, pathToPdf):
caseItemId = MailboxPage(self).login(
user,
passwd).viewDraftTab().createCaseItem(case, caseItem, pathToPdf)
MailboxPage(self).logout()
return caseItemId
class CMF(NuxeoTestCase):
"""CMF
This test use a configuration file CMF.conf.
"""
_lipsum = Lipsum()
usersWithTasks = []
def setUp(self):
"""Setting up test."""
self.logd("setUp")
NuxeoTestCase.setUp(self)
self.memberList = xmlrpc_list_credentials(self.credential_host,
self.credential_port,
'members')
def test_CMF(self):
users = self.memberList
for i in users:
MailboxPage(self).login(i[0], i[1]).logout()
def tearDown(self):
"""Setting up test."""
self.logd("tearDown.\n")
class NuxeoTestCase(FunkLoadTestCase):
server_url = None
_lipsum = Lipsum()
monitor_page = 0
def setUp(self):
self.server_url = self.conf_get('main', 'url')
self.credential_host = self.conf_get('credential', 'host')
self.credential_port = self.conf_getInt('credential', 'port')
self.cred_admin = xmlrpc_get_credential(self.credential_host,
self.credential_port, 'admin')
self.cred_member = xmlrpc_get_credential(self.credential_host,
self.credential_port,
'members')
self.pglog_file = self.conf_get('main', 'pglog', '')
self.log_dir = self.conf_get('main', 'log_dir', '')
if not self.in_bench_mode:
self.monitor_page = self.conf_getInt('main', 'monitor_page', '0')
if self.monitor_page:
self.logd("Tracing pg and jvm heap")
if os.path.exists(self.pglog_file):
self.pglogf = open(self.pglog_file)
self.pglogf.seek(0, 2)
else:
self.pglog_file = None
self.logd("setUp")
def pglog(self):
"""Save the PostgreSQL log for the previous request, logtail."""
if self.pglog_file is None:
return
# wait for async processing
sleep(4)
logfile = os.path.join(
self.log_dir, "pg-%s-%3.3d.log" % (self.test_name, self.steps))
lf = open(logfile, "w")
while True:
data = self.pglogf.read()
if data:
lf.write(data)
else:
break
lf.close()
def performFullGC(self):
"""Ask monitorctl.sh to perform a full GC."""
if self.monitorctl_file is not None:
command(self.monitorctl_file + " invoke-fgc")
def performHeapHistoStart(self):
"""Perform a heap histo of page."""
self.performHeapHisto("%s-%3.3d-before" %
(self.test_name, self.steps + 1))
def performHeapHistoEnd(self):
"""Perform a heap histo of page."""
self.performHeapHisto("%s-%3.3d-end" % (self.test_name, self.steps))
def performHeapHisto(self, tag):
"""Perform a heap histo."""
self.monitorctl_file = self.conf_get('main', 'monitorctl_file', '')
if not os.path.exists(self.monitorctl_file):
return
log_dir = self.conf_get('main', 'log_dir', '')
logfile = os.path.join(log_dir, "hh-%s.txt" % tag)
status, output = command(self.monitorctl_file + " heap-histo")
lf = open(logfile, "w")
lf.write(output)
lf.close()
def getLastJsfState(self):
return extractJsfState(self.getBody())
def get(self, url, params=None, description=None, ok_codes=None):
# Override to save pg logs and heap histo
if self.monitor_page:
self.performFullGC()
self.performHeapHistoStart()
ret = FunkLoadTestCase.get(self, url, params, description, ok_codes)
if self.monitor_page:
self.pglog()
self.performHeapHistoEnd()
return ret
def post(self, url, params=None, description=None, ok_codes=None):
# Override to save pg logs and heap histo
if self.monitor_page:
self.performFullGC()
self.performHeapHistoStart()
ret = FunkLoadTestCase.post(self, url, params, description, ok_codes)
if self.monitor_page:
self.pglog()
self.performHeapHistoEnd()
return ret
def test_critical_path(self):
server_url = self.server_url
self.get(server_url, description='Get root URL')
self.get(server_url + "/users/sign_up",
description="View the user signup page")
auth_token = extract_token(
self.getBody(), 'name="authenticity_token" type="hidden" value="',
'"')
email = Lipsum().getUniqWord() + "@" + Lipsum().getWord() + ".com"
self.post(self.server_url + "/users",
params=[['user[email]', email],
['user[password]', 'alphabet'],
['user[password_confirmation]', 'alphabet'],
['authenticity_token', auth_token],
['commit', 'Sign up']],
description="Create New User")
self.get(server_url + "/communities/new",
description="View the new communities page")
auth_token = extract_token(
self.getBody(), 'name="authenticity_token" type="hidden" value="',
'"')
community_name = Lipsum().getSentence()
self.post(self.server_url + "/communities",
params=[['community[name]', community_name],
['authenticity_token', auth_token],
['commit', 'Create Community']],
description="Create New Community")
last_url = self.getLastUrl()
created_community_id = last_url.split('/')[-1]
self.get(server_url + "/communities/" + created_community_id,
description="View the created community page")
self.get(server_url + "/submissions/new",
description="View the new submissions page")
auth_token = extract_token(
self.getBody(), 'name="authenticity_token" type="hidden" value="',
'"')
submission_title = Lipsum().getSentence()
submission_url = "http://www." + Lipsum().getWord() + Lipsum(
).getUniqWord() + ".com/"
self.post(self.server_url + "/submissions",
params=[['submission[title]', submission_title],
['submission[url]', submission_url],
['submission[community_id]', created_community_id],
['authenticity_token', auth_token],
['commit', 'Create Submission']],
description="Create New Submission")
last_url = self.getLastUrl()
created_submission_id = last_url.split('/')[-1]
self.get(server_url + "/comments/new",
description="View the new comments page")
auth_token = extract_token(
self.getBody(), 'name="authenticity_token" type="hidden" value="',
'"')
comment_message = Lipsum().getSentence()
comment_parent = ''
submission_id = created_submission_id
self.post(self.server_url + "/comments",
params=[['comment[message]', comment_message],
['comment[submission_id]', submission_id],
['comment[parent_id]', comment_parent],
['authenticity_token', auth_token],
['commit', 'Create Comment']],
description="Create New Comment")
def setUp(self):
"""Setting up test."""
self.server_url = self.conf_get('main', 'url')
self.lipsum = Lipsum()
def setUp(self):
"""Setting up whitelist test."""
self.title = self.conf_get('main', 'title')
self.logd("Setting up test: %s\n" % self.title)
self.lipsum = Lipsum()
class Dav(FunkLoadTestCase):
ws_title = "FLNXTest-Dav-workspace"
dir_title = "FLNXTEST-Dav-folder"
tag = "FLNXTEST"
_lipsum = Lipsum()
def setUp(self):
self.server_url = self.conf_get('main', 'url')
self.credential_host = self.conf_get('credential', 'host')
self.credential_port = self.conf_getInt('credential', 'port')
self.cred_admin = xmlrpc_get_credential(self.credential_host,
self.credential_port, 'admin')
self.dav_url = self.server_url + "/site/dav"
self.nb_docs = self.conf_getInt('testWriter', 'nb_docs')
self.cred_member = xmlrpc_get_credential(self.credential_host,
self.credential_port,
'members')
def initWorkspace(self):
"""Create an initial workspace using rest,
because DAV is not allowed to create workspace."""
r = RestAPI(self)
r.login(*self.cred_admin)
root_uid = r.getRootWorkspaceUid()
ws_uid = r.getChildUid(root_uid, self.ws_title, 'Workspace')
if not ws_uid:
ws_uid = r.createDocument(root_uid, 'Workspace', self.ws_title,
'DAV Test workspace description.')
def testDav(self):
self.initWorkspace()
self.setBasicAuth(*self.cred_admin)
dav_url = self.dav_url
resp = self.options(dav_url, description="option on root")
dav = resp.headers.get('DAV')
self.assert_(dav is not None)
self.assert_(dav == '1,2')
allow = resp.headers.get('Allow')
for method in ['PROPPATCH', 'MKCOL', 'COPY', 'MOVE', 'LOCK', 'UNLOCK']:
self.assert_(method in allow)
resp = self.propfind(dav_url,
depth=0,
description="propfind root depth0")
# dom = parseString(self.getBody())
#for node in dom.firstChild.childNodes:
# print node.toxml()
resp = self.propfind(dav_url,
depth=1,
description="propfind root depth1")
dom = parseString(self.getBody())
for node in dom.getElementsByTagName('ns2:href'):
url = node.firstChild.data
# print url
url = dav_url + "/" + self.ws_title
folder_url = url + "/" + self.dir_title
self.delete(folder_url,
ok_codes=[204, 404],
description="Remove folder")
self.method("MKCOL",
folder_url,
ok_codes=[
201,
],
description="Create a folder")
resp = self.propfind(folder_url,
depth=0,
description="propfind root depth0")
# create file
doc_url = folder_url + '/' + self._lipsum.getUniqWord() + '.txt'
content = self._lipsum.getSentence()
self.put(doc_url,
params=Data(None, content),
description="Create a doc",
ok_codes=[
201,
])
# self.delete(folder_url, ok_codes=[204, ],
# description="Remove folder")
self.clearBasicAuth()
def testWriter(self):
self.initWorkspace()
self.setBasicAuth(*self.cred_admin)
dav_url = self.dav_url
url = dav_url + "/" + self.ws_title
folder_url = url + "/" + self._lipsum.getUniqWord()
# create a folder
self.method("MKCOL",
folder_url,
ok_codes=[
201,
],
description="Create a folder")
#resp = self.propfind(folder_url, depth=0,
# description="propfind root depth0")
# create files
for i in range(self.nb_docs):
doc_url = folder_url + '/' + self._lipsum.getUniqWord() + '.txt'
content = self._lipsum.getParagraph()
self.put(doc_url,
params=Data(None, content),
description="Create a doc " + str(i),
ok_codes=[
201,
])
self.clearBasicAuth()
def testUserAgents(self):
dav_url = self.dav_url
# check that nuxeo ask for digest auth for the following ua
uas = [
"MSFrontPage 1", "Microsoft-WebDAV-MiniRedir 1", "DavClnt"
"litmus 1", "gvfs 1", "davfs 1", "WebDAV 1", "cadaver 1"
]
for ua in uas:
self.setUserAgent(ua)
resp = self.propfind(dav_url,
description="test ua auth for " + ua,
ok_codes=[
401,
])
auth = resp.headers.get('WWW-Authenticate')
# print auth
self.assert_("Digest realm" in auth, "%s: %s" % (ua, auth))
# unknown UA also requires authentication
self.setUserAgent("FunkLoad")
resp = self.propfind(dav_url,
description="test non DAV ua",
ok_codes=[
401,
])
def testLocks(self):
self.initWorkspace()
self.setBasicAuth(*self.cred_admin)
dav_url = self.dav_url
url = dav_url + "/" + self.ws_title
doc_url = url + "/" + "lockme"
content = self._lipsum.getParagraph()
self.delete(doc_url,
ok_codes=[204, 404],
description="Remove doc if exists")
self.put(doc_url,
params=Data(None, content),
description="Create a doc",
ok_codes=[
201,
])
data = Data(
'text/xml', """<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<lockinfo xmlns='DAV:'>
<lockscope><exclusive/></lockscope>
<locktype><write/></locktype><owner>funkload test suite</owner>
</lockinfo>""")
self.method("LOCK", doc_url, params=data, description="Lock")
self.propfind(doc_url, ok_codes=[
207,
], description="Get info")
# nothing in the response tell that the doc is locked :/
# print self.getBody()
self.method("UNLOCK", doc_url, ok_codes=[
204,
], description="Unlock")
self.delete(doc_url, ok_codes=[
204,
], description="Remove doc")
def testCreateUpdate(self):
self.initWorkspace()
self.setBasicAuth(*self.cred_admin)
dav_url = self.dav_url
url = dav_url + "/" + self.ws_title
folder_url = url + "/" + self._lipsum.getUniqWord()
# create a folder
self.method("MKCOL",
folder_url,
ok_codes=[
201,
],
description="Create a folder")
# create files
for i in range(self.nb_docs):
doc_url = folder_url + '/' + self._lipsum.getUniqWord() + '.txt'
content = self._lipsum.getParagraph()
self.put(doc_url,
params=Data(None, content),
description="Create a doc " + str(i),
ok_codes=[
201,
])
content += self._lipsum.getParagraph() + " UPDATE"
self.put(doc_url,
params=Data(None, content),
description="Update doc " + str(i),
ok_codes=[
201,
])
#self.delete(doc_url, ok_codes=[204, ], description="Delete doc")
self.clearBasicAuth()
class Rest(FunkLoadTestCase):
ws_title = "FLNXTEST Rest workspace"
dir_title = "FLNXTEST Rest folder"
tag = "FLNXTEST"
_lipsum = Lipsum()
def setUp(self):
self.server_url = self.conf_get('main', 'url')
self.nb_doc = self.conf_getInt('testWriter', 'nb_doc')
self.nb_read = self.conf_getInt('testReader', 'nb_read')
self.credential_host = self.conf_get('credential', 'host')
self.credential_port = self.conf_getInt('credential', 'port')
self.cred_admin = xmlrpc_get_credential(self.credential_host,
self.credential_port, 'admin')
def FAIL_testUpload(self):
r = RestAPI(self)
r.login(*self.cred_admin)
uid = '44f1af7e-5206-4f39-b935-55bb32ab3112'
r.uploadFile(uid, 'foo.txt')
r.logout()
def testWriter(self):
# Create a folder and few documents
r = RestAPI(self)
r.login(*self.cred_admin)
root_uid = r.getRootWorkspaceUid()
ws_uid = r.getChildUid(root_uid, self.ws_title, 'Workspace')
if not ws_uid:
ws_uid = r.createDocument(root_uid, 'Workspace', self.ws_title,
'Test workspace description.')
dir_uid = r.getChildUid(ws_uid, self.dir_title, 'Folder')
if not dir_uid:
dir_uid = r.createDocument(ws_uid, 'Folder', self.dir_title,
'Test folder description')
for i in range(self.nb_doc):
title = self._lipsum.getSubject(uniq=True, prefix=self.tag)
description = self.tag + ' ' + self._lipsum.getParagraph(1)
uid = r.createDocument(dir_uid, 'File', title, description)
r.logout()
def testReader(self):
# browse the workspace
r = RestAPI(self)
r.login(*self.cred_admin)
uid = r.getRootWorkspaceUid()
uid = r.getChildUid(uid, self.ws_title, 'Workspace')
self.assert_(uid, 'Workspace "%s" not found.' % self.ws_title)
uid = r.getChildUid(uid, self.dir_title, 'Folder')
self.assert_(uid, 'Folder "%s" not found.' % self.dir_title)
count = 0
nb_read = self.nb_read
for item in r.browse(uid):
ret = r.exportTree(item.id)
zc = ZipFile(StringIO(ret))
self.assert_('.nuxeo-archive' in zc.namelist())
count += 1
if count > nb_read:
break
r.logout()
class Distribution(FunkLoadTestCase):
"""Nuxeo Courrier
This test use a configuration file Distribution.conf.
"""
_lipsum = Lipsum()
def setUp(self):
"""Setting up test."""
self.logd("setUp")
self.addHeader('Accept-Language', 'en')
self.server_url = self.conf_get('main', 'url')
self.credential_host = self.conf_get('credential', 'host')
self.credential_port = self.conf_getInt('credential', 'port')
self.cred_admin = xmlrpc_get_credential(self.credential_host,
self.credential_port, 'admin')
self.cred_member = xmlrpc_get_credential(self.credential_host,
self.credential_port,
'members')
self.senderList = xmlrpc_list_credentials(self.credential_host,
self.credential_port,
'writers')
self.receiverList = xmlrpc_list_credentials(self.credential_host,
self.credential_port,
'readers')
def getLastJsfState(self):
return extractJsfState(self.getBody())
def getRandReceiver(self):
index = random.randint(0, len(self.receiverList) - 1)
return self.receiverList[index]
def getRandSender(self):
index = random.randint(0, len(self.senderList) - 1)
return self.senderList[index]
def test_distribution(self):
# The description should be set in the configuration file
server_url = self.server_url
# begin of test ---------------------------------------------
lipsum = self._lipsum
today = datetime.today().strftime('%m/%d/%y')
randSender = self.getRandSender()
receiver = self.getRandReceiver()
self.post(server_url + "/nxstartup.faces",
params=[['user_name', randSender[0]],
['user_password', randSender[1]],
['requestedUrl', ''], ['form_submitted_marker', ''],
['Submit', 'Connexion']],
description="Log in")
self.assert_('You are logged as ' + randSender[0] in self.getBody())
self.get(server_url + "/nxpath/default/correspondence/mailboxes/" +
randSender[0] + "@mailbox_view?tabId=&conversationId=0NXMAIN",
description="View personal mailbox")
self.assert_('Create an incoming mail' in self.getBody())
"""Create incoming mail."""
self.post(server_url + "/correspondence/mailbox/mailbox_view.faces",
params=[['j_id245', 'j_id245'],
['javax.faces.ViewState',
self.getLastJsfState()],
['j_id226:j_id227', 'j_id226:j_id227'],
['j_id226_SUBMIT', '1']],
description="View mail form")
self.assert_(
'nxl_head_correspondence_incoming_document' in self.getBody())
self.post(
server_url +
"/correspondence/mail/create_correspondence_document.faces",
params=
[[
'AJAXREQUEST',
'document_create:nxl_correspondence_document:nxw_contactsRecipients:nxw_contactsRecipients_region'
], ['document_create', 'document_create'],
['document_create:nxl_correspondence_document:nxw_title', ''],
[
'document_create:nxl_correspondence_document:nxw_document_type',
'2'
],
[
'document_create:nxl_correspondence_document:nxw_sending_date',
''
],
[
'document_create_link_hidden_',
'document_create:nxl_correspondence_document:nxw_sending_date:trigger'
],
[
'document_create_link_hidden_',
'document_create:nxl_correspondence_document:nxw_receive_date:trigger'
],
[
'document_create_link_hidden_',
'document_create:nxl_correspondence_document:nxw_document_date:trigger'
],
[
'document_create_link_hidden_',
'document_create:nxl_head_correspondence_incoming_document:nxw_scan_date:trigger'
],
[
'document_create:nxl_correspondence_document:nxw_receive_date',
''
],
[
'document_create:nxl_correspondence_document:nxw_document_date',
''
],
[
'document_create:nxl_correspondence_document:nxw_confidentiality',
'4'
], ['document_create:nxl_correspondence_document:nxw_origin', ''],
['document_create:nxl_correspondence_document:nxw_reference', ''],
['document_create:nxl_correspondence_document:nxw_body', ''],
['mce_editor_0_styleSelect', ''],
['mce_editor_0_formatSelect', ''],
[
'document_create:nxl_head_correspondence_incoming_document:nxw_scan_site',
''
],
[
'document_create:nxl_head_correspondence_incoming_document:nxw_scan_date',
''
],
[
'document_create:nxl_file:nxw_file:nxw_file_file:choice',
'none'
], ['document_create:nxl_file:nxw_file:nxw_file_file:upload', ''],
['javax.faces.ViewState',
self.getLastJsfState()], ['type', 'add'],
[
'document_create:nxl_correspondence_document:nxw_contactsRecipients:nxw_contactsRecipients_add',
'document_create:nxl_correspondence_document:nxw_contactsRecipients:nxw_contactsRecipients_add'
], ['for', 'nxw_contactsRecipients_list']],
description="Add recipient")
self.post(
server_url +
"/correspondence/mail/create_correspondence_document.faces",
params=
[[
'AJAXREQUEST',
'document_create:nxl_correspondence_document:nxw_contactsSenders:nxw_contactsSenders_region'
], ['document_create', 'document_create'],
['document_create:nxl_correspondence_document:nxw_title', ''],
[
'document_create:nxl_correspondence_document:nxw_document_type',
'2'
],
[
'document_create:nxl_correspondence_document:nxw_contactsRecipients:nxw_contactsRecipients_list:0:nxw_contactsRecipients_name',
''
],
[
'document_create:nxl_correspondence_document:nxw_contactsRecipients:nxw_contactsRecipients_list:0:nxw_contactsRecipients_surname',
''
],
[
'document_create:nxl_correspondence_document:nxw_contactsRecipients:nxw_contactsRecipients_list:0:nxw_contactsRecipients_service',
''
],
[
'document_create:nxl_correspondence_document:nxw_sending_date',
''
],
[
'document_create_link_hidden_',
'document_create:nxl_correspondence_document:nxw_sending_date:trigger'
],
[
'document_create_link_hidden_',
'document_create:nxl_correspondence_document:nxw_receive_date:trigger'
],
[
'document_create_link_hidden_',
'document_create:nxl_correspondence_document:nxw_document_date:trigger'
],
[
'document_create_link_hidden_',
'document_create:nxl_head_correspondence_incoming_document:nxw_scan_date:trigger'
],
[
'document_create:nxl_correspondence_document:nxw_receive_date',
''
],
[
'document_create:nxl_correspondence_document:nxw_document_date',
''
],
[
'document_create:nxl_correspondence_document:nxw_confidentiality',
'4'
], ['document_create:nxl_correspondence_document:nxw_origin', ''],
['document_create:nxl_correspondence_document:nxw_reference', ''],
['document_create:nxl_correspondence_document:nxw_body', ''],
['mce_editor_0_styleSelect', ''],
['mce_editor_0_formatSelect', ''],
[
'document_create:nxl_head_correspondence_incoming_document:nxw_scan_site',
''
],
[
'document_create:nxl_head_correspondence_incoming_document:nxw_scan_date',
''
],
[
'document_create:nxl_file:nxw_file:nxw_file_file:choice',
'none'
], ['document_create:nxl_file:nxw_file:nxw_file_file:upload', ''],
['javax.faces.ViewState',
self.getLastJsfState()],
[
'document_create:nxl_correspondence_document:nxw_contactsSenders:nxw_contactsSenders_add',
'document_create:nxl_correspondence_document:nxw_contactsSenders:nxw_contactsSenders_add'
], ['type', 'add'], ['for', 'nxw_contactsSenders_list']],
description="Add sender")
self.post(
server_url +
"/correspondence/mail/create_correspondence_document.faces",
params=
[['document_create', 'document_create'],
[
'document_create:nxl_correspondence_document:nxw_title',
lipsum.getSubject()
],
[
'document_create:nxl_correspondence_document:nxw_document_type',
'2'
],
[
'document_create:nxl_correspondence_document:nxw_contactsRecipients:nxw_contactsRecipients_list:0:nxw_contactsRecipients_name',
lipsum.getWord()
],
[
'document_create:nxl_correspondence_document:nxw_contactsRecipients:nxw_contactsRecipients_list:0:nxw_contactsRecipients_surname',
lipsum.getWord()
],
[
'document_create:nxl_correspondence_document:nxw_contactsRecipients:nxw_contactsRecipients_list:0:nxw_contactsRecipients_service',
lipsum.getWord()
],
[
'document_create:nxl_correspondence_document:nxw_sending_date',
today + ' 1:00 PM'
],
[
'document_create:nxl_correspondence_document:nxw_receive_date',
today + ' 2:00 PM'
],
[
'document_create:nxl_correspondence_document:nxw_document_date',
today + ' 11:00 AM'
],
[
'document_create:nxl_correspondence_document:nxw_confidentiality',
'4'
],
[
'document_create:nxl_correspondence_document:nxw_contactsSenders:nxw_contactsSenders_list:0:nxw_contactsSenders_name',
lipsum.getWord()
],
[
'document_create:nxl_correspondence_document:nxw_contactsSenders:nxw_contactsSenders_list:0:nxw_contactsSenders_surname',
lipsum.getWord()
],
[
'document_create:nxl_correspondence_document:nxw_contactsSenders:nxw_contactsSenders_list:0:nxw_contactsSenders_service',
lipsum.getWord()
],
[
'document_create:nxl_correspondence_document:nxw_origin',
lipsum.getAddress()
],
[
'document_create:nxl_correspondence_document:nxw_reference',
lipsum.getUniqWord()
],
[
'document_create:nxl_correspondence_document:nxw_body',
lipsum.getParagraph()
],
[
'document_create:nxl_head_correspondence_incoming_document:nxw_scan_site',
'nuxeo'
],
[
'document_create:nxl_head_correspondence_incoming_document:nxw_scan_date',
today + ' 10:00 AM'
],
[
'document_create:nxl_file:nxw_file:nxw_file_file:choice',
'upload'
], ['document_create_SUBMIT', '1'],
[
'document_create:nxl_file:nxw_file:nxw_file_file:upload',
Upload("hello.pdf")
], ['document_create:j_id365', 'Create'],
['javax.faces.ViewState',
self.getLastJsfState()]],
description="Submit new mail")
self.assert_('Incoming mail saved' in self.getBody())
self.post(server_url +
"/correspondence/mail/view_correspondence_envelope.faces",
params=[['javax.faces.ViewState',
self.getLastJsfState()], ['j_id340_SUBMIT', '1'],
[
'j_id340:j_id341:j_id342:0:j_id343',
'j_id340:j_id341:j_id342:0:j_id343'
]],
description="View distribution form")
self.assert_('distribution_recipients' in self.getBody())
self.post(
server_url +
"/correspondence/mail/distribution_correspondence_envelope.faces",
params=
[[
'AJAXREQUEST',
'distribution_recipients:nxl_correspondence_recipients:j_id328'
], ['distribution_recipients', 'distribution_recipients'],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggest',
receiver[0]
],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggestionBox_selection',
''
],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_copy_recipients_suggest',
''
],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_copy_recipients_suggestionBox_selection',
''
], ['distribution_recipients:comment', ''],
['javax.faces.ViewState',
self.getLastJsfState()],
[
'ajaxSingle',
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggestionBox'
], ['mailboxSuggestionSearchType', ''],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggestionBox',
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggestionBox'
], ['inputvalue', receiver[0]], ['AJAX:EVENTS_COUNT', '1']],
description="Search receiver")
self.assert_(receiver[0] in self.getBody())
self.post(
server_url +
"/correspondence/mail/distribution_correspondence_envelope.faces",
params=
[[
'AJAXREQUEST',
'distribution_recipients:nxl_correspondence_recipients:j_id328'
], ['distribution_recipients', 'distribution_recipients'],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggest',
''
],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggestionBox_selection',
'0'
],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_copy_recipients_suggest',
''
],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_copy_recipients_suggestionBox_selection',
''
], ['distribution_recipients:comment', ''],
['javax.faces.ViewState',
self.getLastJsfState()],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggestionBox:j_id335',
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggestionBox:j_id335'
], ['suggestionSelectionListId', 'nxw_action_recipients_list']],
description="Select receiver")
self.post(
server_url +
"/correspondence/mail/distribution_correspondence_envelope.faces",
params=
[['distribution_recipients', 'distribution_recipients'],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggest',
''
],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_action_recipients_suggestionBox_selection',
''
],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_copy_recipients_suggest',
''
],
[
'distribution_recipients:nxl_correspondence_recipients:nxw_copy_recipients_suggestionBox_selection',
''
], ['distribution_recipients:comment',
lipsum.getSentence()],
['distribution_recipients:j_id389', 'Send'],
['distribution_recipients_SUBMIT', '1'],
['javax.faces.ViewState',
self.getLastJsfState()]],
description="Send mail")
self.assert_('The distribution is done' in self.getBody())
self.get(server_url + "/logout", description="Log out")
# end of test -----------------------------------------------
def tearDown(self):
"""Setting up test."""
self.logd("tearDown.\n")
class CMF(NuxeoTestCase):
"""CMF
This test use a configuration file CMF.conf.
"""
_lipsum = Lipsum()
def setUp(self):
"""Setting up test."""
self.logd("setUp")
NuxeoTestCase.setUp(self)
self.memberList = xmlrpc_list_credentials(self.credential_host,
self.credential_port,
'members')
self.routeManagerList = xmlrpc_list_credentials(
self.credential_host, self.credential_port, 'routeManagers')
f = open('./xml_importer/pdf-list.txt', 'r')
self.pdf_files = f.readlines()
self.routeName = "FunkloadRouteDoc"
self.routeModelId = self.extractRouteModelId("jdoe", "jdoe1",
self.routeName)
def executeApproveLinkOperation(self, user, passwd, mailboxId, caseId):
self.logi("Execute approve op as: " + user)
URL = "http://localhost:8080/nuxeo/site/automation/"
self.setBasicAuth(user, passwd)
data = Data(
'application/json+nxrequest',
'{"params":{},"context":{},"input":"docs:' + mailboxId + ',' +
caseId + '"}')
self.post(URL + 'Case.Management.Approve.CaseLink', data)
self.clearBasicAuth()
def getRandomUser(self):
return random.choice(self.memberList)
def getRandomAdministrator(self):
return random.choice(self.cred_admin)
def getRandomRouteManager(self):
return random.choice(self.routeManagerList)
def getPasswordForUser(self, user):
for i in self.memberList:
if cmp(i[0], user):
return i[1]
def extractRouteStepsIds(self, user, passwd, routeInstanceName):
stepsDocIds = []
p = RouteInstancePage(self).login(
user, passwd).viewRouteInstance(routeInstanceName)
#get all the route steps docIds to modify the route from the route view
stepsDocIds = p.getStepsDocsIds(stepsDocIds)
p.logout()
return stepsDocIds
def updateRoute(self, user, passwd, case, route, stepsDocIds):
#lock route and modify steps
routeInstance = CaseItemPage(self).login(
user, passwd).viewRelatedStartedRoute(case)
p = RoutePage(self).lockRoute(user, route)
self.logi("Route " + routeInstance + " locked by " + user)
j = 0
usersWithTasks = []
for i in stepsDocIds:
randUser = self.getRandomUser()
if RoutePage(self).stepCanBeUpdated(i, routeInstance,
user) is True:
if RoutePage(self).stepNeedsToBeApproved(
i, routeInstance, user) is True:
usersWithTasks.append(randUser)
#TODO delete this refresh call after fixing NXCM-301
CaseItemPage(self).refreshRelatedStartedRoute(case)
RoutePage(self).updateStepDistributionMailboxFromRouteView(
i, "user-" + randUser[0], j)
j = j + 1
p.logout()
return usersWithTasks
class Pages(NuxeoTestCase):
ws_title = "FLNXTEST Page workspace"
dir_title = "FLNXTEST Page folder"
tag = "FLNXTEST"
_lipsum = Lipsum()
def testAvailable(self):
BasePage(self).available()
def testLoginPage(self):
(LoginPage(self).view().login(*self.cred_admin).logout())
LoginPage(self).loginInvalid('foo', 'bar')
def testBasePageViewDocumentPath(self):
# fluent test
p = (LoginPage(self).login(
*self.cred_admin).getRootWorkspaces().logout())
p = (LoginPage(self).login(
*self.cred_admin).viewDocumentPath("workspaces"))
# TODO assert we are on workspaces
ret = p.viewDocumentPath("workspaces/that/does/not/exists",
raiseOn404=False)
self.assert_(ret is None, "Expecting None for a 404.")
p.logout()
def testNavigation(self):
p = (LoginPage(self).login(*self.cred_admin).getRootWorkspaces())
p = (p.rights().manage())
p = (
p.getRootWorkspaces().personalWorkspace().getRootWorkspaces()
#XXX NXP-15036 Update search method with search tab
#.search('workspaces')
.logout())
def testSections(self):
title = self._lipsum.getSubject(uniq=True, prefix=self.tag)
description = self.tag + ' ' + self._lipsum.getParagraph(1)
p = (LoginPage(self).login(
*self.cred_admin).getRootSections().createSection(
title, description))
p = (p.getRootSections().deleteItem(title, "Section").logout())
def dbgtestPublish(self):
p = LoginPage(self).login(*self.cred_admin)
p.viewDocumentPath(
'workspaces/flnxtest-page-workspace/flnxtest-page-folder/flnxtest-tsoc1g7-tris'
)
p.publish().publishOnFirstSection()
p.logout()
def testPublish(self):
title = self._lipsum.getSubject(uniq=True, prefix=self.tag)
description = self.tag + ' ' + self._lipsum.getParagraph(1)
title_section = self._lipsum.getSubject(uniq=True, prefix=self.tag)
p = (LoginPage(self).login(
*self.cred_admin).getRootSections().createSection(
title_section,
description).rights().grant('ReadWrite',
'Members group').view())
p = (LoginPage(self).login(
*self.cred_admin).getRootWorkspaces().createWorkspace(
self.ws_title, 'A description').view().createFolder(
self.dir_title,
'A description').createFile(title, description))
p = (p.publish().publishOnFirstSection())
p = (p.getRootWorkspaces().deleteItem(
self.ws_title).getRootSections().deleteItem(
title_section, "Section"))
p.logout()
def testFolderPage(self):
title = self._lipsum.getSubject(uniq=True, prefix=self.tag)
description = self.tag + ' ' + self._lipsum.getParagraph(1)
p = (LoginPage(self).login(
*self.cred_admin).getRootWorkspaces().createWorkspace(
self.ws_title, 'A description').rights().grant(
'ReadWrite', 'Members group').view().createFolder(
self.dir_title, 'A description'))
fuid = p.getDocUid()
p.createFile(title, description)
p = (p.viewDocumentUid(fuid).sort('author').sort('title').sort(
'lifecycle').sort('date'))
p = (p.getRootWorkspaces().deleteItem(self.ws_title).logout())
def testFileTabs(self):
title = self._lipsum.getSubject(uniq=True, prefix=self.tag)
description = self.tag + ' ' + self._lipsum.getParagraph(1)
p = (LoginPage(self).login(
*self.cred_admin).getRootWorkspaces().createWorkspace(
self.ws_title, 'A description').view().createFolder(
self.dir_title,
'A description').createFile(title, description))
p = (p.edit().files().publish().relations().comments().history())
p = (p.getRootWorkspaces().deleteItem(self.ws_title).logout())
def testUsersGroupsPage(self):
p = LoginPage(self).login(*self.cred_admin)
login = self.tag.lower()
pwd = 'secret'
p = (p.adminCenter().usersAndGroupsPage().createUser(
login,
'*****@*****.**',
pwd,
groups='members',
firstname="first",
lastname=login.capitalize()).createUser(login,
'*****@*****.**',
pwd,
groups='members',
firstname='first',
lastname='last'))
p.exitAdminCenter().logout()
p.login(login, pwd).getRootWorkspaces().logout()
import unittest
from funkload.Lipsum import Lipsum
from funkload.FunkLoadTestCase import FunkLoadTestCase
from webunit.utility import Upload
from funkload.utils import Data
import hashlib
from funkload.utils import extract_token
#from funkload.utils import xmlrpc_get_credential
def user_grade_dir_name(username):
return hashlib.md5(username).hexdigest()[0:5] + username
lipsum = Lipsum()
class Navigation(FunkLoadTestCase):
"""XXX
This test use a configuration file Navigation.conf.
"""
def setUp(self):
"""Setting up test."""
self.logd("setUp")
self.server_url = self.conf_get('main', 'url')
# XXX here you can setup the credential access like this
# credential_host = self.conf_get('credential', 'host')
# credential_port = self.conf_getInt('credential', 'port')
# self.login, self.password = xmlrpc_get_credential(credential_host,
