slugforge 4.0.0

data/spec/fixtures/array.yaml

@@ -0,0 +1,3 @@
+- a
+- b
+

data/spec/fixtures/fog_credentials.yaml

@@ -0,0 +1,4 @@
+default:
+  aws_access_key_id: 'aws-access-key-id'
+  aws_secret_access_key: 'aws-secret-access-key'
+  region: 'us-east-1'

data/spec/fixtures/invalid_syntax.yaml

@@ -0,0 +1 @@
+foo: -

data/spec/fixtures/one.yaml

@@ -0,0 +1,3 @@
+test_option: 1
+foo:
+  bar: "baz"

data/spec/fixtures/two.yaml

@@ -0,0 +1,3 @@
+test_option: 2
+foo:
+  bar: "baz"

data/spec/fixtures/valid.yaml

@@ -0,0 +1,4 @@
+test: foo
+foo:
+  bar: baz
+

data/spec/slugforge/commands/deploy_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'json'
+
+describe Slugforge::Commands::Deploy, :config => true do
+
+  describe "deployment via" do
+    let(:project)   { "zany" }
+    let(:host)      { "example.com" }
+    let(:opts)      { %w(--force --json) }
+    let(:config)    { %w() }
+    let(:cmd)       { ["deploy", operation, target, "--project", project, host, opts, config].flatten }
+    let(:stdout)    { StringIO.new }
+    let(:stderr)    { StringIO.new }
+    let(:output)    { capture(:stdout, stdout) { capture(:stderr, stderr) { Slugforge::Cli.start(cmd) } } }
+    let(:result)    { JSON.parse(output) }
+    let(:s3_root)   { "s3://#{helpers.config.values[:slug_bucket]}/#{project}" }
+
+    shared_examples_for "a deployment method" do
+      it "should succeed" do
+        begin
+          result["success"].should == true
+        rescue SystemExit
+          fail stderr.string
+        end
+      end
+
+      it "has a full slug path" do
+        Slugforge::Commands::Deploy.any_instance.should_receive(:deploy).with(anything, anything, hash_including(locator))
+        output
+      end
+    end
+
+    describe "#file" do
+      let(:operation) { "file" }
+      let(:target)    { "artifact.slug" }
+      let(:locator)   { {:filename => target} }
+
+      it_should_behave_like "a deployment method"
+    end
+
+    describe "#tag" do
+      let(:operation) { "tag" }
+      let(:target)    { "testing" }
+      let(:slug_name) { "123.slug" }
+      let(:locator)   { {:s3_url => "#{s3_root}/#{slug_name}"} }
+
+      context "with existing tagged slug" do
+        before(:each) do
+          create_slug project, slug_name
+          create_tag project, target, slug_name
+        end
+
+        it_should_behave_like "a deployment method"
+      end
+    end
+
+    describe "#name" do
+      let(:operation) { "name" }
+      let(:target)    { "123456" }
+      let(:locator)   { {:s3_url => "#{s3_root}/#{target}.slug"} }
+
+      context "with existing named slug" do
+        before(:each) do
+          create_slug project, "#{target}"
+        end
+
+        it_should_behave_like "a deployment method"
+      end
+    end
+  end
+
+end

data/spec/slugforge/commands_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Slugforge::Command do
+  let(:command_class) { Class.new(Slugforge::Command) }
+  let(:stdout)        { StringIO.new }
+  let(:stderr)        { StringIO.new }
+  let(:args)          { [] }
+  let(:command)       { capture(:stdout, stdout) { capture(:stderr, stderr) { command_class.start(args) } } }
+
+  describe "slugin loading" do
+    context "in a command" do
+      it "should only activate slugins once" do
+        Slugforge::SluginManager.any_instance.should_receive(:activate_slugins).once
+          command
+      end
+    end
+
+    context "in a subcommand" do
+      let(:subcommand_class) { Class.new(Slugforge::SubCommand) }
+      let(:args) { [ 'sub' ] }
+
+      before(:each) do
+        command_class.desc 'sub [THING]', 'test subcommand'
+        command_class.subcommand 'sub', subcommand_class
+      end
+
+      it "should only activate slugins once" do
+        Slugforge::SluginManager.any_instance.should_receive(:activate_slugins).once
+        command
+      end
+    end
+  end
+end

