[NaCl SDK] Add bionic SDK bundle auto-updating to update_nacl_manifest

native_client_sdk/src/build_tools/tests/update_nacl_manifest_test.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import copy
 import datetime
 import hashlib
 import logging
 import os
 import posixpath
 import subprocess
 import sys
 import tempfile
 import unittest
 import urlparse
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 BUILD_TOOLS_DIR = os.path.dirname(SCRIPT_DIR)
 
 sys.path.append(BUILD_TOOLS_DIR)
 import manifest_util
 import update_nacl_manifest
-from update_nacl_manifest import CANARY_BUNDLE_NAME
+from update_nacl_manifest import CANARY_BUNDLE_NAME, BIONIC_CANARY_BUNDLE_NAME
 
 
 HTTPS_BASE_URL = 'https://storage.googleapis.com' \
     '/nativeclient_mirror/nacl/nacl_sdk/'
 
 OS_CR = ('cros',)
+OS_L = ('linux',)
 OS_M = ('mac',)
 OS_ML = ('mac', 'linux')
 OS_MW = ('mac', 'win')
 OS_LW = ('linux', 'win')
 OS_MLW = ('mac', 'linux', 'win')
 OS_ALL = ('all',)
 POST_STABLE = 'post_stable'
 STABLE = 'stable'
 BETA = 'beta'
 DEV = 'dev'
 CANARY = 'canary'
 
 
 def GetArchiveURL(basename, version):
   return urlparse.urljoin(HTTPS_BASE_URL, posixpath.join(version, basename))
 
 
 def GetPlatformArchiveUrl(host_os, version):
   basename = 'naclsdk_%s.tar.bz2' % (host_os,)
   return GetArchiveURL(basename, version)
 
 
+def GetBionicArchiveUrl(version):
+  basename = 'naclsdk_bionic.tar.bz2'
+  return GetArchiveURL(basename, version)
+
+
 def MakeGsUrl(rel_path):
   return update_nacl_manifest.GS_BUCKET_PATH + rel_path
 
 
 def GetPathFromGsUrl(url):
   assert url.startswith(update_nacl_manifest.GS_BUCKET_PATH)
   return url[len(update_nacl_manifest.GS_BUCKET_PATH):]
 
 
 def GetPathFromHttpsUrl(url):
   assert url.startswith(HTTPS_BASE_URL)
   return url[len(HTTPS_BASE_URL):]
 
 
 def MakeArchive(url, host_os):
   archive = manifest_util.Archive(host_os)
   archive.url = url
   # dummy values that won't succeed if we ever use them, but will pass
   # validation. :)
   archive.checksum = {'sha1': 'foobar'}
   archive.size = 1
   return archive
 
 
 def MakePlatformArchive(host_os, version):
   return MakeArchive(GetPlatformArchiveUrl(host_os, version), host_os)
 
 
+def MakeBionicArchive(host_os, version):
+  return MakeArchive(GetBionicArchiveUrl(version), host_os)
+
+
 def MakeNonPlatformArchive(basename, version):
   return MakeArchive(GetArchiveURL(basename, version), 'all')
 
 
 def MakeNonPepperBundle(name, with_archives=False):
   bundle = manifest_util.Bundle(name)
   bundle.version = 1
   bundle.revision = 1
   bundle.description = 'Dummy bundle'
   bundle.recommended = 'yes'
   bundle.stability = 'stable'
 
   if with_archives:
     for host_os in OS_MLW:
       archive = manifest_util.Archive(host_os)
       archive.url = 'http://example.com'
       archive.checksum = {'sha1': 'blah'}
       archive.size = 2
       bundle.AddArchive(archive)
   return bundle
 
 
-def MakePepperBundle(major_version, revision=0, version=None, stability='dev'):
+def MakePepperBundle(major_version, revision=0, version=None, stability='dev',
+                     bundle_name=None):
   assert (version is None or
           version.split('.')[0] == 'trunk' or
           version.split('.')[0] == str(major_version))
-  if stability == CANARY:
-    bundle_name = CANARY_BUNDLE_NAME
-  else:
+  if not bundle_name:
     bundle_name = 'pepper_' + str(major_version)
 
   bundle = manifest_util.Bundle(bundle_name)
   bundle.version = major_version
   bundle.revision = revision
   bundle.description = 'Chrome %s bundle, revision %s' % (major_version,
-      revision)
+                                                          revision)
   bundle.repath = 'pepper_' + str(major_version)
   bundle.recommended = 'no'
   bundle.stability = stability
 
   return bundle
 
 
 def MakePlatformBundle(major_version, revision=0, version=None, host_oses=None,
-    stability='dev'):
+                       stability='dev'):
   bundle = MakePepperBundle(major_version, revision, version, stability)
 
   if host_oses:
     for host_os in host_oses:
       bundle.AddArchive(MakePlatformArchive(host_os, version))
 
   return bundle
 
 
