def testSessionAcquisition(self):
"""Users belonging to a group should be able to see all the sessions
belonging to the group and the group children
"""
session = Session()
group1 = model.Group(group_id="1")
session.add(group1)
group2 = model.Group(group_id="2")
session.add(group2)
account1 = model.Account(loginname="account1")
session.add(account1)
account1.group = group1
group2.parent = group1
account2 = model.Account(loginname="account2")
session.add(account2)
account2.group = group2
survey1 = model.SurveySession(
account=account1,
group=group1,
zodb_path="1",
)
session.add(survey1)
survey2 = model.SurveySession(
account=account2,
group=group2,
zodb_path="2",
)
session.add(survey2)
session.flush()
self.assertListEqual(account1.sessions, [survey1])
self.assertListEqual(account2.sessions, [survey2])
self.assertListEqual(account1.acquired_sessions, [survey1, survey2])
self.assertListEqual(account2.acquired_sessions, [survey2])
def setUp(self):
super(TestCloningViews, self).setUp()
self.loginAsPortalOwner()
addSurvey(self.portal, BASIC_SURVEY)
self.jane = addAccount("*****@*****.**", password="******")
self.john = addAccount("*****@*****.**", password="******")
group = model.Group(group_id="1")
model.Session.add(group)
self.jane.group = group
self.john.group = group
model.Session.flush()
survey_session = model.SurveySession(
title="Dummy session",
created=datetime(2012, 4, 22, 23, 5, 12),
modified=datetime(2012, 4, 23, 11, 50, 30),
zodb_path="nl/ict/software-development",
account=self.jane,
group=group,
company=model.Company(country="nl",
employees="1-9",
referer="other"),
)
module = survey_session.addChild(
model.Module(title="module 1", module_id="1", zodb_path="a"))
risk = module.addChild(
model.Risk(title="question 1", risk_id="1", zodb_path="a/b"))
model.ActionPlan(action_plan="This is the plan", risk=risk)
model.Session.add(survey_session)
def create_session(self):
with api.env.adopt_user(SITE_OWNER_NAME):
api.content.create(container=self.portal.sectors,
type="euphorie.country",
id="eu")
client_country = api.content.create(container=self.portal.client,
type="euphorie.clientcountry",
id="eu")
client_sector = api.content.create(container=client_country,
type="euphorie.clientsector",
id="sector")
api.content.create(container=client_sector,
type="euphorie.survey",
id="survey")
sqlsession = Session()
account = model.Account(loginname="jane", password="******")
sqlsession.add(account)
session = model.SurveySession(title="Session",
zodb_path="eu/sector/survey",
account=account)
sqlsession.add(session)
sqlsession.flush()
return session
def createSurvey():
session = Session()
account = model.Account(loginname="jane", password="******")
session.add(account)
survey = model.SurveySession(title="Session", zodb_path="survey", account=account)
session.add(survey)
session.flush()
return (session, survey)
def setUp(self):
super(TestArchivingViews, self).setUp()
self.loginAsPortalOwner()
addSurvey(self.portal, BASIC_SURVEY)
self.account = addAccount(password="******")
survey_session = model.SurveySession(
title="Dummy session 1",
zodb_path="nl/ict/software-development",
account=self.account,
)
model.Session.add(survey_session)
survey_session = model.SurveySession(
title="Dummy session 2",
zodb_path="nl/ict/software-development",
account=self.account,
)
model.Session.add(survey_session)
def setUp(self):
super(BuildSurveyTreeTests, self).setUp()
self.session = Session()
account = model.Account(id=1, loginname="jane", password="******")
self.session.add(account)
self.survey = model.SurveySession(
title="Survey", zodb_path="survey", account=account
)
self.session.add(self.survey)
self.session.flush()
def createSurveySession():
sqlsession = Session()
account = model.Account(loginname="jane", password="******")
sqlsession.add(account)
session = model.SurveySession(title="Session",
zodb_path="ict/software-development",
account=account)
sqlsession.add(session)
sqlsession.flush()
return session
def createSurveySession(self):
self.sqlsession = Session()
account = model.Account(loginname="jane", password="******")
self.sqlsession.add(account)
self.session = model.SurveySession(title="Session",
zodb_path="nl/dining/survey",
account=account)
self.sqlsession.add(self.session)
self.sqlsession.flush()
return self.session
def setUp(self):
super(TestDashboard, self).setUp()
self.loginAsPortalOwner()
addSurvey(self.portal, BASIC_SURVEY)
self.account = addAccount(password="******")
# We setup two surveys, an archived one and one which is not archived
survey_session = model.SurveySession(
title="Dummy session 1",
zodb_path="nl/ict/software-development",
account=self.account,
)
model.Session.add(survey_session)
survey_session = model.SurveySession(
title="Dummy session 2",
zodb_path="nl/ict/software-development",
account=self.account,
)
survey_session.archived = localized_now() - timedelta(days=1)
model.Session.add(survey_session)
def test_do_GET_no_company_data(self):
# Company might not have been created yet
from euphorie.client import model
context = model.SurveySession()
view = self.View(context, None)
view.update()
self.assertTrue(context.company is not None)
response = view.do_GET()
self.assertEqual(response['country'], None)
self.assertEqual(response['employees'], None)
def testUpdateCompany_Empty(self):
from euphorie.client import model
from tno.euphorie.model import DutchCompany
from tno.euphorie.session import Upload
session = model.SurveySession()
input = objectify.fromstring(self.BASE_SNIPPET)
view = Upload(None, None)
view.updateCompany(input, session)
self.assertTrue(isinstance(session.dutch_company, DutchCompany))
def setUp(self):
super(completion_percentage_tests, self).setUp()
self.session = Session()
account = model.Account(loginname="jane", password="******")
self.session.add(account)
self.survey = model.SurveySession(title="Survey",
zodb_path="survey",
account=account)
self.session.add(self.survey)
self.session.flush()
def test_get_group_filter(self):
session = model.SurveySession()
group = model.Group(group_id="foo")
account = model.Account(id=1)
# Note assertFalse will not do what you want on Binary expression
self.assertEqual(str(session.get_group_filter()), "False")
self.assertEqual(str(session.get_group_filter(False)), "False")
self.assertEqual(str(session.get_group_filter(None)), "False")
self.assertEqual(str(session.get_group_filter("")), "False")
self.assertEqual(str(session.get_group_filter([])), "False")
self.assertEqual(str(session.get_group_filter([""])), "False")
self.assertEqual(
str(session.get_group_filter("1")), "session.group_id = :group_id_1"
)
self.assertEqual(
str(session.get_group_filter(1)), "session.group_id = :group_id_1"
)
self.assertEqual(
str(session.get_group_filter(group)),
"session.group_id = :group_id_1",
)
self.assertEqual(
str(session.get_group_filter(["1"])), "session.group_id = :group_id_1"
)
self.assertEqual(
str(session.get_group_filter([1])), "session.group_id = :group_id_1"
)
self.assertEqual(
str(session.get_group_filter([group])),
"session.group_id = :group_id_1",
)
self.assertEqual(
str(session.get_group_filter([group, "2"])),
"session.group_id IN (:group_id_1, :group_id_2)",
)
with mock.patch("euphorie.client.model.get_current_account", return_value=None):
self.assertEqual(str(session.get_group_filter(True)), "False")
# The account still does not have a group, so we should have False here
with mock.patch(
"euphorie.client.model.get_current_account", return_value=account
):
self.assertEqual(str(session.get_group_filter(True)), "False")
account.group_id = "foo"
with mock.patch(
"euphorie.client.model.get_current_account", return_value=account
):
self.assertEqual(
str(session.get_group_filter(True)),
"session.group_id = :group_id_1",
)
with self.assertRaises(TypeError):
session.get_group_filter(session)
def setUp(self):
from z3c.saconfig import Session
super(BuildSurveyTreeTests, self).setUp()
self.session = Session()
account = model.Account(loginname=u"jane", password=u"secret")
self.session.add(account)
self.survey = model.SurveySession(title=u"Survey",
zodb_path="survey",
account=account)
self.session.add(self.survey)
self.session.flush()
def test_is_archived(self):
"""Verify that a session is archived when the archived attribute
is set and it is in the past
"""
session = model.SurveySession()
self.assertIsNone(session.archived)
self.assertFalse(session.is_archived)
session.archived = localized_now()
self.assertTrue(session.is_archived)
session.archived += timedelta(days=1)
self.assertFalse(session.is_archived)
def test_modify_updates_last_modifier(self):
account = addAccount(password="******")
survey_session = model.SurveySession(title="Dummy session",
account=account,
zodb_path="")
self.assertEqual(survey_session.modified, None)
self.assertEqual(survey_session.last_modifier, None)
with api.env.adopt_user(user=account):
notify(ObjectModifiedEvent(survey_session))
self.assertIsInstance(survey_session.modified, datetime)
self.assertEqual(survey_session.last_modifier, account)
def test_keep_sessions_apart(self):
self.createSqlData()
account = model.Account(loginname=u'john', password=u'jane')
self.session.add(account)
survey2 = model.SurveySession(title=u'Survey',
zodb_path='survey',
account=account)
self.session.add(survey2)
self.session.flush()
zodb_path = ['1']
result = self.find_sql_context(survey2.id, zodb_path)
self.failUnless(result is None)
def test_keep_sessions_apart(self):
self.createSqlData()
account = model.Account(loginname="john", password="******")
self.session.add(account)
survey2 = model.SurveySession(title="Survey",
zodb_path="survey",
account=account)
self.session.add(survey2)
self.session.flush()
zodb_path = ["1"]
result = self.find_sql_context(survey2.id, zodb_path)
self.assertTrue(result is None)
def setUp(self):
super(AddToTreeTests, self).setUp()
self.session = Session()
account = model.Account(id=1, loginname="jane", password="******")
self.session.add(account)
self.survey = model.SurveySession(
title="Survey", zodb_path="survey", account=account
)
self.session.add(self.survey)
self.session.flush()
self.root = self.survey.addChild(
model.Module(title="test session", module_id="1", zodb_path="1")
)
def createSqlData(self):
self.session = Session()
account = model.Account(loginname="jane", password="******")
self.session.add(account)
self.survey = model.SurveySession(title="Survey",
zodb_path="survey",
account=account)
self.session.add(self.survey)
self.session.flush()
self.mod1 = self.survey.addChild(
model.Module(title="module 1", module_id="1", zodb_path="a"))
self.q1 = self.mod1.addChild(
model.Risk(title="question 1", risk_id="1", zodb_path="a/b"))
self.session.flush()
def setUp(self):
super(TestRiskImageDownloadUpload, self).setUp()
self.loginAsPortalOwner()
self.account = addAccount(password="******")
addSurvey(self.portal, BASIC_SURVEY)
survey_session = model.SurveySession(
title="Dummy session",
zodb_path="nl/ict/software-development",
account=self.account,
)
self.risk = survey_session.addChild(
model.Risk(title="risk 1",
zodb_path="1")).__of__(survey_session.traversed_session)
model.Session.add(survey_session)
def test_resume_enforce_same_account(self):
from AccessControl.SecurityManagement import getSecurityManager
from AccessControl.SecurityManagement import setSecurityManager
from AccessControl.SecurityManagement import newSecurityManager
from euphorie.client import model
sm = getSecurityManager()
mgr = self.SessionManagerFactory()
victim = model.Account(loginname="test", password=u"test")
attacker = model.Account(loginname="evil", password=u"layer")
session = model.SurveySession(account=victim)
try:
newSecurityManager(None, attacker)
self.assertRaises(ValueError, mgr.resume, session)
finally:
setSecurityManager(sm)
def createSqlData(self):
from z3c.saconfig import Session
self.session = Session()
account = model.Account(loginname=u'jane', password=u'secret')
self.session.add(account)
self.survey = model.SurveySession(title=u'Survey',
zodb_path='survey',
account=account)
self.session.add(self.survey)
self.session.flush()
self.mod1 = self.survey.addChild(
model.Module(title=u'module 1', module_id='1', zodb_path='a'))
self.q1 = self.mod1.addChild(
model.Risk(title=u'question 1', risk_id='1', zodb_path='a/b'))
self.session.flush()
def testUpdateCompany_AantalInDienst(self):
from euphorie.client import model
from tno.euphorie.session import Upload
session = model.SurveySession()
input = objectify.fromstring(self.BASE_SNIPPET)
view = Upload(None, None)
input.gegevens.attrib["aantalindienst"] = "1"
view.updateCompany(input, session)
self.assertEqual(session.dutch_company.employees, "40h")
input.gegevens.attrib["aantalindienst"] = "25"
view.updateCompany(input, session)
self.assertEqual(session.dutch_company.employees, "max25")
input.gegevens.attrib["aantalindienst"] = "999"
view.updateCompany(input, session)
self.assertEqual(session.dutch_company.employees, "over25")
def test_get_account_filter(self):
session = model.SurveySession()
account = model.Account(id=1)
# Note assertFalse will not do what you want on Binary expression
self.assertEqual(str(session.get_account_filter()), "False")
self.assertEqual(str(session.get_account_filter(False)), "False")
self.assertEqual(str(session.get_account_filter(None)), "False")
self.assertEqual(str(session.get_account_filter("")), "False")
self.assertEqual(str(session.get_account_filter([])), "False")
self.assertEqual(str(session.get_account_filter([""])), "False")
self.assertEqual(
str(session.get_account_filter("1")), "session.account_id = :account_id_1"
)
self.assertEqual(
str(session.get_account_filter(1)), "session.account_id = :account_id_1"
)
session.get_account_filter(account)
self.assertEqual(
str(session.get_account_filter(account)),
"session.account_id = :account_id_1",
)
self.assertEqual(
str(session.get_account_filter(["1"])), "session.account_id = :account_id_1"
)
self.assertEqual(
str(session.get_account_filter([1])), "session.account_id = :account_id_1"
)
self.assertEqual(
str(session.get_account_filter([account])),
"session.account_id = :account_id_1",
)
self.assertEqual(
str(session.get_account_filter([account, "2"])),
"session.account_id IN (:account_id_1, :account_id_2)",
)
with mock.patch("euphorie.client.model.get_current_account", return_value=None):
self.assertEqual(str(session.get_account_filter(True)), "False")
with mock.patch(
"euphorie.client.model.get_current_account", return_value=account
):
self.assertEqual(
str(session.get_account_filter(True)),
"session.account_id = :account_id_1",
)
with self.assertRaises(TypeError):
session.get_account_filter(session)
def setUp(self):
super(TestTrainingQuestions, self).setUp()
with api.env.adopt_user("admin"):
addSurvey(self.portal, BASIC_SURVEY)
self.account = addAccount(password="******")
self.survey = self.portal.client.nl.ict["software-development"]
alsoProvides(self.survey.REQUEST, IClientSkinLayer)
api.portal.set_registry_record("euphorie.use_training_module", True)
survey_session = model.SurveySession(
title="Dummy session",
zodb_path="nl/ict/software-development",
account=self.account,
company=model.Company(country="nl",
employees="1-9",
referer="other"),
)
model.Session.add(survey_session)
seed(a="test_training_questions")
def test_company_timestamp(self, mock_render, mock_applyChanges):
with api.env.adopt_user("admin"):
survey = addSurvey(self.portal, BASIC_SURVEY)
account = addAccount(password="******")
survey_session = model.SurveySession(
id=456,
title="Dummy session",
created=datetime(2021, 4, 9, 9, 11, 31),
modified=datetime(2021, 4, 9, 9, 11, 52),
zodb_path="nl/ict/software-development",
account=account,
)
model.Session.add(survey_session)
survey = self.portal.client.nl.ict["software-development"]
session_id = "++session++%d" % survey_session.id
traversed_survey_session = survey.restrictedTraverse(session_id)
with api.env.adopt_user(user=survey_session.account):
with self._get_view(
"report_company", traversed_survey_session, survey_session
) as view:
view.request.form = {
"form.widgets.conductor": "staff",
"form.widgets.country": "nl",
"form.widgets.employees": "10-49",
"form.widgets.referer": "health-safety-experts",
"form.widgets.workers_participated": False,
"form.widgets.needs_met": True,
"form.widgets.recommend_tool": True,
"form.buttons.next": "",
}
view()
timestamp = mock_applyChanges.call_args[0][0]["timestamp"]
self.assertLess(datetime.now() - timestamp, timedelta(seconds=3))
del view.request.form["form.buttons.next"]
view.request.form["form.buttons.previous"] = ""
view()
self.assertEqual(mock_applyChanges.call_count, 2)
timestamp = mock_applyChanges.call_args[0][0]["timestamp"]
self.assertLess(datetime.now() - timestamp, timedelta(seconds=3))
def create_session_risk(self):
with api.env.adopt_user(SITE_OWNER_NAME):
api.content.create(
container=self.portal.sectors, type="euphorie.country", id="eu"
)
client_country = api.content.create(
container=self.portal.client, type="euphorie.clientcountry", id="eu"
)
client_sector = api.content.create(
container=client_country, type="euphorie.clientsector", id="sector"
)
client_survey = api.content.create(
container=client_sector, type="euphorie.survey", id="survey"
)
sqlsession = Session()
account = model.Account(loginname="jane", password="******")
sqlsession.add(account)
session = model.SurveySession(
title="Session", zodb_path="eu/sector/survey", account=account
)
sqlsession.add(session)
sqlsession.flush()
module = session.addChild(
model.Module(
title="Root", module_id="1", zodb_path="1", has_description=False
)
)
module = module.__of__(client_survey)
risk = session.addChild(
model.Risk(
title="Risk 1",
risk_id="1",
zodb_path="1/1",
type="risk",
identification="no",
)
)
risk = risk.__of__(module)
return risk
def create_survey_session(title, survey, account=None):
"""Create a new survey session.
:param title: title for the new session.
:type title: unicode
:param survey: survey for which the session is being created
:type survey: :py:class:`euphorie.content.survey.Survey`
:rtype: :py:class:`euphorie.client.model.SurveySession` instance
"""
if account is None:
account = getSecurityManager().getUser()
sector = aq_parent(aq_inner(survey))
country = aq_parent(sector)
zodb_path = '%s/%s/%s' % (country.id, sector.id, survey.id)
survey_session = model.SurveySession(title=title,
zodb_path=zodb_path,
account=account)
Session.add(survey_session)
Session.flush() # flush so we get a session id
return survey_session
def test_survey_publication_date_views(self):
"""We have some views to display and set the published column
for a survey session
"""
with api.env.adopt_user("admin"):
survey = addSurvey(self.portal, BASIC_SURVEY)
account = addAccount(password="******")
survey_session = model.SurveySession(
id=123,
title="Dummy session",
created=datetime(2012, 4, 22, 23, 5, 12),
modified=datetime(2012, 4, 23, 11, 50, 30),
zodb_path="nl/ict/software-development",
account=account,
company=model.Company(country="nl",
employees="1-9",
referer="other"),
)
model.Session.add(survey_session)
survey = self.portal.client.nl.ict["software-development"]
session_id = "++session++%d" % survey_session.id
traversed_survey_session = survey.restrictedTraverse(session_id)
with api.env.adopt_user(user=survey_session.account):
with self._get_view("publication_date", traversed_survey_session,
survey_session) as view:
# The view is not callable but
# has traversable allowed attributes
self.assertRaises(ViewNotCallableError, view)
# We have some default values that will be changed
# when publishing/unpublishing the session
self.assertEqual(survey_session.last_publisher, None)
self.assertEqual(survey_session.published, None)
self.assertEqual(survey_session.last_modifier, None)
self.assertEqual(survey_session.review_state, "private")
# Calling set_date will result in having this session published
# and the publication time and the publisher will be recorded
# If no referer is set,
# the methods will redirect to the context url
self.assertEqual(
view.set_date(),
"{url}/{session_id}".format(url=survey.absolute_url(),
session_id=session_id),
)
self.assertEqual(survey_session.last_publisher,
survey_session.account)
self.assertIsInstance(survey_session.published, datetime)
self.assertEqual(survey_session.review_state, "published")
old_modified = survey_session.modified
old_published = survey_session.published
old_modifier = survey_session.last_modifier
# Changing the HTTP_REFERER will redirect there
# and calling reset_date will update the published date
view.request.set("HTTP_REFERER", "foo")
# We need to wait at least one second because the datetime
# is stored with that accuracy
sleep(1)
self.assertEqual(view.reset_date(), "foo")
self.assertEqual(survey_session.last_publisher,
survey_session.account)
# The publisher and publication dates are set. The modification date
# is not touched.
self.assertEqual(survey_session.modified, old_modified)
self.assertEqual(survey_session.last_modifier, old_modifier)
self.assertTrue(survey_session.published > old_published)
# Calling unset_date will restore the publication info
self.assertEqual(view.unset_date(), "foo")
self.assertEqual(survey_session.last_publisher, None)
self.assertEqual(survey_session.published, None)
self.assertEqual(survey_session.review_state, "private")
# We also have a menu view
with self._get_view("publication_menu", traversed_survey_session,
survey_session) as view:
soup = html.fromstring(view())
self.assertListEqual(
["publication_date/set_date#content"],
[
el.attrib["action"].rpartition("@@")[-1]
for el in soup.cssselect("form")
],
)
# We trigger the session to be private
survey_session.published = "foo"
soup = html.fromstring(view())
self.assertListEqual(
[
"publication_date/unset_date#content",
"publication_date/reset_date#content",
],
[
el.attrib["action"].rpartition("@@")[-1]
for el in soup.cssselect("form")
],
)
