+ # -*- coding: utf-8 -*-

+ 

+ import os

+ import glob

+ 

+ import productmd

+ 

+ 

+ def _get_label_name(label):

+     if not label:

+         return None

+     return label.split("-")[0]

+ 

+ 

+ def _sort_key(compose):

+     # Composes should be sorted according to this tuple. This mimicks sorting

+     # in productmd, but without a check for release name. This is safe to do

+     # here, because we always sort composes that were first filtered to the

+     # same short name.

+     return (

+         tuple(productmd.common.split_version(compose.info.release.version)),

+         compose.info.compose.date,

+         productmd.composeinfo.COMPOSE_TYPES.index(compose.info.compose.type),

+         compose.info.compose.respin,

+     )

+ 

+ 

+ def find_composes(patterns):

+     """Given a list of path globs, find all composes in those paths.

+     """

+     result = []

+     for pattern in patterns:

+         for topdir in glob.glob(pattern):

+             for i in os.listdir(topdir):

+                 compose_path = os.path.join(topdir, i)

+                 if os.path.islink(compose_path):

+                     continue

+                 if not os.path.isdir(compose_path):

+                     continue

+ 

+                 compose = productmd.compose.Compose(compose_path)

+                 try:

+                     # Access the metadata to raise an error.

+                     compose.info

+                 except Exception as ex:

+                     continue

+                 result.append(compose)

+     return result

+ 

+ 

+ def filter_composes(

+     composes,

+     release_short=None,

+     release_major_version=None,

+     release_version=None,

+     base_product_short=None,

+     base_product_version=None,

+ ):

+     """Filter composes according to arguments."""

+     result = []

+ 

+     for compose in composes:

+         ci = compose.info

+         if release_short and ci.release.short != release_short:

+             continue

+         if release_major_version and ci.release.major_version != release_major_version:

+             continue

+         if release_version and ci.release.version != release_version:

+             continue

+         if base_product_short and ci.base_product.short != base_product_short:

+             continue

+         if base_product_version and ci.base_product.version != base_product_version:

+             continue

+         result.append(compose)

+ 

+     base_products = set()

+     major_versions = set()

+     for compose in result:

+         ci = compose.info

+         if ci.release.is_layered:

+             base_products.add("%s-%s" % (ci.base_product.short, ci.base_product.version))

+         else:

+             base_products.add(None)

+         major_versions.add(ci.release.major_version)

+ 

+     if len(base_products) > 1:

+         raise ValueError(

+             "More than 1 base product found: %s" % ", ".join(sorted(base_products))

+         )

+     if len(major_versions) > 1:

+         raise ValueError(

+             "More than 1 major version found: %s" % ", ".join(sorted(major_versions))

+         )

+ 

+     return result

+ 

+ 

+ def filter_compatible_composes(composes, compose):

+     """Return composes compatible with provided compose (same release etc.)"""

+     return filter_composes(

+         composes,

+         release_short=compose.info.release.short,

+         release_major_version=compose.info.release.major_version,

+         base_product_short=compose.info.base_product.short,

+         base_product_version=compose.info.base_product.version,

+     )

+ 

+ 

+ def filter_previous_release(composes, compose):

+     """Return composes for the previous product release"""

+     version_split = compose.info.release.version.split(".")

+     version_split[-1] = str(int(version_split[-1]) - 1)

+     previous_version = ".".join(version_split)

+     return filter_composes(

+         composes,

+         release_short=compose.info.release.short,

+         release_version=previous_version,

+         base_product_short=compose.info.base_product.short,

+         base_product_version=compose.info.base_product.version,

+     )

+ 

+ 

+ def filter_same_release(composes, compose):

+     """Return composes for the same product release"""

+     return filter_composes(

+         composes,

+         release_short=compose.info.release.short,

+         release_version=compose.info.release.version,

+         base_product_short=compose.info.base_product.short,

+         base_product_version=compose.info.base_product.version,

+     )

