kitchen-vra 3.3.4 → 3.4.1

data/spec/vra_spec.rb

@@ -18,43 +18,35 @@
 # limitations under the License.
 #
 
-require "spec_helper"
-require "tmpdir"
-require "fileutils"
-require "kitchen/driver/vra"
-require "kitchen/provisioner/dummy"
-require "kitchen/transport/dummy"
-require "kitchen/verifier/dummy"
-
-describe Kitchen::Driver::Vra do
+RSpec.describe Kitchen::Driver::Vra do
   let(:logged_output) { StringIO.new }
   let(:logger)        { Logger.new(logged_output) }
   let(:platform)      { Kitchen::Platform.new(name: "fake_platform") }
   let(:transport)     { Kitchen::Transport::Dummy.new }
-  let(:driver)        { Kitchen::Driver::Vra.new(config) }
+  let(:driver)        { described_class.new(config) }
 
   let(:config) do
     {
-      base_url:        "https://vra.corp.local",
-      username:        "myuser",
-      password:        "mypassword",
-      domain:          "mytenant.corp.com",
-      project_id:      "6ba69375-79d5-42c3-a099-7d32739f71a7",
-      image_mapping:   "VRA-nc-lnx-ce8.4-Docker",
-      flavor_mapping:  "Small",
-      verify_ssl:      true,
-      use_dns:         false,
+      base_url: "https://vra.corp.local",
+      username: "myuser",
+      password: "mypassword",
+      domain: "mytenant.corp.com",
+      project_id: "6ba69375-79d5-42c3-a099-7d32739f71a7",
+      image_mapping: "VRA-nc-lnx-ce8.4-Docker",
+      flavor_mapping: "Small",
+      verify_ssl: true,
+      use_dns: false,
       deployment_name: "test-instance",
-      catalog_id:      "1536b95d-68fe-3c68-9417-46ed24bee3ef",
+      catalog_id: "1536b95d-68fe-3c68-9417-46ed24bee3ef",
     }
   end
 
   let(:instance) do
     instance_double(Kitchen::Instance,
-                    logger:    logger,
-                    transport: transport,
-                    platform:  platform,
-                    to_str:    "instance_str")
+      logger:    logger,
+      transport: transport,
+      platform:  platform,
+      to_str:    "instance_str")
   end
 
   before do
@@ -71,6 +63,54 @@ describe Kitchen::Driver::Vra do
     end
   end
 
+  describe "configuration defaults" do
+    let(:config) do
+      {
+        base_url: "https://vra.corp.local",
+        domain: "mytenant.corp.com",
+        project_id: "6ba69375-79d5-42c3-a099-7d32739f71a7",
+        image_mapping: "VRA-nc-lnx-ce8.4-Docker",
+        flavor_mapping: "Small",
+      }
+    end
+
+    it "names the deployment after the platform under test" do
+      expect(driver[:deployment_name]).to eq("fake_platform")
+    end
+
+    it "connects by IP address rather than by name" do
+      expect(driver[:use_dns]).to be false
+    end
+
+    it "verifies the appliance certificate" do
+      expect(driver[:verify_ssl]).to be true
+    end
+
+    describe "the private key" do
+      let(:id_rsa) { File.expand_path("~/.ssh/id_rsa") }
+      let(:id_dsa) { File.expand_path("~/.ssh/id_dsa") }
+
+      before { allow(File).to receive(:exist?).and_return(false) }
+
+      it "prefers an RSA key" do
+        allow(File).to receive(:exist?).with(id_rsa).and_return(true)
+        allow(File).to receive(:exist?).with(id_dsa).and_return(true)
+
+        expect(driver[:private_key_path]).to eq(id_rsa)
+      end
+
+      it "falls back to a DSA key" do
+        allow(File).to receive(:exist?).with(id_dsa).and_return(true)
+
+        expect(driver[:private_key_path]).to eq(id_dsa)
+      end
+
+      it "is left unset when neither key exists" do
+        expect(driver[:private_key_path]).to be_nil
+      end
+    end
+  end
+
   describe "#create" do
     context "when the server is already created" do
       let(:state) { { deployment_id: "48959518-6a0d-46e1-8415-3749696b65f4" } }
@@ -81,14 +121,8 @@ describe Kitchen::Driver::Vra do
       end
     end
 
