kitchen-rackspace 0.21.2 → 0.22.1

data/spec/kitchen/driver/rackspace/compute_spec.rb

@@ -0,0 +1,162 @@
+RSpec.describe Kitchen::Driver::Rackspace do
+  include_context "a driver for an instance"
+
+  describe "#compute" do
+    let(:config) do
+      {
+        rackspace_username: "monkey",
+        rackspace_api_key: "potato",
+        rackspace_region: "ord",
+      }
+    end
+
+    context "all requirements provided" do
+      it "creates a new compute connection" do
+        allow(Fog::Compute).to receive(:new) { |arg| arg }
+
+        expect(driver.send(:compute)).to eq(
+          provider: "Rackspace",
+          version: "v2",
+          rackspace_username: "monkey",
+          rackspace_api_key: "potato",
+          rackspace_region: "ord"
+        )
+      end
+    end
+
+    context "no username provided" do
+      let(:config) { { rackspace_username: nil, rackspace_api_key: "1234" } }
+
+      it "raises an error" do
+        expect { driver.send(:compute) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "no API key provided" do
+      let(:config) { { rackspace_username: "monkey", rackspace_api_key: nil } }
+
+      it "raises an error" do
+        expect { driver.send(:compute) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#create_server" do
+    subject(:server_def) { driver.send(:create_server) }
+
+    let(:config) do
+      {
+        server_name: "hello",
+        image_id: "there",
+        flavor_id: "captain",
+        public_key_path: "tarpals",
+        no_passwd_lock: false,
+        networks: nil,
+        user_data: nil,
+        config_drive: false,
+      }
+    end
+    let(:servers) do
+      collection = instance_double(Fog::Compute::RackspaceV2::Servers)
+      allow(collection).to receive(:bootstrap) { |arg| arg }
+      collection
+    end
+
+    before do
+      allow_any_instance_of(described_class).to receive(:compute)
+        .and_return(double("compute", servers:))
+    end
+
+    it "creates the server using a compute connection" do
+      expect(server_def).to eq(
+        name: "hello",
+        image_id: "there",
+        flavor_id: "captain",
+        public_key_path: "tarpals",
+        no_passwd_lock: false,
+        networks: nil,
+        user_data: nil,
+        config_drive: false
+      )
+    end
+
+    it "passes user data through" do
+      config[:user_data] = "#cloud-config\n"
+
+      expect(server_def[:user_data]).to eq("#cloud-config\n")
+    end
+
+    it "passes the config drive setting through" do
+      config[:config_drive] = true
+
+      expect(server_def[:config_drive]).to eq(true)
+    end
+
+    # RackConnect and Managed Service Level both need to log in as root to do
+    # their work, so the driver overrides no_passwd_lock whenever either wait
+    # is requested. Getting this wrong leaves the automation stuck forever.
+    context "rackconnect_wait is set" do
+      before { config[:rackconnect_wait] = true }
+
+      it "unlocks the root password even though the option says otherwise" do
+        expect(server_def[:no_passwd_lock]).to eq(true)
+      end
+    end
+
+    context "servicelevel_wait is set" do
+      before { config[:servicelevel_wait] = true }
+
+      it "unlocks the root password even though the option says otherwise" do
+        expect(server_def[:no_passwd_lock]).to eq(true)
+      end
+    end
+
+    context "neither wait is set" do
+      it "leaves the configured no_passwd_lock alone" do
+        config[:no_passwd_lock] = true
+
+        expect(server_def[:no_passwd_lock]).to eq(true)
+      end
+
+      it "leaves a false no_passwd_lock alone" do
+        expect(server_def[:no_passwd_lock]).to eq(false)
+      end
+    end
+
+    context "additional networks specified" do
+      before { config[:networks] = %w{bob_dole} }
+
+      it "keeps PublicNet and ServiceNet ahead of the custom network" do
+        expect(server_def[:networks]).to eq(
+          %w{
+            00000000-0000-0000-0000-000000000000
+            11111111-1111-1111-1111-111111111111
+            bob_dole
+          }
+        )
+      end
+    end
+  end
+
+  describe "#networks" do
+    context "the default Rackspace networks" do
+      it "returns nil so Fog will use the defaults" do
+        expect(driver.send(:networks)).to be_nil
+      end
+    end
+
+    context "a custom Rackspace network" do
+      let(:config) { { networks: %w{abcdefg} } }
+
+      it "returns the base networks plus the custom one" do
+        expect(driver.send(:networks)).to eq(
+          %w{
+            00000000-0000-0000-0000-000000000000
+            11111111-1111-1111-1111-111111111111
+            abcdefg
+          }
+        )
+      end
+    end
+  end
+end

data/spec/kitchen/driver/rackspace/configuration_spec.rb

@@ -0,0 +1,210 @@
+RSpec.describe Kitchen::Driver::Rackspace do
+  include_context "a driver for an instance"
+
+  before do
+    allow(Fog).to receive(:timeout=)
+  end
+
+  describe "default options" do
+    it "defaults to v2 cloud" do
+      expect(driver[:version]).to eq("v2")
+    end
+
+    it "defaults to a 2 GB general purpose flavor" do
+      expect(driver[:flavor_id]).to eq("general1-2")
+    end
+
+    it "defaults to local user's SSH public key" do
+      expect(File).to receive(:exist?).with(%r{/.ssh/id_rsa.pub$})
+        .and_return(true)
+
+      expect(driver[:public_key_path]).to match(%r{/.ssh/id_rsa.pub$})
+    end
+
+    it "falls through the other key types when there is no RSA key" do
+      allow(File).to receive(:exist?).and_return(false)
+      allow(File).to receive(:exist?).with(%r{/.ssh/id_ecdsa.pub$})
+        .and_return(true)
+
+      expect(driver[:public_key_path]).to match(%r{/.ssh/id_ecdsa.pub$})
+    end
+
+    it "leaves public_key_path unset when ~/.ssh holds no public key" do
+      allow(File).to receive(:exist?).and_return(false)
+
+      expect(driver[:public_key_path]).to be_nil
+    end
+
+    it "defaults to SSH with root user on port 22" do
+      expect(driver[:username]).to eq("root")
+      expect(driver[:port]).to eq("22")
+    end
+
+    it "defaults to a random server name" do
+      expect(driver[:server_name]).to match(/^potatoes-/)
+    end
+
+    it "defaults to the DFW region" do
+      expect(driver[:rackspace_region]).to eq("dfw")
+    end
+
+    it "defaults to username from $RACKSPACE_USERNAME" do
+      expect(driver[:rackspace_username]).to eq("user")
+    end
+
+    it "defaults to API key from $RACKSPACE_API_KEY" do
+      expect(driver[:rackspace_api_key]).to eq("key")
+    end
+
+    it "defaults to wait_for timeout of 600 seconds" do
+      expect(driver[:wait_for]).to eq(600)
+    end
+
+    it "defaults the SSH TCP bypassing to false" do
+      expect(driver[:no_ssh_tcp_check]).to eq(false)
+    end
+
+    it "defaults the TCP bypass sleep time to 120 seconds" do
+      expect(driver[:no_ssh_tcp_check_sleep]).to eq(120)
+    end
+
+    it "defaults to the standard Rackspace networks" do
+      expect(driver[:networks]).to eq(nil)
+    end
+
+    it "defaults to not waiting for rackconnect" do
+      expect(driver[:rackconnect_wait]).to eq(false)
+    end
+
+    it "defaults to not waiting for managed service level" do
+      expect(driver[:servicelevel_wait]).to eq(false)
+    end
+
+    it "defaults to the public ip address" do
+      expect(driver[:servicenet]).to eq(false)
+    end
+
+    it "defaults to no_passwd_lock as false" do
+      expect(driver[:no_passwd_lock]).to eq(false)
+    end
+
+    it "defaults to attaching the config drive" do
+      expect(driver[:config_drive]).to eq(true)
+    end
+
+    it "defaults to sending no user data" do
+      expect(driver[:user_data]).to eq(nil)
+    end
+  end
+
+  describe "overridden options" do
+    overrides = {
+      version: "v3",
+      image_id: "22",
+      flavor_id: "33",
+      public_key_path: "/tmp",
+      username: "admin",
+      port: "2222",
+      server_name: "puppy",
+      rackspace_region: "ord",
+      wait_for: 1200,
+      rackconnect_wait: true,
+      servicelevel_wait: true,
+      servicenet: true,
+      no_passwd_lock: true,
+      no_ssh_tcp_check: true,
+      no_ssh_tcp_check_sleep: 180,
+      config_drive: false,
+      user_data: "#cloud-config\n",
+      networks: %w{abcdefg},
+    }
+    let(:config) { overrides.dup }
+
+    # Every key here is a real `default_config` on the driver. Asserting that
+    # first keeps this list from drifting into options that do not exist --
+    # `driver[:whatever]` happily echoes back anything you put in the config
+    # hash, so a test for a made-up option passes without proving anything.
+    it "only names options the driver actually declares" do
+      expect(described_class.defaults.keys).to include(*overrides.keys)
+    end
+
+    overrides.each do |key, value|
+      it "uses the overridden #{key} option" do
+        expect(driver[key]).to eq(value)
+      end
+    end
+  end
+
+  describe "credentials from the environment" do
+    it "reads the username from $RACKSPACE_USERNAME" do
+      ENV["RACKSPACE_USERNAME"] = "rax_user"
+
+      expect(driver[:rackspace_username]).to eq("rax_user")
+    end
+
+    it "falls back to $OS_USERNAME" do
+      ENV.delete("RACKSPACE_USERNAME")
+      ENV["OS_USERNAME"] = "os_user"
+
+      expect(driver[:rackspace_username]).to eq("os_user")
+    end
+
+    it "prefers $RACKSPACE_USERNAME over $OS_USERNAME" do
+      ENV["RACKSPACE_USERNAME"] = "rax_user"
+      ENV["OS_USERNAME"] = "os_user"
+
+      expect(driver[:rackspace_username]).to eq("rax_user")
+    end
+
+    it "falls back to $OS_PASSWORD for the API key" do
+      ENV.delete("RACKSPACE_API_KEY")
+      ENV["OS_PASSWORD"] = "os_pass"
+
+      expect(driver[:rackspace_api_key]).to eq("os_pass")
+    end
+
+    it "prefers $RACKSPACE_API_KEY over $OS_PASSWORD" do
+      ENV["RACKSPACE_API_KEY"] = "rax_key"
+      ENV["OS_PASSWORD"] = "os_pass"
+
+      expect(driver[:rackspace_api_key]).to eq("rax_key")
+    end
+
+    it "falls back to $OS_REGION_NAME for the region" do
+      ENV["OS_REGION_NAME"] = "os_region"
+
+      expect(driver[:rackspace_region]).to eq("os_region")
+    end
+
+    it "prefers $RACKSPACE_REGION over $OS_REGION_NAME" do
+      ENV["RACKSPACE_REGION"] = "ord"
+      ENV["OS_REGION_NAME"] = "os_region"
+
+      expect(driver[:rackspace_region]).to eq("ord")
+    end
+
+    it "falls back to dfw when neither region variable is set" do
+      expect(driver[:rackspace_region]).to eq("dfw")
+    end
+  end
+
+  describe "the fog timeout" do
+    it "hands wait_for to fog as its global timeout" do
+      described_class.new(wait_for: 1200)
+
+      expect(Fog).to have_received(:timeout=).with(1200)
+    end
+
+    it "uses the wait_for default when the option is not set" do
+      described_class.new({})
+
+      expect(Fog).to have_received(:timeout=).with(600)
+    end
+
+    it "coerces a wait_for given as a string" do
+      described_class.new(wait_for: "1200")
+
+      expect(Fog).to have_received(:timeout=).with(1200)
+    end
+  end
+end

data/spec/kitchen/driver/rackspace/create_spec.rb

@@ -0,0 +1,150 @@
+RSpec.describe Kitchen::Driver::Rackspace do
+  include_context "a driver for an instance"
+  include_context "a built server"
+
+  let(:credentials) do
+    { rackspace_username: "hello", rackspace_api_key: "world", wait_for: 1200 }
+  end
+  let(:config) { credentials }
+
+  describe "#create" do
+    it "generates a server name in the absence of one" do
+      driver.create(state)
+
+      expect(driver[:server_name]).to eq("a_monkey!")
+    end
+
+    it "records the server ID" do
+      driver.create(state)
+
+      expect(state[:server_id]).to eq("test123")
+    end
+
+    it "records the public IP as the hostname" do
+      driver.create(state)
+
+      expect(state[:hostname]).to eq("1.2.3.4")
+    end
+
+    it "records the login user" do
+      driver.create(state)
+
+      expect(state[:username]).to eq("root")
+    end
+
+    it "records the SSH port" do
+      driver.create(state)
+
+      expect(state[:port]).to eq("22")
+    end
+
+    it "records an overridden login user and port" do
+      config.merge!(username: "admin", port: "2222")
+      driver.create(state)
+
+      expect(state).to include(username: "admin", port: "2222")
+    end
+
+    it "waits for the server to report ready" do
+      expect(server).to receive(:wait_for)
+
+      driver.create(state)
+    end
+
+    it "waits for the instance to accept a login" do
+      expect(driver).to receive(:tcp_check).with(state)
+
+      driver.create(state)
+    end
+
+    it "does not wait for rackconnect by default" do
+      expect(driver).to_not receive(:rackconnect_check)
+
+      driver.create(state)
+    end
+
+    it "does not wait for managed service level by default" do
+      expect(driver).to_not receive(:servicelevel_check)
+
+      driver.create(state)
+    end
+
+    context "a Fog error" do
+      before do
+        allow_any_instance_of(described_class).to receive(:create_server)
+          .and_raise(Fog::Errors::Error, "Uhoh")
+      end
+
+      it "re-raises it as a Kitchen failure" do
+        expect { driver.create(state) }
+          .to raise_error(Kitchen::ActionFailed, "Uhoh")
+      end
+    end
+
+    # Anything the Rackspace API rejects surfaces from Excon rather than fog,
+    # and it has to be turned into a Kitchen failure too or the user gets a
+    # raw stack trace instead of a message.
+    context "an Excon error" do
+      before do
+        allow_any_instance_of(described_class).to receive(:create_server)
+          .and_raise(Excon::Errors::BadRequest, "Bad flavor")
+      end
+
+      it "re-raises it as a Kitchen failure" do
+        expect { driver.create(state) }
+          .to raise_error(Kitchen::ActionFailed, /Bad flavor/)
+      end
+    end
+  end
+
+  describe "#create with rackconnect_wait" do
+    let(:config) { credentials.merge(rackconnect_wait: true) }
+
+    it "waits for rackconnect" do
+      expect(driver).to receive(:rackconnect_check).with(server)
+
+      driver.create(state)
+    end
+
+    it "waits on the rackconnect automation status" do
+      driver.send(:rackconnect_check, server)
+
+      expect(server).to have_received(:wait_for)
+    end
+
+    # RackConnect hands the server a new public address as part of its work.
+    # Without the refresh, the stale address goes into the state file and the
+    # transport connects to nothing.
+    it "refreshes the server so the new public IP is picked up" do
+      driver.send(:rackconnect_check, server)
+
+      expect(server).to have_received(:update)
+    end
+  end
+
+  describe "#create with servicelevel_wait" do
+    let(:config) { credentials.merge(servicelevel_wait: true) }
+
+    it "waits for managed service level automation" do
+      expect(driver).to receive(:servicelevel_check).with(server)
+
+      driver.create(state)
+    end
+
+    it "waits on the service level automation status" do
+      driver.send(:servicelevel_check, server)
+
+      expect(server).to have_received(:wait_for)
+    end
+  end
+
+  describe "#create with servicenet" do
+    let(:config) { credentials.merge(servicenet: true) }
+
+    it "records the private IP as the hostname" do
+      driver.create(state)
+
+      expect(state[:hostname]).to eq("10.9.8.7")
+    end
+  end
+end

data/spec/kitchen/driver/rackspace/destroy_spec.rb

@@ -0,0 +1,63 @@
+RSpec.describe Kitchen::Driver::Rackspace do
+  include_context "a driver for an instance"
+
+  describe "#destroy" do
+    let(:server) { double("server", nil?: false, destroy: true) }
+    let(:servers) { instance_double(Fog::Compute::RackspaceV2::Servers, get: server) }
+    let(:state) { { server_id: "12345", hostname: "example.com" } }
+
+    before do
+      allow_any_instance_of(described_class).to receive(:compute)
+        .and_return(double("compute", servers:))
+    end
+
+    context "a live server that needs to be destroyed" do
+      it "destroys the server" do
+        expect(server).to receive(:destroy)
+
+        driver.destroy(state)
+      end
+
+      it "clears the server out of the state" do
+        driver.destroy(state)
+
+        expect(state).to_not include(:server_id)
+        expect(state).to_not include(:hostname)
+      end
+
+      it "says which server it destroyed" do
+        driver.destroy(state)
+
+        expect(logged_output.string).to match(/instance <12345> destroyed/)
+      end
+    end
+
+    context "no server ID present" do
+      let(:state) { {} }
+
+      it "does nothing" do
+        expect(driver).to_not receive(:compute)
+
+        expect { driver.destroy(state) }.to_not raise_error
+      end
+    end
+
+    context "a server that was already destroyed" do
+      let(:servers) do
+        instance_double(Fog::Compute::RackspaceV2::Servers, get: nil)
+      end
+
+      it "does not try to destroy the server again" do
+        expect(server).to_not receive(:destroy)
+
+        driver.destroy(state)
+      end
+
+      it "still clears the server out of the state" do
+        driver.destroy(state)
+
+        expect(state).to_not include(:server_id)
+      end
+    end
+  end
+end

data/spec/kitchen/driver/rackspace/image_spec.rb

@@ -0,0 +1,58 @@
+RSpec.describe Kitchen::Driver::Rackspace do
+  include_context "a driver for an instance"
+
+  describe "#default_image" do
+    {
+      "ubuntu-12.04" => "f2d30a56-bc2b-4906-8027-92f8a45bbb10",
+      "ubuntu-12" => "f2d30a56-bc2b-4906-8027-92f8a45bbb10",
+      "ubuntu-14.04" => "e6baca58-c5f4-48d3-901a-abdeb0cfe907",
+      "ubuntu-14" => "e6baca58-c5f4-48d3-901a-abdeb0cfe907",
+      "ubuntu" => "9b3ae961-0ba0-4d5a-973f-2e79043f0ddd",
+      "centos-6" => "7d791876-4c8f-44a2-8d4b-e84bfb0b1c8c",
+      "centos" => "1a79f262-33d2-428c-924b-9852a6c15ea8",
+    }.each do |platform, id|
+      context "the platform is #{platform}" do
+        let(:platform_name) { platform }
+
+        it "resolves it to the right image ID" do
+          expect(driver[:image_id]).to eq(id)
+        end
+      end
+    end
+
+    # The bundled table has not been regenerated since 2016, so every modern
+    # platform name lands here. `image_id` then has no value, `required_config`
+    # rejects it, and the user has to supply one -- which is exactly what the
+    # README tells them to do. If this ever starts returning something, the
+    # README is wrong.
+    context "a platform the bundled table does not know" do
+      let(:platform_name) { "ubuntu-24.04" }
+
+      it "has no image to offer" do
+        expect(driver.default_image).to be_nil
+      end
+    end
+  end
+
+  describe "the bundled image table" do
+    subject(:images) { driver.send(:images) }
+
+    it "parses as JSON" do
+      expect { images }.to_not raise_error
+    end
+
+    it "is not empty" do
+      expect(images).to_not be_empty
+    end
+
+    it "maps every platform name to a UUID" do
+      expect(images.values).to all(match(/\A\h{8}(-\h{4}){3}-\h{12}\z/))
+    end
+
+    it "is only read from disk once" do
+      expect(IO).to receive(:read).once.and_call_original
+
+      2.times { driver.send(:images) }
+    end
+  end
+end

data/spec/kitchen/driver/rackspace/plugin_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe Kitchen::Driver::Rackspace do
+  include_context "a driver for an instance"
+
+  describe "plugin metadata" do
+    it "declares the driver API version" do
+      expect(described_class.instance_variable_get(:@api_version)).to eq(2)
+    end
+
+    it "reports its own gem version to kitchen diagnose" do
+      expect(driver.diagnose_plugin[:version])
+        .to eq(Kitchen::Driver::RACKSPACE_VERSION)
+    end
+  end
+end