data/spec/slugforge/configuration_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+describe Slugforge::Configuration do
+
+  # Use a subclass that can be safely modified without destroying other specs
+  let(:described_class) do
+    Class.new(Slugforge::Configuration) do
+      self.configuration_files = []
+    end
+  end
+
+  subject { described_class.new }
+
+  before(:each) do
+    # Ensure we have a clean configuration object for each test
+    described_class.instance_variable_set(:@options, {})
+  end
+
+  describe '.option' do
+    it 'defines an instance method with the option name' do
+      described_class.option(:test_option, {})
+      subject.should respond_to(:test_option)
+    end
+
+    it 'raies an error if a duplicate option is defined' do
+      described_class.option(:test_option, {})
+      expect { described_class.option(:test_option, {}) }.to raise_error
+    end
+  end
+
+  describe 'programatically defined methods' do
+    describe 'on the instance' do
+      it 'returns the options value' do
+        described_class.option(:test_option, {})
+        subject.instance_variable_set(:@values, {:test_option => 'test'})
+        subject.test_option.should == 'test'
+      end
+    end
+  end
+
+  describe "loading config" do
+    let!(:option) { described_class.option(:test_option, {:default => 'test' }) }
+
+    it 'applies default values' do
+      subject.test_option.should == 'test'
+    end
+
+    context 'from conf files' do
+      before(:each) do
+        FakeFS.deactivate!
+      end
+
+      it "should fail with invalid YAML" do
+        described_class.configuration_files = [ fixture_file("invalid_syntax.yaml") ]
+        expect { subject }.to raise_error
+      end
+
+      it "should gracefully handle non-hash contents" do
+        described_class.configuration_files = [ fixture_file("array.yaml") ]
+        expect { subject }.to_not raise_error
+      end
+
+      context "with a missing configuration file" do
+        before(:each) do
+          described_class.configuration_files = [ "xxxxx.yaml" ]
+        end
+
+        it "applies the defaults" do
+          subject.test_option.should == "test"
+        end
+      end
+
+      context "with single configuration file" do
+        let!(:option) { described_class.option(:test_option, {:default => 'test', :key => 'test'}) }
+
+        before(:each) do
+          described_class.configuration_files = [ fixture_file("valid.yaml") ]
+        end
+
+        it "should load values mapped by their configuration key" do
+          subject.test_option.should == 'foo'
+        end
+
+        context "and a dotted conf key" do
+          let!(:option) { described_class.option(:test_option, {:key => 'foo.bar'}) }
+
+          it "should load nested value" do
+            subject.test_option.should == 'baz'
+          end
+        end
+      end
+
+      context "with multiple configuration files" do
+        let!(:option) { described_class.option(:test_option, {:key => 'test_option'}) }
+
+        before(:each) do
+          described_class.configuration_files = [ fixture_file("one.yaml"), fixture_file("two.yaml") ]
+        end
+
+        it "should override the values in the first file with values from the second" do
+          subject.test_option.should == 2
+        end
+
+        context "and a dotted conf key" do
+          let!(:option) { described_class.option(:test_option, {:key => 'foo.bar'}) }
+
+          it "should load and override nested values" do
+            subject.test_option.should == "baz"
+          end
+        end
+      end
+    end
+
+    context "from ENV" do
+      let!(:option) { described_class.option(:test_option, {:default => 'test', :key => 'test_option', :env => 'TEST_OPTION'}) }
+
+      around(:each) do |example|
+        with_env('TEST_OPTION' => 'foo') { example.run }
+      end
+
+      it 'should assign values from mapped variables' do
+        subject.test_option.should == 'foo'
+      end
+
+      context "with conf file" do
+        before(:each) do
+          described_class.configuration_files = [ fixture_file("one.yaml") ]
+        end
+
+        it "should prefer ENV" do
+          subject.test_option.should == 'foo'
+        end
+      end
+    end
+
+    context "from CLI options" do
+      let!(:option) { described_class.option(:test_option, {:default => 'test', :option => :'test-option'}) }
+
+      subject { described_class.new :'test-option' => 'foo' }
+
+      it "should load value from mapped option" do
+        subject.test_option.should == 'foo'
+      end
+
+      context "with ENV present" do
+        let!(:option) { described_class.option(:test_option, {:default => 'test', :option => :'test-option', :env => 'TEST_OPTION'}) }
+
+        around(:each) do |example|
+          with_env('TEST_OPTION' => 'bar') { example.run }
+        end
+
+        it 'should prefer setting from CLI' do
+          subject.test_option.should == 'foo'
+        end
+      end
+    end
+  end
+
+  describe '#update_with' do
+    it 'yields for every option' do
+      options = {
+        :a => {:key => 'a'},
+        :b => {:key => 'b'}
+      }
+
+      described_class.option(:a, options[:a])
+      described_class.option(:b, options[:b])
+      expect { |b| subject.send(:update_with, &b) }.to yield_successive_args(options[:a], options[:b])
+    end
+
+    context 'when the block returns a value' do
+      it 'updates the options value' do
+        described_class.option(:a, {})
+        subject.instance_variable_set(:@values, {:a => 'false'} )
+        blk = proc { |c| 'true' }
+        subject.send(:update_with, &blk)
+        subject.a.should == 'true'
+      end
+
+      it 'same for "falsey" but not nil' do
+        described_class.option(:a, {})
+        subject.instance_variable_set(:@values, {:a => 'false'} )
+        blk = proc { |c| false }
+        subject.send(:update_with, &blk)
+        subject.a.should == false
+      end
+    end
+
+    context 'when the block does not return a value' do
+      it 'leaves the options value as-is' do
+        described_class.option(:a, {})
+        subject.instance_variable_set(:@values, {:a => 'false'} )
+        blk = proc { |c| nil }
+        subject.send(:update_with, &blk)
+        subject.a.should == 'false'
+      end
+    end
+  end
+end
+

