kitchen-rackspace 0.22.0 → 0.22.1

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

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

@@ -0,0 +1,63 @@
+RSpec.describe Kitchen::Driver::Rackspace do
+  include_context "a driver for an instance"
+
+  describe "#default_name" do
+    subject(:name) { driver.default_name }
+
+    let(:login) { "user" }
+    let(:hostname) { "host" }
+
+    before do
+      allow(Etc).to receive(:getlogin).and_return(login)
+      allow(Socket).to receive(:gethostname).and_return(hostname)
+    end
+
+    it "generates a name" do
+      expect(name).to match(/^potatoes-user-host-(\S*)/)
+    end
+
+    context "a local node with a long hostname" do
+      let(:hostname) { "ab.c" * 20 }
+
+      it "limits the generated name to 63 characters" do
+        expect(name.length).to be <= 63
+      end
+    end
+
+    context "a long hostname, username, and base name" do
+      let(:login) { "abcd" * 20 }
+      let(:hostname) { "efgh" * 20 }
+      let(:instance_name) { "ijkl" * 20 }
+
+      it "limits the generated name to 63 characters" do
+        expect(name.length).to eq(63)
+      end
+    end
+
+    context "a login and hostname with punctuation in them" do
+      let(:login) { "some.u-se-r" }
+      let(:hostname) { "a.host-name" }
+      let(:instance_name) { "a.instance-name" }
+
+      it "strips out the dots to prevent bad server names" do
+        expect(name).to_not include(".")
+      end
+
+      it "strips out all but the three hyphen separators" do
+        expect(name.count("-")).to eq(3)
+      end
+    end
+
+    context "a non-login shell" do
+      let(:login) { nil }
+
+      it "subs in a placeholder login string" do
+        expect(name).to match(/^potatoes-nologin-/)
+      end
+    end
+
+    it "does not repeat itself" do
+      expect(driver.default_name).to_not eq(driver.default_name)
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+RSpec.describe Kitchen::Driver::Rackspace do
+  include_context "a driver for an instance"
+
+  describe "#status" do
+    let(:server) { double("server", state: "ACTIVE") }
+    let(:servers) { instance_double(Fog::Compute::RackspaceV2::Servers) }
+
+    before do
+      allow_any_instance_of(described_class).to receive(:compute)
+        .and_return(double("compute", servers:))
+    end
+
+    context "with no server in state" do
+      it "reports an unknown status" do
+        expect(driver.status({})).to include(live: nil, state: "unknown")
+      end
+    end
+
+    context "with a server Rackspace does not know" do
+      it "reports an unknown status" do
+        expect(servers).to receive(:get).with("gone").and_return(nil)
+
+        expect(driver.status(server_id: "gone")).to include(state: "unknown")
+      end
+    end
+
+    context "with a live server" do
+      before do
+        allow(servers).to receive(:get).with("12345").and_return(server)
+      end
+
+      it "reports the server as live" do
+        expect(driver.status(server_id: "12345")).to include(
+          live: true,
+          state: "ACTIVE",
+          source: "driver",
+          resource_id: "12345"
+        )
+      end
+
+      it "stamps when the check happened" do
+        expect(driver.status(server_id: "12345")[:checked_at])
+          .to match(/\A\d{4}-\d{2}-\d{2}T/)
+      end
+    end
+
+    context "with a server that is not active" do
+      it "reports the server as not live" do
+        allow(servers).to receive(:get)
+          .with("12345").and_return(double("server", state: "ERROR"))
+
+        expect(driver.status(server_id: "12345"))
+          .to include(live: false, state: "ERROR")
+      end
+    end
+
+    context "when Rackspace cannot be reached" do
+      it "reports an unknown status rather than raising" do
+        allow(servers).to receive(:get)
+          .and_raise(Fog::Errors::Error.new("boom"))
+
+        expect(driver.status(server_id: "12345")).to include(state: "unknown")
+      end
+
+      it "survives an Excon error too" do
+        allow(servers).to receive(:get)
+          .and_raise(Excon::Errors::SocketError.new(StandardError.new("nope")))
+
+        expect(driver.status(server_id: "12345")).to include(state: "unknown")
+      end
+    end
+  end
+
+  describe "#doctor" do
+    let(:config) do
+      { image_id: "img-1", public_key_path: "/home/user/.ssh/id_rsa.pub" }
+    end
+    let(:servers) do
+      instance_double(Fog::Compute::RackspaceV2::Servers, all: [])
+    end
+
+    before do
+      allow(driver).to receive(:compute)
+        .and_return(double("compute", servers:))
+    end
+
+    it "reports no problem when the configuration is complete" do
+      expect(driver.doctor(state)).to eq(false)
+    end
+
+    # `summary` is not a method fog-rackspace has. Stubbing the collection with
+    # a verifying double is what keeps that mistake from coming back.
+    it "asks Rackspace for something fog actually implements" do
+      driver.doctor(state)
+
+      expect(servers).to have_received(:all)
+    end
+
+    context "with no resolvable image" do
+      let(:config) { { public_key_path: "/key.pub" } }
+
+      it "reports a problem" do
+        allow(driver).to receive(:default_image).and_return(nil)
+
+        expect(driver.doctor(state)).to eq(true)
+        expect(logged_output.string).to match(/No image_id is set/)
+      end
+    end
+
+    context "with no public key" do
+      let(:config) { { image_id: "img-1", public_key_path: nil } }
+
+      it "reports a problem" do
+        expect(driver.doctor(state)).to eq(true)
+        expect(logged_output.string).to match(/No public key was found/)
+      end
+    end
+
+    context "with credentials Rackspace rejects" do
+      it "reports a problem" do
+        allow(driver).to receive(:compute)
+          .and_raise(Fog::Errors::Error.new("unauthorized"))
+
+        expect(driver.doctor(state)).to eq(true)
+        expect(logged_output.string)
+          .to match(/rejected the configured credentials/)
+      end
+
+      it "names the region it tried" do
+        config[:rackspace_region] = "ord"
+        allow(driver).to receive(:compute)
+          .and_raise(Fog::Errors::Error.new("unauthorized"))
+
+        driver.doctor(state)
+
+        expect(logged_output.string).to match(/region ord/)
+      end
+    end
+
+    it "reports every problem it finds, not just the first" do
+      config.delete(:image_id)
+      config[:public_key_path] = nil
+      allow(driver).to receive(:default_image).and_return(nil)
+
+      driver.doctor(state)
+
+      expect(logged_output.string).to match(/No image_id is set/)
+      expect(logged_output.string).to match(/No public key was found/)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+RSpec.describe Kitchen::Driver::Rackspace do
+  include_context "a driver for an instance"
+
+  describe "#tcp_check" do
+    before do
+      allow_any_instance_of(described_class).to receive(:wait_for_sshd)
+      allow_any_instance_of(described_class).to receive(:sleep)
+    end
+
+    context "the default non-skipping behavior" do
+      it "uses Kitchen's own SSH check" do
+        expect(driver).to receive(:wait_for_sshd).with(state)
+        expect(driver).to_not receive(:sleep)
+
+        driver.send(:tcp_check, state)
+      end
+    end
+
+    context "a config set to wait instead of TCP check" do
+      let(:config) { { no_ssh_tcp_check: true } }
+
+      it "uses a sleep instead of a port check" do
+        expect(driver).to_not receive(:wait_for_sshd)
+        expect(driver).to receive(:sleep)
+
+        driver.send(:tcp_check, state)
+      end
+
+      it "sleeps for the configured number of seconds" do
+        config[:no_ssh_tcp_check_sleep] = 42
+        expect(driver).to receive(:sleep).with(42)
+
+        driver.send(:tcp_check, state)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,12 +1,28 @@
-require "rake"
-require "rspec"
 require "logger"
 require "stringio" unless defined?(StringIO)
 require "kitchen"
 
 require_relative "../lib/kitchen/driver/rackspace"
