pym/portage/tests/ebuild/test_config.py

   1 # Copyright 2010-2011 Gentoo Foundation
   2 # Distributed under the terms of the GNU General Public License v2
   3
   4 import portage
   5 from portage import os
   6 from portage.package.ebuild.config import config
   7 from portage.package.ebuild._config.LicenseManager import LicenseManager
   8 from portage.tests import TestCase
   9 from portage.tests.resolver.ResolverPlayground import ResolverPlayground, ResolverPlaygroundTestCase
  10
  11 class ConfigTestCase(TestCase):
  12
  13         def testClone(self):
  14                 """
  15                 Test the clone via constructor.
  16                 """
  17
  18                 ebuilds = {
  19                         "dev-libs/A-1": { },
  20                 }
  21
  22                 playground = ResolverPlayground(ebuilds=ebuilds)
  23                 try:
  24                         settings = config(clone=playground.settings)
  25                         result = playground.run(["=dev-libs/A-1"])
  26                         pkg, existing_node = result.depgraph._select_package(
  27                                 playground.root, "=dev-libs/A-1")
  28                         settings.setcpv(pkg)
  29
  30                         # clone after setcpv tests deepcopy of LazyItemsDict
  31                         settings2 = config(clone=settings)
  32                 finally:
  33                         playground.cleanup()
  34
  35         def testFeaturesMutation(self):
  36                 """
  37                 Test whether mutation of config.features updates the FEATURES
  38                 variable and persists through config.regenerate() calls. Also
  39                 verify that features_set._prune_overrides() works correctly.
  40                 """
  41                 playground = ResolverPlayground()
  42                 try:
  43                         settings = config(clone=playground.settings)
  44
  45                         settings.features.add('noclean')
  46                         self.assertEqual('noclean' in settings['FEATURES'].split(), True)
  47                         settings.regenerate()
  48                         self.assertEqual('noclean' in settings['FEATURES'].split(),True)
  49
  50                         settings.features.discard('noclean')
  51                         self.assertEqual('noclean' in settings['FEATURES'].split(), False)
  52                         settings.regenerate()
  53                         self.assertEqual('noclean' in settings['FEATURES'].split(), False)
  54
  55                         settings.features.add('noclean')
  56                         self.assertEqual('noclean' in settings['FEATURES'].split(), True)
  57                         settings.regenerate()
  58                         self.assertEqual('noclean' in settings['FEATURES'].split(),True)
  59
  60                         # before: ['noclean', '-noclean', 'noclean']
  61                         settings.features._prune_overrides()
  62                         #  after: ['noclean']
  63                         self.assertEqual(settings._features_overrides.count('noclean'), 1)
  64                         self.assertEqual(settings._features_overrides.count('-noclean'), 0)
  65
  66                         settings.features.remove('noclean')
  67
  68                         # before: ['noclean', '-noclean']
  69                         settings.features._prune_overrides()
  70                         #  after: ['-noclean']
  71                         self.assertEqual(settings._features_overrides.count('noclean'), 0)
  72                         self.assertEqual(settings._features_overrides.count('-noclean'), 1)
  73                 finally:
  74                         playground.cleanup()
  75
  76         def testLicenseManager(self):
  77
  78                 user_config = {
  79                         "package.license":
  80                                 (
  81                                         "dev-libs/* TEST",
  82                                         "dev-libs/A -TEST2",
  83                                         "=dev-libs/A-2 TEST3 @TEST",
  84                                         "*/* @EULA TEST2",
  85                                         "=dev-libs/C-1 *",
  86                                         "=dev-libs/C-2 -*",
  87                                 ),
  88                 }
  89
  90                 playground = ResolverPlayground(user_config=user_config)
  91                 try:
  92                         portage.util.noiselimit = -2
  93
  94                         license_group_locations = (os.path.join(playground.portdir, "profiles"),)
  95                         pkg_license = os.path.join(playground.eroot, "etc", "portage")
  96
  97                         lic_man = LicenseManager(license_group_locations, pkg_license)
  98
  99                         self.assertEqual(lic_man._accept_license_str, None)
 100                         self.assertEqual(lic_man._accept_license, None)
 101                         self.assertEqual(lic_man._license_groups, {"EULA": frozenset(["TEST"])})
 102                         self.assertEqual(lic_man._undef_lic_groups, set(["TEST"]))
 103
 104                         self.assertEqual(lic_man.extract_global_changes(), "TEST TEST2")
 105                         self.assertEqual(lic_man.extract_global_changes(), "")
 106
 107                         lic_man.set_accept_license_str("TEST TEST2")
 108                         self.assertEqual(lic_man._getPkgAcceptLicense("dev-libs/B-1", "0", None), ["TEST", "TEST2", "TEST"])
 109                         self.assertEqual(lic_man._getPkgAcceptLicense("dev-libs/A-1", "0", None), ["TEST", "TEST2", "TEST", "-TEST2"])
 110                         self.assertEqual(lic_man._getPkgAcceptLicense("dev-libs/A-2", "0", None), ["TEST", "TEST2", "TEST", "-TEST2", "TEST3", "@TEST"])
 111
 112                         self.assertEqual(lic_man.get_prunned_accept_license("dev-libs/B-1", [], "TEST", "0", None), "TEST")
 113                         self.assertEqual(lic_man.get_prunned_accept_license("dev-libs/A-1", [], "-TEST2", "0", None), "")
 114                         self.assertEqual(lic_man.get_prunned_accept_license("dev-libs/A-2", [], "|| ( TEST TEST2 )", "0", None), "TEST")
 115                         self.assertEqual(lic_man.get_prunned_accept_license("dev-libs/C-1", [], "TEST5", "0", None), "TEST5")
 116                         self.assertEqual(lic_man.get_prunned_accept_license("dev-libs/C-2", [], "TEST2", "0", None), "")
 117
 118                         self.assertEqual(lic_man.getMissingLicenses("dev-libs/B-1", [], "TEST", "0", None), [])
 119                         self.assertEqual(lic_man.getMissingLicenses("dev-libs/A-1", [], "-TEST2", "0", None), ["-TEST2"])
 120                         self.assertEqual(lic_man.getMissingLicenses("dev-libs/A-2", [], "|| ( TEST TEST2 )", "0", None), [])
 121                         self.assertEqual(lic_man.getMissingLicenses("dev-libs/A-3", [], "|| ( TEST2 || ( TEST3 TEST4 ) )", "0", None), ["TEST2", "TEST3", "TEST4"])
 122                         self.assertEqual(lic_man.getMissingLicenses("dev-libs/C-1", [], "TEST5", "0", None), [])
 123                         self.assertEqual(lic_man.getMissingLicenses("dev-libs/C-2", [], "TEST2", "0", None), ["TEST2"])
 124                         self.assertEqual(lic_man.getMissingLicenses("dev-libs/D-1", [], "", "0", None), [])
 125                 finally:
 126                         portage.util.noiselimit = 0
 127                         playground.cleanup()
 128
 129         def testPackageMaskOrder(self):
 130
 131                 ebuilds = {
 132                         "dev-libs/A-1": { },
 133                         "dev-libs/B-1": { },
 134                         "dev-libs/C-1": { },
 135                         "dev-libs/D-1": { },
 136                         "dev-libs/E-1": { },
 137                 }
 138
 139                 repo_configs = {
 140                         "test_repo": {
 141                                 "package.mask":
 142                                         (
 143                                                 "dev-libs/A",
 144                                                 "dev-libs/C",
 145                                         ),
 146                         }
 147                 }
 148
 149                 profile = {
 150                         "package.mask":
 151                                 (
 152                                         "-dev-libs/A",
 153                                         "dev-libs/B",
 154                                         "-dev-libs/B",
 155                                         "dev-libs/D",
 156                                 ),
 157                 }
 158
 159                 user_config = {
 160                         "package.mask":
 161                                 (
 162                                         "-dev-libs/C",
 163                                         "-dev-libs/D",
 164                                         "dev-libs/E",
 165                                 ),
 166                 }
 167
 168                 test_cases = (
 169                                 ResolverPlaygroundTestCase(
 170                                         ["dev-libs/A"],
 171                                         options = { "--autounmask": 'n' },
 172                                         success = False),
 173                                 ResolverPlaygroundTestCase(
 174                                         ["dev-libs/B"],
 175                                         success = True,
 176                                         mergelist = ["dev-libs/B-1"]),
 177                                 ResolverPlaygroundTestCase(
 178                                         ["dev-libs/C"],
 179                                         success = True,
 180                                         mergelist = ["dev-libs/C-1"]),
 181                                 ResolverPlaygroundTestCase(
 182                                         ["dev-libs/D"],
 183                                         success = True,
 184                                         mergelist = ["dev-libs/D-1"]),
 185                                 ResolverPlaygroundTestCase(
 186                                         ["dev-libs/E"],
 187                                         options = { "--autounmask": 'n' },
 188                                         success = False),
 189                 )
 190
 191                 playground = ResolverPlayground(ebuilds=ebuilds, repo_configs=repo_configs, \
 192                         profile=profile, user_config=user_config)
 193                 try:
 194                         for test_case in test_cases:
 195                                 playground.run_TestCase(test_case)
 196                                 self.assertEqual(test_case.test_success, True, test_case.fail_msg)
 197                 finally:
 198                         playground.cleanup()