axel 0.0.1

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

@@ -0,0 +1,141 @@
+require 'spec_helper'
+module Axel
+  module Payload
+    describe Metadata do
+      describe "class" do
+        subject { Metadata }
+        its(:root_node) { should == :metadata }
+      end
+
+      context "instance" do
+        before do
+          subject[:name] = "jon"
+        end
+
+        it "isn't paged" do
+          subject.paged?.should be_falsey
+        end
+
+        it "has 1 page" do
+          subject.total_pages.should == 1
+        end
+
+        describe "drops" do
+          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 == { "name" => "jon" } }
+          end
+        end
+
+        context "dup" do
+          specify { subject.attributes.should_not be(subject.dup.attributes) }
+        end
+
+        context "clone" do
+          specify { subject.attributes.should_not be(subject.clone.attributes) }
+        end
+
+        context "merge" do
+          let(:age_metadata) { Metadata.new age: 10 }
+          let(:name_metadata) { Metadata.new name: "tom" }
+
+          it "merges a different key" do
+            merged = subject.merge(age_metadata)
+            subject.should_not == merged
+            subject.attributes.should_not == merged.attributes
+            subject.attributes.should == { name: "jon" }.with_indifferent_access
+          end
+
+          it "merges a similar key" do
+            merged = subject.merge(name_metadata)
+            subject.attributes.should_not == merged.attributes
+            subject.attributes.should == { name: "jon" }.with_indifferent_access
+          end
+        end
+
+        context "paged" do
+          before do
+            subject[:pagination] = { total_pages: 2 }
+          end
+
+          it "isn't paged" do
+            subject.paged?.should be_truthy
+          end
+
+          it "has 1 page" do
+            subject.total_pages.should == 2
+          end
+        end
+
+        context "decode" do
+          let(:xml) do
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?><current_user><id type=\"integer\">1</id></current_user>"
+          end
+
+          let(:json) do
+            "{\"current_user\":{\"id\":1}}"
+          end
+
+          let(:ruby_hash) do
+            { current_user: { id: 1 } }
+          end
+
+          it "set the hash for json" do
+            subject[:json] = json
+            subject[:json].should == { "current_user" => { "id" => 1 } }
+          end
+
+          it "set the hash for xml" do
+            subject[:xml] = xml
+            subject[:xml].should == { "current_user" => { "id" => 1 } }
+          end
+
+          it "set the hash for a ruby hash" do
+            subject[:ruby_hash] = ruby_hash
+            subject[:ruby_hash].should == { current_user: { id: 1 } }.with_indifferent_access
+          end
+        end
+
+        context "merge!" do
+          let(:age_metadata) { Metadata.new age: 10 }
+          let(:name_metadata) { Metadata.new name: "tom" }
+
+          it "merges a different key" do
+            subject.merge! age_metadata
+            subject.attributes.should == { age: 10, name: "jon" }.with_indifferent_access
+          end
+
+          it "merges a similar key" do
+            subject.merge! name_metadata
+            subject.attributes.should == { name: "tom" }.with_indifferent_access
+          end
+        end
+
+        context "setting objects" do
+          it "set the object value" do
+            subject[:name].should == "jon"
+            subject["name"].should == "jon"
+          end
+        end
+
+        context "display" do
+          its(:display) { should == { name: "jon" }.with_indifferent_access }
+          its(:display?) { should == true }
+        end
+
+        context "formatting" do
+          its(:to_json) { should == { name: "jon" }.to_json }
+          its(:to_xml) { should == { name: "jon" }.to_xml(skip_instruct: true, root: :metadata) }
+        end
+      end
+    end
+  end
+end

