slugforge 4.0.0

data/spec/slugforge/models/host_group/aws_tag_group_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'slugforge/models/host_group/aws_tag_group'
+
+describe Slugforge::AwsTagGroup do
+  let(:compute) { ::Fog::Compute.new(:provider => 'AWS', :aws_access_key_id => '', :aws_secret_access_key => '') }
+  
+  let(:server_objects) do
+    3.times.map { compute.servers.create }.each { |s| s.wait_for { ready? } }
+  end
+
+  after(:each) do
+    server_objects.each { |server| server.destroy }
+  end
+
+  describe '.detect' do
+    context 'valid instance' do
+      let(:results) { described_class.detect(pattern, compute) }
+      let(:tag_key)   { 'name' }
+      let(:tag_value) { 'valid' }
+      let(:pattern) { "#{tag_key}=#{tag_value}" }
+
+      context 'one host is found' do
+        before(:each) { server_objects.first.tags[tag_key] = tag_value }
+
+        it 'returns the array with one element' do
+          results.hosts.count.should == 1
+        end
+
+        it 'returns an array of FogHosts' do
+          results.hosts.select { |host| host.class == Slugforge::FogHost }.count.should == results.hosts.count
+        end
+      end
+
+      context 'multiple hosts are found' do
+        before(:each) { server_objects.each { |s| s.tags[tag_key] = tag_value } }
+
+        it 'returns the array with all hosts' do
+          results.hosts.count.should == server_objects.count
+        end
+
+        it 'returns an array of FogHosts' do
+          results.hosts.select { |host| host.class == Slugforge::FogHost }.count.should == results.hosts.count
+        end
+      end
+    end
+
+    context 'no hosts are found' do
+      let(:results) { described_class.detect(pattern, compute) }
+      let(:pattern) { 'name=value' }
+      it { results.should be_nil }
+    end
+  end
+end
+

data/spec/slugforge/models/host_group/ec2_instance_group_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'slugforge/models/host_group/ec2_instance_group'
+
+describe Slugforge::Ec2InstanceGroup do
+  let(:compute) { ::Fog::Compute.new(:provider => 'AWS', :aws_access_key_id => '', :aws_secret_access_key => '') }
+  
+  let(:server_objects) do
+    3.times.map { compute.servers.create }.each { |s| s.wait_for { ready? } }
+  end
+
+  after(:each) do
+    server_objects.each { |server| server.destroy }
+  end
+
+  describe '.detect' do
+    context 'valid instance' do
+      let(:results) { described_class.detect(pattern, compute) }
+      let(:pattern) { server_objects.first.id }
+
+      it 'returns the array with one element' do
+        results.hosts.count.should == 1
+      end
+      
+      it 'returns an array of FogHosts' do
+        results.hosts.select { |host| host.class == Slugforge::FogHost }.count.should == results.hosts.count
+      end
+    end
+
+    context 'invalid instance' do
+      context 'pattern is too short' do
+        let(:results) { described_class.detect(pattern, compute) }
+        let(:pattern) { 'i-1234567' }
+        it { results.should be_nil }
+      end
+
+      context 'pattern is too long' do
+        let(:results) { described_class.detect(pattern, compute) }
+        let(:pattern) { 'i-123456789' }
+        it { results.should be_nil }
+      end
+
+      context 'instance does not exist' do
+        let(:results) { described_class.detect(pattern, compute) }
+        # This host *could* exist, but it's a long shot
+        let(:pattern) { 'i-00000000' }
+        it { results.should be_nil }
+      end
+    end
+  end
+end
+

data/spec/slugforge/models/host_group/hostname_group_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'slugforge/models/host_group/hostname_group'
+
+describe Slugforge::HostnameGroup do
+  describe '.detect' do
+    context 'the pattern matches' do
+      let(:results) { described_class.detect(pattern, nil) }
+      let(:pattern) { 'ec2-something.compute-1.amazon.aws.com' }
+      
+      it 'returns the array with one element' do
+        results.hosts.count.should == 1
+      end
+      
+      it 'returns an array of HostnameHosts' do
+        results.hosts.select { |host| host.class == Slugforge::HostnameHost }.count.should == results.hosts.count
+      end
+    end
+  end
+end
+

