def test_about_view(self):
request = DummyRequest()
inst = self._makeOne(request)
result = inst.about_view()
self.assertEqual(result['page_title'], 'About')
def client(self):
return features.Client(DummyRequest(db=db.Session))
def test_init_initializes_an_empty_cache(self):
client = features.Client(DummyRequest())
assert client._cache == {}
def test_generate_pdf_with_amendement_content_factor_many_authors_groups(
app, lecture_senat, article1_senat, amendements_senat):
from zam_repondeur.export.pdf import generate_html_for_pdf
from zam_repondeur.models import Amendement, DBSession
amendement_6666 = amendements_senat[0]
amendement_6666.auteur = "M. JEAN"
amendement_6666.groupe = "Les Indépendants"
amendement_6666.user_content.avis = "Défavorable"
amendement_6666.user_content.objet = "L’objet"
amendement_6666.user_content.reponse = "La réponse"
DBSession.add(amendement_6666)
amendement_9999 = amendements_senat[1]
amendement_9999.auteur = "M. JEAN"
amendement_9999.groupe = "Les Indépendants"
amendement_9999.user_content.avis = "Défavorable"
amendement_9999.user_content.objet = "L’objet"
amendement_9999.user_content.reponse = "La réponse"
DBSession.add(amendement_9999)
Amendement.create(
lecture=lecture_senat,
article=article1_senat,
num=42,
position=3,
auteur="M. DUPONT",
groupe="RDSE",
avis="Défavorable",
objet="L’objet",
reponse="La réponse",
)
Amendement.create(
lecture=lecture_senat,
article=article1_senat,
num=57,
position=4,
auteur="M. DURAND",
groupe="Les Républicains",
avis="Défavorable",
objet="L’objet",
reponse="La réponse",
)
Amendement.create(
lecture=lecture_senat,
article=article1_senat,
num=72,
position=5,
auteur="M. MARTIN",
groupe="Les Républicains",
avis="Défavorable",
objet="L’objet",
reponse="La réponse",
)
Amendement.create(
lecture=lecture_senat,
article=article1_senat,
num=83,
position=6,
auteur="M. MARTIN",
groupe="Les Républicains",
avis="Défavorable",
objet="L’objet",
reponse="La réponse",
)
parser = HTMLParser(
generate_html_for_pdf(DummyRequest(), "print.html",
{"lecture": lecture_senat}))
assert (
parser.css_first(".first-page .lecture").text() ==
"Sénat, session 2017-2018, Séance publique, Numéro lecture, texte nº\xa063"
)
assert _html_page_titles(parser) == [
"Article 1",
"Réponse",
"Amendement nº 6666",
"Amendement nº 9999",
"Amendement nº 42",
"Amendement nº 57",
"Amendement nº 72",
"Amendement nº 83",
]
response_node = parser.css_first(".reponse")
assert _cartouche_to_list(response_node) == [
"Article",
"Art. 1",
"Amendements",
"6666, 9999, …, 57, 72 et 83 (6 au total)",
"Auteurs",
"M. DUPONT, M. DURAND, M. JEAN et M. MARTIN",
"Groupes",
"Les Indépendants, Les Républicains et RDSE",
"Avis",
"Défavorable",
]
assert response_node.css_first("div h5").text() == "Objet"
assert "L’objet" in response_node.css_first("div p").text()
assert response_node.css("div h5")[-1].text() == "Réponse"
assert "La réponse" in response_node.css("div p")[-1].text()
def pyramid_request(self):
return DummyRequest()
def test_forbidden(self):
from ...views.home import HomeView
view = HomeView(DummyResource(), DummyRequest())
self.assertSetEqual({'forgot_url', 'auth_url', 'add_url'},
set(view.auth().keys()))
def test_site_view(self):
request = DummyRequest()
inst = self._makeOne(request)
result = inst.site()
self.assertIn('Site View', result['page_title'])
def dummyrequest():
from pyramid.testing import DummyRequest, setUp, tearDown
request = DummyRequest()
setUp(request=request)
yield request
tearDown()
def test_multiple_openapi_views() -> None:
"""Test registration multiple openapi views."""
with testConfig() as config:
config.include("pyramid_openapi3")
with tempfile.NamedTemporaryFile() as document:
document.write(MINIMAL_DOCUMENT)
document.seek(0)
config.pyramid_openapi3_spec(
document.name,
route="/foo.yaml",
route_name="foo_api_spec",
apiname="foo",
)
with tempfile.NamedTemporaryFile() as document:
document.write(ALTERNATE_DOCUMENT)
document.seek(0)
config.pyramid_openapi3_spec(
document.name,
route="/bar.yaml",
route_name="bar_api_spec",
apiname="bar",
)
config.add_route("foo", "/foo")
view_func = lambda *arg: "foo" # noqa: E731
config.add_view(openapi=True,
renderer="json",
view=view_func,
route_name="foo")
config.add_route("bar", "/bar")
view_func = lambda *arg: "bar" # noqa: E731
config.add_view(openapi=True,
renderer="json",
view=view_func,
route_name="bar")
# Simulate, that `check_all_routes` was called
settings = config.registry.settings
settings.setdefault("pyramid_openapi3", {})
settings["pyramid_openapi3"].setdefault("routes", {})
settings["pyramid_openapi3"]["routes"]["foo"] = "foo"
settings["pyramid_openapi3"]["routes"]["bar"] = "bar"
request_interface = config.registry.queryUtility(IRouteRequest,
name="foo")
view = config.registry.adapters.registered(
(IViewClassifier, request_interface, Interface), IView, name="")
request = DummyRequest(config=config, content_type="text/html")
request.matched_route = DummyRoute(name="foo", pattern="/foo")
context = None
response = view(context, request)
assert response.json == "foo"
request_interface = config.registry.queryUtility(IRouteRequest,
name="bar")
view = config.registry.adapters.registered(
(IViewClassifier, request_interface, Interface), IView, name="")
request = DummyRequest(config=config, content_type="text/html")
request.matched_route = DummyRoute(name="bar", pattern="/bar")
context = None
response = view(context, request)
assert response.json == "bar"
def setUp(self):
request = DummyRequest()
self.config = setUp(request=request)
def test_site_view(self):
request = DummyRequest()
inst = self._makeOne(request)
result = inst.site_view()
self.assertTrue('form' in result.keys())
def test_updates_view(self):
request = DummyRequest()
inst = self._makeOne(request)
result = inst.updates_view()
self.assertEqual(len(result), 5)
def test_people_view(self):
request = DummyRequest()
inst = self._makeOne(request)
result = inst.people_view()
self.assertEqual(result["page_title"], "People")
self.assertEqual(len(result["people"]), 2)
def test_company_view(self):
request = DummyRequest()
inst = self._makeOne(request)
result = inst.company_view()
self.assertEqual(result["page_title"], "ACME, Inc. Projects")
self.assertEqual(len(result["projects"]), 2)
def test_notfound_view():
from pyramid_listing_example.views import notfound_view
request = DummyRequest()
assert notfound_view(request) == {}
assert request.response.status == "404 Not Found"
def _make_req(self):
req = DummyRequest()
req.registry.db = db
req.matchdict["doc_id"] = mock_doc.id
req.validated = {}
return req
def test_websocket_bad_origin(config):
config.registry.settings.update({'origins': 'http://good'})
config.include('h.streamer')
req = DummyRequest(headers={'Origin': 'http://bad'})
res = websocket(req)
assert res.code == 403
def setUp(self):
super(TestDynamoCache, self).setUp()
self.db = DynamoCache(DummyRequest(), **self.kwargs)
self.storage = self.db.storage = MagicMock(spec=IStorage)
def test_index(self, _p):
from ...views.home import HomeView
_p.return_value = []
view = HomeView(DummyResource(), DummyRequest())
response = view.index()
self.assertEqual(response, {'portlets': []})
def _backend(self, settings):
""" Wrapper to instantiate a ConfigAccessBackend """
kwargs = ConfigAccessBackend.configure(settings)
request = DummyRequest()
request.userid = None
return ConfigAccessBackend(request, **kwargs)
def test_login(self):
from pyramid.testing import DummyRequest
from c2cgeoportal_geoportal.views.entry import Entry
request = DummyRequest()
request.user = None
entry = Entry(request)
request.path = "/for_test"
expected = {
"lang": "fr",
"came_from": "/for_test",
}
self.assertEqual(entry.loginform403(), expected)
request.params = {
"came_from": "/for_a_second_test",
}
entry = Entry(request)
expected = {
"lang": "fr",
"came_from": "/for_a_second_test",
}
self.assertEqual(entry.loginform(), expected)
entry = Entry(request)
request.params = {}
expected = {
"lang": "fr",
"came_from": "/",
}
self.assertEqual(entry.loginform(), expected)
request.registry.settings = {
"functionalities": {
"anonymous": {
"func": ["anon"],
"toto": "titi"
},
"registered": {
"func": ["reg"]
},
"available_in_templates": ["func"]
},
"admin_interface": {
"available_functionalities": ["func"]
}
}
entry = Entry(request)
expected = {"functionalities": {"func": ["anon"]}}
self.assertEqual(entry.loginuser(), expected)
class G:
id = 123
def __init__(self, name, functionalities):
self.name = name
self.functionalities = functionalities
class U:
username = "******"
is_password_changed = True
def __init__(self, role="__test_role", functionalities=None):
if functionalities is None:
functionalities = []
self.role_name = role
self.role = G(role, functionalities)
request.user = U()
entry = Entry(request)
expected = {
"success": True,
"username": "******",
"is_password_changed": True,
"role_name": "__test_role",
"role_id": 123,
"functionalities": {
"func": ["reg"]
}
}
self.assertEqual(entry.loginuser(), expected)
class F:
name = "func"
value = "user"
request.user = U("__test_role2", [F()])
entry = Entry(request)
expected = {
"success": True,
"username": "******",
"is_password_changed": True,
"role_name": "__test_role2",
"role_id": 123,
"functionalities": {
"func": ["user"]
}
}
self.assertEqual(entry.loginuser(), expected)
def setUp(self):
self.request = DummyRequest()
self.request.userid = None
self.auth = ACLAuthorizationPolicy()
def test_generate_pdf_with_amendement_responses(app, lecture_senat,
article1_senat,
article1av_senat,
article7bis_senat):
from zam_repondeur.export.pdf import generate_html_for_pdf
from zam_repondeur.models import Amendement
amendement = Amendement.create(
lecture=lecture_senat,
article=article1_senat,
alinea="",
num=42,
rectif=1,
auteur="M. DUPONT",
groupe="RDSE",
matricule="000000",
corps="<p>L'article 1 est supprimé.</p>",
expose="<p>Cet article va à l'encontre du principe d'égalité.</p>",
resume="Suppression de l'article",
position=1,
avis="Favorable",
)
Amendement.create(
lecture=lecture_senat,
article=article1av_senat,
alinea="",
num=57,
auteur="M. DURAND",
groupe="Les Républicains",
matricule="000001",
corps="baz",
expose="qux",
)
Amendement.create(
lecture=lecture_senat,
article=article7bis_senat,
alinea="",
num=21,
auteur="M. MARTIN",
groupe=None,
matricule="000002",
corps="quux",
expose="quuz",
)
Amendement.create(
lecture=lecture_senat,
article=article1_senat,
alinea="",
num=43,
auteur="M. JEAN",
groupe="Les Indépendants",
matricule="000003",
corps="corge",
expose="grault",
)
Amendement.create(
lecture=lecture_senat,
article=article1_senat,
alinea="",
num=596,
rectif=1,
parent=amendement,
auteur="M. JEAN",
groupe="Les Indépendants",
matricule="000003",
corps="corge",
expose="grault",
)
parser = HTMLParser(
generate_html_for_pdf(DummyRequest(), "print.html",
{"lecture": lecture_senat}))
assert (
parser.css_first(".first-page .lecture").text() ==
"Sénat, session 2017-2018, Séance publique, Numéro lecture, texte nº\xa063"
)
assert _html_page_titles(parser) == [
"Article 1",
"Réponse",
"Amendement nº 42 rect.",
"Article 7 bis",
]
def test_site(self):
request = DummyRequest()
context = DummyResource()
inst = self._makeOne(context, request)
result = inst.root()
self.assertIn('Root', result['page_title'])
def dummyrequest(pyramidconfig):
from pyramid.testing import DummyRequest
request = DummyRequest()
pyramidconfig.begin(request=request)
yield request
def test_folder_view(self):
request = DummyRequest()
context = DummyResource()
inst = self._makeOne(context, request)
result = inst.folder()
self.assertIn('Folder', result['page_title'])
def test_init_stores_the_request(self):
request = DummyRequest()
client = features.Client(request)
assert client.request == request
def test_document_view(self):
request = DummyRequest()
context = DummyResource()
inst = self._makeOne(context, request)
result = inst.document()
self.assertIn('Document', result['page_title'])
def test_get_wps_output_context_validation():
bad_cases = [
"test/////test", "test/test//", "test/./test/test",
"test/../test/test", "/test/test/test/test", "/test/test/", "/test",
"/test/", "./test", "../test", "/"
]
good_cases = [
("test", "test"),
("test/test", "test/test"),
("test/test/", "test/test"), # allow trailing slash auto-removed
("test/test/test/test", "test/test/test/test"),
("test-test", "test-test"),
("test_test", "test_test"),
("test-test/test/test_test", "test-test/test/test_test"),
]
header_names = [
"x-wps-output-context", "X-WPS-OUTPUT-CONTEXT", "X-WPS-Output-Context"
]
for header in header_names:
for case in bad_cases:
# validate against provided header
try:
req = DummyRequest(headers={header: case})
get_wps_output_context(req)
except HTTPUnprocessableEntity:
pass
else:
pytest.fail(
"Exception not raised when expected: (header={}, case={})".
format(header, case))
# validate same conditions fulfilled by default context if header omitted
try:
settings = {"weaver.wps_output_context": case}
with mock.patch("weaver.wps.utils.get_settings",
return_value=settings):
req = DummyRequest(headers={})
get_wps_output_context(req)
except HTTPUnprocessableEntity:
pass
else:
pytest.fail(
"Exception not raised when expected: (<setting>, case={})".
format(case))
for case, result in good_cases:
# validate against provided header
try:
req = DummyRequest(headers={header: case})
ctx = get_wps_output_context(req)
assert ctx == result
except Exception as exc:
pytest.fail(
"Exception raised when none is expected: (header={}, case={})\n"
"Exception: {!s}: ${!s}".format(header, case,
exc.__class__.__name__,
exc))
# validate same conditions fulfilled by default context if header omitted
settings = {"weaver.wps_output_context": case}
with mock.patch("weaver.wps.utils.get_settings",
return_value=settings):
try:
req = DummyRequest(headers={})
ctx = get_wps_output_context(req)
assert ctx == result
except Exception as exc:
pytest.fail(
"Exception raised when none is expected: (<setting>, case={})\n"
"Exception: {!s}: ${!s}".format(
case, exc.__class__.__name__, exc))
def test_index_view(self):
request = DummyRequest()
inst = self._makeOne(request)
result = inst.index_view()
self.assertEqual(result['page_title'], 'Home')
