nucleus 0.2.0 → 0.3.1

data/lib/nucleus/scripts/initialize_config_defaults.rb

@@ -1,26 +1,26 @@
-# Check the API versions once and make them available via configatron
-nucleus_config.api.versions = Nucleus::VersionDetector.api_versions
-
-# make sure the key is always set
-key_file = nil
-if nucleus_config.ssh.key?(:custom_key) && !nucleus_config.ssh.custom_key.nil?
-  puts "Loading custom SSH key #{nucleus_config.ssh.custom_key}"
-  # use the custom key file
-  key_file = nucleus_config.ssh.custom_key
-
-  # fail if file does not exist
-  unless File.exist?(key_file)
-    msg = "Could not find the SSH key: '#{key_file}'"
-    STDERR.puts msg
-    fail Nucleus::StartupError.new(msg, Nucleus::ExitCodes::INVALID_SSH_KEY_FILE)
-  end
-
-  if File.read(key_file).include?('ENCRYPTED')
-    msg = "Provided private key '#{key_file}' must not be protected with a passphrase."
-    STDERR.puts msg
-    fail Nucleus::StartupError.new(msg, Nucleus::ExitCodes::INVALID_SSH_KEY_FILE_PROTECTED)
-  end
-end
-
-# now setup the SSHHandler
-nucleus_config.ssh.handler = Nucleus::SSHHandler.new(key_file)
+# Check the API versions once and make them available via configatron
+nucleus_config.api.versions = Nucleus::VersionDetector.api_versions
+
+# make sure the key is always set
+key_file = nil
+if nucleus_config.ssh.key?(:custom_key) && !nucleus_config.ssh.custom_key.nil?
+  puts "Loading custom SSH key #{nucleus_config.ssh.custom_key}"
+  # use the custom key file
+  key_file = nucleus_config.ssh.custom_key
+
+  # fail if file does not exist
+  unless File.exist?(key_file)
+    msg = "Could not find the SSH key: '#{key_file}'"
+    STDERR.puts msg
+    raise Nucleus::StartupError.new(msg, Nucleus::ExitCodes::INVALID_SSH_KEY_FILE)
+  end
+
+  if File.read(key_file).include?('ENCRYPTED')
+    msg = "Provided private key '#{key_file}' must not be protected with a passphrase."
+    STDERR.puts msg
+    raise Nucleus::StartupError.new(msg, Nucleus::ExitCodes::INVALID_SSH_KEY_FILE_PROTECTED)
+  end
+end
+
+# now setup the SSHHandler
+nucleus_config.ssh.handler = Nucleus::SSHHandler.new(key_file)

data/lib/nucleus/version.rb

@@ -1,3 +1,3 @@
 module Nucleus
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.3.1'.freeze
 end

data/nucleus.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
 
   # we ignore the test files and icons as they tremendously increase the gem size (up to 43MB)
   spec.files = `git ls-files -z --exclude-standard`.split("\x0").reject do |f|
-    f[%r{^(lib/nucleus_api|spec/adapter|icons)/}]
+    f[%r{^(lib/nucleus_api|spec/adapter|icons|docs)/}]
   end
   # again only unit and integration, but no adapter test files
   spec.test_files = spec.files.grep(%r{^(spec)/})
@@ -79,7 +79,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'guard-yard'
   spec.add_development_dependency 'inch', '~> 0.7'
   spec.add_development_dependency 'rake', '~> 10.4'
-  spec.add_development_dependency 'rubocop', '~> 0.36.0'
+  spec.add_development_dependency 'rubocop', '~> 0.37.2'
   spec.add_development_dependency 'vcr', '~> 3.0'
   spec.add_development_dependency 'webmock', '~> 1.20'
   spec.add_development_dependency 'yard', '~> 0.8'

data/spec/integration/api/auth_spec.rb

@@ -31,17 +31,17 @@ describe Nucleus::API::V1::Auth do
 
       allow_any_instance_of(Nucleus::Adapters::V1::Heroku).to receive(:applications).and_wrap_original do |m, _|
         unless m.receiver.send(:headers)['Authorization'] == 'bearer 1234567890'
-          fail Nucleus::Errors::EndpointAuthenticationError, 'Bad authentication credentials'
+          raise Nucleus::Errors::EndpointAuthenticationError, 'Bad authentication credentials'
         end
         []
       end
       call_count = 0
       allow_any_instance_of(Nucleus::Adapters::V1::CloudFoundryV2).to receive(:applications).and_wrap_original do |m, _|
         unless m.receiver.send(:headers)['Authorization'] == 'bearer 0987654321'
-          fail Nucleus::Errors::EndpointAuthenticationError, 'Bad authentication credentials'
+          raise Nucleus::Errors::EndpointAuthenticationError, 'Bad authentication credentials'
         end
         call_count += 1
