motherbrain 0.0.0.placeholder → 0.13.1

data/spec/unit/mb/provisioner/provision_data_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe MotherBrain::Provisioner::ProvisionData do
+  subject { provision_data }
+
+  let(:provision_data) { described_class.new(environment_name) }
+
+  let(:data_bag) { ridley.data_bag.find(described_class::DATA_BAG) }
+  let(:data_bag_attributes) { data_bag_item.attributes }
+  let(:data_bag_item) { data_bag.item.find(environment_name) }
+  let(:environment_name) { "test" }
+  let(:instances) {
+    [
+      {
+        instance_id: "i-abcdefb1",
+        instance_type: "m1.large",
+        public_hostname: "box1.cloud.example.com"
+      },
+      {
+        instance_id: "i-abcdefb2",
+        instance_type: "m1.large",
+        public_hostname: "box2.cloud.example.com"
+      }
+    ]
+  }
+  let(:provisioner_name) { "aws" }
+
+  describe "#instances" do
+    it "returns an empty hash by default" do
+      expect(provision_data.instances).to eq({})
+    end
+
+    it "saves an empty hash to the data bag" do
+      provision_data.instances
+
+      provision_data.save
+
+      expect(data_bag_attributes[:instances]).to eq({})
+    end
+  end
+
+  describe "#add_instances_to_provisioner" do
+    it "adds the instances to the data bag" do
+      provision_data.add_instances_to_provisioner provisioner_name, instances
+
+      provision_data.save
+
+      expect(
+        data_bag_attributes[:instances][provisioner_name].map(&:to_hash).map(&:symbolize_keys)
+      ).to match_array(instances)
+    end
+
+    it "is idempotent" do
+      provision_data.add_instances_to_provisioner provisioner_name, instances
+      provision_data.add_instances_to_provisioner provisioner_name, instances
+
+      provision_data.save
+
+      expect(
+        data_bag_attributes[:instances][provisioner_name].map(&:to_hash).map(&:symbolize_keys)
+      ).to match_array(instances)
+    end
+  end
+
+  describe "#remove_instance_from_provisioner" do
+    it "removes an instance from a provisioner by key/value pair" do
+      provision_data.add_instances_to_provisioner provisioner_name, instances
+      provision_data.remove_instance_from_provisioner provisioner_name,
+        :instance_id, instances.first[:instance_id]
+
+      expect(provision_data.instances[provisioner_name]).to match_array([instances.last])
+    end
+  end
+
+  describe "#provisioners" do
+    it "lists all provisioners with instances for this environment" do
+      provision_data.add_instances_to_provisioner provisioner_name, instances
+
+      expect(provision_data.provisioners).to match_array([provisioner_name])
+    end
+  end
+
+  describe "#instances_for_provisioner" do
+    it "returns an empty array by default" do
+      expect(provision_data.instances_for_provisioner(:aws)).to eq([])
+    end
+
+    it "returns all instances for a provisioner" do
+      provision_data.add_instances_to_provisioner provisioner_name, instances
+
+      expect(
+        provision_data.instances_for_provisioner(:aws)
+      ).to match_array(instances)
+    end
+  end
+
+  describe "#save" do
+    it "creates a data bag item" do
+      provision_data.save
+
+      expect(data_bag_item).to_not be_nil
+    end
+  end
+
+  describe "#destroy" do
+    it "creates a data bag item" do
+      provision_data.save
+      provision_data.destroy
+
+      expect(data_bag_item).to be_nil
+    end
+  end
+end

data/spec/unit/mb/provisioner_spec.rb

