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

stacker_bee 2.0.0 → 2.1.0.pre180

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