data/spec/slugforge/models/host_group/ip_address_group_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'slugforge/models/host_group/ip_address_group'
+
+describe Slugforge::IpAddressGroup do
+  describe '.detect' do
+    context 'valid address pattern' do
+      let(:results) { described_class.detect(pattern, nil) }
+
+      context 'short octets' do
+        let(:pattern) { '1.2.3.4' }
+
+        it 'returns an array with one element' do
+          results.hosts.count.should == 1
+        end
+
+        it 'returns an array of IpAddressHosts' do
+          results.hosts.select { |host| host.class == Slugforge::IpAddressHost }.count.should == results.hosts.count
+        end
+      end
+
+      context 'long octets' do
+        let(:pattern) { '123.234.111.222' }
+
+        it 'returns an array with one element' do
+          results.hosts.count.should == 1
+        end
+
+        it 'returns an array of IpAddressHosts' do
+          results.hosts.select { |host| host.class == Slugforge::IpAddressHost }.count.should == results.hosts.count
+        end
+      end
+    end
+
+    context 'invalid address pattern' do
+      let(:results) { described_class.detect(pattern, nil) }
+
+      context 'the pattern contains letters' do
+        let(:pattern) { '1.2.a.4' }
+        it { results.should be_nil }
+      end
+
+      context 'the pattern contains less than 4 octets' do
+        let(:pattern) { '1.2.3' }
+        it { results.should be_nil }
+      end
+
+      context 'the pattern contains more than 4 octets' do
+        let(:pattern) { '1.2.3.4.5' }
+        it { results.should be_nil }
+      end
+    end
+  end
+end
+

data/spec/slugforge/models/host_group/security_group_group_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'slugforge/models/host_group/security_group_group'
+
+describe Slugforge::SecurityGroupGroup do
+  let(:compute) { ::Fog::Compute.new(:provider => 'AWS', :aws_access_key_id => '', :aws_secret_access_key => '') }
+  
+  let(:server_objects) do
+    3.times.map { compute.servers.create }.each { |s| s.wait_for { ready? } }
+  end
+
+  after(:each) do
+    server_objects.each { |server| server.destroy }
+  end
+
+  describe '.detect' do
+    context 'valid instance' do
+      let(:results) { described_class.detect(pattern, compute) }
+      let(:pattern) { 'group' }
+
+      context 'one host is found' do
+        before(:each) { server_objects.first.groups << pattern }
+
+        it 'returns the array with one element' do
+          results.hosts.count.should == 1
+        end
+
+        it 'returns an array of FogHosts' do
+          results.hosts.select { |host| host.class == Slugforge::FogHost }.count.should == results.hosts.count
+        end
+      end
+
+      context 'multiple hosts are found' do
+        before(:each) { server_objects.each { |s| s.groups << pattern } }
+
+        it 'returns the array with all hosts' do
+          results.hosts.count.should == server_objects.count
+        end
+
+        it 'returns an array of FogHosts' do
+          results.hosts.select { |host| host.class == Slugforge::FogHost }.count.should == results.hosts.count
+        end
+      end
+    end
+
+    context 'no hosts are found' do
+      let(:results) { described_class.detect(pattern, compute) }
+      let(:pattern) { 'name=value' }
+      it { results.should be_nil }
+    end
+  end
+end
+

data/spec/slugforge/models/tag_manager_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'slugforge/models/tag_manager'
+
+describe Slugforge::TagManager do
+
+  let(:s3)      { ::Fog::Storage.new(
+                  :aws_access_key_id     => 'aws_access_key_id',
+                  :aws_secret_access_key => 'aws_secret_access_key',
+                  :provider              => 'AWS',
+                  :region                => 'us-east-1')
+                }
+  let(:tm)      { Slugforge::TagManager.new(:s3 => s3, :bucket => 'tj-slugforge') }
+  let!(:bucket) { s3.directories.create(:key => 'tj-slugforge') }
+
+  context "projects" do
+    it "list of projects should start empty" do
+      tm.projects.should be_empty
+    end
+
+    context "with a project" do
+      before(:each) do
+        bucket.files.create(:key => 'project1/test.slug')
+        bucket.files.create(:key => 'project2/test.slug')
+      end
+
+      it "list of projects should include all projects" do
+        tm.projects.should include("project1")
+        tm.projects.should include("project2")
+      end
+    end
+  end
+
+  context "tags" do
+    before(:each) do
+      bucket.files.create(:key  => 'project1/test.slug')
+      bucket.files.create(:key  => 'project2/test.slug')
+      bucket.files.create(
+        :key  => 'project2/tags/prod',
+        :body => "test.slug\nold.slug"
+      )
+    end
+
+    context "invalid project" do
+      it "lists no tags" do
+        tm.tags('bad_project').should be_empty
+      end
+    end
+
+    context "with no tags" do
+      it "lists no tags" do
+        tm.tags('project1').should be_empty
+      end
+    end
+
+    context "with tags" do
+      it "lists the tags" do
+        tm.tags('project2').should include('prod')
+      end
+
+      it "lists only the current slug for the tag" do
+        tm.slug_for_tag('project2', 'prod').should include('test.slug')
+        tm.slug_for_tag('project2', 'prod').should_not include('old.slug')
+      end
+
+      it "lists the slug history for the tag" do
+        tm.slugs_for_tag('project2', 'prod').should include('old.slug')
+      end
+
+      it "lists the tags for a slug" do
+        tm.tags_for_slug('project2', 'test.slug').should include('prod')
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+end
+
+$: << File.expand_path('../../lib', __FILE__)
+require 'slugforge'
+require 'fakefs/spec_helpers'
+
+ENV["THOR_DEBUG"] = "1"
+
+# Load support files
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }
+
+def fixture_file(file)
+  File.expand_path(File.join("../fixtures", file), __FILE__)
+end
+
+def with_env(env)
+  old_env = env.reduce({}) { |old,(k,v)| old[k] = ENV[k]; ENV[k] = v; old }
+  yield
+  old_env.each { |k,v| ENV[k] = v }
+end
+
+RSpec.configure do |config|
+  config.before(:all) do
+    Slugforge::Configuration.configuration_files = [ 'slugforge.yml' ]
+
+    sanitize_environment! /AWS_|EC2_|S3_|JENKINS_|SLUGFORGE_/
+  end
+
+  config.include FakeFS::SpecHelpers
+  config.include HelperProvider
+  config.include ConfigurationWriter
+end

