def setUp(self):
self.server = TestServerLauncher()
self.server.start()
self.api = RestApiClient(ConanOutput(sys.stdout, Color),
requester=requests)
self.api.remote_url = "http://localhost:%s" % str(self.server.port)
time.sleep(0.05) # necessary in linux
# Authenticate user
token = self.api.authenticate("private_user", "private_pass")
self.api.token = token
self.local_folder = temp_folder()
def init_dynamic_vars(self, user_io=None):
output = TestBufferConanOutput()
# Migration system
self.paths = migrate_and_get_paths(self.base_folder,
output,
storage_folder=self.storage_folder)
self.user_io = user_io or MockedUserIO(self.users, out=output)
self.runner = TestRunner(output)
requester = TestRequester(self.servers)
# Verify client version against remotes
self.requester = VersionCheckerRequester(
requester, self.client_version, self.min_server_compatible_version,
output)
self.rest_api_client = RestApiClient(output, requester=self.requester)
# To store user and token
self.localdb = LocalDB(self.paths.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.paths, self.servers.items(),
auth_manager, self.user_io.out)
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
else:
if self.requester_class:
requester = self.requester_class(self.servers)
else:
requester = TestRequester(self.servers)
# Verify client version against remotes
self.requester = VersionCheckerRequester(requester, self.client_version,
self.min_server_compatible_version, output)
put_headers = self.client_cache.read_put_headers()
self.rest_api_client = RestApiClient(output, requester=self.requester, put_headers=put_headers)
# To store user and token
self.localdb = LocalDB(self.client_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.client_cache, auth_manager, self.user_io.out)
def setUp(self):
self.server = TestServerLauncher()
self.server.start()
self.api = RestApiClient(ConanOutput(sys.stdout, Color), requester=requests)
self.api.remote_url = "http://localhost:%s" % str(self.server.port)
time.sleep(0.05) # necessary in linux
# Authenticate user
token = self.api.authenticate("private_user", "private_pass")
self.api.token = token
self.local_folder = temp_folder()
def setUpClass(cls):
if not cls.server:
cls.server = TestServerLauncher(
server_capabilities=['ImCool', 'TooCool'])
cls.server.start()
cls.api = RestApiClient(TestBufferConanOutput(),
requester=requests)
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 setUpClass(cls):
if not cls.server:
plugin = VersionCheckerPlugin(Version("0.16.0"), Version("0.16.0"), ["ImCool"])
cls.server = TestServerLauncher(server_version=Version("0.16.0"),
min_client_compatible_version=Version("0.16.0"),
plugins=[plugin])
cls.server.start()
cls.api = RestApiClient(TestBufferConanOutput(), requester=requests)
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 setUp(self):
mocked_user_io = UserIO(out=TestBufferConanOutput())
mocked_user_io.get_username = Mock(return_value="myuser")
mocked_user_io.get_password = Mock(return_value="mypassword")
requester = RequesterWithTokenMock()
self.rest_client = RestApiClient(mocked_user_io.out,
requester,
revisions_enabled=False,
put_headers=None)
self.localdb = LocalDBMock()
self.auth_manager = ConanApiAuthManager(self.rest_client,
mocked_user_io, self.localdb)
self.auth_manager.remote = Remote("myremote", "myurl", True, True)
self.auth_manager.user = None
def instance_remote_manager(client_cache):
requester = requests.Session()
requester.proxies = client_cache.conan_config.proxies
# Verify client version against remotes
version_checker_requester = VersionCheckerRequester(requester, Version(CLIENT_VERSION),
Version(MIN_SERVER_COMPATIBLE_VERSION),
out)
# To handle remote connections
rest_api_client = RestApiClient(out, requester=version_checker_requester)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, out)
return remote_manager
def instance_remote_manager(client_cache):
requester = get_basic_requester(client_cache)
# Verify client version against remotes
version_checker_req = VersionCheckerRequester(requester, Version(client_version),
Version(MIN_SERVER_COMPATIBLE_VERSION),
out)
# To handle remote connections
put_headers = client_cache.read_put_headers()
rest_api_client = RestApiClient(out, requester=version_checker_req,
put_headers=put_headers)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, out)
return remote_manager
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 main(args):
""" main entry point of the conans application, using a Command to
parse parameters
"""
if hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
import colorama
colorama.init()
color = True
else:
color = False
out = ConanOutput(sys.stdout, color)
user_io = UserIO(out=out)
user_folder = os.path.expanduser("~")
paths = migrate_and_get_paths(user_folder, out)
# Verify client version against remotes
version_checker_requester = VersionCheckerRequester(
requests, Version(CLIENT_VERSION),
Version(MIN_SERVER_COMPATIBLE_VERSION), out)
# To handle remote connections
rest_api_client = RestApiClient(out, requester=version_checker_requester)
# To store user and token
localdb = LocalDB(paths.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(paths, paths.conan_config.remotes,
auth_manager, out)
command = Command(paths, user_io, os.system, remote_manager, localdb)
current_dir = os.getcwd()
try:
import signal
def sigint_handler(signal, frame):
print('You pressed Ctrl+C!')
sys.exit(0)
signal.signal(signal.SIGINT, sigint_handler)
error = command.run(args)
finally:
os.chdir(current_dir)
sys.exit(error)
def instance_remote_manager(requester, client_cache, user_io, _client_version,
min_server_compatible_version):
# Verify client version against remotes
version_checker_req = VersionCheckerRequester(requester, _client_version,
min_server_compatible_version,
user_io.out)
# To handle remote connections
put_headers = client_cache.read_put_headers()
rest_api_client = RestApiClient(user_io.out, requester=version_checker_req,
put_headers=put_headers)
# To store user and token
localdb = LocalDB(client_cache.localdb)
# Wraps RestApiClient to add authentication support (same interface)
auth_manager = ConanApiAuthManager(rest_api_client, user_io, localdb)
# Handle remote connections
remote_manager = RemoteManager(client_cache, auth_manager, user_io.out)
return localdb, rest_api_client, remote_manager
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
class RestApiTest(unittest.TestCase):
def setUp(self):
self.server = TestServerLauncher()
self.server.start()
self.api = RestApiClient(ConanOutput(sys.stdout, Color), requester=requests)
self.api.remote_url = "http://*****:*****@private_user/testing")
self._upload_conan(conan_reference)
# Get the conans
conan = self.api.get_conan(conan_reference)
self.assertIsNotNone(conan)
self.assertIn(CONANFILE, conan)
self.assertIn(CONAN_MANIFEST, conan)
def get_conan_digest_test(self):
# Upload a conans
conan_reference = ConanFileReference.loads("conan2/1.0.0@private_user/testing")
self._upload_conan(conan_reference)
# Get the conans digest
digest = self.api.get_conan_digest(conan_reference)
self.assertEquals(digest.sha, "thesha")
self.assertEquals(digest.time, 123123123)
def get_package_test(self):
# Upload a conans
conan_reference = ConanFileReference.loads("conan3/1.0.0@private_user/testing")
self._upload_conan(conan_reference)
# Upload an package
package_reference = PackageReference(conan_reference, "1F23223EFDA")
self._upload_package(package_reference)
# Get the package
package = self.api.get_package(package_reference)
self.assertIsNotNone(package)
self.assertIn("hello.cpp", package)
def upload_huge_conan_test(self):
# Upload a conans
conan_reference = ConanFileReference.loads("conanhuge/1.0.0@private_user/testing")
files = {"file%s.cpp" % name: "File conent" for name in xrange(1000)}
self._upload_conan(conan_reference, files)
# Get the conans
pack = self.api.get_conan(conan_reference)
self.assertIsNotNone(pack)
self.assertIn("file999.cpp", pack)
def search_test(self):
# Upload a conan1
conan_name1 = "HelloOnly/0.10@private_user/testing"
conan_reference1 = ConanFileReference.loads(conan_name1)
self._upload_conan(conan_reference1)
# Upload an package
conan_info = """[settings]
arch: x86_64
compiler: gcc
os: Linux
[options]
386: False
[requires]
Hello
Bye/2.9
Say/2.1@user/testing
Chat/2.1@user/testing:SHA_ABC
"""
package_reference = PackageReference(conan_reference1, "1F23223EFDA")
self._upload_package(package_reference, {CONANINFO: conan_info})
# Upload a conan2
conan_name2 = "helloonlyToo/2.1@private_user/stable"
conan_reference2 = ConanFileReference.loads(conan_name2)
self._upload_conan(conan_reference2)
# Get the info about this ConanFileReference
info = self.api.search("helloonly*")
expected_info1 = {"1F23223EFDA": ConanInfo.loads(conan_info)}
expected_info2 = {}
self.assertEqual(expected_info1, info[conan_reference1])
self.assertEqual(expected_info2, info[conan_reference2])
# Get the info about this ConanFileReference
info = self.api.search("HelloOnly*", ignorecase=False)
expected_info = {"1F23223EFDA": ConanInfo.loads(conan_info)}
self.assertEqual({conan_reference1: expected_info}, info)
def remove_test(self):
# Upload a conans
conan_reference1 = ConanFileReference.loads("MyFirstConan/1.0.0@private_user/testing")
self._upload_conan(conan_reference1)
path1 = self.server.paths.conan(conan_reference1)
self.assertTrue(os.path.exists(path1))
# Remove conans and packages
self.api.remove(conan_reference1)
self.assertFalse(os.path.exists(path1))
def remove_packages_test(self):
conan_ref = ConanFileReference.loads("MySecondConan/2.0.0@private_user/testing")
self._upload_conan(conan_ref)
folders = {}
for sha in ["1", "2", "3", "4", "5"]:
# Upload an package
package_ref = PackageReference(conan_ref, sha)
self._upload_package(package_ref)
folder = self.server.paths.package(package_ref)
self.assertTrue(os.path.exists(folder))
folders[sha] = folder
self.api.remove_packages(conan_ref, ["1"])
self.assertTrue(os.path.exists(self.server.paths.conan(conan_ref)))
self.assertFalse(os.path.exists(folders["1"]))
self.assertTrue(os.path.exists(folders["2"]))
self.assertTrue(os.path.exists(folders["3"]))
self.assertTrue(os.path.exists(folders["4"]))
self.assertTrue(os.path.exists(folders["5"]))
self.api.remove_packages(conan_ref, ["2", "3"])
self.assertTrue(os.path.exists(self.server.paths.conan(conan_ref)))
self.assertFalse(os.path.exists(folders["1"]))
self.assertFalse(os.path.exists(folders["2"]))
self.assertFalse(os.path.exists(folders["3"]))
self.assertTrue(os.path.exists(folders["4"]))
self.assertTrue(os.path.exists(folders["5"]))
self.api.remove_packages(conan_ref)
self.assertTrue(os.path.exists(self.server.paths.conan(conan_ref)))
for sha in ["1", "2", "3", "4", "5"]:
self.assertFalse(os.path.exists(folders[sha]))
def _upload_package(self, package_reference, base_files=None):
files = hello_source_files(3, [1, 12])
if base_files:
files.update(base_files)
self.api.upload_package(package_reference, files)
def _upload_conan(self, conan_reference, base_files=None):
files = hello_source_files(3, [1, 12])
if base_files:
files.update(base_files)
content = """
from conans import ConanFile
class MyConan(ConanFile):
name = "%s"
version = "%s"
settings = arch, compiler, os
""" % (conan_reference.name, conan_reference.version)
files[CONANFILE] = content
files_md5s = {filename: md5(content) for filename, content in files.iteritems()}
conan_digest = FileTreeManifest(123123123, files_md5s)
files[CONAN_MANIFEST] = str(conan_digest)
self.api.upload_conan(conan_reference, files)
def relative_url_completion_test(self):
api = RestApiClient(TestBufferConanOutput(), requester=requests)
# test absolute urls
self.assertEquals(api._complete_url("http://host"), "http://host")
self.assertEquals(api._complete_url("http://host:1234"), "http://host:1234")
self.assertEquals(api._complete_url("https://host"), "https://host")
self.assertEquals(api._complete_url("https://host:1234"), "https://host:1234")
# test relative urls
api.remote_url = "http://host"
self.assertEquals(api._complete_url("v1/path_to_file.txt"),
"http://host/v1/path_to_file.txt")
api.remote_url = "http://host:1234"
self.assertEquals(api._complete_url("v1/path_to_file.txt"),
"http://host:1234/v1/path_to_file.txt")
api.remote_url = "https://host"
self.assertEquals(api._complete_url("v1/path_to_file.txt"),
"https://host/v1/path_to_file.txt")
api.remote_url = "https://host:1234"
self.assertEquals(api._complete_url("v1/path_to_file.txt"),
"https://host:1234/v1/path_to_file.txt")
# test relative urls with subdirectory
api.remote_url = "https://host:1234/subdir/"
self.assertEquals(api._complete_url("v1/path_to_file.txt"),
"https://host:1234/subdir/v1/path_to_file.txt")
def relative_url_completion_test(self):
api = RestApiClient(TestBufferConanOutput(), requester=requests)
# test absolute urls
self.assertEquals(api._complete_url("http://host"), "http://host")
self.assertEquals(api._complete_url("http://host:1234"),
"http://host:1234")
self.assertEquals(api._complete_url("https://host"), "https://host")
self.assertEquals(api._complete_url("https://host:1234"),
"https://host:1234")
# test relative urls
api.remote_url = "http://host"
self.assertEquals(api._complete_url("v1/path_to_file.txt"),
"http://host/v1/path_to_file.txt")
api.remote_url = "http://host:1234"
self.assertEquals(api._complete_url("v1/path_to_file.txt"),
"http://host:1234/v1/path_to_file.txt")
api.remote_url = "https://host"
self.assertEquals(api._complete_url("v1/path_to_file.txt"),
"https://host/v1/path_to_file.txt")
api.remote_url = "https://host:1234"
self.assertEquals(api._complete_url("v1/path_to_file.txt"),
"https://host:1234/v1/path_to_file.txt")
# test relative urls with subdirectory
api.remote_url = "https://host:1234/subdir/"
self.assertEquals(api._complete_url("v1/path_to_file.txt"),
"https://host:1234/subdir/v1/path_to_file.txt")
class RestApiTest(unittest.TestCase):
def setUp(self):
self.server = TestServerLauncher()
self.server.start()
self.api = RestApiClient(ConanOutput(sys.stdout, Color),
requester=requests)
self.api.remote_url = "http://*****:*****@private_user/testing")
self._upload_conan(conan_reference)
# Get the conans
conan = self.api.get_conan(conan_reference)
self.assertIsNotNone(conan)
self.assertIn(CONANFILE, conan)
self.assertIn(CONAN_MANIFEST, conan)
def get_conan_digest_test(self):
# Upload a conans
conan_reference = ConanFileReference.loads(
"conan2/1.0.0@private_user/testing")
self._upload_conan(conan_reference)
# Get the conans digest
digest = self.api.get_conan_digest(conan_reference)
self.assertEquals(digest.sha, "thesha")
self.assertEquals(digest.time, 123123123)
def get_package_test(self):
# Upload a conans
conan_reference = ConanFileReference.loads(
"conan3/1.0.0@private_user/testing")
self._upload_conan(conan_reference)
# Upload an package
package_reference = PackageReference(conan_reference, "1F23223EFDA")
self._upload_package(package_reference)
# Get the package
package = self.api.get_package(package_reference)
self.assertIsNotNone(package)
self.assertIn("hello.cpp", package)
def upload_huge_conan_test(self):
# Upload a conans
conan_reference = ConanFileReference.loads(
"conanhuge/1.0.0@private_user/testing")
files = {"file%s.cpp" % name: "File conent" for name in range(1000)}
self._upload_conan(conan_reference, files)
# Get the conans
pack = self.api.get_conan(conan_reference)
self.assertIsNotNone(pack)
self.assertIn("file999.cpp", pack)
def search_test(self):
# Upload a conan1
conan_name1 = "HelloOnly/0.10@private_user/testing"
conan_reference1 = ConanFileReference.loads(conan_name1)
self._upload_conan(conan_reference1)
# Upload an package
conan_info = """[settings]
arch: x86_64
compiler: gcc
os: Linux
[options]
386: False
[requires]
Hello
Bye/2.9
Say/2.1@user/testing
Chat/2.1@user/testing:SHA_ABC
"""
package_reference = PackageReference(conan_reference1, "1F23223EFDA")
self._upload_package(package_reference, {CONANINFO: conan_info})
# Upload a conan2
conan_name2 = "helloonlyToo/2.1@private_user/stable"
conan_reference2 = ConanFileReference.loads(conan_name2)
self._upload_conan(conan_reference2)
# Get the info about this ConanFileReference
info = self.api.search("helloonly*")
expected_info1 = {"1F23223EFDA": ConanInfo.loads(conan_info)}
expected_info2 = {}
self.assertEqual(expected_info1, info[conan_reference1])
self.assertEqual(expected_info2, info[conan_reference2])
# Get the info about this ConanFileReference
info = self.api.search("HelloOnly*", ignorecase=False)
expected_info = {"1F23223EFDA": ConanInfo.loads(conan_info)}
self.assertEqual({conan_reference1: expected_info}, info)
def remove_test(self):
# Upload a conans
conan_reference1 = ConanFileReference.loads(
"MyFirstConan/1.0.0@private_user/testing")
self._upload_conan(conan_reference1)
path1 = self.server.paths.conan(conan_reference1)
self.assertTrue(os.path.exists(path1))
# Remove conans and packages
self.api.remove(conan_reference1)
self.assertFalse(os.path.exists(path1))
def remove_packages_test(self):
conan_ref = ConanFileReference.loads(
"MySecondConan/2.0.0@private_user/testing")
self._upload_conan(conan_ref)
folders = {}
for sha in ["1", "2", "3", "4", "5"]:
# Upload an package
package_ref = PackageReference(conan_ref, sha)
self._upload_package(package_ref)
folder = self.server.paths.package(package_ref)
self.assertTrue(os.path.exists(folder))
folders[sha] = folder
self.api.remove_packages(conan_ref, ["1"])
self.assertTrue(os.path.exists(self.server.paths.conan(conan_ref)))
self.assertFalse(os.path.exists(folders["1"]))
self.assertTrue(os.path.exists(folders["2"]))
self.assertTrue(os.path.exists(folders["3"]))
self.assertTrue(os.path.exists(folders["4"]))
self.assertTrue(os.path.exists(folders["5"]))
self.api.remove_packages(conan_ref, ["2", "3"])
self.assertTrue(os.path.exists(self.server.paths.conan(conan_ref)))
self.assertFalse(os.path.exists(folders["1"]))
self.assertFalse(os.path.exists(folders["2"]))
self.assertFalse(os.path.exists(folders["3"]))
self.assertTrue(os.path.exists(folders["4"]))
self.assertTrue(os.path.exists(folders["5"]))
self.api.remove_packages(conan_ref)
self.assertTrue(os.path.exists(self.server.paths.conan(conan_ref)))
for sha in ["1", "2", "3", "4", "5"]:
self.assertFalse(os.path.exists(folders[sha]))
def _upload_package(self, package_reference, base_files=None):
files = hello_source_files(3, [1, 12])
if base_files:
files.update(base_files)
self.api.upload_package(package_reference, files)
def _upload_conan(self, conan_reference, base_files=None):
files = hello_source_files(3, [1, 12])
if base_files:
files.update(base_files)
content = """
from conans import ConanFile
class MyConan(ConanFile):
name = "%s"
version = "%s"
settings = arch, compiler, os
""" % (conan_reference.name, conan_reference.version)
files[CONANFILE] = content
files_md5s = {
filename: md5(content)
for filename, content in files.items()
}
conan_digest = FileTreeManifest(123123123, files_md5s)
files[CONAN_MANIFEST] = str(conan_digest)
self.api.upload_conan(conan_reference, files)