-    let(:state) { {} }
-    let(:resource) do
-      double("server1",
-             deployment_id: "e8706351-cf4c-4c12-acb7-c90cc683b22c",
-             name: "test-server",
-             ip_address: "1.2.3.4",
-             vm?: true)
-    end
+    let(:state)    { {} }
+    let(:resource) { vra_resource(deployment_id: "e8706351-cf4c-4c12-acb7-c90cc683b22c") }
 
     before do
       allow(driver).to receive(:request_server).and_return(resource)
@@ -115,22 +149,34 @@ describe Kitchen::Driver::Vra do
       expect(driver).to receive(:wait_for_server)
       driver.create(state)
     end
+
+    context "when a private key is configured" do
+      let(:config) { super().merge(private_key_path: "/home/me/.ssh/id_vra") }
+
+      it "tells the transport which key to connect with" do
+        driver.create(state)
+        expect(state[:ssh_key]).to eq("/home/me/.ssh/id_vra")
+      end
+    end
+
+    context "when no private key was found" do
+      let(:config) { super().merge(private_key_path: nil) }
+
+      it "leaves the transport to work out how to connect" do
+        driver.create(state)
+        expect(state).not_to have_key(:ssh_key)
+      end
+    end
   end
 
   describe "#hostname_for" do
-    let(:server) do
-      double("server",
-             deployment_id: "test_id",
-             name: "test_hostname",
-             ip_address: "1.2.3.4",
-             vm?: true)
-    end
+    let(:server) { vra_resource(deployment_id: "test_id", name: "test_hostname") }
 
     context "when use_dns is true and dns_suffix is defined" do
       let(:config) do
         {
-          use_dns:      true,
-          dns_suffix:   "my.com",
+          use_dns: true,
+          dns_suffix: "my.com",
         }
       end
 
@@ -143,20 +189,23 @@ describe Kitchen::Driver::Vra do
       let(:config) { { use_dns: true } }
 
       it "raises an exception if the server name is nil" do
-        allow(server).to receive(:name).and_return(nil)
-        expect { driver.hostname_for(server) }.to raise_error(RuntimeError)
+        expect { driver.hostname_for(vra_resource(name: nil)) }.to raise_error(RuntimeError)
       end
 
       it "returns the server name" do
         expect(driver.hostname_for(server)).to eq("test_hostname")
       end
+
+      it "does not go looking for an IP address" do
+        expect(server).not_to receive(:ip_address)
+        driver.hostname_for(server)
+      end
     end
 
     context "when use_dns is false" do
       it "falls back to the server name if no IP address exists" do
-        allow(server).to receive(:ip_address).and_return(nil)
         expect(driver).to receive(:warn)
-        expect(driver.hostname_for(server)).to eq("test_hostname")
+        expect(driver.hostname_for(vra_resource(ip_address: nil))).to eq("test-server")
       end
 
       it "returns the IP address if it exists" do
@@ -166,47 +215,32 @@ describe Kitchen::Driver::Vra do
   end
 
   describe "#request_server" do
-    let(:submitted_request) { double("submitted_request") }
-    let(:catalog_request)   { double("catalog_request") }
-    let(:resource1) do
-      double("server1",
-             id: "e8706351-cf4c-4c12-acb7-c90cc683b22c",
-             name: "server1",
-             ip_address: "1.2.3.4",
-             vm?: true)
-    end
-    let(:resource2) do
-      double("server2",
-             id: "9e2364cf-7af4-4b85-93fd-1f03ee2ac865",
-             name: "server2",
-             ip_address: "4.3.2.1",
-             vm?: true)
-    end
-    let(:resources) { [resource1] }
+    let(:deployment)      { vra_deployment(id: "74e26af9-2d2f-4889-a472-95dbcedb70b8", resources: resources) }
+    let(:catalog_request) { vra_deployment_request(submit: deployment) }
+    let(:resource1)       { vra_resource(id: "e8706351-cf4c-4c12-acb7-c90cc683b22c", name: "server1") }
+    let(:resource2)       { vra_resource(id: "9e2364cf-7af4-4b85-93fd-1f03ee2ac865", name: "server2") }
+    let(:resources)       { [resource1] }
 
     before do
       allow(driver).to receive(:catalog_request).and_return(catalog_request)
-      allow(catalog_request).to receive(:submit).and_return(submitted_request)
-      allow(submitted_request).to receive(:id).and_return("74e26af9-2d2f-4889-a472-95dbcedb70b8")
-      allow(submitted_request).to receive(:resources).and_return(resources)
-      allow(submitted_request).to receive(:failed?).and_return(false)
-      allow(driver).to receive(:wait_for_request).with(submitted_request)
+      allow(driver).to receive(:wait_for_request).with(deployment)
     end
 
     it "submits a catalog request" do
