lobot 2.1.0 → 3.0.0

data/spec/lib/lobot/config_spec.rb

@@ -1,297 +0,0 @@
-# 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
-      Tempfile.new('lobot-config').tap do |file|
-        file.write YAML.dump(config_contents)
-        file.close
-      end
-    end
-
-    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
-      it "writes the values to the file" do
-        config.ssh_port = 20912
-        config.save
-        config = Lobot::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 = 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"}}) }
-      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' }
-
-    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

data/spec/lib/lobot/configuration_wizard_spec.rb

@@ -1,347 +0,0 @@
-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