stacker_bee 2.0.0 → 2.1.0.pre180

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

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe StackerBee::Middleware::Base do
+  let(:env) { StackerBee::Middleware::Environment.new(params: params) }
+  let(:params) { {} }
+  let(:app) { double(:app, call: response) }
+  let(:response) { double(:response) }
+  let(:content_type) { double }
+  before { env.response.content_type = content_type }
+
+  let(:middleware) { subclass.new(app: app) }
+
+  let(:subclass) { Class.new(StackerBee::Middleware::Base, &subclass_body) }
+  let(:subclass_body) { proc { } }
+
+  describe "#call" do
+    before do
+      middleware.call env
+    end
+
+    def self.it_calls_its_app_with_the_env
+      it "calls its app with the env" do
+        app.should have_received(:call).with(env)
+      end
+    end
+
+    it_calls_its_app_with_the_env
+
+    context "when overriding #before" do
+      let(:subclass_body) do
+        proc do
+          def before(env)
+            env.before_was_run = true
+          end
+        end
+      end
+
+      it_calls_its_app_with_the_env
+
+      it "runs the before hook" do
+        env.before_was_run.should be_true
+      end
+    end
+
+    context "when overriding #after" do
+      let(:subclass_body) do
+        proc do
+          def after(env)
+            env.after_was_run = true
+          end
+        end
+      end
+
+      it_calls_its_app_with_the_env
+
+      it "runs the after hook" do
+        env.after_was_run.should be_true
+      end
+    end
+
+    context "when overriding #content_types" do
+      let(:subclass_body) do
+        proc do
+          def after(env)
+            env.after_was_run = true
+          end
+
+          def content_types
+            /html/
+          end
+        end
+      end
+
+      it_calls_its_app_with_the_env
+
+      context "when it matches the content type" do
+        let(:content_type) { 'text/html; uft-8' }
+        it "runs the after hook" do
+          env.after_was_run.should be_true
+        end
+      end
+
+      context "when it doesn't match the content type" do
+        let(:content_type) { 'text/javascript; uft-8' }
+        it "runs the after hook" do
+          env.after_was_run.should be_nil
+        end
+      end
+    end
+
+    context "when overriding #params" do
+      let(:subclass_body) do
+        proc do
+          def params(params)
+            params.merge(params_merged?: true)
+          end
+        end
+      end
+
+      it "changes the params" do
+        env.request.params[:params_merged?].should be_true
+      end
+    end
+  end
+
+  describe "#endpoint_name_for" do
+    let(:endpoint_name) { double }
+    let(:normalized_endpoint_name) { double }
+
+    it "delegates to its app" do
+      app.should_receive(:endpoint_name_for)
+        .with(endpoint_name)
+        .and_return(normalized_endpoint_name)
+
+      middleware.endpoint_name_for(endpoint_name)
+        .should == normalized_endpoint_name
+    end
+  end
+
+  describe "#matches_content_type?" do
+    describe "by default" do
+      before { env.response.content_type = '$8^02(324' }
+      it "matches anything" do
+        middleware.matches_content_type?(env).should be_true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe StackerBee::Middleware::CloudStackAPI do
+  let(:env) do
+    StackerBee::Middleware::Environment.new(
+      endpoint_name: 'endpoint-name',
+      path: path
+    )
+  end
+
+  let(:middleware) { described_class.new(api_key: "API-KEY", params: {}) }
+  let(:path) { nil }
+
+  before { middleware.before(env) }
+
+  describe "request" do
+    subject { env.request }
+
+    context "when the path is not set" do
+      let(:path) { nil }
+      its(:path) { should == described_class::DEFAULT_PATH }
+    end
+
+    context "when the path is already set" do
+      let(:path) { "already set"  }
+      its(:path) { should == path }
+    end
+  end
+
+  describe "params" do
+    subject { env.request.params }
+    its([:api_key])  { should eq "API-KEY" }
+    its([:response]) { should eq "json" }
+    its([:command])  { should eq "endpoint-name" }
+  end
+end
+

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

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe StackerBee::Middleware::ConsoleAccess do
+  let(:env) do
+    StackerBee::Middleware::Environment.new(endpoint_name: endpoint_name)
+  end
+
+  let(:middleware) { described_class.new(app: app) }
+  let(:app) { double(:app) }
+
+  context "when it matches the endpoint" do
+    let(:endpoint_name) { described_class::ENDPOINT }
+
+    it "adds its path to the env" do
+      middleware.before(env)
+      env.request.path.should == described_class::PATH
+    end
+
+    it "adds cmd to the parameters" do
+      env.request.params.should_not include described_class::PARAMS
+    end
+  end
+
+  context "when it doesn't match the endpoint" do
+    let(:endpoint_name) { :other_endpoint }
+
+    before { middleware.before(env) }
+
+    it "doesn't add it's path" do
+      env.request.path.should_not == described_class::PATH
+    end
+
+    it "doesn't add cmd to the parameters" do
+      env.request.params.should_not include described_class::PARAMS
+    end
+  end
+
+  it "matches html content typtes" do
+    middleware.content_types.should =~ "text/html; charset=utf-8"
+  end
+
+  describe "#endpoint_name_for" do
+    context "given names it reponds to" do
+      %w[consoleAccess console_access CONSOLEACCESS].each do |name|
+        it "returns consoleAccess for '#{name}'" do
+          middleware.endpoint_name_for(name).should == described_class::ENDPOINT
+        end
+      end
+    end
+
+    context "for other names" do
+      before { app.stub :endpoint_name_for, &:upcase }
+
+      it "delegates for other names" do
+        middleware.endpoint_name_for('other-name').should == 'OTHER-NAME'
+      end
+    end
+  end
+end

