stacker_bee 1.0.0

data/spec/integration/request_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'logger'
+
+describe "A response to a request sent to the CloudStack API", :vcr do
+  let(:io)         { StringIO.new }
+  let(:logger)     { Logger.new(io) }
+  let(:log_string) { io.string }
+  let(:url)        { CONFIG["url"] }
+  let(:config_hash) do
+    {
+      url:        url,
+      api_key:    CONFIG["api_key"],
+      secret_key: CONFIG["secret_key"],
+      logger:     logger,
+      apis_path:  File.join(File.dirname(__FILE__), '../fixtures/4.2.json')
+    }
+  end
+  let(:client) do
+    StackerBee::Client.new(config_hash)
+  end
+  subject { client.list_accounts }
+
+  it { should_not be_empty }
+
+  context "first item" do
+    subject { client.list_accounts.first }
+    it { should include "id" }
+    its(["accounttype"])  { should be_a Numeric }
+    its(["account_type"]) { should be_a Numeric }
+  end
+
+  it "should log request" do
+    subject
+    log_string.should include "listAccounts"
+  end
+
+  it "should not log response as error" do
+    subject
+    log_string.should_not include "ERROR"
+  end
+
+  context "containing an error" do
+    subject do
+      client.deploy_virtual_machine
+    end
+    it { expect { subject }.to raise_error StackerBee::ClientError }
+
+    it "should log response as error" do
+      begin
+        subject
+      rescue StackerBee::ClientError
+        log_string.should include "ERROR"
+      end
+    end
+  end
+
+  context "failing to connect" do
+    let(:url) { "http://127.0.0.1:1234/client/api" }
+    it "should raise helpful exception" do
+      klass = StackerBee::ConnectionError
+      expect(-> { subject }).to raise_error klass, /#{url}/
+    end
+  end
+
+  context "trailing slash in URL", :regression do
+    let(:url) { CONFIG["url"].gsub(/\/$/, '') + '/' }
+    it "makes request with trailing slash" do
+      stub = stub_request(:get, /#{url}/).to_return(body: '{"foo": {}}')
+      subject
+      stub.should have_been_requested
+    end
+  end
+
+  context "space character in a request parameter", :regression do
+    let(:params) { { name: "stacker bee" } }
+    subject do
+      client.list_accounts(params)
+    end
+
+    it "properly signs the request" do
+      expect { subject }.not_to raise_error
+    end
+  end
+
+  context "a nil request parameter", :regression do
+    let(:params) { { name: nil } }
+    subject do
+      client.list_accounts(params)
+    end
+
+    it "properly executes the request" do
+      expect { subject }.not_to raise_error
+    end
+  end
+
+  context "a request parameter with and empty string", :regression do
+    let(:params) { { name: '' } }
+    subject do
+      client.list_accounts(params)
+    end
+
+    it "properly executes the request" do
+      expect { subject }.not_to raise_error
+    end
+  end
+
+  context "a request parameter with an Array", :regression do
+    let(:params) { { page: 1, pagesize: 1, details: [:events, :stats] } }
+    subject do
+      client.list_hosts(params).first.keys
+    end
+    it { should include "cpuused" }
+    it { should include "events" }
+    it { should_not include "cpuallocated" }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,58 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require File.expand_path("../../lib/stacker_bee", __FILE__)
+
+require 'yaml'
+
+default_config_file = File.expand_path("../../config.default.yml", __FILE__)
+config_file         = File.expand_path("../../config.yml", __FILE__)
+
+CONFIG = YAML.load(File.read(default_config_file))
+CONFIG.merge!(YAML.load(File.read(config_file))) if File.exists?(config_file)
+
+require 'webmock/rspec'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.after(:each) do
+    StackerBee::Client.reset!
+  end
+end
+
+require 'vcr'
+
+VCR.configure do |c|
+  c.hook_into :webmock
+  c.cassette_library_dir     = 'spec/cassettes'
+  c.filter_sensitive_data('<CLOUD_STACK_URL>') do
+    CONFIG["url"]
+  end
+  c.filter_sensitive_data('<CLOUD_STACK_API_KEY>') do
+    CONFIG["api_key"]
+  end
+  c.filter_sensitive_data('<CLOUD_STACK_SECRET_KEY>') do
+    CONFIG["secret_key"]
+  end
+  c.default_cassette_options = {
+    record: :new_episodes,
+    match_requests_on: [
+      :method,
+      VCR.request_matchers.uri_without_param(:signature)
+    ]
+  }
+  c.configure_rspec_metadata!
+end

data/spec/units/stacker_bee/api_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe StackerBee::API do
+  subject { api }
+
+  let(:api) { StackerBee::API.new(api_path: api_path) }
+  let(:api_path) do
+    File.join(File.dirname(__FILE__), '../../fixtures/simple.json')
+  end
+
+  its(:api_path) { should eq api_path }
+
+  its(["list_virtual_machines"]) { should be_a Hash }
+  its(["get_vm_password"])       { should be_a Hash }
+  its(["getvmpassword"])         { should be_a Hash }
+  its(["getVMPassword"])         { should be_a Hash }
+  its(["getVmPassword"])         { should be_a Hash }
+  its(["getWRONG"])              { should be_nil }
+
+  it { should be_key "get_vm_password" }
+  it { should be_key "getvmpassword" }
+  it { should be_key "getVMPassword" }
+  it { should be_key "getVmPassword" }
+end

data/spec/units/stacker_bee/client_spec.rb

@@ -0,0 +1,181 @@
+require "spec_helper"
+require "ostruct"
+
+describe StackerBee::Client, ".api" do
+  let(:api) { double }
+  before do
+    StackerBee::API.stub(:new) { api }
+    StackerBee::Client.api_path = nil
+  end
+  subject { StackerBee::Client }
+  its(:api_path) { should_not be_nil }
+  its(:api) { should eq api }
+end
+
+describe StackerBee::Client, "calling endpoint" do
+  let(:url)         { "cloud-stack.com" }
+  let(:api_key)     { "cloud-stack-api-key" }
+  let(:secret_key)  { "cloud-stack-secret-key" }
+  let(:config_hash) do
+    {
+      url:        url,
+      api_key:    api_key,
+      secret_key: secret_key
+    }
+  end
+  let(:client)       { StackerBee::Client.new config_hash }
+  let(:endpoint)     { :list_virtual_machines }
+  let(:params)       { { list: :all } }
+  let(:connection)   { double }
+  let(:request)      { double :allow_empty_string_params= => nil }
+  let(:raw_response) { double }
+  let(:response)     { double }
+  let(:api_path) do
+    File.join(File.dirname(__FILE__), '../../fixtures/simple.json')
+  end
+
+  before do
+    StackerBee::Client.api_path = api_path
+    StackerBee::Connection.stub(:new) { connection }
+    StackerBee::Request.stub(:new).with(
+      "listVirtualMachines", api_key, params
+    ) do
+      request
+    end
+    connection.stub(:get).with(request) { raw_response }
+    StackerBee::Response.stub(:new).with(raw_response) { response }
+  end
+
+  subject { client }
+  it { should respond_to endpoint }
+  describe "response to endpoint request" do
+    subject { client.list_virtual_machines(params) }
+    it { should eq response }
+  end
+end
+
+describe StackerBee::Client, "#request" do
+  subject { client.request(endpoint, params) }
+  let(:endpoint)    { "listVirtualMachines" }
+  let(:params)      { { list: :all } }
+
+  let(:url)         { "cloud-stack.com" }
+  let(:api_key)     { "cloud-stack-api-key" }
+  let(:secret_key)  { "cloud-stack-secret-key" }
+  let(:config_hash) do
+    {
+      url:        url,
+      api_key:    api_key,
+      secret_key: secret_key
+    }
+  end
+  let(:client)        { StackerBee::Client.new config_hash }
+  let(:connection)    { double }
+  let(:request)       { double :allow_empty_string_params= => nil }
+  let(:raw_response)  { double }
+  let(:response)      { double }
+
+  before do
+    StackerBee::Connection.should_receive(:new) { connection }
+    StackerBee::Request.should_receive(:new).with(endpoint, api_key, params) do
+      request
+    end
+    connection.should_receive(:get).with(request) { raw_response }
+    StackerBee::Response.should_receive(:new).with(raw_response) { response }
+  end
+
+  it { should eq response }
+
+  context "called with a differently-cased endpoint" do
+    subject { client.request("list_Virtual_mACHINES", params) }
+    it { should eq response }
+  end
+end
+
+describe StackerBee::Client, "configuration" do
+  let(:default_url)         { "default_cloud-stack.com" }
+  let(:default_api_key)     { "default-cloud-stack-api-key" }
+  let(:default_secret_key)  { "default-cloud-stack-secret-key" }
+  let(:default_config_hash) do
+    {
+      url:        default_url,
+      api_key:    default_api_key,
+      secret_key: default_secret_key,
+      allow_empty_string_params: false
+    }
+  end
+  let!(:default_configuration) do
+    StackerBee::Configuration.new(default_config_hash)
+  end
+  let(:instance_url)        { "instance-cloud-stack.com" }
+  let(:instance_api_key)    { "instance-cloud-stack-api-key" }
+  let(:instance_secret_key) { "instance-cloud-stack-secret-key" }
+  let(:instance_config_hash) do
+    {
+      url:        instance_url,
+      api_key:    instance_api_key,
+      secret_key: instance_secret_key,
+      allow_empty_string_params: false
+    }
+  end
+  let!(:instance_configuration) do
+    StackerBee::Configuration.new(instance_config_hash)
+  end
+  before do
+    StackerBee::Configuration.stub(:new) do
+      fail "Unexpected Configuration instantiation"
+    end
+    StackerBee::Configuration.stub(:new).with(default_config_hash)  do
+      default_configuration
+    end
+    StackerBee::Configuration.stub(:new).with(instance_config_hash) do
+      instance_configuration
+    end
+    StackerBee::Client.configuration = default_config_hash
+  end
+
+  describe ".new" do
+    subject { StackerBee::Client.new }
+
+    context "with default, class configuration" do
+      its(:url)           { should eq default_url }
+      its(:api_key)       { should eq default_api_key }
+      its(:secret_key)    { should eq default_secret_key }
+    end
+
+    context "with instance-specific configuration" do
+      subject { StackerBee::Client.new(instance_config_hash) }
+      its(:configuration) { should eq instance_configuration }
+      its(:url)           { should eq instance_url }
+      its(:api_key)       { should eq instance_api_key }
+      its(:secret_key)    { should eq instance_secret_key }
+    end
+
+    context "with instance-specific configuration that's not a hash" do
+      subject { StackerBee::Client.new(config) }
+      let(:config) { double(to_hash: instance_config_hash) }
+      its(:configuration) { should eq instance_configuration }
+      its(:url)           { should eq instance_url }
+      its(:api_key)       { should eq instance_api_key }
+      its(:secret_key)    { should eq instance_secret_key }
+    end
+
+    describe "#url" do
+      let(:other_url) { "other-cloud-stack.com" }
+      before { subject.url = other_url }
+      its(:url) { should eq other_url }
+    end
+
+    describe "#api_key" do
+      let(:other_api_key) { "other-cloud-stack-api-key" }
+      before { subject.api_key = other_api_key }
+      its(:api_key) { should eq other_api_key }
+    end
+
+    describe "#secret_key" do
+      let(:other_secret_key) { "other-cloud-stack-secret-key" }
+      before { subject.secret_key = other_secret_key }
+      its(:secret_key) { should eq other_secret_key }
+    end
+  end
+end

data/spec/units/stacker_bee/configuration_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe StackerBee::Configuration do
+  its(:url)         { should be_nil }
+  its(:api_key)     { should be_nil }
+  its(:secret_key)  { should be_nil }
+end

data/spec/units/stacker_bee/connection_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe StackerBee::Connection do
+  let(:url)           { "http://test.com:1234/foo/bar/" }
+  let(:secret_key)    { "shhh" }
+  let(:configuration) { double url: url, secret_key: secret_key }
+  let(:query_params)  { [[:foo, :bar]] }
+  let(:request)       { double query_params: query_params }
+  let(:response)      { double }
+  let(:faraday)       { double get: response }
+  let(:connection)    { StackerBee::Connection.new configuration }
+  subject { connection.get request }
+  before do
+    Faraday.stub(:new) { faraday }
+  end
+
+  context "successfully connecting" do
+    before do
+      faraday.should_receive(:get).with('/foo/bar/', query_params) { response }
+    end
+    it { should be response }
+    it "specifies url without path when creating connection" do
+      subject
+      Faraday.should have_received(:new).with(url: "http://test.com:1234")
+    end
+  end
+
+  context "failing to connect" do
+    before do
+      faraday.stub(:get) { fail Faraday::Error::ConnectionFailed, "boom" }
+    end
+    it "should raise helpful exception" do
+      klass = StackerBee::ConnectionError
+      expect(-> { subject }).to raise_error klass, /#{url}/
+    end
+  end
+
+  context "no protocol specified in URL" do
+    let(:url) { "wrong.com" }
+    it "should raise helpful exception" do
+      klass = StackerBee::ConnectionError
+      expect(-> { subject }).to raise_error klass, /no protocol/
+    end
+  end
+end

data/spec/units/stacker_bee/middleware/logger_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe StackerBee::Middleware::Logger do
+  let(:app)        { double }
+  let(:io)         { StringIO.new }
+  let(:logger)     { Logger.new(io) }
+  let(:log_string) { io.string }
+  let(:middleware) { described_class.new app, logger }
+  subject { middleware }
+
+  context "with a no logger specified" do
+    let(:middleware) { described_class.new app, nil }
+    its(:logger) { should be_a Logger }
+  end
+
+  describe "logging request" do
+    let(:env) do
+      {
+        method:          "PATCH",
+        url:             "http://localhost",
+        request_headers: { "User-Agent" => "RSpec" }
+      }
+    end
+    before do
+      middleware.log_request(env)
+    end
+    subject { log_string }
+    it { should include "PATCH" }
+    it { should include "localhost" }
+    it { should include "User-Agent" }
+  end
+
+  describe "logging a response" do
+    let(:status) { 200 }
+    let(:env) do
+      {
+        status:           status,
+        body:             "OK",
+        response_headers: { "Server" => "RSpec" }
+      }
+    end
+    before do
+      middleware.log_response(env)
+    end
+    subject { log_string }
+    it { should =~ /INFO.*#{status}/ }
+    it { should include "OK" }
+    it { should include "Server" }
+
+    context "failing status" do
+      let(:status) { 401 }
+      it { should =~ /ERROR.*#{status}/ }
+    end
+  end
+end