def test_post_success(self):
self.maxDiff = None
request = LightRequest(**LIGHT_REQUEST_DICT)
self.cache_mock.get_and_remove.return_value = dump_xml(request.export_xml()).decode('utf-8')
token, encoded = self.get_token()
response = self.client.post(self.url, {'test_token': encoded})
# Context
self.assertIn('saml_request', response.context)
self.assertEqual(response.context['identity_provider_endpoint'],
'https://test.example.net/identity-provider-endpoint')
self.assertEqual(response.context['relay_state'], 'relay123')
self.assertEqual(response.context['error'], None)
# SAML Request
saml_request_xml = b64decode(response.context['saml_request'].encode('utf-8')).decode('utf-8')
self.assertIn(request.id, saml_request_xml) # light_request.id preserved
self.assertIn('<saml2:Issuer Format="urn:oasis:names:tc:SAML:2.0:nameid-format:entity">'
'https://test.example.net/saml/idp.xml</saml2:Issuer>', saml_request_xml)
self.assertIn('Destination="http://testserver/IdentityProviderResponse"', saml_request_xml)
self.assertIn('<Signature xmlns="http://www.w3.org/2000/09/xmldsig#"><SignedInfo>', saml_request_xml)
# Rendering
self.assertContains(response, 'Redirect to Identity Provider is in progress')
self.assertContains(response,
'<form class="auto-submit" action="https://test.example.net/identity-provider-endpoint"')
self.assertContains(response, '<input type="hidden" name="SAMLRequest" value="{}"'.format(
response.context['saml_request']))
self.assertContains(response, '<input type="hidden" name="RelayState" value="relay123"/>')
self.assertNotIn(b'An error occurred', response.content)
def test_export_xml_minimal_sample(self):
request = LightRequest(
citizen_country_code='CA', id='test-light-request-id',
level_of_assurance=LevelOfAssurance.LOW, requested_attributes={})
with cast(BinaryIO, (DATA_DIR / 'light_request_minimal.xml').open('rb')) as f:
data = f.read()
self.assertEqual(dump_xml(request.export_xml()), data)
def test_get_light_request_success(self):
orig_light_request = LightRequest(**LIGHT_REQUEST_DICT)
self.cache_mock.get_and_remove.return_value = dump_xml(orig_light_request.export_xml()).decode('utf-8')
token, encoded = self.get_token()
view = ProxyServiceRequestView()
view.request = self.factory.post(self.url, {'test_token': encoded})
view.light_token = token
view.storage = IgniteStorage('test.example.net', 1234, 'test-proxy-service-request-cache', '')
light_request = view.get_light_request()
self.assertEqual(light_request, orig_light_request)
self.maxDiff = None
self.assertEqual(self.client_mock.mock_calls,
[call.connect('test.example.net', 1234),
call.get_cache('test-proxy-service-request-cache'),
call.get_cache().get_and_remove('request-token-id')])
def test_post_remember_country_codes(self):
request = LightRequest(**LIGHT_REQUEST_DICT)
self.cache_mock.get_and_remove.return_value = dump_xml(request.export_xml()).decode('utf-8')
token, encoded = self.get_token()
response = self.client.post(self.url, {'test_token': encoded})
self.assertEqual(response.status_code, 200)
self.assertEqual(
self.client_mock.mock_calls,
[
call.connect('test.example.net', 1234),
call.get_cache('test-proxy-service-request-cache'),
call.get_cache().get_and_remove('request-token-id'),
call.connect('test.example.net', 1234),
call.get_cache('aux-cache'),
call.get_cache().put(
'aux-test-light-request-id',
'{"citizen_country": "CA", "origin_country": "CA"}'
),
]
)
def test_post_remember_name_id_format(self):
request = LightRequest(**LIGHT_REQUEST_DICT)
self.cache_mock.get_and_remove.return_value = dump_xml(request.export_xml()).decode('utf-8')
token, encoded = self.get_token()
response = self.client.post(self.url, {'test_token': encoded})
self.assertEqual(response.status_code, 200)
self.assertEqual(
self.client_mock.mock_calls,
[
call.connect('test.example.net', 1234),
call.get_cache('test-proxy-service-request-cache'),
call.get_cache().get_and_remove('request-token-id'),
call.connect('test.example.net', 1234),
call.get_cache('aux-cache'),
call.get_cache().put(
'aux-test-light-request-id',
'{"name_id_format": "urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified"}'
),
]
)
def test_post_remember_country_codes(self, uuid_mock):
self.maxDiff = None
saml_request_xml, saml_request_encoded = self.load_saml_request(
signed=True)
light_request = LightRequest(**LIGHT_REQUEST_DICT)
light_request.issuer = 'https://example.net/EidasNode/ConnectorMetadata'
self.cache_mock.get_and_remove.return_value = dump_xml(
light_request.export_xml()).decode('utf-8')
response = self.client.post(
self.url, {
'SAMLRequest': saml_request_encoded,
'RelayState': 'relay123',
'country_param': 'ca'
})
self.assertEqual(response.status_code, 200)
self.assertSequenceEqual(self.client_mock.mock_calls[-3:], [
call.connect('test.example.net', 1234),
call.get_cache('aux-cache'),
call.get_cache().put(
'aux-test-saml-request-id',
'{"citizen_country": "CA", "origin_country": "CA"}'),
])
def put_light_request(self, uid: str, request: LightRequest) -> None:
"""Store a LightRequest under a unique id."""
data = dump_xml(request.export_xml()).decode('utf-8')
LOGGER.debug('Store Light Request to cache: id=%r, data=%s', uid, data)
self.get_cache(self.request_cache_name).put(uid, data)
def test_post_success(self, uuid_mock: MagicMock):
self.maxDiff = None
saml_request_xml, saml_request_encoded = self.load_saml_request(
signed=True)
light_request = LightRequest(**LIGHT_REQUEST_DICT)
light_request.issuer = 'https://example.net/EidasNode/ConnectorMetadata'
self.cache_mock.get_and_remove.return_value = dump_xml(
light_request.export_xml()).decode('utf-8')
response = self.client.post(
self.url, {
'SAMLRequest': saml_request_encoded,
'RelayState': 'relay123',
'country_param': 'ca'
})
# Context
self.assertIn('token', response.context)
self.assertEqual(response.context['token_parameter'],
'test_request_token')
self.assertEqual(response.context['eidas_url'],
'http://test.example.net/SpecificConnectorRequest')
self.assertEqual(response.context['error'], None)
# Token
encoded_token = response.context['token']
token = LightToken.decode(encoded_token, 'sha256',
'request-token-secret')
self.assertEqual(token.id, 'T0uuid4')
self.assertEqual(token.issuer, 'request-token-issuer')
self.assertEqual(token.created, datetime(2017, 12, 11, 14, 12, 5))
# Storing light request
light_request_data = LIGHT_REQUEST_DICT.copy()
light_request_data.update({
'id': 'test-saml-request-id',
'issuer': 'test-connector-request-issuer',
})
light_request = LightRequest(**light_request_data)
light_request.requested_attributes = light_request.requested_attributes.copy(
)
del light_request.requested_attributes[
'http://eidas.europa.eu/attributes/naturalperson/AdditionalAttribute']
del light_request.requested_attributes[
'http://eidas.europa.eu/attributes/legalperson/LegalAdditionalAttribute']
self.assertEqual(self.client_class_mock.mock_calls, [call(timeout=66)])
self.assertEqual(self.client_mock.mock_calls, [
call.connect('test.example.net', 1234),
call.get_cache('test-connector-request-cache'),
call.get_cache().put(
'T0uuid4',
dump_xml(light_request.export_xml()).decode('utf-8'))
])
# Rendering
self.assertContains(response, 'Redirect to eIDAS Node is in progress')
self.assertContains(response, 'eidas_node/connector/formautosubmit.js')
self.assertContains(
response, '<form class="auto-submit" '
'action="http://test.example.net/SpecificConnectorRequest"')
self.assertContains(
response,
'<input type="hidden" name="test_request_token" value="{}"'.format(
encoded_token))
self.assertNotIn(b'An error occurred', response.content)