@@ -0,0 +1,251 @@
+require 'spec_helper'
+
+describe MB::Provisioner do
+  subject { described_class }
+
+  before(:each) do
+    @original = described_class.all
+    described_class.clear!
+  end
+
+  after(:each) do
+    described_class.clear!
+    @original.each { |k| described_class.register(k) }
+  end
+
+  describe "::all" do
+    it "returns a set" do
+      subject.all.should be_a(Set)
+    end
+  end
+
+  describe "::register" do
+    let(:provisioner_class) do
+      Class.new(described_class::Base) do
+        @provisioner_id = :hello
+      end
+    end
+
+    it "adds the given class to the list of registered provisioners" do
+      subject.register(provisioner_class)
+
+      subject.all.should have(1).item
+    end
+
+    describe "registered class" do
+      it "has the correct provisioner_id" do
+        subject.register(provisioner_class)
+
+        subject.all.first.provisioner_id.should eql(:hello)
+      end
+    end
+
+    context "given a class that does not respond to provisioner_id" do
+      let(:provisioner_class) { Class.new }
+
+      it "raises an InvalidProvisionerClass exception" do
+        expect {
+          subject.register(provisioner_class)
+        }.to raise_error(MB::InvalidProvisionerClass)
+      end
+    end
+
+    context "given a class with a nil value for provisioner_id" do
+      let(:provisioner_class) do
+        Class.new(described_class::Base) do
+          @provisioner_id = nil
+        end
+      end
+
+      it "raises an InvalidProvisionerClass exception" do
+        expect {
+          subject.register(provisioner_class)
+        }.to raise_error(MB::InvalidProvisionerClass)
+      end
+    end
+
+    context "when a provisioner with the given id has already been registered" do
+      it "raises an ProvisionerRegistrationError" do
+        rspec_provisioner = Class.new(described_class::Base) do
+          register_provisioner :rspec_provisioner
+        end
+
+        expect {
+          Class.new(described_class::Base) do
+            register_provisioner :rspec_provisioner
+          end
+        }.to raise_error(MB::ProvisionerRegistrationError)
+      end
+    end
+
+    context "given the :default option set to true" do
+      it "sets the given class as the default class" do
+        rspec_provisioner = Class.new(described_class::Base) do
+          register_provisioner :rspec_provisioner, default: true
+        end
+
+        subject.default.should eql(rspec_provisioner)
+      end
+
+      it "raises if there is already a default class" do
+        rspec_provisioner = Class.new(described_class::Base) do
+          register_provisioner :rspec_provisioner, default: true
+        end
+
+        expect {
+          Class.new(described_class::Base) do
+            register_provisioner :rspec_provisioner_two, default: true
+          end
+        }.to raise_error(MB::ProvisionerRegistrationError)
+      end
+    end
+  end
+
+  describe "::get" do
+    it "returns the provisioner class with the given provisioner_id" do
+      rspec_provisioner = Class.new(described_class::Base) do
+        register_provisioner :rspec_provisioner
+      end
+
+      subject.get(:rspec_provisioner).should eql(rspec_provisioner)
+    end
+  end
+
+  describe "::default" do
+    context "given there is a default provisioner class" do
+      it "returns the default provisioner class" do
+        rspec_provisioner = Class.new(described_class::Base) do
+          register_provisioner :rspec_provisioner, default: true
+        end
+
+        subject.default.should eql(rspec_provisioner)
+      end
+    end
+
+    context "when there is no default provisioner class" do
+      it "returns nil" do
+        subject.default.should be_nil
+      end
+    end
+  end
+end
+
+describe MB::Provisioner::Base do
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::validate_create" do
+      it "does not raise an error if the number of nodes in the response matches the expected in manifest" do
+        manifest = MB::Provisioner::Manifest.new.from_json(
+          {
+            nodes: [
+              {
+                type: "x1.large",
+                count: 2,
+                components: ["activemq::master"]
+              },
+              {
+                type: "x1.small",
+                count: 1,
+                components: ["nginx::server"]
+              }
+            ]
+          }.to_json)
+
+        response = [
+          {
+            name: "a1.riotgames.com",
+            instance_type: "x1.large"
+          },
+          {
+            name: "a2.riotgames.com",
+            instance_type: "x1.large"
+          },
+          {
+            name: "a3.riotgames.com",
+            instance_type: "x1.small"
+          }
+        ]
+
+        expect {
+          subject.validate_create(response, manifest)
+        }.to_not raise_error
+      end
+
+      it "raises an error if there are less nodes than the manifest expects" do
+        manifest = MB::Provisioner::Manifest.new.from_json({
+          nodes: [
+            {
+              type: "x1.large",
+              count: 2,
+              components: ["activemq::master"]
+            },
+            {
+              type: "x1.small",
+              components: ["nginx::server"]
+            }
+          ]
+        }.to_json)
+
+        response = [
+          {
+            name: "a1.riotgames.com",
+            instance_type: "x1.large"
+          }
+        ]
+
+        expect {
+          subject.validate_create(response, manifest)
+        }.to raise_error(MB::UnexpectedProvisionCount)
+      end
+
+      it "raises an error if there are more nodes than the manifest expects" do
+        manifest = MB::Provisioner::Manifest.new.from_json({
+          nodes: [
+            {
+              type: "x1.large",
+              components: ["activemq::master"]
+            }
+          ]
+        }.to_json)
+
+        response = [
+          {
+            name: "a1.riotgames.com",
+            instance_type: "x1.large"
+          },
+          {
+            name: "a2.riotgames.com",
+            instance_type: "x1.large"
+          }
+        ]
+
+        expect {
+          subject.validate_create(response, manifest)
+        }.to raise_error(MB::UnexpectedProvisionCount)
+      end
+    end
+  end
+
+  subject { described_class.new }
+
+  describe "#up" do
+    let(:job) { double('job') }
+    let(:env_name) { "rpsec" }
+    let(:manifest) { double('manifest') }
+    let(:plugin) { double('plugin') }
+
+    it "raises an AbstractFunction error" do
+      expect { subject.up(job, env_name, manifest, plugin) }.to raise_error(MB::AbstractFunction)
+    end
+  end
+
+  describe "#down" do
+    let(:job) { double('job') }
+    let(:env_name) { "rpsec" }
+
+    it "raises an AbstractFunction error" do
+      expect { subject.down(job, env_name) }.to raise_error(MB::AbstractFunction)
+    end
+  end
+end

