kitchen-rackspace 0.22.0 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 341c3ad7208f8a4747c8f1ea02a0729e0902de1aa9c953015b85dd597138809e
-  data.tar.gz: aefd1c800711e40f056620f7f77f597a98cd7773f81e4c2a7f224554a338f205
+  metadata.gz: e15a887394d3ed26e459527e63a809e9cc8e0ac881c831eab8b71a9a585d5833
+  data.tar.gz: 23b98c7da4db1e2361bf0734069a6303ed1d976334977e296bb6e2935420d2b5
 SHA512:
-  metadata.gz: 1c8b613a15c6cfa635246d9fa0b20f53910ba99015c8550c532067205b3fd7da0ac39070b158eb01d018660303dfec891a07c949394896e856f8b619d094f170
-  data.tar.gz: e1d15ce47f981dcd4e187fb93b2fb53e1064ce246efd993222fa60988f952ac7bcaa8c446b9c3e501526d5d9db0b8940ebe4bf20fb56eb82c603ce47b69066d2
+  metadata.gz: '059d13472f0a85ce909b4ca0ad5b14873f19c88e7b8709d4181e9980d2e0663735d3512e9d61ca1e366a6bce1b0d96599b8e4975f242275e7b6779ca5d035a3f'
+  data.tar.gz: 365fead87993ea3f203f48de1512e747eb6cbe8d5de7746db9a025fce7ee570065d3eba539535978823391115b84f199f07ab809e2e0427db267f01b4819caa9

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.22.0"
+  ".": "0.22.1"
 }

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/CHANGELOG.md

