cipd: Skip test on Windows for now.

go/test.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 """Runs Go unit tests verifying code coverage.
 
 Expects Go toolset to be in PATH, GOPATH and GOROOT correctly set. Use ./env.py
 to set them up.
 
@@ skipping 63 matching lines @@
 
 def makedirs(path):
   """Same as os.makedirs, but doesn't fail if path exists."""
   try:
     os.makedirs(path)
   except OSError as err:
     if err.errno != errno.EEXIST:
       raise
 
 
+def get_goos():
+  """Converts sys.platform to GOOS value."""
+  if sys.platform.startswith('win'):
+    return 'windows'
+  if sys.platform.startswith('darwin'):
+    return 'darwin'
+  if sys.platform.startswith('linux'):
+    return 'linux'
+  raise ValueError('Unrecognized platform: %s' % sys.platform)
+
+
 _package_info_cache = {}
 
 def get_package_info(package):
   """Returns contents of <package>/<name>.infra_testing file or {} if missing.
 
   *.infra_testing contains a JSON dict with the following keys:
   {
     // Do not run tests in this package at all. Default 'false'.
-    "skip_testing": boolean,
+    "skip_testing": a list of platforms (GOOS) to skip tests on,
     // Minimum allowed code coverage percentage, see below. Default '100'.
     "expected_coverage_min": number,
     // Maximum allowed code coverage percentage, see below. Default '100'.
     "expected_coverage_max": number
   }
 
   expected_coverage_min and expected_coverage_max set a boundary on what the
   code coverage percentage of the package is expected to be. test.py will fail
   if code coverage is less than 'expected_coverage_min' (meaning the package
   code has degraded), or larger than 'expected_coverage_max' (meaning the
@@ skipping 30 matching lines @@
       print >> sys.stderr, 'Not a valid JSON file: %s' % info_file
       return {}
 
   if package not in _package_info_cache:
     _package_info_cache[package] = do_read()
   return _package_info_cache[package]
 
 
 def should_skip(package):
   """True to skip package tests, reads 'skip_testing' from *.infra_testing."""
-  return get_package_info(package).get('skip_testing', False)
+  skip = get_package_info(package).get('skip_testing', [])
+  if not isinstance(skip, list):
+    raise TypeError(
+        '%s: "skip_testing" should be a list of platforms to skip tests on, '
+        'got %r instead' % (package, skip))
+  return get_goos() in skip
+
 
 def get_build_tags(package):
-  """True to skip package tests, reads 'skip_testing' from *.infra_testing."""
+  """Build tags to use when building a package, read from *.infra_testing."""
   tags = get_package_info(package).get('build_tags', ())
   if tags:
     return '-tags='+(','.join(tags))
   return None
 
+
 def get_expected_coverage(package):
   """Returns allowed code coverage percentage as a pair (min, max)."""
   info = get_package_info(package)
   min_cover = info.get('expected_coverage_min', 100.0)
   max_cover = info.get('expected_coverage_max', 100.0)
   if max_cover < min_cover:
     max_cover = min_cover
   return (min_cover, max_cover)
 
 
@@ skipping 88 matching lines @@
     print 'Use ./env.py python test.py'
     return 1
 
   # Coverage dir is always overwritten with new coverage reports.
   if os.path.exists(coverage_dir):
     shutil.rmtree(coverage_dir)
     makedirs(coverage_dir)
 
   # Code coverage report requires tests to be run against a single package, so
   # discover all individual packages.
-  packages = [p for p in list_packages(package_root) if not should_skip(p)]
-  if not packages:
+  skipped = []
+  packages = []
+  for p in list_packages(package_root):
+    if should_skip(p):
+      skipped.append(p)
+    else:
+      packages.append(p)
+
+  if skipped:
+    print 'Skipping these packages (see "skip_testing" in *.infra_testing):'
+    for p in sorted(skipped):
+      print '    %s' % p
+    print
+
+  if packages:
+    print 'About to run tests for: '
+    for p in sorted(packages):
+      print '    %s' % p
+  else:
     print 'No tests to run'
     return 0
+  print '-' * 80
 
   failed = []
   bad_cover = []
   tpool = ThreadPool(len(packages))
   def run(pkg):
     coverage_file = os.path.join(coverage_dir, pkg.replace('/', os.sep))
     return run_package_tests(pkg, coverage_file)
   for result in tpool.imap_unordered(run, packages):
     if result.tests_pass and result.coverage_pass:
       sys.stdout.write('.')
@@ skipping 54 matching lines @@
   elif len(args) == 1:
     package_root = args[0]
   else:
     print >> sys.stderr, sys.modules['__main__'].__doc__.strip()
     return 1
   return run_tests(package_root, os.path.join(INFRA_GO_DIR, 'coverage'))
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))