-      expect(driver.catalog_request).to receive(:submit).and_return(submitted_request)
+      expect(catalog_request).to receive(:submit).and_return(deployment)
       driver.request_server
     end
 
     it "waits for the request to complete" do
-      expect(driver).to receive(:wait_for_request).with(submitted_request)
+      expect(driver).to receive(:wait_for_request).with(deployment)
       driver.request_server
     end
 
     it "raises an exception if the request failed" do
-      allow(submitted_request).to receive(:failed?).and_return(true)
-      allow(submitted_request).to receive(:completion_details).and_return("it failed")
-      expect { driver.request_server }.to raise_error(RuntimeError)
+      allow(deployment).to receive(:failed?).and_return(true)
+      allow(deployment).to receive(:completion_details).and_return("it failed")
+
+      expect { driver.request_server }.to raise_error(RuntimeError, /it failed/)
     end
 
     describe "getting the server from the request" do
@@ -217,16 +251,26 @@ describe Kitchen::Driver::Vra do
       end
 
       context "when multiple servers are returned" do
+        let(:resources) { [resource1, resource2] }
+
         it "raises an exception" do
-          allow(submitted_request).to receive(:resources).and_return([ resource1, resource2 ])
-          expect { driver.request_server }.to raise_error(RuntimeError)
+          expect { driver.request_server }.to raise_error(RuntimeError, /more than one server/)
         end
       end
 
       context "when no servers are returned" do
+        let(:resources) { [] }
+
         it "raises an exception" do
-          allow(submitted_request).to receive(:resources).and_return([])
-          expect { driver.request_server }.to raise_error(RuntimeError)
+          expect { driver.request_server }.to raise_error(RuntimeError, /did not create any servers/)
+        end
+      end
+
+      context "when the deployment also contains things that are not VMs" do
+        let(:resources) { [vra_resource(id: "net-1", vm?: false), resource1] }
+
+        it "picks out the one VM" do
+          expect(driver.request_server).to eq(resource1)
         end
       end
     end
@@ -234,18 +278,25 @@ describe Kitchen::Driver::Vra do
     it "returns the the single server resource object" do
       expect(driver.request_server).to eq(resource1)
     end
+
+    context "when unique_name is set" do
+      let(:config) { super().merge(unique_name: true) }
+
+      it "reports the name vRA will give the deployment" do
+        allow(driver).to receive(:info)
+
+        driver.request_server
+
+        expect(driver).to have_received(:info)
+          .with("Deployment name is deployment_74e26af9-2d2f-4889-a472-95dbcedb70b8")
+      end
+    end
   end
 
   describe "#wait_for_server" do
     let(:connection) { instance.transport.connection(state) }
     let(:state)      { {} }
-    let(:resource1) do
-      double("server1",
-             id: "test_id",
-             name: "server1",
-             ip_address: "1.2.3.4",
-             vm?: true)
-    end
+    let(:resource1)  { vra_resource(id: "test_id", name: "server1") }
 
     before do
       allow(transport).to receive(:connection).and_return(connection)
@@ -330,45 +381,91 @@ describe Kitchen::Driver::Vra do
     end
   end
 
