Add git-number script to calculate generation numbers for commits.

tests/git_common_test.py

+#!/usr/bin/env python
+# Copyright (c) 2013 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.
+
+"""Unit tests for git_common.py"""
+
+import collections
+import binascii
+import os
+import signal
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

[M-A Ruel, 2013/11/07 20:59:11]

Make this a constant, and use another one for the __main__ section below.

[iannucci, 2013/11/07 21:44:57]

Done.

+
+from testing_support import git_test_utils
+
+
+class GitCommonTestBase(unittest.TestCase):
+  @classmethod
+  def setUpClass(cls):
+    super(GitCommonTestBase, cls).setUpClass()
+    import git_common
+    cls.gc = git_common
+
+
+class Support(GitCommonTestBase):
+  def testMemoizeOne(self):
+    calls = collections.defaultdict(int)
+    def double_if_even(val):
+      calls[val] += 1
+      if val % 2 == 0:
+        return val * 2
+      else:
+        return None
+    # Use this explicitly as a wrapper fn instead of a decorator. Otherwise
+    # pylint crashes (!!)
+    double_if_even = self.gc.memoize_one(double_if_even)
+    self.assertEqual(double_if_even(2), 4)
+    self.assertEqual(double_if_even(2), 4)
+    self.assertEqual(double_if_even(1), None)
+    self.assertEqual(double_if_even(1), None)
+    self.assertDictEqual(calls, {1: 2, 2: 1})
+
+    double_if_even.cache[10] = 20
+    self.assertEqual(double_if_even(10), 20)
+    self.assertDictEqual(calls, {1: 2, 2: 1})
+
+    double_if_even.cache.clear()
+    self.assertEqual(double_if_even(2), 4)
+    self.assertEqual(double_if_even(2), 4)
+    self.assertEqual(double_if_even(1), None)
+    self.assertEqual(double_if_even(1), None)
+    self.assertEqual(double_if_even(10), 20)
+    self.assertDictEqual(calls, {1: 4, 2: 2, 10: 1})
+
+
+def slow_square(i):
+  """Helper for ScopedPoolTest.
+
+  Must be global because non top-level functions aren't pickleable.
+  """
+  import time

[M-A Ruel, 2013/11/07 20:59:11]

You want to reimport in fear of time.sleep() mocking?

[iannucci, 2013/11/07 21:44:57]

No, actually I'm not sure why I did this. Fixed.

