def __init__(self, integrator, shopping_cart_extension=None, additional_request_headers=()): MetaDataProvider.__validate_additional_request_headers( additional_request_headers) for i in additional_request_headers: i.name = re.sub(r'\r?\n(?:(?![\r\n])\s)*', " ", i.name) i.name = i.name.strip() i.value = re.sub(r'\r?\n(?:(?![\r\n])\s)*', " ", i.value) i.value = i.value.strip() server_meta_info = self.ServerMetaInfo() server_meta_info.platform_identifier = self._platform_identifier server_meta_info.sdk_identifier = self._sdk_identifier server_meta_info.sdk_creator = "Ingenico" server_meta_info.integrator = integrator server_meta_info.shopping_cart_extension = shopping_cart_extension server_meta_info_string = DefaultMarshaller.INSTANCE().marshal( server_meta_info) server_meta_info_header = RequestHeader( self.__SERVER_META_INFO_HEADER, b64encode(server_meta_info_string.encode('utf-8'))) if not additional_request_headers: self.__meta_data_headers = tuple([server_meta_info_header]) else: request_headers = [server_meta_info_header] request_headers.extend(additional_request_headers) self.__meta_data_headers = tuple(request_headers)
def assertServerMetaInfo(self, meta_data_provider, integrator, shopping_cart_extension=None, request_header=None): """Assert that checks that the request_header is the default header "X-GCS-ServerMetaInfo", that the server_meta_data_info of the meta_data_provider is correct and that the shopping cart extension is consistent with the extension stored in meta_data_provider """ self.assertEqual("X-GCS-ServerMetaInfo", request_header.name) self.assertIsNotNone(request_header.value) # server_meta_info is stored in json format and encoded using utf-8 and base64 encoding, decode it server_meta_info_json = base64.b64decode( request_header.value).decode('utf-8') server_meta_info = DefaultMarshaller.INSTANCE().unmarshal( server_meta_info_json, MetaDataProvider.ServerMetaInfo) self.assertEqual(meta_data_provider._platform_identifier, server_meta_info.platform_identifier) self.assertEqual(meta_data_provider._sdk_identifier, server_meta_info.sdk_identifier) self.assertEqual("Ingenico", server_meta_info.sdk_creator) self.assertEqual(integrator, server_meta_info.integrator) if shopping_cart_extension is None: self.assertIsNone(server_meta_info.shopping_cart_extension) else: self.assertEqual(shopping_cart_extension.creator, server_meta_info.shopping_cart_extension.creator) self.assertEqual(shopping_cart_extension.name, server_meta_info.shopping_cart_extension.name) self.assertEqual(shopping_cart_extension.version, server_meta_info.shopping_cart_extension.version) self.assertEqual( shopping_cart_extension.extension_id, server_meta_info.shopping_cart_extension.extension_id)
def create_helper_builder(secret_key_store): """ Creates a WebhooksHelperBuilder that will use the given SecretKeyStore. """ return WebhooksHelperBuilder().with_marshaller( DefaultMarshaller.INSTANCE()).with_secret_key_store( secret_key_store)
def test_create_communicator(self): """Tests that the factory is correctly able to create a communicator""" communicator = Factory.create_communicator_from_file( PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY) self.assertIs(communicator.marshaller, DefaultMarshaller.INSTANCE()) session = communicator._Communicator__session connection = session.connection self.assertIsInstance(connection, DefaultConnection) DefaultConnectionTest.assertConnection(self, connection, None, None, 100, None) authenticator = session.authenticator self.assertIsInstance(authenticator, DefaultAuthenticator) with warnings.catch_warnings(): warnings.simplefilter("ignore") self.assertEqual( AuthorizationType.V1HMAC, authenticator._DefaultAuthenticator__authorization_type) self.assertEqual(API_KEY_ID, authenticator._DefaultAuthenticator__api_id_key) self.assertEqual( SECRET_API_KEY, authenticator._DefaultAuthenticator__secret_api_key) meta_data_provider = session.meta_data_provider self.assertIsInstance(meta_data_provider, MetaDataProvider) request_headers = meta_data_provider.meta_data_headers self.assertEqual(1, len(request_headers)) self.assertEqual("X-GCS-ServerMetaInfo", request_headers[0].name)
def test_to_uri_with_request_parameters(self): """Tests if the communicator can correctly construct an url using a known base url, a relative url and a list of request parameters """ requestparams = [ RequestParam("amount", "123"), RequestParam("source", "USD"), RequestParam("target", "EUR"), RequestParam("dummy", "é&%=") ] patcher = patch( 'ingenico.connect.sdk.session.Session', api_endpoint=urlparse("https://api-sandbox.globalcollect.com")) session = patcher.start() communicator = Communicator(session, DefaultMarshaller.INSTANCE()) uri1 = communicator._to_absolute_uri("v1/merchant/20000/convertamount", requestparams) uri2 = communicator._to_absolute_uri( "/v1/merchant/20000/convertamount", requestparams) self.assertEqual( "https://api-sandbox.globalcollect.com/v1/merchant/20000/convertamount" "?amount=123&source=USD&target=EUR&dummy=%C3%A9%26%25%3D", uri1.geturl()) self.assertEqual( "https://api-sandbox.globalcollect.com/v1/merchant/20000/convertamount" "?amount=123&source=USD&target=EUR&dummy=%C3%A9%26%25%3D", uri2.geturl())
def test_unmarshal_extended_token_response(self): """Tests if the marshaller is able to marshal an object that inherits from token_response in such a way that it can be interpreted as a token_response """ token_response = TokenResponseWithExtraField() billing_address = Address() billing_address.country_code = "NL" customer = CustomerToken() customer.billing_address = billing_address card = TokenCard() card_data = TokenCardData() card.customer = customer card.data = card_data token_response.card = card token_response.extraField = "a random string" marshaller = DefaultMarshaller.INSTANCE() # Marshal the extended token response and unmarshal as a regular token response json = marshaller.marshal(token_response) unmarshalled = marshaller.unmarshal(json, TokenResponse) self.assertIsNotNone(unmarshalled.card) self.assertIsNotNone(unmarshalled.card.customer) self.assertIsNotNone(unmarshalled.card.customer.billing_address) self.assertEqual( "NL", unmarshalled.card.customer.billing_address.country_code) self.assertIsNotNone(unmarshalled.card.data)
def create_communicator_from_configuration(communicator_configuration): """ Create a Communicator based on the configuration stored in the CommunicatorConfiguration argument """ session = Factory.create_session_from_configuration( communicator_configuration) return Communicator(session, DefaultMarshaller.INSTANCE())
def create_communicator_from_file(configuration_file_name, api_key_id, secret_api_key): """ Creates a Communicator based on the configuration values in configuration_file_name, api_key_id and secret_api_key. """ configuration = Factory.create_configuration(configuration_file_name, api_key_id, secret_api_key) session = Factory.create_session_from_configuration(configuration) return Communicator(session, DefaultMarshaller.INSTANCE())
def test_with_client_meta_info(self): """Tests if the function withClientMetaInfo alters a client when it needs to and does nothing if not required""" client1 = Factory.create_client_from_file(PROPERTIES_URI, API_KEY_ID, SECRET_API_KEY) # client2 = client1.with_client_meta_info(None) client2 = client1.with_client_meta_info(None) client_meta_info = DefaultMarshaller.INSTANCE().marshal({"test": "test"}) client3 = client1.with_client_meta_info(client_meta_info) client4 = client3.with_client_meta_info(client_meta_info) client5 = client3.with_client_meta_info(None) self.assertIsNone(client1._client_headers) self.assertIs(client1, client2) self.assertIsNot(client1, client3) self.assertClientHeaders(client3, client_meta_info) self.assertIs(client3, client4) self.assertIsNot(client3, client5) self.assertIsNone(client5._client_headers)
def test_to_uri_without_request_parameters(self): """Tests if the communicator can correctly construct an url using a known base url and a relative url""" patcher = patch( 'ingenico.connect.sdk.session.Session', api_endpoint=urlparse("https://api-sandbox.globalcollect.com")) session = patcher.start() communicator = Communicator(session, DefaultMarshaller.INSTANCE()) uri1 = communicator._to_absolute_uri("v1/merchant/20000/convertamount", []) uri2 = communicator._to_absolute_uri( "/v1/merchant/20000/convertamount", []) self.assertEqual( "https://api-sandbox.globalcollect.com/v1/merchant/20000/convertamount", uri1.geturl()) self.assertEqual( "https://api-sandbox.globalcollect.com/v1/merchant/20000/convertamount", uri2.geturl())
def test_unmarshal_with_extra_fields(self): """Tests if the marshaller is able to marshal an object and unmarshal it as an instance of a parent class""" dummy_object = JsonDummyExtended() mini_dummy = JsonMiniDummy() mini_mini_dummy = JsonMiniMiniDummy() mini_mini_dummy.foo = "hiddenfoo" mini_dummy.foo = mini_mini_dummy dummy_object.foo = mini_dummy dummy_object.bar = True dummy_object.boo = 0o1 dummy_object.far = "close" dummy_object.extra_field = "something else" marshaller = DefaultMarshaller.INSTANCE() json = marshaller.marshal(dummy_object) unmarshalled = marshaller.unmarshal(json, JsonDummy) self.assertEqual(True, unmarshalled.bar) self.assertEqual(0o1, unmarshalled.boo) self.assertEqual("close", unmarshalled.far) self.assertEqual("hiddenfoo", unmarshalled.foo.foo.foo)
def create_communicator_from_session(session): """ Create a Communicator based on the settings stored in the Session argument """ return Communicator(session, DefaultMarshaller.INSTANCE())
def __create_helper(self, marshaller=DefaultMarshaller.INSTANCE()): return WebhooksHelper(marshaller, InMemorySecretKeyStore.INSTANCE())
def test_create_helper(self): helper = Webhooks.create_helper(InMemorySecretKeyStore.INSTANCE()) self.assertIs(DefaultMarshaller.INSTANCE(), helper.marshaller) self.assertIs(InMemorySecretKeyStore.INSTANCE(), helper.secret_key_store)