stacker_bee 2.1.1.pre252 → 2.1.1.pre263

data/spec/integration/request_spec.rb

@@ -1,15 +1,15 @@
-require "spec_helper"
-require "logger"
+require 'spec_helper'
+require 'logger'
 
-describe "A response to a request sent to the CloudStack API", :vcr do
+describe 'A response to a request sent to the CloudStack API', :vcr do
   subject { client.list_accounts }
 
-  let(:url) { CONFIG["url"] }
+  let(:url) { CONFIG['url'] }
   let(:config_hash) do
     {
       url:         url,
-      api_key:     CONFIG["api_key"],
-      secret_key:  CONFIG["secret_key"],
+      api_key:     CONFIG['api_key'],
+      secret_key:  CONFIG['secret_key'],
       middlewares: middlewares
     }
   end
@@ -21,77 +21,77 @@ describe "A response to a request sent to the CloudStack API", :vcr do
 
   it { should_not be_empty }
 
-  context "first item" do
+  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 }
+    it { should include 'id' }
+    its(['accounttype'])  { should be_a Numeric }
+    its(['account_type']) { should be_a Numeric }
   end
 
-  context "failing to connect" do
-    let(:url) { "http://127.0.0.1:666/client/api" }
-    it "raises a helpful exception" do
+  context 'failing to connect' do
+    let(:url) { 'http://127.0.0.1:666/client/api' }
+    it 'raises a 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
+  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
+  context 'space character in a request parameter', :regression do
     subject { client.list_accounts(params) }
-    let(:params) { { name: "stacker bee" } }
+    let(:params) { { name: 'stacker bee' } }
 
-    it "properly signs the request" do
+    it 'properly signs the request' do
       expect { subject }.not_to raise_error
     end
   end
 
-  context "a nil request parameter" do
+  context 'a nil request parameter' do
     subject { client.list_accounts(params) }
     let(:params) { { name: nil } }
 
-    it "properly executes the request" do
+    it 'properly executes the request' do
       expect { subject }.not_to raise_error
     end
   end
 
-  context "a request parameter with and empty string", :regression do
+  context 'a request parameter with and empty string', :regression do
     subject { client.list_accounts(params) }
     let(:params) { { name: '' } }
 
-    it "properly executes the request" do
+    it 'properly executes the request' do
       expect { subject }.not_to raise_error
     end
   end
 
-  context "a request that triggers an error" do
+  context 'a request that triggers an error' do
     subject { client.list_accounts(domain_id: 666) }
 
     let(:message) { "Domain id=666 doesn't exist" }
-    it "properly signs the request" do
+    it 'properly signs the request' do
       expect { subject }.to raise_error StackerBee::ClientError, message
     end
   end
 
-  context "a request parameter with an Array", :regression do
+  context 'a request parameter with an Array', :regression do
     subject { client.list_hosts(params).first.keys }
     let(:params) { { page: 1, pagesize: 1, details: [:events, :stats] } }
-    it { should include "cpuused" }
-    it { should include "events" }
-    it { should_not include "cpuallocated" }
+    it { should include 'cpuused' }
+    it { should include 'events' }
+    it { should_not include 'cpuallocated' }
   end
 
-  context "a request parameter with a map" do
-    let(:zone_id) { client.list_zones.first["id"] }
-    let(:service_offering_id) { service_offerings.first["id"] }
+  context 'a request parameter with a map' do
+    let(:zone_id) { client.list_zones.first['id'] }
+    let(:service_offering_id) { service_offerings.first['id'] }
 
     let(:service_offerings) do
       client.list_network_offerings(
@@ -103,42 +103,42 @@ describe "A response to a request sent to the CloudStack API", :vcr do
     let(:network) do
       client.create_network(zone_id: zone_id,
                             network_offering_id: service_offering_id,
-                            name: "John", displaytext: "John")
+                            name: 'John', displaytext: 'John')
     end
 
     let(:tag) do
-      client.create_tags(resource_type: "Network",
-                         resource_ids: network["id"],
-                         tags: { "speed [lab]" => 'real fast!' })
+      client.create_tags(resource_type: 'Network',
+                         resource_ids: network['id'],
+                         tags: { 'speed [lab]' => 'real fast!' })
     end
 
-    it "can create an object" do
+    it 'can create an object' do
       tag.should_not be_nil
     end
   end
 
-  describe "middleware" do
+  describe 'middleware' do
     let(:middlewares) do
       lambda do |builder|
         builder.use middleware_class
       end
     end
 
-    context "a middleware that matches the content type" do
+    context 'a middleware that matches the content type' do
       let(:middleware_class) do
         Class.new(StackerBee::Middleware::Base) do
           def content_types
             /javascript/
           end
 