+def MakeBionicBundle(major_version, revision=0, version=None, host_oses=None):
+  bundle = MakePepperBundle(major_version, revision, version, 'dev')
+
+  if host_oses:
+    for host_os in host_oses:
+      bundle.AddArchive(MakeBionicArchive(host_os, version))
+
+  return bundle
+
+
 class MakeManifest(manifest_util.SDKManifest):
   def __init__(self, *args):
     manifest_util.SDKManifest.__init__(self)
 
     for bundle in args:
       self.AddBundle(bundle)
 
   def AddBundle(self, bundle):
     self.MergeBundle(bundle, allow_existing=False)
 
@@ skipping 88 matching lines @@
 # Shorthand for premade bundles/versions
 V18_0_1025_163 = '18.0.1025.163'
 V18_0_1025_175 = '18.0.1025.175'
 V18_0_1025_184 = '18.0.1025.184'
 V19_0_1084_41 = '19.0.1084.41'
 V19_0_1084_67 = '19.0.1084.67'
 V21_0_1145_0 = '21.0.1145.0'
 V21_0_1166_0 = '21.0.1166.0'
 V26_0_1386_0 = '26.0.1386.0'
 V26_0_1386_1 = '26.0.1386.1'
+V37_0_2054_0 = '37.0.2054.0'
 VTRUNK_140819 = 'trunk.140819'
+VTRUNK_277776 = 'trunk.277776'
 B18_0_1025_163_MLW = MakePlatformBundle(18, 132135, V18_0_1025_163, OS_MLW)
 B18_0_1025_184_MLW = MakePlatformBundle(18, 134900, V18_0_1025_184, OS_MLW)
 B18_NONE = MakePlatformBundle(18)
 B19_0_1084_41_MLW = MakePlatformBundle(19, 134854, V19_0_1084_41, OS_MLW)
 B19_0_1084_67_MLW = MakePlatformBundle(19, 142000, V19_0_1084_67, OS_MLW)
 B19_NONE = MakePlatformBundle(19)
-BCANARY_NONE = MakePlatformBundle(0, stability=CANARY)
+BCANARY_NONE = MakePepperBundle(0, stability=CANARY,
+                                bundle_name=CANARY_BUNDLE_NAME)
 B21_0_1145_0_MLW = MakePlatformBundle(21, 138079, V21_0_1145_0, OS_MLW)
 B21_0_1166_0_MW = MakePlatformBundle(21, 140819, V21_0_1166_0, OS_MW)
 B26_NONE = MakePlatformBundle(26)
 B26_0_1386_0_MLW = MakePlatformBundle(26, 177362, V26_0_1386_0, OS_MLW)
 B26_0_1386_1_MLW = MakePlatformBundle(26, 177439, V26_0_1386_1, OS_MLW)
 BTRUNK_140819_MLW = MakePlatformBundle(21, 140819, VTRUNK_140819, OS_MLW)
+BBIONIC_NONE = MakePepperBundle(0, stability=CANARY,
+                                bundle_name=BIONIC_CANARY_BUNDLE_NAME)
+BBIONIC_TRUNK_277776 = MakeBionicBundle(37, 277776, VTRUNK_277776, OS_L)
 NON_PEPPER_BUNDLE_NOARCHIVES = MakeNonPepperBundle('foo')
 NON_PEPPER_BUNDLE_ARCHIVES = MakeNonPepperBundle('bar', with_archives=True)
 
 
 class TestUpdateManifest(unittest.TestCase):
   def setUp(self):
     self.history = MakeHistory()
     self.files = MakeFiles()
     self.version_mapping = {}
     self.delegate = None
     self.uploaded_manifest = None
     self.manifest = None
     # Ignore logging warnings, etc.
-    logging.getLogger('update_nacl_manifest').setLevel(logging.CRITICAL)
+    logging.getLogger('update_nacl_manifest').setLevel(logging.INFO)
 
   def _MakeDelegate(self):
     self.delegate = TestDelegate(self.manifest, self.history.history,
         self.files, self.version_mapping)
 
   def _Run(self, host_oses, extra_archives=None, fixed_bundle_versions=None):
     update_nacl_manifest.Run(self.delegate, host_oses, extra_archives,
                              fixed_bundle_versions)
 
   def _HasUploadedManifest(self):
     return 'naclsdk_manifest2.json' in self.files
 
   def _ReadUploadedManifest(self):
     self.uploaded_manifest = manifest_util.SDKManifest()
     self.uploaded_manifest.LoadDataFromString(
         self.files['naclsdk_manifest2.json'])
 
