axel 0.0.1

data/spec/lib/axel/controller_base_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+# So we don't have to add rails-api as a dependency
+ActionController::API = ActionController::Base
+module Axel
+  describe ControllerBase do
+    its(:configured) { should == ::ActionController::Base }
+    context "configured to use rails api" do
+      before do
+        subject.send(:config).stub uses_rails_api?: true
+      end
+
+      its(:configured) { should == ActionController::API }
+    end
+  end
+end

data/spec/lib/axel/controller_parameters_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module Axel
+  describe ControllerParameters do
+    subject { ControllerParameters.new original_params }
+    let(:original_params) { {} }
+    let(:params_class) { double }
+    it { should respond_to :params_object }
+
+    describe "with strong params defined" do
+      before do
+        subject.stub strong_params?: true, params_class: params_class
+      end
+
+      it "creates strong params" do
+        params_class.should_receive(:new).with(original_params).once
+        subject.params_object
+      end
+    end
+
+    describe "without strong params defined" do
+      before do
+        subject.stub strong_params?: false
+      end
+
+      it "returns the original object" do
+        subject.params_object.should be original_params
+      end
+    end
+  end
+end

data/spec/lib/axel/inspector_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Axel
+  describe Inspector do
+    subject { Inspector.new object, parens, attributes }
+    let(:object) { double(id: 1, name: "Jon", request_uri: "http://some-url/users/1") }
+    let(:parens) { [:request_uri] }
+    let(:attributes) { { id: 1, name: "Jon" } }
+
+    its(:object) { should == object }
+    it "retrieves parens_params keys" do
+      subject.parens_params.keys.should == parens
+    end
+    its(:attributes) { should == attributes }
+
+    describe "with parens and attributes set" do
+      its(:inspect) { should == "#<RSpec::Mocks::Double(\"http://some-url/users/1\") id: 1, name: \"Jon\">" }
+    end
+
+    describe "with an erroring parens attribute" do
+      before { object.stub(:request_uri) { raise "No good" } }
+      its(:inspect) { should == "#<RSpec::Mocks::Double(nil) id: 1, name: \"Jon\">" }
+    end
+
+    describe "without parens" do
+      let(:parens) { nil }
+      its(:inspect) { should == "#<RSpec::Mocks::Double id: 1, name: \"Jon\">" }
+    end
+
+    describe "without attributes" do
+      let(:attributes) { nil }
+      its(:inspect) { should == "#<RSpec::Mocks::Double(\"http://some-url/users/1\")>" }
+    end
+
+    describe "with a class" do
+      before do
+        subject.stub class?: true
+      end
+
+      let(:object) { double request_uri: "http://example_uri/users", name: "MyClass" }
+      let(:parens) { [:request_uri] }
+      let(:attributes) { nil }
+      its(:inspect) { should == "MyClass(\"http://example_uri/users\")" }
+    end
+  end
+end

data/spec/lib/axel/request_options_spec.rb

@@ -0,0 +1,50 @@
+require 'axel/request_options'
+module Axel
+  describe RequestOptions do
+    subject { RequestOptions.new nil, example_options }
+    let(:example_options) { {} }
+
+    it "compiles with the default headers" do
+      subject.compiled.should == {
+        'headers' => {
+          'Content-Type' => 'application/json'
+        },
+      }
+    end
+
+    describe "non-conflicting params" do
+      let(:example_options) { { params: { id: 1 } } }
+      it "compiles with the non-conflicting params" do
+        subject.compiled.should == {
+          'params' => { 'id' => 1 },
+          'headers' => {
+            'Content-Type' => 'application/json'
+          },
+        }
+      end
+    end
+
+    describe "slightly-conflicting params" do
+      let(:example_options) { { headers: { id: 1 } } }
+      it "compiles with the non-conflicting params" do
+        subject.compiled.should == {
+          'headers' => {
+            'id' => 1,
+            'Content-Type' => 'application/json'
+          },
+        }
+      end
+    end
+
+    describe "truly-conflicting params" do
+      let(:example_options) { { headers: { "Content-Type" => 1 } } }
+      it "compiles with the non-conflicting params" do
+        subject.compiled.should == {
+          'headers' => {
+            'Content-Type' => 1
+          },
+        }
+      end
+    end
+  end
+end