data/spec/units/stacker_bee/{dictionary_flattener_spec.rb → middleware/dictionary_flattener_spec.rb}

@@ -1,24 +1,24 @@
 require 'spec_helper'
 
-describe StackerBee::DictionaryFlattener do
-  let(:lb)               { StackerBee::DictionaryFlattener::LB }
-  let(:rb)               { StackerBee::DictionaryFlattener::RB }
+describe StackerBee::Middleware::DictionaryFlattener do
+  let(:lb)               { described_class::LB }
+  let(:rb)               { described_class::RB }
   let(:string)           { "cool[0].name%21" }
   let(:tokenized_string) { "cool#{lb}0#{rb}.name%21" }
 
   describe ".detokenize" do
-    subject { StackerBee::DictionaryFlattener.detokenize(tokenized_string) }
+    subject { described_class.detokenize(tokenized_string) }
     it { should eq string  }
   end
 
   describe ".tokenize" do
-    subject { StackerBee::DictionaryFlattener.tokenize(string) }
+    subject { described_class.tokenize(string) }
     it { should eq tokenized_string  }
   end
 
   describe ".new" do
     def prefix(number)
-      StackerBee::DictionaryFlattener.tokenize "rebels[#{number}]"
+      described_class.tokenize "rebels[#{number}]"
     end
 
     let(:params) do
@@ -27,7 +27,7 @@ describe StackerBee::DictionaryFlattener do
     end
 
     subject do