data/spec/slugforge/helper/fog_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Slugforge::Helper::Fog, :config => false do
+  let(:command_class) do
+    Class.new(Slugforge::Command) do
+      include Slugforge::Helper::Config
+      include Slugforge::Helper::Fog
+
+      desc 'test', 'An example command'
+      def test; end
+    end
+  end
+
+  let(:options) {{ 'aws-access-key-id' => 'abc', 'aws-region' => 'north-pole-9', 'aws-secret-key' => '123', 'slug-bucket' => 'bucket' }}
+
+  let(:command) { command_class.new [], options }
+
+  context "#aws_credentials" do
+    subject(:aws_credentials) { command.aws_credentials }
+
+    it "should error without access key" do
+      options.delete('aws-access-key-id')
+      expect { aws_credentials }.to raise_error(/access key/)
+    end
+
+    it "should error without secret key" do
+      options.delete('aws-secret-key')
+      expect { aws_credentials }.to raise_error(/secret key/)
+    end
+
+    it "should not error without session token" do
+      expect { aws_credentials }.to_not raise_error
+    end
+
+    context "response hash" do
+      it "should include key and secret" do
+        expect(aws_credentials).to eq({:aws_access_key_id => 'abc', :aws_secret_access_key => '123'})
+      end
+
+      context "when session token is set" do
+        let(:options) {{ 'aws-access-key-id' => 'abc', 'aws-secret-key' => '123', 'aws-session-token' => 'xyz' }}
+
+        it "should include session token" do
+          expect(aws_credentials).to eq({
+            :aws_session_token     => 'xyz',
+            :aws_access_key_id     => 'abc',
+            :aws_secret_access_key => '123'})
+        end
+      end
+    end
+  end
+
+  context "#aws_session" do
+    # Fog doesn't have an STS mock yet
+    let(:response)    { build_sts_response }
+    let(:session)     { response.body }
+    let(:username)    { 'user name' }
+    let(:sts)         { double(::Fog::AWS::STS, :get_federation_token => response) }
+
+    before(:each) do
+      ::Fog::AWS::STS.stub(:new) { sts }
+    end
+
+    it "should exchange aws credentials for a federation session token" do
+      command.stub(:username).and_return(username)
+      ::Fog::AWS::STS.should_receive(:new).with(command.aws_credentials) { sts }
+      sts.should_receive(:get_federation_token).with(username, instance_of(Hash), instance_of(Fixnum))
+
+      command.aws_session
+    end
+
+    it "should return a session hash matching what fog expects for credentials" do
+      expect(command.aws_session).to eq({
+        :aws_access_key_id     => session['AccessKeyId'],
+        :aws_region            => options['aws-region'],
+        :aws_secret_access_key => session['SecretAccessKey'],
+        :aws_session_token     => session['SessionToken']
+      })
+    end
+  end
+end