+  describe "#status" do
+    let(:deployments) { instance_double(Vra::Deployments) }
+    let(:client)      { vra_client(deployments: deployments) }
+
+    before { allow(driver).to receive(:vra_client).and_return(client) }
+
+    it "reports an unknown status when state names no deployment" do
+      expect(driver.status({})).to include(live: nil, state: "unknown")
+    end
+
+    it "reports an unknown status when vRA has never heard of the deployment" do
+      allow(deployments).to receive(:by_id).with("gone")
+        .and_raise(Vra::Exception::NotFound.new("nope"))
+
+      expect(driver.status(deployment_id: "gone")).to include(state: "unknown")
+    end
+
+    it "reports a successfully created deployment as live" do
+      allow(deployments).to receive(:by_id).with("dep-1").and_return(vra_deployment)
+
+      expect(driver.status(deployment_id: "dep-1")).to include(
+        live: true, state: "CREATE_SUCCESSFUL", source: "driver",
+        resource_id: "dep-1"
+      )
+    end
+
+    it "stamps when the check happened" do
+      allow(deployments).to receive(:by_id).and_return(vra_deployment)
+
+      expect(driver.status(deployment_id: "dep-1")[:checked_at])
+        .to match(/\A\d{4}-\d{2}-\d{2}T/)
+    end
+
+    it "reports a deployment still building as not live" do
+      allow(deployments).to receive(:by_id).and_return(vra_deployment(status: "CREATE_INPROGRESS"))
+
+      expect(driver.status(deployment_id: "dep-1"))
+        .to include(live: false, state: "CREATE_INPROGRESS")
+    end
+
+    it "names a failed deployment rather than reporting a bare false" do
+      allow(deployments).to receive(:by_id).and_return(vra_deployment(status: "CREATE_FAILED", failed?: true))
+
+      expect(driver.status(deployment_id: "dep-1"))
+        .to include(live: false, state: "CREATE_FAILED")
+    end
+
+    it "reports an unknown status when vRA cannot be reached" do
+      allow(deployments).to receive(:by_id).and_raise(StandardError.new("boom"))
+
+      expect(driver.status(deployment_id: "dep-1")).to include(state: "unknown")
+    end
+  end
+
   describe "#destroy" do
-    let(:deployment_id)     { "8c1a833a-5844-4100-b58c-9cab3543c958" }
+    let(:deployment_id)   { "8c1a833a-5844-4100-b58c-9cab3543c958" }
     let(:state)           { { deployment_id: deployment_id } }
-    let(:vra_client)      { double("vra_client") }
-    let(:deployments)       { double("resources") }
-    let(:destroy_request) { double("destroy_request") }
-    let(:resource) do
-      double("server1",
-             deployment_id: deployment_id,
-             name: "server1",
-             ip_address: "5.6.7.8",
-             vm?: true)
-    end
+    let(:deployments)     { instance_double(Vra::Deployments) }
+    let(:client)          { vra_client(deployments: deployments) }
+    let(:destroy_request) { vra_request(id: "6da65982-7c33-4e6e-b346-fdf4bcbf01ab") }
+    let(:deployment)      { vra_deployment(id: deployment_id, destroy: destroy_request) }
 
     before do
-      allow(driver).to receive(:vra_client).and_return(vra_client)
+      allow(driver).to receive(:vra_client).and_return(client)
       allow(driver).to receive(:wait_for_request).with(destroy_request)
-      allow(vra_client).to receive(:deployments).and_return(deployments)
-      allow(deployments).to receive(:by_id).and_return(resource)
-      allow(resource).to receive(:destroy).and_return(destroy_request)
-      allow(destroy_request).to receive(:id).and_return("6da65982-7c33-4e6e-b346-fdf4bcbf01ab")
+      allow(deployments).to receive(:by_id).and_return(deployment)
     end
 
     context "when the resource is not created" do
       let(:state) { {} }
+
       it "does not look up the resource if no resource ID exists" do
-        expect(vra_client.deployments).not_to receive(:by_id)
+        expect(deployments).not_to receive(:by_id)
         driver.destroy(state)
       end
     end
 
     it "looks up the resource record" do
-      expect(vra_client.deployments).to receive(:by_id).with(deployment_id).and_return(resource)
+      expect(deployments).to receive(:by_id).with(deployment_id).and_return(deployment)
       driver.destroy(state)
     end
 
     context "when the resource record cannot be found" do
       it "does not raise an exception" do
-        allow(vra_client.deployments).to receive(:by_id).with(deployment_id).and_raise(Vra::Exception::NotFound)
+        allow(deployments).to receive(:by_id).with(deployment_id).and_raise(Vra::Exception::NotFound)
         expect { driver.destroy(state) }.not_to raise_error
       end
     end
@@ -376,13 +473,13 @@ describe Kitchen::Driver::Vra do
     describe "creating the destroy request" do
       context "when the destroy method or server is not found" do
         it "does not raise an exception" do
-          allow(resource).to receive(:destroy).and_raise(Vra::Exception::NotFound)
+          allow(deployment).to receive(:destroy).and_raise(Vra::Exception::NotFound)
           expect { driver.destroy(state) }.not_to raise_error
         end
       end
 
       it "calls #destroy on the server" do
-        expect(resource).to receive(:destroy).and_return(destroy_request)
+        expect(deployment).to receive(:destroy).and_return(destroy_request)
         driver.destroy(state)
       end
     end
