Clean up location directory

Clean up location directory before any installation operation

rubygems.py

@@ -79,6 +79,10 @@ class Recipe(object):
     def update(self):
         pass
 
+    def _clean_up(self, path):
+        if os.path.exists(path):
+            shutil.rmtree(path)
+  
     def _check_dependency_constraint(self, cons_dict, dep_dict, gemname):
         if not cons_dict['symbol']:
             return
@@ -197,17 +201,6 @@ class Recipe(object):
         recipe.install()
 
         current_dir = os.getcwd()
-        try:
-            os.mkdir(self.options['location'])
-        except OSError as e:
-            if e.errno == errno.EEXIST:
-                pass
-            else:
-                raise zc.buildout.UserError(
-                    'IO error while creating %s directory.'
-                    % self.options['location']
-                )
-
         os.chdir(srcdir)
 
         env = self._get_env()
@@ -274,15 +267,7 @@ class Recipe(object):
 
     def get_gem_executable(self, bindir):
         gem_executable = os.path.join(bindir, 'gem')
-        gem_executable = glob.glob(gem_executable + '*')
-
-        if gem_executable:
-            if not self.version:
-                self.version = self.run([
-                    gem_executable[0],
-                    '--version',
-                ])
-            return gem_executable[0]
+        return glob.glob(gem_executable + '*')[0]
 
     def get_dependency_list(self, gem_dict, gem_executable):
         gem_search_pattern = '^' + gem_dict['gemname'].replace('.',r'\.') + '$'
@@ -314,24 +299,29 @@ class Recipe(object):
         } for match in self.gem_regex.findall(cmd_result)]
 
     def get_rubygems_version(self):
-      gem_executable = self.get_gem_executable(self.bindir)
-      if gem_executable:
-          return self.run([gem_executable, '--version',])
-
       if not self.url:
           self.url = self._get_rubygems_url(self.options.get('version'))
       return re.search(r'rubygems-([0-9.]+).zip$', self.url).group(1)
 
     def install(self):
-        parts = [self.options['location']]
+        location = self.options['location']
+        self._clean_up(location)
+        try:
+            os.mkdir(location)
+        except OSError as e:
+            if e.errno == errno.EEXIST:
+                pass
+            else:
+                raise zc.buildout.UserError('IO error while creating %s directory.'
+                                             % self.options['location'])
+
+        parts = [location]
         self.version = self.get_rubygems_version()
         if int(self.version.split(".")[0]) < 2:
             raise zc.buildout.UserError("Rubygems version must be >= 2.0.0")
 
+        self._install_rubygems()
         gem_executable = self.get_gem_executable(self.bindir)
-        if not gem_executable:
-            self._install_rubygems()
-            gem_executable = self.get_gem_executable(self.bindir)
 
         gem_dict_list = list(map(self.get_gem_dict, self.gems))
         for gem_dict in gem_dict_list:

tests/test_rubygems.py

@@ -26,13 +26,18 @@ def touch(path):
 
 
 class fixture(object):
+    bin_dir = os.path.join('rubygems', 'bin')
+    rubygems_path = os.path.join(bin_dir, 'gem')
+
     def __init__(self, options=None, version=RUBYGEMS_DEFAULT_VERSION,
                  rubygems_installed=False):
         self.options = options or {}
+        self.rubygems_installed = rubygems_installed
         self.version = self.options.get('return', {}).get('version', version)
-  
+
         self.to_patch = (
             ('check_output', 'rubygems.subprocess.check_output'),
+            ('clean_up', 'rubygems.Recipe._clean_up'),
             ('urlopen', 'rubygems.urllib.request.urlopen'),
             ('download', 'rubygems.Download'),
         )
@@ -44,13 +49,9 @@ class fixture(object):
                        )),
         }
 
-        self.to_create = ()
-  
-        if rubygems_installed:
-            self.to_patch.append(
-                ('get_version', 'rubygems.Recipe.get_rubygems_version'))
-            self.patch_return_value_dict['get_version'] = self.version
-            self.to_create.append(path / 'rubygems/bin/gem')
+        self.patch_side_effect_dict = {
+            'check_output': self.check_output_mock,
+        }
 
     def __call__(self, func):
         @functools.wraps(func)
@@ -63,6 +64,13 @@ class fixture(object):
             self.tear_down()
         return wrapper
 
+    def check_output_mock(self, cmd, **kwargs):
+        if cmd[:3] == ['ruby', 'setup.rb', 'all']:
+            self.install_rubygems()
+
+    def install_rubygems(self):
+        touch(self.tempdir / self.rubygems_path)
+
     def patch(self, modules):
         self.patchers = {}
         self.patches = {}
@@ -81,16 +89,17 @@ class fixture(object):
         self.patch(self.to_patch)
         for k, v in self.patch_return_value_dict.items():
             self.patches[k].return_value = v
+        for k, v in self.patch_side_effect_dict.items():
+            self.patches[k].side_effect = v
 
         self.makedirs((
             'bin',
             'ruby-' + self.version,
             'rubygems-' + self.version,
-            'rubygems/bin',
+            self.bin_dir,
         ))
-
-        for file_path in self.to_create:
-            touch(file_path)
+        if self.rubygems_installed:
+            self.install_rubygems()
 
         buildout = {'buildout': dict({
             'parts-directory': str(self.tempdir),
@@ -150,8 +159,8 @@ class RubyGemsDefaultTestCase(RubyGemsTestCase):
 
         expected_install_arg_list_list = [
             [
-                'ruby', None, 'install', '--no-document',
-                '--bindir=%s/rubygems/bin' % path,
+                'ruby', str(path / fixture.rubygems_path), 'install',
+                '--no-document', '--bindir=' + str(path / fixture.bin_dir),
                 'sass', '--',
             ],
         ]
@@ -280,7 +289,8 @@ class RubyGemsDefaultTestCase(RubyGemsTestCase):
         recipe.install()
 
 class deployment_fixture(fixture):
-    def mocked_check_output_for_dependencies(self, cmd, **kwargs):
+    def check_output_mock(self, cmd, **kwargs):
+        super(deployment_fixture, self).check_output_mock(cmd)
         if len(cmd) > 3 and cmd[2] == 'dependency':
             filename = 'dependency_%s-%s.txt' % (cmd[5][2:-2], cmd[4])
             dependency_output_file = os.path.join(
@@ -293,7 +303,6 @@ class deployment_fixture(fixture):
     def set_up(self):
         buildout, name, options, version = super(deployment_fixture, self).set_up()
         options['deployment'] = 'true'
-        self.patches['check_output'].side_effect = self.mocked_check_output_for_dependencies
         return buildout, name, options, version
 
 
@@ -309,13 +318,14 @@ class RubyGemsDeploymentTestCase(RubyGemsTestCase):
             if version[0] < '3':
                 gem_search_pattern = '/' + gem_search_pattern + '/'
 
+            gem_executable = str(path / fixture.rubygems_path)
             expected_install_arg_list_list.extend([
                 [
-                    'ruby', None, 'dependency', '-rv', gem_dict['version'],
+                    'ruby', gem_executable, 'dependency', '-rv', gem_dict['version'],
                     gem_search_pattern,
                 ], [
-                    'ruby', None, 'install', '--no-document',
-                    '--bindir=%s/rubygems/bin' % path,
+                    'ruby', gem_executable, 'install', '--no-document',
+                    '--bindir=' + str(path / fixture.bin_dir),
                     '--ignore-dependencies', gem_dict['gemname'],
                     '--version=' + gem_dict['version'], '--',
                 ]