-  def _AssertUploadedManifestHasBundle(self, bundle, stability):
-    if stability == CANARY:
-      bundle_name = CANARY_BUNDLE_NAME
-    else:
+  def _AssertUploadedManifestHasBundle(self, bundle, stability,
+                                       bundle_name=None):
+    if not bundle_name:
       bundle_name = bundle.name
 
     uploaded_manifest_bundle = self.uploaded_manifest.GetBundle(bundle_name)
     # Bundles that we create in the test (and in the manifest snippets) have
     # their stability set to "dev". update_nacl_manifest correctly updates it.
     # So we have to force the stability of |bundle| so they compare equal.
     test_bundle = copy.copy(bundle)
     test_bundle.stability = stability
-    if stability == CANARY:
-      test_bundle.name = CANARY_BUNDLE_NAME
+    if bundle_name:
+      test_bundle.name = bundle_name
     self.assertEqual(uploaded_manifest_bundle, test_bundle)
 
   def _AddCsvHistory(self, history):
     import csv
     import cStringIO
     history_stream = cStringIO.StringIO(history)
     self.history.history = [(platform, channel, version, date)
         for platform, channel, version, date in csv.reader(history_stream)]
 
   def testNoUpdateNeeded(self):
@@ skipping 146 matching lines @@
     # Note that the bundle in naclsdk_manifest2.json will be called
     # CANARY_BUNDLE_NAME, whereas the bundle in the manifest "snippet" will be
     # called "pepper_21".
     canary_bundle = copy.deepcopy(BCANARY_NONE)
     self.manifest = MakeManifest(canary_bundle)
     self.history.Add(OS_MW, CANARY, V21_0_1145_0)
     self.files.Add(B21_0_1145_0_MLW)
     self._MakeDelegate()
     self._Run(OS_MLW)
     self._ReadUploadedManifest()
-    self._AssertUploadedManifestHasBundle(B21_0_1145_0_MLW, CANARY)
+    self._AssertUploadedManifestHasBundle(B21_0_1145_0_MLW, CANARY,
+                                          bundle_name=CANARY_BUNDLE_NAME)
 
   def testUpdateCanaryUseTrunkArchives(self):
     canary_bundle = copy.deepcopy(BCANARY_NONE)
     self.manifest = MakeManifest(canary_bundle)
     self.history.Add(OS_MW, CANARY, V21_0_1166_0)
     self.files.Add(B21_0_1166_0_MW)
     self.files.Add(BTRUNK_140819_MLW)
     self.version_mapping[V21_0_1166_0] = VTRUNK_140819
     self._MakeDelegate()
     self._Run(OS_MLW)
     self._ReadUploadedManifest()
 
     test_bundle = copy.deepcopy(B21_0_1166_0_MW)
     test_bundle.AddArchive(BTRUNK_140819_MLW.GetArchive('linux'))
-    self._AssertUploadedManifestHasBundle(test_bundle, CANARY)
+    self._AssertUploadedManifestHasBundle(test_bundle, CANARY,
+                                          bundle_name=CANARY_BUNDLE_NAME)
 
   def testCanaryUseOnlyTrunkArchives(self):
     self.manifest = MakeManifest(copy.deepcopy(BCANARY_NONE))
     history = """win,canary,21.0.1163.0,2012-06-04 12:35:44.784446
 mac,canary,21.0.1163.0,2012-06-04 11:54:09.433166"""
     self._AddCsvHistory(history)
     self.version_mapping['21.0.1163.0'] = 'trunk.140240'
     my_bundle = MakePlatformBundle(21, 140240, '21.0.1163.0', OS_MLW)
     self.files.Add(my_bundle)
     self._MakeDelegate()
     self._Run(OS_MLW)
     self._ReadUploadedManifest()
-    self._AssertUploadedManifestHasBundle(my_bundle, CANARY)
+    self._AssertUploadedManifestHasBundle(my_bundle, CANARY,
+                                          bundle_name=CANARY_BUNDLE_NAME)
 
   def testCanaryShouldOnlyUseCanaryVersions(self):
     canary_bundle = copy.deepcopy(BCANARY_NONE)
     self.manifest = MakeManifest(canary_bundle)
     self.history.Add(OS_MW, CANARY, V21_0_1166_0)
     self.history.Add(OS_MW, BETA, V19_0_1084_41)
     self.files.Add(B19_0_1084_41_MLW)
     self.version_mapping[V21_0_1166_0] = VTRUNK_140819
     self._MakeDelegate()
     self.assertRaises(Exception, self._Run, OS_MLW)
