capsulecd 1.0.0

data/spec/lib/capsulecd/base/configuration_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe CapsuleCD::Configuration do
+  describe '::new' do
+    describe 'with a sample configuration file' do
+      let(:config_file_path) { 'spec/fixtures/sample_configuration.yml' }
+      subject { CapsuleCD::Configuration.new(config_file:config_file_path, source: :github, package_type: :node) }
+
+      it 'should populate github_access_token' do
+        expect(subject.source_github_access_token).to eql('sample_test_token')
+      end
+
+      it 'should populate engine_npm_auth_token' do
+        expect(subject.npm_auth_token).to eql('sample_auth_token')
+      end
+
+      it 'should use cli specified source' do
+        expect(subject.source).to eql(:github)
+      end
+
+      it 'should correctly base64 decode chef supermarket key' do
+        expect(subject.chef_supermarket_key).to eql("-----BEGIN RSA PRIVATE KEY-----\nsample_supermarket_key\n-----END RSA PRIVATE KEY-----\n")
+      end
+
+      it 'should have correct defaults' do
+        expect(subject.engine_version_bump_type).to eql(:patch)
+        expect(subject.chef_supermarket_type).to eql('Other')
+      end
+    end
+
+    describe 'with an incorrect configuration file' do
+      let(:config_file_path) { 'spec/fixtures/incorrect_configuration.yml' }
+      subject { CapsuleCD::Configuration.new(config_file:config_file_path, source: :github, package_type: :node) }
+
+      it 'should populate github_access_token' do
+        expect(subject.source_github_access_token).to eql('sample_test_token')
+      end
+
+      it 'should populate engine_npm_auth_token' do
+        expect(subject.npm_auth_token).to eql('sample_auth_token')
+      end
+
+      it 'should use cli specified source' do
+        expect(subject.source).to eql(:github)
+      end
+
+      it 'should have a nil chef supermarket key' do
+        expect(subject.chef_supermarket_key).to eql(nil)
+      end
+    end
+
+    describe 'when overriding sample configuration file' do
+      let(:config_file_path) { 'spec/fixtures/sample_configuration.yml' }
+
+      describe 'with ENV variables' do
+        it 'should use CAPSULE_SOURCE_GITHUB_ACCESS_TOKEN instead of config file' do
+          allow(ENV).to receive(:each).and_yield('CAPSULE_SOURCE_GITHUB_ACCESS_TOKEN', 'override_test_token')
+
+          config = CapsuleCD::Configuration.new(config_file: config_file_path, source: :github, package_type: :node)
+
+          expect(config.source_github_access_token).to eql('override_test_token')
+        end
+
+        it 'should use CAPSULE_ENGINE_VERSION_BUMP_TYPE instead of default and return symbol' do
+          allow(ENV).to receive(:each).and_yield('CAPSULE_ENGINE_VERSION_BUMP_TYPE', 'patch')
+
+          config = CapsuleCD::Configuration.new(config_file: config_file_path, source: :github, package_type: :node)
+
+          expect(config.engine_version_bump_type).to eql(:patch)
+        end
+      end
+    end
+
+  end
+end

data/spec/lib/capsulecd/base/engine_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe CapsuleCD::Engine do
+
+  describe '::new' do
+    describe 'without a source specified' do
+      it 'should throw an error' do
+        expect{CapsuleCD::Engine.new({})}.to raise_error(CapsuleCD::Error::SourceUnspecifiedError)
+      end
+    end
+  end
+
+  describe '::bump_version' do
+    subject{
+      CapsuleCD::Engine.new({:source => :github})
+    }
+    it 'should default to bumping patch segement' do
+      version = SemVer.parse('1.0.2')
+      new_version = subject.send(:bump_version, version)
+      expect(new_version.to_s).to eql('1.0.3')
+    end
+
+    describe 'when engine_version_bump_type is :minor' do
+      subject{
+        CapsuleCD::Engine.new({
+                                  :source => :github,
+                                  :engine_version_bump_type => :minor
+                              })
+      }
+      it 'should correctly bump minor and clear patch segement' do
+        version = SemVer.parse('1.0.2')
+        new_version = subject.send(:bump_version, version)
+        expect(new_version.to_s).to eql('1.1.0')
+      end
+    end
+
+    describe 'when engine_version_bump_type is :major' do
+      subject{
+        CapsuleCD::Engine.new({
+                                  :source => :github,
+                                  :engine_version_bump_type => :major
+                              })
+      }
+      it 'should correctly bump major and clear minor and patch segements' do
+        version = SemVer.parse('1.0.2')
+        new_version = subject.send(:bump_version, version)
+        expect(new_version.to_s).to eql('2.0.0')
+      end
+    end
+  end
+end

