modulesync 2.1.1 → 2.3.1

data/lib/modulesync.rb

@@ -1,3 +1,4 @@
+require 'English'
 require 'fileutils'
 require 'pathname'
 
@@ -18,10 +19,10 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
 
   def self.config_defaults
     {
-      :project_root         => 'modules/',
+      :project_root => 'modules/',
       :managed_modules_conf => 'managed_modules.yml',
-      :configs              => '.',
-      :tag_pattern          => '%s'
+      :configs => '.',
+      :tag_pattern => '%s',
     }
   end
 
@@ -44,8 +45,8 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
           .to_a
     else
       $stderr.puts "#{local_template_dir} does not exist." \
-        ' Check that you are working in your module configs directory or' \
-        ' that you have passed in the correct directory with -c.'
+                   ' Check that you are working in your module configs directory or' \
+                   ' that you have passed in the correct directory with -c.'
       exit 1
     end
   end
@@ -62,7 +63,7 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     managed_modules = Util.parse_config(config_file)
     if managed_modules.empty?
       $stderr.puts "No modules found in #{config_file}." \
-        ' Check that you specified the right :configs directory and :managed_modules_conf file.'
+                   ' Check that you specified the right :configs directory and :managed_modules_conf file.'
       exit 1
     end
     managed_modules.select! { |m| m =~ Regexp.new(filter) } unless filter.nil?
@@ -82,7 +83,6 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
   end
 
   def self.manage_file(puppet_module, filename, settings, options)
-    namespace = settings.additional_settings[:namespace]
     module_name = settings.additional_settings[:puppet_module]
     configs = settings.build_file_configs(filename)
     target_file = puppet_module.path(filename)
@@ -95,12 +95,12 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
         # Meta data passed to the template as @metadata[:name]
         metadata = {
           :module_name => module_name,
-          :workdir     => puppet_module.working_directory,
+          :workdir => puppet_module.working_directory,
           :target_file => target_file,
         }
         template = Renderer.render(erb, configs, metadata)
         Renderer.sync(template, target_file)
-      rescue StandardError => e
+      rescue StandardError
         $stderr.puts "#{puppet_module.given_name}: Error while rendering file: '#{filename}'"
         raise
       end
@@ -109,7 +109,12 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
 
   def self.manage_module(puppet_module, module_files, defaults)
     puts "Syncing '#{puppet_module.given_name}'"
