def test_get_release(self):
component = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
releases=[
{
"version": "1.0.0",
"sha": "0000000000000000000000000000000000000000",
"series": "first",
},
{
"version": "1.1.0",
"sha": "0000000000000000000000000000000000000001",
"series": "first",
},
],
)
release = component.get_release("1.1.0")
self.assertIsInstance(release, c.Release)
self.assertEqual("1.1.0", release.version)
release_pred = component.get_release("1.1.0", predecessor=True)
self.assertIsInstance(release_pred, c.Release)
self.assertEqual("1.0.0", release_pred.version)
def component(releases_dir, components_dir, subparser, **kwargs):
os.makedirs(components_dir, exist_ok=True)
component_name = kwargs.pop("component_name")
if subparser == "get":
component = c_lib.Component.from_file(
component_name, components_dir
)
elif subparser == "add":
try:
component = c_lib.Component.from_file(
component_name, components_dir
)
except c_lib.ComponentError:
component = c_lib.Component(
name=component_name, directory=components_dir, **kwargs
)
else:
raise c_lib.ComponentError(
"Component '{name}' already exists.".format(
name=component_name,
)
)
try:
with TemporaryDirectory() as tmp_dir:
git.Repo.clone_from(
c_lib.git_http_to_ssh(component.repo_url), tmp_dir
)
except FileNotFoundError as e:
raise c_lib.ComponentError(
"The repo_url provided is inaccessible, please check."
)
elif subparser == "update":
component = c_lib.Component.from_file(
component_name, components_dir
)
if kwargs["new_name"]:
component.name = kwargs["new_name"]
if kwargs["repo_url"]:
component.repo_url = kwargs["repo_url"]
if "is_product" in kwargs:
component.is_product = kwargs["is_product"]
else:
raise c_lib.ComponentError(
"The component subparser '{sp}' is not recognised.".format(
sp=subparser,
)
)
if component._is_changed:
component.to_file()
msg = "{change} component {name}".format(
change=subparser.capitalize(),
name=component.name,
)
c_lib.commit_changes(releases_dir, components_dir, msg)
return component
def test_dict(self):
component = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
releases=[{
"version": "1.0.0",
"sha": "0000000000000000000000000000000000000000",
"series": "first",
}],
)
expected = {
"is_product":
False,
"name":
"test1",
"releases": [
{
"series":
"first",
"versions": [
{
"sha": "0000000000000000000000000000000000000000",
"version": "1.0.0",
},
],
},
],
"repo_url":
"https://github.com/rcbops/test1",
}
self.assertEqual(expected, component.to_dict())
def test_create_without_releases(self):
component = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
)
self.assertEqual([], component.releases)
def test_yaml(self):
component = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
releases=[{
"version": "1.0.0",
"sha": "0000000000000000000000000000000000000000",
"series": "first",
}],
)
component_yaml = yaml.dump(component, default_flow_style=False)
expected = ("artifact_stores: []\n"
"is_product: false\n"
"name: test1\n"
"releases:\n"
"- series: first\n"
" versions:\n"
" - sha: '0000000000000000000000000000000000000000'\n"
" version: 1.0.0\n"
"repo_url: https://github.com/rcbops/test1\n")
self.assertEqual(expected, component_yaml)
def test_difference(self):
component_pred = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
releases=[{
"version": "1.0.0",
"sha": "0000000000000000000000000000000000000000",
"series": "first",
}],
)
component_succ = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
releases=[{
"version": "1.0.0",
"sha": "0000000000000000000000000000000000000000",
"series": "first",
}, {
"version": "1.1.0",
"sha": "0000000000000000000000000000000000000001",
"series": "first",
}],
)
expected_diff_from_pred = {
"releases": [{
"versions": [
{
"version": "1.1.0",
"sha": "0000000000000000000000000000000000000001",
},
],
}],
}
self.assertEqual(expected_diff_from_pred,
component_succ.difference(component_pred))
expected_diff_from_succ = {}
self.assertEqual(expected_diff_from_succ,
component_pred.difference(component_succ))
def test_create_with_release(self):
component = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
releases=[{
"version": "1.0.0",
"sha": "0000000000000000000000000000000000000000",
"series": "first",
}],
)
self.assertEqual(1, len(component.releases))
def test_create_release(self):
component = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
)
version = "1.0.0"
sha = "0000000000000000000000000000000000000000"
series = "first"
release = component.create_release(version=version,
sha=sha,
series=series)
self.assertIsInstance(release, c.Release)
self.assertEqual(release, component.get_release(release.version))
def test_to_file(self, save_data, is_changed):
component = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
releases=[{
"version": "1.0.0",
"sha": "0000000000000000000000000000000000000000",
"series": "first",
}],
directory=".",
)
is_changed.return_value = False
component.to_file()
save_data.assert_not_called()
is_changed.return_value = True
component.to_file()
self.assertEqual(1, save_data.call_count)
def test_is_changed_when_new(self):
component = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
releases=[{
"version": "1.0.0",
"sha": "0000000000000000000000000000000000000000",
"series": "first",
}],
)
self.assertTrue(component._is_changed)
component.create_release(
version="1.1.0",
sha="0000000000000000000000000000000000000001",
series="first",
)
self.assertTrue(component._is_changed)
def setUp(self):
self.component = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
)
def test_requirement_from_version_constraints(self):
component = c.Component(
name="test1",
repo_url="https://github.com/rcbops/test1",
is_product=False,
releases=[
{
"version": "0.0.1",
"sha": "0000000000000000000000000000000000000000",
"series": "first",
},
{
"version": "1.0.0",
"sha": "0000000000000000000000000000000000000001",
"series": "first",
},
{
"version": "1.0.1",
"sha": "0000000000000000000000000000000000000002",
"series": "first",
},
{
"version": "1.1.0",
"sha": "0000000000000000000000000000000000000003",
"series": "first",
},
{
"version": "1.1.1",
"sha": "0000000000000000000000000000000000000004",
"series": "first",
},
{
"version": "2.0.0-alpha.1",
"sha": "0000000000000000000000000000000000000005",
"series": "first",
},
{
"version": "2.0.0-beta.1",
"sha": "0000000000000000000000000000000000000006",
"series": "first",
},
{
"version": "2.0.0-beta.2",
"sha": "0000000000000000000000000000000000000007",
"series": "first",
},
{
"version": "2.0.0",
"sha": "0000000000000000000000000000000000000008",
"series": "first",
},
{
"version": "10.0.0",
"sha": "0000000000000000000000000000000000000009",
"series": "first",
},
],
)
self.assertTrue(schemata.component_schema.validate(
component.to_dict()))
constraints_test_cases = (
{
"constraints": [],
"expected_version": "10.0.0"
},
{
"constraints": ["version<10.0.0"],
"expected_version": "2.0.0"
},
{
"constraints": ["version<2"],
"expected_version": "1.1.1"
},
{
"constraints": ["version<1.1"],
"expected_version": "1.0.1"
},
{
"constraints": ["version<=1.1"],
"expected_version": "1.1.1"
},
{
"constraints": ["version<2.0.0-beta.1"],
"expected_version": "2.0.0-alpha.1"
},
)
for test_case in constraints_test_cases:
calculated_requirement = c.requirement_from_version_constraints(
component, test_case["constraints"])
self.assertEqual(test_case["expected_version"],
calculated_requirement["version"])
def component(releases_dir, components_dir, subparser, **kwargs):
os.makedirs(components_dir, exist_ok=True)
component_name = kwargs.pop("component_name")
if subparser == "get":
component = c_lib.Component.from_file(
component_name, components_dir
)
elif subparser == "add":
import_releases = kwargs.pop("import_releases", [])
try:
component = c_lib.Component.from_file(
component_name, components_dir
)
except c_lib.ComponentError:
pass
else:
raise c_lib.ComponentError(
"Component '{name}' already exists.".format(
name=component_name,
)
)
ssh_url = c_lib.git_http_to_ssh(kwargs["repo_url"])
with TemporaryDirectory() as tmp_dir:
try:
repo = git.Repo.clone_from(ssh_url, tmp_dir)
except FileNotFoundError as e:
raise c_lib.ComponentError(
"The repo_url provided is inaccessible, please check."
)
else:
repo.remotes.origin.fetch()
releases = []
for each in import_releases:
series, tag_regex = each.split(":", 1)
for tag in repo.tags:
if re.search(tag_regex, tag.name):
releases.append(
{
"version": tag.name,
"sha": str(tag.commit),
"series": series,
}
)
component = c_lib.Component(
name=component_name, directory=components_dir,
releases=releases, **kwargs
)
elif subparser == "update":
component = c_lib.Component.from_file(
component_name, components_dir
)
if kwargs["new_name"]:
component.name = kwargs["new_name"]
if kwargs["repo_url"]:
component.repo_url = kwargs["repo_url"]
if "is_product" in kwargs:
component.is_product = kwargs["is_product"]
else:
raise c_lib.ComponentError(
"The component subparser '{sp}' is not recognised.".format(
sp=subparser,
)
)
if component._is_changed:
component.to_file()
msg = "{change} component {name}".format(
change=subparser.capitalize(),
name=component.name,
)
c_lib.commit_changes(releases_dir, components_dir, msg)
return component