data/spec/support/env.rb

@@ -0,0 +1,3 @@
+def sanitize_environment! (pattern)
+  ENV.keys.select { |k| k =~ pattern }.each { |k| ENV[k] = nil }
+end

data/spec/support/example_groups/configuration_writer.rb

@@ -0,0 +1,24 @@
+require 'active_support/concern'
+
+module ConfigurationWriter
+  extend ActiveSupport::Concern
+
+  included do
+    def write_config_file(configuration)
+      File.open(Slugforge::Configuration.configuration_files.first, "w+") do |f|
+        f.write configuration.to_yaml
+      end
+    end
+
+    # Only do this configuration when specifically requested by setting :config => true on the example group
+    before(:each, :config => true) do
+      write_config_file 'aws' => {
+        'access_key' => 'zzz-access-key',
+        'secret_key' => 'zzz-secret-key',
+        'slug_bucket' => 'tj-slugforge'
+      }
+
+      helpers.s3.directories.create({key: 'tj-slugforge'})
+    end
+  end
+end

data/spec/support/example_groups/helper_provider.rb

@@ -0,0 +1,10 @@
+require 'active_support/concern'
+
+module HelperProvider
+  extend ActiveSupport::Concern
+
+  included do
+    let(:helpers) { SpecHelpers.new }
+  end
+end
+

data/spec/support/factories.rb

@@ -0,0 +1,18 @@
+def create_slug(project, name, content = "blag")
+  bucket = helpers.s3.directories.new(:key => 'tj-slugforge')
+  bucket.files.create :key => "#{project}/#{name}.slug", :body => "blah"
+end
+
+def create_tag(project, tag, slug)
+  bucket = helpers.s3.directories.new(:key => 'tj-slugforge')
+  bucket.files.create :key => "#{project}/tags/#{tag}", :body => "#{project}/#{slug}"
+end
+
+def build_sts_response
+  double('STS Response', :body => {
+    'AccessKeyId' => "access-#{rand(1000)}",
+    'AwsRegion' => "region-#{rand(1000)}",
+    'SecretAccessKey' => "secret-#{rand(1000)}",
+    'SessionToken' => "session-#{rand(1000)}"
+    })
+end

data/spec/support/fog.rb

@@ -0,0 +1,15 @@
+RSpec.configure do |config|
+  config.before(:all) do
+    Fog.mock!
+    Fog::Mock.delay = 0
+  end
+
+  config.before(:each) do
+    # Fog does not provide STS mocks yet
+    ::Fog::AWS::STS.stub(:new) {
+      double(::Fog::AWS::STS,
+        :get_session_token => build_sts_response,
+        :get_federation_token => build_sts_response)
+    }
+  end
+end

data/spec/support/helpers.rb

@@ -0,0 +1,18 @@
+class SpecHelpers
+  def self.class_option(*); end
+  def self.source_root(*); end
+
+  include Slugforge::Helper
+
+  def initialize(args=[], options={}, config={})
+    @config = Slugforge::Configuration.new(options)
+  end
+
+  def config; @config; end
+
+  def options; {}; end
+
+  def metadata
+    parse_metadata_file
+  end
+end