+ 

+ 

+ def filter_compose_type(composes, compose_type):

+     """Return composes matching given compose_type"""

+     return [i for i in composes if i.info.compose.type == compose_type]

+ 

+ 

+ def filter_older_than(composes, compose):

+     """Return composes older than given compose"""

+     return [i for i in composes if _sort_key(i) < _sort_key(compose)]

+ 

+ 

+ def _get_latest(composes):

+     return max(composes, key=_sort_key) if composes else None

+ 

+ 

+ def _get_latest_by_type(composes, type_, compose=None):

+     if compose:

+         composes = filter_older_than(composes, compose)

+     composes = filter_compose_type(composes, type_)

+     return _get_latest(composes)

+ 

+ 

+ def get_latest_production(composes, compose=None):

+     """Return latest production compose"""

+     return _get_latest_by_type(composes, "production", compose=compose)

+ 

+ 

+ def get_latest_nightly(composes, compose=None):

+     """Return latest nightly compose"""

+     return _get_latest_by_type(composes, "nightly", compose=compose)

+ 

+ 

+ def get_previous_ga(composes, compose=None):

+     """Return latest RC for *previous* product release"""

+     if compose:

+         composes = filter_previous_release(composes, compose)

+     composes = filter_compose_type(composes, "production")

+     composes = [i for i in composes if _get_label_name(i.info.compose.label) == "RC"]

+     return _get_latest(composes)

+ 

+ 

+ def get_latest_beta(composes, compose=None):

+     """Return latest Beta for current product release"""

+     if compose:

+         if _get_label_name(compose.info.compose.label) == "Beta":

+             return None

+         composes = filter_same_release(composes, compose)

+     composes = filter_compose_type(composes, "production")

+     composes = [i for i in composes if _get_label_name(i.info.compose.label) == "Beta"]

+     return _get_latest(composes)

+ 

+ 

+ def get_previous_milestone(composes, compose):

+     """Return latest compose with a different milestone name"""

+     if not compose.info.compose.label:

+         return None

+     composes = filter_same_release(composes, compose)

+     composes = filter_older_than(composes, compose)

+     composes = filter_compose_type(composes, "production")

+     label_name = _get_label_name(compose.info.compose.label)

+     composes = [

+         i

+         for i in composes

+         if _get_label_name(i.info.compose.label) != label_name

+     ]

+     return _get_latest(composes)

+ 

+ 

+ def get_same_milestone_previous_version(composes, compose):

+     """Return latest compose with the same milestone name, but lower major

+     label version.

+     """

+     if not compose.info.compose.label:

+         return None

+     composes = filter_same_release(composes, compose)

+     composes = filter_older_than(composes, compose)

+     composes = filter_compose_type(composes, "production")

+     label_name = _get_label_name(compose.info.compose.label)

+     composes = [

+         i

+         for i in composes

+         if i.info.compose.label_major_version != compose.info.compose.label_major_version

+         and _get_label_name(i.info.compose.label) == label_name

+     ]

+     return _get_latest(composes)

+ 

+ 

+ def get_same_milestone_previous_respin(composes, compose):

+     """Return latest compose with the same milestone name, same major label

+     version, but lower minor label version (older respin).

+     """

+     if not compose.info.compose.label:

+         return None

+     composes = filter_same_release(composes, compose)

+     composes = filter_older_than(composes, compose)

+     composes = filter_compose_type(composes, "production")

+     label_name = _get_label_name(compose.info.compose.label)

+     composes = [

+         i

+         for i in composes

+         if i.info.compose.label_major_version == compose.info.compose.label_major_version

+         and _get_label_name(i.info.compose.label) == label_name

+     ]

+     return _get_latest(composes)

+ 

+ 

+ def get_related_composes(composes, compose):

+     """Return composes related to the given one"""

+     result = {}

+ 

