| #!/usr/bin/python2 |
| |
| # Copyright (c) 2013 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Unit tests for xbuddy.py.""" |
| |
| from __future__ import print_function |
| |
| import ConfigParser |
| import os |
| import shutil |
| import tempfile |
| import time |
| import unittest |
| |
| import mox |
| |
| import gsutil_util |
| import xbuddy |
| |
| #pylint: disable=W0212 |
| |
| GS_ALTERNATE_DIR = 'gs://chromeos-alternate-archive/' |
| |
| |
| class xBuddyTest(mox.MoxTestBase): |
| """Regression tests for xbuddy.""" |
| def setUp(self): |
| mox.MoxTestBase.setUp(self) |
| |
| self.static_image_dir = tempfile.mkdtemp('xbuddy_unittest_static') |
| |
| self.mock_xb = xbuddy.XBuddy( |
| True, |
| static_dir=self.static_image_dir |
| ) |
| self.images_dir = tempfile.mkdtemp('xbuddy_unittest_images') |
| self.mock_xb.images_dir = self.images_dir |
| |
| def tearDown(self): |
| """Removes testing files.""" |
| shutil.rmtree(self.static_image_dir) |
| shutil.rmtree(self.images_dir) |
| |
| def testParseBoolean(self): |
| """Check that some common True/False strings are handled.""" |
| self.assertEqual(xbuddy.XBuddy.ParseBoolean(None), False) |
| self.assertEqual(xbuddy.XBuddy.ParseBoolean('false'), False) |
| self.assertEqual(xbuddy.XBuddy.ParseBoolean('bs'), False) |
| self.assertEqual(xbuddy.XBuddy.ParseBoolean('true'), True) |
| self.assertEqual(xbuddy.XBuddy.ParseBoolean('y'), True) |
| |
| def testLookupOfficial(self): |
| """Basic test of _LookupOfficial. Checks that a given suffix is handled.""" |
| self.mox.StubOutWithMock(gsutil_util, 'GSUtilRun') |
| gsutil_util.GSUtilRun(mox.IgnoreArg(), |
| mox.IgnoreArg()).AndReturn('v') |
| expected = 'b-s/v' |
| self.mox.ReplayAll() |
| self.assertEqual(self.mock_xb._LookupOfficial('b', suffix='-s'), expected) |
| self.mox.VerifyAll() |
| |
| def testLookupChannel(self): |
| """Basic test of _LookupChannel. Checks that a given suffix is handled.""" |
| self.mox.StubOutWithMock(gsutil_util, 'GetLatestVersionFromGSDir') |
| mock_data1 = '4100.68.0' |
| gsutil_util.GetLatestVersionFromGSDir( |
| mox.IgnoreArg(), with_release=False).AndReturn(mock_data1) |
| mock_data2 = 'R28-4100.68.0' |
| gsutil_util.GetLatestVersionFromGSDir(mox.IgnoreArg()).AndReturn(mock_data2) |
| self.mox.ReplayAll() |
| expected = 'b-release/R28-4100.68.0' |
| self.assertEqual(self.mock_xb._LookupChannel('b', '-release'), |
| expected) |
| self.mox.VerifyAll() |
| |
| def testLookupAliasPathRewrite(self): |
| """Tests LookupAlias of path rewrite, including keyword substitution.""" |
| alias = 'foobar' |
| path = 'remote/BOARD/VERSION/test' |
| self.mox.StubOutWithMock(self.mock_xb.config, 'get') |
| self.mock_xb.config.get('LOCATION_SUFFIXES', alias).AndRaise( |
| ConfigParser.Error()) |
| self.mock_xb.config.get('PATH_REWRITES', alias).AndReturn(path) |
| self.mox.ReplayAll() |
| self.assertEqual(('remote/parrot/1.2.3/test', '-release'), |
| self.mock_xb.LookupAlias(alias, board='parrot', |
| version='1.2.3')) |
| |
| def testLookupAliasSuffix(self): |
| """Tests LookupAlias of location suffix.""" |
| alias = 'foobar' |
| suffix = '-random' |
| self.mox.StubOutWithMock(self.mock_xb.config, 'get') |
| self.mock_xb.config.get('LOCATION_SUFFIXES', alias).AndReturn(suffix) |
| self.mock_xb.config.get('PATH_REWRITES', alias).AndRaise( |
| ConfigParser.Error()) |
| self.mox.ReplayAll() |
| self.assertEqual((alias, suffix), |
| self.mock_xb.LookupAlias(alias, board='parrot', |
| version='1.2.3')) |
| |
| def testLookupAliasPathRewriteAndSuffix(self): |
| """Tests LookupAlias with both path rewrite and suffix.""" |
| alias = 'foobar' |
| path = 'remote/BOARD/VERSION/test' |
| suffix = '-random' |
| self.mox.StubOutWithMock(self.mock_xb.config, 'get') |
| self.mock_xb.config.get('LOCATION_SUFFIXES', alias).AndReturn(suffix) |
| self.mock_xb.config.get('PATH_REWRITES', alias).AndReturn(path) |
| self.mox.ReplayAll() |
| self.assertEqual(('remote/parrot/1.2.3/test', suffix), |
| self.mock_xb.LookupAlias(alias, board='parrot', |
| version='1.2.3')) |
| |
| def testResolveVersionToBuildId_Official(self): |
| """Check _ResolveVersionToBuildId recognizes aliases for official builds.""" |
| board = 'b' |
| suffix = '-s' |
| |
| # aliases that should be redirected to LookupOfficial |
| |
| self.mox.StubOutWithMock(self.mock_xb, '_LookupOfficial') |
| self.mock_xb._LookupOfficial(board, suffix, image_dir=None) |
| self.mock_xb._LookupOfficial(board, suffix, |
| image_dir=GS_ALTERNATE_DIR) |
| self.mock_xb._LookupOfficial(board, 'paladin', image_dir=None) |
| self.mock_xb._LookupOfficial(board, 'paladin', |
| image_dir=GS_ALTERNATE_DIR) |
| |
| self.mox.ReplayAll() |
| version = 'latest-official' |
| self.mock_xb._ResolveVersionToBuildId(board, suffix, version) |
| self.mock_xb._ResolveVersionToBuildId(board, suffix, version, |
| image_dir=GS_ALTERNATE_DIR) |
| version = 'latest-official-paladin' |
| self.mock_xb._ResolveVersionToBuildId(board, suffix, version) |
| self.mock_xb._ResolveVersionToBuildId(board, suffix, version, |
| image_dir=GS_ALTERNATE_DIR) |
| self.mox.VerifyAll() |
| |
| def testResolveVersionToBuildId_Channel(self): |
| """Check _ResolveVersionToBuildId recognizes aliases for channels.""" |
| board = 'b' |
| suffix = '-s' |
| |
| # aliases that should be redirected to LookupChannel |
| self.mox.StubOutWithMock(self.mock_xb, '_LookupChannel') |
| self.mock_xb._LookupChannel(board, suffix, image_dir=None) |
| self.mock_xb._LookupChannel(board, suffix, image_dir=GS_ALTERNATE_DIR) |
| self.mock_xb._LookupChannel(board, suffix, channel='dev', image_dir=None) |
| self.mock_xb._LookupChannel(board, suffix, channel='dev', |
| image_dir=GS_ALTERNATE_DIR) |
| |
| self.mox.ReplayAll() |
| version = 'latest' |
| self.mock_xb._ResolveVersionToBuildId(board, suffix, version) |
| self.mock_xb._ResolveVersionToBuildId(board, suffix, version, |
| image_dir=GS_ALTERNATE_DIR) |
| version = 'latest-dev' |
| self.mock_xb._ResolveVersionToBuildId(board, suffix, version) |
| self.mock_xb._ResolveVersionToBuildId(board, suffix, version, |
| image_dir=GS_ALTERNATE_DIR) |
| self.mox.VerifyAll() |
| |
| def testResolveVersionToBuildId_BaseVersion(self): |
| """Check _ResolveVersionToBuildId handles a base version.""" |
| board = 'b' |
| suffix = '-s' |
| |
| self.mox.StubOutWithMock(self.mock_xb, '_ResolveBuildVersion') |
| self.mock_xb._ResolveBuildVersion(board, suffix, '1.2.3').AndReturn( |
| 'R12-1.2.3') |
| self.mox.StubOutWithMock(self.mock_xb, '_RemoteBuildId') |
| self.mock_xb._RemoteBuildId(board, suffix, 'R12-1.2.3') |
| self.mox.ReplayAll() |
| |
| self.mock_xb._ResolveVersionToBuildId(board, suffix, '1.2.3') |
| self.mox.VerifyAll() |
| |
| def testBasicInterpretPath(self): |
| """Basic checks for splitting a path""" |
| path = 'parrot/R27-2455.0.0/test' |
| expected = ('test', 'parrot', 'R27-2455.0.0', True) |
| self.assertEqual(self.mock_xb._InterpretPath(path=path), expected) |
| |
| path = 'parrot/R27-2455.0.0/full_payload' |
| expected = ('full_payload', 'parrot', 'R27-2455.0.0', True) |
| self.assertEqual(self.mock_xb._InterpretPath(path=path), expected) |
| |
| path = 'parrot/R27-2455.0.0' |
| expected = ('ANY', 'parrot', 'R27-2455.0.0', True) |
| self.assertEqual(self.mock_xb._InterpretPath(path=path), expected) |
| |
| path = 'remote/parrot/R27-2455.0.0' |
| expected = ('test', 'parrot', 'R27-2455.0.0', False) |
| self.assertEqual(self.mock_xb._InterpretPath(path=path), expected) |
| |
| path = 'local/parrot/R27-2455.0.0' |
| expected = ('ANY', 'parrot', 'R27-2455.0.0', True) |
| self.assertEqual(self.mock_xb._InterpretPath(path=path), expected) |
| |
| path = '' |
| expected = ('ANY', None, 'latest', True) |
| self.assertEqual(self.mock_xb._InterpretPath(path=path), expected) |
| |
| path = 'local' |
| expected = ('ANY', None, 'latest', True) |
| self.assertEqual(self.mock_xb._InterpretPath(path=path), expected) |
| |
| path = 'local/parrot/latest/ANY' |
| expected = ('ANY', 'parrot', 'latest', True) |
| self.assertEqual(self.mock_xb._InterpretPath(path=path), expected) |
| |
| def testInterpretPathWithDefaults(self): |
| """Test path splitting with default board/version.""" |
| path = '' |
| expected = ('ANY', 'parrot', 'latest', True) |
| self.assertEqual(expected, self.mock_xb._InterpretPath( |
| path=path, default_board='parrot')) |
| |
| path = '' |
| expected = ('ANY', None, '1.2.3', True) |
| self.assertEqual(expected, self.mock_xb._InterpretPath( |
| path=path, default_version='1.2.3')) |
| |
| path = '' |
| expected = ('ANY', 'parrot', '1.2.3', True) |
| self.assertEqual(expected, self.mock_xb._InterpretPath( |
| path=path, default_board='parrot', default_version='1.2.3')) |
| |
| path = '1.2.3' |
| expected = ('ANY', None, '1.2.3', True) |
| self.assertEqual(expected, self.mock_xb._InterpretPath( |
| path=path, default_version='1.2.3')) |
| |
| path = 'latest' |
| expected = ('ANY', None, 'latest', True) |
| self.assertEqual(expected, self.mock_xb._InterpretPath( |
| path=path, default_version='1.2.3')) |
| |
| path = '1.2.3' |
| expected = ('ANY', 'parrot', '1.2.3', True) |
| self.assertEqual(expected, self.mock_xb._InterpretPath( |
| path=path, default_board='parrot', default_version='1.2.3')) |
| |
| path = 'parrot' |
| expected = ('ANY', 'parrot', '1.2.3', True) |
| self.assertEqual(expected, self.mock_xb._InterpretPath( |
| path=path, default_version='1.2.3')) |
| |
| def testTimestampsAndList(self): |
| """Creation and listing of builds according to their timestamps.""" |
| # make 3 different timestamp files |
| b_id11 = 'b1/v1' |
| b_id12 = 'b1/v2' |
| b_id23 = 'b2/v3' |
| xbuddy.Timestamp.UpdateTimestamp(self.mock_xb._timestamp_folder, b_id11) |
| time.sleep(0.05) |
| xbuddy.Timestamp.UpdateTimestamp(self.mock_xb._timestamp_folder, b_id12) |
| time.sleep(0.05) |
| xbuddy.Timestamp.UpdateTimestamp(self.mock_xb._timestamp_folder, b_id23) |
| |
| # reference second one again |
| time.sleep(0.05) |
| xbuddy.Timestamp.UpdateTimestamp(self.mock_xb._timestamp_folder, b_id12) |
| |
| # check that list returns the same 3 things, in last referenced order |
| result = self.mock_xb._ListBuildTimes() |
| self.assertEqual(result[0][0], b_id12) |
| self.assertEqual(result[1][0], b_id23) |
| self.assertEqual(result[2][0], b_id11) |
| |
| def testSyncRegistry(self): |
| # check that there are no builds initially |
| result = self.mock_xb._ListBuildTimes() |
| self.assertEqual(len(result), 0) |
| |
| # set up the dummy build/images directory with images |
| boards = ['a', 'b'] |
| versions = ['v1', 'v2'] |
| for b in boards: |
| os.makedirs(os.path.join(self.mock_xb.images_dir, b)) |
| for v in versions: |
| os.makedirs(os.path.join(self.mock_xb.images_dir, b, v)) |
| |
| # Sync and check that they've been added to xBuddy's registry |
| self.mock_xb._SyncRegistryWithBuildImages() |
| result = self.mock_xb._ListBuildTimes() |
| self.assertEqual(len(result), 4) |
| |
| ############### Public Methods |
| def testXBuddyCaching(self): |
| """Caching & replacement of timestamp files.""" |
| path_a = ('remote', 'a', 'R0', 'test') |
| path_b = ('remote', 'b', 'R0', 'test') |
| self.mox.StubOutWithMock(gsutil_util, 'GSUtilRun') |
| self.mox.StubOutWithMock(self.mock_xb, '_Download') |
| self.mox.StubOutWithMock(self.mock_xb, '_Download') |
| for _ in range(8): |
| self.mock_xb._Download(mox.IsA(str), mox.In(mox.IsA(str))) |
| |
| # All non-release urls are invalid so we can meet expectations. |
| gsutil_util.GSUtilRun(mox.Not(mox.StrContains('-release')), |
| None).MultipleTimes().AndRaise( |
| gsutil_util.GSUtilError('bad url')) |
| gsutil_util.GSUtilRun(mox.StrContains('-release'), None).MultipleTimes() |
| |
| self.mox.ReplayAll() |
| |
| # requires default capacity |
| self.assertEqual(self.mock_xb.Capacity(), '5') |
| |
| # Get 6 different images: a,b,c,d,e,f |
| images = ['a', 'b', 'c', 'd', 'e', 'f'] |
| for c in images: |
| self.mock_xb.Get(('remote', c, 'R0', 'test')) |
| time.sleep(0.05) |
| |
| # check that b,c,d,e,f are still stored |
| result = self.mock_xb._ListBuildTimes() |
| self.assertEqual(len(result), 5) |
| |
| # Flip the list to get reverse chronological order |
| images.reverse() |
| for i in range(5): |
| self.assertEqual(result[i][0], '%s-release/R0' % images[i]) |
| |
| # Get b,a |
| self.mock_xb.Get(path_b) |
| time.sleep(0.05) |
| self.mock_xb.Get(path_a) |
| time.sleep(0.05) |
| |
| # check that d,e,f,b,a are still stored |
| result = self.mock_xb._ListBuildTimes() |
| self.assertEqual(len(result), 5) |
| images_expected = ['a', 'b', 'f', 'e', 'd'] |
| for i in range(5): |
| self.assertEqual(result[i][0], '%s-release/R0' % images_expected[i]) |
| |
| self.mox.VerifyAll() |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