-    puppet_module.repository.prepare_workspace(options[:branch]) unless options[:offline]
+    # NOTE: #prepare_workspace now supports to execute only offline operations
+    # but we totally skip the workspace preparation to keep the current behavior
+    unless options[:offline]
+      puppet_module.repository.prepare_workspace(branch: options[:branch],
+                                                 operate_offline: false)
+    end
 
     module_configs = Util.parse_config puppet_module.path(MODULE_CONF_FILE)
     settings = Settings.new(defaults[GLOBAL_DEFAULTS_KEY] || {},
@@ -129,9 +134,8 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
 
     if options[:noop]
       puts "Using no-op. Files in '#{puppet_module.given_name}' may be changed but will not be committed."
-      puppet_module.repository.show_changes(options)
-      options[:pr] && \
-        pr(puppet_module).manage(puppet_module.repository_namespace, puppet_module.repository_name, options)
+      changed = puppet_module.repository.show_changes(options)
+      changed && options[:pr] && puppet_module.open_pull_request
     elsif !options[:offline]
       pushed = puppet_module.repository.submit_changes(files_to_manage, options)
       # Only bump/tag if pushing didn't fail (i.e. there were changes)
@@ -139,13 +143,13 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
         new = puppet_module.bump(options[:message], options[:changelog])
         puppet_module.repository.tag(new, options[:tag_pattern]) if options[:tag]
       end
-      pushed && options[:pr] && \
-        pr(puppet_module).manage(puppet_module.repository_namespace, puppet_module.repository_name, options)
+      pushed && options[:pr] && puppet_module.open_pull_request
     end
   end
 
   def self.config_path(file, options)
     return file if Pathname.new(file).absolute?
+
     File.join(options[:configs], file)
   end
 
@@ -157,15 +161,6 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     @options = config_defaults.merge(cli_options)
     defaults = Util.parse_config(config_path(CONF_FILE, options))
 
-    if options[:pr]
-      unless options[:branch]
-        $stderr.puts 'A branch must be specified with --branch to use --pr!'
-        raise
-      end
-
-      @pr = create_pr_manager if options[:pr]
-    end
-
     local_template_dir = config_path(MODULE_FILES_DIR, options)
     local_files = find_template_files(local_template_dir)
     module_files = relative_names(local_files, local_template_dir)
@@ -173,56 +168,99 @@ module ModuleSync # rubocop:disable Metrics/ModuleLength
     errors = false
     # managed_modules is either an array or a hash
     managed_modules.each do |puppet_module|
-      begin
-        manage_module(puppet_module, module_files, defaults)
-      rescue ModuleSync::Error, Git::GitExecuteError => e
-        message = e.message || "Error during '#{options[:command]}'"
-        $stderr.puts "#{puppet_module.given_name}: #{message}"
-        exit 1 unless options[:skip_broken]
-        errors = true
-        $stdout.puts "Skipping '#{puppet_module.given_name}' as update process failed"
-      rescue StandardError => e
-        raise unless options[:skip_broken]
-        errors = true
-        $stdout.puts "Skipping '#{puppet_module.given_name}' as update process failed"
-      end
+      manage_module(puppet_module, module_files, defaults)
+    rescue ModuleSync::Error, Git::GitExecuteError => e
+      message = e.message || 'Error during `update`'
+      $stderr.puts "#{puppet_module.given_name}: #{message}"
+      exit 1 unless options[:skip_broken]
+      errors = true
+      $stdout.puts "Skipping '#{puppet_module.given_name}' as update process failed"
+    rescue StandardError
+      raise unless options[:skip_broken]
+
+      errors = true
+      $stdout.puts "Skipping '#{puppet_module.given_name}' as update process failed"
     end
     exit 1 if errors && options[:fail_on_warnings]
   end
 
-  def self.pr(puppet_module)
-    module_options = puppet_module.options
-    github_conf = module_options[:github]
-    gitlab_conf = module_options[:gitlab]
-
-    if !github_conf.nil?
-      base_url = github_conf[:base_url] || ENV.fetch('GITHUB_BASE_URL', 'https://api.github.com')
-      require 'modulesync/pr/github'
-      ModuleSync::PR::GitHub.new(github_conf[:token], base_url)
-    elsif !gitlab_conf.nil?
-      base_url = gitlab_conf[:base_url] || ENV.fetch('GITLAB_BASE_URL', 'https://gitlab.com/api/v4')
-      require 'modulesync/pr/gitlab'
-      ModuleSync::PR::GitLab.new(gitlab_conf[:token], base_url)
-    elsif @pr.nil?
-      $stderr.puts 'No GitHub or GitLab token specified for --pr!'
-      raise
-    else
-      @pr
+  def self.clone(cli_options)
+    @options = config_defaults.merge(cli_options)
+
+    managed_modules.each do |puppet_module|
+      puppet_module.repository.clone unless puppet_module.repository.cloned?
     end
   end
 
-  def self.create_pr_manager
-    github_token = ENV.fetch('GITHUB_TOKEN', '')
-    gitlab_token = ENV.fetch('GITLAB_TOKEN', '')
+  def self.execute(cli_options)
+    @options = config_defaults.merge(cli_options)
 
-    if !github_token.empty?
-      require 'modulesync/pr/github'
-      ModuleSync::PR::GitHub.new(github_token, ENV.fetch('GITHUB_BASE_URL', 'https://api.github.com'))
-    elsif !gitlab_token.empty?
-      require 'modulesync/pr/gitlab'
-      ModuleSync::PR::GitLab.new(gitlab_token, ENV.fetch('GITLAB_BASE_URL', 'https://gitlab.com/api/v4'))
-    else
-      warn '--pr specified without environment variables GITHUB_TOKEN or GITLAB_TOKEN'
+    errors = {}
+    managed_modules.each do |puppet_module|
+      $stdout.puts "#{puppet_module.given_name}:"
+
+      puppet_module.repository.clone unless puppet_module.repository.cloned?
+      puppet_module.repository.switch branch: @options[:branch]
+
+      command_args = cli_options[:command_args]
+      local_script = File.expand_path command_args[0]
+      command_args[0] = local_script if File.exist?(local_script)
+
+      # Remove bundler-related env vars to allow the subprocess to run `bundle`
+      command_env = ENV.reject { |k, _v| k.match?(/(^BUNDLE|^SOURCE_DATE_EPOCH$|^GEM_|RUBY)/) }
+
+      result = system command_env, *command_args, unsetenv_others: true, chdir: puppet_module.working_directory
+      unless result
+        message = "Command execution failed ('#{@options[:command_args].join ' '}': #{$CHILD_STATUS})"
+        raise Thor::Error, message if @options[:fail_fast]
+
+        errors.merge!(
+          puppet_module.given_name => message,
+        )
+        $stderr.puts message
+      end
+
+      $stdout.puts ''
+    end
+
+    unless errors.empty?
+      raise Thor::Error, <<~MSG
+        Error(s) during `execute` command:
+        #{errors.map { |name, message| "  * #{name}: #{message}" }.join "\n"}
+      MSG
+    end
+
+    exit 1 unless errors.empty?
+  end
+
+  def self.reset(cli_options)
+    @options = config_defaults.merge(cli_options)
+    if @options[:branch].nil?
+      raise Thor::Error,
+            "Error: 'branch' option is missing, please set it in configuration or in command line."
+    end
+
+    managed_modules.each do |puppet_module|
+      puppet_module.repository.reset_workspace(
+        branch: @options[:branch],
+        source_branch: @options[:source_branch],
+        operate_offline: @options[:offline],
+      )
+    end
+  end
+
+  def self.push(cli_options)
+    @options = config_defaults.merge(cli_options)
+
+    if @options[:branch].nil?
+      raise Thor::Error,
+            "Error: 'branch' option is missing, please set it in configuration or in command line."
+    end
+
+    managed_modules.each do |puppet_module|
+      puppet_module.repository.push branch: @options[:branch], remote_branch: @options[:remote_branch]
+    rescue ModuleSync::Error => e
+      raise Thor::Error, "#{puppet_module.given_name}: #{e.message}"
     end
   end
 end

data/modulesync.gemspec

@@ -1,14 +1,14 @@
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name                  = 'modulesync'
-  spec.version               = '2.1.1'
+  spec.version               = '2.3.1'
   spec.authors               = ['Vox Pupuli']
   spec.email                 = ['voxpupuli@groups.io']
   spec.summary               = 'Puppet Module Synchronizer'
   spec.description           = 'Utility to synchronize common files across puppet modules in Github.'
-  spec.homepage              = 'http://github.com/voxpupuli/modulesync'
+  spec.homepage              = 'https://github.com/voxpupuli/modulesync'
   spec.license               = 'Apache-2.0'
   spec.required_ruby_version = '>= 2.5.0'
 
@@ -17,11 +17,15 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'aruba', '~> 0.14'
+  spec.add_development_dependency 'aruba', '>= 0.14', '< 2'
   spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'cucumber'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'rubocop', '~> 0.50.0'
+  spec.add_development_dependency 'rubocop', '~> 1.2'
+  spec.add_development_dependency 'rubocop-rake'
+  spec.add_development_dependency 'rubocop-rspec'
+  spec.add_development_dependency 'simplecov'
 
   spec.add_runtime_dependency 'git', '~>1.7'
   spec.add_runtime_dependency 'gitlab', '~>4.0'

data/spec/helpers/faker/puppet_module_remote_repo.rb

@@ -77,6 +77,7 @@ module ModuleSync
         branch ||= default_branch
         FileUtils.chdir(tmp_repo_dir) do
           run %W[git checkout #{branch}]
+          run %w[git pull --force --prune]
           File.write filename, content
           run %W[git add #{filename}]
           run %w[git commit --message] << "Add file: '#{filename}'"
@@ -94,7 +95,7 @@ module ModuleSync
       def commit_count_by(author, commit = nil)
         FileUtils.chdir(bare_repo_dir) do
           commit ||= '--all'
-          stdout = run %W[git rev-list #{commit} --author #{author} --count]
+          stdout = run %W[git rev-list --author #{author} --count #{commit} --]
           return Integer(stdout)
         end
       end
@@ -105,6 +106,20 @@ module ModuleSync
         end
       end
 
+      def delete_branch(branch)
+        FileUtils.chdir(bare_repo_dir) do
+          run %W{git branch -D #{branch}}
+        end
+      end
+
+      def create_branch(branch, from = nil)
+        from ||= default_branch
+        FileUtils.chdir(tmp_repo_dir) do
+          run %W{git branch -c #{from} #{branch}}
+          run %W{git push --set-upstream origin #{branch}}
+        end
+      end
+
       def remote_url
         "file://#{bare_repo_dir}"
       end

data/spec/spec_helper.rb

@@ -1 +1,3 @@
+require 'simplecov'
+
 require 'modulesync'

data/spec/unit/modulesync/git_service/factory_spec.rb

@@ -0,0 +1,16 @@
+require 'modulesync'
+require 'modulesync/git_service/factory'
+
+describe ModuleSync::GitService::Factory do
+  context 'when instantiate a GitHub service without credentials' do
+    it 'raises an error' do
+      expect { ModuleSync::GitService::Factory.instantiate(type: :github, endpoint: nil, token: nil) }.to raise_error(ModuleSync::GitService::MissingCredentialsError)
+    end
+  end
+
+  context 'when instantiate a GitLab service without credentials' do
+    it 'raises an error' do
+      expect { ModuleSync::GitService::Factory.instantiate(type: :gitlab, endpoint: nil, token: nil) }.to raise_error(ModuleSync::GitService::MissingCredentialsError)
+    end
+  end
+end

data/spec/unit/modulesync/git_service/github_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+require 'modulesync/git_service/github'
+
+describe ModuleSync::GitService::GitHub do
+  context '::open_pull_request' do
+    before(:each) do
+      @client = double()
+      allow(Octokit::Client).to receive(:new).and_return(@client)
+      @it = ModuleSync::GitService::GitHub.new('test', 'https://api.github.com')
+    end
+
+    let(:args) do
+      {
+        repo_path: 'test/modulesync',
+        namespace: 'test',
+        title: 'Test PR is submitted',
+        message: 'Hello world',
+        source_branch: 'test',
+        target_branch: 'master',
+        labels: labels,
+        noop: false,
+      }
+    end
+
+    let(:labels) { [] }
+
+    it 'submits PR when --pr is set' do
+      allow(@client).to receive(:pull_requests)
+        .with(args[:repo_path],
+              :state => 'open',
+              :base => 'master',
+              :head => "#{args[:namespace]}:#{args[:source_branch]}"
+             ).and_return([])
+      expect(@client).to receive(:create_pull_request)
+        .with(args[:repo_path],
+              'master',
+              args[:source_branch],
+              args[:title],
+              args[:message]
+             ).and_return({"html_url" => "http://example.com/pulls/22"})
+      expect { @it.open_pull_request(**args) }.to output(/Submitted PR/).to_stdout
+    end
+
+    it 'skips submitting PR if one has already been issued' do
+      pr = {
+        "title" => "Test title",
+        "html_url" => "https://example.com/pulls/44",
+        "number" => "44"
+      }
+
+      expect(@client).to receive(:pull_requests)
+        .with(args[:repo_path],
+              :state => 'open',
+              :base => 'master',
+              :head => "#{args[:namespace]}:#{args[:source_branch]}"
+             ).and_return([pr])
+      expect { @it.open_pull_request(**args) }.to output("Skipped! 1 PRs found for branch 'test'\n").to_stdout
+    end
+
+    context 'when labels are set' do
+      let(:labels) { %w{HELLO WORLD} }
+
+      it 'adds labels to PR' do
+        allow(@client).to receive(:create_pull_request).and_return({"html_url" => "http://example.com/pulls/22", "number" => "44"})
+        allow(@client).to receive(:pull_requests)
+          .with(args[:repo_path],
+                :state => 'open',
+                :base => 'master',
+                :head => "#{args[:namespace]}:#{args[:source_branch]}"
+               ).and_return([])
+        expect(@client).to receive(:add_labels_to_an_issue)
+          .with(args[:repo_path],
+                "44",
+                ["HELLO", "WORLD"]
+               )
+        expect { @it.open_pull_request(**args) }.to output(/Attaching the following labels to PR 44: HELLO, WORLD/).to_stdout
+      end
+    end
+  end
+end

data/spec/unit/modulesync/git_service/gitlab_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+require 'modulesync/git_service/gitlab'
+
+describe ModuleSync::GitService::GitLab do
+  context '::open_pull_request' do
+    before(:each) do
+      @client = double()
+      allow(Gitlab::Client).to receive(:new).and_return(@client)
+      @it = ModuleSync::GitService::GitLab.new('test', 'https://gitlab.com/api/v4')
+    end
+
+    let(:args) do
+      {
+        repo_path: 'test/modulesync',
+        namespace: 'test',
+        title: 'Test MR is submitted',
+        message: 'Hello world',
+        source_branch: 'test',
+        target_branch: 'master',
+        labels: labels,
+        noop: false,
+      }
+    end
+
+    let(:labels) { [] }
+
+    it 'submits MR when --pr is set' do
+      allow(@client).to receive(:merge_requests)
+        .with(args[:repo_path],
+              :state => 'opened',
+              :source_branch => args[:source_branch],
+              :target_branch => 'master',
+             ).and_return([])
+
+      expect(@client).to receive(:create_merge_request)
+        .with(args[:repo_path],
+              args[:title],
+              :labels => [],
+              :source_branch => args[:source_branch],
+              :target_branch => 'master',
+             ).and_return({"html_url" => "http://example.com/pulls/22"})
+
+      expect { @it.open_pull_request(**args) }.to output(/Submitted MR/).to_stdout
+    end
+
+    it 'skips submitting MR if one has already been issued' do
+      mr = {
+        "title" => "Test title",
+        "html_url" => "https://example.com/pulls/44",
+        "iid" => "44"
+      }
+
+      expect(@client).to receive(:merge_requests)
+        .with(args[:repo_path],
+              :state => 'opened',
+              :source_branch => args[:source_branch],
+              :target_branch => 'master',
+             ).and_return([mr])
+
+      expect { @it.open_pull_request(**args) }.to output("Skipped! 1 MRs found for branch 'test'\n").to_stdout
+    end
+
+    context 'when labels are set' do
+      let(:labels) { %w{HELLO WORLD} }
+
+      it 'adds labels to MR' do
+        mr = double()
+        allow(mr).to receive(:iid).and_return("42")
+
+        expect(@client).to receive(:create_merge_request)
+          .with(args[:repo_path],
+                args[:title],
+                :labels => ["HELLO", "WORLD"],
+                :source_branch => args[:source_branch],
+                :target_branch => 'master',
+               ).and_return(mr)
+
+        allow(@client).to receive(:merge_requests)
+          .with(args[:repo_path],
+                :state => 'opened',
+                :source_branch => args[:source_branch],
+                :target_branch => 'master',
+               ).and_return([])
+
+        expect { @it.open_pull_request(**args) }.to output(/Attached the following labels to MR 42: HELLO, WORLD/).to_stdout
+      end
+    end
+  end
+end