nucleus 0.1.0

data/spec/unit/adapters/archive_converter_spec.rb

@@ -0,0 +1,25 @@
+describe Nucleus::Adapters::ArchiveConverter, memfs: true do
+  subject { Nucleus::Adapters::ArchiveConverter }
+  let(:zip) { 'zip' }
+  let(:tar_gz) { 'tar.gz' }
+  let(:input_file) { File.join(Dir.tmpdir, 'archive_converter_spec_input_file.tar.gz') }
+  it 'extracts, sanitizes and archives the input file' do
+    sanitizer = double(Nucleus::ApplicationRepoSanitizer)
+    expect(sanitizer).to receive(:sanitize).once
+
+    extractor = double(Nucleus::ArchiveExtractor)
+    expect(extractor).to receive(:extract).with(input_file, any_args, tar_gz).once
+
+    archiver = double(Nucleus::Archiver)
+    expect(archiver).to receive(:compress).with(any_args, zip).once
+
+    expect(Nucleus::Archiver).to receive(:new) { archiver }
+    expect(Nucleus::ArchiveExtractor).to receive(:new) { extractor }
+    expect(Nucleus::ApplicationRepoSanitizer).to receive(:new) { sanitizer }
+
+    # make sure working files get deleted
+    expect(FileUtils).to receive(:rm_rf).once
+
+    subject.convert(input_file, tar_gz, zip, true)
+  end
+end

data/spec/unit/adapters/file_manager_spec.rb

@@ -0,0 +1,93 @@
+require 'spec/unit/unit_spec_helper'
+
+describe Nucleus::Adapters::FileManager, memfs: true do
+  let(:dir) { File.join(Dir.tmpdir, 'file_manager_load_file_test_dir') }
+  let(:file) { File.join(dir, 'file_manager_load_file_test') }
+  let(:contents) { 'Heja BVB, Heja BVB, Heja Heja BVB' }
+
+  # make sure file is deleted before the next attempt
+  before(:each) { FileUtils.rm_rf(dir) }
+
+  describe '#load_file' do
+    before do
+      FileUtils.mkdir_p(dir)
+      File.open(file, 'wb') { |f| f.write contents }
+      @result = Nucleus::Adapters::FileManager.load_file(file)
+    end
+    it 'returns the actual file contents' do
+      expect(@result.read).to eql(contents)
+    end
+    it 'returns a StringIO object' do
+      expect(@result).to be_a(StringIO)
+    end
+  end
+
+  describe '#save_file_from_data' do
+    let(:io) { StringIO.new(contents) }
+    let(:md5) { Digest::MD5.hexdigest(contents) }
+    context 'file already exists' do
+      context 'and force: false' do
+        let(:force) { false }
+        before { FileUtils.mkdir_p(dir) }
+        it 'fails if the file already exists' do
+          # prepare already existing file
+          File.open(file, 'wb') { |f| f.write contents }
+
+          expect do
+            Nucleus::Adapters::FileManager.save_file_from_data(file, io, force)
+          end.to raise_error(Nucleus::FileExistenceError)
+        end
+
+        it 'fails if the file already exists but content is different than anticipated' do
+          # prepare already existing file
+          File.open(file, 'wb') { |f| f.write StringIO.new("#{contents} - manipulated") }
+
+          expect do
+            Nucleus::Adapters::FileManager.save_file_from_data(file, io, force, md5)
+          end.to raise_error(ArgumentError)
+        end
+
+        it 'succeeds if the file already exists and has the anticipated contents' do
+          # prepare already existing file
+          File.open(file, 'wb') { |f| f.write contents }
+
+          # call
+          Nucleus::Adapters::FileManager.save_file_from_data(file, io, force, md5)
+
+          # expect file exists with valid content
+          expect(File.exist?(file)).to eql(true)
+          expect(File.read(file)).to eql(contents)
+        end
+      end
+
+      context 'and force: true' do
+        let(:force) { true }
+        it 'succeeds' do
+          # call
+          Nucleus::Adapters::FileManager.save_file_from_data(file, io, force)
+          # expect file exists with valid content
+          expect(File.exist?(file)).to eql(true)
+          expect(File.read(file)).to eql(contents)
+        end
+      end
+    end
+
+    context 'file does not exist yet' do
+      it 'succeeds if the file already exists' do
+        # call
+        Nucleus::Adapters::FileManager.save_file_from_data(file, io)
+        # expect file exists with valid content
+        expect(File.exist?(file)).to eql(true)
+        expect(File.read(file)).to eql(contents)
+      end
+
+      it 'succeeds' do
+        # call
+        Nucleus::Adapters::FileManager.save_file_from_data(file, io)
+        # expect file exists with valid content
+        expect(File.exist?(file)).to eql(true)
+        expect(File.read(file)).to eql(contents)
+      end
+    end
+  end
+end

