chef-provisioning-google 0.1.0

data/spec/chef/provisioning/google_driver/client/instances_spec.rb

@@ -0,0 +1,205 @@
+require "chef/provisioning/google_driver/client/instances"
+require "chef/provisioning/google_driver/client/google_compute_error"
+require_relative "services_helper"
+
+include Chef::Provisioning::GoogleDriver::Client
+
+RSpec.describe Instances do
+  include ServicesHelper
+
+  before(:example) do
+    setup_service("instances", %w{get insert delete start stop})
+    @instances_client = Instances.new(@google, ServicesHelper::PROJECT,
+                                      ServicesHelper::ZONE)
+  end
+
+  context "when start is called" do
+
+    def expect_start(status, body)
+      expect_call("instances.start", { instance: "instance_name" },
+                  nil, status, body)
+    end
+
+    it "raises an error if the API call failed" do
+      expect_start(400, {})
+      expect do
+        @instances_client.start("instance_name")
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "raises an error if the response contains errors" do
+      expect_start(200, { error: { errors: [{ message: "failure!" }] } })
+      expect do
+        @instances_client.start("instance_name")
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "returns a valid operation if everything goes well" do
+      expect_start(200, { name: "name", status: "LOL" })
+      operation = @instances_client.start("instance_name")
+      expect(operation.name).to eq("name")
+      expect(operation).not_to be_done
+    end
+
+  end
+
+  context "when stop is called" do
+
+    def expect_stop(status, body)
+      expect_call("instances.stop", { instance: "instance_name" },
+                  nil, status, body)
+    end
+
+    it "raises an error if the API call failed" do
+      expect_stop(400, {})
+      expect do
+        @instances_client.stop("instance_name")
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "raises an error if the response contains errors" do
+      expect_stop(200, { error: { errors: [{ message: "failure!" }] } })
+      expect do
+        @instances_client.stop("instance_name")
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "returns a valid operation if everything goes well" do
+      expect_stop(200, { name: "name", status: "LOL" })
+      operation = @instances_client.stop("instance_name")
+      expect(operation.name).to eq("name")
+      expect(operation).not_to be_done
+    end
+
+  end
+
+  context "when delete is called" do
+
+    def expect_delete(status, body)
+      expect_call("instances.delete", { instance: "instance_name" },
+                  nil, status, body)
+    end
+
+    it "raises an error if the API call failed" do
+      expect_delete(400, {})
+      expect do
+        @instances_client.delete("instance_name")
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "raises an error if the response contains errors" do
+      expect_delete(200, { error: { errors: [{ message: "failure!" }] } })
+      expect do
+        @instances_client.delete("instance_name")
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "returns a valid operation if everything goes well" do
+      expect_delete(200, { name: "name", status: "LOL" })
+      operation = @instances_client.delete("instance_name")
+      expect(operation.name).to eq("name")
+      expect(operation).not_to be_done
+    end
+
+  end
+
+  context "when create is called" do
+
+    def expect_create(status, body)
+      expect_call("instances.insert", {}, { some_option: 123 },
+                  status, body)
+    end
+
+    it "raises an error if the API call failed" do
+      expect_create(400, {})
+      expect do
+        @instances_client.create(some_option: 123)
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "raises an error if the response contains errors" do
+      expect_create(200, { error: { errors: [{ message: "failure!" }] } })
+      expect do
+        @instances_client.create(some_option: 123)
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "returns a valid operation if everything goes well" do
+      expect_create(200, { name: "name", status: "DONE" })
+      operation = @instances_client.create(some_option: 123)
+      expect(operation.name).to eq("name")
+      expect(operation).to be_done
+    end
+
+  end
+
+  context "when get is called" do
+
+    def expect_get(status, body)
+      expect_call("instances.get", { instance: "instance_name" },
+                  nil, status, body)
+    end
+
+    it 'returns nil if the instance couldn\'t be found' do
+      expect_get(404, {})
+      @instances_client.get("instance_name")
+    end
+
+    it "raises an error if the API call failed" do
+      expect_get(400, {})
+      expect do
+        @instances_client.get("instance_name")
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "raises an error if the response contains errors" do
+      expect_get(200, { error: { errors: [{ message: "failure!" }] } })
+      expect do
+        @instances_client.get("instance_name")
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "returns a valid instance if everything goes well" do
+      networkInterface = { accessConfigs: [{ natIP: "ip" }] }
+      expect_get(200, {
+                   name: "instance_name",
+                   id: "instance_id",
+                   status: "RUNNING",
+                   networkInterfaces: [networkInterface],
+                 })
+      instance = @instances_client.get("instance_name")
+      expect(instance.name).to eq("instance_name")
+      expect(instance.id).to eq("instance_id")
+      expect(instance.status).to eq("RUNNING")
+      expect(instance).to be_running
+      expect(instance).not_to be_stopped
+      expect(instance).not_to be_stopping
+      expect(instance).not_to be_terminated
+      expect(instance.determine_remote_host).to eq("ip")
+    end
+
+  end
+
+  context "when wait_for_status is called" do
+
+    def expect_get(name, body)
+      expect_call("instances.get", { instance: name },
+                  nil, 200, body)
+    end
+
+    before(:example) do
+      @action_handler = double("action_handler")
+      expect(@action_handler).to receive(:report_progress)
+    end
+
+    it "returns a valid instance if everything goes well" do
+      expect_get("instance_name", { name: "instance_name2" })
+      instance = @instances_client.get("instance_name")
+      expect_get("instance_name2", { name: "instance_name2", status: "RUNNING" })
+      running_instance = @instances_client.wait_for_status(@action_handler,
+                                                           instance, "RUNNING")
+      expect(running_instance.name).to eq("instance_name2")
+    end
+  end
+
+end