data/spec/models/axel/querier_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+SomeClass = Class.new do
+  def self.routes
+    {}
+  end
+
+  def self.retrieve_default_request_options(options)
+    Axel::RequestOptions.new({}, options).compiled
+  end
+end
+
+module Axel
+  describe Querier do
+    subject { Querier.new klass }
+    let(:klass) { SomeClass.tap { |c| c.stub request_uri: "http://localhost" } }
+
+    its(:klass) { should == klass }
+
+    before do
+      SomeClass.stub :request do
+        [SomeClass.new]
+      end
+    end
+
+    describe "paged" do
+      describe "paged, but not asked for" do
+        let(:returned) { [double(paged?: true)] }
+        it "should be requested once" do
+          klass.should_receive(:request).once.and_return(returned)
+          subject.to_a.should == returned
+        end
+      end
+
+      describe "paged requested" do
+        describe "nil element" do
+          it "returns empty array" do
+            klass.should_receive(:request).once.and_return([])
+            subject.paged.to_a.should == []
+          end
+        end
+
+        describe "single element" do
+          let(:returned) { [double(paged?: false)] }
+
+          it "returns singular array" do
+            klass.should_receive(:request).once.and_return(returned)
+            subject.paged.to_a.should == returned
+          end
+        end
+
+        describe "multiple pages" do
+          let(:returned) { [double(paged?: true, total_pages: 3)] }
+
+          it "returns singular array" do
+            klass.should_receive(:request).exactly(3).times.and_return(returned)
+            subject.paged.to_a.should == returned + returned + returned
+          end
+        end
+      end
+    end
+
+    describe "accidentally build an array" do
+      before do
+        subject.stub build_into_response_container: []
+      end
+
+      it "successfully builds from a list" do
+        subject.send :run_requests # should not error, want full trace if it DOES error
+      end
+    end
+
+    describe "to_a" do
+      it "calls run_requests" do
+        subject.should_receive(:run_requests).once.and_return []
+        subject.to_a
+      end
+    end
+
+    describe "path" do
+      subject { Querier.new(klass).at_path("some_resource", "1") }
+      before do
+        subject.class.any_instance.stub manual_uri: "http://localhost"
+      end
+
+      it "has a built request_uri" do
+        subject.send(:request_uri).should == "http://localhost/some_resource/1"
+      end
+
+      it "has appended the request_uri" do
+        subject.at_path("another_resource")
+          .send(:request_uri).should == "http://localhost/some_resource/1/another_resource"
+      end
+    end
+
+    describe "where" do
+      subject { Querier.new(klass).where(id: 1) }
+      it "sets parameters" do
+        subject.send(:retrieve_request_options).should == {"headers"=>{"Content-Type"=>"application/json"}, "params"=>{"id"=>1}}
+      end
+
+      it "has appended the request_uri" do
+        subject.where(name: "jon").send(:retrieve_request_options).should == {"headers"=>{"Content-Type"=>"application/json"}, "params"=>{"id"=>1, "name"=>"jon"}}
+      end
+    end
+
+    describe "uri" do
+      subject { Querier.new(klass).uri("http://user-service.dev") }
+
+      it "has a built request_uri" do
+        subject.send(:manual_uri).should == "http://user-service.dev"
+        subject.send(:request_uri).should == "http://user-service.dev"
+      end
+
+      it "has appended the request_uri" do
+        subject.uri("http://other-url").send(:manual_uri).should == "http://other-url"
+        subject.uri("http://other-url").send(:request_uri).should == "http://other-url"
+      end
+    end
+
+    describe "none" do
+      it "forces empty" do
+        subject.none == []
+      end
+    end
+
+    describe "reload" do
+      before do
+        subject.send :loaded=, true
+        subject.send :records=, [1,2,3]
+      end
+
+      it "resets variables and tries to force a reload of data" do
+        subject.loaded?.should be_truthy
+        subject.send(:records).should == [1,2,3]
+        subject.reload
+        subject.loaded?.should be_falsey
+        subject.send(:records).should == []
+      end
+    end
+
+    describe "enumerations" do
+      it { should respond_to :each }
+      it { should respond_to :first }
+      it { should respond_to :last }
+
+      its(:each) { should be_an Enumerator }
+    end
+
+    describe "loaded?" do
+      its(:loaded?) { should == false }
+      describe 'with ran requests' do
+        it "becomes loaded when to_a ran" do
+          expect { subject.to_a }.to change { subject.loaded? }.from(false).to(true)
+        end
+      end
+    end
+  end
+end