data/spec/lib/capsulecd/base/source/github_spec.rb

@@ -0,0 +1,253 @@
+require 'spec_helper'
+require 'capsulecd/base/source/github'
+
+describe CapsuleCD::Source::Github do
+  describe '#source_configure' do
+
+    describe 'when no authentication token is present' do
+      let(:test_engine) { Class.new { include CapsuleCD::Source::Github } }
+      let(:config) { CapsuleCD::Configuration.new({}) }
+      it 'should raise an error' do
+        engine = test_engine.new
+        engine.instance_variable_set(:@config, config)
+        expect { engine.source_configure }.to raise_error(CapsuleCD::Error::SourceAuthenticationFailed)
+      end
+    end
+
+    describe 'when authentication token is present' do
+      let(:test_engine) { Class.new { include CapsuleCD::Source::Github } }
+      let(:config) { CapsuleCD::Configuration.new({:config_file => 'spec/fixtures/sample_configuration.yml'}) }
+
+      it 'should successfully create an source_client' do
+        allow(Dir).to receive(:mktmpdir).and_return('/tmp')
+        engine = test_engine.new
+        engine.instance_variable_set(:@config, config)
+        engine.source_configure
+        expect(engine.source_client).to be_a_kind_of Octokit::Client
+      end
+    end
+  end
+
+  describe '#source_process_push_payload' do
+    let(:test_engine) { Class.new { include CapsuleCD::Source::Github } }
+    let(:payload) do
+      {
+        'head' => {
+          'sha' => '0a5948802a2bba02e019fd13bf3db3c5329faae6',
+          'ref' => 'master',
+          'repo' => {
+            'clone_url' => 'https://github.com/AnalogJ/npm_analogj_test.git',
+            'name' => 'npm_analog_test'
+          }
+        }
+      }
+    end
+    let(:config) { CapsuleCD::Configuration.new({:config_file => 'spec/fixtures/sample_configuration.yml'}) }
+    it 'should clone git repo' do
+      engine = test_engine.new
+      engine.instance_variable_set(:@config, config)
+      engine.instance_variable_set(:@source_git_parent_path, '/tmp')
+      allow(CapsuleCD::GitUtils).to receive(:clone).and_return(engine.source_git_parent_path + payload['head']['repo']['name'])
+      allow(CapsuleCD::GitUtils).to receive(:checkout).and_return(true)
+
+      engine.source_process_push_payload(payload)
+
+      expect(engine.source_git_local_path).to eql(engine.source_git_parent_path + payload['head']['repo']['name'])
+      expect(engine.source_git_local_branch).to eql(payload['head']['repo']['branch'])
+      expect(engine.source_git_head_info).to be_a(Hash)
+    end
+
+    describe 'with an invalid payload' do
+      it 'should raise an error' do
+        engine = test_engine.new
+        engine.instance_variable_set(:@config, config)
+        engine.instance_variable_set(:@source_git_parent_path, '/tmp')
+        expect { engine.source_process_push_payload('head' => {}) }.to raise_error(CapsuleCD::Error::SourcePayloadFormatError)
+      end
+    end
+  end
+
+  describe '#source_process_pull_request_payload' do
+    let(:test_engine) { Class.new { include CapsuleCD::Source::Github } }
+    let(:source_client_double) { instance_double(Octokit::Client) }
+    let(:config) { CapsuleCD::Configuration.new({:config_file => 'spec/fixtures/sample_configuration.yml'}) }
+
+    describe 'with a closed pull request payload' do
+      let(:payload) do
+        {
+          'state' => 'closed'
+        }
+      end
+      it 'should raise an error' do
+        engine = test_engine.new
+        engine.instance_variable_set(:@config, config)
+        expect { engine.source_process_pull_request_payload(payload) }.to raise_error(CapsuleCD::Error::SourcePayloadUnsupported)
+      end
+    end
+
+    describe 'when the default branch is not the same as the pull request base branch' do
+      let(:config) { CapsuleCD::Configuration.new({:config_file => 'spec/fixtures/sample_configuration.yml'}) }
+      let(:payload) do
+        {
+          'state' => 'open',
+          'base' => {
+            'repo' => {
+              'default_branch' => 'master'
+            },
+            'ref' => 'development'
+          }
+        }
+      end
+      it 'should raise an error' do
+        engine = test_engine.new
+        engine.instance_variable_set(:@config, config)
+        expect { engine.source_process_pull_request_payload(payload) }.to raise_error(CapsuleCD::Error::SourcePayloadUnsupported)
+      end
+    end
+
+    describe 'when the user who opened the PR is not a collaborator' do
+      let(:payload) do
+        {
+          'state' => 'open',
+          'number' => 8,
+          'base' => {
+            'repo' => {
+              'full_name' => 'AnalogJ/npm_analogj_test',
+              'default_branch' => 'master',
+              'clone_url' => 'https://github.com/AnalogJ/npm_analogj_test.git',
+              'name' => 'npm_analog_test'
+            },
+            'sha' => '0a5948802a2bba02e019fd13bf3db3c5329faae6',
+            'ref' => 'master'
+          },
+          'user' => {
+            'login' => 'AnalogJ'
+          }
+        }
+      end
+
+      it 'should raise an error', :skip => true do
+        engine = test_engine.new
+        engine.instance_variable_set(:@source_client, source_client_double)
+        engine.instance_variable_set(:@source_git_parent_path, '/tmp')
+
+        allow(source_client_double).to receive(:collaborator?).and_return(false)
+        allow(source_client_double).to receive(:add_comment).and_return(false)
+
+        expect { engine.source_process_pull_request_payload(payload) }.to raise_error(CapsuleCD::Error::SourceUnauthorizedUser)
+      end
+    end
+
+    describe 'when using a valid payload' do
+      let(:payload) do
+        {
+          'state' => 'open',
+          'number' => 8,
+          'base' => {
+            'sha' => '0a5948802a2bba02e019fd13bf3db3c5329faae6',
+            'ref' => 'master',
+            'repo' => {
+              'full_name' => 'AnalogJ/npm_analogj_test',
+              'clone_url' => 'https://github.com/AnalogJ/npm_analogj_test.git',
+              'name' => 'npm_analog_test',
+              'default_branch' => 'master'
+            }
+          },
+          'head' => {
+            'sha' => '0a5948802a2bba02e019fd13bf3db3c5329faae6',
+            'ref' => 'feature',
+            'repo' => {
+              'full_name' => 'AnalogJ/npm_analogj_test',
+              'clone_url' => 'https://github.com/AnalogJ/npm_analogj_test.git',
+              'name' => 'npm_analog_test'
+            }
+          },
+          'user' => {
+            'login' => 'AnalogJ'
+          }
+        }
+      end
+
+      it 'should clone merged repo' do
+        engine = test_engine.new
+        engine.instance_variable_set(:@config, config)
+        engine.instance_variable_set(:@source_client, source_client_double)
+        engine.instance_variable_set(:@source_git_parent_path, '/tmp')
+
+        allow(source_client_double).to receive(:collaborator?).and_return(true)
+        allow(source_client_double).to receive(:add_comment).and_return(false)
+        allow(source_client_double).to receive(:create_status).and_return(false)
+        allow(CapsuleCD::GitUtils).to receive(:clone).and_return(engine.source_git_parent_path + payload['head']['repo']['name'])
+        allow(CapsuleCD::GitUtils).to receive(:fetch).and_return(true)
+        allow(CapsuleCD::GitUtils).to receive(:checkout).and_return(true)
+
+        engine.source_process_pull_request_payload(payload)
+
+        expect(engine.source_git_local_branch).to eql('pr_8')
+        expect(engine.source_git_local_path).to eql(engine.source_git_parent_path + payload['head']['repo']['name'])
+        expect(engine.source_git_head_info).to be_a(Hash)
+        expect(engine.source_git_base_info).to be_a(Hash)
+      end
+    end
+  end
+
+  describe '#source_release' do
+    let(:test_engine) { Class.new { include CapsuleCD::Source::Github } }
+    let(:source_client_double) { instance_double(Octokit::Client) }
+    let(:git_commit_double) { instance_double(Git::Object::Commit) }
+
+    describe 'when release state is valid' do
+      let(:payload) do
+        {
+          'state' => 'open',
+          'number' => 8,
+          'base' => {
+            'sha' => '0a5948802a2bba02e019fd13bf3db3c5329faae6',
+            'repo' => {
+              'full_name' => 'AnalogJ/npm_analogj_test',
+              'clone_url' => 'https://github.com/AnalogJ/npm_analogj_test.git',
+              'name' => 'npm_analog_test',
+              'default_branch' => 'master'
+            },
+            'ref' => 'master'
+          },
+          'head' => {
+            'sha' => '0a5948802a2bba02e019fd13bf3db3c5329faae6',
+            'repo' => {
+              'full_name' => 'AnalogJ/npm_analogj_test',
+              'clone_url' => 'https://github.com/AnalogJ/npm_analogj_test.git',
+              'name' => 'npm_analog_test'
+            },
+            'ref' => 'feature'
+          },
+          'user' => {
+            'login' => 'AnalogJ'
+          }
+        }
+      end
+
+      it 'should successfully push changes to github' do
+        engine = test_engine.new
+        engine.instance_variable_set(:@source_client, source_client_double)
+        engine.instance_variable_set(:@source_release_commit, git_commit_double)
+        engine.instance_variable_set(:@source_git_local_path, '')
+        engine.instance_variable_set(:@source_git_local_branch, '')
+        engine.instance_variable_set(:@source_git_base_info, payload['base'])
+        engine.instance_variable_set(:@source_git_head_info, payload['head'])
+        engine.instance_variable_set(:@source_release_artifacts, [])
+        engine.instance_variable_set(:@source_git_parent_path, test_directory)
+
+        allow(source_client_double).to receive(:create_release).and_return(true)
+        allow(source_client_double).to receive(:upload_asset).and_return(false)
+        allow(source_client_double).to receive(:create_status).and_return(false)
+        allow(git_commit_double).to receive(:sha).and_return('0a5948802a2bba02e019fd13bf3db3c5329faae6')
+        allow(git_commit_double).to receive(:name).and_return('test')
+        allow(CapsuleCD::GitUtils).to receive(:push).and_return(true)
+        allow(CapsuleCD::GitUtils).to receive(:generate_changelog).and_return('')
+        allow(FileUtils).to receive(:remove_entry_secure).and_return(true)
+
+        engine.source_release
+      end
+    end
+  end
+end

