src/third_party/chromite/cbuildbot/metadata_lib_unittest.py

   1 #!/usr/bin/python
   2 # Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 """Test the archive_lib module."""
   7
   8 from __future__ import print_function
   9
  10 import logging
  11 import multiprocessing
  12 import os
  13 import sys
  14
  15 sys.path.insert(0, os.path.abspath('%s/../..' % os.path.dirname(__file__)))
  16 from chromite.cbuildbot import metadata_lib
  17 from chromite.lib import cros_test_lib
  18 from chromite.lib import parallel
  19
  20
  21 @cros_test_lib.NetworkTest()
  22 class MetadataFetchTest(cros_test_lib.TestCase):
  23   """Test functions for fetching metadata from GS."""
  24
  25   def testPaladinBuilder(self):
  26     bot, version = ('x86-mario-paladin', '5611.0.0')
  27     full_version = metadata_lib.FindLatestFullVersion(bot, version)
  28     self.assertEqual(full_version, 'R35-5611.0.0-rc2')
  29     metadata = metadata_lib.GetBuildMetadata(bot, full_version)
  30     metadata_dict = metadata._metadata_dict # pylint: disable=W0212
  31     self.assertEqual(metadata_dict['status']['status'], 'passed')
  32
  33
  34 class MetadataTest(cros_test_lib.TestCase):
  35   """Tests the correctness of various metadata methods."""
  36
  37   def testGetDict(self):
  38     starting_dict = {'key1': 1,
  39                      'key2': '2',
  40                      'cl_actions': [('a', 1), ('b', 2)],
  41                      'board-metadata': {
  42                          'board-1': {'info': 432}
  43                          }
  44                      }
  45     metadata = metadata_lib.CBuildbotMetadata(starting_dict)
  46     ending_dict = metadata.GetDict()
  47     self.assertEqual(starting_dict, ending_dict)
  48
  49   def testUpdateKeyDictWithDict(self):
  50     expected_dict = {str(x): x for x in range(20)}
  51     m = multiprocessing.Manager()
  52     metadata = metadata_lib.CBuildbotMetadata(multiprocess_manager=m)
  53
  54     metadata.UpdateKeyDictWithDict('my_dict', expected_dict)
  55
  56     self.assertEqual(expected_dict, metadata.GetDict()['my_dict'])
  57
  58
  59   def testUpdateKeyDictWithDictMultiprocess(self):
  60     expected_dict = {str(x): x for x in range(20)}
  61     m = multiprocessing.Manager()
  62     metadata = metadata_lib.CBuildbotMetadata(multiprocess_manager=m)
  63
  64     with parallel.BackgroundTaskRunner(metadata.UpdateKeyDictWithDict) as q:
  65       for k, v in expected_dict.iteritems():
  66         q.put(['my_dict', {k: v}])
  67
  68     self.assertEqual(expected_dict, metadata.GetDict()['my_dict'])
  69
  70
  71   def testUpdateBoardMetadataWithEmptyDict(self):
  72     metadata = metadata_lib.CBuildbotMetadata()
  73     metadata.UpdateBoardDictWithDict('someboard', {})
  74     self.assertEqual(metadata.GetDict()['board-metadata']['someboard'], {})
  75
  76
  77   def testUpdateBoardMetadataWithMultiprocessDict(self):
  78     starting_dict = {'key1': 1,
  79                      'key2': '2',
  80                      'cl_actions': [('a', 1), ('b', 2)],
  81                      'board-metadata': {
  82                          'board-1': {'info': 432}
  83                          }
  84                      }
  85
  86     m = multiprocessing.Manager()
  87     metadata = metadata_lib.CBuildbotMetadata(metadata_dict=starting_dict,
  88                                               multiprocess_manager=m)
  89
  90     # pylint: disable-msg=E1101
  91     update_dict = m.dict()
  92     update_dict['my_key'] = 'some value'
  93     metadata.UpdateBoardDictWithDict('board-1', update_dict)
  94
  95     self.assertEqual(metadata.GetDict()['board-metadata']['board-1']['my_key'],
  96                      'some value')
  97
  98   def testMultiprocessSafety(self):
  99     m = multiprocessing.Manager()
 100     metadata = metadata_lib.CBuildbotMetadata(multiprocess_manager=m)
 101     key_dict = {'key1': 1, 'key2': 2}
 102     starting_dict = {'key1': 1,
 103                      'key2': '2',
 104                      'key3': key_dict,
 105                      'cl_actions': [('a', 1), ('b', 2)],
 106                      'board-metadata': {
 107                          'board-1': {'info': 432}
 108                          }
 109                     }
 110
 111     # Test that UpdateWithDict is process-safe
 112     parallel.RunParallelSteps([lambda: metadata.UpdateWithDict(starting_dict)])
 113     ending_dict = metadata.GetDict()
 114     self.assertEqual(starting_dict, ending_dict)
 115
 116     # Test that UpdateKeyDictWithDict is process-safe
 117     parallel.RunParallelSteps([lambda: metadata.UpdateKeyDictWithDict(
 118         'key3', key_dict)])
 119     ending_dict = metadata.GetDict()
 120     self.assertEqual(starting_dict, ending_dict)
 121
 122     # Test that RecordCLAction is process-safe
 123     fake_change = metadata_lib.GerritPatchTuple(12345, 1, False)
 124     fake_action = ('asdf,')
 125     parallel.RunParallelSteps([lambda: metadata.RecordCLAction(fake_change,
 126                                                                fake_action)])
 127     ending_dict = metadata.GetDict()
 128     # Assert that an action was recorded.
 129     self.assertEqual(len(starting_dict['cl_actions']) + 1,
 130                      len(ending_dict['cl_actions']))
 131
 132   def testPerBoardDict(self):
 133     starting_per_board_dict = {
 134         'board-1': {'kubrick': 2001,
 135                     'bergman': 'persona',
 136                     'hitchcock': 'vertigo'},
 137         'board-2': {'kubrick': ['barry lyndon', 'dr. strangelove'],
 138                     'bergman': 'the seventh seal'}
 139     }
 140
 141     starting_dict = {'board-metadata': starting_per_board_dict}
 142
 143     m = multiprocessing.Manager()
 144     metadata = metadata_lib.CBuildbotMetadata(metadata_dict=starting_dict,
 145                                               multiprocess_manager=m)
 146
 147     extra_per_board_dict = {
 148         'board-1': {'kurosawa': 'rashomon',
 149                     'coen brothers': 'fargo'},
 150         'board-3': {'hitchcock': 'north by northwest',
 151                     'coen brothers': 'the big lebowski'}
 152     }
 153
 154     expected_dict = starting_per_board_dict
 155
 156     # Write each per board key-value pair to metadata in a separate process.
 157     with parallel.BackgroundTaskRunner(metadata.UpdateBoardDictWithDict) as q:
 158       for board, board_dict in extra_per_board_dict.iteritems():
 159         expected_dict.setdefault(board, {}).update(board_dict)
 160         for k, v in board_dict.iteritems():
 161           q.put([board, {k: v}])
 162
 163     self.assertEqual(expected_dict, metadata.GetDict()['board-metadata'])
 164
 165
 166 if __name__ == '__main__':
 167   cros_test_lib.main(level=logging.DEBUG)