RubyGems - stacker_bee - Versions diffs - 2.0.0 → 2.1.0.pre180 - Mend

stacker_bee 2.0.0 → 2.1.0.pre180

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (73) hide show

data/spec/integration/configure_middleware_spec.rb CHANGED Viewed

@@ -1,30 +1,68 @@
 require 'spec_helper'
-describe "Client initialization configures the middleware" do
+describe "Configuring middlewares" do
+  let(:configuration) do
+    {
+      url:                 "http://garbagestring",
+      api_key:             "HI!",
+      secret_key:          "SECRET",
+      faraday_middlewares: faraday_middlewares,
+      middlewares:         middlewares
+    }
+  end
-  context "pass a new middleware to the client" do
-    subject { StackerBee::Client.new(configuration) }
+  let(:faraday_middlewares) { proc {} }
+  let(:middlewares)         { proc {} }
-    let(:configuration) do
-      {
-        url:         "http://garbagestring",
-        api_key:     "HI!",
-        secret_key:  "SECRETT",
-        middlewares: ->(faraday) { faraday.use middleware_class }
-      }
-    end
+  let(:middleware_class) { Class.new(StackerBee::Middleware::Base, &body) }
+  let(:faraday_middleware_class) { Class.new(Faraday::Middleware, &body) }
-    let(:middleware_class) do
-      Class.new(Faraday::Middleware) do
-        def call(env)
-          fail "MiddlewareUsed"
-        end
+  let(:body) do
+    proc do
+      def call(env)
+        fail "MiddlewareUsed"
       end
     end
+  end
+  def self.it_uses_the_middleware
     it "uses the middle ware" do
       expect { subject.list_virtual_machines }
         .to raise_exception "MiddlewareUsed"
     end
   end
+  def self.it_configures_a_faraday_middleware
+    describe "a Faraday middleware" do
+      let(:faraday_middlewares) do
+        ->(faraday) { faraday.use faraday_middleware_class }
+      end
+      it_uses_the_middleware
+    end
+  end
+  def self.it_configures_a_middleware
+    describe "a StackerBee middleware" do
+      let(:middlewares) do
+        ->(builder) { builder.use middleware_class }
+      end
+      it_uses_the_middleware
+    end
+  end
+  describe "via StackerBee::Client.configuration=" do
+    subject { StackerBee::Client.new }
+    before  { StackerBee::Client.configuration = configuration }
+    it_configures_a_middleware
+    it_configures_a_faraday_middleware
+  end
+  describe "via the Client initializer" do
+    subject { StackerBee::Client.new(configuration) }
+    it_configures_a_middleware
+    it_configures_a_faraday_middleware
+  end
 end

data/spec/integration/console_spec.rb ADDED Viewed

@@ -0,0 +1,21 @@
+require "spec_helper"
+describe "A request sent to CloudStack for console access", :vcr do
+  let(:config_hash) do
+    {
+      url:        CONFIG['url'],
+      api_key:    CONFIG['api_key'],
+      secret_key: CONFIG['secret_key']
+    }
+  end
+  let(:client) { StackerBee::Client.new(config_hash) }
+  let(:vm) { "36f9c08b-f17a-4d0e-ac9b-d45ce2d34fcd" }
+  subject(:console_access) { client.console_access(vm: vm) }
+  it "returns html for console access" do
+    expect(console_access).to match %r{<html>.*<frame src=.*</html>}
+  end
+end

data/spec/integration/request_spec.rb CHANGED Viewed

@@ -8,9 +8,11 @@ describe "A response to a request sent to the CloudStack API", :vcr do
       url:        url,
       api_key:    CONFIG["api_key"],
       secret_key: CONFIG["secret_key"],
-      apis_path:  File.join(File.dirname(__FILE__), '../fixtures/4.2.json')
+      apis_path:  File.join(File.dirname(__FILE__), '../fixtures/4.2.json'),
+      middlewares: middlewares
     }
   end
+  let(:middlewares) { proc { } }
   let(:client) do
     StackerBee::Client.new(config_hash)
@@ -55,7 +57,7 @@ describe "A response to a request sent to the CloudStack API", :vcr do
     end
   end
-  context "a nil request parameter", :regression do
+  context "a nil request parameter" do
     let(:params) { { name: nil } }
     subject do
       client.list_accounts(params)
@@ -77,6 +79,15 @@ describe "A response to a request sent to the CloudStack API", :vcr do
     end
   end
+  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
+      expect { subject }.to raise_error StackerBee::ClientError, message
+    end
+  end
   context "a request parameter with an Array", :regression do
     let(:params) { { page: 1, pagesize: 1, details: [:events, :stats] } }
     subject do
@@ -112,4 +123,48 @@ describe "A response to a request sent to the CloudStack API", :vcr do
       tag.should_not be_nil
     end
   end