data/spec/lib/axel/uri_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+module Axel
+  describe "Uri" do
+    subject { Uri.new base_url }
+    let(:base_url) { "http://user-service.stage.com/users" }
+
+    before do
+      subject.stub config: {
+        dev: {
+          host: ".dev",
+          scheme: "http"
+        },
+        stage: {
+          host: ->(base, n) { "#{base}.stage#{n}.com" },
+          scheme: "https"
+        },
+        prod: {
+          host: ".your-platform.com",
+          scheme: "https"
+        }
+      }
+    end
+    it "to dev switches out the stage URI for .dev" do
+      subject.to(:dev).to_s.should == "http://user-service.dev/users"
+    end
+
+    it "for stage" do
+      subject.to(:stage).to_s.should == "https://user-service.stage.com/users"
+    end
+
+    it "for stage n" do
+      subject.to(:stage, 2).to_s.should == "https://user-service.stage2.com/users"
+    end
+
+    it "for prod" do
+      subject.to(:prod).to_s.should == "https://user-service.your-platform.com/users"
+    end
+
+    its(:dashed_app_name) { should == "user-service" }
+    its(:app_name) { should == "User Service" }
+  end
+end

data/spec/lib/axel_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+describe Axel do
+  subject { Axel }
+
+  context "services" do
+    it { subject.service_configurator.should be_a Axel::Configurators::Services }
+  end
+
+  context "config" do
+    context "with stubs" do
+      context "block checks" do
+        context "with block" do
+          specify do
+            expect { |b| subject.config &b }.to yield_with_args
+          end
+        end
+      end
+    end
+
+    context "once" do
+      before do
+        subject.config do |config|
+          config.add_resource :user_service, :user, service: { url: "http://user-service.dev" }
+        end
+      end
+
+      it "sets a user service with a configuration" do
+        subject.services[:user_service].should be_a Axel::Configurations::Service
+      end
+
+      it "sets a resource configuration" do
+        subject.resources[:user].should be_a Axel::Configurations::Resource
+      end
+
+      context "twice" do
+        before do
+          subject.config do |config|
+            config.add_resource :api_proxy, :registry, service: { url: "http://api-proxy.dev" }
+            config.add_resource :user_service, :persona
+          end
+        end
+        it "sets a user service with a configuration" do
+          subject.services[:user_service].should be_a Axel::Configurations::Service
+        end
+
+        it "sets a user resource configuration" do
+          subject.resources[:user].should be_a Axel::Configurations::Resource
+        end
+
+        it "sets a persona resource configuration" do
+          subject.resources[:persona].should be_a Axel::Configurations::Resource
+        end
+
+        it "sets a api proxy service with a configuration" do
+          subject.services[:api_proxy].should be_a Axel::Configurations::Service
+        end
+
+        it "sets a pers resource configuration" do
+          subject.resources[:registry].should be_a Axel::Configurations::Resource
+        end
+      end
+    end
+  end
+end

data/spec/models/axel/api_proxy_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module Axel
+  describe ApiProxy do
+    context "the class" do
+      subject { ApiProxy }
+
+      its(:cache_file) { should be_a Pathname }
+      its(:cache_dir) { should be_a Pathname }
+
+      context "invalid json" do
+        let(:json) { "not_json" }
+        it "can't parse, toss back hash as we expect" do
+          subject.build(nil, double(success?: true, body: json)).should == {}
+        end
+      end
+    end
+
+    context "the instance" do
+      subject { ApiProxy.new endpoint }
+      let(:endpoint) { "http://api.not-existant" }
+
+      context "get new data" do
+        let(:new_data) { "{\"routes\":[{\"service\":\"https://user-service.stage.com\",\"path\":\"/personas\",\"matcher\":\"^/personas(\\\\/[\\\\w]+)*\\\\/?(\\\\.\\\\w+)?(\\\\?.*)?$\"},{\"service\":\"https://cms-service.stage.com\",\"path\":\"/mobile_products\",\"matcher\":\"^/mobile_products(\\\\/[\\\\w]+)*\\\\/?(\\\\.\\\\w+)?(\\\\?.*)?$\"}]}" }
+
+        before do
+          loaded = MultiJson.load new_data
+          subject.class.stub request: loaded
+          subject.stub write_cache: loaded["routes"]
+        end
+
+        it "configs the resources" do
+          Axel.send(:_config).should_receive(:add_resource).with(
+            "user_service",
+            "personas",
+            service: { url: "https://user-service.stage.com" }).once
+          Axel.send(:_config).should_receive(:add_resource).with(
+            "cms_service",
+            "mobile_products",
+            service: { url: "https://cms-service.stage.com" }).once
+          subject.register!
+        end
+      end
+
+      context "get old data" do
+        let(:cached_data) { [{"service"=>"https://user-service.stage.com", "path"=>"/personas", "matcher"=>"^/personas(\\/[\\w]+)*\\/?(\\.\\w+)?(\\?.*)?$"}, {"service"=>"https://cms-service.stage.com", "path"=>"/mobile_products", "matcher"=>"^/mobile_products(\\/[\\w]+)*\\/?(\\.\\w+)?(\\?.*)?$"}] }
+
+        before do
+          subject.stub read_cache: cached_data
+        end
+
+        it "configs the resources" do
+          Axel.send(:_config).should_receive(:add_resource).with(
+            "user_service",
+            "personas",
+            service: { url: "https://user-service.stage.com" }).once
+          Axel.send(:_config).should_receive(:add_resource).with(
+            "cms_service",
+            "mobile_products",
+            service: { url: "https://cms-service.stage.com" }).once
+          subject.register!
+        end
+      end
+    end
+  end
+end