-        fail Nucleus::Errors::EndpointAuthenticationError, 'Fail 1st attempt' if call_count == 1
+        raise Nucleus::Errors::EndpointAuthenticationError, 'Fail 1st attempt' if call_count == 1
         []
       end
     end

data/spec/spec_helper.rb

@@ -1,98 +1,98 @@
-$LOAD_PATH << File.join(__dir__, '..')
-
-# figure out where we are being loaded from
-if $LOADED_FEATURES.grep(%r{spec\/spec_helper\.rb}).any?
-  begin
-    fail 'foo'
-  rescue => e
-    puts <<-MSG
-  ===================================================
-  It looks like spec_helper.rb has been loaded
-  multiple times. Normalize the require to:
-
-    require "spec/spec_helper"
-
-  Things like File.join and File.expand_path will
-  cause it to be loaded multiple times.
-
-  Loaded this time from:
-
-    #{e.backtrace.join("\n    ")}
-  ===================================================
-    MSG
-  end
-end
-
-require 'vcr'
-require 'factory_girl'
-require 'faker'
-require 'tmpdir'
-
-# we need this to detect whether to apply test middleware (tailing hack)
-ENV['RACK_ENV'] = 'test'
-
-if ENV['CODECLIMATE_REPO_TOKEN']
-  require 'simplecov'
-  require 'codeclimate-test-reporter'
-  SimpleCov.add_filter 'vendor'
-  SimpleCov.formatters = []
-  # merge results of the last 1 hour
-  SimpleCov.merge_timeout 3600
-  SimpleCov.start CodeClimate::TestReporter.configuration.profile
-else
-  require 'simplecov'
-  # merge results of the last 1 hour
-  SimpleCov.merge_timeout 3600
-  SimpleCov.start do
-    add_filter 'spec/'
-    add_filter 'lib/nucleus/scripts/'
-    add_filter 'config/'
-
-    add_group 'Adapters', 'lib/nucleus/adapters'
-    add_group 'Core', 'lib/nucleus/core'
-    add_group 'Persistence', 'lib/nucleus/persistence'
-    add_group 'Lib ext.', 'lib/nucleus/ext'
-    add_group 'API versions', 'lib/nucleus_api/api/versions'
-    add_group 'API entities', 'lib/nucleus_api/api/entities'
-    add_group 'API helpers', 'lib/nucleus_api/api/helpers'
-    add_group 'API Middleware', 'lib/nucleus_api/rack_middleware'
-    add_group 'API Models', 'lib/nucleus_api/models'
-    add_group 'API Lib ext.', 'lib/nucleus_api/ext'
-  end
-end
-
-# load configuration for integration tests
-require 'nucleus/scripts/setup_config'
-# disable logging
-# TODO: disable logging via proper config option
-nucleus_config.logging.level = Logger::Severity::FATAL
-# force tmp database
-nucleus_config.db.path = File.join(Dir.tmpdir, "#{SecureRandom.uuid}.nucleus.test.store")
-nucleus_config.db.delete_on_shutdown = true
-nucleus_config.db.override = true
-
-# require our app
-require 'nucleus_api/scripts/load_api'
-
-# load the certificate to use for the tests only
-nucleus_config.ssh.custom_key = File.expand_path(File.join('spec', 'nucleus_git_key.pem'))
-
-# initialize db, versions and auth strategy
-require 'nucleus/scripts/initialize_config_defaults'
-# initialize the api config
-require 'nucleus_api/scripts/initialize_api_customizations'
-
-require 'spec/factories/models'
-
-# require shared examples
-require_all 'spec/support'
-
-RSpec.configure do |config|
-  config.include FactoryGirl::Syntax::Methods
-  config.before(:suite) do
-    Excon.defaults[:mock] = true
-  end
-  config.after(:each) do
-    Excon.stubs.clear
-  end
-end
+$LOAD_PATH << File.join(__dir__, '..')
+
+# figure out where we are being loaded from
+if $LOADED_FEATURES.grep(%r{spec\/spec_helper\.rb}).any?
+  begin
+    raise 'foo'
+  rescue => e
+    puts <<-MSG
+  ===================================================
+  It looks like spec_helper.rb has been loaded
+  multiple times. Normalize the require to:
+
+    require "spec/spec_helper"
+
+  Things like File.join and File.expand_path will
+  cause it to be loaded multiple times.
+
+  Loaded this time from:
+
+    #{e.backtrace.join("\n    ")}
+  ===================================================
+    MSG
+  end
+end
+
+require 'vcr'
+require 'factory_girl'
+require 'faker'
+require 'tmpdir'
+
+# we need this to detect whether to apply test middleware (tailing hack)
+ENV['RACK_ENV'] = 'test'
+
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require 'simplecov'
+  require 'codeclimate-test-reporter'
+  SimpleCov.add_filter 'vendor'
+  SimpleCov.formatters = []
+  # merge results of the last 1 hour
+  SimpleCov.merge_timeout 3600
+  SimpleCov.start CodeClimate::TestReporter.configuration.profile
+else
+  require 'simplecov'
+  # merge results of the last 1 hour
+  SimpleCov.merge_timeout 3600
+  SimpleCov.start do
+    add_filter 'spec/'
+    add_filter 'lib/nucleus/scripts/'
+    add_filter 'config/'
+
+    add_group 'Adapters', 'lib/nucleus/adapters'
+    add_group 'Core', 'lib/nucleus/core'
+    add_group 'Persistence', 'lib/nucleus/persistence'
+    add_group 'Lib ext.', 'lib/nucleus/ext'
+    add_group 'API versions', 'lib/nucleus_api/api/versions'
+    add_group 'API entities', 'lib/nucleus_api/api/entities'
+    add_group 'API helpers', 'lib/nucleus_api/api/helpers'
+    add_group 'API Middleware', 'lib/nucleus_api/rack_middleware'
+    add_group 'API Models', 'lib/nucleus_api/models'
+    add_group 'API Lib ext.', 'lib/nucleus_api/ext'
+  end
+end
+
+# load configuration for integration tests
+require 'nucleus/scripts/setup_config'
+# disable logging
+# TODO: disable logging via proper config option
+nucleus_config.logging.level = Logger::Severity::FATAL
+# force tmp database
+nucleus_config.db.path = File.join(Dir.tmpdir, "#{SecureRandom.uuid}.nucleus.test.store")
+nucleus_config.db.delete_on_shutdown = true
+nucleus_config.db.override = true
+
+# require our app
+require 'nucleus_api/scripts/load_api'
+
+# load the certificate to use for the tests only
+nucleus_config.ssh.custom_key = File.expand_path(File.join('spec', 'nucleus_git_key.pem'))
+
+# initialize db, versions and auth strategy
+require 'nucleus/scripts/initialize_config_defaults'
+# initialize the api config
+require 'nucleus_api/scripts/initialize_api_customizations'
+
+require 'spec/factories/models'
+
+# require shared examples
+require_all 'spec/support'
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+  config.before(:suite) do
+    Excon.defaults[:mock] = true
+  end
+  config.after(:each) do
+    Excon.stubs.clear
+  end
+end