+
+# `require "fog/rackspace"` only registers the services; it does not load the
+# model classes. Load the ones the specs verify doubles against, so that a
+# stubbed method which fog does not actually implement fails the example
+# instead of quietly passing.
+require "fog/rackspace/models/compute_v2/servers"
+
+Dir[File.expand_path("support/**/*.rb", __dir__)].sort.each { |f| require f }
+
 RSpec.configure do |config|
-  config.run_all_when_everything_filtered = true
-  config.filter_run(:focus)
-  config.order = "random"
+  config.disable_monkey_patching!
+  config.filter_run_when_matching :focus
+  config.order = :random
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
 end

data/spec/support/driver_context.rb

@@ -0,0 +1,51 @@
+# Everything a driver needs to exist outside a real Test Kitchen run: an
+# instance to belong to, a logger to talk to, and a config hash to read.
+#
+# Individual example groups override `config`, `platform_name`, and
+# `instance_name` with `let` to describe the situation under test.
+RSpec.shared_context "a driver for an instance" do
+  let(:logged_output) { StringIO.new }
+  let(:logger) { Logger.new(logged_output) }
+  let(:config) { {} }
+  let(:state) { {} }
+  let(:platform_name) { "ubuntu" }
+  let(:instance_name) { "potatoes" }
+
+  let(:instance) do
+    double("instance",
+           name: instance_name,
+           logger:,
+           to_str: "instance",
+           platform: double("platform", name: platform_name))
+  end
+
+  let(:driver) { described_class.new(config) }
+
+  before do
+    allow_any_instance_of(described_class).to receive(:instance)
+      .and_return(instance)
+    ENV["RACKSPACE_USERNAME"] = "user"
+    ENV["RACKSPACE_API_KEY"] = "key"
+  end
+end
+
+# A server that has finished building and is reachable, as `#create` sees it.
+RSpec.shared_context "a built server" do
+  let(:server) do
+    double("server",
+           id: "test123",
+           wait_for: true,
+           update: nil,
+           public_ip_address: "1.2.3.4",
+           private_ip_address: "10.9.8.7")
+  end
+
+  before do
+    allow_any_instance_of(described_class).to receive(:default_name)
+      .and_return("a_monkey!")
+    allow_any_instance_of(described_class).to receive(:create_server)
+      .and_return(server)
+    allow_any_instance_of(described_class).to receive(:tcp_check)
+      .and_return(true)
+  end
+end

