frenetic 0.0.20.alpha.6 → 1.0.0.alpha.1

data/spec/hypermedia_link_set_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe Frenetic::HypermediaLinkSet do
+  subject(:instance) { described_class.new links }
+
+  describe '#initialize' do
+    context 'with a single link' do
+      let(:links) { { href:'foo' } }
+
+      it 'converts the argument to an array' do
+        expect(subject.size).to eq 1
+      end
+
+      it 'transforms it into HypermediaLink' do
+        expect(subject.first).to be_an_instance_of Frenetic::HypermediaLink
+      end
+    end
+  end
+
+  describe '#href' do
+    subject { super().href tmpl_data }
+
+    context 'without template data' do
+      let(:tmpl_data) {}
+
+      context 'with a single link in the set' do
+        let(:link_a) do
+          Frenetic::HypermediaLink.new href:'/foo/bar'
+        end
+
+        let(:links) { [link_a] }
+
+        it 'returns the HREF of the first link' do
+          allow(link_a).to receive(:href).and_call_original
+          expect(subject).to eq '/foo/bar'
+          expect(link_a).to have_received(:href)
+        end
+      end
+
+      context 'with multiple links in the set' do
+        let(:links) do
+          [
+            { href:'/foo/bar' },
+            { href:'/baz/qux' }
+          ]
+        end
+
+        it 'returns the first link in the set' do
+          expect(subject).to eq '/foo/bar'
+        end
+      end
+    end
+
+    context 'with template data' do
+      let(:tmpl_data) { { id:1 } }
+
+      let(:link_a) do
+        Frenetic::HypermediaLink.new href:'/foo/{id}', templated:true
+      end
+
+      let(:links) { [link_a] }
+
+      it 'finds most relevant link' do
+        allow(instance).to receive(:find_relevant_link)
+        subject
+        expect(instance).to have_received(:find_relevant_link)
+      end
+
+      it 'passes along the template data' do
+        allow(link_a).to receive(:href).and_call_original
+        subject
+        expect(link_a).to have_received(:href).with(tmpl_data)
+      end
+    end
+  end
+
+  describe '#find_relevant_link' do
+    let(:tmpl_data) { { id:1 } }
+
+    subject { super().find_relevant_link tmpl_data }
+
+    context 'with a single, matching link' do
+      let(:links) do
+        [
+          { href:'/foo/{id}', templated:true }
+        ]
+      end
+
+      it 'returns the matching link' do
+        expect(subject).to be_an_instance_of Frenetic::HypermediaLink
+      end
+    end
+
+    context 'with multiple matching links' do
+      let(:link_a) do
+        Frenetic::HypermediaLink.new( href:'/foo/{id}', templated:true )
+      end
+
+      let(:links) do
+        [
+          link_a,
+          { href:'/bar/{id}', templated:true }
+        ]
+      end
+
+      it 'returns the first matching link' do
+        expect(subject).to eq link_a
+      end
+    end
+
+    context 'with no matching links' do
+      let(:links) do
+        [
+          { href:'/foo/{fname}', templated:true },
+          { href:'/foo/{lname}', templated:true }
+        ]
+      end
+
+      it 'raises an error' do
+        expect{ subject }.to raise_error Frenetic::HypermediaError
+      end
+    end
+  end
+
+  describe '#[]' do
+    subject { super()[rel] }
+
+    let(:link_b) do
+      Frenetic::HypermediaLink.new( href:'/bar', rel:'bar' )
+    end
+
+    let(:links) do
+      [
+        { href:'/foo', rel:'foo' },
+        link_b
+      ]
+    end
+
+    context 'for a relation that exists' do
+      let(:rel) { :bar }
+
+      it 'returns the desired link' do
+        expect(subject).to eq link_b
+      end
+    end
+
+    context 'for a relation that does not exist' do
+      let(:rel) { :baz }
+
+      it 'returns nothing' do
+        expect(subject).to be_nil
+      end
+    end
+  end
+end