data/spec/test_suites.rake

@@ -25,7 +25,7 @@ namespace :spec do
         Rake::Task["spec:suite:#{suite[:id]}"].execute
         failed << suite[:id] unless $CHILD_STATUS.success?
       end
-      fail "Spec suite#{failed.length > 1 ? 's' : ''} '#{failed.join(', ')}' failed" unless failed.empty?
+      raise "Spec suite#{failed.length > 1 ? 's' : ''} '#{failed.join(', ')}' failed" unless failed.empty?
     end
   end
 end

data/spec/unit/adapters/git_deployer_spec.rb

@@ -1,262 +1,262 @@
-require 'spec/unit/unit_spec_helper'
-
-describe Nucleus::Adapters::GitDeployer do
-  let(:repo_name) { 'my_repository' }
-  let(:repo_url) { 'http://repo.example.org' }
-  let(:user_email) { 'myuser@example.org' }
-  let(:repo) { double(Git::Base) }
-  let(:zip) { 'zip' }
-  let(:file) { File.join('random', 'file', 'path') }
-
-  it '#deploy fails early with invalid format' do
-    subject = Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email)
-    extractor = double(Nucleus::ArchiveExtractor)
-    expect(Nucleus::ArchiveExtractor).to receive(:new).with(any_args).once { extractor }
-    # we assume format is supported
-    expect(extractor).to receive(:supports?).with(kind_of(String)).once { false }
-    # call should fail
-    expect { subject.deploy(nil, 'xyz') }.to raise_error(Nucleus::Errors::AdapterRequestError)
-  end
-
-  describe 'repository actions' do
-    before do
-      # every action needs to clone the repository
-      expect(Git).to receive(:clone).with(repo_url, repo_name, path: kind_of(String)).once { repo }
-      # verify cleanup is performed for each method call
-      expect(FileUtils).to receive(:rm_rf).with(File.join(Dir.tmpdir, repo_name)).once
-    end
-
-    describe '#download' do
-      let!(:exclude_git) { true }
-
-      context 'with master branch' do
-        subject { Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email) }
-        let(:repo_branch) { 'master' }
-        it 'returns archived repository' do
-          # verify archiver is called to return the response
-          archiver = double(Nucleus::Archiver)
-          expect(Nucleus::Archiver).to receive(:new).with(exclude_git) { archiver }
-          expect(archiver).to receive(:compress).with(kind_of(String), zip).once { 'response' }
-
-          # execute the call
-          response = subject.download(zip, exclude_git)
-          expect(response).to eql('response')
-        end
-      end
-
-      context 'with nucleus branch' do
-        let(:repo_branch) { 'nucleus' }
-        subject { Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email, repo_branch) }
-        it 'returns archived repository' do
-          branch_mock = double(Git::Branch)
-          expect(repo).to receive(:branch).with(repo_branch).once { branch_mock }
-          expect(repo).to receive(:checkout).with(branch_mock).once { repo }
-
-          # verify archiver is called to return the response
-          archiver = double(Nucleus::Archiver)
-          expect(Nucleus::Archiver).to receive(:new).with(exclude_git) { archiver }
-          expect(archiver).to receive(:compress).with(kind_of(String), zip).once { 'response' }
-
-          # execute the call
-          response = subject.download(zip, exclude_git)
-          expect(response).to eql('response')
-        end
-
-        it 'returns archived repository even if master did not contain any commit' do
-          # branch fails for master without commits
-          expect(repo).to receive(:branch).with(repo_branch).once { fail StandardError, 'No commit for master' }
-          # then we rely on the fallback, checkout new branch
-          expect(repo).to receive(:checkout).with(repo_branch, new_branch: true).once { repo }
-
-          # verify archiver is called to return the response
-          archiver = double(Nucleus::Archiver)
-          expect(Nucleus::Archiver).to receive(:new).with(exclude_git) { archiver }
-          expect(archiver).to receive(:compress).with(kind_of(String), zip).once { 'response' }
-
-          # execute the call
-          response = subject.download(zip, exclude_git)
-          expect(response).to eql('response')
-        end
-      end
-    end
-
-    describe '#trigger_build' do
-      # set username and email
-      before { expect(repo).to receive(:config).with(kind_of(String), kind_of(String)).twice }
-
-      it 'succeeds for master branch' do
-        subject = Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email)
-        expect(repo).to receive(:add).with(all: true).once
-        expect(repo).to receive(:commit).with(kind_of(String)).once
-        expect(repo).to receive(:repack).with(no_args).once
-        expect(repo).to receive(:push).with(kind_of(String), 'master', force: true).once
-
-        # there shall be the attempt to write a file to the repository
-        expect(Nucleus::Adapters::FileManager).to receive(:save_file_from_data).with(any_args).once
-        # trigger the method
-        subject.trigger_build
-      end
-
-      it 'succeeds for nucleus branch' do
-        subject = Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email, 'nucleus')
-        expect(repo).to receive(:add).with(all: true).once
-        expect(repo).to receive(:commit).with(kind_of(String)).once
-        expect(repo).to receive(:repack).with(no_args).once
-        expect(repo).to receive(:push).with(kind_of(String), 'nucleus', force: true).once
-
-        branch_mock = double(Git::Branch)
-        expect(repo).to receive(:branch).with('nucleus').once { branch_mock }
-        expect(repo).to receive(:checkout).with(branch_mock).once { repo }
-
-        # there shall be the attempt to write a file to the repository
-        expect(Nucleus::Adapters::FileManager).to receive(:save_file_from_data)
-        # trigger the method
-        subject.trigger_build
-      end
-    end
-
-    describe '#deploy', memfs: true do
-      before { expect(repo).to receive(:config).with(kind_of(String), kind_of(String)).twice }
-      context 'with master branch' do
-        let(:repo_branch) { 'master' }
-        subject { Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email) }
-
-        describe 'fails' do
-          it 'if no files were extracted' do
-            extractor = double(Nucleus::ArchiveExtractor)
-            expect(Nucleus::ArchiveExtractor).to receive(:new).once { extractor }
-            # we assume format is supported
-            expect(extractor).to receive(:supports?).with(kind_of(String)).once { true }
-            # assumes number of extracted files
-            expect(extractor).to receive(:extract).with(file, kind_of(String), zip) { 0 }
-
-            # write files to disk, as the extractor would do
-            repo_dir = File.join(Dir.tmpdir, repo_name)
-            git_dir = File.join(repo_dir, '.git')
-            FileUtils.mkdir_p(git_dir)
-            FileUtils.touch(File.join(git_dir, 'some_git_file.txt'))
-
-            # make sure files actually exist
-            expect(File.file?(File.join(git_dir, 'some_git_file.txt'))).to eql(true)
-            expect(File.directory?(git_dir)).to eql(true)
-
-            # call should fail
-            expect { subject.deploy(file, zip) }.to raise_error(Nucleus::Errors::AdapterRequestError)
-          end
-        end
-
-        it 'succeeds' do
-          expect(repo).to receive(:add).with(all: true).once
-          expect(repo).to receive(:commit).with(kind_of(String)).once
-          expect(repo).to receive(:repack).with(no_args).once
-          expect(repo).to receive(:push).with(kind_of(String), repo_branch, force: true).once
-
-          extractor = double(Nucleus::ArchiveExtractor)
-          expect(Nucleus::ArchiveExtractor).to receive(:new).once { extractor }
-          # we assume format is supported
-          expect(extractor).to receive(:supports?).with(kind_of(String)).once { true }
-          # assumes number of extracted files
-          expect(extractor).to receive(:extract).with(file, kind_of(String), zip) { 9 }
-
-          # write files to disk, as the extractor would do
-          repo_dir = File.join(Dir.tmpdir, repo_name)
-          git_dir = File.join(repo_dir, '.git')
-          other_dir = File.join(repo_dir, 'another_dir')
-          FileUtils.mkdir_p(git_dir)
-          FileUtils.mkdir_p(other_dir)
-          FileUtils.touch(File.join(repo_dir, 'file_1.txt'))
-          FileUtils.touch(File.join(other_dir, 'file_2.txt'))
-          FileUtils.touch(File.join(git_dir, 'some_git_file.txt'))
-
-          # make sure files actually exist
-          expect(File.file?(File.join(repo_dir, 'file_1.txt'))).to eql(true)
-          expect(File.file?(File.join(other_dir, 'file_2.txt'))).to eql(true)
-          expect(File.file?(File.join(git_dir, 'some_git_file.txt'))).to eql(true)
-          expect(File.directory?(git_dir)).to eql(true)
-          expect(File.directory?(other_dir)).to eql(true)
-
-          # expect(Find).to receive(:find).with(kind_of(String)).once
-          expect(FileUtils).to receive(:rm_rf).with(other_dir).once.and_call_original
-          expect(FileUtils).to receive(:rm_f).with(File.join(repo_dir, 'file_1.txt')).once.and_call_original
-
-          sanitizer = double(Nucleus::ApplicationRepoSanitizer)
-          expect(Nucleus::ApplicationRepoSanitizer).to receive(:new).once { sanitizer }
-          # we assume format is supported
-          expect(sanitizer).to receive(:sanitize).with(kind_of(String)).once
-
-          # call should succeed
-          subject.deploy(file, zip)
-
-          # normal files should be deleted
-          expect(File.exist?(File.join(repo_dir, 'file_1.txt'))).to eql(false)
-          expect(File.exist?(File.join(other_dir, 'file_2.txt'))).to eql(false)
-          expect(File.exist?(other_dir)).to eql(false)
-
-          # whereas git files should still exist
-          expect(File.exist?(File.join(git_dir, 'some_git_file.txt'))).to eql(true)
-          expect(File.exist?(git_dir)).to eql(true)
-        end
-      end
-
-      context 'with nucleus branch' do
-        let(:repo_branch) { 'nucleus' }
-        subject { Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email, repo_branch) }
-        it 'succeeds' do
-          expect(repo).to receive(:add).with(all: true).once
-          expect(repo).to receive(:commit).with(kind_of(String)).once
-          expect(repo).to receive(:repack).with(no_args).once
-          expect(repo).to receive(:push).with(kind_of(String), repo_branch, force: true).once
-
-          branch_mock = double(Git::Branch)
-          expect(repo).to receive(:branch).with(repo_branch).once { branch_mock }
-          expect(repo).to receive(:checkout).with(branch_mock).once { repo }
-
-          extractor = double(Nucleus::ArchiveExtractor)
-          expect(Nucleus::ArchiveExtractor).to receive(:new).once { extractor }
-          # we assume format is supported
-          expect(extractor).to receive(:supports?).with(kind_of(String)).once { true }
-          # assumes number of extracted files
-          expect(extractor).to receive(:extract).with(file, kind_of(String), zip) { 9 }
-
-          # write files to disk, as the extractor would do
-          repo_dir = File.join(Dir.tmpdir, repo_name)
-          git_dir = File.join(repo_dir, '.git')
-          other_dir = File.join(repo_dir, 'another_dir')
-          FileUtils.mkdir_p(git_dir)
-          FileUtils.mkdir_p(other_dir)
-          FileUtils.touch(File.join(repo_dir, 'file_1.txt'))
-          FileUtils.touch(File.join(other_dir, 'file_2.txt'))
-          FileUtils.touch(File.join(git_dir, 'some_git_file.txt'))
-
-          # make sure files actually exist
-          expect(File.file?(File.join(repo_dir, 'file_1.txt'))).to eql(true)
-          expect(File.file?(File.join(other_dir, 'file_2.txt'))).to eql(true)
-          expect(File.file?(File.join(git_dir, 'some_git_file.txt'))).to eql(true)
-          expect(File.directory?(git_dir)).to eql(true)
-          expect(File.directory?(other_dir)).to eql(true)
-
-          # expect(Find).to receive(:find).with(kind_of(String)).once
-          expect(FileUtils).to receive(:rm_rf).with(other_dir).once.and_call_original
-          expect(FileUtils).to receive(:rm_f).with(File.join(repo_dir, 'file_1.txt')).once.and_call_original
-
-          sanitizer = double(Nucleus::ApplicationRepoSanitizer)
-          expect(Nucleus::ApplicationRepoSanitizer).to receive(:new).once { sanitizer }
-          # we assume format is supported
-          expect(sanitizer).to receive(:sanitize).with(kind_of(String)).once
-
-          # call should succeed
-          subject.deploy(file, zip)
-
-          # normal files should be deleted
-          expect(File.exist?(File.join(repo_dir, 'file_1.txt'))).to eql(false)
-          expect(File.exist?(File.join(other_dir, 'file_2.txt'))).to eql(false)
-          expect(File.exist?(other_dir)).to eql(false)
-
-          # whereas git files should still exist
-          expect(File.exist?(File.join(git_dir, 'some_git_file.txt'))).to eql(true)
-          expect(File.exist?(git_dir)).to eql(true)
-        end
-      end
-    end
-  end
-end
+require 'spec/unit/unit_spec_helper'
+
+describe Nucleus::Adapters::GitDeployer do
+  let(:repo_name) { 'my_repository' }
+  let(:repo_url) { 'http://repo.example.org' }
+  let(:user_email) { 'myuser@example.org' }
+  let(:repo) { double(Git::Base) }
+  let(:zip) { 'zip' }
+  let(:file) { File.join('random', 'file', 'path') }
+
+  it '#deploy fails early with invalid format' do
+    subject = Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email)
+    extractor = double(Nucleus::ArchiveExtractor)
+    expect(Nucleus::ArchiveExtractor).to receive(:new).with(any_args).once { extractor }
+    # we assume format is supported
+    expect(extractor).to receive(:supports?).with(kind_of(String)).once { false }
+    # call should fail
+    expect { subject.deploy(nil, 'xyz') }.to raise_error(Nucleus::Errors::AdapterRequestError)
+  end
+
+  describe 'repository actions' do
+    before do
+      # every action needs to clone the repository
+      expect(Git).to receive(:clone).with(repo_url, repo_name, path: kind_of(String)).once { repo }
+      # verify cleanup is performed for each method call
+      expect(FileUtils).to receive(:rm_rf).with(File.join(Dir.tmpdir, repo_name)).once
+    end
+
+    describe '#download' do
+      let!(:exclude_git) { true }
+
+      context 'with master branch' do
+        subject { Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email) }
+        let(:repo_branch) { 'master' }
+        it 'returns archived repository' do
+          # verify archiver is called to return the response
+          archiver = double(Nucleus::Archiver)
+          expect(Nucleus::Archiver).to receive(:new).with(exclude_git) { archiver }
+          expect(archiver).to receive(:compress).with(kind_of(String), zip).once { 'response' }
+
+          # execute the call
+          response = subject.download(zip, exclude_git)
+          expect(response).to eql('response')
+        end
+      end
+
+      context 'with nucleus branch' do
+        let(:repo_branch) { 'nucleus' }
+        subject { Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email, repo_branch) }
+        it 'returns archived repository' do
+          branch_mock = double(Git::Branch)
+          expect(repo).to receive(:branch).with(repo_branch).once { branch_mock }
+          expect(repo).to receive(:checkout).with(branch_mock).once { repo }
+
+          # verify archiver is called to return the response
+          archiver = double(Nucleus::Archiver)
+          expect(Nucleus::Archiver).to receive(:new).with(exclude_git) { archiver }
+          expect(archiver).to receive(:compress).with(kind_of(String), zip).once { 'response' }
+
+          # execute the call
+          response = subject.download(zip, exclude_git)
+          expect(response).to eql('response')
+        end
+
+        it 'returns archived repository even if master did not contain any commit' do
+          # branch fails for master without commits
+          expect(repo).to receive(:branch).with(repo_branch).once { raise StandardError, 'No commit for master' }
+          # then we rely on the fallback, checkout new branch
+          expect(repo).to receive(:checkout).with(repo_branch, new_branch: true).once { repo }
+
+          # verify archiver is called to return the response
+          archiver = double(Nucleus::Archiver)
+          expect(Nucleus::Archiver).to receive(:new).with(exclude_git) { archiver }
+          expect(archiver).to receive(:compress).with(kind_of(String), zip).once { 'response' }
+
+          # execute the call
+          response = subject.download(zip, exclude_git)
+          expect(response).to eql('response')
+        end
+      end
+    end
+
+    describe '#trigger_build' do
+      # set username and email
+      before { expect(repo).to receive(:config).with(kind_of(String), kind_of(String)).twice }
+
+      it 'succeeds for master branch' do
+        subject = Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email)
+        expect(repo).to receive(:add).with(all: true).once
+        expect(repo).to receive(:commit).with(kind_of(String)).once
+        expect(repo).to receive(:repack).with(no_args).once
+        expect(repo).to receive(:push).with(kind_of(String), 'master', force: true).once
+
+        # there shall be the attempt to write a file to the repository
+        expect(Nucleus::Adapters::FileManager).to receive(:save_file_from_data).with(any_args).once
+        # trigger the method
+        subject.trigger_build
+      end
+
+      it 'succeeds for nucleus branch' do
+        subject = Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email, 'nucleus')
+        expect(repo).to receive(:add).with(all: true).once
+        expect(repo).to receive(:commit).with(kind_of(String)).once
+        expect(repo).to receive(:repack).with(no_args).once
+        expect(repo).to receive(:push).with(kind_of(String), 'nucleus', force: true).once
+
+        branch_mock = double(Git::Branch)
+        expect(repo).to receive(:branch).with('nucleus').once { branch_mock }
+        expect(repo).to receive(:checkout).with(branch_mock).once { repo }
+
+        # there shall be the attempt to write a file to the repository
+        expect(Nucleus::Adapters::FileManager).to receive(:save_file_from_data)
+        # trigger the method
+        subject.trigger_build
+      end
+    end
+
+    describe '#deploy', memfs: true do
+      before { expect(repo).to receive(:config).with(kind_of(String), kind_of(String)).twice }
+      context 'with master branch' do
+        let(:repo_branch) { 'master' }
+        subject { Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email) }
+
+        describe 'fails' do
+          it 'if no files were extracted' do
+            extractor = double(Nucleus::ArchiveExtractor)
+            expect(Nucleus::ArchiveExtractor).to receive(:new).once { extractor }
+            # we assume format is supported
+            expect(extractor).to receive(:supports?).with(kind_of(String)).once { true }
+            # assumes number of extracted files
+            expect(extractor).to receive(:extract).with(file, kind_of(String), zip) { 0 }
+
+            # write files to disk, as the extractor would do
+            repo_dir = File.join(Dir.tmpdir, repo_name)
+            git_dir = File.join(repo_dir, '.git')
+            FileUtils.mkdir_p(git_dir)
+            FileUtils.touch(File.join(git_dir, 'some_git_file.txt'))
+
+            # make sure files actually exist
+            expect(File.file?(File.join(git_dir, 'some_git_file.txt'))).to eql(true)
+            expect(File.directory?(git_dir)).to eql(true)
+
+            # call should fail
+            expect { subject.deploy(file, zip) }.to raise_error(Nucleus::Errors::AdapterRequestError)
+          end
+        end
+
+        it 'succeeds' do
+          expect(repo).to receive(:add).with(all: true).once
+          expect(repo).to receive(:commit).with(kind_of(String)).once
+          expect(repo).to receive(:repack).with(no_args).once
+          expect(repo).to receive(:push).with(kind_of(String), repo_branch, force: true).once
+
+          extractor = double(Nucleus::ArchiveExtractor)
+          expect(Nucleus::ArchiveExtractor).to receive(:new).once { extractor }
+          # we assume format is supported
+          expect(extractor).to receive(:supports?).with(kind_of(String)).once { true }
+          # assumes number of extracted files
+          expect(extractor).to receive(:extract).with(file, kind_of(String), zip) { 9 }
+
+          # write files to disk, as the extractor would do
+          repo_dir = File.join(Dir.tmpdir, repo_name)
+          git_dir = File.join(repo_dir, '.git')
+          other_dir = File.join(repo_dir, 'another_dir')
+          FileUtils.mkdir_p(git_dir)
+          FileUtils.mkdir_p(other_dir)
+          FileUtils.touch(File.join(repo_dir, 'file_1.txt'))
+          FileUtils.touch(File.join(other_dir, 'file_2.txt'))
+          FileUtils.touch(File.join(git_dir, 'some_git_file.txt'))
+
+          # make sure files actually exist
+          expect(File.file?(File.join(repo_dir, 'file_1.txt'))).to eql(true)
+          expect(File.file?(File.join(other_dir, 'file_2.txt'))).to eql(true)
+          expect(File.file?(File.join(git_dir, 'some_git_file.txt'))).to eql(true)
+          expect(File.directory?(git_dir)).to eql(true)
+          expect(File.directory?(other_dir)).to eql(true)
+
+          # expect(Find).to receive(:find).with(kind_of(String)).once
+          expect(FileUtils).to receive(:rm_rf).with(other_dir).once.and_call_original
+          expect(FileUtils).to receive(:rm_f).with(File.join(repo_dir, 'file_1.txt')).once.and_call_original
+
+          sanitizer = double(Nucleus::ApplicationRepoSanitizer)
+          expect(Nucleus::ApplicationRepoSanitizer).to receive(:new).once { sanitizer }
+          # we assume format is supported
+          expect(sanitizer).to receive(:sanitize).with(kind_of(String)).once
+
+          # call should succeed
+          subject.deploy(file, zip)
+
+          # normal files should be deleted
+          expect(File.exist?(File.join(repo_dir, 'file_1.txt'))).to eql(false)
+          expect(File.exist?(File.join(other_dir, 'file_2.txt'))).to eql(false)
+          expect(File.exist?(other_dir)).to eql(false)
+
+          # whereas git files should still exist
+          expect(File.exist?(File.join(git_dir, 'some_git_file.txt'))).to eql(true)
+          expect(File.exist?(git_dir)).to eql(true)
+        end
+      end
+
+      context 'with nucleus branch' do
+        let(:repo_branch) { 'nucleus' }
+        subject { Nucleus::Adapters::GitDeployer.new(repo_name, repo_url, user_email, repo_branch) }
+        it 'succeeds' do
+          expect(repo).to receive(:add).with(all: true).once
+          expect(repo).to receive(:commit).with(kind_of(String)).once
+          expect(repo).to receive(:repack).with(no_args).once
+          expect(repo).to receive(:push).with(kind_of(String), repo_branch, force: true).once
+
+          branch_mock = double(Git::Branch)
+          expect(repo).to receive(:branch).with(repo_branch).once { branch_mock }
+          expect(repo).to receive(:checkout).with(branch_mock).once { repo }
+
+          extractor = double(Nucleus::ArchiveExtractor)
+          expect(Nucleus::ArchiveExtractor).to receive(:new).once { extractor }
+          # we assume format is supported
+          expect(extractor).to receive(:supports?).with(kind_of(String)).once { true }
+          # assumes number of extracted files
+          expect(extractor).to receive(:extract).with(file, kind_of(String), zip) { 9 }
+
+          # write files to disk, as the extractor would do
+          repo_dir = File.join(Dir.tmpdir, repo_name)
+          git_dir = File.join(repo_dir, '.git')
+          other_dir = File.join(repo_dir, 'another_dir')
+          FileUtils.mkdir_p(git_dir)
+          FileUtils.mkdir_p(other_dir)
+          FileUtils.touch(File.join(repo_dir, 'file_1.txt'))
+          FileUtils.touch(File.join(other_dir, 'file_2.txt'))
+          FileUtils.touch(File.join(git_dir, 'some_git_file.txt'))
+
+          # make sure files actually exist
+          expect(File.file?(File.join(repo_dir, 'file_1.txt'))).to eql(true)
+          expect(File.file?(File.join(other_dir, 'file_2.txt'))).to eql(true)
+          expect(File.file?(File.join(git_dir, 'some_git_file.txt'))).to eql(true)
+          expect(File.directory?(git_dir)).to eql(true)
+          expect(File.directory?(other_dir)).to eql(true)
+
+          # expect(Find).to receive(:find).with(kind_of(String)).once
+          expect(FileUtils).to receive(:rm_rf).with(other_dir).once.and_call_original
+          expect(FileUtils).to receive(:rm_f).with(File.join(repo_dir, 'file_1.txt')).once.and_call_original
+
+          sanitizer = double(Nucleus::ApplicationRepoSanitizer)
+          expect(Nucleus::ApplicationRepoSanitizer).to receive(:new).once { sanitizer }
+          # we assume format is supported
+          expect(sanitizer).to receive(:sanitize).with(kind_of(String)).once
+
+          # call should succeed
+          subject.deploy(file, zip)
+
+          # normal files should be deleted
+          expect(File.exist?(File.join(repo_dir, 'file_1.txt'))).to eql(false)
+          expect(File.exist?(File.join(other_dir, 'file_2.txt'))).to eql(false)
+          expect(File.exist?(other_dir)).to eql(false)
+
+          # whereas git files should still exist
+          expect(File.exist?(File.join(git_dir, 'some_git_file.txt'))).to eql(true)
+          expect(File.exist?(git_dir)).to eql(true)
+        end
+      end
+    end
+  end
+end