+     result["beta"] = get_latest_beta(composes, compose)

+     result["ga"] = get_previous_ga(composes, compose)

+ 

+     result["latest_production"] = get_latest_production(composes, compose)

+     result["latest_nightly"] = get_latest_nightly(composes)

+ 

+     if compose is None:

+         compose = result["latest_production"]

+     result["previous_milestone"] = get_previous_milestone(composes, compose)

+     result["same_milestone_previous_version"] = get_same_milestone_previous_version(

+         composes, compose

+     )

+     result["same_milestone_previous_respin"] = get_same_milestone_previous_respin(

+         composes, compose

+     )

+ 

+     return result

+ tests/composes/DP-1.0-20160315.t.0 

+ import os

+ import mock

+ 

+ try:

+     import unittest2 as unittest

+ except ImportError:

+     import unittest

+ 

+ from compose_utils import find_latest

+ 

+ EXISTING_COMPOSES = [

+     "DP-1.0-20160315.t.0",

+     "DP-1.0-20160315.t.1",

+     "DP-1.0-20160315.t.2",

+     "DP-1.0-20160720.t.8",

+     "DP-1.0-20181012.t.0",

+     "Fedora-Modular-Bikeshed-20171004.n.0",

+     "Fedora-Modular-Bikeshed-20171005.n.0",

+ ]

+ 

+ 

+ class TestFindComposes(unittest.TestCase):

+     def test_find_in_path(self):

+         path = os.path.join(os.path.dirname(__file__), "composes")

+         composes = find_latest.find_composes([path])

+         self.assertItemsEqual([c.info.compose.id for c in composes], EXISTING_COMPOSES)

+ 

+     def test_find_with_glob(self):

+         path = os.path.join(os.path.dirname(__file__), "comp*")

+         composes = find_latest.find_composes([path])

+         self.assertItemsEqual([c.info.compose.id for c in composes], EXISTING_COMPOSES)

+ 

+ 

+ class MockCI(object):

+     def __init__(

+         self,

+         release_short,

+         release_version,

+         bp_short=None,

+         bp_version=None,

+         type_=None,

+         label=None,

+         date=None,

+         respin=None,

+     ):

+         self.release = mock.Mock(

+             short=release_short,

+             version=release_version,

+             major_version=release_version.split(".")[0],

+             is_layered=False,

+         )

+         self.release.is_layered = bp_short and bp_version

+         self.base_product = mock.Mock(short=bp_short, version=bp_version)

+         cid = "%s-%s-%s.%s" % (release_short, release_version, date, respin)

+         self.compose = mock.Mock(

+             type=type_,

+             label=label,

+             label_major_version=label.split("-")[1].split(".")[0] if label else None,

+             date=date,

+             respin=respin,

+             id=cid,

+         )

+ 

+     def __repr__(self):

+         return "MockCI(%s, %s, %s, %s, %s, %s, %s, %s)" % (

+             self.release.short,

+             self.release.version,

+             self.base_product.short,

+             self.base_product.version,

+             self.compose.type,

+             self.compose.label,

+             self.compose.date,

+             self.compose.respin,

+         )

+ 

+ 

+ class MockCompose(object):

+     def __init__(self, *args, **kwargs):

+         self.info = MockCI(*args, **kwargs)

+ 

+     def __repr__(self):

+         return "MockCompose<%r>" % self.info

+ 

+ 

+ class TestFilterComposes(unittest.TestCase):

+     def setUp(self):

+         self.c_dp10 = MockCompose("DP", "1.0")

+         self.c_test10 = MockCompose("Test", "1.0")

+         self.c_dp20 = MockCompose("DP", "2.0")

+         self.c_dp21 = MockCompose("DP", "2.1")

+         self.c_lp30 = MockCompose("LP1", "3.0", bp_short="BP", bp_version="4")

+         self.c_lp31 = MockCompose("LP2", "3.1", bp_short="BP", bp_version="5")