data/spec/hypermedia_link_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Frenetic::HypermediaLink do
+  let(:basic_link) do
+    { href:'/api/my_link' }
+  end
+
+  let(:templated_link) do
+    { href:'/api/my_link/{id}-{title}', templated:true }
+  end
+
+  let(:relation_link) do
+    { href:'/api/foo', rel:'foo' }
+  end
+
+  subject { described_class.new(link) }
+
+  describe '#href' do
+    subject { super().href data }
+
+    context 'with a non-templated link' do
+      let(:link) { basic_link }
+      let(:data) {}
+
+      it 'correctly transforms the data' do
+        expect(subject).to eq '/api/my_link'
+      end
+    end
+
+    context 'with a templated link' do
+      let(:link) { templated_link }
+
+      context 'and complate template data' do
+        let(:data) { { id:1, title:'title' } }
+
+        it 'correctly transforms the data' do
+          expect(subject).to eq '/api/my_link/1-title'
+        end
+      end
+
+      context 'and incomplete template data' do
+        let(:data) { { id:1 } }
+
+        it 'raises an error' do
+          expect{subject}.to raise_error Frenetic::HypermediaError
+        end
+      end
+
+      context 'and non-Hash template data' do
+        let(:templated_link) do
+          { href:'/api/my_link/{id}', templated:true }
+        end
+
+        let(:data) { 1 }
+
+        it 'infers the template data' do
+          expect(subject).to eq '/api/my_link/1'
+        end
+      end
+    end
+  end
+
+  describe '#templated?' do
+    subject { super().templated? }
+
+    context 'with a non-templated link' do
+      let(:link) { basic_link }
+
+      it 'returns FALSE' do
+        expect(subject).to eq false
+      end
+    end
+
+    context 'with a templated link' do
+      let(:link) { templated_link }
+
+      it 'returns TRUE' do
+        expect(subject).to eq true
+      end
+    end
+  end
+
+  describe '#expandable?' do
+    subject { super().expandable? data }
+
+    let(:link) { templated_link }
+
+    context 'when the data can fully fulfill the template requirements' do
+      let(:data) { { id:1, title:'title' } }
+
+      it 'returns TRUE' do
+        expect(subject).to eq true
+      end
+    end
+
+    context 'when the data cannot fully fulfill the template requirements' do
+      let(:data) { { id:1 } }
+
+      it 'returns FALSE' do
+        expect(subject).to eq false
+      end
+    end
+
+    context 'when the data provides more than the template requires' do
+      let(:data) { { id:1, title:'title', garbage:true } }
+
+      it 'returns TRUE' do
+        expect(subject).to eq true
+      end
+    end
+
+    context 'with a non-template URL' do
+      let(:link) { basic_link }
+
+      let(:data) { { id:1 } }
+
+      it 'returns FALSE' do
+        expect(subject).to eq false
+      end
+    end
+  end
+
+  describe '#template' do
+    subject { super().template }
+
+    let(:link) { templated_link }
+
+    it 'returns an Addressable Template' do
+      expect(subject).to be_an_instance_of Addressable::Template
+    end
+  end
+
+  describe '#as_json' do
+    subject { super().as_json }
+
+    let(:link) { templated_link }
+
+    it 'returns a Hash representation of the link' do
+      expect(subject).to include 'href' => '/api/my_link/{id}-{title}'
+      expect(subject).to include 'templated' => true
+    end
+  end
+
+  describe '#rel' do
+    subject { super().rel }
+
+    let(:link) { relation_link }
+
+    it 'returns the relation name' do
+      expect(subject).to eq 'foo'
+    end
+  end
+end

data/spec/middleware/hal_json_spec.rb

@@ -1,13 +1,12 @@
 require 'spec_helper'
 
 describe Frenetic::Middleware::HalJson do
-
   def process(body, content_type = nil, options = {}, status = 200)
     env = {
-      body:             body,
-      request:          options,
-      response_headers: Faraday::Utils::Headers.new( headers ),
-      status:           status
+      body: body,
+      request: options,
+      response_headers: Faraday::Utils::Headers.new(headers),
+      status: status
     }
     env[:response_headers]['content-type'] = content_type if content_type
 
@@ -15,9 +14,7 @@ describe Frenetic::Middleware::HalJson do
   end
 
   let(:options) { Hash.new }
-
   let(:headers) { Hash.new }
