def test_config_sections(self): config = ConfigParams.from_tuples("Section1.Key1", "Value1", "Section1.Key2", "Value2", "Section1.Key3", "Value3") assert 3 == len(config) assert "Value1" == config.get("Section1.Key1") assert "Value2" == config.get("Section1.Key2") assert "Value3" == config.get("Section1.Key3") assert None == config.get("Section1.Key4") section2 = ConfigParams.from_tuples("Key1", "ValueA", "Key2", "ValueB") config.add_section("Section2", section2) assert 5 == len(config) assert "ValueA" == config.get("Section2.Key1") assert "ValueB" == config.get("Section2.Key2") sections = config.get_section_names() assert 2 == len(sections) assert "Section1" in sections assert "Section2" in sections section1 = config.get_section("Section1") assert 3 == len(section1) assert "Value1" == section1.get("Key1") assert "Value2" == section1.get("Key2") assert "Value3" == section1.get("Key3")
def test_read_config(self): config = ConfigParams.from_tuples("id", "ABC") name = NameResolver.resolve(config) assert "ABC" == name config = ConfigParams.from_tuples("name", "ABC") name = NameResolver.resolve(config) assert "ABC" == name
def test_concat_options(self): options1 = ConfigParams.from_tuples("host", "server1", "port", "8080", "param1", "ABC") options2 = ConfigParams.from_tuples("host", "server2", "port", "8080", "param2", "XYZ") options = ConnectionUtils.concat(options1, options2) assert len(options) == 4 assert "server1,server2" == options.get_as_nullable_string("host") assert "8080,8080" == options.get_as_nullable_string("port") assert "ABC" == options.get_as_nullable_string("param1") assert "XYZ" == options.get_as_nullable_string("param2")
def test_lookup(self): credential_resolver = CredentialResolver() credential = credential_resolver.lookup("correlation_id") assert None == credential RestConfigWithoutStoreKey = ConfigParams.from_tuples( "credential.username", "Negrienko", "credential.password", "qwerty", "credential.access_key", "key" ) credential_resolver = CredentialResolver(RestConfigWithoutStoreKey) credential = credential_resolver.lookup("correlation_id") assert "Negrienko" == credential.get("username") assert "qwerty" == credential.get("password") assert "key" == credential.get("access_key") assert None == credential.get("store_key") credential_resolver = CredentialResolver(RestConfig) credential = credential_resolver.lookup("correlation_id") assert None == credential credential_resolver.set_references(References()) try: credential = credential_resolver.lookup("correlation_id") except Exception as ex: assert "Cannot locate reference: Credential store wasn't found to make lookup" == ex.message
def test_get_open_api_override(self): open_api_content = "swagger yaml content" # recreate service with new configuration self.service.close(None) config = rest_config.set_defaults( ConfigParams.from_tuples("swagger.auto", False)) ctrl = DummyController() self.service = DummyCommandableHttpService() self.service.configure(config) references = References.from_tuples( Descriptor('pip-services-dummies', 'controller', 'default', 'default', '1.0'), ctrl, Descriptor('pip-services-dummies', 'service', 'http', 'default', '1.0'), self.service) self.service.set_references(references) try: self.service.open(None) response = requests.request('GET', 'http://localhost:3005/dummy/swagger') assert response.text == open_api_content finally: self.service.close(None)
def test_lookup_and_store(self): config = ConfigParams.from_tuples('key1.user', 'user1', 'key1.pass', 'pass1', 'key2.user', 'user2', 'key2.pass', 'pass2') credential_store = MemoryCredentialStore() credential_store.read_credentials(config) cred1 = credential_store.lookup('123', 'key1') cred2 = credential_store.lookup('123', 'key2') assert cred1.get_username() == 'user1' assert cred1.get_password() == 'pass1' assert cred2.get_username() == 'user2' assert cred2.get_password() == 'pass2' cred_config = CredentialParams.from_tuples('user', 'user3', 'pass', 'pass3', 'access_id', '123') credential_store.store(None, 'key3', cred_config) cred3 = credential_store.lookup('123', 'key3') assert cred3.get_username() == 'user3' assert cred3.get_password() == 'pass3' assert cred3.get_access_id() == '123'
def test_read_connections(self): config = ConfigParams.from_tuples("connections.key1.host", "10.1.1.100", "connections.key1.port", "8080", "connections.key2.host", "10.1.1.101", "connections.key2.port", "8082") discovery = MemoryDiscovery() discovery.configure(config) # Resolve one connection = discovery.resolve_one("123", "key1") assert "10.1.1.100" == connection.get_host() assert 8080 == connection.get_port() connection = discovery.resolve_one("123", "key2") assert "10.1.1.101" == connection.get_host() assert 8082 == connection.get_port() # Resolve all discovery.register(None, "key1", ConnectionParams.from_tuples("host", "10.3.3.151")) connections = discovery.resolve_all("123", "key1") assert len(connections) > 1
def setup_method(self, method): config = ConfigParams.from_tuples("options.timeout", 500) self.cache = MemoryCache() self.cache.configure(config) self.fixture = CacheFixture(self.cache)
def test_resolve_parameters(self): connection_resolver = HttpConnectionResolver() connection_resolver.configure( ConfigParams.from_tuples("connection.protocol", "http", "connection.host", "somewhere.com", "connection.port", 777)) connection = connection_resolver.resolve(None) assert connection.get_as_string('uri') == "http://somewhere.com:777"
def __init__(self): self._default_config = ConfigParams.from_tuples( "base_route", None, "dependencies.endpoint", "*:endpoint:http:*:1.0") # self._registered = False self._dependency_resolver = DependencyResolver() self._logger = CompositeLogger() self._counters = CompositeCounters()
def test_from_config(self): config = ConfigParams.from_tuples("name", "new name", "description", "new description", "properties.access_key", "key", "properties.store_key", "store key") context_info = ContextInfo.from_config(config) assert context_info.name == "new name" assert context_info.description == "new description"
def test_config_params(self): component_config = ComponentConfig() assert None == component_config.descriptor config = ConfigParams.from_tuples("config.key", "key", "config.key2", "key2") component_config.config = config assert component_config.config == config
def test_connection_uri(self): connection_resolver = HttpConnectionResolver() connection_resolver.configure(ConfigParams.from_tuples("connection.uri", "https://somewhere.com:123")) connection = connection_resolver.resolve(None) assert connection.get_protocol() == "https" assert connection.get_host() == "somewhere.com" assert connection.get_port() == 123 assert connection.get_uri() == "https://somewhere.com:123"
def test_exclude_keys(self): options1 = ConfigParams.from_tuples("host", "server1", "port", "8080", "param1", "ABC") options = ConnectionUtils.exclude(options1, "host", "port") assert len(options) == 1 assert options.get_as_nullable_string("host") is None assert options.get_as_nullable_string("port") is None assert "ABC" == options.get_as_nullable_string("param1")
def test_from_config(self): config = ConfigParams.from_tuples("field1.field11", 123, "field2", "ABC", "field1.field12", "XYZ") params = Parameters.from_config(config) assert 2 == len(params) assert "ABC" == params.get("field2") value = params.get_as_map("field1") assert 2 == len(value) assert "123" == value.get("field11") assert "XYZ" == value.get("field12")
def test_resolve_uri(self): connection_resolver = HttpConnectionResolver() connection_resolver.configure( ConfigParams.from_tuples("connection.uri", "http://somewhere.com:777")) connection = connection_resolver.resolve(None) assert connection.get_as_string('protocol') == "http" assert connection.get_as_string('host') == "somewhere.com" assert connection.get_as_integer('port') == 777 assert connection.get_as_string('uri') == "http://somewhere.com:777"
def setup_class(cls): if cls.mongoUri is None and cls.mongoHost is None: return db_config = ConfigParams.from_tuples('connection.uri', cls.mongoUri, 'connection.host', cls.mongoHost, 'connection.port', cls.mongoPort, 'connection.database', cls.mongoDatabase) cls.connection = MongoDbConnection() cls.connection.configure(db_config) cls.connection.open(None)
def __init__(self): """ Creates a new instance of the connection component. """ self.__default_config = ConfigParams.from_tuples( 'options.max_pool_size', 2, 'options.keep_alive', 1, 'options.connect_timeout', 5000, 'options.auto_reconnect', True, 'options.max_page_size', 100, 'options.debug', True) self._logger = CompositeLogger() self._connection_resolver = MongoDbConnectionResolver() self._options = ConfigParams()
def test_parse_uri_2(self): options = ConfigParams.from_tuples("host", "broker1,broker2", "port", ",8082", "username", "user", "password", "pass123", "param1", "ABC", "param2", "XYZ", "param3", None) uri = ConnectionUtils.compose_uri(options, "tcp", 9092) assert uri == "tcp://*****:*****@broker1:9092,broker2:8082?param1=ABC¶m2=XYZ¶m3" uri = ConnectionUtils.compose_uri(options, None, None) assert uri == "user:pass123@broker1,broker2:8082?param1=ABC¶m2=XYZ¶m3"
def setup_method(self, method=None): host = os.environ.get('PUSHGATEWAY_SERVICE_HOST') or 'localhost' port = os.environ.get('PUSHGATEWAY_SERVICE_PORT') or 9091 self.__counters = PrometheusCounters() self.__fixture = CountersFixture(self.__counters) config = ConfigParams.from_tuples('source', 'test', 'connection.host', host, 'connection.port', port) self.__counters.configure(config) self.__counters.open(None)
def setup_class(cls): if cls.mysql_uri is None and cls.mysql_host is None: return db_config = ConfigParams.from_tuples( 'connection.uri', cls.mysql_uri, 'connection.host', cls.mysql_host, 'connection.port', cls.mysql_port, 'connection.database', cls.mysql_database, 'credential.username', cls.mysql_user, 'credential.password', cls.mysql_password) cls.persistence = DummyMySqlPersistence() cls.fixture = DummyPersistenceFixture(cls.persistence) cls.persistence.configure(db_config) cls.persistence.open(None)
def setup_class(cls): if cls.mongoUri is None and cls.mongoHost is None: return db_config = ConfigParams.from_tuples('connection.uri', cls.mongoUri, 'connection.host', cls.mongoHost, 'connection.port', cls.mongoPort, 'connection.database', cls.mongoDatabase) cls.persistence = BeaconsMongoDbPersistence() cls.fixture = BeaconsPersistenceFixture(cls.persistence) cls.persistence.configure(db_config) cls.persistence.open(None)
def setup_class(cls): if cls.mysql_uri is None and cls.mysql_host is None: return db_config = ConfigParams.from_tuples( 'connection.uri', cls.mysql_uri, 'connection.host', cls.mysql_host, 'connection.port', cls.mysql_port, 'connection.database', cls.mysql_database, 'credential.username', cls.mysql_user, 'credential.password', cls.mysql_password) cls.connection = MySqlConnection() cls.connection.configure(db_config) cls.connection.open(None)
def __init__(self): """ Creates a new instance of the client. """ self._connection_resolver = HttpConnectionResolver() self._default_config = ConfigParams.from_tuples( "connection.protocol", "http", "connection.host", "0.0.0.0", "connection.port", 3000, "options.timeout", 10000, "options.request_max_size", 1024 * 1024, "options.connect_timeout", 10000, "options.retries", 3, "options.debug", True) self._logger = CompositeLogger() self._counters = CompositeCounters() self._options = ConfigParams() self._headers = {}
def setup_method(self): host = os.environ.get('MEMCACHED_SERVICE_HOST') or 'localhost' port = os.environ.get('MEMCACHED_SERVICE_PORT') or 11211 self._cache = MemcachedCache() config = ConfigParams.from_tuples('connection.host', host, 'connection.port', port) self._cache.configure(config) self._fixture = CacheFixture(self._cache) self._cache.open(None)
def setup_method(self): host = os.environ.get('REDIS_SERVICE_HOST') or 'localhost' port = os.environ.get('REDIS_SERVICE_PORT') or 6379 self._lock = RedisLock() config = ConfigParams.from_tuples('connection.host', host, 'connection.port', port) self._lock.configure(config) self._fixture = LockFixture(self._lock) self._lock.open(None)
def test_https_with_no_credentials_connection_params(self): connection_resolver = HttpConnectionResolver() connection_resolver.configure(ConfigParams.from_tuples( "connection.host", "somewhere.com", "connection.port", 123, "connection.protocol", "https", "credential.internal_network", "internal_network" )) connection = connection_resolver.resolve(None) assert 'https' == connection.get_protocol() assert 'somewhere.com' == connection.get_host() assert 123 == connection.get_port() assert 'https://somewhere.com:123' == connection.get_uri() assert connection.get('credential.internal_network')
def test_from_config(self): config = ConfigParams.from_tuples() try: component_config = ComponentConfig.from_config(config) except ConfigException as e: assert e.message == "Component configuration must have descriptor or type" config = ConfigParams.from_tuples("descriptor", "descriptor_name", "type", "type", "config.key", "key", "config.key2", "key2") try: component_config = ComponentConfig.from_config(config) except ConfigException as e: assert e.message == "Descriptor descriptor_name is in wrong format" descriptor = Descriptor("group", "type", "kind", "name", "version") tipe = TypeDescriptor("type", None) config = ConfigParams.from_tuples("descriptor", "group:type:kind:name:version", "type", "type", "config.key", "key", "config.key2", "key2") component_config = ComponentConfig.from_config(config) assert component_config.descriptor == descriptor assert component_config.type == tipe
def __init__(self): """ Creates HttpEndpoint """ self._default_config = ConfigParams.from_tuples( "connection.protocol", "http", "connection.host", "0.0.0.0", "connection.port", 3000, "credential.ssl_key_file", None, "credential.ssl_crt_file", None, "credential.ssl_ca_file", None, "options.maintenance_enabled", False, "options.request_max_size", 1024 * 1024, "options.file_max_size", 200 * 1024 * 1024, "connection.connect_timeout", 60000, "connection.debug", True) self._connection_resolver = HttpConnectionResolver() self._logger = CompositeLogger() self._counters = CompositeCounters() self._registrations = []
def test_https_with_no_credentials_connection_params(self): connection_resolver = HttpConnectionResolver() connection_resolver.configure( ConfigParams.from_tuples("connection.host", "somewhere.com", "connection.port", 123, "connection.protocol", "https", "credential.internal_network", "internal_network")) connection = connection_resolver.resolve(None) assert 'https' == connection.get_as_string('protocol') assert 'somewhere.com' == connection.get_as_string('host') assert 123 == connection.get_as_integer('port') assert 'https://somewhere.com:123' == connection.get_as_string('uri') assert connection.get_as_nullable_string('internal_network') is None