+  time.sleep(0.2)
+  return i ** 2
+
+
+class ScopedPoolTest(GitCommonTestBase):
+  if sys.platform.startswith('win'):
+    CTRL_C = signal.CTRL_C_EVENT
+  else:
+    CTRL_C = signal.SIGINT
+
+  def testThreads(self):
+    result = []
+    with self.gc.ScopedPool(kind='threads') as pool:
+      for i in pool.imap(slow_square, xrange(10)):
+        result.append(i)
+    self.assertEqual(result, [0, 1, 4, 9, 16, 25, 36, 49, 64, 81])
+
+  def testThreadsCtrlC(self):
+    result = []
+    with self.assertRaises(KeyboardInterrupt):
+      with self.gc.ScopedPool(kind='threads') as pool:
+        # Make sure this pool is interrupted in mid-swing
+        for i in pool.imap(slow_square, xrange(1000000)):
+          if i > 32:
+            os.kill(os.getpid(), self.CTRL_C)
+          result.append(i)
+    self.assertEqual(result, [0, 1, 4, 9, 16, 25])
+
+  def testProcs(self):
+    result = []
+    with self.gc.ScopedPool() as pool:
+      for i in pool.imap(slow_square, xrange(10)):
+        result.append(i)
+    self.assertEqual(result, [0, 1, 4, 9, 16, 25, 36, 49, 64, 81])
+
+  def testProcsCtrlC(self):
+    result = []
+    with self.assertRaises(KeyboardInterrupt):
+      with self.gc.ScopedPool() as pool:
+        # Make sure this pool is interrupted in mid-swing
+        for i in pool.imap(slow_square, xrange(1000000)):
+          if i > 32:
+            os.kill(os.getpid(), self.CTRL_C)
+          result.append(i)
+    self.assertEqual(result, [0, 1, 4, 9, 16, 25])
+
+
+class ProgressPrinterTest(GitCommonTestBase):
+  class FakeStream(object):
+    def __init__(self):
+      self.data = set()
+      self.count = 0
+
+    def write(self, line):
+      self.data.add(line)
+
+    def flush(self):
+      self.count += 1
+
+  # This test is probably racy, but I don't have a better alternative.
+  @unittest.expectedFailure
+  def testBasic(self):
+    fmt = '%(count)d/10'
+    stream = self.FakeStream()
+
+    pp = self.gc.ProgressPrinter(fmt, enabled=True, stream=stream, period=0.01)
+    with pp as inc:
+      import time
+      for _ in xrange(10):
+        time.sleep(0.02)
+        inc()
+
+    filtered = set(x.strip() for x in stream.data)
+    rslt = set(fmt % {'count': i} for i in xrange(11))
+    self.assertSetEqual(filtered, rslt)
+    self.assertGreaterEqual(stream.count, 10)
+
+
+class GitReadOnlyFunctionsTest(git_test_utils.GitRepoReadOnlyTestBase,
+                               GitCommonTestBase):
+  REPO = """
+  A B C D
+    B E D
+  """
+
+  COMMIT_A = {
+    'some/files/file1': {'data': 'file1'},
+    'some/files/file2': {'data': 'file2'},
+    'some/files/file3': {'data': 'file3'},
+    'some/other/file':  {'data': 'otherfile'},
+  }
+
+  COMMIT_C = {
+    'some/files/file2': {
+      'mode': 0755,
+      'data': 'file2 - vanilla'},
+  }
+
+  COMMIT_E = {
+    'some/files/file2': {'data': 'file2 - merged'},
+  }
+
+  COMMIT_D = {
+    'some/files/file2': {'data': 'file2 - vanilla\nfile2 - merged'},
+  }
+
+  def testHashes(self):
+    ret = self.repo.run(
+      self.gc.hashes, *[
+        'master',
+        'master~3',
+        self.repo['E']+'~',
+        self.repo['D']+'^2',
+        'tag_C^{}',
+      ]
+    )
+    self.assertEqual(ret, [
+      self.repo['D'],
+      self.repo['A'],
+      self.repo['B'],
+      self.repo['E'],
+      self.repo['C'],
+    ])
+
+  def testParseCommittishes(self):
+    ret = self.repo.run(
+      self.gc.parse_committishes, *[
+        'master',
+        'master~3',
+        self.repo['E']+'~',
+        self.repo['D']+'^2',
+        'tag_C^{}',
+      ]
+    )
+    self.assertEqual(ret, map(binascii.unhexlify, [
+      self.repo['D'],
+      self.repo['A'],
+      self.repo['B'],
+      self.repo['E'],
+      self.repo['C'],
+    ]))
+
+    with self.assertRaisesRegexp(Exception, r"one of \('master', 'bananas'\)"):
+      self.repo.run(self.gc.parse_committishes, 'master', 'bananas')
+
+  def testTree(self):
+    tree = self.repo.run(self.gc.tree, 'master:some/files')
+    file1 = self.COMMIT_A['some/files/file1']['data']
+    file2 = self.COMMIT_D['some/files/file2']['data']
+    file3 = self.COMMIT_A['some/files/file3']['data']
+    self.assertEquals(tree['file1'],
+                      ('100644', 'blob', git_test_utils.git_hash_data(file1)))
+    self.assertEquals(tree['file2'],
+                      ('100755', 'blob', git_test_utils.git_hash_data(file2)))
+    self.assertEquals(tree['file3'],
+                      ('100644', 'blob', git_test_utils.git_hash_data(file3)))
+
+    tree = self.repo.run(self.gc.tree, 'master:some')
+    self.assertEquals(len(tree), 2)
+    # Don't check the tree hash because we're lazy :)
+    self.assertEquals(tree['files'][:2], ('040000', 'tree'))
+
+    tree = self.repo.run(self.gc.tree, 'master:wat')
+    self.assertEqual(tree, None)
+
+  def testTreeRecursive(self):
+    tree = self.repo.run(self.gc.tree, 'master:some', recurse=True)
+    file1 = self.COMMIT_A['some/files/file1']['data']
+    file2 = self.COMMIT_D['some/files/file2']['data']
+    file3 = self.COMMIT_A['some/files/file3']['data']
+    other = self.COMMIT_A['some/other/file']['data']
+    self.assertEquals(tree['files/file1'],
+                      ('100644', 'blob', git_test_utils.git_hash_data(file1)))
+    self.assertEquals(tree['files/file2'],
+                      ('100755', 'blob', git_test_utils.git_hash_data(file2)))
+    self.assertEquals(tree['files/file3'],
+                      ('100644', 'blob', git_test_utils.git_hash_data(file3)))
+    self.assertEquals(tree['other/file'],
+                      ('100644', 'blob', git_test_utils.git_hash_data(other)))
+
+  def testError(self):
+    with self.assertRaisesRegexp(self.gc.CalledProcessError, 'status 1'):
+      self.gc.run('rev-parse', 'bananas')
+
+
+class GitMutableFunctionsTest(git_test_utils.GitRepoReadWriteTestBase,
+                              GitCommonTestBase):
+  REPO = ""

[M-A Ruel, 2013/11/07 20:59:11]

REPO = ''

[iannucci, 2013/11/07 21:44:57]

Done.

+
+  def _intern_data(self, data):
+    with tempfile.TemporaryFile() as f:
+      f.write(data)
+      f.seek(0)
+      return self.repo.run(self.gc.intern_f, f)
+
+  def testIndata(self):
+    data = 'WayCOOL SuperTest!'
+    data_hash = self.repo.run(
+      self.gc.run, 'hash-object', '-t', 'blob', '--stdin', indata=data)
+    self.assertEqual(data_hash, git_test_utils.git_hash_data(data))
+
+  def testInternF(self):
+    data = "CoolBobcatsBro"
+    data_hash = self._intern_data(data)
+    self.assertEqual(data_hash, git_test_utils.git_hash_data(data))
+    self.assertEqual(self.repo.git('cat-file', 'blob', data_hash).stdout, data)
+
+  def testMkTree(self):
+    tree = {}
+    for i in 1, 2, 3:
+      name = 'file%d' % i
+      tree[name] = ('100644', 'blob', self._intern_data(name))
+    tree_hash = self.repo.run(self.gc.mktree, tree)
+    self.assertEqual(tree_hash, '37b61866d6e061c4ba478e7eb525be7b5752737d')
+
+
+if __name__ == '__main__':
+  sys.exit(git_test_utils.covered_main(
+    os.path.join(os.path.abspath(os.path.dirname(os.path.dirname(__file__))),
+                 'git_common.py')
+  ))