-      StackerBee::DictionaryFlattener.new(params).params
+      described_class.new.params(params)
     end
 
     it "flattens objects in the manner that cloudstack expects" do

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe StackerBee::Middleware::EndpointNormalizer do
+  let(:middleware) { described_class.new(app: app, api: api) }
+  let(:app) { double(:app) }
+
+  let(:env) do
+    StackerBee::Middleware::Environment.new(
+      endpoint_name: endpoint_name
+    )
+  end
+
+  context "when it doesn't match" do
+    let(:api) { {} }
+    let(:endpoint_name) { :some_endpoint }
+
+    describe "#endpoint_name_for" do
+      before { app.stub :endpoint_name_for, &:upcase }
+
+      it "delegates to its app" do
+        middleware.endpoint_name_for('some-name').should == 'SOME-NAME'
+      end
+    end
+
+    describe "#before" do
+      before { app.stub endpoint_name_for: nil }
+
+      it "doesn't set the endpoint to nil", :regression do
+        middleware.before env
+        env.request.endpoint_name.should == endpoint_name
+      end
+    end
+  end
+
+  context "when it matches an endpoint"
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe StackerBee::Middleware::FormatKeys do
+  subject { described_class.new.params(params) }
+
+  let(:params) do
+    {
+      symbol:   true,
+      key_case: true
+    }
+  end
+
+  it { should     have_key "symbol" }
+  it { should_not have_key :symbol  }
+
+  it { should     have_key "keyCase" }
+  it { should_not have_key :key_case }
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe StackerBee::Middleware::FormatValues do
+  subject { described_class.new.params(params) }
+
+  let(:params) do
+    {
+      single: 1,
+      list:  [1,2,3]
+    }
+  end
+
+  its([:single]) { should eq "1" }
+  its([:list])   { should eq "1,2,3" }
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe StackerBee::Middleware::HTTPStatus do
+  subject { env.response }
+  before { middleware.after(env) }
+
+  let(:middleware) { described_class.new }
+  let(:env) do
+    StackerBee::Middleware::Environment.new.tap do |env|
+      env.raw_response = double(status: http_status, success?: success?)
+      env.response.body = body
+    end
+  end
+  let(:body) { { errorcode: http_status, errortext: message } }
+  let(:message) { "Unable to execute API command deployvirtualmachine " }
+
+  context "given an error" do
+    let(:http_status) { 431 }
+    let(:success?) { false }
+
+    its(:status) { should eq http_status }
+    its(:error) { should eq message }
+    it { should_not be_success }
+  end
+
+  context "given a success" do
+    let(:http_status) { 200 }
+    let(:success?) { true }
+
+    its(:status) { should eq http_status }
+    its(:error) { should be_nil }
+    it { should be_success }
+  end
+end

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

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe StackerBee::Middleware::RaiseOnHTTPError do
+  pending
+end

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

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+# TODO: does this really need to work with nested hashes?
+describe StackerBee::Middleware::RemoveEmptyStrings do
+  let(:middleware) do
+    described_class.new(app: proc { |env| @response_env = env })
+  end
+  let(:env) { StackerBee::Middleware::Environment.new }
+  # TODO: rename response_env
+  let(:response_env) { @response_env }
+  let(:params) { response_env.request.params }
+
+  before do
+    env.request.params = {
+      blank: '',
+      ok1: true,
+      ok2: nil,
+      ok3: 'string',
+      ok4: ' ',
+
+      nested: {
+        blank: '',
+        ok1: true,
+        ok2: nil,
+        ok3: 'string',
+        ok4: ' ',
+
+        nested: {
+          blank: '',
+          ok1: true,
+          ok2: nil,
+          ok3: 'string',
+          ok4: ' '
+        }
+      }
+    }
+  end
+
+  before do
+    middleware.call(env)
+  end
+
+  it "removes empty strings from the input" do
+    params.keys.should =~ [:ok1, :ok2, :ok3, :ok4, :nested]
+  end
+
+  it "removes empty strings nested in hashes" do
+    params[:nested].keys.should =~ [:ok1, :ok2, :ok3, :ok4, :nested]
+  end
+
+  it "removes empty strings deeply nested in hashes" do
+    params[:nested][:nested].keys.should =~ [:ok1, :ok2, :ok3, :ok4]
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe StackerBee::Middleware::RemoveNils do
+  it "removes pairs with nil values from the params" do
+    subject.params(something: 'something', nothing: nil)
+      .should eq something: 'something'
+  end
+end

data/spec/units/stacker_bee/request_error_spec.rb

@@ -1,44 +1,32 @@
 require "spec_helper"
 
-describe StackerBee::RequestError, ".for" do
-  let(:raw_response) { double status: status, body: '{"foo": "bar"}' }
-  subject { StackerBee::RequestError.for raw_response }
+describe "An error occuring" do
+  let(:env)      { double response: response }
+  let(:response) { double status: status, error: error_text }
+  let(:error_text) { "There was an error!" }
+  let(:status)   { 431 }
 