data/spec/lib/capsulecd/base/transform_engine_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe CapsuleCD::TransformEngine do
+  before(:each) do
+    CapsuleCD.send(:remove_const, 'EngineExtension')
+    load 'lib/capsulecd/base/transform_engine.rb'
+  end
+  describe '::new' do
+    describe 'with a global configuration file' do
+
+      describe 'with an empty engine' do
+        before(:each) do
+          stub_const 'EmptyEngine', Class.new
+        end
+
+        let(:config_file_path) { 'spec/fixtures/sample_global_configuration.yml' }
+        subject { CapsuleCD::TransformEngine.new() }
+
+        it 'should raise an error if we specify that its a repo configuration' do
+          expect{
+            subject.transform(nil, config_file_path)
+          }.to raise_error(CapsuleCD::Error::EngineTransformUnavailableStep)
+        end
+
+        it 'should register the EngineExtension methods after transform' do
+          engine = EmptyEngine.new
+          expect(engine.methods - Object.methods).to be_empty
+          subject.transform(engine, config_file_path, :global)
+          expect((engine.methods - Object.methods).sort).to eql([:post_build_step, :post_source_configure, :pre_source_configure, :source_configure])
+          expect(engine.source_configure).to eql('override source_configure')
+        end
+      end
+
+      describe 'with an base engine' do
+        before(:each) do
+          stub_const 'BaseEngine', CapsuleCD::Engine
+        end
+
+        let(:config_file_path) { 'spec/fixtures/sample_global_configuration.yml' }
+        subject { CapsuleCD::TransformEngine.new() }
+
+
+        it 'should register the EngineExtension methods after transform, and override any existing methods' do
+          engine = BaseEngine.new(source: :github)
+          engine.instance_variable_set(:@source_git_local_path, test_directory)
+          subject.transform(engine, config_file_path, :global)
+          expect(engine.source_configure).to eql('override source_configure')
+          expect(engine.post_build_step).to eql('override post_build_step'+test_directory)
+        end
+      end
+
+    end
+
+  end
+end

