ciborg 0.0.1 → 3.0.0

data/spec/lib/ciborg/cli_spec.rb

@@ -0,0 +1,292 @@
+require "spec_helper"
+
+describe Ciborg::CLI do
+  let(:cli) { subject }
+  let(:sobo) { Ciborg::Sobo.new(ciborg_config.master, ciborg_config.server_ssh_key_path) }
+
+  before do
+    cli.stub(:ciborg_config).and_return(ciborg_config) # ciborg_config must be defined in each context below
+  end
+
+  context 'with Amazon' do
+    let(:ciborg_config) {
+      Ciborg::Config.new(
+        :aws_key => ENV["EC2_KEY"],
+        :aws_secret => ENV["EC2_SECRET"],
+        :server_ssh_key => ssh_key_pair_path)
+    }
+
+    describe '#create & #destroy_ec2', :slow, :ec2 do
+      it "launches an instance and associates elastic ip" do
+        pending "Missing EC2 Credentials" unless SpecHelpers::ec2_credentials_present?
+        cli.ciborg_config.instance_size = 't1.micro'
+        expect { cli.create }.to change { ciborg_config.master }.from(nil)
+
+        cli.stub(:options).and_return({'force' => 'force'})
+        expect { cli.destroy_ec2 }.to change { ciborg_config.master }.to(nil)
+      end
+    end
+
+    describe "#ssh" do
+      it "starts an ssh session to the ciborg host" do
+        cli.should_receive(:exec).with("ssh -i #{cli.ciborg_config.server_ssh_key_path} ubuntu@#{cli.ciborg_config.master} -p #{cli.ciborg_config.ssh_port}")
+        cli.ssh
+      end
+    end
+
+    describe "#open", :osx do
+      let(:ciborg_config) do
+        Ciborg::Config.new(:node_attributes => {
+            :nginx => {
+                :basic_auth_user => "ci",
+                :basic_auth_password => "secret"
+            }
+        })
+      end
+
+      it "opens a web browser with the ciborg page" do
+        ciborg_config.master = "127.0.0.1"
+        cli.should_receive(:exec).with("open https://ci:secret@127.0.0.1/")
+        cli.open
+      end
+    end
+
+    describe "#trust_certificate", :osx do
+      let(:keychain) { Ciborg::Keychain.new("/Library/Keychains/System.keychain") }
+      before { ciborg_config.master = "192.168.99.99" }
+
+      it "adds the key to the keychain" do
+        fake_keychain = double(:keychain)
+        fake_keychain.should_receive(:fetch_remote_certificate).with("https://#{ciborg_config.master}/").and_return("IAMACERTIFICATE")
+        fake_keychain.should_receive(:add_certificate).with("IAMACERTIFICATE")
+        Ciborg::Keychain.should_receive(:new).with("/Library/Keychains/System.keychain").and_return(fake_keychain)
+
+        cli.trust_certificate
+      end
+    end
+
+    describe "#add_build" do
+      let(:name) { "bob" }
+      let(:repository) { "http://github.com/mkocher/soloist.git" }
+      let(:branch) { "master" }
+      let(:command) { "script/ci_build.sh" }
+
+      context "when the config is invalid" do
+        before { ciborg_config.node_attributes.jenkins = {} }
+
+        it "raises an error" do
+          expect do
+            cli.add_build(name, repository, branch, command)
+          end.to raise_error %r{your config file does not have a}
+        end
+      end
+
+      context "when the configuration is valid" do
+        context "with persisted configuration data" do
+          let(:tempfile) do
+            Tempfile.new('ciborg-config').tap do |file|
+              file.write YAML.dump({})
+              file.close
+            end
+          end
+
+          let(:ciborg_config) { Ciborg::Config.from_file(tempfile.path) }
+
+          def builds
+            cli.ciborg_config.reload.node_attributes.jenkins.builds
+          end
+
+          it "persists a build" do
+            cli.add_build(name, repository, branch, command)
+            builds.should_not be_nil
+            builds.should_not be_empty
+          end
+        end
+      end
+    end
+
+    context "with a fake amazon" do
+      let(:ip_address) { "127.0.0.1" }
+      let(:server) { double("server", :public_ip_address => ip_address).as_null_object }
+      let(:amazon) { double("AMZN", :launch_server => server).as_null_object }
+      let(:instance_id) { 'i-xxxxxx' }
+
+      before do
+        cli.stub(:amazon).and_return(amazon)
+      end
+
+      describe "#create" do
+        before do
+          amazon.stub(:with_key_pair).and_yield("unique-key-pair-name")
+          cli.should_receive(:wait_for_server)
+        end
+
+        it "uses the configured key pair" do
+          amazon.should_receive(:with_key_pair).with(cli.ciborg_config.server_ssh_pubkey)
+          cli.create
+        end
+
+        context "with a custom security group", :slow => false do
+          before { cli.ciborg_config.security_group = 'custom_group' }
+
+          it "launches the instance with the configured security group" do
+            amazon.should_receive(:create_security_group).with('custom_group')
+            amazon.should_receive(:open_port).with('custom_group', anything, anything)
+            amazon.should_receive(:launch_server).with(anything, 'custom_group', anything, anything)
+            cli.create
+          end
+        end
+
+        context "with a custom instance size", :slow => false do
+          before { cli.ciborg_config.instance_size = 'really_big_instance' }
+
+          it "launches the instance with the configured instance size" do
+            amazon.should_receive(:launch_server).with(anything, anything, 'really_big_instance', 'us-east-1b')
+            cli.create
+          end
+        end
+      end
+
+      describe "destroy_ec2" do
+        before do
+          cli.ciborg_config.master = ip_address
+          cli.ciborg_config.instance_id = instance_id
+        end
+
+        context 'by default' do
+          before do
+            amazon.stub(:destroy_ec2).and_yield(mock("SERVER").as_null_object)
+          end
+
+          it 'deletes the known instance' do
+            amazon.should_receive(:destroy_ec2).and_yield(mock("SERVER").as_null_object)
+            cli.destroy_ec2
+          end
+
+          it 'clears the master ip address' do
+            expect { cli.destroy_ec2 }.to change(cli.ciborg_config, :master).to(nil)
+          end
+
+          it 'clears the master instance id' do
+            expect { cli.destroy_ec2 }.to change(cli.ciborg_config, :instance_id).to(nil)
+          end
+
+          it 'does not delete sibling instances' do
+            amazon.should_receive(:destroy_ec2).with(a_kind_of(Proc), instance_id)
+            cli.destroy_ec2
+          end
+
+          it 'prompts for confirmation' do
+            cli.should_receive(:yes?).and_return(true)
+            amazon.should_receive(:destroy_ec2).with(a_kind_of(Proc), instance_id) do |confirm_proc, instance_id|
+              confirm_proc.call(mock("SERVER").as_null_object)
+            end
+            cli.destroy_ec2
+          end
+        end
+
+        context 'with --all' do
+          before do
+            cli.stub(:options).and_return({'all' => 'all'})
+          end
+
+          it 'deletes everything tagged "ciborg"' do
+            amazon.should_receive(:destroy_ec2).with(a_kind_of(Proc), :all)
+            cli.destroy_ec2
+          end
+        end
+
+        context 'with --force' do
+          before do
+            cli.stub(:options).and_return({'force' => 'force'})
+          end
+
+          it 'does not prompt for confirmation' do
+            cli.should_not_receive(:ask)
+            amazon.should_receive(:destroy_ec2).with(a_kind_of(Proc), instance_id) do |confirm_proc, instance_id|
+              confirm_proc.call(mock("SERVER").as_null_object)
+            end
+            cli.destroy_ec2
+          end
+        end
+      end
+    end
+  end
+
+  context 'with Vagrant', :vagrant do
+    let(:ciborg_config) {
+      Ciborg::Config.new(
+          "node_attributes" => {
+              "jenkins" => {
+                  "builds" => []
+              },
+              "nginx" => {
+                  "basic_auth_user" => "ci",
+                  "basic_auth_password" => "secret"
+              }
+          },
+          "server_ssh_key" => ssh_key_pair_path,
+          "github_ssh_key" => ssh_key_pair_path
+      )
+    }
+
+    describe "#create_vagrant" do
+      it "starts a virtual machine" do
+        cli.create_vagrant
+        Godot.wait('192.168.33.10', 22).should be
+      end
+
+      it "updates the config master ip address" do
+        expect { cli.create_vagrant }.to change { ciborg_config.master }.to('192.168.33.10')
+      end
+    end
+
+    describe "#bootstrap", :slow do
+      before { cli.create_vagrant }
+
+      it "installs all necessary packages, installs rvm and sets up the user" do
+        cli.bootstrap
+        sobo.backtick("dpkg --get-selections").should include("libncurses5-dev")
+        sobo.backtick("ls /usr/local/rvm/").should_not be_empty
+        sobo.backtick("groups ubuntu").should include("rvm")
+      end
+    end
+
+    describe "#chef", :slow do
+      let(:name) { "Bob" }
+      let(:repository) { "http://github.com/mkocher/soloist.git" }
+      let(:branch) { "master" }
+      let(:command) { "exit 0" }
+
+      let(:godot) { Godot.new(cli.master_server.ip, 8080, timeout: 180) }
+      let(:jenkins) { Ciborg::Jenkins.new(ciborg_config) }
+
+      before do
+        cli.create_vagrant
+        cli.bootstrap
+        cli.add_build(name, repository, branch, command)
+        FileUtils.mkdir_p("/tmp/ciborg_dummy/cookbooks/pork/recipes/")
+        File.write("/tmp/ciborg_dummy/cookbooks/pork/recipes/bacon.rb", "package 'htop'")
+      end
+
+      after do
+        FileUtils.rm_rf("/tmp/ciborg_dummy")
+      end
+
+      it "runs chef" do
+        Dir.chdir('/tmp/ciborg_dummy/') do
+          cli.ciborg_config.recipes = ["pivotal_ci::jenkins", "pivotal_ci::id_rsa", "pivotal_ci::git_config", "sysctl", "pivotal_ci::jenkins_config", "pork::bacon"]
+          cli.chef
+        end
+
+        sobo.backtick("ls /var/lib/").should include "jenkins"
+        sobo.backtick("grep 'kernel.shmmax=' /etc/sysctl.conf").should_not be_empty
+        sobo.backtick("sudo cat /var/lib/jenkins/.ssh/id_rsa").should == ciborg_config.github_ssh_key
+        sobo.system("dpkg -l htop").should == 0
+
+        godot.wait!
+        godot.match!(/Bob/, 'api/json')
+      end
+    end
+  end
+end