@@ skipping 24 matching lines @@
         '21.0.1157.0': 'unknown',
         '21.0.1156.1': 'trunk.139576',
         '21.0.1156.0': 'trunk.139984'}
     self.files.Add(MakePlatformBundle(21, 139890, '21.0.1159.2', OS_MLW))
     self.files.Add(MakePlatformBundle(21, 0, '21.0.1157.1', ('linux', 'win')))
     my_bundle = MakePlatformBundle(21, 139576, '21.0.1156.1', OS_MLW)
     self.files.Add(my_bundle)
     self._MakeDelegate()
     self._Run(OS_MLW)
     self._ReadUploadedManifest()
-    self._AssertUploadedManifestHasBundle(my_bundle, CANARY)
+    self._AssertUploadedManifestHasBundle(my_bundle, CANARY,
+                                          bundle_name=CANARY_BUNDLE_NAME)
 
   def testExtensionWorksAsBz2(self):
     # Allow old bundles with just .bz2 extension to work
     self.manifest = MakeManifest(B18_NONE)
     self.history.Add(OS_MLW, BETA, V18_0_1025_163)
     bundle = copy.deepcopy(B18_0_1025_163_MLW)
     archive_url = bundle.GetArchive('mac').url
     bundle.GetArchive('mac').url = archive_url.replace('.tar', '')
     self.files.Add(bundle)
     self._MakeDelegate()
@@ skipping 168 matching lines @@
     history = """win,canary,31.0.1608.1,2013-08-22 09:33:24.469760
 mac,canary,31.0.1608.0,2013-08-22 07:18:09.762600"""
     self._AddCsvHistory(history)
     self.version_mapping['31.0.1608.1'] = 'trunk.218914'
     self.version_mapping['31.0.1608.0'] = 'trunk.218872'
     my_bundle = MakePlatformBundle(31, 218872, '31.0.1608.0', OS_MLW)
     self.files.Add(my_bundle)
     self._MakeDelegate()
     self._Run(OS_MLW)
     self._ReadUploadedManifest()
-    self._AssertUploadedManifestHasBundle(my_bundle, CANARY)
+    self._AssertUploadedManifestHasBundle(my_bundle, CANARY,
+                                          bundle_name=CANARY_BUNDLE_NAME)
 
   def testDontIgnoreLastDigitForNonCanary(self):
     self.manifest = MakeManifest(B26_NONE)
     self.history.Add(OS_M, BETA, V26_0_1386_1)  # Only Mac
     self.history.Add(OS_LW, BETA, V26_0_1386_0)  # Only Linux, Windows.
     self.files.Add(B26_0_1386_0_MLW)
 
     self._MakeDelegate()
     # This raises because pepper_26 is not found in the history, and therefore
     # "locked", but it also doesn't have an online version, therefore there is
     # no good version number to upload.
     #
     # Basically we're asserting that 26.0.1386.1 != 26.0.1386.0, which would be
     # true if it were canary.
     self.assertRaises(update_nacl_manifest.UnknownLockedBundleException,
                       self._Run, OS_MLW)
 
+  def testUpdateBionic(self):
+    bionic_bundle = copy.deepcopy(BBIONIC_NONE)
+    self.manifest = MakeManifest(bionic_bundle)
+    self.history.Add(OS_MW, CANARY, V37_0_2054_0)
+    self.files.Add(BBIONIC_TRUNK_277776)
+    self.version_mapping[V37_0_2054_0] = VTRUNK_277776
+    self._MakeDelegate()
+    self._Run(OS_MLW)
+    self._ReadUploadedManifest()
+    self._AssertUploadedManifestHasBundle(BBIONIC_TRUNK_277776, CANARY,
+                                          bundle_name=BIONIC_CANARY_BUNDLE_NAME)
+
 
 class TestUpdateVitals(unittest.TestCase):
   def setUp(self):
     f = tempfile.NamedTemporaryFile('w', prefix="test_update_nacl_manifest")
     self.test_file = f.name
     f.close()
     test_data = "Some test data"
     self.sha1 = hashlib.sha1(test_data).hexdigest()
     self.data_len = len(test_data)
     with open(self.test_file, 'w') as f:
@@ skipping 35 matching lines @@
       '21.0.1180.80': '151582',
       '23.0.1271.89': '167132',
       '24.0.1305.4': '164971',
     }
     for version, revision in revision_dict.iteritems():
       self.assertEqual('trunk.%s' % revision,
                        self.delegate.GetTrunkRevision(version))
 
 
 if __name__ == '__main__':
+  logging.basicConfig(level=logging.INFO)
   sys.exit(unittest.main())