data/spec/chef/provisioning/google_driver/client/operations_spec.rb

@@ -0,0 +1,62 @@
+require "chef/provisioning/google_driver/client/global_operations"
+require "chef/provisioning/google_driver/client/zone_operations"
+require "chef/provisioning/google_driver/client/google_compute_error"
+require "chef/provisioning/google_driver/client/operation"
+require_relative "services_helper"
+
+include Chef::Provisioning::GoogleDriver::Client
+
+RSpec.shared_examples "Operations" do |service_name, client_class|
+
+  include ServicesHelper
+
+  before(:example) do
+    setup_service(service_name, ["get"])
+    @service_name = service_name
+    @operations_client = client_class.new(@google, ServicesHelper::PROJECT,
+                                          ServicesHelper::ZONE)
+    @operation = Operation.new({ body: { name: "op", status: "NOT_DONE" } })
+  end
+
+  context "when get is called" do
+
+    def expect_get(status, body)
+      expect_call("#{@service_name}.get", { operation: "op" }, nil, status, body)
+    end
+
+    it "raises an error if the API call failed" do
+      expect_get(400, {})
+      expect do
+        @operations_client.get(@operation)
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "raises an error if the response contains errors" do
+      expect_get(200, { error: { errors: [{ message: "failure!" }] } })
+      expect do
+        @operations_client.get(@operation)
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "returns a valid result if everything goes well" do
+      expect_get(200, { name: "op", status: "NOT_DONE" })
+      operation = @operations_client.get(@operation)
+      expect(operation.name).to eq("op")
+      expect(operation).not_to be_done
+    end
+
+  end
+
+end
+
+RSpec.describe GlobalOperations do
+
+  it_behaves_like "Operations", "global_operations", GlobalOperations
+
+end
+
+RSpec.describe ZoneOperations do
+
+  it_behaves_like "Operations", "zone_operations", ZoneOperations
+
+end

data/spec/chef/provisioning/google_driver/client/projects_spec.rb