-          def after(env)
-            fail "Middleware Used"
+          def after(_env)
+            fail 'Middleware Used'
           end
         end
       end
 
-      it "uses the middleware" do
-        expect { client.list_accounts }.to raise_error "Middleware Used"
+      it 'uses the middleware' do
+        expect { client.list_accounts }.to raise_error 'Middleware Used'
       end
     end
 
@@ -149,13 +149,13 @@ describe "A response to a request sent to the CloudStack API", :vcr do
             /html/
           end
 
-          def after(env)
-            fail "Middleware Used"
+          def after(_env)
+            fail 'Middleware Used'
           end
         end
       end
 
-      it "uses the middleware" do
+      it 'uses the middleware' do
         expect { client.list_accounts }.not_to raise_error
       end
     end

data/spec/spec_helper.rb

@@ -5,12 +5,12 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
-require File.expand_path("../../lib/stacker_bee", __FILE__)
+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__)
+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.exist?(config_file)
@@ -18,7 +18,7 @@ CONFIG.merge!(YAML.load(File.read(config_file))) if File.exist?(config_file)
 require 'webmock/rspec'
 
 support_files = Dir[File.join(
-  File.expand_path("../../spec/support/**/*.rb", __FILE__)
+  File.expand_path('../../spec/support/**/*.rb', __FILE__)
 )]
 support_files.each { |f| require f }
 

data/spec/support/vcr.rb

@@ -5,20 +5,20 @@ VCR.configure do |c|
   c.cassette_library_dir = 'spec/cassettes'
 
   c.filter_sensitive_data('<CLOUD_STACK_URL>') do
-    CONFIG["url"]
+    CONFIG['url']
   end
 
   c.filter_sensitive_data('<CLOUD_STACK_HOST>') do
-    uri = URI.parse(CONFIG["url"])
+    uri = URI.parse(CONFIG['url'])
     "#{uri.scheme}://#{uri.host}:#{uri.port}"
   end
 
   c.filter_sensitive_data('<CLOUD_STACK_API_KEY>') do
-    CONFIG["api_key"]
+    CONFIG['api_key']
   end
 
   c.filter_sensitive_data('<CLOUD_STACK_SECRET_KEY>') do
-    CONFIG["secret_key"]
+    CONFIG['secret_key']
   end
 
   c.default_cassette_options = {

data/spec/units/stacker_bee/api_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe StackerBee::API do
   subject { api }
@@ -10,15 +10,15 @@ describe StackerBee::API do
 
   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 }
+  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" }
+  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

@@ -1,7 +1,7 @@
-require "spec_helper"
-require "ostruct"
+require 'spec_helper'
+require 'ostruct'
 
-describe StackerBee::Client, ".api" do
+describe StackerBee::Client, '.api' do
   subject { described_class }
   let(:api) { double }
   before do
@@ -12,10 +12,10 @@ describe StackerBee::Client, ".api" do
   its(:api) { should eq api }
 end
 
-describe StackerBee::Client, "calling endpoint" do
+describe StackerBee::Client, 'calling endpoint' do
   let(:client) do
     described_class.new(
-      url: "http://example.com",
+      url: 'http://example.com',
       middlewares: lambda do |builder|
         builder.before middleware_class,
                        expected_endpoint_name: endpoint_name,
@@ -44,28 +44,28 @@ describe StackerBee::Client, "calling endpoint" do
   let(:params)        { double(:params) }
   let(:response_body) { double(:response_body) }
 
-  describe "responding to methods" do
+  describe 'responding to methods' do
     subject { client }
     it { should respond_to endpoint_name }
   end
 
-  describe "via a method call" do
+  describe 'via a method call' do
     subject { client.list_virtual_machines(params) }
     it { should eq response_body }
   end
 
-  describe "via #request" do
+  describe 'via #request' do
     subject { client.request(endpoint_name, params) }
     it { should eq response_body }
   end
 end
 
-describe StackerBee::Client, "configuration" do
+describe StackerBee::Client, 'configuration' do
   before { described_class.configuration = default_config_hash }
 
-  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_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,
@@ -76,9 +76,9 @@ describe StackerBee::Client, "configuration" do
     }
   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_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,
@@ -89,10 +89,10 @@ describe StackerBee::Client, "configuration" do
     }
   end
 
-  describe ".new" do
+  describe '.new' do
     subject { client.configuration }
 
-    context "with default, class configuration" do
+    context 'with default, class configuration' do
       let(:client) { described_class.new }
 
       its(:url)        { should eq default_url }