@@ -391,81 +488,201 @@ describe Kitchen::Driver::Vra do
       expect(driver).to receive(:wait_for_request).with(destroy_request)
       driver.destroy(state)
     end
-  end
 
-  describe "#catalog_request" do
-    let(:catalog_request) { double("catalog_request") }
-    let(:vra_client)      { double("vra_client") }
-    let(:catalog)         { double("catalog") }
-    before do
-      allow(driver).to receive(:vra_client).and_return(vra_client)
-      allow(vra_client).to receive(:catalog).and_return(catalog)
-      allow(catalog).to receive(:request).and_return(catalog_request)
-      %i{catalog_id= set_parameter}.each do |method|
-        allow(catalog_request).to receive(method)
+    describe "the cached credentials" do
+      let(:cache_dir) { Dir.mktmpdir("kitchen-vra-spec") }
+
+      around { |example| Dir.chdir(cache_dir) { example.run } }
+      after  { FileUtils.remove_entry(cache_dir) }
+
+      it "removes the cache file left behind by a previous run" do
+        FileUtils.mkdir_p(".kitchen")
+        File.write(".kitchen/cached_vra", "cached")
+
+        driver.destroy(state)
+
+        expect(File.exist?(".kitchen/cached_vra")).to be false
+      end
+
+      it "does not claim to have removed a cache file that was never written" do
+        expect(driver).not_to receive(:info).with(/Removed.*cached/i)
+
+        driver.destroy(state)
       end
     end
+  end
+
+  describe "#catalog_request" do
+    let(:deployment_request) { vra_deployment_request }
+    let(:catalog)            { instance_double(Vra::Catalog, request: deployment_request) }
+    let(:client)             { vra_client(catalog: catalog) }
+
+    before { allow(driver).to receive(:vra_client).and_return(client) }
 
     it "creates a catalog_request" do
-      expect(vra_client.catalog).to receive(:request).and_return(catalog_request)
+      expect(catalog).to receive(:request).and_return(deployment_request)
       driver.catalog_request
     end
 
-    context "when option parameters are not supplied" do
+    it "asks for the configured image, flavor, project and version" do
+      expect(catalog).to receive(:request).with(
+        "1536b95d-68fe-3c68-9417-46ed24bee3ef",
+        hash_including(
+          image_mapping:  "VRA-nc-lnx-ce8.4-Docker",
+          flavor_mapping: "Small",
+          project_id:     "6ba69375-79d5-42c3-a099-7d32739f71a7",
+          version:        nil
+        )
+      ).and_return(deployment_request)
+
+      driver.catalog_request
+    end
+
+    it "names the deployment" do
+      expect(catalog).to receive(:request)
+        .with(anything, hash_including(name: "test-instance"))
+        .and_return(deployment_request)
+
+      driver.catalog_request
+    end
+
+    context "when unique_name is set" do
+      let(:config) { super().merge(unique_name: true) }
+
+      it "leaves vRA to name the deployment after the request" do
+        expect(catalog).to receive(:request)
+          .with(anything, hash_excluding(:name))
+          .and_return(deployment_request)
+
+        driver.catalog_request
+      end
+    end
+
+    context "when the catalog item is named rather than identified" do
       let(:config) do
-        {
-          base_url:        "https://vra.corp.local",
-          username:        "myuser",
-          password:        "mypassword",
-          domain:          "domain.corp.com",
-          verify_ssl:      true,
-          project_id:      "6ba69375-79d5-42c3-a099-7d32739f71a7",
-          image_mapping:   "VRA-nc-lnx-ce8.4-Docker",
-          flavor_mapping:  "Small",
-          catalog_id:      "2kabc423-af89-56fc-990a-82fab34ed12",
-        }
+        super().reject { |key, _value| key == :catalog_id }
+          .merge(catalog_name: "Ubuntu Server")
+      end
+
+      it "looks the name up and requests the ID it resolves to" do
+        allow(catalog).to receive(:fetch_catalog_items).with("Ubuntu Server")
+          .and_return([vra_catalog_item(id: "cat-9")])
+        expect(catalog).to receive(:request).with("cat-9", anything).and_return(deployment_request)
+
+        driver.catalog_request
+      end
+
+      context "when the name matches nothing in the catalog" do
+        before do
+          allow(catalog).to receive(:fetch_catalog_items).and_return([])
+          allow(driver).to receive(:error)
+        end
+
+        it "fails rather than requesting an unknown catalog item" do
+          expect { driver.catalog_request }
+            .to raise_error(Kitchen::InstanceFailure, /without a valid catalog/)
+        end
+
+        it "says which name it could not resolve" do
+          expect { driver.catalog_request }.to raise_error(Kitchen::InstanceFailure)
+
+          expect(driver).to have_received(:error).with(/Ubuntu Server/)
+        end
       end
