Added "gclient pack" subcommand, which generates a patch relative to...

tests/gclient_test.py

 #!/usr/bin/python
 #
 # Copyright 2008-2009 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 """Unit tests for gclient.py."""
 
 __author__ = 'stephen5.ng@gmail.com (Stephen Ng)'
 
 import __builtin__
 import os
+import re
 import StringIO
 import unittest
 
 import gclient
 import super_mox
 from super_mox import mox
 
 
 class BaseTestCase(super_mox.SuperMoxTestBase):
   def setUp(self):
@@ skipping 70 matching lines @@
     self.args = self.Args()
     self.root_dir = self.Dir()
     self.url = self.Url()
 
 
 class GClientCommandsTestCase(GClientBaseTestCase):
   def testCommands(self):
     known_commands = [gclient.DoCleanup, gclient.DoConfig, gclient.DoDiff,
                       gclient.DoExport, gclient.DoHelp, gclient.DoStatus,
                       gclient.DoUpdate, gclient.DoRevert, gclient.DoRunHooks,
-                      gclient.DoRevInfo]
+                      gclient.DoRevInfo, gclient.DoPack]
     for (k,v) in gclient.gclient_command_map.iteritems():
       # If it fails, you need to add a test case for the new command.
       self.assert_(v in known_commands)
     self.mox.ReplayAll()
 
 class TestDoConfig(GclientTestCase):
   def testMissingArgument(self):
     exception_msg = "required argument missing; see 'gclient help config'"
 
     self.mox.ReplayAll()
@@ skipping 171 matching lines @@
     self.args = ['dir']
     self.ReturnValue('export', gclient.DoExport, 0)
   def testError(self):
     self.args = ['dir']
     self.ReturnValue('export', gclient.DoExport, 42)
   def testBadClient(self):
     self.args = ['dir']
     self.BadClient(gclient.DoExport)
 
 
+class TestDoPack(GenericCommandTestCase):
+  def Options(self, *args, **kwargs):
+      return self.OptionsObject(self, *args, **kwargs)
+
+  def testBasic(self):
+    self.ReturnValue('pack', gclient.DoPack, 0)
+  def testError(self):
+    self.ReturnValue('pack', gclient.DoPack, 42)
+  def testBadClient(self):
+    self.BadClient(gclient.DoPack)
+
+
 class TestDoRevert(GenericCommandTestCase):
   def testBasic(self):
     self.ReturnValue('revert', gclient.DoRevert, 0)
   def testError(self):
     self.ReturnValue('revert', gclient.DoRevert, 42)
   def testBadClient(self):
     self.BadClient(gclient.DoRevert)
 
 
 class GClientClassTestCase(GclientTestCase):
@@ skipping 698 matching lines @@
   def setUp(self):
     GClientBaseTestCase.setUp(self)
     self.root_dir = self.Dir()
     self.args = self.Args()
     self.url = self.Url()
     self.relpath = 'asf'
 
   def testDir(self):
     members = [
       'FullUrlForRelativeUrl', 'RunCommand', 'cleanup', 'diff', 'export',
-      'relpath', 'revert', 'scm_name', 'status', 'update', 'url',
+      'pack', 'relpath', 'revert', 'scm_name', 'status', 'update', 'url',
     ]
 
     # If you add a member, be sure to add the relevant test!
     self.compareMembers(self._scm_wrapper(), members)
 
   def testFullUrlForRelativeUrl(self):
     self.url = 'svn://a/b/c/d'
 
     self.mox.ReplayAll()
     scm = self._scm_wrapper(url=self.url, root_dir=self.root_dir,
@@ skipping 219 matching lines @@
 
 
 class RunSVNTestCase(BaseTestCase):
   def testRunSVN(self):
     param2 = 'bleh'
     gclient.SubprocessCall(['svn', 'foo', 'bar'], param2).AndReturn(None)
     self.mox.ReplayAll()
     gclient.RunSVN(['foo', 'bar'], param2)
 
 
-class SubprocessCallAndCaptureTestCase(BaseTestCase):
+class SubprocessCallAndFilterTestCase(BaseTestCase):
   def setUp(self):
     BaseTestCase.setUp(self)
     self.mox.StubOutWithMock(gclient, 'CaptureSVN')
 
-  def testSubprocessCallAndCapture(self):
+  def testSubprocessCallAndFilter(self):
     command = ['boo', 'foo', 'bar']
     in_directory = 'bleh'
     fail_status = None
     pattern = 'a(.*)b'
     test_string = 'ahah\naccb\nallo\naddb\n'
     class Mock(object):
       stdout = StringIO.StringIO(test_string)
       def wait(self):
         pass
     kid = Mock()
     print("\n________ running 'boo foo bar' in 'bleh'")
     for i in test_string:
       gclient.sys.stdout.write(i)
     gclient.subprocess.Popen(command, bufsize=0, cwd=in_directory,
                              shell=(gclient.sys.platform == 'win32'),
                              stdout=gclient.subprocess.PIPE).AndReturn(kid)
     self.mox.ReplayAll()
+    compiled_pattern = re.compile(pattern)
+    line_list = []
     capture_list = []
-    gclient.SubprocessCallAndCapture(command, in_directory, fail_status,
-                                     pattern, capture_list)
+    def FilterLines(line):
+      line_list.append(line)
+      match = compiled_pattern.search(line)
+      if match:
+        capture_list.append(match.group(1))
+    gclient.SubprocessCallAndFilter(command, in_directory,
+                                    True, True,
+                                    fail_status, FilterLines)
+    self.assertEquals(line_list, ['ahah', 'accb', 'allo', 'addb'])
     self.assertEquals(capture_list, ['cc', 'dd'])
 
   def testCaptureSVNStatus(self):
     x = self
     def CaptureSVNMock(command, in_directory=None, print_error=True):
       x.assertEquals(in_directory, None)
       x.assertEquals(print_error, True)
       x.assertEquals(['status', '--xml', '.'], command)
       return r"""<?xml version="1.0"?>
 <status>
@@ skipping 57 matching lines @@
 """
     gclient.CaptureSVN = CaptureSVNMock
     info = gclient.CaptureSVNStatus(None)
     self.assertEquals(info, [])
 
 
 if __name__ == '__main__':
   unittest.main()
 
 # vim: ts=2:sw=2:tw=80:et: