pdksync 0.5.0 → 0.8.0

data/managed_modules.yml

@@ -1,56 +1,39 @@
 ---
-## windows team
-#- puppetlabs-acl
-#- puppetlabs-chocolatey
-#- puppetlabs-dsc
-#- puppetlabs-dsc_lite
-#- puppetlabs-iis
-#- puppetlabs-powershell
-#- puppetlabs-registry
-#- puppetlabs-reboot
-#- puppetlabs-scheduled_task
-#- puppetlabs-sqlserver
-#- puppetlabs-windows
-#- puppetlabs-wsus_client
-## modules team
+## Content and Tooling Team
+#- device_manager
 #- puppetlabs-accounts
+#- puppetlabs-acl
 #- puppetlabs-apache
 #- puppetlabs-apt
-#- puppetlabs-bootstrap
+#- puppetlabs-chocolatey
 #- puppetlabs-concat
+#- puppetlabs-docker
 #- puppetlabs-exec
 #- puppetlabs-facter_task
 #- puppetlabs-firewall
 #- puppetlabs-haproxy
-#- puppetlabs-ibm_installation_manager
+#- puppetlabs-iis
 #- puppetlabs-inifile
 #- puppetlabs-java
 #- puppetlabs-java_ks
+#- puppetlabs-kubernetes
+#- puppetlabs-lvm 
 #- puppetlabs-motd
+#- puppetlabs-mount_iso
 #- puppetlabs-mysql
+#- puppetlabs-node_encrypt 
 #- puppetlabs-ntp
 #- puppetlabs-package
 #- puppetlabs-postgresql
+#- puppetlabs-powershell
 #- puppetlabs-puppet_conf
-#- puppetlabs-resource
+#- puppetlabs-reboot
+#- puppetlabs-registry
 #- puppetlabs-satellite_pe_tools
+#- puppetlabs-scheduled_task
 #- puppetlabs-service
+#- puppetlabs-sqlserver
 #- puppetlabs-stdlib
-#- puppetlabs-tagmail
 #- puppetlabs-tomcat
-#- puppetlabs-translate
 #- puppetlabs-vcsrepo
-#- puppetlabs-websphere_application_server
-## networking team
-#- cisco_ios
-#- device_manager
-#- puppetlabs-panos
-#- puppetlabs-resource_api
-## testing only
-#- puppetlabs-testing
-#- puppetlabs-testing1
-#- puppetlabs-testing2
-## cloud and containers team
-#- puppetlabs-kubernetes
-#- puppetlabs-helm
-#- puppetlabs-rook
+#- puppetlabs-wsus_client

data/pdksync.gemspec

@@ -1,31 +1,34 @@
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pdksync/version'
 
 Gem::Specification.new do |spec|
-  spec.name                  = 'pdksync'
-  spec.version               = '0.5.0'
-  spec.authors               = ['Puppet']
-  spec.email                 = ['']
-  spec.summary               = 'Puppet Module PDK Synchronizer'
-  spec.description           = 'Utility to synchronize common files across puppet modules using PDK Update.'
-  spec.homepage              = 'http://github.com/puppetlabs/pdksync'
-  spec.license               = 'Apache-2.0'
-  spec.required_ruby_version = '>= 2.0.0'
+  spec.name = 'pdksync'
+  spec.version = PdkSync::VERSION
+  spec.authors = ['Puppet']
+  spec.email = ['']
+  spec.summary = 'Puppet Module PDK Synchronizer'
+  spec.description = 'Utility to synchronize common files across puppet modules using PDK Update.'
+  spec.homepage = 'http://github.com/puppetlabs/pdksync'
+  spec.license = 'Apache-2.0'
+  spec.required_ruby_version = '>= 2.7'
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'codecov'
+  spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'rubocop', '~> 0.50.0'
-  spec.add_development_dependency 'pry'
-
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'simplecov-console'
+  spec.add_runtime_dependency 'pdk', '>= 1.14.1'
   spec.add_runtime_dependency 'git', '~>1.3'
-  spec.add_runtime_dependency 'pdk', '>= 1.4.1'
   spec.add_runtime_dependency 'rake'
   spec.add_runtime_dependency 'gitlab'
   spec.add_runtime_dependency 'octokit'
-  spec.add_runtime_dependency 'colorize'
+  spec.add_runtime_dependency 'jenkins_api_client'
 end

data/spec/configuration_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'pdksync/configuration'
+
+RSpec.describe 'configuration' do
+  before(:each) do
+    allow(ENV).to receive(:[]).with('HOME').and_return('./')
+    allow(ENV).to receive(:[]).with('GITHUB_TOKEN').and_return('blah')
+    allow(ENV).to receive(:[]).with('PDKSYNC_CONFIG_PATH').and_return(nil)
+  end
+
+  let(:instance) do
+    PdkSync::Configuration.new
+  end
+
+  it '#new' do
+    expect(instance).to be_a PdkSync::Configuration
+  end
+
+  it 'passes when token is provided' do
+    expect(instance).to be_a PdkSync::Configuration
+  end
+
+  it 'raises error without token' do
+    allow(ENV).to receive(:[]).with('GITHUB_TOKEN').and_return(nil)
+    expect { instance }.to raise_error(ArgumentError)
+  end
+
+  it '#custom_config' do
+    expect(instance.custom_config).to be_a Hash
+  end
+
+  it '#custom_config does not exist' do
+    expect(instance.custom_config('/tmp/blah')).to be_a Hash
+  end
+
+  it '#custom_config exists' do
+    config = File.join(fixtures_dir, 'pdksync.yml')
+    data = instance.custom_config(config)
+    expect(data).to be_a Hash
+    expect(data[:namespace]).to eq('voxpupuli')
+  end
+
+  it '#locate_config_path' do
+    expect(instance.local_config_path).to be_nil
+  end
+
+  it '#locate_config_path with value' do
+    config = File.join(fixtures_dir, 'pdksync.yml')
+    expect(instance.locate_config_path(config)).to eq(config)
+  end
+
+  it 'gets a different config file path when variable is used' do
+    allow(ENV).to receive(:[]).with('PDKSYNC_CONFIG_PATH').and_return(File.join(fixtures_dir, 'pdksync.yml'))
+    expect(instance.locate_config_path(ENV['PDKSYNC_CONFIG_PATH'])).to eq(File.join(fixtures_dir, 'pdksync.yml'))
+  end
+end

data/spec/fixtures/fake_managed_modules.yaml

@@ -0,0 +1,2 @@
+---
+- puppetlabs/puppetlabs-motd

data/spec/fixtures/pdksync.yml

@@ -0,0 +1,2 @@
+---
+namespace: voxpupuli

data/spec/logger_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'pdksync/logger'
+
+RSpec.describe 'logger' do
+  before(:each) do
+    allow(ENV).to receive(:[]).with('PDKSYNC_LOG_FILENAME').and_return('dev/')
+    allow(ENV).to receive(:[]).with('LOG_LEVEL').and_return(nil)
+    # allow(PdkSync::Logger).to receive(:logger).and_return(PdkSync::Logger.logger($stderr))
+  end
+
+  let(:logger) do
+    PdkSync::Logger.instance_variable_set('@logger', nil)
+    PdkSync::Logger.logger
+  end
+
+  it '#self.logger' do
+    expect(PdkSync::Logger.logger).to be_a Logger
+  end
+
+  it '#self.debug' do
+    allow(ENV).to receive(:[]).with('LOG_LEVEL').and_return('debug')
+    expect(logger.debug('this is a debug')).to be_truthy
+    # wasn't able to capture stdout with rspec, no idea why
+    # expect { logger.debug("this is a debug") }.to output(/DEBUG - PdkSync: this is a debug/).to_stdout
+  end
+
+  it '#self.warn' do
+    allow(ENV).to receive(:[]).with('LOG_LEVEL').and_return('warn')
+    # wasn't able to capture stdout with rspec, no idea why
+    expect(logger.warn('this is a warning')).to be_truthy # output(/WARN - PdkSync: this is a warning/).to_stdout
+  end
+
+  it '#self.info' do
+    allow(ENV).to receive(:[]).with('LOG_LEVEL').and_return('info')
+    # wasn't able to capture stdout with rspec, no idea why
+    expect(logger.info('this is a info')).to be_truthy # output(/INFO - PdkSync: this is a info/).to_stderr
+  end
+
+  it '#self.fatal' do
+    allow(ENV).to receive(:[]).with('LOG_LEVEL').and_return('error')
+    # wasn't able to capture stdout with rspec, no idea why
+    expect(logger.fatal('this is a fatal')).to be_truthy # output(/FATAL - PdkSync: this is a fatal/).to_stderr
+  end
+end