-
   let(:middleware) do
     described_class.new(lambda {|env|
       Faraday::Response.new(env)
@@ -51,7 +48,7 @@ describe Frenetic::Middleware::HalJson do
 
     subject { process(body) }
 
-    it 'should parse the body' do
+    it 'parses the body' do
       expect(subject.body).to include 'name' => 'My Name'
     end
   end
@@ -61,23 +58,24 @@ describe Frenetic::Middleware::HalJson do
 
     context 'from the server' do
       let(:status) { 500 }
+      let(:error) do
+        { 'status' => status.to_s, error:'500 Server Error' }.to_json
+      end
 
-      let(:error) { { 'status' => status.to_s, error:'500 Server Error' }.to_json }
-
-      it 'should raise an error' do
+      it 'raises an error' do
         expect{ subject }.to raise_error Frenetic::ServerError
       end
     end
 
     context 'cause by the client' do
       let(:status) { 404 }
+      let(:error) do
+        { 'status' => status.to_s, error:'404 Not Found' }.to_json
+      end
 
-      let(:error) { { 'status' => status.to_s, error:'404 Not Found' }.to_json }
-
-      it 'should raise an error' do
+      it 'raises an error' do
         expect{ subject }.to raise_error Frenetic::ClientError
       end
     end
   end
-
 end

data/spec/resource_collection_spec.rb

@@ -43,34 +43,36 @@ describe Frenetic::ResourceCollection do
 
   subject(:instance) { described_class.new(MyTempResource, collection_response) }
 
-  it 'should know where the resources are located' do
-    subject.collection_key.should == 'my_temp_resources'
+  it 'knows where the resources are located' do
+    expect(subject.collection_key).to eq 'my_temp_resources'
   end
 
-  it 'should know which resource it represents' do
-    subject.resource_type.should == 'my_temp_resource'
+  it 'knows which resource it represents' do
+    expect(subject.resource_type).to eq 'my_temp_resource'
   end
 
-  it 'should extract the embedded resources' do
-    subject.size.should == 2
+  it 'extracts the embedded resources' do
+    expect(subject.size).to eq 2
   end
 
-  it 'should parse the embedded resources' do
-    subject.first.should be_a MyTempResource
+  it 'parses the embedded resources' do
+    expect(subject.first).to be_a MyTempResource
   end
 
-  it 'should be able to make API calls' do
-    subject.api.should be_an_instance_of Frenetic
+  it 'is able to make API calls' do
+    expect(subject.api).to be_an_instance_of Frenetic
   end
 
-  it 'should have links' do
-    subject.links.should_not be_empty
+  it 'has links' do
+    expect(subject.links).to_not be_empty
   end
 
   context 'for a non-embedded resource' do
     subject { described_class.new(MyTempResource) }
 
-    it { should be_empty }
+    it 'is empty' do
+      expect(subject).to be_empty
+    end
   end
 
   describe '#get' do
@@ -78,9 +80,8 @@ describe Frenetic::ResourceCollection do
 
     subject { super().get(1) }
 
-    it 'should GET the full representation' do
-      subject.should be_an_instance_of MyTempResource
+    it 'issues a GET the full representation' do
+      expect(subject).to be_an_instance_of MyTempResource
     end
   end
-
 end

data/spec/resource_mockery_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+require 'frenetic/resource_mockery'
+
+describe Frenetic::ResourceMockery do
+  let(:my_temp_resource) do
+    Class.new(Frenetic::Resource)
+  end
+
+  let(:my_mocked_resource) do
+    Class.new(my_temp_resource) do
+      def self.default_attributes
+        { qux:'qux' }
+      end
+    end
+  end
+
+  before do
+    stub_const 'MyNamespace::MyMockedResource', my_mocked_resource
+    MyNamespace::MyMockedResource.send :include, described_class
+  end
+
+  let(:params) { { foo:1, bar:'baz' } }
+
+  subject { MyNamespace::MyMockedResource.new params }
+
+  it 'violates some basic CS principles by telling the parent-class of its existence' do
+    expect(my_temp_resource.instance_variables).to include :@mock_class
+  end
+
+  describe '#properties' do
+    subject { super().properties }
+
+    it 'returns a hash of available properties' do
+      expect(subject).to include 'foo' => 'fixnum'
+      expect(subject).to include 'bar' => 'string'
+    end
+  end
+
+  describe '#attributes' do
+    subject { super().attributes }
+
+    it 'returns a hash of the resources attributes' do
+      expect(subject).to include 'foo' => 1
+      expect(subject).to include 'bar' => 'baz'
+      expect(subject).to include 'qux' => 'qux'
+    end
+  end
+
+  describe '.default_attributes' do
+    let(:my_mocked_resource) { Class.new(my_temp_resource) }
+
+    subject { MyNamespace::MyMockedResource.default_attributes }
+
+    it 'allows implementors to specify sane defaults' do
+      expect(subject).to eq Hash.new
+    end
+  end
+
+  describe '#default_attributes' do
+    let(:my_mocked_resource) { Class.new(my_temp_resource) }
+
+    subject { MyNamespace::MyMockedResource.new.default_attributes }
+
+    it 'proxies to the class method' do
+      expect(subject).to eq Hash.new
+    end
+  end
+end