+         self.c_lp50 = MockCompose("LP", "5.0", bp_short="XP", bp_version="6")

+         self.ci_list = [self.c_dp10, self.c_test10, self.c_dp20, self.c_dp21]

+         self.layered_list = [self.c_lp30, self.c_lp31, self.c_lp50]

+ 

+     def test_no_filter(self):

+         ci_list = [self.c_dp10, self.c_test10]

+         self.assertEqual(find_latest.filter_composes(ci_list), ci_list)

+ 

+     def test_filter_release_short(self):

+         self.assertEqual(

+             find_latest.filter_composes(self.ci_list, release_short="Test"),

+             [self.c_test10],

+         )

+ 

+     def test_filter_release_major_version(self):

+         self.assertEqual(

+             find_latest.filter_composes(self.ci_list, release_major_version="1"),

+             [self.c_dp10, self.c_test10],

+         )

+ 

+     def test_filter_release_version(self):

+         self.assertEqual(

+             find_latest.filter_composes(self.ci_list, release_version="2.1"),

+             [self.c_dp21],

+         )

+ 

+     def test_filter_base_product(self):

+         self.assertEqual(

+             find_latest.filter_composes(self.layered_list, base_product_short="XP"),

+             [self.c_lp50],

+         )

+ 

+     def test_filter_base_product_version(self):

+         self.assertEqual(

+             find_latest.filter_composes(self.layered_list, base_product_version="4"),

+             [self.c_lp30],

+         )

+ 

+     def test_multiple_release_shorts(self):

+         with self.assertRaises(ValueError) as ctx:

+             find_latest.filter_composes(self.layered_list, base_product_short="BP")

+         self.assertIn("More than 1 base product", str(ctx.exception))

+ 

+     def test_multiple_major_version(self):

+         with self.assertRaises(ValueError) as ctx:

+             find_latest.filter_composes(self.ci_list, release_short="DP")

+         self.assertIn("More than 1 major version", str(ctx.exception))

+ 

+ 

+ class TestFilters(unittest.TestCase):

+     def setUp(self):

+         self.ci_list = mock.Mock()

+ 

+     @mock.patch("compose_utils.find_latest.filter_composes")

+     def test_filter_compatible(self, mock_filter):

+         ci = MockCompose("DP", "1.0", "BP", "2")

+         self.assertEqual(

+             find_latest.filter_compatible_composes(self.ci_list, ci),

+             mock_filter.return_value,

+         )

+         self.assertEqual(

+             mock_filter.call_args_list,

+             [

+                 mock.call(

+                     self.ci_list,

+                     release_short="DP",

+                     release_major_version="1",

+                     base_product_short="BP",

+                     base_product_version="2",

+                 )

+             ],

+         )

+ 

+     @mock.patch("compose_utils.find_latest.filter_composes")

+     def test_filter_same_release(self, mock_filter):

+         ci = MockCompose("DP", "1.0", "BP", "2")

+         self.assertEqual(

+             find_latest.filter_same_release(self.ci_list, ci), mock_filter.return_value

+         )

+         self.assertEqual(

+             mock_filter.call_args_list,

+             [

+                 mock.call(

+                     self.ci_list,

+                     release_short="DP",

+                     release_version="1.0",

+                     base_product_short="BP",

+                     base_product_version="2",

+                 )

+             ],

+         )

+ 

+     @mock.patch("compose_utils.find_latest.filter_composes")

+     def test_filter_previous_release(self, mock_filter):

+         ci = MockCompose("DP", "2.4", "BP", "1")

+         self.assertEqual(

+             find_latest.filter_previous_release(self.ci_list, ci),

+             mock_filter.return_value,

+         )

+         self.assertEqual(

+             mock_filter.call_args_list,

+             [

+                 mock.call(

+                     self.ci_list,

+                     release_short="DP",

+                     release_version="2.3",

+                     base_product_short="BP",

+                     base_product_version="1",

+                 )

+             ],

+         )