data/spec/support/rackspace_environment.rb

@@ -0,0 +1,27 @@
+# The driver reads its credentials and its region straight out of the
+# environment, and several examples set those variables to prove it. Without
+# this the values leak from one example into the next, and out of the suite
+# into whatever else the process goes on to do.
+RACKSPACE_ENVIRONMENT_VARIABLES = %w{
+  RACKSPACE_USERNAME
+  RACKSPACE_API_KEY
+  RACKSPACE_REGION
+  OS_USERNAME
+  OS_PASSWORD
+  OS_REGION_NAME
+}.freeze
+
+RSpec.configure do |config|
+  config.around do |example|
+    saved = RACKSPACE_ENVIRONMENT_VARIABLES.to_h { |name| [name, ENV.fetch(name, nil)] }
+    RACKSPACE_ENVIRONMENT_VARIABLES.each { |name| ENV.delete(name) }
+
+    begin
+      example.run
+    ensure
+      saved.each do |name, value|
+        value.nil? ? ENV.delete(name) : ENV[name] = value
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kitchen-rackspace
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.22.1
 platform: ruby
 authors:
 - Jonathan Hartman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-24 00:00:00.000000000 Z
+date: 2026-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog-rackspace
@@ -77,6 +77,7 @@ files:
 - ".gitignore"
 - ".markdownlint.yaml"
 - ".release-please-manifest.json"
+- ".rspec"
 - ".rubocop.yml"
 - ".yamllint"
 - ".yardopts"
@@ -94,8 +95,18 @@ files:
 - lib/kitchen/driver/rackspace_version.rb
 - release-please-config.json
 - renovate.json
-- spec/kitchen/driver/rackspace_spec.rb
+- spec/kitchen/driver/rackspace/compute_spec.rb
+- spec/kitchen/driver/rackspace/configuration_spec.rb
+- spec/kitchen/driver/rackspace/create_spec.rb
+- spec/kitchen/driver/rackspace/destroy_spec.rb
+- spec/kitchen/driver/rackspace/image_spec.rb
+- spec/kitchen/driver/rackspace/plugin_spec.rb
+- spec/kitchen/driver/rackspace/server_name_spec.rb
+- spec/kitchen/driver/rackspace/status_spec.rb
+- spec/kitchen/driver/rackspace/tcp_check_spec.rb
 - spec/spec_helper.rb
+- spec/support/driver_context.rb
+- spec/support/rackspace_environment.rb
 homepage: https://github.com/test-kitchen/kitchen-rackspace
 licenses:
 - Apache-2.0