data/spec/unit/adapters/git_deployer_spec.rb

@@ -0,0 +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

data/spec/unit/adapters/v1/stub_spec.rb

@@ -0,0 +1,14 @@
+# Here we test that the Stub adapter always fails if an adapter implementation is missing
+describe Nucleus::Adapters::V1::Stub do
+  subject { Nucleus::Adapters::V1::Stub.new('https://example.org') }
+  Nucleus::Adapters::V1::Stub.instance_methods(false).each do |method_name|
+    it "#{method_name} shall fail with AdapterMissingImplementationError" do
+      if subject.method(method_name).arity > 0
+        args = Array.new(subject.method(method_name).arity, nil)
+        expect { subject.send(method_name, *args) }.to raise_error(Nucleus::Errors::AdapterMissingImplementationError)
+      else
+        expect { subject.send(method_name) }.to raise_error(Nucleus::Errors::AdapterMissingImplementationError)
+      end
+    end
+  end
+end

data/spec/unit/common/helpers/auth_helper_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Nucleus::Adapters::AuthenticationRetryWrapper do
+  let!(:adapter) { double('adapter') }
+  let!(:auth_client) { double('auth_client') }
+  let!(:calculator) { double('calculator') }
+  let!(:user) { 'my fictionary user' }
+  let!(:pass) { 'my fictionary password' }
+  let!(:fake_env) { { 'HTTP_AUTHORIZATION' => 'Basic ' + ["#{user}:#{pass}"].pack('m*').gsub(/\n/, '') } }
+  before do
+    cache_key = 'a unique cache key!'
+    cache_dao = double(Nucleus::API::DB::CacheDao)
+    allow(cache_dao).to receive(:get) do |key|
+      key.end_with?('adapter') ? adapter : cache_key
+    end
+    RequestStore.store[:cache_key] = cache_key
+    allow(adapter).to receive(:cache)
+    allow(adapter).to receive(:cache_key)
+    allow(adapter).to receive(:cached) { auth_client }
+  end
+
+  describe '#with_authentication' do
+    context 'when cache is outdated' do
+      before do
+        counted = 0
+        expect  = 1
+        allow(calculator).to receive(:calc) do
+          fail(Nucleus::Errors::EndpointAuthenticationError.new('error', auth_client)) if (counted += 1) <= expect
+          1
+        end
+      end
+
+      context 'and refresh was ok' do
+        it 'response is returned in repeated call' do
+          expect(auth_client).to receive(:refresh).once
+          expect(calculator).to receive(:calc).exactly(2).times
+          Nucleus::Adapters::AuthenticationRetryWrapper.with_authentication(adapter, fake_env) { calculator.calc }
+        end
+      end
+      context 'and refresh failed' do
+        before do
+          allow(auth_client).to receive(:refresh).and_raise(
+            Nucleus::Errors::EndpointAuthenticationError.new('error', auth_client))
+        end
+        context 'but authentication succeeded' do
+          before { allow(adapter).to receive(:authenticate) { 'authentication result' } }
+          it 'response is returned in repeated call after the authentication' do
+            expect(auth_client).to receive(:authenticate).once
+            expect(calculator).to receive(:calc).exactly(2).times
+            Nucleus::Adapters::AuthenticationRetryWrapper.with_authentication(adapter, fake_env) { calculator.calc }
+          end
+        end
+        context 'and authentication failed' do
+          it 'finally fails' do
+            expect(auth_client).to receive(:authenticate).once.and_raise(Nucleus::Errors::EndpointAuthenticationError,
+                                                                         'error')
+            expect(calculator).to receive(:calc).exactly(1).times
+            expect do
+              Nucleus::Adapters::AuthenticationRetryWrapper.with_authentication(adapter, fake_env) { calculator.calc }
+            end.to raise_error(Nucleus::Errors::EndpointAuthenticationError)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#re_authenticate' do
+    it 'calls authentication on the adapter' do
+      expect(auth_client).to receive(:authenticate).once.with(user, pass)
+      Nucleus::Adapters::AuthenticationRetryWrapper.re_authenticate(adapter, fake_env)
+    end
+  end
+end