stacker_bee 2.0.0 → 2.1.0.pre180

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

@@ -1,55 +0,0 @@
-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

data/spec/units/stacker_bee/request_spec.rb

@@ -1,51 +0,0 @@
-require "spec_helper"
-
-describe StackerBee::Request do
-  let(:endpoint)  { "listStuff" }
-  let(:api_key)   { "this_guy" }
-  let(:params) do
-    {
-      list:     :all,
-      nothing:  nil,
-      deets:    [:things, :stuff],
-      settings: { cookiename: "Fred", something: "cool" },
-      blank:    ''
-    }
-  end
-
-  let(:request)   { StackerBee::Request.new endpoint, api_key, params }
-  subject { request }
-
-  describe "#query_params" do
-    let(:new_params) { params.merge("settings[1].name" => "cool") }
-    let(:flattener)  { double(new: double(params: new_params)) }
-
-    before do
-      stub_const "StackerBee::DictionaryFlattener", flattener
-    end
-
-    subject { request.query_params }
-
-    it { should include ["settings[1].name", "cool"] }
-    it { should include ["list", :all] }
-    it { should include %W(apiKey #{api_key}) }
-    it { should include %w(command listStuff) }
-    it { should include %w(response json) }
-    it { should include %w(deets things,stuff) }
-
-    it "removes params with nil values" do
-      subject.map(&:first).should_not include "nothing"
-    end
-
-    it "removes params with blank values" do
-      subject.map(&:first).should_not include "blank"
-    end
-
-    context "allowing blank strings" do
-      before do
-        request.allow_empty_string_params = true
-      end
-      it { should include ['blank', ''] }
-    end
-  end
-end

data/spec/units/stacker_bee/response_spec.rb

@@ -1,79 +0,0 @@
-require "spec_helper"
-
-describe StackerBee::Response do
-  let(:raw_body)          { '{ "json": "here" }' }
-  let(:raw_response)  { double body: raw_body, :success? => true }
-  let(:response)      { StackerBee::Response.new raw_response }
-  subject { response }
-  its(:body) { should == 'here' }
-
-  context "raw response for list endpoint" do
-    let(:raw_body) do
-      '{ "listvirtualmachinesresponse":
-        { "count": 1, "virtualmachine": [{"ohai": "there"}] }
-      }'
-    end
-    its(:body) { should == [{ "ohai" => "there" }] }
-
-    context "first item" do
-      subject { response.first }
-      it { should == { "ohai" => "there" } }
-      its(["o_hai"]) { should == "there" }
-    end
-  end
-
-  context "raw response for list endpoint with no records" do
-    let(:raw_body) { '{ "listvirtualmachinesresponse": {} }' }
-    its(:body) { should == {} }
-  end
-
-  context "raw response for async endpoint" do
-    let(:raw_body) do
-      '{ "deployvirtualmachineresponse": { "id": 123, "jobid": 321 } }'
-    end
-    its(:body) { should == { "id" => 123, "jobid" => 321 } }
-  end
-
-  context "raw response for create endpoint" do
-    let(:raw_body) { '{ "register_ssh_keypair": { "fingerprint": 456 } }' }
-    its(:body) { should == { "fingerprint" => 456 } }
-  end
-
-  context "for failed request" do
-    let(:raw_response) do
-      double(
-        :body     => '{ "foo": "bar" }',
-        :success? => false,
-        :status   => 431
-      )
-    end
-    it { expect { subject }.to raise_exception StackerBee::ClientError }
-  end
-
-  context "for response with single key that's an object" do
-    let(:raw_body) { '{ "getuserresponse": { "user": { "id": 1 } } }' }
-    its(:body) { should == { "id" => 1 } }
-  end
-
-  context "for request with invalid credentials" do
-    let(:raw_response) do
-      double(
-        body: %[
-          { "createprojectresponse" :
-            {"uuidList":[],"errorcode":401,"errortext":"#{message}"} } ],
-        success?: false,
-        status: 401
-      )
-    end
-    let(:client_error) { StackerBee::AuthenticationError.new raw_response }
-    let(:message) do
-      "unable to verify user credentials and/or request signature"
-    end
-    it "raises an AuthenticationError" do
-      expect { subject }.to raise_exception(
-        StackerBee::AuthenticationError, message
-      )
-    end
-  end
-
-end