data/spec/unit/mb/provisioners/aws_spec.rb

@@ -0,0 +1,392 @@
+require 'spec_helper'
+
+describe MB::Provisioner::AWS do
+  subject { aws }
+  let(:aws) { described_class.new }
+
+  let(:job) { double('job') }
+
+  before :all do
+    Fog::Mock.delay = 0
+    Fog.mock!
+  end
+
+  before :each do
+    aws.stub :sleep
+    job.stub :set_status
+  end
+
+  let(:environment_name) { "mbtest" }
+  let(:plugin) { double('plugin') }
+
+  let(:manifest) do
+    MB::Provisioner::Manifest.new.from_json({
+      options: {
+        access_key: "ABCDEFG",
+        secret_key: "abcdefgh123456789",
+        endpoint: "http://euca.example.com/services/Eucalyptus",
+        image_id: "emi-1234ABCD",
+        key_name: "mb",
+        security_groups: ["foo", "bar"],
+        availability_zone: "riot1"
+      },
+      nodes: [
+        {
+          type: "m1.large",
+          count: 4,
+          components: ["activemq::master"]
+        },
+        {
+          type: "m1.large",
+          count: 2,
+          components: ["activemq::slave"]
+        },
+        {
+          type: "m1.small",
+          count: 2,
+          components: ["nginx::server"]
+        }
+      ]
+    }.to_json)
+  end
+
+  let(:response) do
+    [
+     {instance_type: "m1.large", public_hostname: "ex1.cloud.example.com"},
+     {instance_type: "m1.large", public_hostname: "ex2.cloud.example.com"},
+     {instance_type: "m1.large", public_hostname: "ex3.cloud.example.com"},
+     {instance_type: "m1.large", public_hostname: "ex4.cloud.example.com"},
+     {instance_type: "m1.large", public_hostname: "ex5.cloud.example.com"},
+     {instance_type: "m1.large", public_hostname: "ex6.cloud.example.com"},
+     {instance_type: "m1.small", public_hostname: "ex7.cloud.example.com"},
+     {instance_type: "m1.small", public_hostname: "ex8.cloud.example.com"}
+    ]
+  end
+
+  let(:aws_nodes) do
+    1.upto(3).collect do |n|
+      Ridley::NodeObject.new(double('resource'),
+        name: "awsnode#{n}",
+        automatic: {
+          ec2: {
+            instance_id: "i-ABCDEFG#{n}"
+          }
+        }
+      )
+    end
+  end
+
+  let(:euca_nodes) do
+    1.upto(3).collect do |n|
+      Ridley::NodeObject.new(double('resource'),
+        name: "eucanode#{n}",
+        automatic: {
+          eucalyptus: {
+            instance_id: "i-EBCDEFG#{n}"
+          }
+        }
+      )
+    end
+  end
+
+  describe "#up" do
+    it "does all the steps" do
+      aws.should_receive(:validate_manifest_options).and_return(true)
+      aws.should_receive(:create_instances).and_return(true)
+      aws.should_receive(:store_provision_data)
+      aws.should_receive(:verify_instances).and_return(true)
+      aws.should_receive(:verify_connection).and_return(true)
+      aws.should_receive(:instances_as_manifest).twice.and_return(response)
+      expect(aws.up(job, environment_name, manifest, plugin, skip_bootstrap: true)).to eq(response)
+    end
+  end
+
+  describe "#down" do
+    subject(:down) { aws.down job, environment_name }
+
+    let(:instances) { aws.up(job, environment_name, manifest, plugin) }
+    let(:instance_ids) {
+      instances.collect { |instance| instance[:instance_id] }
+    }
+    let(:fog) { aws.send(:fog_connection, manifest) }
+
+    before do
+      aws.stub(fog_connection: Fog::Compute.new(provider: 'aws', aws_access_key_id: "", aws_secret_access_key: ""))
+      fog.create_key_pair('mb')
+      aws.stub(instance_ids_for_environment: instance_ids)
+    end
+
+    it "terminates the instances" do
+      instance_ids.each do |instance_id|
+        fog.should_receive(:terminate_instances).with(instance_id)
+      end
+
+      down
+    end
+  end
+
+  context "with a manifest" do
+    before do
+      fog.create_key_pair('mb') rescue Fog::Compute::AWS::Error
+    end
+
+    let(:fog) { aws.send(:fog_connection, manifest) }
+
+    context "auth settings" do
+      context "without manifest keys" do
+        before do
+          ENV['EC2_ACCESS_KEY'] = ENV['EC2_SECRET_KEY'] = ENV['AWS_ACCESS_KEY'] = ENV['AWS_SECRET_KEY'] = ENV['EC2_URL'] = nil
+          manifest.options.delete :access_key
+          manifest.options.delete :secret_key
+          manifest.options.delete :endpoint
+        end
+
+        it "should error on access_key" do
+          expect { aws.send(:access_key, manifest) }.to raise_error(MB::ConfigOptionMissing)
+        end
+
+        it "should error on secret_key" do
+          expect { aws.send(:secret_key, manifest) }.to raise_error(MB::ConfigOptionMissing)
+        end
+
+        context "with Euca environment variables" do
+          before do
+            ENV['EC2_ACCESS_KEY'] = 'EC2ABCDEFG'
+            ENV['EC2_SECRET_KEY'] = 'EC2abcdefgh123456789'
+            ENV['EC2_URL']        = 'http://euca2.example.com/services/Eucalyptus'
+          end
+
+          it "should get from the Euca environment variables" do
+            expect(aws.send(:access_key, manifest)).to eq('EC2ABCDEFG')
+            expect(aws.send(:secret_key, manifest)).to eq('EC2abcdefgh123456789')
+            expect(aws.send(:endpoint, manifest)).to eq('http://euca2.example.com/services/Eucalyptus')
+          end
+        end
+
+        context "with AWS environment variables" do
+          before do
+            ENV['AWS_ACCESS_KEY'] = 'AWSABCDEFG'
+            ENV['AWS_SECRET_KEY'] = 'AWSabcdefgh123456789'
+            ENV['EC2_URL']        = 'http://ec2.ap-southeast-1.amazonaws.com'
+          end
+
+          it "should get from the AWS environment variables" do
+            expect(aws.send(:access_key, manifest)).to eq('AWSABCDEFG')
+            expect(aws.send(:secret_key, manifest)).to eq('AWSabcdefgh123456789')
+            expect(aws.send(:endpoint, manifest)).to eq('http://ec2.ap-southeast-1.amazonaws.com')
+          end
+        end
+      end
+
+      context "with manifest keys" do
+        it "should get from the manifest options" do
+          expect(aws.send(:access_key, manifest)).to eq('ABCDEFG')
+          expect(aws.send(:secret_key, manifest)).to eq('abcdefgh123456789')
+          expect(aws.send(:endpoint, manifest)).to eq('http://euca.example.com/services/Eucalyptus')
+        end
+      end
+    end
+
+    describe "#validate_manifest_options(job,manifest)" do
+      subject(:validate_manifest_options) {
+        aws.send(:validate_manifest_options, job, manifest)
+      }
+
+      context "with a valid options hash in the manifest" do
+        it { should be_true }
+
+        it "does not raise when SecurityGroups is not set" do
+          manifest[:options].delete :security_groups
+          expect { validate_manifest_options }.not_to raise_error
+        end
+      end
+
+      context "with an invalid options hash in the manifest" do
+        it { should be_true }
+
+        it "raises on no options" do
+          manifest.delete :options
+          expect { validate_manifest_options }.to raise_error(MB::InvalidProvisionManifest)
+        end
+
+        it "raises on no ImageId" do
+          manifest[:options].delete :image_id
+          expect { validate_manifest_options }.to raise_error(MB::InvalidProvisionManifest)
+        end
+
+        it "raises on no KeyName" do
+          manifest[:options].delete :key_name
+          expect { validate_manifest_options }.to raise_error(MB::InvalidProvisionManifest)
+        end
+
+        it "raises on no AvailabilityZone" do
+          manifest[:options].delete :availability_zone
+          expect { validate_manifest_options }.to raise_error(MB::InvalidProvisionManifest)
+        end
+
+        it "raises on SecurityGroups not being an array" do
+          manifest[:options][:security_groups] = :fleeble
+          expect { validate_manifest_options }.to raise_error(MB::InvalidProvisionManifest)
+        end
+      end
+    end
+
+    context "ssh configuration" do
+      context "set in manifest" do
+        before do
+          manifest[:options][:ssh] ||= {}
+          manifest[:options][:ssh][:user] = "dauser"
+          manifest[:options][:ssh][:keys] = ["/home/dauser/.ssh/dakey"]
+        end
+
+        it "finds the ssh username from the manifest" do
+          expect(aws.send(:ssh_username, manifest.options)).to eq("dauser")
+        end
+
+        it "finds the ssh keys from the manifest" do
+          expect(aws.send(:ssh_keys, manifest.options).first).to eq("/home/dauser/.ssh/dakey")
+        end
+      end
+
+      context "not set in manifest" do
+        before do
+          manifest[:options].delete(:ssh)
+        end
+
+        context "set in config" do
+          before do
+            MB::Application.config[:ssh] ||= {}
+            MB::Application.config[:ssh][:user] = "dauser2"
+            MB::Application.config[:ssh][:keys] = ["/home/dauser2/.ssh/dakey"]
+          end
+
+          it "finds the ssh username from the config" do
+            expect(aws.send(:ssh_username, manifest.options)).to eq("dauser2")
+          end
+
+          it "finds the ssh keys from the config" do
+            expect(aws.send(:ssh_keys, manifest.options).first).to eq("/home/dauser2/.ssh/dakey")
+          end
+        end
+
+        context "not set in config" do
+          before do
+            MB::Application.config[:ssh] = nil
+          end
+
+          it "fails when trying to find the ssh username" do
+            expect { aws.send(:ssh_username, manifest.options) }.to raise_error(MB::InvalidProvisionManifest)
+          end
+
+          it "fails when trying to find the ssh keys" do
+            expect { aws.send(:ssh_keys, manifest.options) }.to raise_error(MB::InvalidProvisionManifest)
+          end
+        end
+      end
+    end
+
+    describe "#instance_counts" do
+      subject(:instance_counts) { aws.send(:instance_counts, manifest) }
+
+      it { should be_a(Hash) }
+
+      it "counts the m1.large instances" do
+        expect(instance_counts['m1.large']).to eq(6)
+      end
+
+      it "counts the m1.small instances" do
+        expect(instance_counts['m1.small']).to eq(2)
+      end
+    end
+
+    describe "#create_instances" do
+      it "makes calls by instance type" do
+        aws.should_receive(:run_instances).exactly(2).times.and_return(true)
+        aws.send :create_instances, job, manifest, fog
+      end
+    end
+
+    describe "#run_instances" do
+      it "keeps track of the instances" do
+        result = aws.send(:run_instances, job, fog, {}, "m1.large", 3, manifest.options)
+
+        expect(result).to be_a(Hash)
+        expect(result).to have(3).instances
+
+        result.each do |type, instance|
+          expect(instance[:type]).to eq("m1.large")
+          expect(instance[:ipaddress]).to be_nil
+        end
+      end
+    end
+
+    describe "#verify_instances" do
+      it "should check the instance status" do
+        instances = aws.send(:create_instances, job, manifest, fog)
+        fog.should_receive(:describe_instances).and_call_original
+        aws.send :verify_instances, job, fog, instances
+      end
+    end
+
+
+    describe "#verify_connection" do
+      it "should wait for SSH" do
+        instances = aws.send(:create_instances, job, manifest, fog)
+        aws.send :verify_instances, job, fog, instances
+        Fog.should_receive(:wait_for)
+        aws.send :verify_connection, job, fog, manifest, instances
+      end
+    end
+
+    describe "#instances_as_manifest" do
+      let(:instances) { aws.send(:create_instances, job, manifest, fog) }
+
+      before do
+        instances.each do |instance_id, instance|
+          instance[:ipaddress] = "172.16.1.#{rand(253)+1}"
+          instance[:status]    = 16
+        end
+      end
+
+      it "returns an array" do
+        expect(aws.send(:instances_as_manifest, instances)).to be_an(Array)
+      end
+
+      it "has 8 instances" do
+        expect(aws.send(:instances_as_manifest, instances)).to have(8).instances
+      end
+    end
+  end
+
+  describe "#instance_ids" do
+    subject(:instance_ids) { aws.send(:instance_ids, environment_name) }
+
+    context "AWS" do
+      before do
+        aws.ridley.should_receive(:search).with(:node, "chef_environment:#{environment_name}").and_return(aws_nodes)
+      end
+
+      it { should have(3).instances }
+
+      it "should find all 3" do
+        ["i-ABCDEFG1", "i-ABCDEFG2", "i-ABCDEFG3"].each do |i|
+          expect(instance_ids).to include(i)
+        end
+      end
+    end
+
+    context "Eucalyptus" do
+      before do
+        aws.ridley.should_receive(:search).with(:node, "chef_environment:#{environment_name}").and_return(euca_nodes)
+      end
+
+      it { should have(3).instances }
+
+      it "should find all 3" do
+        ["i-EBCDEFG1", "i-EBCDEFG2", "i-EBCDEFG3"].each do |i|
+          expect(instance_ids).to include(i)
+        end
+      end
+    end
+  end
+end