data/spec/lib/capsulecd/chef/chef_engine_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe 'CapsuleCD::Chef::ChefEngine', :chef do
+  describe '#build_step' do
+    describe 'when building an empty package' do
+      let(:engine) do
+        require 'capsulecd/chef/chef_engine'
+        CapsuleCD::Chef::ChefEngine.new(source: :github,
+                                        package_type: :chef)
+      end
+      it 'should raise an error' do
+        engine.instance_variable_set(:@source_git_local_path, test_directory )
+
+        expect { engine.build_step }.to raise_error(CapsuleCD::Error::BuildPackageInvalid)
+      end
+    end
+
+    describe 'when building a simple package ' do
+      let(:engine) do
+        require 'capsulecd/chef/chef_engine'
+        CapsuleCD::Chef::ChefEngine.new(source: :github,
+                                        package_type: :chef)
+      end
+      it 'should create a Rakefile, Berksfile, .gitignore file,  file and tests folder' do
+        FileUtils.copy_entry('spec/fixtures/chef/cookbook_analogj_test', test_directory)
+        engine.instance_variable_set(:@source_git_local_path, test_directory )
+
+        VCR.use_cassette('chef_build_step',:tag => :chef) do
+          engine.build_step
+        end
+        File.exist?(test_directory+'/Rakefile')
+        File.exist?(test_directory+'/Berksfile')
+        File.exist?(test_directory+'/.gitignore')
+        File.exist?(test_directory+'/Gemfile')
+
+      end
+    end
+  end
+
+  describe '#test_step' do
+    let(:engine) do
+      require 'capsulecd/chef/chef_engine'
+      CapsuleCD::Chef::ChefEngine.new(source: :github,
+                                          package_type: :chef)
+    end
+    let(:config_double) { CapsuleCD::Configuration.new }
+    describe 'when testing chef package' do
+      it 'should run install dependencies' do
+        FileUtils.copy_entry('spec/fixtures/chef/cookbook_analogj_test', test_directory)
+        allow(Open3).to receive(:popen3).and_return(false)
+        allow(config_double).to receive(:engine_cmd_test).and_call_original
+        allow(config_double).to receive(:engine_disable_test).and_call_original
+        engine.instance_variable_set(:@source_git_local_path, test_directory)
+        engine.instance_variable_set(:@config, config_double)
+
+        engine.test_step
+      end
+    end
+  end
+
+  describe 'integration tests' do
+    let(:engine) do
+      require 'capsulecd/chef/chef_engine'
+      CapsuleCD::Chef::ChefEngine.new(source: :github,
+                                      runner: :default,
+                                      package_type: :chef,
+                                      config_file: 'spec/fixtures/sample_chef_configuration.yml'
+                                     # config_file: 'spec/fixtures/live_chef_configuration.yml'
+      )
+    end
+    let(:git_commit_double) { instance_double(Git::Object::Commit) }
+    describe 'when testing chef package' do
+      it 'should complete successfully' do
+        FileUtils.copy_entry('spec/fixtures/chef/cookbook_analogj_test', test_directory)
+
+        VCR.use_cassette('integration_chef',:tag => :chef) do
+          #set defaults for stubbed classes
+          source_git_local_path = test_directory
+          allow(File).to receive(:exist?).and_call_original
+          allow(File).to receive(:open).and_call_original
+          allow(Open3).to receive(:popen3).and_call_original
+
+          #stub methods in source_process_pull_request_payload
+          allow(CapsuleCD::GitUtils).to receive(:clone).and_return(source_git_local_path)
+          allow(CapsuleCD::GitUtils).to receive(:fetch).and_return(true)
+          allow(CapsuleCD::GitUtils).to receive(:checkout).and_return(true)
+
+          #stub methods in build_step
+          allow(CapsuleCD::GitUtils).to receive(:create_gitignore).with(source_git_local_path, ['ChefCookbook']).and_return(true)
+
+          #stub methods in package_step
+          allow(CapsuleCD::GitUtils).to receive(:commit).and_return(true)
+          allow(CapsuleCD::GitUtils).to receive(:tag).with(source_git_local_path,'v0.1.11').and_return(git_commit_double)
+          allow(git_commit_double).to receive(:sha).and_return('0a5948802a2bba02e019fd13bf3db3c5329faae6')
+          allow(git_commit_double).to receive(:name).and_return('0.1.11')
+
+          #stub methods in release_step
+          allow(Open3).to receive(:popen3).with("knife cookbook site share cookbook_analogj_test Other -c #{File.expand_path('~/knife.rb')}").and_return(true)
+          allow(File).to receive(:open).with(File.expand_path('~/knife.rb'), 'w+').and_return(true)
+          allow(File).to receive(:open).with(File.expand_path('~/client.pem'), 'w+').and_return(true)
+
+          #stub methods in source_release
+          allow(CapsuleCD::GitUtils).to receive(:push).and_return(true)
+          allow(CapsuleCD::GitUtils).to receive(:generate_changelog).and_return('')
+
+          engine.start
+
+        end
+
+      end
+    end
+  end
+
+end