@@ -100,7 +100,7 @@ describe StackerBee::Client, "configuration" do
       its(:secret_key) { should eq default_secret_key }
     end
 
-    context "with instance-specific configuration" do
+    context 'with instance-specific configuration' do
       let(:client) { described_class.new(instance_config_hash) }
 
       its(:url)        { should eq instance_url }
@@ -117,7 +117,7 @@ describe StackerBee::Client, "configuration" do
       its(:secret_key) { should eq instance_secret_key }
     end
 
-    context "with partial instance-specific configuration" do
+    context 'with partial instance-specific configuration' do
       let(:client) { described_class.new(partial_config_hash) }
       let(:partial_config_hash) do
         { url: instance_config_hash[:url] }

data/spec/units/stacker_bee/configuration_spec.rb

@@ -1,110 +1,110 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe StackerBee::Configuration do
   describe "setting an attribute that doesn't exist" do
     [:ssl_verify?, :url?, :other_attr].each do |attr|
-      it "raises an error" do
+      it 'raises an error' do
         expect { described_class.new(attr => true) }
           .to raise_error described_class::NoAttributeError, /#{attr}/
       end
     end
   end
 
-  describe "#ssl_verify?" do
+  describe '#ssl_verify?' do
     subject { configuration.ssl_verify? }
 
-    context "when not set" do
+    context 'when not set' do
       let(:configuration) { described_class.new }
       it { should eq true }
     end
 
-    context "when set to false" do
+    context 'when set to false' do
       let(:configuration) { described_class.new(ssl_verify: false) }
       it { should eq false }
     end
 
-    context "when set to true" do
+    context 'when set to true' do
       let(:configuration) { described_class.new(ssl_verify: true) }
       it { should eq true }
     end
   end
 
-  describe "#url" do
+  describe '#url' do
     subject { configuration.url }
 
-    context "when not set" do
+    context 'when not set' do
       let(:configuration) { described_class.new }
       it { should eq nil }
     end
 
-    context "when set" do
+    context 'when set' do
       let(:configuration) { described_class.new(url: setting) }
-      let(:setting) { "http://example.com" }
+      let(:setting) { 'http://example.com' }
       it { should eq setting }
     end
   end
 
-  describe "#secret_key" do
+  describe '#secret_key' do
     subject { configuration.secret_key }
 
-    context "when not set" do
+    context 'when not set' do
       let(:configuration) { described_class.new }
       it { should eq nil }
     end
 
-    context "when set" do
+    context 'when set' do
       let(:configuration) { described_class.new(secret_key: setting) }
-      let(:setting) { "qwertyuiop" }
+      let(:setting) { 'qwertyuiop' }
       it { should eq setting }
     end
   end
 
-  describe "#api_key" do
+  describe '#api_key' do
     subject { configuration.api_key }
 
-    context "when not set" do
+    context 'when not set' do
       let(:configuration) { described_class.new }
       it { should eq nil }
     end
 
-    context "when set" do
+    context 'when set' do
       let(:configuration) { described_class.new(api_key: setting) }
-      let(:setting) { "qwertyuiop" }
+      let(:setting) { 'qwertyuiop' }
       it { should eq setting }
     end
   end
 
-  describe "#middlewares" do
+  describe '#middlewares' do
     subject { configuration.middlewares }
 
-    context "when not set" do
+    context 'when not set' do
       let(:configuration) { described_class.new }
       it { should be_a Proc }
     end
 
-    context "when set" do
+    context 'when set' do
       let(:configuration) { described_class.new(middlewares: setting) }
       let(:setting) { proc { something } }
       it { should eq setting }
     end
   end
 
-  describe "#faraday_middlewares" do
+  describe '#faraday_middlewares' do
     subject { configuration.faraday_middlewares }
 
-    context "when not set" do
+    context 'when not set' do
       let(:configuration) { described_class.new }
       it { should be_a Proc }
     end
 
-    context "when set" do
+    context 'when set' do
       let(:configuration) { described_class.new(faraday_middlewares: setting) }
       let(:setting) { proc { something } }
       it { should eq setting }
     end
   end
 
-  describe "#merge" do
+  describe '#merge' do
     subject { parent.merge(child) }
 
     let(:parent) do
@@ -131,7 +131,7 @@ describe StackerBee::Configuration do
 
     context "when the child doesn't have an attribute set" do
       let(:child) { described_class.new }
-      it "uses the attribute of the parent" do
+      it 'uses the attribute of the parent' do
         subject.url.should eq :parent_url
         subject.api_key.should eq :parent_api_key
         subject.secret_key.should eq :parent_secret_key