@@ -9,6 +9,13 @@
 * Docs: rewrite README for new users and split contributor docs ([#121](https://github.com/test-kitchen/kitchen-rackspace/pull/121)) ([638440a](https://github.com/test-kitchen/kitchen-rackspace/commit/638440a))
 * Remove dependabot config in favor of renovate ([#122](https://github.com/test-kitchen/kitchen-rackspace/pull/122)) ([92dcec9](https://github.com/test-kitchen/kitchen-rackspace/commit/92dcec9))
 
+## [0.22.1](https://github.com/test-kitchen/kitchen-rackspace/compare/v0.22.0...v0.22.1) (2026-08-30)
+
+
+### Bug Fixes
+
+* check credentials with a call fog-rackspace actually implements ([#133](https://github.com/test-kitchen/kitchen-rackspace/issues/133)) ([a3b35fb](https://github.com/test-kitchen/kitchen-rackspace/commit/a3b35fb72290a2372d32f9b2e1156d49742ebaef))
+
 ## [0.22.0](https://github.com/test-kitchen/kitchen-rackspace/compare/v0.21.2...v0.22.0) (2026-08-24)
 
 

data/CONTRIBUTING.md

@@ -49,6 +49,38 @@ bundle exec cookstyle --chefstyle
 back to stock RuboCop defaults, disagrees with this codebase about string
 quoting, and reports over a hundred offenses that are not real.
 
+### How the specs are laid out
+
+There is one spec file per area of the driver, so the file you need to open is
+the one named after the thing you changed:
+
+| File | Covers |
+| --- | --- |
+| `spec/kitchen/driver/rackspace/plugin_spec.rb` | API version and plugin version |
+| `spec/kitchen/driver/rackspace/configuration_spec.rb` | `default_config` values, overrides, credentials from the environment |
+| `spec/kitchen/driver/rackspace/image_spec.rb` | platform-name to image-ID resolution and the bundled `data/images.json` |
+| `spec/kitchen/driver/rackspace/server_name_spec.rb` | the generated server name |
+| `spec/kitchen/driver/rackspace/create_spec.rb` | `#create`, the RackConnect and service level waits, ServiceNet |
+| `spec/kitchen/driver/rackspace/tcp_check_spec.rb` | waiting for the instance to accept a login |
+| `spec/kitchen/driver/rackspace/destroy_spec.rb` | `#destroy` |
+| `spec/kitchen/driver/rackspace/status_spec.rb` | `#status` and `#doctor` |
+| `spec/kitchen/driver/rackspace/compute_spec.rb` | the fog connection, `#create_server`, and the network list |
+
+`spec/support/` holds the shared setup:
+
+- `driver_context.rb` — the `"a driver for an instance"` shared context, which
+  gives an example group a logger, a fake Test Kitchen instance, and a driver
+  built from `config`. Nearly every group includes it. `"a built server"` adds
+  a server double that has finished building.
+- `rackspace_environment.rb` — clears `RACKSPACE_*` and `OS_*` out of the
+  environment around every example and puts your own back afterwards, so
+  credentials in your shell cannot make a spec pass or fail.
+
+When you stub a fog object, reach for `instance_double` rather than `double`.
+A plain double will happily answer a method fog does not have, which is how a
+`kitchen doctor` that called a nonexistent `servers.summary` shipped with a
+green test suite.
+
 Many style offenses can be corrected automatically:
 
 ```sh
@@ -79,7 +111,7 @@ leave one running.
 1. Fork the repository.
 2. Create a feature branch off `main`.
 3. Make your change, adding or updating tests to cover it.
-4. Make sure `bundle exec rspec` and `bundle exec cookstyle` pass.
+4. Make sure `bundle exec rake test` and `bundle exec cookstyle --chefstyle` pass.
 5. Push the branch to your fork and open a pull request.
 
 Please keep pull requests focused on a single change — it makes review much

data/README.md

@@ -223,16 +223,28 @@ All options below are set under the `driver:` key in `kitchen.yml`.
 | `server_name` | *generated* | Name for the server. If unset, a unique name of at most 63 characters is generated from the base name, your username, the hostname, and a random string. |
 | `user_data` | `nil` | Extra configuration data passed to the server at build time. |
 | `config_drive` | `true` | Attach the read-only metadata config drive. |
-| `no_passwd_lock` | `false` | Do not let the underlying fog library lock the root account. |
+| `no_passwd_lock` | `false` | Do not let the underlying fog library lock the root account. Forced on when `rackconnect_wait` or `servicelevel_wait` is set — see [Networking](#networking). |
 
 ### Networking
 
 | Option | Default | Description |
 | --- | --- | --- |
-| `networks` | PublicNet and ServiceNet | Array of Rackspace network UUIDs to attach. |
+| `networks` | *PublicNet and ServiceNet* | **Additional** Rackspace network UUIDs to attach. PublicNet and ServiceNet are always attached too — see below. |
 | `servicenet` | `false` | Connect over the ServiceNet address rather than the public one. |
-| `rackconnect_wait` | `false` | Wait for RackConnect to finish before continuing. Enable this if the account uses RackConnect. |
-| `servicelevel_wait` | `false` | Wait for Managed Service Level automation to finish before continuing. |
+| `rackconnect_wait` | `false` | Wait for RackConnect to finish before continuing. Enable this if the account uses RackConnect. Forces `no_passwd_lock` on. |
+| `servicelevel_wait` | `false` | Wait for Managed Service Level automation to finish before continuing. Forces `no_passwd_lock` on. |
+
+`networks` adds to the standard networks rather than replacing them. Whatever
+you list, the driver puts Rackspace's PublicNet
+(`00000000-0000-0000-0000-000000000000`) and ServiceNet
+(`11111111-1111-1111-1111-111111111111`) at the front of the list first, so
+there is no way to build a server without a public interface. Do not list
+either of those UUIDs yourself — you will just send Rackspace a duplicate.
+
+`rackconnect_wait` and `servicelevel_wait` both turn `no_passwd_lock` on
+regardless of how you set it, because RackConnect and Managed Service Level
+each log in as root to do their work and a locked root account leaves them
+stuck.
 
 ### SSH
 
@@ -246,7 +258,7 @@ All options below are set under the `driver:` key in `kitchen.yml`.
 
 | Option | Default | Description |
 | --- | --- | --- |
-| `wait_for` | `600` | Seconds to wait for the server to become available before timing out. |
+| `wait_for` | `600` | Seconds any single wait may take before timing out. This is fog's global timeout, so it applies to the build wait and to the `rackconnect_wait` and `servicelevel_wait` polls individually, not to `kitchen create` as a whole. |
 | `no_ssh_tcp_check` | `false` | Skip the TCP check on the SSH port. Use when a firewall makes the check unreliable. |
 | `no_ssh_tcp_check_sleep` | `120` | Seconds to sleep instead of checking, when `no_ssh_tcp_check` is enabled. |
 
@@ -266,12 +278,22 @@ Image IDs are per-region, so `image_id` and `rackspace_region` travel together.
 
 ### Connecting over ServiceNet
 
+```yaml
+driver:
+  name: rackspace
+  servicenet: true
+```
+
+`servicenet` is all you need — ServiceNet is attached either way, and this
+tells the driver to hand the transport the private address instead of the
+public one. Use `networks` only to attach an *extra* network of your own:
+
 ```yaml
 driver:
   name: rackspace
   servicenet: true
   networks:
-    - 11111111-1111-1111-1111-111111111111
+    - 4b1c1b3a-8f0f-4a1e-9d33-6f3c7ab2e5d9  # your isolated cloud network
 ```
 
 ### RackConnect accounts

data/lib/kitchen/driver/rackspace.rb

@@ -74,6 +74,11 @@ module Kitchen
       required_config :image_id
       required_config :public_key_path
 
+      # Sets up the driver and applies +wait_for+ as fog's global timeout.
+      #
+      # +Fog.timeout+ is process-wide, so the last driver constructed wins if
+      # several are in play.
+      #
       # @param config [Hash] the driver configuration
       def initialize(config)
         super
@@ -172,7 +177,8 @@ module Kitchen
       # Checks the configuration for the mistakes that only show up as a
       # confusing failure part way through +create+.
       #
-      # @param state [Hash] mutable instance and driver state
+      # @param state [Hash] instance state; accepted for the Test Kitchen hook
+      #   signature and not read
       # @return [Boolean] true when a problem was reported
       def doctor(state) # rubocop:disable Lint/UnusedMethodArgument
         problems = []
@@ -198,9 +204,14 @@ module Kitchen
       # Confirms the configured credentials can actually talk to Rackspace,
       # which is cheaper to learn here than half way through a converge.
       #
+      # Listing servers is the cheapest authenticated call fog-rackspace
+      # offers: +GET /servers+ returns only an ID and a name per server, and
+      # it exercises the compute endpoint for the configured region rather
+      # than just the identity endpoint.
+      #
       # @return [Array<String>] a problem description, or an empty array
       def credential_problems
-        compute.servers.summary
+        compute.servers.all
         []
       rescue Fog::Errors::Error, Excon::Errors::Error => e
         ["Rackspace rejected the configured credentials for region " \
@@ -237,13 +248,19 @@ module Kitchen
       # unlocked to do their work, so +no_passwd_lock+ is forced on whenever
       # either wait is requested, regardless of how it was configured.
       #
+      # @note fog's +bootstrap+ calls +Server#setup+, which rescues
+      #   +Errno::ECONNREFUSED+ and retries forever, one second apart. A server
+      #   that never opens port 22 hangs here rather than failing, and
+      #   +wait_for+ does not bound it.
+      #
       # @return [Fog::Compute::RackspaceV2::Server] the newly built server
       def create_server
         server_def = { name: config[:server_name], networks: }
         %i{image_id flavor_id public_key_path no_passwd_lock user_data config_drive}.each do |opt|
           server_def[opt] = config[opt]
         end
-        # see @note on bootstrap def about rackconnect
+        # RackConnect and Managed Service Level need the root password left
+        # unlocked; see the note above.
         no_passwd_lock = config[:rackconnect_wait] || config[:servicelevel_wait]
         server_def[:no_passwd_lock] = no_passwd_lock if no_passwd_lock
         compute.servers.bootstrap(server_def)
@@ -275,8 +292,13 @@ module Kitchen
         puts "(ssh ready)"
       end
 
+      # Blocks until the configured transport can connect to the instance.
+      #
       # Kitchen::Driver::SSHBase used to supply this; the configured transport
       # knows how to wait for the instance to accept connections.
+      #
+      # @param state [Hash] instance state describing how to connect
+      # @return [void]
       def wait_for_sshd(state)
         instance.transport.connection(state, &:wait_until_ready)
       end

data/lib/kitchen/driver/rackspace_version.rb

@@ -4,6 +4,6 @@ module Kitchen
   # Test Kitchen's driver plugins.
   module Driver
     # The version of the kitchen-rackspace gem.
-    RACKSPACE_VERSION = "0.22.0"
+    RACKSPACE_VERSION = "0.22.1"
   end
 end

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