data/spec/slugforge/helper/git_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe Slugforge::Helper::Git do
+  class DummyClass
+    attr_accessor :options
+  end
+
+  let(:dummy_class)    { DummyClass.new }
+  let(:git_account)    { 'GitAccount' }
+  let(:git_repository) { 'repository' }
+  let(:git_branch)     { 'master' }
+  let(:git_remote)     { 'remote' }
+  let(:git_url)        { "git@github.com:#{git_account}/#{git_repository}.git" }
+  let(:git_sha)        { '0123456789abcdef0123456789abcdef01234567' }
+
+  before(:each) do
+    dummy_class.extend(subject)
+    dummy_class.stub(:error_class).and_return(Thor::Error)
+  end
+
+  context 'not inside work tree' do
+    before(:each) { dummy_class.stub(:git_inside_work_tree?).and_return(false) }
+
+    it '#git_account returns nil' do
+      dummy_class.git_account.should be_nil
+    end
+    it '#git_repository returns nil' do
+      dummy_class.git_repository.should be_nil
+    end
+    it '#git_branch returns nil' do
+      dummy_class.git_branch.should be_nil
+    end
+    it '#git_remote returns nil' do
+      dummy_class.git_remote.should be_nil
+    end
+    it '#git_remote_sha returns nil' do
+      dummy_class.git_remote_sha.should be_nil
+    end
+    it '#git_url returns empty' do
+      dummy_class.git_url.should be_empty
+    end
+    it '#git_sha raises' do
+      expect { dummy_class.git_sha }.to raise_error(Thor::Error)
+    end
+  end
+
+  context 'inside work tree' do
+    before(:each) { dummy_class.stub(:git_inside_work_tree?).and_return(true) }
+    context 'git_url is empty' do
+      before(:each) { dummy_class.stub(:git_url).and_return('') }
+
+      it '#git_account returns nil' do
+        dummy_class.git_account.should be_nil
+      end
+      it '#git_repository returns nil' do
+        dummy_class.git_repository.should be_nil
+      end
+    end
+
+    context 'git_url is valid (SSH)' do
+      before(:each) { dummy_class.stub(:git_url).and_return(git_url) }
+
+      it '#git_accout returns account' do
+        dummy_class.git_account.should == git_account
+      end
+      it '#git_repository returns repository' do
+        dummy_class.git_repository.should == git_repository
+      end
+    end
+
+    context 'git_url is valid (HTTPS)' do
+      let(:git_url) { "https://github.com/#{git_account}/#{git_repository}" }
+
+      before(:each) { dummy_class.stub(:git_url).and_return(git_url) }
+
+      it '#git_accout returns account' do
+        dummy_class.git_account.should == git_account
+      end
+      it '#git_repository returns repository' do
+        dummy_class.git_repository.should == git_repository
+      end
+    end
+
+    describe '#git_remote_sha' do
+      before(:each) do
+        dummy_class.stub(:git_command).and_return(git_sha)
+        dummy_class.stub(:git_url).and_return(git_url)
+        dummy_class.stub(:git_branch).and_return(git_branch)
+      end
+
+      context 'no options specified' do
+        it 'returns first 10 characters of SHA' do
+          dummy_class.git_remote_sha.should == git_sha.slice(0...10)
+        end
+      end
+
+      context 'sha_length specified' do
+        it 'returns first character when sha_length=1' do
+          dummy_class.git_remote_sha(:sha_length => 1).should == git_sha.slice(0...1)
+        end
+        
+        it 'returns all characters when sha_length=40' do
+          dummy_class.git_remote_sha(:sha_length => 40).should == git_sha.slice(0...40)
+        end
+        
+        it 'returns all characters when sha_length>40' do
+          dummy_class.git_remote_sha(:sha_length => 50).should == git_sha.slice(0...40)
+        end
+      end
+
+      context 'url specified' do
+        it 'git_command receives url' do
+          test_url = 'test_url'
+          dummy_class.git_remote_sha(:url => test_url)
+          dummy_class.should have_received(:git_command).with("ls-remote #{test_url} #{git_branch}")
+        end
+      end
+
+      context 'branch specified' do
+        it 'git_command receives branch' do
+          test_branch = 'test_branch'
+          dummy_class.git_remote_sha(:branch => test_branch)
+          dummy_class.should have_received(:git_command).with("ls-remote #{git_url} #{test_branch}")
+        end
+      end
+    end
+
+    describe '#git_sha' do
+      before(:each) { dummy_class.stub(:git_command).and_return(git_sha) }
+
+      context 'no options specified' do
+        it 'returns first 10 characters of SHA' do
+          dummy_class.git_sha.should == git_sha.slice(0...10)
+        end
+      end
+
+      context 'sha_length specified' do
+        it 'returns first character when sha_length=1' do
+          dummy_class.git_sha(:sha_length => 1).should == git_sha.slice(0...1)
+        end
+        
+        it 'returns all characters when sha_length=40' do
+          dummy_class.git_sha(:sha_length => 40).should == git_sha.slice(0...40)
+        end
+        
+        it 'returns all characters when sha_length>40' do
+          dummy_class.git_sha(:sha_length => 50).should == git_sha.slice(0...40)
+        end
+      end
+    end
+  end
+end