@@ -143,7 +143,7 @@ describe StackerBee::Configuration do
 
     context "when the parent doesn't have an attribute set" do
       let(:parent) { described_class.new }
-      it "uses the attribute of the child" do
+      it 'uses the attribute of the child' do
         subject.url.should eq :child_url
         subject.api_key.should eq :child_api_key
         subject.secret_key.should eq :child_secret_key
@@ -156,7 +156,7 @@ describe StackerBee::Configuration do
     context "when the parent and child don't have an attribut set" do
       let(:child) { described_class.new }
       let(:parent) { described_class.new }
-      it "uses the defaults of the attributes of the child" do
+      it 'uses the defaults of the attributes of the child' do
         subject.url.should eq nil
         subject.api_key.should eq nil
         subject.secret_key.should eq nil

data/spec/units/stacker_bee/connection_spec.rb

@@ -1,12 +1,12 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe StackerBee::Connection do
   subject(:get) { connection.get(path, query_params) }
   before { Faraday.stub new: faraday }
 
-  let(:url)          { "http://test.com:1234/foo/bar/" }
-  let(:path)         { "/foo/bar" }
-  let(:secret_key)   { "shhh" }
+  let(:url)          { 'http://test.com:1234/foo/bar/' }
+  let(:path)         { '/foo/bar' }
+  let(:secret_key)   { 'shhh' }
   let(:query_params) { [[:foo, :bar]] }
   let(:response)     { double(:response) }
   let(:faraday)      { double(:faraday, get: response) }
@@ -20,47 +20,47 @@ describe StackerBee::Connection do
     )
   end
 
-  context "successfully connecting" do
+  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
+    it 'specifies url without path when creating connection' do
       get
-      Faraday.should have_received(:new).with(url: "http://test.com:1234",
+      Faraday.should have_received(:new).with(url: 'http://test.com:1234',
                                               ssl: { verify: true })
     end
   end
 
-  context "failing to connect" do
+  context 'failing to connect' do
     before do
-      faraday.stub(:get) { fail Faraday::Error::ConnectionFailed, "boom" }
+      faraday.stub(:get) { fail Faraday::Error::ConnectionFailed, 'boom' }
     end
-    it "raises a helpful exception" do
+    it 'raises a helpful exception' do
       expect { get }.to raise_error StackerBee::ConnectionError, /#{url}/
     end
   end
 
-  context "no protocol specified in URL" do
-    let(:url) { "wrong.com" }
-    it "raises a helpful exception" do
+  context 'no protocol specified in URL' do
+    let(:url) { 'wrong.com' }
+    it 'raises a helpful exception' do
       expect { get }.to raise_error StackerBee::ConnectionError, /no protocol/
     end
   end
 
-  context "when given a path" do
+  context 'when given a path' do
     let(:path) { '/baz' }
-    it "makes a request to the correct path" do
+    it 'makes a request to the correct path' do
       expect(faraday).to receive(:get).with(query_params, path)
       connection.get query_params, path
     end
   end
 
-  context "when verifying an ssl connection" do
+  context 'when verifying an ssl connection' do
     let(:ssl_verify) { false }
-    it "specifies the ssl verify option when creating a connection" do
+    it 'specifies the ssl verify option when creating a connection' do
       get
-      Faraday.should have_received(:new).with(url: "http://test.com:1234",
+      Faraday.should have_received(:new).with(url: 'http://test.com:1234',
                                               ssl: { verify: false })
     end
   end

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

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe StackerBee::Middleware::Adapter do
   let(:env) do
@@ -19,14 +19,14 @@ describe StackerBee::Middleware::Adapter do
   let(:raw_response) do
     double(env: { response_headers: response_headers }, body: response_body)
   end
-  let(:response_headers) { { "content-type" => content_type } }
-  let(:content_type) { "text/javascript; charset=UTF-8"  }
+  let(:response_headers) { { 'content-type' => content_type } }
+  let(:content_type) { 'text/javascript; charset=UTF-8'  }
   let(:response_body) { double }
 
-  describe "#call" do
+  describe '#call' do
     before { middleware.call(env) }
 
-    it "makes a call via the connection" do
+    it 'makes a call via the connection' do
       connection.should have_received(:get)
     end
 
@@ -42,12 +42,12 @@ describe StackerBee::Middleware::Adapter do
       env.response.body.should == response_body
     end
 
-    it "sorts the paramers" do
+    it 'sorts the paramers' do
       connection.should have_received(:get).with(path, [%w(a a), %w(z z)])
     end
   end
 
-  describe "#endpoint_name_for" do
+  describe '#endpoint_name_for' do
     subject { middleware.endpoint_name_for('listVirtualMachines') }
     it { should be_nil }
   end