def test_contains():
"""This is particularly tested because it's how fulfilling is tested."""
dep1 = parsing.VCSDependency("testurl")
dep2 = parsing.VCSDependency("testurl")
dep3 = parsing.VCSDependency("otherurl")
assert dep1 in dep2
assert dep1 not in dep3
def test_match_mixed_multiple(venvscache):
reqs = {
'vcs': [parsing.VCSDependency('url1'),
parsing.VCSDependency('url2')],
'pypi': get_reqs('dep1 == 5', 'dep2')
}
interpreter = 'pythonX.Y'
options = {'foo': 'bar'}
venv = json.dumps({
'metadata': 'foobar',
'installed': {
'vcs': {
'url1': None,
'url2': None
},
'pypi': {
'dep1': '5',
'dep2': '7'
}
},
'interpreter': 'pythonX.Y',
'options': {
'foo': 'bar'
}
})
resp = venvscache._select([venv],
reqs,
interpreter,
uuid='',
options=options)
assert resp == 'foobar'
def test_contains(self):
"""This is particularly tested because it's how fulfilling is tested."""
dep1 = parsing.VCSDependency("testurl")
dep2 = parsing.VCSDependency("testurl")
dep3 = parsing.VCSDependency("otherurl")
self.assertTrue(dep1 in dep2)
self.assertFalse(dep1 in dep3)
def test_vcs_mixed_multiple(self):
self.check([
([parsing.VCSDependency('someurl')] + get_distrib(
('dep', '3')), 'venv_best_fit'),
([parsing.VCSDependency('someurl')] + get_distrib(
('dep', '1')), 'venv_1'),
])
def test_mixed_backends(self):
with open("tests/test_files/req_mixed_backends.py") as f:
parsed = parsing._parse_docstring(f)
# Only module requirements was found
self.assertDictEqual(parsed, {
REPO_PYPI: [get_req('foo'), get_req('bar')],
REPO_VCS: [parsing.VCSDependency('git+http://whatever'),
parsing.VCSDependency('anotherurl')],
})
def test_equality(self):
dep1 = parsing.VCSDependency("testurl")
dep2 = parsing.VCSDependency("testurl")
dep3 = parsing.VCSDependency("otherurl")
self.assertTrue(dep1 == dep2)
self.assertFalse(dep1 == dep3)
self.assertFalse(dep1 != dep2)
self.assertTrue(dep1 != dep3)
self.assertFalse(dep1 == 123)
self.assertFalse(dep1 == "testurl")
def test_equality():
dep1 = parsing.VCSDependency("testurl")
dep2 = parsing.VCSDependency("testurl")
dep3 = parsing.VCSDependency("otherurl")
assert dep1 == dep2
assert not (dep1 == dep3)
assert not (dep1 != dep2)
assert dep1 != dep3
assert not (dep1 == 123)
assert not (dep1 == "testurl")
def test_two_different(self):
requirement_files = [create_tempfile(self, ['1', '2'])]
manual_dependencies = ['vcs::3', 'vcs::4']
d = main.consolidate_dependencies(needs_ipython=False, child_program=None,
requirement_files=requirement_files,
manual_dependencies=manual_dependencies)
self.assertEqual(d, {
'pypi': {Requirement.parse('1'), Requirement.parse('2')},
'vcs': {parsing.VCSDependency('3'), parsing.VCSDependency('4')}
})
def test_mixed_backends():
with open("tests/test_files/req_mixed_backends.py") as f:
parsed = parsing._parse_docstring(f)
# Only module requirements was found
assert parsed == {
REPO_PYPI:
get_reqs("foo", "bar"),
REPO_VCS: [
parsing.VCSDependency("git+http://whatever"),
parsing.VCSDependency("anotherurl"),
],
}
def test_complex_case(self):
child_program = create_tempfile(self, ['"""fades:', '1', '2', '"""'])
requirement_files = [create_tempfile(self, ['3', 'vcs::5'])]
manual_dependencies = ['vcs::4', 'vcs::6']
d = main.consolidate_dependencies(needs_ipython=False, child_program=child_program,
requirement_files=requirement_files,
manual_dependencies=manual_dependencies)
self.assertEqual(d, {
'pypi': {Requirement.parse('1'), Requirement.parse('2'), Requirement.parse('3')},
'vcs': {parsing.VCSDependency('5'), parsing.VCSDependency('4'),
parsing.VCSDependency('6')}
})
def test_vcs_simple(self):
parsed = parsing._parse_requirement(
io.StringIO("""
vcs::strangeurl
"""))
self.assertDictEqual(parsed,
{REPO_VCS: [parsing.VCSDependency("strangeurl")]})
def test_match_mixed_single(self):
reqs = {'vcs': [parsing.VCSDependency('someurl')], 'pypi': get_req('dep == 5')}
interpreter = 'pythonX.Y'
options = {'foo': 'bar'}
venv1 = json.dumps({
'metadata': 'foobar1',
'installed': {'vcs': {'someurl': None}, 'pypi': {'dep': '5'}},
'interpreter': 'pythonX.Y',
'options': {'foo': 'bar'}
})
venv2 = json.dumps({
'metadata': 'foobar2',
'installed': {'pypi': {'dep': '5'}},
'interpreter': 'pythonX.Y',
'options': {'foo': 'bar'}
})
venv3 = json.dumps({
'metadata': 'foobar3',
'installed': {'vcs': {'someurl': None}},
'interpreter': 'pythonX.Y',
'options': {'foo': 'bar'}
})
resp = self.venvscache._select(
[venv1, venv2, venv3], reqs, interpreter, uuid='', options=options)
self.assertEqual(resp, 'foobar1')
def test_vcs_explicit(self):
parsed = parsing._parse_content(
io.StringIO("""
import foo # fades vcs::superurl
"""))
self.assertDictEqual(parsed,
{REPO_VCS: [parsing.VCSDependency('superurl')]})
def test_vcs_implicit(self):
parsed = parsing._parse_content(io.StringIO("""
import foo # fades http://www.whatever/project
"""))
self.assertDictEqual(parsed, {
REPO_VCS: [parsing.VCSDependency('http://www.whatever/project')]
})
def test_mixed():
parsed = parsing.parse_manual(
["pypi::foo", "vcs::git+git://server.com/etc"])
assert parsed == {
REPO_PYPI: get_reqs("foo"),
REPO_VCS: [parsing.VCSDependency("git+git://server.com/etc")],
}
def test_vcs_simple_default():
parsed = parsing._parse_requirement(
io.StringIO("""
bzrhttp://server/bleh
"""))
assert parsed == {
REPO_VCS: [parsing.VCSDependency("bzrhttp://server/bleh")]
}
def test_vcs_simple_default(self):
parsed = parsing._parse_requirement(
io.StringIO("""
bzr+http://server/bleh
"""))
self.assertDictEqual(
parsed,
{REPO_VCS: [parsing.VCSDependency("bzr+http://server/bleh")]})
def test_mixed(self):
parsed = parsing.parse_manual(
["pypi::foo", "vcs::git+git://server.com/etc"])
self.assertDictEqual(
parsed, {
REPO_PYPI: [get_req('foo')],
REPO_VCS: [parsing.VCSDependency("git+git://server.com/etc")],
})
def test_vcs_implicit():
parsed = parsing._parse_content(
io.StringIO("""
import foo # fades http://www.whatever/project
"""))
assert parsed == {
REPO_VCS: [parsing.VCSDependency('http://www.whatever/project')]
}
def test_mixed(self):
parsed = parsing._parse_requirement(io.StringIO("""
vcs::strangeurl
pypi::foo
"""))
self.assertDictEqual(parsed, {
REPO_VCS: [parsing.VCSDependency("strangeurl")],
REPO_PYPI: [get_req('foo')],
})
def test_mixed(self):
parsed = parsing._parse_content(io.StringIO("""
import foo # fades vcs::superurl
import bar # fades
"""))
self.assertDictEqual(parsed, {
REPO_VCS: [parsing.VCSDependency('superurl')],
REPO_PYPI: [get_req('bar')],
})
def test_mixed():
parsed = parsing._parse_content(
io.StringIO("""
import foo # fades vcs::superurl
import bar # fades
"""))
assert parsed == {
REPO_VCS: [parsing.VCSDependency('superurl')],
REPO_PYPI: get_reqs('bar'),
}
def test_mixed():
parsed = parsing._parse_requirement(
io.StringIO("""
vcs::strangeurl
pypi::foo
"""))
assert parsed == {
REPO_VCS: [parsing.VCSDependency("strangeurl")],
REPO_PYPI: get_reqs('foo'),
}
def test_simple_vcs_match(self):
reqs = {'vcs': [parsing.VCSDependency('someurl')]}
interpreter = 'pythonX.Y'
options = {'foo': 'bar'}
venv = json.dumps({
'metadata': 'foobar',
'installed': {'vcs': {'someurl': None}},
'interpreter': 'pythonX.Y',
'options': {'foo': 'bar'}
})
resp = self.venvscache._select([venv], reqs, interpreter, uuid='', options=options)
self.assertEqual(resp, 'foobar')
def test_create_vcs(self):
requested = {
REPO_VCS: [parsing.VCSDependency("someurl")]
}
interpreter = 'python3'
is_current = True
options = {"virtualenv_options": [], "pyvenv_options": []}
pip_options = []
with patch.object(envbuilder._FadesEnvBuilder, 'create_env') as mock_create:
with patch.object(envbuilder, 'PipManager') as mock_mgr_c:
mock_create.return_value = ('env_path', 'env_bin_path', 'pip_installed')
mock_mgr_c.return_value = self.FakeManager()
venv_data, installed = envbuilder.create_venv(requested, interpreter, is_current,
options, pip_options)
self.assertEqual(venv_data, {
'env_bin_path': 'env_bin_path',
'env_path': 'env_path',
'pip_installed': 'pip_installed',
})
self.assertDictEqual(installed, {REPO_VCS: {'someurl': None}})
def test_nomatch_vcs_dependency(venvscache):
reqs = {'vcs': [parsing.VCSDependency('someurl')]}
interpreter = 'pythonX.Y'
options = {'foo': 'bar'}
venv = json.dumps({
'metadata': 'foobar',
'installed': {
'vcs': {
'otherurl': None
}
},
'interpreter': 'pythonX.Y',
'options': {
'foo': 'bar'
}
})
resp = venvscache._select([venv],
reqs,
interpreter,
uuid='',
options=options)
assert resp is None
def test_vcs_explicit():
parsed = parsing._parse_content(
io.StringIO("""
import foo # fades vcs::superurl
"""))
assert parsed == {REPO_VCS: [parsing.VCSDependency('superurl')]}
def test_vcs_simple_default():
url = "git+git://server.com/etc"
parsed = parsing.parse_manual([url])
assert parsed == {REPO_VCS: [parsing.VCSDependency(url)]}
def test_vcs_simple():
parsed = parsing._parse_requirement(
io.StringIO("""
vcs::strangeurl
"""))
assert parsed == {REPO_VCS: [parsing.VCSDependency("strangeurl")]}
('dep3', '4')), 'venv_best_fit'),
(get_distrib(('dep1', '5'), ('dep2', '7'), ('dep3', '2')), 'venv_1'),
],
[
(get_distrib(('dep2', '3'), ('dep1', '2'),
('dep3', '8')), 'venv_best_fit'),
(get_distrib(('dep1', '7'), ('dep3', '5'), ('dep2', '2')), 'venv_1'),
],
[
(get_distrib(('dep1', '3'), ('dep2', '2')), 'venv_1'),
(get_distrib(('dep1', '4'), ('dep2', '2')), 'venv_2'),
(get_distrib(('dep1', '5'), ('dep2', '7')), 'venv_best_fit'),
(get_distrib(('dep1', '5'), ('dep2', '6')), 'venv_3'),
],
[
([parsing.VCSDependency('someurl')], 'venv_best_fit'),
],
[
([parsing.VCSDependency('someurl')] + get_distrib(
('dep', '3')), 'venv_best_fit'),
],
[
([parsing.VCSDependency('someurl')] + get_distrib(
('dep', '3')), 'venv_best_fit'),
([parsing.VCSDependency('someurl')] + get_distrib(
('dep', '1')), 'venv_1'),
],
])
def test_best_fit(venvscache, possible_venvs):
"""Check the venv best fitting decissor."""
assert venvscache._select_better_fit(possible_venvs) == 'venv_best_fit'
