lobot 2.0.0pre → 2.1.0

data/spec/lib/lobot/config_spec.rb

@@ -1,8 +1,99 @@
+# encoding: UTF-8
 require "spec_helper"
 
 describe Lobot::Config do
   let(:default_config) { Lobot::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
+        Lobot::Password.stub(:generate).and_return('password')
+        Lobot::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
@@ -14,10 +105,64 @@ describe Lobot::Config do
 
     let(:config) { Lobot::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) { Lobot::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('lobot-config').tap do |file|
+            file.write <<-YAML
+---
+ssh_port: 42
+keypair_name: lobot
+            YAML
+            file.close
+          end
+        end
+        let(:config) { Lobot::Config.from_file(tempfile.path) }
+
+        it "silently removes it from the configuration" do
+          config.ssh_port.should == 42
+        end
+
+      end
     end
 
     describe "#save" do
@@ -29,6 +174,14 @@ describe Lobot::Config do
       end
     end
 
+    describe "#update" do
+      it "sets and persists the provided values" do
+        config.update(ssh_port: 20912)
+        config = Lobot::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"}}) }
@@ -54,15 +207,27 @@ describe Lobot::Config do
 
   describe "defaults" do
     its(:ssh_port) { should == 22 }
-    its(:server_ssh_key) { should =~ /id_rsa$/ }
-    its(:github_ssh_key) { should =~ /id_rsa$/ }
     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'] }
+    its(:cookbook_paths) { should == ['./chef/cookbooks/', './chef/travis-cookbooks/ci_environment', './chef/project-cookbooks'] }
     its(:instance_size) { should == 'c1.medium' }
 
+    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 ==  {
+        subject.node_attributes.travis_build_environment.to_hash.should == {
           "user" => "jenkins",
           "group" => "nogroup",
           "home" => "/var/lib/jenkins"
@@ -71,6 +236,10 @@ describe Lobot::Config do
     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,
@@ -78,6 +247,7 @@ describe Lobot::Config do
           "node_attributes" => {
             "nginx" => {
               "basic_auth_user" => "ci",
+              "basic_auth_password" => 'a_secure_password'
             },
             "travis_build_environment" => {
               "user" => "jenkins",
@@ -91,5 +261,37 @@ describe Lobot::Config do
         }
       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
+end

data/spec/lib/lobot/configuration_wizard_spec.rb

@@ -0,0 +1,347 @@
+require 'spec_helper'
+
+describe Lobot::ConfigurationWizard do
+  let(:working_path) { Dir.mktmpdir }
+  let(:cli) { double(:cli).as_null_object }
+  let(:wizard) { Lobot::ConfigurationWizard.new }
+
+  before { wizard.stub(:cli => cli) }
+
+  around do |example|
+    Dir.chdir(working_path) { example.run }
+  end
+
+  describe "#config" do
+    it "creates the config directory if it does not exist" do
+      expect {
+        wizard.config
+      }.to change {
+        File.directory?(File.join(working_path, "config"))
+      }.from(false).to(true)
+    end
+
+    it "uses the values in your existing lobot.yml" do
+      FileUtils.mkdir_p "config"
+      config = Lobot::Config.new(:path => "config/lobot.yml")
+      config.ssh_port = 2222
+      config.save
+
+      wizard.config.ssh_port.should == 2222
+    end
+
+    it "saves off the config to config/lobot.yml" do
+      expect {
+        wizard.config.save
+      }.to change {
+        File.exists?(File.join(working_path, "config", "lobot.yml"))
+      }.from(false).to(true)
+    end
+  end
+
+  describe "#ask_with_default" do
+    it "makes you feel like you need a shower" do
+      wizard.should_receive(:ask).with("Your ID [1]:")
+      wizard.ask_with_default("Your ID", "1")
+    end
+
+    it "defaults to the default value" do
+      wizard.should_receive(:ask).and_return("")
+      wizard.ask_with_default("Who is buried in Grant's Tomb", "Grant").should == "Grant"
+    end
+
+    it "uses the provided answer" do
+      wizard.should_receive(:ask).and_return("robert e lee's left nipple")
+      wizard.ask_with_default("Who is buried in Grant's Tomb", "Grant").should_not == "Grant"
+    end
+
+    it "does not display a nil default" do
+      wizard.should_receive(:ask).with("Monkey mustache:")
+      wizard.ask_with_default("Monkey mustache", nil)
+    end
+  end
+
+  describe "#setup" do
+    before do
+      wizard.stub(:ask => "totally-valid-value", :yes? => true, :say => nil)
+      wizard.config.stub(:save)
+    end
+
+    it "Says that you're trying to set up a ci box" do
+      question = "It looks like you're trying to set up a CI Box. Can I help? (Yes/No)"
+      wizard.should_receive(:yes?).with(question)
+      wizard.setup
+    end
+
+    it "prompts for aws credentials" do
+      wizard.should_receive(:prompt_for_aws)
+      wizard.setup
+    end
+
+    it "prompts for nginx basic auth credentials" do
+      wizard.should_receive(:prompt_for_basic_auth)
+      wizard.setup
+    end
+
+    it "prompts for an ssh key" do
+      wizard.should_receive(:prompt_for_ssh_key)
+      wizard.setup
+    end
+
+    it "prompts for a github key" do
+      wizard.should_receive(:prompt_for_github_key)
+      wizard.setup
+    end
+
+    it "prompts for a build" do
+      wizard.should_receive(:prompt_for_build)
+      wizard.setup
+    end
+
+    it "confirms the entered configuration values" do
+      reloaded_config = double("reloaded_config")
+      wizard.config.should_receive(:reload).and_return(reloaded_config)
+      reloaded_config.should_receive(:display)
+      wizard.stub(:user_wants_to_create_instance?).and_return(false)
+
+      wizard.setup
+    end
+
+    it "saves the config" do
+      wizard.config.should_receive(:save)
+      wizard.setup
+    end
+
+    it "prompts to start an instance on amazon" do
+      wizard.should_receive(:user_wants_to_create_instance?)
+      wizard.setup
+    end
+
+    context 'when the user wants to create an instance' do
+      before do
+        wizard.stub(:user_wants_to_create_instance?).and_return(true)
+      end
+
+      it "creates the instance then provisions the server" do
+        wizard.should_receive(:create_instance).ordered
+        wizard.should_receive(:provision_server).ordered
+        wizard.setup
+      end
+    end
+
+    context 'when the user does not want to create an instance' do
+      before do
+        wizard.stub(:user_wants_to_create_instance?).and_return(false)
+      end
+
+      it "does not creates an instance nor provision anything" do
+        wizard.should_not_receive(:create_instance)
+        wizard.should_not_receive(:provision_server)
+        wizard.setup
+      end
+    end
+  end
+
+  describe "#prompt_for_aws" do
+    before { wizard.stub(:say) }
+
+    it "reads in the key and secret" do
+      wizard.should_receive(:ask).and_return("aws-key")
+      wizard.should_receive(:ask).and_return("aws-secret-key")
+
+      wizard.prompt_for_aws
+
+      wizard.config.aws_key.should == "aws-key"
+      wizard.config.aws_secret.should == "aws-secret-key"
+    end
+  end
+
+  describe "#prompt_for_basic_auth" do
+    it "prompts for the username and password" do
+      wizard.should_receive(:ask).and_return("admin")
+      wizard.should_receive(:ask).and_return("password")
+
+      wizard.prompt_for_basic_auth
+
+      wizard.config.node_attributes.nginx.basic_auth_user.should == "admin"
+      wizard.config.node_attributes.nginx.basic_auth_password.should == "password"
+    end
+  end
+
+  describe "#prompt_for_ssh_key" do
+    it "prompts for the path" do
+      wizard.should_receive(:ask).and_return("~/.ssh/top_secret_rsa")
+
+      wizard.prompt_for_ssh_key
+
+      wizard.config.server_ssh_key_path.should == File.expand_path("~/.ssh/top_secret_rsa")
+    end
+  end
+
+  describe "#prompt_for_github_key" do
+    it "prompts for the path" do
+      wizard.should_receive(:ask).and_return("~/.ssh/the_matthew_kocher_memorial_key")
+
+      wizard.prompt_for_github_key
+
+      wizard.config.github_ssh_key_path.should == File.expand_path("~/.ssh/the_matthew_kocher_memorial_key")
+    end
+  end
+
+  describe "#prompt_for_build" do
+    def first_jenkins_build
+      wizard.config.node_attributes.jenkins.builds.first
+    end
+
+    before do
+      wizard.stub(:ask)
+      wizard.stub(:this_is_a_rails_project?).and_return(false)
+    end
+
+    context "when there are no builds" do
+      before do
+        wizard.should_receive(:ask_with_default).with("What is the address of your git repository?", nil).ordered.and_return("Fort-Knox")
+        wizard.should_receive(:ask_with_default).with("What would you like to name your build?", nil).ordered.and_return("fancy-build")
+        wizard.should_receive(:ask_with_default).with("What command should be run during the build?", nil).ordered.and_return("build.sh")
+      end
+
+      it "asks you for the build name" do
+        wizard.prompt_for_build
+        first_jenkins_build["name"].should == "fancy-build"
+      end
+
+      it "asks you for the git repository" do
+        wizard.prompt_for_build
+        first_jenkins_build["repository"].should == "Fort-Knox"
+      end
+
+      context "when it is not a rails project or the user does not want the sample build script" do
+        it "asks you for the build command" do
+          wizard.prompt_for_build
+          first_jenkins_build["command"].should == "build.sh"
+        end
+      end
+
+      it "always builds the master branch" do
+        wizard.prompt_for_build
+        first_jenkins_build["branch"].should == "master"
+      end
+
+    end
+
+    context "when the project is a rails project" do
+      before do
+        wizard.should_receive(:this_is_a_rails_project?).and_return(true)
+      end
+
+      it "asks whether you would like to use the sample rails build script" do
+        wizard.should_receive(:yes?).with("It looks like this is a Rails project.  Would you like to use the default Rails build script? (Yes/No)").and_return(true)
+        wizard.prompt_for_build
+      end
+
+      context "and when the user wants to use the sample build script" do
+        it 'generates a ci_build.sh file' do
+          wizard.should_receive(:yes?).with("It looks like this is a Rails project.  Would you like to use the default Rails build script? (Yes/No)").and_return(true)
+          wizard.should_receive(:copy_file)
+          wizard.prompt_for_build
+        end
+      end
+    end
+
+    context "when there are builds" do
+      before do
+        wizard.stub(:ask_with_default)
+
+        wizard.config.node_attributes.jenkins.builds << {
+          "name" => "first-post",
+          "repository" => "what",
+          "command" => "hot-grits",
+          "branch" => "oak"
+        }
+
+        wizard.config.node_attributes.jenkins.builds << {
+          "name" => "grails",
+          "repository" => "huh",
+          "command" => "colored-greens",
+          "branch" => "larch"
+        }
+      end
+
+      it "prompts for the name using the first build as a default" do
+        wizard.should_receive(:ask_with_default).with("What would you like to name your build?", "first-post")
+        wizard.prompt_for_build
+      end
+
+      it "prompts for the repository using the first build as a default" do
+        wizard.should_receive(:ask_with_default).with("What is the address of your git repository?", "what")
+        wizard.prompt_for_build
+      end
+
+      it "prompts for the repository using the first build as a default" do
+        wizard.should_receive(:ask_with_default).with("What command should be run during the build?", "hot-grits")
+        wizard.prompt_for_build
+      end
+    end
+  end
+
+  describe "#user_wants_to_create_instance?" do
+    before { wizard.stub(:yes? => true, :say => nil) }
+
+    context "when there is not an instance in the config" do
+      it "asks to start an amazon instance" do
+        wizard.should_receive(:yes?).and_return(:yep)
+        wizard.user_wants_to_create_instance?.should == :yep
+      end
+    end
+
+    context "when there is an instance in the config" do
+      before { wizard.config.master = "1.123.123.1" }
+
+      it "does not ask to start an instance" do
+        wizard.should_not_receive(:yes?)
+        wizard.user_wants_to_create_instance?.should_not be
+      end
+    end
+  end
+
+  describe "#create_instance" do
+    it "calls create on CLI" do
+      cli.should_receive(:create)
+      wizard.create_instance
+    end
+  end
+
+  describe "#provision_server" do
+    before { wizard.stub(:say) }
+
+    context "when there is no instance in the config" do
+      it "does not bootstrap the instance" do
+        cli.should_not_receive(:bootstrap)
+        wizard.provision_server
+      end
+
+      it "does not run chef" do
+        cli.should_not_receive(:chef)
+        wizard.provision_server
+      end
+    end
+
+    context "when an instance exists" do
+      before do
+        wizard.config
+        wizard.config.master = "1.2.3.4"
+        wizard.config.save
+        wizard.config.master = nil
+      end
+
+      it "bootstraps the instance" do
+        cli.should_receive(:bootstrap)
+        wizard.provision_server
+      end
+
+      it "runs chef" do
+        cli.should_receive(:chef)
+        wizard.provision_server
+      end
+    end
+  end
+end