def upload_test(self):
conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1")
files["conanfile.py"] = files["conanfile.py"].replace(
"def build(", "def build2(")
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("upload %s" % str(conan_reference))
self.client.run("info %s" % str(conan_reference))
self.assertIn("remote0=http://", self.client.user_io.out)
# The remote, once fixed does not change
self.client.run("upload %s -r=remote1" % str(conan_reference))
self.client.run("info %s" % str(conan_reference))
self.assertIn("remote0=http://", self.client.user_io.out)
# Now install it in other machine from remote 0
client2 = TestClient(servers=self.servers, users=self.users)
client2.run("install %s --build=missing" % str(conan_reference))
client2.run("info %s" % str(conan_reference))
self.assertIn("remote0=http://", client2.user_io.out)
# Now install it in other machine from remote 1
servers = self.servers.copy()
servers.pop("remote0")
client3 = TestClient(servers=servers, users=self.users)
client3.run("install %s --build=missing" % str(conan_reference))
client3.run("info %s" % str(conan_reference))
self.assertIn("remote1=http://", client3.user_io.out)
def check_multi_server_test(self):
# Check what happen if we have 2 servers and one is outdated
# The expected behavior: If we specify the remote with (-r), the commmand will fail
# if the client fot that remote is outdated. If we are just looking for a package (not with -r)
# the client will look for the package on each remote.
# Client deprecated for "the_last_server" but OK for "normal_server"
self.servers = OrderedDict({"the_last_server": self._get_server(10, 4),
"normal_server": self._get_server(4, 2)})
# First upload a package ok with an ok client
tmp_client = TestClient(servers=self.servers,
users={"default":[("lasote", "mypass")]}, client_version=4)
files = cpp_hello_conan_files("Hello0", "0.1")
tmp_client.save(files)
tmp_client.run("export lasote/stable")
errors = tmp_client.run("upload Hello0/0.1@lasote/stable -r normal_server --all")
errors |= tmp_client.run("upload Hello0/0.1@lasote/stable -r the_last_server --all")
self.assertFalse(errors)
# Now with a conflictive client...try to look in servers
self.client = TestClient(servers=self.servers,
users={"default":[("lasote", "mypass")]}, client_version=2)
errors = self.client.run("search something -r the_last_server", ignore_error=True)
self.assertIn("Your conan's client version is deprecated for the current remote (v10). Upgrade conan client.", self.client.user_io.out)
self.assertTrue(errors) # Errors
errors = self.client.run("install Hello0/0.1@lasote/stable --build missing", ignore_error=True)
self.assertIn("Your conan's client version is deprecated for the current remote (v10). Upgrade conan client.", self.client.user_io.out)
self.assertFalse(errors) # No Errors! because it finds the package in the second remote
def conan_test_test(self):
'''Checks --build in test command'''
client_a = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")],
"local": [("lasote", "mypass")]})
client_b = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")],
"local": [("lasote", "mypass")]})
# Upload Hello0 to local and default from client_a
self._create(client_a, "Hello0", "0.0")
client_a.run("upload Hello0/0.0@lasote/stable -r local")
client_a.run("upload Hello0/0.0@lasote/stable -r default")
client_a.run("remote list_ref")
self.assertIn("Hello0/0.0@lasote/stable: local", str(client_a.user_io.out))
sleep(1) # For timestamp and updates checks
# Download Hello0 from local with client_b
client_b.run("install Hello0/0.0@lasote/stable -r local --build missing")
client_b.run("remote list_ref")
self.assertIn("Hello0/0.0@lasote/stable: local", str(client_b.user_io.out))
# Update Hello0 with client_a and reupload
self._create(client_a, "Hello0", "0.0", modifier="\n")
client_a.run("upload Hello0/0.0@lasote/stable -r local")
# Execute info method in client_b, should advise that there is an update
client_b.run("info Hello0/0.0@lasote/stable -u")
self.assertIn("Updates: There is a newer version (local)", str(client_b.user_io.out))
# Now try to update the package with install -u
client_b.run("remote list_ref")
self.assertIn("Hello0/0.0@lasote/stable: local", str(client_b.user_io.out))
client_b.run("install Hello0/0.0@lasote/stable -u --build")
self.assertIn("Hello0/0.0@lasote/stable: Retrieving from remote 'local'",
str(client_b.user_io.out))
client_b.run("remote list_ref")
self.assertIn("Hello0/0.0@lasote/stable: local", str(client_b.user_io.out))
# Upload a new version from client A, but only to the default server (not the ref-listed)
# Upload Hello0 to local and default from client_a
sleep(1) # For timestamp and updates checks
self._create(client_a, "Hello0", "0.0", modifier="\n\n")
client_a.run("upload Hello0/0.0@lasote/stable -r default")
# Now client_b checks for updates without -r parameter
client_b.run("info Hello0/0.0@lasote/stable")
self.assertIn("Remote: local", str(client_b.user_io.out))
self.assertIn("You have the latest version (local)", str(client_b.user_io.out))
# But if we connect to default, should tell us that there is an update IN DEFAULT!
client_b.run("info Hello0/0.0@lasote/stable -r default")
self.assertIn("Remote: local", str(client_b.user_io.out))
self.assertIn("There is a newer version (default)", str(client_b.user_io.out))
client_b.run("remote list_ref")
self.assertIn("Hello0/0.0@lasote/stable: local", str(client_b.user_io.out))
# Well, now try to update the package with -r default -u
client_b.run("install Hello0/0.0@lasote/stable -r default -u --build")
self.assertIn("Hello0/0.0@lasote/stable: Retrieving from remote 'default'", str(client_b.user_io.out))
client_b.run("info Hello0/0.0@lasote/stable")
self.assertIn("Updates: The local file is newer than remote's one (local)", str(client_b.user_io.out))
def reuse_test(self):
conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1", build=False)
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
client.save(files)
client.run("export lasote/stable")
client.run("upload %s" % str(conan_reference))
gen_reference = ConanFileReference.loads(
"MyCustomGen/0.2@lasote/stable")
files = {CONANFILE: generator}
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
client.save(files)
client.run("export lasote/stable")
client.run("upload %s" % str(gen_reference))
# Test local, no retrieval
files = {CONANFILE_TXT: consumer}
client.save(files, clean_first=True)
client.run("install --build")
generated = load(os.path.join(client.current_folder, "customfile.gen"))
self.assertEqual(generated, "My custom generator content")
# Test retrieval from remote
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files = {CONANFILE_TXT: consumer}
client.save(files)
client.run("install --build")
generated = load(os.path.join(client.current_folder, "customfile.gen"))
self.assertEqual(generated, "My custom generator content")
def setUp(self):
test_server = TestServer()
self.servers = {"default": test_server}
self.client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
self.package_ids = self._upload_some_packages(self.client)
self.new_client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
def reuse_test(self):
self._export_upload("hello0/0.1@lasote/stable")
self._export_upload("hello1/0.1@lasote/stable", 1, [0])
self._export_upload("hello2/0.1@lasote/stable", 2, [0])
self._export_upload("hello3/0.1@lasote/stable", 3, [1, 2])
client = TestClient(servers=self.servers, users=[("lasote", "mypass")]) # Mocked userio
conan_reference = ConanFileReference.loads("hello4/0.2@lasote/stable")
files3 = hello_conan_files(conan_reference=conan_reference, number=4, deps=[3], lang='go')
client.save(files3)
os.chdir(client.current_folder)
client.run("install --build missing")
client.run("build")
command = os.sep.join([".", "bin", "say_hello"])
with CustomEnvPath(paths_to_add=['$GOPATH/bin'],
var_to_add=[('GOPATH', client.current_folder), ]):
client.runner('go install hello4_main', os.path.join(client.current_folder, 'src'))
if platform.system() == "Windows":
command = "hello4_main"
else:
command = './hello4_main'
client.runner(command, os.path.join(client.current_folder, 'bin'))
self.assertEqual(['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'],
str(client.user_io.out).splitlines()[-6:])
# Try to upload and reuse the binaries
client.run("upload hello3/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client.run("upload hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client.run("upload hello2/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client.run("upload hello0/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
#
client2 = TestClient(servers=self.servers, users=[("lasote", "mypass")]) # Mocked userio
conan_reference = ConanFileReference.loads("hello4/0.2@lasote/stable")
files3 = hello_conan_files(conan_reference=conan_reference, number=4, deps=[3], lang='go')
client2.save(files3)
client2.run("install --build missing")
command = os.sep.join([".", "bin", "say_hello"])
with CustomEnvPath(paths_to_add=['$GOPATH/bin'],
var_to_add=[('GOPATH', client2.current_folder), ]):
client2.runner('go install hello4_main', os.path.join(client2.current_folder, 'src'))
if platform.system() == "Windows":
command = "hello4_main"
else:
command = './hello4_main'
client2.runner(command, os.path.join(client2.current_folder, 'bin'))
self.assertEqual(['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'],
str(client2.user_io.out).splitlines()[-6:])
def reuse_test(self):
conan_reference = ConanFileReference.loads("stringutil/0.1@lasote/stable")
files = {'conanfile.py': stringutil_conanfile,
'reverse.go': reverse,
'reverse_test.go': reverse_test,
'reverse.txt': reverse,
'hello/helloreverse.txt': reverse}
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install %s --build missing" % str(conan_reference))
# Check compilation ok
package_ids = self.client.paths.conan_packages(conan_reference)
self.assertEquals(len(package_ids), 1)
package_ref = PackageReference(conan_reference, package_ids[0])
self._assert_package_exists(package_ref, self.client.paths, list(files.keys()))
# Upload conans
self.client.run("upload %s" % str(conan_reference))
# Check that conans exists on server
server_paths = self.servers["default"].paths
conan_path = server_paths.export(conan_reference)
self.assertTrue(os.path.exists(conan_path))
# Upload package
self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0])))
# Check library on server
self._assert_package_exists_in_server(package_ref, server_paths, list(files.keys()))
# Now from other "computer" install the uploaded conans with same options (nothing)
other_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
other_conan.run("install %s --build missing" % str(conan_reference))
# Build should be empty
build_path = other_conan.paths.build(package_ref)
self.assertFalse(os.path.exists(build_path))
# Lib should exist
self._assert_package_exists(package_ref, other_conan.paths, list(files.keys()))
reuse_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
files = {'conanfile.py': reuse_conanfile,
'src/hello/main.go': main}
reuse_conan.save(files)
reuse_conan.run("install --build missing")
with CustomEnvPath(paths_to_add=['$GOPATH/bin'],
var_to_add=[('GOPATH', reuse_conan.current_folder), ]):
if platform.system() == "Windows":
command = "hello"
else:
command = './hello'
reuse_conan.runner('go install hello', cwd=reuse_conan.current_folder)
reuse_conan.runner(command, cwd=os.path.join(reuse_conan.current_folder, 'bin'))
self.assertIn("Hello, Go!", reuse_conan.user_io.out)
def setUp(self):
test_server = TestServer(
[("*/*@*/*", "*")], # read permissions
[], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
self.servers = {"default": test_server}
self.client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
self.package_ids = self._upload_some_packages(self.client)
self.new_client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
def check_versions_test(self):
# Client deprecated
self.servers = {"default": self._get_server(10, 5)}
self.client = TestClient(servers=self.servers,
users={"default":[("lasote", "mypass")]}, client_version=4)
errors = self.client.run("search something -r default", ignore_error=True)
self.assertIn("Your conan's client version is deprecated for the current remote (v10). Upgrade conan client.", self.client.user_io.out)
self.assertTrue(errors) # Not Errors
# Client outdated
self.servers = {"default": self._get_server(10, 4)}
self.client = TestClient(servers=self.servers,
users={"default":[("lasote", "mypass")]}, client_version=4)
errors = self.client.run("search something -r default", ignore_error=False)
self.assertIn(" A new conan version (v10) is available in current remote. Please, upgrade conan client to avoid deprecation.", self.client.user_io.out)
self.assertFalse(errors) # Not Errors
# Client ok
self.servers = {"default": self._get_server(10, 4)}
self.client = TestClient(servers=self.servers,
users={"default":[("lasote", "mypass")]}, client_version=10)
errors = self.client.run("search something -r default", ignore_error=False)
self.assertNotIn("conan client", self.client.user_io.out)
self.assertFalse(errors) # Not Errors
# Server outdated
self.servers = {"default": self._get_server(1, 1)}
self.client = TestClient(servers=self.servers,
users={"default":[("lasote", "mypass")]}, client_version=10,
min_server_compatible_version=1)
errors = self.client.run("search something -r default", ignore_error=True)
self.assertIn("The conan remote version is outdated (v1). Please, contact" \
" with your system administrator and upgrade the remote to" \
" avoid deprecation", self.client.user_io.out)
self.assertFalse(errors) # No Errors
# Server deprecated
self.servers = {"default": self._get_server(1, 1)}
self.client = TestClient(servers=self.servers,
users={"default":[("lasote", "mypass")]}, client_version=10,
min_server_compatible_version=2)
errors = self.client.run("search something -r default", ignore_error=True)
self.assertIn("Your conan's client is incompatible with this remote."
" The server is deprecated. "
"(v1). Please, contact with your system administrator and"
" upgrade the server.",
self.client.user_io.out)
self.assertTrue(errors) # Errors
def setUp(self):
test_server = TestServer()
self.servers = {"default": test_server}
self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
self.new_client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
self.ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1", build=False)
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install Hello0/0.1@lasote/stable --build missing")
self.client.run("upload Hello0/0.1@lasote/stable --all")
def test_export_a_new_version(self):
self._create_packages_and_builds()
# Export an update of the same conans
conan2 = TestClient(self.conan.base_folder)
files2 = cpp_hello_conan_files("Hello0", "0.1")
files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE]
conan2.save(files2)
conan2.run("export lasote/stable")
reg_path3 = conan2.paths.export(self.conan_ref)
digest3 = FileTreeManifest.loads(
load(conan2.paths.digestfile_conanfile(self.conan_ref)))
self.assertIn(
'%s: A new conanfile.py version was exported' %
str(self.conan_ref), self.conan.user_io.out)
self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path3),
self.conan.user_io.out)
self.assertTrue(os.path.exists(reg_path3))
for name in list(files2.keys()):
self.assertTrue(os.path.exists(os.path.join(reg_path3, name)))
expected_sums = {
'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
'conanfile.py': '6b19dfd1241712a6c694c7c397f909ce',
'executable': '68b329da9893e34099c7d8ad5cb9c940',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'
}
self.assertEqual(expected_sums, digest3.file_sums)
def setUp(self):
self.client = TestClient()
# No conans created
self.client.run("search")
output = self.client.user_io.out
self.assertIn('There are no packages', output)
# Conans with and without packages created
root_folder1 = 'Hello/1.4.10/fenix/testing'
root_folder2 = 'helloTest/1.4.10/fenix/stable'
root_folder3 = 'Bye/0.14/fenix/testing'
root_folder4 = 'NodeInfo/1.0.2/fenix/stable'
root_folder5 = 'MissFile/1.0.2/fenix/stable'
self.client.save(
{
"Empty/1.10/fake/test/reg/fake.txt":
"//",
"%s/%s/WindowsPackageSHA/%s" % (root_folder1, PACKAGES_FOLDER, CONANINFO):
conan_vars1,
"%s/%s/PlatformIndependantSHA/%s" % (root_folder1, PACKAGES_FOLDER, CONANINFO):
conan_vars1b,
"%s/%s/LinuxPackageSHA/%s" % (root_folder1, PACKAGES_FOLDER, CONANINFO):
conan_vars1c,
"%s/%s/a44f541cd44w57/%s" % (root_folder2, PACKAGES_FOLDER, CONANINFO):
conan_vars2,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder3, PACKAGES_FOLDER, CONANINFO):
conan_vars3,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder4, PACKAGES_FOLDER, CONANINFO):
conan_vars4,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder5, PACKAGES_FOLDER, "hello.txt"):
"Hello"
}, self.client.paths.store)
def setUp(self):
test_server = TestServer(
[], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
self.servers = {"default": test_server}
self.conan = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
def build_order_test(self):
self.client = TestClient()
self._create("Hello0", "0.1")
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._create("Hello2",
"0.1", ["Hello1/0.1@lasote/stable"],
export=False)
self.client.run("info -bo=Hello0/0.1@lasote/stable")
self.assertIn("[Hello0/0.1@lasote/stable], [Hello1/0.1@lasote/stable]",
self.client.user_io.out)
self.client.run("info -bo=Hello1/0.1@lasote/stable")
self.assertIn("[Hello1/0.1@lasote/stable]", self.client.user_io.out)
self.client.run(
"info -bo=Hello1/0.1@lasote/stable -bo=Hello0/0.1@lasote/stable")
self.assertIn("[Hello0/0.1@lasote/stable], [Hello1/0.1@lasote/stable]",
self.client.user_io.out)
self.client.run(
"info Hello1/0.1@lasote/stable -bo=Hello0/0.1@lasote/stable")
self.assertEqual(
"[Hello0/0.1@lasote/stable], [Hello1/0.1@lasote/stable]\n",
self.client.user_io.out)
def test_export_the_same_code(self):
file_list = self._create_packages_and_builds()
# Export the same conans
conan2 = TestClient(self.conan.base_folder)
files2 = cpp_hello_conan_files("Hello0", "0.1")
conan2.save(files2)
conan2.run("export lasote/stable")
reg_path2 = conan2.paths.export(self.conan_ref)
digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))
self.assertNotIn('A new Conan version was exported', conan2.user_io.out)
self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out)
self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out)
self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out)
self.assertIn('%s: conanfile.py exported to local storage' % str(self.conan_ref),
self.conan.user_io.out)
self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path2), self.conan.user_io.out)
self.assertTrue(os.path.exists(reg_path2))
for name in files2.keys():
self.assertTrue(os.path.exists(os.path.join(reg_path2, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
'conanfile.py': 'f21a98d974e9294b0d709070042c6e78',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, digest2.file_sums)
for f in file_list:
self.assertTrue(os.path.exists(f))
def reuse_test(self):
client = TestClient()
client.save({
CONANFILE: conanfile,
"__init__.py": "",
"mytest.py": test
})
client.run("export lasote/stable")
client.save({CONANFILE: reuse}, clean_first=True)
client.run("install . -g txt -g env")
content = load(os.path.join(client.current_folder, CONANENV))
self.assertIn("PYTHONPATH", content)
self.assertIn("Hello Bar", client.user_io.out)
self.assertNotIn("Hello Foo", client.user_io.out)
client.run("build")
self.assertNotIn("Hello Bar", client.user_io.out)
self.assertIn("Hello Foo", client.user_io.out)
client.run("export lasote/stable")
client.run("install Consumer/0.1@lasote/stable --build")
lines = [
line.split(":")[1]
for line in str(client.user_io.out).splitlines()
if line.startswith("Consumer/0.1@lasote/stable: Hello")
]
self.assertEqual(
[' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'], lines)
def test_no_remotes(self):
client = TestClient()
files = cpp_hello_conan_files("Hello0", "0.1")
client.save(files)
client.run("export lasote/stable")
client.run("upload Hello0/0.1@lasote/stable", ignore_error=True)
self.assertIn("ERROR: No default remote defined", client.user_io.out)
def test_declared_stdlib_and_passed(self):
client = TestClient()
client.save(self.files)
client.run("export lasote/testing")
client.run(
'install -s compiler=clang -s compiler.version=3.3 -s compiler.libcxx=libstdc++ ',
ignore_error=False)
client.run('build')
self.assertIn("-stdlib=libstdc++", str(client.user_io.out))
self.assertIn("Found Define: _GLIBCXX_USE_CXX11_ABI=0",
str(client.user_io.out))
client.run('install -s compiler=clang -s compiler.libcxx=libstdc++11',
ignore_error=False)
client.run('build')
self.assertIn("-stdlib=libstdc++", str(client.user_io.out))
self.assertIn("Found Define: _GLIBCXX_USE_CXX11_ABI=1",
str(client.user_io.out))
client.run(
'install -s compiler=clang -s compiler.version=3.3 -s compiler.libcxx=libc++',
ignore_error=False)
client.run('build')
self.assertIn("-stdlib=libc++", str(client.user_io.out))
self.assertNotIn("Found Define: _GLIBCXX_USE_CXX11",
str(client.user_io.out))
def _test_with_conanfile(self, test_conanfile):
client = TestClient()
files = cpp_hello_conan_files("Hello0", "0.1")
print_build = 'self.output.warn("BUILD_TYPE=>%s" % self.settings.build_type)'
files[CONANFILE] = files[CONANFILE].replace("def build(self):",
'def build(self):\n %s' % print_build)
# Add build_type setting
files[CONANFILE] = files[CONANFILE].replace(', "arch"',
', "arch", "build_type"')
cmakelist = """PROJECT(MyHello)
cmake_minimum_required(VERSION 2.8)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()
ADD_EXECUTABLE(greet main.cpp)
TARGET_LINK_LIBRARIES(greet ${CONAN_LIBS})
"""
files["test_package/CMakeLists.txt"] = cmakelist
files["test_package/conanfile.py"] = test_conanfile
files["test_package/main.cpp"] = files["main.cpp"]
client.save(files)
client.run("export lasote/stable")
error = client.run("test -s build_type=Release")
self.assertFalse(error)
self.assertIn('Hello Hello0', client.user_io.out)
error = client.run("test -s Hello0:build_type=Debug -o Hello0:language=1")
self.assertFalse(error)
self.assertIn('Hola Hello0', client.user_io.out)
self.assertIn('BUILD_TYPE=>Debug', client.user_io.out)
def basic_source_test(self):
conanfile = '''
from conans import ConanFile
class ConanLib(ConanFile):
name = "Hello"
version = "0.1"
def source(self):
self.output.info("Running source!")
'''
client = TestClient()
client.save({CONANFILE: conanfile})
client.run("export lasote/stable")
client.run("source Hello/0.1@lasote/stable")
self.assertIn("Hello/0.1@lasote/stable: Configuring sources",
client.user_io.out)
self.assertIn("Hello/0.1@lasote/stable: Running source!",
client.user_io.out)
# The second call shouldn't have effect
client.run("source Hello/0.1@lasote/stable")
self.assertNotIn("Hello/0.1@lasote/stable: Configuring sources",
client.user_io.out)
self.assertNotIn("Hello/0.1@lasote/stable: Running source!",
client.user_io.out)
# Forced should have effect
client.run("source Hello/0.1@lasote/stable --force")
self.assertIn("WARN: Forced removal of source folder",
client.user_io.out)
self.assertIn("Hello/0.1@lasote/stable: Configuring sources",
client.user_io.out)
self.assertIn("Hello/0.1@lasote/stable: Running source!",
client.user_io.out)
def test_complex_deps_propagation_override(self):
client = TestClient()
# Try injecting some package level ENV in the install, but without priority
self._export(client, "A", [], {}, {
"VAR1": "900",
"VAR2": "23",
"VAR3": "-23"
})
self._export(client, "B", ["A"], {}, {"VAR1": "800", "VAR2": "24"})
self._export(client, "C", ["B"], {"VAR3": "bestvalue"},
{"VAR1": "700"})
client.save({"conanfile.py": reuse})
client.run("install . --build missing -e LIB_B:VAR3=override")
self.assertIn("Building LIB_A, VAR1:None", client.user_io.out)
self.assertIn("Building LIB_A, VAR2:None", client.user_io.out)
self.assertIn("Building LIB_A, VAR3:None", client.user_io.out)
self.assertIn("Building LIB_B, VAR1:900", client.user_io.out)
self.assertIn("Building LIB_B, VAR2:23", client.user_io.out)
self.assertIn("Building LIB_B, VAR3:override", client.user_io.out)
self.assertIn("Building LIB_C, VAR1:800", client.user_io.out)
self.assertIn("Building LIB_C, VAR2:24", client.user_io.out)
self.assertIn("Building LIB_C, VAR3:-23", client.user_io.out)
client.run("build")
self.assertInSep("VAR1=>700:800:900", client.user_io.out)
self.assertInSep("VAR2=>24:23*", client.user_io.out)
self.assertInSep("VAR3=>bestvalue*", client.user_io.out)
def build_policies_update_test(self):
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
conanfile = """
from conans import ConanFile
class MyPackage(ConanFile):
name = "test"
version = "1.9"
build_policy = 'always'
def source(self):
self.output.info("Getting sources")
def build(self):
self.output.info("Building sources")
def package(self):
self.output.info("Packaging this test package")
"""
files = {CONANFILE: conanfile}
client.save(files, clean_first=True)
client.run("export lasote/stable")
client.run("install test/1.9@lasote/stable")
self.assertIn("Getting sources", client.user_io.out)
self.assertIn("Building sources", client.user_io.out)
self.assertIn("Packaging this test package", client.user_io.out)
self.assertIn(
"Building package from source as defined by build_policy='always'",
client.user_io.out)
client.run("upload test/1.9@lasote/stable")
def test_rel_path(self):
base_folder = temp_folder()
source_folder = os.path.join(base_folder, "source")
current_folder = os.path.join(base_folder, "current")
os.makedirs(current_folder)
client = TestClient(current_folder=current_folder)
files = cpp_hello_conan_files("Hello0", "0.1")
conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable")
client.save(files, path=source_folder)
client.run("export lasote/stable --path=../source")
reg_path = client.paths.export(conan_ref)
manif = FileTreeManifest.loads(
load(client.paths.digestfile_conanfile(conan_ref)))
self.assertIn(
'%s: A new conanfile.py version was exported' % str(conan_ref),
client.user_io.out)
self.assertIn('%s: Folder: %s' % (str(conan_ref), reg_path),
client.user_io.out)
self.assertTrue(os.path.exists(reg_path))
for name in list(files.keys()):
self.assertTrue(os.path.exists(os.path.join(reg_path, name)))
expected_sums = {
'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
'conanfile.py': '05bd2ffe3ff0c35b3a1deede3264a8b6',
'executable': '68b329da9893e34099c7d8ad5cb9c940',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'
}
self.assertEqual(expected_sums, manif.file_sums)
def reuse_test(self):
files = cpp_hello_conan_files("Hello0", "1.0")
# To avoid building
files[CONANFILE] = files[CONANFILE].replace("build(", "build2(")
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install Hello0/1.0@lasote/stable --build")
self.client.run("upload Hello0/1.0@lasote/stable --all")
client2 = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
client2.run("install Hello0/1.0@lasote/stable")
files["helloHello0.h"] = "//EMPTY!"
self.client.save(files, clean_first=True)
sleep(1)
self.client.run("export lasote/stable")
self.client.run("install Hello0/1.0@lasote/stable --build")
self.client.run("upload Hello0/1.0@lasote/stable --all")
client2.run("install Hello0/1.0@lasote/stable --update")
ref = ConanFileReference.loads("Hello0/1.0@lasote/stable")
package_ids = client2.paths.conan_packages(ref)
package_path = client2.paths.package(
PackageReference(ref, package_ids[0]))
header = load(os.path.join(package_path, "include/helloHello0.h"))
self.assertEqual(header, "//EMPTY!")
def setUp(self):
self.conan = TestClient()
self.files = cpp_hello_conan_files("Hello0", "0.1")
self.conan_ref = ConanFileReference("Hello0", "0.1", "lasote",
"stable")
self.conan.save(self.files)
self.conan.run("export lasote/stable")
def fail_test_package_test(self):
client = TestClient()
conanfile = """
from conans import ConanFile
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
exports = "*"
def package(self):
self.copy("*")
"""
test_conanfile = """
from conans import ConanFile, CMake
import os
class HelloReuseConan(ConanFile):
requires = "Hello/0.1@lasote/stable"
def test(self):
self.conanfile_directory
"""
client.save({"conanfile.py": conanfile,
"FindXXX.cmake": "Hello FindCmake",
"test/conanfile.py": test_conanfile})
client.run("test_package")
ref = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertEqual("Hello FindCmake",
load(os.path.join(client.paths.package(ref), "FindXXX.cmake")))
client.save({"FindXXX.cmake": "Bye FindCmake"})
client.run("test_package")
self.assertEqual("Bye FindCmake",
load(os.path.join(client.paths.package(ref), "FindXXX.cmake")))
def external_python_with_simple_var_test(self):
client = TestClient()
conanfile_simple = """from conans import ConanFile, tools
class ToolsTest(ConanFile):
name = "Hello"
version = "0.1"
def build(self):
with tools.pythonpath(self):
import external
external.external_baz()
"""
external_py = '''
def external_baz():
print("External baz")
'''
external_dir = temp_folder()
save(os.path.join(external_dir, "external.py"), external_py)
client.save({CONANFILE: conanfile_simple})
client.run("export lasote/stable")
# Should work even if PYTHONPATH is not declared as [], only external resource needed
client.run(
'install Hello/0.1@lasote/stable --build missing -e PYTHONPATH="%s"'
% external_dir)
def use_short_paths_test(self):
client = TestClient()
shorted_path = temp_folder()
short_paths_refs_file = os.path.join(client.paths.conan_folder,
SHORTED_REFERENCES_FILENAME)
save(short_paths_refs_file,
"Hello0/0.1@lasote/stable: %s" % shorted_path)
files = cpp_hello_conan_files("Hello0", "0.1")
client.save(files, clean_first=True)
client.run("export lasote/stable")
self.assertTrue(os.path.exists(os.path.join(shorted_path, "e")))
self.assertFalse(os.path.exists(os.path.join(shorted_path, "p")))
self.assertFalse(os.path.exists(os.path.join(shorted_path, "b")))
client.run("install Hello0/0.1@lasote/stable --build")
self.assertTrue(os.path.exists(os.path.join(shorted_path, "p")))
self.assertTrue(os.path.exists(os.path.join(shorted_path, "b")))
sha_short = os.listdir(os.path.join(os.path.join(shorted_path,
"p")))[0]
self.assertEquals(len(sha_short), 6)
self.assertTrue(
os.path.exists(os.path.join(shorted_path, "p", sha_short, "lib")))
client.run("search Hello0*")
self.assertIn("Hello0/0.1@lasote/stable", str(client.user_io.out))
def test_override_simple2(self):
client = TestClient()
# Try injecting some package level ENV in the install
self._export(client, "A", [], {"VAR3": "-23"}, {
"VAR1": "900",
"VAR2": "23"
})
self._export(client, "B", ["A"], {}, {"VAR1": "800", "VAR2": "24"})
self._export(client, "C", ["B"], {}, {"VAR1": "700"})
client.save({"conanfile.py": reuse})
client.run("install . --build missing -e VAR3=override")
self.assertIn("Building LIB_A, VAR1:None", client.user_io.out)
self.assertIn("Building LIB_A, VAR2:None", client.user_io.out)
self.assertIn("Building LIB_A, VAR3:override", client.user_io.out)
self.assertIn("Building LIB_B, VAR1:900", client.user_io.out)
self.assertIn("Building LIB_B, VAR2:23", client.user_io.out)
self.assertIn("Building LIB_B, VAR3:override", client.user_io.out)
self.assertIn("Building LIB_C, VAR1:800", client.user_io.out)
self.assertIn("Building LIB_C, VAR2:24", client.user_io.out)
self.assertIn("Building LIB_C, VAR3:override", client.user_io.out)
client.run("build")
self.assertInSep("VAR1=>700:800:900", client.user_io.out)
self.assertInSep("VAR2=>24:23*", client.user_io.out)
self.assertInSep("VAR3=>override*", client.user_io.out)
def no_signature_test(self):
auth = AuthorizationHeaderSpy()
retur = ReturnHandlerPlugin()
server = TestServer(plugins=[auth, retur])
server.app
servers = {"default": server}
client = TestClient(servers=servers,
users={"default": [("lasote", "mypass")]})
client.save({"conanfile.py": conanfile})
client.run("export lasote/stable")
errors = client.run("upload Hello/0.1@lasote/stable")
self.assertFalse(errors)
expected_calls = [('get_conan_digest_url', None),
('check_credentials', None),
('authenticate', 'Basic'),
('get_conanfile_snapshot', 'Bearer'),
('get_conanfile_upload_urls', 'Bearer'),
('put', 'Bearer')]
self.assertEqual(len(expected_calls), len(auth.auths))
for i, (method, auth_type) in enumerate(expected_calls):
real_call = auth.auths[i]
self.assertEqual(method, real_call[0])
if auth_type:
self.assertIn(auth_type, real_call[1])
# The Bearer of the last two calls must be identical
self.assertEqual(auth.auths[-1][1], auth.auths[-2][1])