data/spec/lib/ciborg/config_spec.rb

@@ -0,0 +1,299 @@
+# encoding: UTF-8
+require "spec_helper"
+
+describe Ciborg::Config do
+  let(:default_config) { Ciborg::Config.new }
+
+  describe "#add_build" do
+    let(:name) { "bob" }
+    let(:repository) { "http://github.com/mkocher/soloist.git" }
+    let(:branch) { "master" }
+    let(:command) { "script/ci_build.sh" }
+
+    let(:build_params) { {
+      "name" => name,
+      "repository" => repository,
+      "command" => command,
+      "branch" => branch,
+      "junit_publisher" => true
+    } }
+
+    it "adds a build to the node attributes" do
+      subject.add_build(name, repository, branch, command)
+      subject.node_attributes.jenkins.builds.should =~ [build_params]
+    end
+
+    it "does not add a build twice with identical parameters" do
+      subject.add_build(name, repository, branch, command)
+      subject.add_build(name, repository, branch, command)
+      subject.node_attributes.jenkins.builds.should =~ [build_params]
+    end
+  end
+
+  describe "#display" do
+    before do
+      subject.add_build("default", "repos", "branch", "command")
+      subject.add_build("integration", "repos", "branch", "command")
+      subject.add_build("enemy", "repos", "branch", "command")
+    end
+
+    context "without a running instance" do
+      it "returns a pretty-printed string version of the config" do
+        # The basic_auth_password will be blank on CI, so we force it
+        subject.stub(:basic_auth_password).and_return('password')
+
+        subject.display.should == <<OOTPÜT
+-- ciborg configuration --
+  Instance ID:
+  IP Address:
+  Instance size:      #{subject.instance_size}
+
+  Builds:
+    default
+    integration
+    enemy
+
+  Web URL:
+  User name:          #{subject.basic_auth_user}
+  User password:      #{subject.basic_auth_password}
+
+  CC Menu URL:
+OOTPÜT
+      end
+    end
+
+    context "with a running instance" do
+      subject do
+        Ciborg::Password.stub(:generate).and_return('password')
+        Ciborg::Config.new({instance_id: 'i-xxxxxx',
+                                   master: '127.0.0.1',
+                                   instance_size: 'c9.humungous'
+                                  })
+      end
+
+      it "returns a pretty-printed string version of the config" do
+
+        subject.display.should == <<OOTPÜT
+-- ciborg configuration --
+  Instance ID:        i-xxxxxx
+  IP Address:         127.0.0.1
+  Instance size:      c9.humungous
+
+  Builds:
+    default           https://127.0.0.1/job/default/rssAll
+    integration       https://127.0.0.1/job/integration/rssAll
+    enemy             https://127.0.0.1/job/enemy/rssAll
+
+  Web URL:            https://127.0.0.1
+  User name:          ci
+  User password:      password
+
+  CC Menu URL:        https://ci:password@127.0.0.1/cc.xml
+OOTPÜT
+      end
+    end
+  end
+
+  describe "with a file" do
+    let(:config_contents) { {ssh_port: 42} }
+    let(:tempfile) do
+      Tempfile.new('ciborg-config').tap do |file|
+        file.write YAML.dump(config_contents)
+        file.close
+      end
+    end
+
+    let(:config) { Ciborg::Config.from_file(tempfile.path) }
+
+    describe "#valid?" do
+      it "returns true by default" do
+        config.should be_valid
+        config.errors.should be_empty
+      end
+
+      context "when there is no jenkins config" do
+        let(:config_contents) { {node_attributes: {}} }
+
+        it "returns false" do
+          config.should_not be_valid
+        end
+      end
+
+      context "when jenkins config has no builds" do
+        let(:config_contents) { {node_attributes: {jenkins: {}}} }
+
+        it "returns false" do
+          config.should_not be_valid
+        end
+
+        it "has a useful error message" do
+          config.errors.should include("your config file does not have a [:node_attributes][:jenkins][:builds] key")
+        end
+      end
+    end
+
+    describe ".from_file" do
+      it "loads from a yaml file" do
+        config.ssh_port.should == 42
+      end
+
+      context "when the yaml file does not exist" do
+        let(:config) { Ciborg::Config.from_file("#{tempfile.path}-nonexistent") }
+
+        it "does not load from a yaml file" do
+          config.ssh_port.should == 22
+        end
+      end
+
+      context "handles deprecated keypair_name attribute" do
+        let(:tempfile) do
+          Tempfile.new('ciborg-config').tap do |file|
+            file.write <<-YAML
+---
+ssh_port: 42
+keypair_name: ciborg
+            YAML
+            file.close
+          end
+        end
+        let(:config) { Ciborg::Config.from_file(tempfile.path) }
+
+        it "silently removes it from the configuration" do
+          config.ssh_port.should == 42
+        end
+
+      end
+    end
+
+    describe "#save" do
+      it "writes the values to the file" do
+        config.ssh_port = 20912
+        config.save
+        config = Ciborg::Config.from_file(tempfile.path)
+        config.ssh_port.should == 20912
+      end
+    end
+
+    describe "#update" do
+      it "sets and persists the provided values" do
+        config.update(ssh_port: 20912)
+        config = Ciborg::Config.from_file(tempfile.path)
+        config.ssh_port.should == 20912
+      end
+    end
+
+    describe "soloistrc-specific attributes" do
+      let(:recipes) { ["pivotal_workstation::broken_postgres", "pivotal_workstation::janus"] }
+      let(:node_attributes) { default_config.node_attributes.merge({"radiator" => {"busted" => "hella"}}) }
+      let(:config_contents) { {recipes: recipes, node_attributes: node_attributes} }
+
+      describe "#recipes" do
+        it "preserves the recipes in a config file" do
+          config.recipes.should == recipes
+        end
+      end
+
+      describe "#soloistrc" do
+        it "has recipes" do
+          config.soloistrc['recipes'].should == recipes
+        end
+
+        it "has node_attributes" do
+          config.soloistrc['node_attributes']['radiator']['busted'].should == "hella"
+        end
+      end
+    end
+  end
+
+  describe "defaults" do
+    its(:ssh_port) { should == 22 }
+    its(:recipes) { should == ["pivotal_ci::jenkins", "pivotal_ci::limited_travis_ci_environment", "pivotal_ci"] }
+    its(:cookbook_paths) { should == ['./chef/cookbooks/', './chef/travis-cookbooks/ci_environment', './chef/project-cookbooks'] }
+    its(:instance_size) { should == 'c1.medium' }
+    its(:security_group) { should == 'ciborg'}
+    its(:availability_zone) { should == 'us-east-1b' }
+
+    context 'when id_rsa exists' do
+      before { File.stub(:exists?).and_return(true) }
+
+      its(:server_ssh_key_path) { should == File.expand_path('~/.ssh/id_rsa')}
+      its(:github_ssh_key_path) { should == File.expand_path('~/.ssh/id_rsa')}
+    end
+
+    context 'when id_rsa does not exist' do
+      before { File.stub(:exists?).and_return(false) }
+
+      its(:server_ssh_key_path) { should_not be }
+      its(:github_ssh_key_path) { should_not be }
+    end
+
+    describe "#node_attributes" do
+      it "defaults to overwriting the travis build environment" do
+        subject.node_attributes.travis_build_environment.to_hash.should == {
+          "user" => "jenkins",
+          "group" => "nogroup",
+          "home" => "/var/lib/jenkins"
+        }
+      end
+    end
+
+    describe "#soloistrc" do
+      before do
+        Haddock::Password.stub(:generate).and_return('a_secure_password')
+      end
+
+      it "defaults to recipes and nginx basic auth" do
+        subject.soloistrc.should == {
+          "recipes" => subject.recipes,
+          "cookbook_paths" => subject.cookbook_paths,
+          "node_attributes" => {
+            "nginx" => {
+              "basic_auth_user" => "ci",
+              "basic_auth_password" => 'a_secure_password'
+            },
+            "travis_build_environment" => {
+              "user" => "jenkins",
+              "group" => "nogroup",
+              "home" => "/var/lib/jenkins"
+            },
+            "jenkins" => {
+              "builds" => []
+            }
+          }
+        }
+      end
+    end
+
+    describe 'ssh key accessors' do
+      before do
+        File.stub(:exists?).with(File.expand_path('~/.ssh/id_rsa')).and_return(true)
+      end
+
+      context 'github' do
+        before do
+          File.stub(:read).with(subject.github_ssh_key_path) { "---GITHUB PRIVATE---" }
+          File.stub(:read).with(subject.github_ssh_pubkey_path) { "---GITHUB PUBLIC---" }
+        end
+
+        its(:github_ssh_key_path) { should =~ /^\/.*id_rsa$/ }
+        its(:github_ssh_pubkey_path) { should =~ /^\/.*id_rsa\.pub$/ }
+
+        its(:github_ssh_key) { should == "---GITHUB PRIVATE---" }
+        its(:github_ssh_pubkey) { should == "---GITHUB PUBLIC---" }
+      end
+
+      context 'server' do
+        before do
+          File.stub(:read).with(subject.server_ssh_key_path) { "---SERVER PRIVATE---" }
+          File.stub(:read).with(subject.server_ssh_pubkey_path) { "---SERVER PUBLIC---" }
+        end
+
+        its(:server_ssh_key_path) { should =~ /^\/.*id_rsa$/ }
+        its(:server_ssh_pubkey_path) { should =~ /^\/.*id_rsa\.pub$/ }
+
+        its(:server_ssh_key) { should == "---SERVER PRIVATE---" }
+        its(:server_ssh_pubkey) { should == "---SERVER PUBLIC---" }
+      end
+    end
+  end
+end