data/spec/models/axel/router_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+module Axel
+  SomeClass = Class.new ServiceResource::Base
+  SomeOtherClass = Class.new ServiceResource::Base
+
+  describe Router do
+    subject { Router.new(klass, path, method_name, options) }
+    let(:path) { "users/:id/personas/:persona_id" }
+    let(:klass) { SomeClass }
+    let(:method_name) { :user_persona }
+    let(:options) { {} }
+
+    its(:parameters) { should == ["id", "persona_id"] }
+    its(:arity) { should == 2 }
+
+    before do
+      klass.stub request_uri: "http://localhost", site: "http://localhost"
+    end
+
+    describe "with custom class filler" do
+      describe "given class constant" do
+        let(:options) { { class: SomeOtherClass } }
+        let(:querier_stub) { double }
+        it "calls via some other class" do
+          SomeOtherClass.should_receive(:querier).and_return querier_stub
+          querier_stub.should_receive(:without_default_path).and_return querier_stub
+          querier_stub.should_receive(:at_path).and_return querier_stub
+          querier_stub.should_receive(:request_options).and_return querier_stub
+          subject.route 1
+        end
+      end
+
+      describe "given class name" do
+        let(:options) { { class_name: "axel/some_other_class" } }
+        let(:querier_stub) { double }
+        it "calls via some other class" do
+          SomeOtherClass.should_receive(:querier).and_return querier_stub
+          querier_stub.should_receive(:without_default_path).and_return querier_stub
+          querier_stub.should_receive(:at_path).and_return querier_stub
+          querier_stub.should_receive(:request_options).and_return querier_stub
+          subject.route 1
+        end
+      end
+    end
+
+    context "no arity" do
+      let(:path) { "users" }
+      let(:route_with_options) { subject.route(params: { some_param: 1 }) }
+      its(:arity) { should == 0 }
+      it "can route with regular params and request options" do
+        route_with_options.send(:extra_paths).should == ["users"]
+        route_with_options.send(:retrieve_request_options).should == {
+          "headers" => { "Content-Type"=>"application/json" },
+          "params" => { "some_param"=>1 }
+        }
+      end
+    end
+
+    context "route" do
+      let(:regular_routed) { subject.route(1,2) }
+      let(:hash_routed) { subject.route(id: 1, persona_id: 2) }
+      let(:regular_routed_with_request_options) { subject.route(1, 2, params: { some_param: 1 }) }
+      let(:hash_routed_with_request_options) { subject.route({ id: 1, persona_id: 2 }, { params: { some_param: 1 } }) }
+      it "can route with regular params" do
+        regular_routed.send(:extra_paths).should == ["users/1/personas/2"]
+        regular_routed.send(:retrieve_request_options).should == {
+          "headers" => { "Content-Type"=>"application/json" }
+        }
+      end
+
+      it "can route with hash params" do
+        hash_routed.send(:extra_paths).should == ["users/1/personas/2"]
+        hash_routed.send(:retrieve_request_options).should == {
+          "headers" => { "Content-Type"=>"application/json" }
+        }
+      end
+
+      it "can route with regular params and request options" do
+        regular_routed_with_request_options.send(:extra_paths).should == ["users/1/personas/2"]
+        regular_routed_with_request_options.send(:retrieve_request_options).should == {
+          "headers" => { "Content-Type"=>"application/json" },
+          "params" => { "some_param"=>1 }
+        }
+      end
+
+      it "can route with hash params and request options" do
+        hash_routed_with_request_options.send(:extra_paths).should == ["users/1/personas/2"]
+        hash_routed_with_request_options.send(:retrieve_request_options).should == {
+          "headers" => { "Content-Type"=>"application/json" },
+          "params" => { "some_param"=>1 }
+        }
+      end
+
+      context "with arity of 1" do
+        let(:path) { "users/:id/personas" }
+        let(:hash_routed) { subject.route({ id: 1}) }
+        let(:hash_routed_with_request_options) { subject.route({ id: 1}, { params: { some_param: 1 } }) }
+        it "can route with hash params" do
+          hash_routed.send(:extra_paths).should == ["users/1/personas"]
+          hash_routed.send(:retrieve_request_options).should == {
+            "headers" => { "Content-Type"=>"application/json" }
+          }
+        end
+
+        it "can route with hash params and request options" do
+          hash_routed_with_request_options.send(:extra_paths).should == ["users/1/personas"]
+          hash_routed_with_request_options.send(:retrieve_request_options).should == {
+            "headers" => { "Content-Type"=>"application/json" },
+            "params" => { "some_param"=>1 }
+          }
+        end
+      end
+    end
+  end
+end

