def test_requester_with_host_specific_proxies(self):
client = TestClient()
conf = textwrap.dedent("""
[proxies]
https=http://conan.url
only.for.this.conan.url = http://special.url
only.for.that.conan.url = http://user:[email protected]
http=
only.for.the.other.conan.url = http://other.special.url
""")
save(client.cache.conan_conf_path, conf)
requester = ConanRequester(client.cache.config)
def verify_proxies(url, **kwargs):
self.assertEqual(
kwargs["proxies"], {
"http://only.for.the.other.conan.url":
"http://other.special.url",
"https":
"http://conan.url",
"https://only.for.this.conan.url":
"http://special.url",
"https://only.for.that.conan.url":
"http://*****:*****@extra.special.url"
})
return "mocked ok!"
requester._http_requester.get = verify_proxies
self.assertFalse("NO_PROXY" in os.environ,
"Error: NO_PROXY=%s" % os.getenv("NO_PROXY"))
self.assertEqual(requester.get("MyUrl"), "mocked ok!")
def test_requester(self):
client = TestClient()
conf = """
[proxies]
https=None
no_proxy=http://someurl,http://otherurl.com
http=http://conan.url
"""
save(client.cache.conan_conf_path, conf)
with warnings.catch_warnings(record=True) as warn:
warnings.simplefilter("always")
requester = ConanRequester(client.cache.config)
def verify_proxies(url, **kwargs):
self.assertEqual(kwargs["proxies"], {
"https": None,
"http": "http://conan.url"
})
return "mocked ok!"
requester._http_requester.get = verify_proxies
self.assertEqual(os.environ["NO_PROXY"],
"http://someurl,http://otherurl.com")
self.assertEqual(requester.get("MyUrl"), "mocked ok!")
self.assertEqual(1, len(warn))
self.assertTrue(issubclass(warn[-1].category, UserWarning))
self.assertIn(
"proxies.no_proxy has been deprecated. "
"Use proxies.no_proxy_match instead", str(warn[-1].message))
def test_cache_config(self):
file_path = os.path.join(temp_folder(), "whatever_cacert")
save(file_path, "")
conan_conf = os.path.join(temp_folder(), "conan.conf")
save(conan_conf, normalize(default_client_conf))
replace_in_file(conan_conf,
"# cacert_path",
"cacert_path={}".format(file_path),
output=TestBufferConanOutput())
config = ConanClientConfigParser(conan_conf)
mocked_requester = MockRequesterGet()
requester = ConanRequester(config, mocked_requester)
requester.get(url="bbbb", verify=True)
self.assertEqual(mocked_requester.verify, file_path)
def test_environ_kept(self):
client = TestClient()
conf = """
[proxies]
"""
save(client.cache.conan_conf_path, conf)
requester = ConanRequester(client.cache.config)
def verify_env(url, **kwargs):
self.assertTrue("HTTP_PROXY" in os.environ)
with tools.environment_append({"HTTP_PROXY": "my_system_proxy"}):
requester._http_requester.get = verify_env
requester.get("MyUrl")
def test_cache_config(self):
cache = ClientCache(temp_folder(), TestBufferConanOutput())
file_path = os.path.join(cache.cache_folder, "whatever_cacert")
replace_in_file(cache.conan_conf_path,
"# cacert_path",
"cacert_path={}".format(file_path),
output=TestBufferConanOutput())
save(file_path, "")
cache.invalidate()
requester = ConanRequester(cache.config)
mocked_requester = MockRequesterGet()
requester._http_requester = mocked_requester
requester.get(url="bbbb", verify=True)
self.assertEqual(mocked_requester.verify, file_path)
def _init_collaborators(self, user_io=None):
output = TestBufferConanOutput()
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.runner = TestRunner(output, runner=self.conan_runner)
# Check if servers are real
real_servers = False
for server in self.servers.values():
if isinstance(server, str): # Just URI
real_servers = True
if real_servers:
requester = requests.Session()
else:
if self.requester_class:
requester = self.requester_class(self.servers)
else:
requester = TestRequester(self.servers)
self.requester = ConanRequester(requester, self.client_cache)
self.localdb, self.rest_api_client, self.remote_manager = Conan.instance_remote_manager(
self.requester, self.client_cache, self.user_io,
self.client_version, self.min_server_compatible_version)
set_global_instances(output, self.requester)
def setUpClass(cls):
if not cls.server:
cls.server = TestServerLauncher(
server_capabilities=['ImCool', 'TooCool'])
cls.server.start()
filename = os.path.join(temp_folder(), "conan.conf")
save(filename, "")
config = ConanClientConfigParser(filename)
requester = ConanRequester(config, requests)
client_factory = RestApiClientFactory(TestBufferConanOutput(),
requester=requester,
config=config)
localdb = LocalDBMock()
mocked_user_io = UserIO(out=TestBufferConanOutput())
mocked_user_io.get_username = Mock(return_value="private_user")
mocked_user_io.get_password = Mock(return_value="private_pass")
cls.auth_manager = ConanApiAuthManager(client_factory,
mocked_user_io, localdb)
cls.remote = Remote("myremote",
"http://127.0.0.1:%s" % str(cls.server.port),
True, True)
cls.auth_manager._authenticate(cls.remote,
user="******",
password="******")
cls.api = client_factory.new(cls.remote, localdb.access_token,
localdb.refresh_token, {})
def _init_collaborators(self, user_io=None):
output = TestBufferConanOutput()
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.cache = ClientCache(self.base_folder, self.storage_folder, output)
self.runner = TestRunner(output, runner=self.conan_runner)
# Check if servers are real
real_servers = False
for server in self.servers.values():
if isinstance(server, str) or isinstance(
server, ArtifactoryServer): # Just URI
real_servers = True
break
with tools.environment_append(self.cache.config.env_vars):
if real_servers:
requester = requests.Session()
else:
if self.requester_class:
requester = self.requester_class(self.servers)
else:
requester = TestRequester(self.servers)
self.requester = ConanRequester(requester, self.cache,
get_request_timeout())
self.hook_manager = HookManager(self.cache.hooks_path,
get_env("CONAN_HOOKS", list()),
self.user_io.out)
self.localdb, self.rest_api_client, self.remote_manager = \
Conan.instance_remote_manager(self.requester, self.cache,
self.user_io, self.hook_manager)
return output, self.requester
def _init_collaborators(self, user_io=None):
output = TestBufferConanOutput()
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.runner = TestRunner(output, runner=self.conan_runner)
# Check if servers are real
real_servers = False
for server in self.servers.values():
if isinstance(server, str): # Just URI
real_servers = True
with tools.environment_append(self.client_cache.conan_config.env_vars):
if real_servers:
requester = requests.Session()
else:
if self.requester_class:
requester = self.requester_class(self.servers)
else:
requester = TestRequester(self.servers)
self.requester = ConanRequester(requester, self.client_cache,
get_request_timeout())
self.plugin_manager = PluginManager(
self.client_cache.plugins_path,
get_env("CONAN_PLUGINS", list()), self.user_io.out)
self.localdb, self.rest_api_client, self.remote_manager = Conan.instance_remote_manager(
self.requester, self.client_cache, self.user_io,
self.client_version, self.min_server_compatible_version,
self.plugin_manager)
set_global_instances(output, self.requester)
def test_requester(self):
client = TestClient()
conf = """
[proxies]
https=None
no_proxy=http://someurl,http://otherurl.com
http=http://conan.url
"""
save(client.cache.conan_conf_path, conf)
client.cache.invalidate()
requester = ConanRequester(client.cache.config)
def verify_proxies(url, **kwargs):
self.assertEqual(kwargs["proxies"], {"https": None, "http": "http://conan.url"})
return "mocked ok!"
requester._http_requester.get = verify_proxies
self.assertEqual(os.environ["NO_PROXY"], "http://someurl,http://otherurl.com")
self.assertEqual(requester.get("MyUrl"), "mocked ok!")
def test_user_agent(self):
cache_folder = temp_folder()
cache = ClientCache(cache_folder, TestBufferConanOutput())
mock_http_requester = MagicMock()
requester = ConanRequester(cache.config, mock_http_requester)
requester.get(url="aaa")
headers = mock_http_requester.get.call_args[1]["headers"]
self.assertIn("Conan/%s" % __version__, headers["User-Agent"])
requester.get(url="aaa", headers={"User-Agent": "MyUserAgent"})
headers = mock_http_requester.get.call_args[1]["headers"]
self.assertEqual("MyUserAgent", headers["User-Agent"])
def setUpClass(cls):
if not cls.server:
cls.server = TestServerLauncher(
server_capabilities=['ImCool', 'TooCool'])
cls.server.start()
filename = os.path.join(temp_folder(), "conan.conf")
save(filename, "")
config = ConanClientConfigParser(filename)
requester = ConanRequester(config, requests)
cls.api = RestApiClient(TestBufferConanOutput(),
requester=requester,
revisions_enabled=False)
cls.api.remote_url = "http://127.0.0.1:%s" % str(cls.server.port)
# Authenticate user
token = cls.api.authenticate("private_user", "private_pass")
cls.api.token = token
def init_dynamic_vars(self, user_io=None):
# Migration system
output = TestBufferConanOutput()
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.cache = ClientCache(self.base_folder, output)
# Migration system
migrator = ClientMigrator(self.cache, Version(__version__), output)
migrator.migrate()
http_requester = self._get_http_requester()
config = self.cache.config
if self.conan_runner:
self.runner = self.conan_runner
else:
self.runner = ConanRunner(config.print_commands_to_output,
config.generate_run_log_file,
config.log_run_to_output,
output=output)
self.requester = ConanRequester(config, http_requester)
self.hook_manager = HookManager(self.cache.hooks_path, config.hooks,
self.user_io.out)
put_headers = self.cache.read_put_headers()
self.rest_api_client = RestApiClient(
self.user_io.out,
self.requester,
revisions_enabled=config.revisions_enabled,
put_headers=put_headers)
# To store user and token
self.localdb = LocalDB.create(self.cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(self.rest_api_client, self.user_io,
self.localdb)
# Handle remote connections
self.remote_manager = RemoteManager(self.cache, auth_manager,
self.user_io.out,
self.hook_manager)
return output, self.requester
def test_environ_removed(self):
client = TestClient()
conf = """
[proxies]
no_proxy_match=MyExcludedUrl*
"""
save(client.cache.conan_conf_path, conf)
requester = ConanRequester(client.cache.config)
def verify_env(url, **kwargs):
self.assertFalse("HTTP_PROXY" in os.environ)
self.assertFalse("http_proxy" in os.environ)
with tools.environment_append({"http_proxy": "my_system_proxy"}):
requester._http_requester.get = verify_env
requester.get("MyUrl")
self.assertEqual(os.environ["http_proxy"], "my_system_proxy")
with tools.environment_append({"HTTP_PROXY": "my_system_proxy"}):
requester._http_requester.get = verify_env
requester.get("MyUrl")
self.assertEqual(os.environ["HTTP_PROXY"], "my_system_proxy")
def get_basic_requester(client_cache):
requester = requests.Session()
# Manage the verify and the client certificates and setup proxies
return ConanRequester(requester, client_cache)
def _create_requesters(cache_folder=None):
cache = ClientCache(cache_folder or temp_folder(),
TestBufferConanOutput())
mock_requester = MockRequesterGet()
requester = ConanRequester(cache.config, mock_requester)
return requester, mock_requester, cache