+ 

+     def test_filter_by_type(self):

+         nightly = MockCompose("DP", "1.0", type_="nightly")

+         ci_list = [nightly, MockCompose("DP", "1.0", type_="production")]

+         self.assertEqual(find_latest.filter_compose_type(ci_list, "nightly"), [nightly])

+ 

+     def test_filter_older_than(self):

+         c1 = MockCompose("DP", "1.0", type_="nightly", date="20190301", respin=0)

+         c2 = MockCompose("DP", "1.0", type_="nightly", date="20190301", respin=1)

+         c3 = MockCompose("DP", "1.0", type_="nightly", date="20190228", respin=0)

+         c4 = MockCompose("DP", "1.0", type_="nightly", date="20190228", respin=1)

+         ci_list = [c1, c2, c3, c4]

+         self.assertEqual(find_latest.filter_older_than(ci_list, c1), [c3, c4])

+         self.assertEqual(find_latest.filter_older_than(ci_list, c2), [c1, c3, c4])

+         self.assertEqual(find_latest.filter_older_than(ci_list, c3), [])

+         self.assertEqual(find_latest.filter_older_than(ci_list, c4), [c3])

+ 

+     def test_get_latest_production(self):

+         c1 = MockCompose("DP", "1.0", type_="nightly", date="20190301", respin=0)

+         c2 = MockCompose("DP", "1.0", type_="production", date="20190301", respin=1)

+         c3 = MockCompose("DP", "1.0", type_="production", date="20190228", respin=0)

+         c4 = MockCompose("DP", "1.0", type_="production", date="20190228", respin=1)

+         ci_list = [c1, c2, c3, c4]

+         self.assertEqual(find_latest.get_latest_production(ci_list), c2)

+         self.assertEqual(find_latest.get_latest_production(ci_list, c2), c4)

+         self.assertEqual(find_latest.get_latest_production(ci_list, c4), c3)

+         self.assertEqual(find_latest.get_latest_production(ci_list, c3), None)

+ 

+     def test_get_latest_nightly(self):

+         c1 = MockCompose("DP", "1.0", type_="production", date="20190301", respin=0)

+         c2 = MockCompose("DP", "1.0", type_="nightly", date="20190301", respin=1)

+         c3 = MockCompose("DP", "1.0", type_="nightly", date="20190228", respin=0)

+         c4 = MockCompose("DP", "1.0", type_="nightly", date="20190228", respin=1)

+         ci_list = [c1, c2, c3, c4]

+         self.assertEqual(find_latest.get_latest_nightly(ci_list), c2)

+         self.assertEqual(find_latest.get_latest_nightly(ci_list, c2), c4)

+         self.assertEqual(find_latest.get_latest_nightly(ci_list, c4), c3)

+         self.assertEqual(find_latest.get_latest_nightly(ci_list, c3), None)

+ 

+     def test_get_previous_ga(self):

+         c1 = MockCompose("DP", "1.0", type_="nightly", date="20190301", respin=0)

+         c2 = MockCompose(

+             "DP", "1.1", type_="production", date="20190301", respin=1, label="RC-1.0"

+         )

+         c3 = MockCompose(

+             "DP", "1.0", type_="production", date="20190228", respin=0, label="RC-1.0"

+         )

+         c4 = MockCompose("DP", "1.0", type_="production", date="20190228", respin=1)

+         ci_list = [c1, c2, c3, c4]

+         self.assertEqual(find_latest.get_previous_ga(ci_list), c2)

+         self.assertEqual(find_latest.get_previous_ga(ci_list, c2), c3)

+         self.assertEqual(find_latest.get_previous_ga(ci_list, c3), None)

+ 

+     def test_get_previous_beta(self):

+         c1 = MockCompose("DP", "1.0", type_="nightly", date="20190301", respin=0)