data/spec/lib/capsulecd/cli_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'rspec/support/spec/in_sub_process'
+require 'capsulecd/cli'
+require 'capsulecd/base/engine'
+
+describe CapsuleCD::Cli do
+  describe '#start' do
+    describe 'with default_engine' do
+      let(:engine_double) { instance_double(CapsuleCD::Engine, start: true) }
+      it 'should call the default start command with the proper options' do
+        expect(CapsuleCD::Engine).to receive(:new).with(
+          runner: :default, source: :default, package_type: :default, dry_run: false).and_return engine_double
+
+        CapsuleCD::Cli.start %w(start)
+      end
+    end
+
+    describe 'with node_engine', :node do
+      require 'capsulecd/node/node_engine'
+      let(:engine_double) { instance_double(CapsuleCD::Node::NodeEngine, start: true) }
+      it 'should call the node start command with the proper options' do
+        expect(CapsuleCD::Node::NodeEngine).to receive(:new).with(
+          runner: :default, source: :default, package_type: :node, dry_run: false).and_return engine_double
+
+        CapsuleCD::Cli.start %w(start --package_type node)
+      end
+    end
+
+    describe 'with chef_engine', :chef do
+      let(:engine_double) do
+        require 'capsulecd/chef/chef_engine'
+        instance_double(CapsuleCD::Chef::ChefEngine, start: true)
+      end
+      it 'should call the chef start command with the proper options' do
+        require 'capsulecd/chef/chef_engine'
+        expect(CapsuleCD::Chef::ChefEngine).to receive(:new).with(
+          runner: :default, source: :default, package_type: :chef, dry_run: false).and_return engine_double
+
+        CapsuleCD::Cli.start %w(start --package_type chef)
+      end
+    end
+
+    describe 'with python_engine', :python do
+      let(:engine_double) do
+        require 'capsulecd/python/python_engine'
+        instance_double(CapsuleCD::Python::PythonEngine, start: true)
+      end
+      it 'should call the python start command with the proper options' do
+        require 'capsulecd/python/python_engine'
+        expect(CapsuleCD::Python::PythonEngine).to receive(:new).with(
+          runner: :default, source: :default, package_type: :python, dry_run: false).and_return engine_double
+
+        CapsuleCD::Cli.start %w(start --package_type python)
+      end
+    end
+  end
+end