+    end
+
+    context "when neither a catalog ID nor a catalog name is given" do
+      let(:config) { super().reject { |key, _value| key == :catalog_id } }
 
+      it "fails before talking to vRA" do
+        expect(catalog).not_to receive(:request)
+        expect { driver.catalog_request }.to raise_error(Kitchen::InstanceFailure)
+      end
+    end
+
+    context "when option parameters are not supplied" do
       it "does not attempt to set params on the catalog_request" do
-        expect(catalog_request).not_to receive(:set_parameters)
+        expect(deployment_request).not_to receive(:set_parameters)
         driver.catalog_request
       end
     end
 
     context "when extra parameters are set" do
       let(:config) do
-        {
-          base_url:         "https://vra.corp.local",
-          username:         "myuser",
-          password:         "mypassword",
-          domain:           "mydomain.corp.com",
-          verify_ssl:       true,
-          project_id:       "6ba69375-79d5-42c3-a099-7d32739f71a7",
-          image_mapping:    "VRA-nc-lnx-ce8.4-Docker",
-          flavor_mapping:   "Small",
-          catalog_id:      "2kabc423-af89-56fc-990a-82fab34ed12",
-          extra_parameters: { "key1" => { type: "string", value: "value1" },
-                              "key2" => { type: "integer", value: 123 } },
-        }
+        super().merge(
+          extra_parameters: {
+            "key1" => { type: "string", value: "value1" },
+            "key2" => { type: "integer", value: 123 },
+          }
+        )
       end
 
       it "sets extra parameters" do
-        expect(catalog_request).to receive(:set_parameters).with("key1", { type: "string", value: "value1" })
-        expect(catalog_request).to receive(:set_parameters).with("key2", { type: "integer", value: 123 })
+        expect(deployment_request).to receive(:set_parameters).with("key1", { type: "string", value: "value1" })
+        expect(deployment_request).to receive(:set_parameters).with("key2", { type: "integer", value: 123 })
         driver.catalog_request
       end
     end
   end
 
   describe "#vra_client" do
+    let(:client) { vra_client }
+
     it "sets up a client object" do
       expect(Vra::Client).to receive(:new).with(base_url:   config[:base_url],
-                                                username:   config[:username],
-                                                password:   config[:password],
-                                                domain:     config[:domain],
-                                                verify_ssl: config[:verify_ssl])
+        username:   config[:username],
+        password:   config[:password],
+        domain:     config[:domain],
+        verify_ssl: config[:verify_ssl])
       driver.vra_client
     end
+
+    it "builds the client once and hands the same one back" do
+      expect(Vra::Client).to receive(:new).once.and_return(client)
+
+      expect(driver.vra_client).to eq(client)
+      expect(driver.vra_client).to eq(client)
+    end
+
+    context "when cache_credentials is enabled" do
+      let(:config) { super().merge(cache_credentials: true) }
+
+      before { allow(driver).to receive(:c_save) }
+
+      it "does not prompt for credentials it already has" do
+        allow(Vra::Client).to receive(:new).and_return(client)
+        expect(driver).not_to receive(:ask)
+
+        driver.vra_client
+      end
+    end
+
+    context "when the client cannot be built" do
+      before do
+        allow(driver).to receive(:warn)
+        allow(driver).to receive(:check_config)
+      end
+
+      it "re-prompts for the credentials and tries once more" do
+        attempts = 0
+        allow(Vra::Client).to receive(:new) do
+          attempts += 1
+          raise ArgumentError, "Username and password are required" if attempts == 1
+
+          client
+        end
+
+        expect(driver.vra_client).to eq(client)
+        expect(driver).to have_received(:check_config).with(true)
+      end
+
+      it "raises rather than handing back something that is not a client" do
+        allow(Vra::Client).to receive(:new)
+          .and_raise(ArgumentError, "Username and password are required")
+
+        expect { driver.vra_client }.to raise_error(ArgumentError)
+      end
+    end
   end
 
   describe "#wait_for_request" do