+  describe "middleware" do
+    let(:middlewares) do
+      lambda do |builder|
+        builder.use middleware_class
+      end
+    end
+    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"
+          end
+        end
+      end
+      it "uses the middleware" do
+        expect { client.list_accounts }.to raise_error "Middleware Used"
+      end
+    end
+    context "a middleware that doesn't match the content type" do
+      let(:middleware_class) do
+        Class.new(StackerBee::Middleware::Base) do
+          def content_types
+            /html/
+          end
+          def after(env)
+            fail "Middleware Used"
+          end
+        end
+      end
+      it "uses the middleware" do
+        expect { client.list_accounts }.not_to raise_error
+      end
+    end
+  end
 end

data/spec/spec_helper.rb CHANGED Viewed

@@ -37,16 +37,25 @@ require 'vcr'
 VCR.configure do |c|
   c.hook_into :webmock
-  c.cassette_library_dir     = 'spec/cassettes'
+  c.cassette_library_dir = 'spec/cassettes'
   c.filter_sensitive_data('<CLOUD_STACK_URL>') do
     CONFIG["url"]
   end
+  c.filter_sensitive_data('<CLOUD_STACK_HOST>') do
+    uri = URI.parse(CONFIG["url"])
+    "#{uri.scheme}://#{uri.host}:#{uri.port}"
+  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: [
@@ -54,5 +63,6 @@ VCR.configure do |c|
       VCR.request_matchers.uri_without_param(:signature)
     ]
   }
   c.configure_rspec_metadata!
 end

data/spec/units/faraday_graylog_middleware_spec.rb CHANGED Viewed

@@ -11,7 +11,7 @@ describe FaradayMiddleware::Graylog do
   let(:log_data) { logger.data }
   let(:logger)   { DummyLogger.new }
-  let(:dummy_adapter) { ->(env){ Faraday::Response.new(env) } }
+  let(:dummy_adapter) { ->(env) { Faraday::Response.new(env) } }
   let(:middleware) do
     described_class.new(dummy_adapter, logger, facility: facility)
   end

data/spec/units/stacker_bee/client_spec.rb CHANGED Viewed

@@ -13,96 +13,65 @@ describe StackerBee::Client, ".api" do
 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')
+  let(:client) do
+    StackerBee::Client.new(
+      url: "http://example.com",
+      middlewares: ->(builder) do
+        builder.before middleware_class,
+          expected_endpoint_name: endpoint_name,
+          expected_params:        params,
+          response_body:          response_body
+      end
+    )
   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
+  let(:middleware_class) do
+    Class.new StackerBee::Middleware::Base do
+      def call(env)
+        raise unless env.request.endpoint_name == expected_endpoint_name
+        raise unless env.request.params == expected_params
+        env.response.body = response_body
+      end
+      def endpoint_name_for(*)
+        true
+      end
     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
+  let(:endpoint_name) { :list_virtual_machines }
+  let(:params)        { double(:params) }
+  let(:response_body) { double(:response_body) }
-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
-    }
+  describe "responding to methods" do
+    subject { client }
+    it { should respond_to endpoint_name }
   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 }
+  describe "via a method call" do
+    subject { client.list_virtual_machines(params) }
+    it { should eq response_body }
   end
-  it { should eq response }
-  context "called with a differently-cased endpoint" do
-    subject { client.request("list_Virtual_mACHINES", params) }
-    it { should eq response }
+  describe "via #request" do
+    subject { client.request(endpoint_name, params) }
+    it { should eq response_body }
   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,
-      middlewares: ->(*) {}
+      url:                 default_url,
+      api_key:             default_api_key,
+      secret_key:          default_secret_key,
+      faraday_middlewares: proc {},
+      middlewares:         proc {}
     }
   end
   let!(:default_configuration) do
@@ -113,19 +82,19 @@ describe StackerBee::Client, "configuration" do
   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,
-      middlewares: ->(*) {}
+      url:                 instance_url,
+      api_key:             instance_api_key,
+      secret_key:          instance_secret_key,
+      faraday_middlewares: proc {},
+      middlewares:         proc {}
     }
   end
   let!(:instance_configuration) do
     StackerBee::Configuration.new(instance_config_hash)
   end
   before do
-    StackerBee::Configuration.stub(:new) do
-      fail "Unexpected Configuration instantiation"
+    StackerBee::Configuration.stub(:new) do |options|
+      fail "Unexpected Configuration instantiation: \n#{args.inspect}"
     end
     StackerBee::Configuration.stub(:new).with(default_config_hash)  do
       default_configuration

data/spec/units/stacker_bee/connection_spec.rb CHANGED Viewed

@@ -2,26 +2,30 @@ require "spec_helper"
 describe StackerBee::Connection do
   let(:url)           { "http://test.com:1234/foo/bar/" }