+         c2 = MockCompose(

+             "DP", "1.1", type_="production", date="20190301", respin=1, label="Beta-1.1"

+         )

+         c3 = MockCompose("DP", "1.0", type_="production", date="20190228", respin=0)

+         c4 = MockCompose(

+             "DP", "1.0", type_="production", date="20190228", respin=1, label="Beta-1.0"

+         )

+         c5 = MockCompose("DP", "2.0", type_="production", date="20190227", respin=0)

+         ci_list = [c1, c2, c3, c4, c5]

+         self.assertEqual(find_latest.get_latest_beta(ci_list, c2), None)

+         self.assertEqual(find_latest.get_latest_beta(ci_list), c2)

+         self.assertEqual(find_latest.get_latest_beta(ci_list, c3), c4)

+         self.assertEqual(find_latest.get_latest_beta(ci_list, c5), None)

+ 

+     def test_get_previous_milestone(self):

+         c1 = MockCompose("DP", "1.0", type_="nightly", date="20190301", respin=0)

+         c2 = MockCompose(

+             "DP", "1.0", type_="production", date="20190301", respin=1, label="Beta-1.1"

+         )

+         c3 = MockCompose(

+             "DP", "1.1", type_="production", date="20190228", respin=0, label="RC-1.0"

+         )

+         c4 = MockCompose(

+             "DP",

+             "1.0",

+             type_="production",

+             date="20190228",

+             respin=1,

+             label="Alpha-1.0",

+         )

+         ci_list = [c1, c2, c3, c4]

+         self.assertEqual(find_latest.get_previous_milestone(ci_list, c1), None)

+         self.assertEqual(find_latest.get_previous_milestone(ci_list, c2), c4)

+         self.assertEqual(find_latest.get_previous_milestone(ci_list, c3), None)

+         self.assertEqual(find_latest.get_previous_milestone(ci_list, c4), None)

+ 

+     def test_get_same_milestone_previous_version(self):

+         c1 = MockCompose("DP", "1.0", type_="nightly", date="20190301", respin=0)

+         c2 = MockCompose(

+             "DP", "1.0", type_="production", date="20190201", respin=1, label="Beta-1.1"

+         )

+         c3 = MockCompose(

+             "DP", "1.0", type_="production", date="20190328", respin=0, label="Beta-2.0"

+         )

+         c4 = MockCompose(

+             "XP",

+             "1.0",

+             type_="production",

+             date="20190328",

+             respin=1,

+             label="Alpha-1.0",

+         )

+         c5 = MockCompose(

+             "DP", "1.0", type_="production", date="20190401", respin=0, label="Beta-2.1"

+         )

+         ci_list = [c1, c2, c3, c4, c5]

+         self.assertEqual(

+             find_latest.get_same_milestone_previous_version(ci_list, c1), None

+         )

+         self.assertEqual(

+             find_latest.get_same_milestone_previous_version(ci_list, c2), None

+         )

+         self.assertEqual(

+             find_latest.get_same_milestone_previous_version(ci_list, c3), c2

+         )

+         self.assertEqual(

+             find_latest.get_same_milestone_previous_version(ci_list, c4), None

+         )

+         self.assertEqual(

+             find_latest.get_same_milestone_previous_version(ci_list, c5), c2

+         )

+ 

+     def test_get_same_milestone_previous_respin(self):

+         c1 = MockCompose("DP", "1.0", type_="nightly", date="20190301", respin=0)

+         c2 = MockCompose(

+             "DP", "1.0", type_="production", date="20190201", respin=1, label="Beta-1.0"

+         )

+         c3 = MockCompose(

+             "DP", "1.0", type_="production", date="20190328", respin=0, label="Beta-1.1"

+         )

+         c4 = MockCompose(

+             "XP",

+             "1.0",

+             type_="production",

+             date="20190328",

+             respin=1,

+             label="Alpha-1.0",

+         )