@@ -476,21 +693,42 @@ describe Kitchen::Driver::Vra do
 
     context "when the requests completes normally, 3 loops" do
       it "only refreshes the request 3 times" do
-        request = double("request")
-        allow(request).to receive(:status)
-        allow(request).to receive(:completed?).exactly(3).times.and_return(false, false, true)
-        expect(request).to receive(:refresh).exactly(3).times
+        request = vra_request(status: nil)
+        allow(request).to receive(:completed?).and_return(false, false, true)
 
         driver.wait_for_request(request)
+
+        expect(request).to have_received(:refresh).exactly(3).times
       end
     end
 
     context "when the request is completed on the first loop" do
       it "only refreshes the request 1 time" do
-        request = double("request")
-        allow(request).to receive(:status)
-        allow(request).to receive(:completed?).once.and_return(true)
-        expect(request).to receive(:refresh).once
+        request = vra_request(status: nil)
+
+        driver.wait_for_request(request)
+
+        expect(request).to have_received(:refresh).once
+      end
+    end
+
+    it "reports a status once, not on every poll" do
+      request = vra_request(status: "IN_PROGRESS")
+      allow(request).to receive(:completed?).and_return(false, false, true)
+      allow(driver).to receive(:info)
+
+      driver.wait_for_request(request)
+
+      expect(driver).to have_received(:info).with("Current request status: IN_PROGRESS").once
+    end
+
+    context "with a slower refresh rate configured" do
+      let(:config) { super().merge(request_refresh_rate: 10) }
+
+      it "waits that long between polls" do
+        request = vra_request(status: nil)
+        allow(request).to receive(:completed?).and_return(false, true)
+        expect(driver).to receive(:sleep).with(10)
 
         driver.wait_for_request(request)
       end
@@ -498,16 +736,19 @@ describe Kitchen::Driver::Vra do
 
     context "when the timeout is exceeded" do
       it "prints a warning and exits" do
-        request = double("request")
         allow(Timeout).to receive(:timeout).and_raise(Timeout::Error)
-        expect { driver.wait_for_request(request) }.to raise_error(Timeout::Error)
+        allow(driver).to receive(:error)
+
+        expect { driver.wait_for_request(vra_request) }.to raise_error(Timeout::Error)
+        expect(driver).to have_received(:error).with(/did not complete in 600 seconds/)
       end
     end
 
     context "when a non-timeout exception is raised" do
       it "raises the original exception" do
-        request = double("request")
+        request = vra_request
         allow(request).to receive(:refresh).and_raise(RuntimeError)
+
         expect { driver.wait_for_request(request) }.to raise_error(RuntimeError)
       end
     end
@@ -525,6 +766,13 @@ describe Kitchen::Driver::Vra do
 
     after { FileUtils.remove_entry(cache_dir) }
 
+    # A second driver reading the cache the first one wrote, which is what the
+    # next `kitchen` run is.
+    def reader(overrides = {})
+      described_class.new(config.merge(overrides).reject { |k, _v| %i{username password}.include?(k) })
+        .tap { |driver| allow(driver).to receive(:instance).and_return(instance) }
+    end
+
     describe "#c_save" do
       it "creates the cache file" do
         driver.c_save
@@ -544,18 +792,29 @@ describe Kitchen::Driver::Vra do
         driver.c_save
         expect(File.read(cache_file)).not_to include("mypassword")
       end
+
+      it "does not write the username in the clear either" do
+        driver.c_save
+        expect(File.read(cache_file)).not_to include("myuser")
+      end
+
+      it "reports a cache it could not write rather than failing the run" do
+        allow(FileUtils).to receive(:mkdir_p).and_raise(Errno::EACCES)
+        expect(driver).to receive(:warn).with(/Unable to save credentials/)
+
+        expect { driver.c_save }.not_to raise_error
+      end
     end
 
     describe "#c_load" do
       it "restores credentials written by #c_save" do
         driver.c_save
 
-        reader = Kitchen::Driver::Vra.new(config.reject { |k, _v| %i{username password}.include?(k) })
-        allow(reader).to receive(:instance).and_return(instance)
-        reader.c_load
+        loader = reader
+        loader.c_load
 
-        expect(reader[:username]).to eq("myuser")
-        expect(reader[:password]).to eq("mypassword")
+        expect(loader[:username]).to eq("myuser")
+        expect(loader[:password]).to eq("mypassword")
       end
 
       it "does nothing when no cache file exists" do