+  let(:path)          { "/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 }
+  let(:response)      { double(:response) }
+  let(:faraday)       { double(:faraday, get: response) }
+  let(:connection)    { StackerBee::Connection.new(configuration) }
+  let(:configuration) do
+    double(url: url, secret_key: secret_key, ssl_verify: nil)
+  end
+  subject(:get) { connection.get query_params, path }
   before do
     Faraday.stub(:new) { faraday }
   end
   context "successfully connecting" do
     before do
-      faraday.should_receive(:get).with('/foo/bar/', query_params) { response }
+      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")
+      get
+      Faraday.should have_received(:new).with(url: "http://test.com:1234",
+                                              ssl: { verify: true })
     end
   end
@@ -31,7 +35,7 @@ describe StackerBee::Connection do
     end
     it "should raise helpful exception" do
       klass = StackerBee::ConnectionError
-      expect(-> { subject }).to raise_error klass, /#{url}/
+      expect { get }.to raise_error klass, /#{url}/
     end
   end
@@ -39,7 +43,26 @@ describe StackerBee::Connection do
     let(:url) { "wrong.com" }
     it "should raise helpful exception" do
       klass = StackerBee::ConnectionError
-      expect(-> { subject }).to raise_error klass, /no protocol/
+      expect { get }.to raise_error klass, /no protocol/
+    end
+  end
+  context "when given a path" do
+    let(:path) { '/baz' }
+    it "makes a request to the correct path" do
+      expect(faraday).to receive(:get).with(path, query_params)
+      connection.get query_params, path
+    end
+  end
+  context "when verifying an ssl connection" do
+    let(:configuration) do
+      double url: url, secret_key: secret_key, ssl_verify: false
+    end
+    it "specifies the ssl verify option when creating a connection" do
+      get
+      Faraday.should have_received(:new).with(url: "http://test.com:1234",
+                                              ssl: { verify: false })
     end
   end
 end

data/spec/units/stacker_bee/console_spec.rb ADDED Viewed

File without changes

data/spec/units/stacker_bee/{graylog_faraday_middleware_spec.rb → http_middleware/graylog_spec.rb} RENAMED Viewed

@@ -1,6 +1,6 @@
 require 'spec_helper'
-describe StackerBee::GraylogFaradayMiddleware do
+describe StackerBee::HTTPMiddleware::Graylog do
   subject { log_data }
   class DummyLogger
@@ -11,7 +11,7 @@ describe StackerBee::GraylogFaradayMiddleware do
   let(:log_data) { logger.data }
   let(:logger)   { DummyLogger.new }
-  let(:dummy_adapter) { ->(env){ Faraday::Response.new(env) } }
+  let(:dummy_adapter) { ->(env) { Faraday::Response.new(env) } }
   let(:middleware) { described_class.new(dummy_adapter, logger) }
   let(:status) { 200 }
@@ -32,4 +32,20 @@ describe StackerBee::GraylogFaradayMiddleware do
   end
   its([:facility]) { should == "stacker-bee" }
+  context "without a command in the url" do
+    let(:env) do
+      {
+        body: "DATA",
+        response_headers: {},
+        response: {},
+        status: status,
+        url: URI.parse("http://a.b/?key=KEY&&val=val")
+      }
+    end
+    it "sets a custom short message" do
+      log_data[:short_message].should eq "StackerBee"
+    end
+  end
 end

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

@@ -0,0 +1,54 @@
+require "spec_helper"
+describe StackerBee::Middleware::Adapter do
+  let(:env) do
+    StackerBee::Middleware::Environment.new(
+      endpoint_name: 'listVirtualMachines',
+      params: params,
+      path: path
+    )
+  end
+  let(:app) { double(:app, call: response) }
+  let(:response) { double(:response) }
+  let(:path) { double(:path) }
+  let(:params) { { 'z' => 'z', 'a' => 'a' } }
+  let(:connection) { double(:connection, get: raw_response) }
+  let(:middleware) { described_class.new(app: app, connection: connection) }
+  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_body) { double }
+  describe "#call" do
+    before { middleware.call(env) }
+    it "makes a call via the connection" do
+      connection.should have_received(:get)
+    end
+    it "sets the environment's raw_response" do
+      env.raw_response.should == raw_response
+    end
+    it "sets the response's mime type" do
+      env.response.content_type.should == content_type
+    end
+    it "sets the response's body to the raw response's body" do
+      env.response.body.should == response_body
+    end
+    it "sorts the paramers" do
+      connection.should have_received(:get).with([["a", "a"], ["z", "z"]], path)
+    end
+  end
+  describe "#endpoint_name_for" do
+    subject { middleware.endpoint_name_for('listVirtualMachines') }
+    it { should be_nil }
+  end
+end