+         ci_list = [c1, c2, c3, c4]

+         self.assertEqual(

+             find_latest.get_same_milestone_previous_respin(ci_list, c1), None

+         )

+         self.assertEqual(

+             find_latest.get_same_milestone_previous_respin(ci_list, c2), None

+         )

+         self.assertEqual(

+             find_latest.get_same_milestone_previous_respin(ci_list, c3), c2

+         )

+         self.assertEqual(

+             find_latest.get_same_milestone_previous_respin(ci_list, c4), None

+         )

+ 

+ 

+ @mock.patch("compose_utils.find_latest.get_latest_beta")

+ @mock.patch("compose_utils.find_latest.get_previous_ga")

+ @mock.patch("compose_utils.find_latest.get_latest_production")

+ @mock.patch("compose_utils.find_latest.get_latest_nightly")

+ @mock.patch("compose_utils.find_latest.get_previous_milestone")

+ @mock.patch("compose_utils.find_latest.get_same_milestone_previous_version")

+ @mock.patch("compose_utils.find_latest.get_same_milestone_previous_respin")

+ class TestGetRelatedComposes(unittest.TestCase):

+     def setUp(self):

+         self.ci = mock.Mock()

+         self.ci_list = mock.Mock()

+ 

+     def test_get_related(self, gsmpr, gsmpv, gpm, gln, glp, gpg, glb):

+         self.assertEqual(

+             find_latest.get_related_composes(self.ci_list, None),

+             {

+                 "beta": glb.return_value,

+                 "ga": gpg.return_value,

+                 "latest_nightly": gln.return_value,

+                 "latest_production": glp.return_value,

+                 "previous_milestone": gpm.return_value,

+                 "same_milestone_previous_version": gsmpv.return_value,

+                 "same_milestone_previous_respin": gsmpr.return_value,

+             },

+         )

+         self.assertEqual(glb.call_args_list, [mock.call(self.ci_list, None)])

+         self.assertEqual(gpg.call_args_list, [mock.call(self.ci_list, None)])

+         self.assertEqual(glp.call_args_list, [mock.call(self.ci_list, None)])

+         self.assertEqual(gln.call_args_list, [mock.call(self.ci_list)])

+         self.assertEqual(

+             gpm.call_args_list, [mock.call(self.ci_list, glp.return_value)]

+         )

+         self.assertEqual(

+             gsmpv.call_args_list, [mock.call(self.ci_list, glp.return_value)]

+         )

+         self.assertEqual(

+             gsmpr.call_args_list, [mock.call(self.ci_list, glp.return_value)]

+         )

+ 

+     def test_get_related_with_ci(self, gsmpr, gsmpv, gpm, gln, glp, gpg, glb):

+         self.assertEqual(

+             find_latest.get_related_composes(self.ci_list, self.ci),

+             {

+                 "beta": glb.return_value,

+                 "ga": gpg.return_value,

+                 "latest_nightly": gln.return_value,

+                 "latest_production": glp.return_value,

+                 "previous_milestone": gpm.return_value,

+                 "same_milestone_previous_version": gsmpv.return_value,

+                 "same_milestone_previous_respin": gsmpr.return_value,

+             },

+         )

+         self.assertEqual(glb.call_args_list, [mock.call(self.ci_list, self.ci)])

+         self.assertEqual(gpg.call_args_list, [mock.call(self.ci_list, self.ci)])

+         self.assertEqual(glp.call_args_list, [mock.call(self.ci_list, self.ci)])

+         self.assertEqual(gln.call_args_list, [mock.call(self.ci_list)])

+         self.assertEqual(gpm.call_args_list, [mock.call(self.ci_list, self.ci)])

+         self.assertEqual(gsmpv.call_args_list, [mock.call(self.ci_list, self.ci)])

+         self.assertEqual(gsmpr.call_args_list, [mock.call(self.ci_list, self.ci)])

+ ignore = E501,E402,W503