@@ -566,9 +825,7 @@ describe Kitchen::Driver::Vra do
       it "refuses a cache written against a different base_url" do
         driver.c_save
 
-        other = Kitchen::Driver::Vra.new(config.merge(base_url: "https://other.corp.local")
-                                               .reject { |k, _v| %i{username password}.include?(k) })
-        allow(other).to receive(:instance).and_return(instance)
+        other = reader(base_url: "https://other.corp.local")
         expect(other).to receive(:warn).with(/Failed to load cached credentials/)
         other.c_load
 
@@ -580,30 +837,97 @@ describe Kitchen::Driver::Vra do
         driver.c_save
         File.write(cache_file, File.read(cache_file).succ)
 
-        loader = Kitchen::Driver::Vra.new(config.reject { |k, _v| %i{username password}.include?(k) })
-        allow(loader).to receive(:instance).and_return(instance)
+        loader = reader
         expect(loader).to receive(:warn).with(/Failed to load cached credentials/)
         loader.c_load
 
         expect(loader[:username]).to be_nil
       end
+
+      it "refuses a cache written in a layout it does not recognize" do
+        FileUtils.mkdir_p(File.dirname(cache_file))
+        File.write(cache_file, "v0:whatever")
+
+        loader = reader
+        expect(loader).to receive(:warn).with(/unrecognized cache format/)
+        loader.c_load
+
+        expect(loader[:username]).to be_nil
+      end
     end
 
     describe "#check_config" do
-      it "uses the cache instead of prompting" do
-        driver.c_save
+      it "keeps the credentials it was configured with" do
+        allow(driver).to receive(:ask)
 
-        reader = Kitchen::Driver::Vra.new(config.reject { |k, _v| %i{username password}.include?(k) })
-        allow(reader).to receive(:instance).and_return(instance)
-        allow(ENV).to receive(:[]).and_call_original
-        allow(ENV).to receive(:[]).with("VRA_USER_NAME").and_return(nil)
-        allow(ENV).to receive(:[]).with("VRA_USER_PASSWORD").and_return(nil)
-        expect(reader).not_to receive(:ask)
+        driver.check_config
 
-        reader.check_config
+        expect(driver[:username]).to eq("myuser")
+        expect(driver[:password]).to eq("mypassword")
+        expect(driver).not_to have_received(:ask)
+      end
+
+      it "asks again when told to, even though it has credentials" do
+        allow(driver).to receive(:ask).and_return("newuser", "newpass")
+
+        driver.check_config(true)
+
+        expect(driver[:username]).to eq("newuser")
+        expect(driver[:password]).to eq("newpass")
+      end
+
+      it "does not write a cache file unless asked to" do
+        driver.check_config
+
+        expect(File.exist?(cache_file)).to be false
+      end
+
+      context "when cache_credentials is enabled" do
+        let(:config) { super().merge(cache_credentials: true) }
+
+        it "writes the credentials out for the next run" do
+          driver.check_config
+
+          expect(File.exist?(cache_file)).to be true
+        end
+      end
 
-        expect(reader[:username]).to eq("myuser")
-        expect(reader[:password]).to eq("mypassword")
+      context "when the config names no credentials" do
+        it "reads them from the environment" do
+          stub_const("ENV", ENV.to_hash.merge("VRA_USER_NAME" => "envuser",
+            "VRA_USER_PASSWORD" => "envpass"))
+          loader = reader
+          expect(loader).not_to receive(:ask)
+
+          loader.check_config
+
+          expect(loader[:username]).to eq("envuser")
+          expect(loader[:password]).to eq("envpass")
+        end
+
+        it "uses the cache instead of prompting" do
+          driver.c_save
+
+          stub_const("ENV", ENV.to_hash.reject { |key, _v| key.start_with?("VRA_USER_") })
+          loader = reader
+          expect(loader).not_to receive(:ask)
+
+          loader.check_config
+
+          expect(loader[:username]).to eq("myuser")
+          expect(loader[:password]).to eq("mypassword")
+        end
+
+        it "prompts as a last resort" do
+          stub_const("ENV", ENV.to_hash.reject { |key, _v| key.start_with?("VRA_USER_") })
+          loader = reader
+          allow(loader).to receive(:ask).and_return("askeduser", "askedpass")
+
+          loader.check_config
+
+          expect(loader[:username]).to eq("askeduser")
+          expect(loader[:password]).to eq("askedpass")
+        end
       end
     end
   end