data/spec/pdksync_spec.rb

@@ -0,0 +1,185 @@
+require 'pdksync'
+require 'spec_helper'
+require 'git'
+require 'fileutils'
+require 'octokit'
+
+describe PdkSync do
+  before(:all) do
+    @pdksync_dir = './modules_pdksync'
+    @pdksync_gem_dir = './gems_pdksync'
+    module_name = 'puppetlabs-motd'
+    gem_name = 'puppet-strings'
+    @module_names = ['puppetlabs-motd']
+    @output_path_module = "#{@pdksync_dir}/#{module_name}"
+    @output_path_gem = "#{@pdksync_gem_dir}/#{gem_name}"
+    @folder = Dir.pwd
+    # Make changes to modules_managed.yaml file
+    text = File.read('managed_modules.yml')
+    new_contents = text.gsub(%r{#- puppetlabs-motd$}, '- puppetlabs-motd')
+    File.open('managed_modules.yml', 'w') { |file| file.puts new_contents }
+  end
+
+  let(:platform) { Object.new }
+
+  before(:each) do
+    allow(ENV).to receive(:[]).with('HOME').and_return('./')
+    allow(ENV).to receive(:[]).with('GIT_DIR').and_return(nil)
+    allow(ENV).to receive(:[]).with('GIT_WORK_TREE').and_return(nil)
+    allow(ENV).to receive(:[]).with('GIT_INDEX_FILE').and_return(nil)
+    allow(ENV).to receive(:[]).with('PDKSYNC_LOG_FILENAME').and_return(nil)
+    allow(ENV).to receive(:[]).with('LOG_LEVEL').and_return(nil)
+    allow(ENV).to receive(:[]).with('GIT_SSH').and_return(nil)
+    allow(ENV).to receive(:[]).with('GIT_PATH').and_return(nil)
+    allow(ENV).to receive(:[]).with('GITHUB_TOKEN').and_return('blah')
+    allow(ENV).to receive(:[]).with('GEMFURY_TOKEN').and_return('blah')
+    allow(ENV).to receive(:[]).with('PDKSYNC_VERSION_CHECK').and_return(nil)
+    allow(ENV).to receive(:[]).with('http_proxy').and_return(nil)
+    allow(ENV).to receive(:[]).with('HTTP_PROXY').and_return(nil)
+    allow(ENV).to receive(:[]).with('PDKSYNC_CONFIG_PATH').and_return(nil)
+    allow(ENV).to receive(:[]).with('TERM').and_return(nil)
+    allow(ENV).to receive(:[]).with('NO_COLOR').and_return(nil)
+    allow(PdkSync::Utils).to receive(:return_modules).and_return(@module_names)
+    allow(PdkSync::Utils).to receive(:validate_modules_exist).and_return(@module_names)
+    allow(PdkSync::Utils).to receive(:setup_client).and_return(git_client)
+    Dir.chdir(@folder)
+    allow(PdkSync::GitPlatformClient).to receive(:new).and_return(platform)
+    allow(Octokit).to receive(:tags).with('puppetlabs/pdk').and_return([{ name: '1' }])
+    allow(PdkSync::Utils.configuration).to receive(:git_base_uri).and_return('https://github.com')
+  end
+
+  let(:git_client) do
+    double(PdkSync::GitPlatformClient)
+  end
+
+  context 'main method' do
+    it 'runs clone sucessfully' do
+      allow(PdkSync::Utils).to receive(:setup_client).and_return(git_client)
+      FileUtils.rm_rf(@pdksync_dir)
+      PdkSync::Utils.create_filespace
+      PdkSync.main(steps: [:clone])
+      expect(Dir.exist?(@pdksync_dir)).to be(true)
+      expect(Dir.exist?(@output_path_module)).to be(true)
+    end
+
+    it 'runs pdk convert, and files have changed' do
+      PdkSync.main(steps: [:pdk_convert])
+      File.exist?("#{@output_path_module}/convert_report.txt")
+    end
+
+    it 'raise when running a command with no argument' do
+      expect { PdkSync.main(steps: [:run_a_command]) }.to raise_error(RuntimeError, %r{"run_a_command" requires an argument to run.})
+    end
+
+    it 'runs a command "touch cat.meow"' do
+      PdkSync.main(steps: [:run_a_command], args: { command: 'touch cat.meow' })
+      expect File.exist?("#{@output_path_module}/cat.meow")
+    end
+
+    it 'raise when create_commit with no arguments' do
+      expect { PdkSync.main(steps: [:create_commit]) }.to raise_error(RuntimeError, %r{Needs a branch_name and commit_message})
+    end
+
+    it 'raise when create_pr with no arguments' do
+      expect { PdkSync.main(steps: [:create_pr]) }.to raise_error(RuntimeError, %r{Needs a pr_title})
+    end
+
+    it 'create_pr with 1 argument' do
+      expect { PdkSync.main(steps: [:create_pr], args: { pr_title: 'some title' }) }.to_not raise_error
+    end
+
+    it 'raise when clean_branches with no arguments' do
+      expect { PdkSync.main(steps: [:clean_branches]) }.to raise_error(RuntimeError, %r{Needs a branch_name, and the branch name contains the string pdksync})
+    end
+
+    it 'raise when gem_file_update with no arguments' do
+      expect { PdkSync.main(steps: [:gem_file_update]) }.to raise_error(NoMethodError)
+    end
+    it 'gem_file_update runs with invalid gem_line given' do
+      expect { PdkSync.main(steps: [:gem_file_update], args: { gem_to_test: 'puppet_litmus', gem_line: "gem 'puppet_litmus'\, git: 'https://github.com/test/puppet_litmus.git'" }) }. to raise_error(Errno::ENOENT) # rubocop:disable Metrics/LineLength
+    end
+    it 'gem_file_update runs with invalid gem_sha_replacer' do
+      expect { PdkSync.main(steps: [:gem_file_update], args: { gem_to_test: 'puppet_litmus', gem_sha_finder: 'jsjsjsjsjsjsjs', gem_sha_replacer: 'abcdefgjhkk' }) }.to raise_error(RuntimeError) # , ("Couldn't find sha: abcdefgjhkk in your repository: puppet_litmus")) # rubocop:disable Metrics/LineLength
+    end
+    it 'gem_file_update runs with invalid gem_version_replacer' do
+      expect { PdkSync.main(steps: [:gem_file_update], args: { gem_to_test: 'puppet_litmus', gem_version_finder: '<= 0.4.9', gem_version_replacer: '<= 1.4.11' }) }.to raise_error(RuntimeError) # , ("Couldn't find version: 1.4.11 in your repository: puppet_litmus")) # rubocop:disable Metrics/LineLength
+    end
+    it 'gem_file_update runs with invalid gem_branch_replacer' do
+      expect { PdkSync.main(steps: [:gem_file_update], args: { gem_to_test: 'puppet_litmus', gem_branch_finder: 'jsjsjsjsjsjsjs', gem_branch_replacer: 'abcdefgjhkk' }) }.to raise_error(RuntimeError) # , "Couldn't find branch: abcdefgjhkk in your repository: puppet_litmus") # rubocop:disable Metrics/LineLength
+    end
+    it 'raise when run_tests with no arguments' do
+      expect { PdkSync.main(steps: [:run_tests_locally]) }.to raise_error(NoMethodError) # , %r{run_tests" requires arguments (module_type) to run.})
+    end
+    it 'raise when run_tests_jenkins with no arguments' do
+      allow(ENV).to receive(:[]).with('JENKINS_USERNAME').and_return('JENKINS_USERNAME')
+      allow(ENV).to receive(:[]).with('JENKINS_PASSWORD').and_return('JENKINS_PASSWORD')
+      expect { PdkSync.main(steps: [:run_tests_jenkins], args: {}) }.to raise_error(RuntimeError) # , "run_tests_jenkins requires arguments (github_repo, github_branch) to run"
+    end
+    it 'raise errors without jenkins credentials' do
+      allow(ENV).to receive(:[]).with('JENKINS_USERNAME').and_return(nil)
+      allow(ENV).to receive(:[]).with('JENKINS_PASSWORD').and_return(nil)
+      expect { PdkSync.main(steps: [:run_tests_jenkins], args: { jenkins_server_url: 'https//jenkins.com', github_repo: 'test', github_branch: 'test' }) }.to raise_error(RuntimeError, %r{Jenkins access token for Jenkins not set})
+    end
+
+    describe 'gem_file_update with valid values' do
+      before(:all) do
+        PdkSync.main(steps: [:gem_file_update], args: {
+                       gem_to_test: 'puppet_litmus',
+                       gem_line: "gem 'puppet_litmus'\, git: 'https://github.com/puppetlabs/puppet_litmus.git'\, branch: 'main'\, ref: '04da90638f5b5fd7f007123c8c0cc551c8cb3e54'\, '=0.1.0'"
+                     })
+      end
+      it 'gem_file_update with valid gem_branch_replacer' do
+        PdkSync.main(steps: [:gem_file_update], args: { gem_to_test: 'puppet_litmus',
+                                                        gem_branch_finder: 'master', gem_branch_replacer: 'main' })
+        expect(File.read('Gemfile')).to match(%r{main})
+      end
+      it 'gem_file_update runs, and contains the gem_sha given' do
+        PdkSync.main(steps: [:gem_file_update], args: { gem_to_test: 'puppet_litmus',
+                                                        gem_sha_finder: '04da90638f5b5fd7f007123c8c0cc551c8cb3e54', gem_sha_replacer: '95ed1c62ffcf89003eb0fe9d66989caa45884538' })
+        expect(File.read('Gemfile')).to match(%r{95ed1c62ffcf89003eb0fe9d66989caa45884538})
+      end
+      it 'gem_file_update runs, and contains the gem_version given' do
+        PdkSync.main(steps: [:gem_file_update], args: { gem_to_test: 'puppet_litmus',
+                                                        gem_version_finder: '=0.1.0', gem_version_replacer: '<=0.3.0' })
+        expect(File.read('Gemfile')).to match(%r{0.3.0})
+      end
+      it 'gem_file_update with valid gem_line' do
+        PdkSync.main(steps: [:gem_file_update], args: { gem_to_test: 'puppet_litmus',
+                                                        gem_line: "gem 'puppet_litmus'\, git: 'https://github.com/puppetlabs/puppet_litmus.git'" })
+        expect(File.read('Gemfile')).to match(%r{gem 'puppet_litmus', git: 'https://github.com/puppetlabs/puppet_litmus.git'})
+      end
+      it 'multigem updated in the module gemfile' do
+        PdkSync.main(steps: [:multi_gemfile_update], args: { gem_name: 'puppet-module', gemfury_username: 'tester' })
+        expect File.exist?("#{@output_path_module}/Gemfile")
+      end
+    end
+  end
+  context 'main method' do
+    let(:platform) { Object.new }
+
+    it 'runs clone gem sucessfully' do
+      allow(PdkSync::Utils).to receive(:setup_client).and_return(git_client)
+      FileUtils.rm_rf(@pdksync_gem_dir)
+      PdkSync::Utils.create_filespace_gem
+      PdkSync.main(steps: [:clone_gem], args: { gem_name: 'puppet-strings' })
+      expect(Dir.exist?(@pdksync_dir)).to be(true)
+      expect(Dir.exist?(@pdksync_gem_dir)).to be(true)
+      expect(Dir.exist?(@output_path_gem)).to be(true)
+    end
+    it 'raise when running a command with no argument' do
+      expect { PdkSync.main(steps: [:multi_gem_testing]) }.to raise_error(RuntimeError, %r{"multi_gem_testing" requires arguments to run version_file and build_gem})
+    end
+    it 'runs a command for updating the version and building the gem' do
+      allow(Octokit).to receive(:tags).with('puppetlabs/puppet-strings').and_return([{ name: '1' }])
+      PdkSync.main(steps: [:multi_gem_testing], args: { gem_name: 'puppet-strings', version_file: 'lib/puppet-strings/version.rb', build_gem: 'rake build', gem_path: 'pkg', gem_username: 'tester' })
+      expect File.exist?("#{@output_path_gem}/pkg")
+    end
+  end
+  after(:all) do
+    # Make changes to modules_managed.yaml file
+    Dir.chdir(@folder)
+    text = File.read('managed_modules.yml')
+    new_contents = text.gsub(%r{- puppetlabs-motd$}, '#- puppetlabs-motd')
+    File.open('managed_modules.yml', 'w') { |file| file.puts new_contents }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+if ENV['SIMPLECOV'] == 'yes'
+  begin
+    require 'simplecov'
+    require 'simplecov-console'
+    require 'codecov'
+
+    SimpleCov.formatters = [
+      SimpleCov::Formatter::HTMLFormatter,
+      SimpleCov::Formatter::Console,
+      SimpleCov::Formatter::Codecov
+    ]
+    SimpleCov.start do
+      track_files 'lib/**/*.rb'
+      add_filter '/spec'
+
+      # do not track vendored files
+      add_filter '/vendor'
+      add_filter '/.vendor'
+
+      # do not track gitignored files
+      # this adds about 4 seconds to the coverage check
+      # this could definitely be optimized
+      add_filter do |f|
+        # system returns true if exit status is 0, which with git-check-ignore means file is ignored
+        system("git check-ignore --quiet #{f.filename}")
+      end
+    end
+  rescue LoadError
+    raise 'Add the simplecov, simplecov-console, codecov gems to Gemfile to enable this task'
+  end
+end
+
+require 'rspec'
+require 'git'
+require 'fileutils'
+
+def pupmods_dir
+  @pupmods_dir ||= begin
+    p = File.join(fixtures_dir, 'puppetlabs')
+    FileUtils.mkdir_p(p) unless File.exist?(p)
+    p
+  end
+end
+
+def remote_testing_repo
+  File.join(pupmods_dir, 'puppetlabs-motd.git')
+end
+
+# localizes the remote repo for faster testing, download once and use the local machine as the remote repo
+def setup_fake_module
+  Git.clone('https://github.com/puppetlabs/puppetlabs-motd.git', remote_testing_repo) unless Dir.exist?(File.join(remote_testing_repo, '.git'))
+end
+
+def destroy_fake_modules
+  FileUtils.rm_rf(pupmods_dir)
+end
+
+def fixtures_dir
+  @fixtures_dir ||= File.join(__dir__, 'fixtures')
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    setup_fake_module
+    # provide a fake github token for the tests
+    ENV['GITHUB_TOKEN'] = 'github-token'
+  end
+  config.before(:each) do
+    allow(PdkSync::Utils.configuration).to receive(:git_base_uri).and_return("file://#{fixtures_dir}")
+  end
+  config.after(:suite) { FileUtils.rm_rf(pupmods_dir) }
+end

data/spec/utils_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'pdksync/utils'
+require 'tempfile'
+
+describe 'PdkSync::Utils' do
+  before(:all) do
+    @tmp_dir = Dir.mktmpdir('testing')
+  end
+
+  let(:cloned_module) do
+    begin
+      Git.open(@tmp_dir)
+    rescue ArgumentError
+      PdkSync::Utils.clone_directory('puppetlabs',
+                                     'puppetlabs-motd', @tmp_dir)
+    end
+  end
+
+  let(:metadata_file) do
+    File.join(@tmp_dir, 'metadata.json')
+  end
+
+  before(:each) do
+    cloned_module
+    cloned_module.config('user.name', 'puppetlabs')
+    cloned_module.config('user.email', 'email@email.com')
+  end
+
+  after(:all) do
+    FileUtils.remove_entry @tmp_dir
+  end
+
+  it '#self.clone_directory' do
+    Dir.mktmpdir do |dir|
+      PdkSync::Utils.clone_directory('puppetlabs',
+                                     'puppetlabs-motd', dir)
+      expect(cloned_module).to be_a Git::Base
+    end
+  end
+
+  it '#self.create_commit' do
+    File.write(File.join(@tmp_dir, 'README.md'), rand(32_332))
+    expect(PdkSync::Utils.create_commit(cloned_module, 'main', 'boom')).to match(%r{1 file changed})
+  end
+
+  it '#self.run_command' do
+    expect(PdkSync::Utils.run_command('./', 'pwd', nil)).to eq(0)
+  end
+
+  it '#self.pdk_update' do
+    expect(PdkSync::Utils.pdk_update(@tmp_dir)).to eq(0)
+  end
+
+  it '#self.return_template_ref' do
+    expect(PdkSync::Utils.return_template_ref(metadata_file)).to match(%r{heads/main-0-|tags/})
+  end
+
+  it '#self.module_templates_url' do
+    allow(Octokit).to receive(:tags).with('puppetlabs/pdk').and_return([{ name: 'v1.14.1' }])
+    url, version = PdkSync::Utils.module_templates_url(metadata_file).split('#')
+    expect(url).to eq('https://github.com/puppetlabs/pdk-templates.git')
+    expect(version).to match(%r{main})
+  end
+
+  it '#self.change_module_template_url' do
+    url = 'https://github.com/nwops/pdk-templates'
+    ref = 'special'
+    expect(PdkSync::Utils.change_module_template_url(url, ref, metadata_file)).to eq('https://github.com/nwops/pdk-templates#special')
+  end
+
+  it '#self.checkout_branch' do
+    PdkSync::Utils.checkout_branch(cloned_module, 'sync1234')
+    branch = cloned_module.branches.find { |b| b.name.eql?('pdksync_sync1234') }
+    expect(branch).to be_a Git::Branch
+  end
+
+  it '#self.check_pdk_version is false' do
+    process = double
+    allow(process).to receive(:exitstatus).and_return(true)
+    allow(Octokit).to receive(:tags).with('puppetlabs/pdk').and_return([{ name: 'v1.14.1' }])
+    allow(PdkSync::Utils).to receive(:return_pdk_path).and_return('/opt/puppetlabs/pdk/bin/pdk')
+    allow(Open3).to receive(:capture3).with('/opt/puppetlabs/pdk/bin/pdk --version').and_return(['1.14.0', nil, process])
+    expect(PdkSync::Utils.check_pdk_version).to be false
+  end
+
+  it '#self.check_pdk_version is true' do
+    process = double
+    allow(process).to receive(:exitstatus).and_return(true)
+    allow(PdkSync::Utils).to receive(:return_pdk_path).and_return('/opt/puppetlabs/pdk/bin/pdk')
+    allow(Open3).to receive(:capture3).with('/opt/puppetlabs/pdk/bin/pdk --version').and_return(['1.14.0', nil, process])
+    allow(Octokit).to receive(:tags).with('puppetlabs/pdk').and_return([{ name: 'v1.14.0' }])
+    expect(PdkSync::Utils.check_pdk_version).to be true
+  end
+
+  it '#self.check_gem_latest_version' do
+    process = double
+    allow(process).to receive(:exitstatus).and_return(true)
+    allow(Octokit).to receive(:tags).with('puppetlabs/puppet_module_gems').and_return([{ name: '0.4.0' }])
+    expect(PdkSync::Utils.check_gem_latest_version('puppet_module_gems')).to eq '0.4.0'
+  end
+
+  it '#self.update_gem_latest_version_by_one' do
+    expect(PdkSync::Utils.update_gem_latest_version_by_one('0.4.0')).to eq Gem::Version.new('0.5')
+  end
+
+  it '#self.create_filespace' do
+    expect(PdkSync::Utils.create_filespace).to eq('modules_pdksync')
+  end
+
+  it '#self.setup_client' do
+    g = double(PdkSync::GitPlatformClient)
+    expect(PdkSync::GitPlatformClient).to receive(:new).with(:github,
+                                                             {access_token: 'github-token',
+                                                             api_endpoint: nil,
+                                                             gitlab_api_endpoint: 'https://gitlab.com/api/v4'}).and_return(g)
+    expect(PdkSync::Utils.setup_client).to eq(g)
+  end
+
+  it '#self.return_modules' do
+    allow_any_instance_of(PdkSync::Configuration).to receive(:managed_modules).and_return(File.join(fixtures_dir, 'fake_managed_modules.yaml'))
+    expect(PdkSync::Utils.return_modules).to eq(['puppetlabs/puppetlabs-motd'])
+  end
+
+  it '#self.validate_modules_exist' do
+    client = double
+    allow_any_instance_of(PdkSync::Configuration).to receive(:managed_modules).and_return(File.join(fixtures_dir, 'fake_managed_modules.yaml'))
+    allow(client).to receive(:repository?).with('puppetlabs/puppetlabs-motd').and_return(true)
+    expect(PdkSync::Utils.validate_modules_exist(client, ['puppetlabs-motd'])).to be true
+  end
+
+  it '#self.create_filespace_gem' do
+    expect(PdkSync::Utils.create_filespace_gem).to eq('gems_pdksync')
+  end
+end