data/spec/models/axel/service_resource/base_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+require 'json'
+FakeResource = Class.new Axel::ServiceResource::Base
+module Axel
+  module ServiceResource
+    describe Base do
+      context "class" do
+        subject { Base }
+
+        context "#load_values" do
+          let(:old_attributes) { { key_1: 'value_1', key_2: 'value_2' }.with_indifferent_access }
+          let(:response_body) { '{"result":{"key_1":"value_1_mod"}}' }
+          let(:new_attributes) { ::JSON.parse(response_body)['result'] }
+          let(:object) { FakeResource.new(old_attributes) }
+          let(:response) { double(body: response_body, success?: true, code: 200) }
+
+          it 'merges attributes' do
+            subject.load_values(object, response)
+            object.attributes.should eq(old_attributes.merge(new_attributes))
+          end
+        end
+
+        context "routes" do
+          its(:routes) { should be_a HashWithIndifferentAccess }
+          context "defining route" do
+            after { subject.instance_variable_set("@_routes", nil) }
+            it "sets up a route" do
+              subject.should_not respond_to :user_with_id
+              subject.route "user/:id", :user_with_id
+              subject.should respond_to :user_with_id
+            end
+          end
+        end
+
+        context "site" do
+          context "without setting site" do
+            before { subject.stub(resource: double(base_url: "http://some-url")) }
+
+            its(:site) { should == "http://some-url" }
+          end
+
+          context "manual set site" do
+            before { subject.site("http://some-other-url") }
+            after { subject.instance_variable_set("@site", nil) }
+            it "set the site" do
+              subject.site.should == "http://some-other-url"
+            end
+          end
+        end
+
+        context "path" do
+          context "without setting path" do
+            context "without resource" do
+              its(:path) { should == "bases" }
+            end
+
+            context "with resource" do
+              before { subject.stub(resource: double(path: "resources")) }
+
+              its(:path) { should == "resources" }
+            end
+          end
+
+          context "manual set path" do
+            context "with resource" do
+              before { subject.stub(resource: double(path: "resources")) }
+
+              it "sets resource path" do
+                subject.resource.should_receive(:path=).once
+                subject.path "some_path"
+              end
+            end
+          end
+
+          context "without resource" do
+            before { subject.stub resource: nil }
+            after { subject.instance_variable_set("@path", nil) }
+            it "sets instance variable" do
+              subject.path "some_other_path"
+              subject.instance_variable_get("@path").should == "some_other_path"
+            end
+          end
+        end
+
+        context "querier" do
+          its(:querier) { should be_a Axel::Querier }
+          it "has a querier where self is the klass" do
+            subject.querier.klass.should == Base
+          end
+        end
+
+        context "resource_name" do
+          # testing order messes with the name
+          before { subject.instance_variable_set("@_resource_name", nil) }
+          after { subject.instance_variable_set("@_resource_name", nil) }
+          it "sets the resource name and makes accessible" do
+            subject.resource_name.should == "bases"
+            subject.resource_name "users"
+            subject.resource_name.should == "users"
+          end
+        end
+
+        context "resource" do
+          # testing order messes with the name
+          before { subject.instance_variable_set("@_resource_name", nil) }
+          after { subject.instance_variable_set("@_resource_name", nil) }
+          # for the should_receive
+          before { Axel.stub(resources: double) }
+          it "tries based on the class name" do
+            Axel.resources.should_receive(:[]).with "bases"
+            subject.resource
+          end
+
+          it "with a resource name set it tries that name" do
+            subject.resource_name "users"
+            Axel.resources.should_receive(:[]).with "users"
+            subject.resource
+            subject.send(:instance_variable_set, "@_resource_name", nil)
+          end
+        end
+
+        describe "uri_join" do
+          it "builds a id path" do
+            subject.uri_join("http://localhost", 1).should == "http://localhost/1"
+          end
+
+          it "builds a id path with extra" do
+            subject.uri_join("http://localhost", "1/", "/personas/").should == "http://localhost/1/personas"
+          end
+
+          it "just one" do
+            subject.uri_join("http://localhost").should == "http://localhost"
+          end
+        end
+
+        context "#request" do
+          let(:request_builder) { double }
+
+          before do
+            subject.should_receive(:build_request).with("http://localhost", { 'headers' => { 'Content-Type' => 'application/json'} }).and_return request_builder
+            request_builder.should_receive(:run).once
+          end
+
+          it "builds and runs synchronous request with typhoid" do
+            subject.request "http://localhost"
+          end
+        end
+
+        context "#inherited" do
+          subject { FakeResource }
+          context "it setup accessors" do
+            context "instance" do
+              subject { FakeResource.new }
+              it { should respond_to :id }
+              it { should respond_to :id= }
+              it { should respond_to :uri }
+              it { should respond_to :uri= }
+            end
+          end
+        end
+      end
+
+      context "instance" do
+        subject { Base.new params }
+        let(:params) { {} }
+
+        context "resource_exception" do
+          context "remote errors" do
+            let(:remote_errors) { Payload::Errors.new status: 404, messages: ["Fail!"] }
+            before do
+              subject.stub remote_errors: remote_errors
+            end
+
+            it "sets error resource exception" do
+              subject.resource_exception.to_s.should == "Failed. HTTP Status: 404, Messages: Fail!"
+            end
+          end
+        end
+
+        context "new instance" do
+          context "without envelope response" do
+            let(:params) { { id: 1 } }
+
+            its(:envelope?) { should be_falsey }
+
+            its(:metadata) { should be_a Payload::Metadata }
+            it "sets no metadata" do
+              subject.metadata.attributes.should == {}
+            end
+
+            its(:remote_errors) { should be_a Payload::Errors }
+            it "sets error" do
+              subject.remote_errors.status_code.should == 200
+              subject.remote_errors.messages.should == []
+            end
+
+            its(:result) { should == { id: 1 }.with_indifferent_access }
+            it "converts attributes to result" do
+              subject.result.should == subject.attributes
+            end
+          end
+
+          context "with envelope response" do
+            let(:params) { { metadata: { current_user: { id: 1 } }, result: { id: 1 } } }
+
+            its(:envelope?) { should be_truthy }
+
+            its(:metadata) { should be_a Payload::Metadata }
+            it "sets metadata" do
+              subject.metadata[:current_user].should == { id: 1 }.with_indifferent_access
+            end
+
+            its(:remote_errors) { should be_a Payload::Errors }
+            it "sets error" do
+              subject.remote_errors.status_code.should == 200
+              subject.remote_errors.messages.should == []
+            end
+
+            its(:result) { should == { id: 1 }.with_indifferent_access }
+            it "converts attributes to result" do
+              subject.result.should == subject.attributes
+            end
+          end
+        end
+
+        context "request_uri" do
+          context "uri set by incoming object" do
+            let(:params) { { metadata: { current_user: { id: 1 } }, result: { id: 1, uri: "http://localhost/users" } } }
+
+            its(:request_uri) { should == "http://localhost/users" }
+          end
+
+          context "uri computed" do
+            before do
+              Base.stub site: "http://localhost", path: "users"
+            end
+
+            its(:request_uri) { should == "http://localhost/users" }
+          end
+        end
+      end
+    end
+  end
+end