-  context "HTTP status in the 400s" do
-    let(:status) { 431 }
-    it { should be_a StackerBee::ClientError }
-  end
-  context "HTTP status in the 500s" do
-    let(:status) { 500 }
-    it { should be_a StackerBee::ServerError }
-  end
-  context "HTTP status > 599" do
-    let(:status) { 999 }
-    it { should be_a StackerBee::RequestError }
-  end
-end
+  describe StackerBee::RequestError, ".for" do
+    subject { StackerBee::RequestError.for env }
 
-describe StackerBee::RequestError do
-  let(:http_status) { 431 }
-  let(:message) do
-    "Unable to execute API command deployvirtualmachine " +
-    "due to missing parameter zoneid"
+    context "HTTP status in the 400s" do
+      let(:status) { 431 }
+      it { should be_a StackerBee::ClientError }
+    end
+    context "HTTP status in the 500s" do
+      let(:status) { 500 }
+      it { should be_a StackerBee::ServerError }
+    end
+    context "HTTP status > 599" do
+      let(:status) { 999 }
+      it { should be_a StackerBee::RequestError }
+    end
   end
-  let(:raw_body) do
-    <<-EOS
-    {
-      "deployvirtualmachineresponse": {
-        "uuidList":    [],
-        "errorcode":   #{http_status},
-        "cserrorcode": 9999,
-        "errortext":   "#{message}"
-      }
-    }
-    EOS
+
+  describe StackerBee::RequestError do
+    subject {  StackerBee::ClientError.new(env) }
+
+    its(:status) { should eq status }
+    its(:to_s) { should eq error_text }
   end
-  let(:raw_response) { double body: raw_body, :success? => false, status: 431 }
-  let(:client_error) { StackerBee::ClientError.new raw_response }
-  subject { client_error }
-  its(:status) { should eq http_status }
-  its(:to_s) { should eq message }
 end

data/spec/units/stacker_bee/utilities_spec.rb

@@ -24,4 +24,30 @@ describe StackerBee::Utilities, "#uncase" do
   it { camel_case("fooBar", true).should eq "fooBar" }
   it { camel_case("fooBar", false).should eq "FooBar" }
   it { camel_case("foo[0].Bar", false).should eq "Foo[0].Bar" }
+
+  describe "#map_a_hash" do
+    let(:original) { { 1 =>  1, 2 =>  2 } }
+    let(:expected) { { 2 => -1, 4 => -2 } }
+
+    let(:transformed) do
+      map_a_hash(original) { |key, value| [key * 2, value * -1] }
+    end
+
+    it "should map over a hash" do
+      transformed.should eq expected
+    end
+
+    it "should not modify the original" do
+      original.freeze
+      transformed
+    end
+  end
+
+  describe ".transform_hash_keys" do
+    it { transform_hash_keys({ 1 => 2 }, &:odd?).should eq true => 2 }
+  end
+
+  describe ".transform_hash_values" do
+    it { transform_hash_values({ 1 => 2 }, &:odd?).should eq 1 => false }
+  end
 end

data/stacker_bee.gemspec

@@ -19,10 +19,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "faraday",            "~> 0.8"
+  spec.add_runtime_dependency "faraday",            "~> 0.8", "< 0.9"
+  spec.add_runtime_dependency 'multi_json',         "~> 1.8"
+
   # this is a dependency for FaradayMiddleware::Graylog
   spec.add_runtime_dependency "faraday_middleware", "~> 0.9"
-  spec.add_runtime_dependency 'multi_json',         "~> 1.8"
 
   spec.add_development_dependency "bundler",  "~> 1.3"
   spec.add_development_dependency "rake",     "~> 10.0"
@@ -31,4 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "vcr",      "~> 2.6"
   spec.add_development_dependency "rubocop"
   spec.add_development_dependency "pry"
+
+  # Release every merge to master as a prerelease
+  spec.version = "#{spec.version}.pre#{ENV['TRAVIS_BUILD_NUMBER']}" if ENV['TRAVIS']
 end