data/spec/models/axel/payload/errors_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+module Axel
+  module Payload
+    describe Errors do
+      subject { Errors.new params }
+      let(:params) { {} }
+
+      its(:messages) { should == [] }
+      its(:status) { should == 200 }
+
+      context "http created code" do
+        let(:params) { { status: 201 } }
+        it "should be success" do
+          subject.success?.should be_truthy
+          subject.display?.should be_falsey
+        end
+      end
+
+      context "http accepted code" do
+        let(:params) { { status: 202 } }
+        it "should be success" do
+          subject.success?.should be_truthy
+          subject.display?.should be_falsey
+        end
+      end
+
+      context "http no content code" do
+        let(:params) { { status: 204 } }
+        it "should be success" do
+          subject.success?.should be_truthy
+          subject.display?.should be_falsey
+        end
+      end
+
+      context "exception" do
+        let(:params) { { status: 404, messages: ["Fail!"] } }
+        it "sets exception" do
+          subject.exception.should be_a RemoteError
+          subject.exception.to_s.should == "Failed. HTTP Status: 404, Messages: Fail!"
+        end
+      end
+
+      context "reset!" do
+        let(:params) { { status: 404, messages: ["Fail!"] } }
+
+        it "sets params, resets, clear object" do
+          subject.status_code.should == 404
+          subject.messages.should == ["Fail!"]
+          subject.reset!
+          subject.status_code.should == 200
+          subject.messages.should == []
+        end
+      end
+
+      describe "header status" do
+        its(:header_status) { should == 200 }
+        context "non-200 status" do
+          before do
+            subject.status = :unprocessable_entity
+          end
+
+          its(:header_status) { should == 422 }
+
+          context "suppressed" do
+            let(:params) { { suppress_response_codes: 1 } }
+            its(:header_status) { should == 200 }
+          end
+        end
+      end
+
+      describe "drops" do
+        let(:params) { { messages: ["no good"], status: 404 } }
+
+        context "with a drop" do
+          it "changes the boolean and drops the message" do
+            subject.drop?.should be_falsey
+            subject.drop!
+            subject.drop?.should be_truthy
+            subject.display.should == {}
+          end
+        end
+
+        context "without a drop" do
+          its(:display) { should == { status: 404, messages: ["no good"] } }
+        end
+      end
+
+      describe "<<" do
+        it "adds to the error list" do
+          expect { subject << "There was an error" }.to change { subject.messages }.from([]).to(["There was an error"])
+        end
+      end
+
+      describe "display" do
+        its(:display) { should == { status: 200, messages: [] } }
+
+        context "with some errors and status" do
+          before do
+            subject << "ERROR"
+            subject.status = :unprocessable_entity
+          end
+
+          its(:display) { should == { status: 422, messages: ["ERROR"] } }
+        end
+      end
+
+      describe "display?" do
+        its(:display?) { should == false }
+
+        context "with a non 200 status" do
+          before do
+            subject.status = 403
+          end
+          its(:display?) { should == true }
+        end
+
+        context "with an error message" do
+          before do
+            subject << "ERROR"
+          end
+          its(:display?) { should == true }
+        end
+      end
+
+      describe "new_error" do
+        context "non-200 status, one message" do
+          before do
+            subject.new_error 404, "ERROR"
+          end
+          its(:display) { should == { status: 404, messages: ["ERROR"] } }
+        end
+
+        context "non-200 status, multiple messages" do
+          before do
+            subject.new_error :not_found, "ERROR", "ERROR 2"
+          end
+          its(:display) { should == { status: 404, messages: ["ERROR", "ERROR 2"] } }
+        end
+
+        context "200 status, multiple messages" do
+          before do
+            subject.new_error nil, "ERROR"
+          end
+          its(:display) { should == { status: 200, messages: ["ERROR"] } }
+        end
+      end
+
+      describe "formats" do
+        context "no display" do
+          its(:to_json) { should == "" }
+          its(:to_xml) { should == "" }
+        end
+
+        context "with errors and status" do
+          before do
+            subject.new_error :not_found, "Not found"
+          end
+
+          its(:to_json) { should == { status: 404, messages: ["Not found"] }.to_json }
+          its(:to_xml) { should == { status: 404, messages: ["Not found"] }.to_xml(skip_instruct: true, root: :error) }
+        end
+      end
+    end
+  end
+end