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 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")
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)