@@ -0,0 +1,162 @@
+require "chef/provisioning/google_driver/client/projects"
+require "chef/provisioning/google_driver/client/google_compute_error"
+require_relative "services_helper"
+
+include Chef::Provisioning::GoogleDriver::Client
+
+RSpec.describe Projects do
+
+  FINGERPRINT = "asdf"
+  ITEMS = [{ key: "sshKeys", value: "testuser1:key1\ntestuser2:key2" },
+           { key: "chef-provisioning-google_ssh-mappings",
+             value: "testuser3:key3\ntestuser4:key4" }]
+  SSH_KEYS = [%w{testuser1 key1}, %w{testuser2 key2}]
+  SSH_MAPPINGS = { "testuser3" => "key3", "testuser4" => "key4" }
+
+  include ServicesHelper
+
+  before(:example) do
+    setup_service("projects", %w{get set_common_instance_metadata})
+    @projects_client = Projects.new(@google, ServicesHelper::PROJECT,
+                                    ServicesHelper::ZONE)
+  end
+
+  def expect_get(status, body)
+    expect_call("projects.get", {}, nil, status, body)
+  end
+
+  def expect_successful_get
+    expect_get(200, { name: "name", commonInstanceMetadata: {
+                   fingerprint: FINGERPRINT,
+                   items: ITEMS,
+                 } })
+  end
+
+  context "when get is called" do
+
+    it "raises an error if the API call failed" do
+      expect_get(400, {})
+      expect do
+        @projects_client.get
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "raises an error if the response contains errors" do
+      expect_get(200, { error: { errors: [{ message: "failure!" }] } })
+      expect do
+        @projects_client.get
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "returns a valid result if everything goes well" do
+      expect_successful_get
+      metadata = @projects_client.get
+      expect(metadata).not_to be_changed
+      expect(metadata.ssh_keys).to eq(SSH_KEYS)
+      expect(metadata.ssh_mappings).to eq(SSH_MAPPINGS)
+      expect(metadata).not_to be_changed
+    end
+
+  end
+
+  context "when set_common_instance_metadata is called" do
+    before(:example) do
+      expect_successful_get
+      @metadata = @projects_client.get
+    end
+
+    def expect_set_common_instance_metadata(ssh_keys, ssh_mappings, status,
+                                            response_body)
+      request_body = {
+        items: [{ key: "chef-provisioning-google_ssh-mappings",
+                  value: ssh_mappings },
+                { key: "sshKeys", value: ssh_keys }],
+        fingerprint: FINGERPRINT,
+      }
+      expect_call("projects.set_common_instance_metadata", {}, request_body,
+                  status, response_body)
+    end
+
+    it 'does nothing if the metadata hasn\'t been changed' do
+      @metadata.ssh_keys
+      @metadata.ssh_mappings
+      @projects_client.set_common_instance_metadata(@metadata)
+    end
+
+    it "raises an error if the API call failed" do
+      expect_set_common_instance_metadata(
+        "testuser1:key1\ntestuser2:key2\nfoo:bar",
+        "testuser3:key3\ntestuser4:key4",
+        400,
+        {})
+      # Change something such that the API call actually happens.
+      @metadata.ensure_key("foo", "bar")
+      expect do
+        @projects_client.set_common_instance_metadata(@metadata)
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "raises an error if the response contains errors" do
+      expect_set_common_instance_metadata(
+        "testuser1:key1\ntestuser2:key2\nfoo:bar",
+        "testuser3:key3\ntestuser4:key4",
+        200,
+        { error: { errors: [{ message: "failure!" }] } })
+      # Change something such that the API call actually happens.
+      @metadata.ensure_key("foo", "bar")
+      expect do
+        @projects_client.set_common_instance_metadata(@metadata)
+      end.to raise_error(GoogleComputeError)
+    end
+
+    it "returns a valid result if an ssh key is added successfully" do
+      expect_set_common_instance_metadata(
+        "testuser1:key1\ntestuser2:key2\nfoo:bar",
+        "testuser3:key3\ntestuser4:key4",
+        200,
+        { status: "DONE" })
+      @metadata.ensure_key("foo", "bar")
+      expect(@metadata).to be_changed
+      operation = @projects_client.set_common_instance_metadata(@metadata)
+      expect(operation).to be_done
+    end
+
+    it "returns a valid result if an ssh mapping is added successfully" do
+      expect_set_common_instance_metadata(
+        "testuser1:key1\ntestuser2:key2",
+        "testuser3:key3\ntestuser4:key4\nfoo:bar",
+        200,
+        { status: "DONE" })
+      @metadata.set_ssh_mapping("foo", "bar")
+      expect(@metadata).to be_changed
+      operation = @projects_client.set_common_instance_metadata(@metadata)
+      expect(operation).to be_done
+    end
+
+    it "returns a valid result if an ssh key is removed successfully" do
+      expect_set_common_instance_metadata(
+        "testuser1:key1",
+        "testuser3:key3\ntestuser4:key4",
+        200,
+        { status: "DONE" })
+      @metadata.delete_ssh_key("key2")
+      expect(@metadata).to be_changed
+      operation = @projects_client.set_common_instance_metadata(@metadata)
+      expect(operation).to be_done
+    end
+
+    it "returns a valid result if an ssh mapping is removed successfully" do
+      expect_set_common_instance_metadata(
+        "testuser1:key1\ntestuser2:key2",
+        "testuser3:key3",
+        200,
+        { status: "DONE" })
+      @metadata.delete_ssh_mapping("testuser4")
+      expect(@metadata).to be_changed
+      operation = @projects_client.set_common_instance_metadata(@metadata)
+      expect(operation).to be_done
+    end
+
+  end
+
+end

data/spec/chef/provisioning/google_driver/client/services_helper.rb

@@ -0,0 +1,33 @@
+require "ffi_yajl"
+
+# Helper module for testing classes that do calls to the Google API.
+module ServicesHelper
+  PROJECT = "test-project"
+  ZONE = "test-zone"
+  DEFAULT_PARAMETERS = { project: PROJECT, zone: ZONE }
+
+  def setup_service(service_name, methods)
+    service = double(service_name)
+    methods.each do |m|
+      allow(service).to receive(m.to_sym).and_return("#{service_name}.#{m}")
+    end
+    compute = double("compute")
+    allow(compute).to receive(service_name.to_sym).and_return(service)
+    @google = double("google")
+    allow(@google).to receive(:discovered_api).and_return(compute)
+  end
+
+  def expect_call(method, parameters, request_body,
+                  status, response_body)
+    inner_response = double("inner_response")
+    allow(inner_response).to receive(:status).and_return(status)
+    encoded_body = FFI_Yajl::Encoder.encode(response_body)
+    allow(inner_response).to receive(:body).and_return(encoded_body)
+    response = double("response")
+    allow(response).to receive(:response).and_return(inner_response)
+    allow(@google).to receive(:execute).with(
+      hash_including(api_method: method,
+                     parameters: parameters.merge(DEFAULT_PARAMETERS),
+                     body_object: request_body)).and_return(response)
+  end
+end