tools/mb/mb_validation_unittest.py

   1 #!/usr/bin/env python3
   2 # Copyright 2020 The Chromium Authors
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5 """Tests for mb_validate.py."""
   6
   7 import sys
   8 import ast
   9 import os
  10 import unittest
  11
  12 sys.path.insert(0, os.path.join(
  13     os.path.dirname(os.path.abspath(__file__)), '..'))
  14
  15 from mb import mb
  16 from mb import mb_unittest
  17 from mb.lib import validation
  18
  19 TEST_UNREFERENCED_MIXIN_CONFIG = """\
  20 {
  21   'public_artifact_builders': {},
  22   'configs': {
  23     'rel_bot_1': ['rel'],
  24     'rel_bot_2': ['rel'],
  25   },
  26   'builder_groups': {
  27     'fake_builder_group_a': {
  28       'fake_builder_a': 'rel_bot_1',
  29       'fake_builder_b': 'rel_bot_2',
  30     },
  31   },
  32   'mixins': {
  33     'unreferenced_mixin': {
  34       'gn_args': 'proprietary_codecs=true',
  35     },
  36     'rel': {
  37       'gn_args': 'is_debug=false',
  38     },
  39   },
  40 }
  41 """
  42
  43 TEST_UNKNOWNMIXIN_CONFIG = """\
  44 {
  45   'public_artifact_builders': {},
  46   'configs': {
  47     'rel_bot_1': ['rel'],
  48     'rel_bot_2': ['rel', 'unknown_mixin'],
  49   },
  50   'builder_groups': {
  51     'fake_builder_group_a': {
  52       'fake_builder_a': 'rel_bot_1',
  53       'fake_builder_b': 'rel_bot_2',
  54     },
  55   },
  56   'mixins': {
  57     'rel': {
  58       'gn_args': 'is_debug=false',
  59     },
  60   },
  61 }
  62 """
  63
  64 TEST_UNKNOWN_NESTED_MIXIN_CONFIG = """\
  65 {
  66   'public_artifact_builders': {},
  67   'configs': {
  68     'rel_bot_1': ['rel', 'nested_mixin'],
  69     'rel_bot_2': ['rel'],
  70   },
  71   'builder_groups': {
  72     'fake_builder_group_a': {
  73       'fake_builder_a': 'rel_bot_1',
  74       'fake_builder_b': 'rel_bot_2',
  75     },
  76   },
  77   'mixins': {
  78     'nested_mixin': {
  79       'mixins': {
  80         'unknown_mixin': {
  81           'gn_args': 'proprietary_codecs=true',
  82         },
  83       },
  84     },
  85     'rel': {
  86       'gn_args': 'is_debug=false',
  87     },
  88   },
  89 }
  90 """
  91
  92 TEST_CONFIG_UNSORTED_GROUPS = """\
  93 {
  94   'builder_groups': {
  95     'groupB': {},
  96     'groupA': {},
  97     'groupC': {},
  98   },
  99   'configs': {
 100   },
 101   'mixins': {
 102   },
 103 }
 104 """
 105
 106 TEST_CONFIG_UNSORTED_BUILDERNAMES = """\
 107 {
 108   'builder_groups': {
 109     'group': {
 110       'builderB': '',
 111       'builderA': ''
 112     },
 113   },
 114   'configs': {
 115   },
 116   'mixins': {
 117   },
 118 }
 119 """
 120
 121 TEST_CONFIG_UNSORTED_CONFIGS = """\
 122 {
 123   'builder_groups': {
 124   },
 125   'configs': {
 126     'configB': {},
 127     'configA': {},
 128   },
 129   'mixins': {
 130   },
 131 }
 132 """
 133
 134 TEST_CONFIG_UNSORTED_MIXINS = """\
 135 {
 136   'builder_groups': {
 137   },
 138   'configs': {
 139   },
 140   'mixins': {
 141     'mixinB': {},
 142     'mixinA': {},
 143   },
 144 }
 145 """
 146
 147
 148 class UnitTest(unittest.TestCase):
 149   def test_GetAllConfigs(self):
 150     configs = ast.literal_eval(mb_unittest.TEST_CONFIG)
 151     all_configs = validation.GetAllConfigs(configs['builder_groups'])
 152     self.assertEqual(all_configs['rel_bot'], 'fake_builder_group')
 153     self.assertEqual(all_configs['debug_goma'], 'fake_builder_group')
 154
 155   def test_CheckAllConfigsAndMixinsReferenced_ok(self):
 156     configs = ast.literal_eval(mb_unittest.TEST_CONFIG)
 157     errs = []
 158     all_configs = validation.GetAllConfigs(configs['builder_groups'])
 159     config_configs = configs['configs']
 160     mixins = configs['mixins']
 161
 162     validation.CheckAllConfigsAndMixinsReferenced(errs, all_configs,
 163                                                   config_configs, mixins)
 164
 165     self.assertEqual(errs, [])
 166
 167   def test_CheckAllConfigsAndMixinsReferenced_unreferenced(self):
 168     configs = ast.literal_eval(TEST_UNREFERENCED_MIXIN_CONFIG)
 169     errs = []
 170     all_configs = validation.GetAllConfigs(configs['builder_groups'])
 171     config_configs = configs['configs']
 172     mixins = configs['mixins']
 173
 174     validation.CheckAllConfigsAndMixinsReferenced(errs, all_configs,
 175                                                   config_configs, mixins)
 176
 177     self.assertIn('Unreferenced mixin "unreferenced_mixin".', errs)
 178
 179   def test_CheckAllConfigsAndMixinsReferenced_unknown(self):
 180     configs = ast.literal_eval(TEST_UNKNOWNMIXIN_CONFIG)
 181     errs = []
 182     all_configs = validation.GetAllConfigs(configs['builder_groups'])
 183     config_configs = configs['configs']
 184     mixins = configs['mixins']
 185
 186     validation.CheckAllConfigsAndMixinsReferenced(errs, all_configs,
 187                                                   config_configs, mixins)
 188     self.assertIn(
 189         'Unknown mixin "unknown_mixin" '
 190         'referenced by config "rel_bot_2".', errs)
 191
 192   def test_CheckAllConfigsAndMixinsReferenced_unknown_nested(self):
 193     configs = ast.literal_eval(TEST_UNKNOWN_NESTED_MIXIN_CONFIG)
 194     errs = []
 195     all_configs = validation.GetAllConfigs(configs['builder_groups'])
 196     config_configs = configs['configs']
 197     mixins = configs['mixins']
 198
 199     validation.CheckAllConfigsAndMixinsReferenced(errs, all_configs,
 200                                                   config_configs, mixins)
 201
 202     self.assertIn(
 203         'Unknown mixin "unknown_mixin" '
 204         'referenced by mixin "nested_mixin".', errs)
 205
 206   def test_CheckAllConfigsAndMixinsReferenced_unused(self):
 207     configs = ast.literal_eval(TEST_UNKNOWN_NESTED_MIXIN_CONFIG)
 208     errs = []
 209     all_configs = validation.GetAllConfigs(configs['builder_groups'])
 210     config_configs = configs['configs']
 211     mixins = configs['mixins']
 212
 213     validation.CheckAllConfigsAndMixinsReferenced(errs, all_configs,
 214                                                   config_configs, mixins)
 215
 216     self.assertIn(
 217         'Unknown mixin "unknown_mixin" '
 218         'referenced by mixin "nested_mixin".', errs)
 219
 220   def test_EnsureNoProprietaryMixins(self):
 221     bad_configs = ast.literal_eval(mb_unittest.TEST_BAD_CONFIG)
 222     errs = []
 223     builder_groups = bad_configs['builder_groups']
 224     mixins = bad_configs['mixins']
 225     config_configs = bad_configs['configs']
 226
 227     validation.EnsureNoProprietaryMixins(errs, builder_groups, config_configs,
 228                                          mixins)
 229
 230     self.assertIn(
 231         'Public artifact builder "a" '
 232         'can not contain the "chrome_with_codecs" mixin.', errs)
 233     self.assertIn(
 234         'Public artifact builder "b" '
 235         'can not contain the "chrome_with_codecs" mixin.', errs)
 236     self.assertEqual(len(errs), 2)
 237
 238   def test_CheckDuplicateConfigs_ok(self):
 239     configs = ast.literal_eval(mb_unittest.TEST_CONFIG)
 240     config_configs = configs['configs']
 241     mixins = configs['mixins']
 242     grouping = configs['builder_groups']
 243     errs = []
 244
 245     validation.CheckDuplicateConfigs(errs, config_configs, mixins, grouping,
 246                                      mb.FlattenConfig)
 247     self.assertEqual(errs, [])
 248
 249   @unittest.skip('bla')
 250   def test_CheckDuplicateConfigs_dups(self):
 251     configs = ast.literal_eval(mb_unittest.TEST_DUP_CONFIG)
 252     config_configs = configs['configs']
 253     mixins = configs['mixins']
 254     grouping = configs['builder_groups']
 255     errs = []
 256
 257     validation.CheckDuplicateConfigs(errs, config_configs, mixins, grouping,
 258                                      mb.FlattenConfig)
 259     self.assertIn(
 260         'Duplicate configs detected. When evaluated fully, the '
 261         'following configs are all equivalent: \'some_config\', '
 262         '\'some_other_config\'. Please consolidate these configs '
 263         'into only one unique name per configuration value.', errs)
 264
 265   def test_CheckKeyOrderingOK(self):
 266     mb_config = ast.literal_eval(mb_unittest.TEST_CONFIG)
 267     errs = []
 268     validation.CheckKeyOrdering(errs, mb_config['builder_groups'],
 269                                 mb_config['configs'], mb_config['mixins'])
 270     self.assertEqual(errs, [])
 271
 272   def test_CheckKeyOrderingBad(self):
 273     mb_config = ast.literal_eval(TEST_CONFIG_UNSORTED_GROUPS)
 274     errs = []
 275     validation.CheckKeyOrdering(errs, mb_config['builder_groups'],
 276                                 mb_config['configs'], mb_config['mixins'])
 277     self.assertIn('\nThe keys in "builder_groups" are not sorted:', errs)
 278
 279     mb_config = ast.literal_eval(TEST_CONFIG_UNSORTED_BUILDERNAMES)
 280     errs = []
 281     validation.CheckKeyOrdering(errs, mb_config['builder_groups'],
 282                                 mb_config['configs'], mb_config['mixins'])
 283     self.assertIn('\nThe builders in group "group" are not sorted:', errs)
 284
 285     mb_config = ast.literal_eval(TEST_CONFIG_UNSORTED_CONFIGS)
 286     errs = []
 287     validation.CheckKeyOrdering(errs, mb_config['builder_groups'],
 288                                 mb_config['configs'], mb_config['mixins'])
 289     self.assertIn('\nThe config names are not sorted:', errs)
 290
 291     mb_config = ast.literal_eval(TEST_CONFIG_UNSORTED_MIXINS)
 292     errs = []
 293     validation.CheckKeyOrdering(errs, mb_config['builder_groups'],
 294                                 mb_config['configs'], mb_config['mixins'])
 295     self.assertIn('\nThe mixin names are not sorted:', errs)
 296
 297
 298 if __name__ == '__main__':
 299   unittest.main()