frenetic 2.0.0 → 3.0.0

data/lib/frenetic/version.rb

@@ -1,3 +1,3 @@
 class Frenetic
-  VERSION = '2.0.0'
+  VERSION = '3.0.0'
 end

data/spec/concerns/related_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe Frenetic::Related do
+  let(:success) { true }
+
+  let(:response) do
+    res = Struct.new(:body, :success?)
+    res.new({
+      'id' => 99,
+      'foo' => 'bar'
+    }, success)
+  end
+
+  let(:api_stub) { double('ApiDouble', get: response).as_null_object }
+
+  let(:related_resource) do
+    Class.new do
+      attr_reader :id
+
+      def initialize(attrs = {})
+        @id = attrs.fetch('id')
+      end
+    end
+  end
+
+  let(:my_temp_resource) do
+    Class.new do
+      def initialize(attrs = {})
+        @attrs = attrs
+      end
+
+      def api
+        self.class.class_variable_get('@@_api_stub')
+      end
+
+      def links
+        @attrs['_links']
+      end
+
+      def self.find_resource_class(*args)
+        RelatedResource
+      end
+    end
+  end
+
+  let(:params) do
+    {
+      '_links' => {
+        'self' => {},
+        'related_resource' => {
+          'href' => '/related_resource'
+        }
+      }
+    }
+  end
+
+  before do
+    stub_const('MyTempResource', my_temp_resource)
+    stub_const('RelatedResource', related_resource)
+    MyTempResource.class_variable_set('@@_api_stub', api_stub)
+    MyTempResource.send(:include, described_class)
+  end
+
+  subject(:instance) { MyTempResource.new(params) }
+
+  describe '#extract_related_resources' do
+    subject { super().extract_related_resources }
+
+    it 'builds a relation map' do
+      subject
+      expect(instance.send(:relations)).to_not be_empty
+    end
+
+    it 'does not extract self-referential resources' do
+      subject
+      expect(instance.send(:relations)).to_not include 'self'
+    end
+  end
+
+  describe '#fetch_related_resource' do
+    let(:relation) { 'related_resource' }
+
+    let(:props) do
+      {
+        'id' => 99
+      }
+    end
+
+    subject { super().fetch_related_resource(relation, props) }
+
+    it 'returns the instantiated related resource instance' do
+      expect(subject).to be_a RelatedResource
+      expect(subject.id).to eql 99
+    end
+
+    context 'for an unsuccessul resource request' do
+      let(:success) { false }
+
+      it 'returns nil' do
+        expect(subject).to be_nil
+      end
+    end
+
+    context 'with an unknown resource instance' do
+      let(:exception) do
+        Frenetic::ClientError.new(status: 404)
+      end
+
+      before do
+        allow(api_stub).to receive(:get).and_raise(exception)
+      end
+
+      it 'raises an error' do
+        expect{subject}.to raise_error(Frenetic::ResourceNotFound)
+      end
+    end
+  end
+end

data/spec/concerns/structure_method_definer_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Frenetic::StructureMethodDefiner do
+  let(:my_temp_resource) { Class.new }
+
+  before do
+    stub_const('MyTempResource', my_temp_resource)
+    MyTempResource.send(:extend, described_class)
+  end
+
+  describe '.structure' do
+    before do
+      MyTempResource.structure do
+        123
+      end
+    end
+
+    subject { MyTempResource.instance_variable_get('@_structure_block') }
+
+    it 'stores a reference to the block' do
+      expect(subject).to_not be_nil
+    end
+  end
+end

data/spec/resource_mockery_spec.rb

@@ -11,12 +11,12 @@ describe Frenetic::ResourceMockery do
     Class.new(my_temp_resource) do
       def self.default_attributes
         {
-          id: 1,
-          price: 0.0,
-          qux: 'qux',
-          _embedded: {
-            embedded_resource: {
-              plugh: 'xyzzy'
+          'id' => 1,
+          'price' => 0.0,
+          'qux' => 'qux',
+          '_embedded' => {
+            'embedded_resource' => {
+              'plugh' => 'xyzzy'
             }
           }
         }
@@ -26,16 +26,16 @@ describe Frenetic::ResourceMockery do
 
   let(:params) do
     {
-      id: '1',
-      foo: 'bar',
-      price: '0.0',
-      bar: 'baz',
+      'id' => '1',
+      'foo' => 'bar',
+      'price' => '0.0',
+      'bar' => 'baz',
       _embedded: {
-        embedded_resource: {
-          grault: 'garply'
+        'embedded_resource' => {
+          'grault' => 'garply'
         },
-        another_resource: {
-          waldo: 'fred'
+        'another_resource' => {
+          'waldo' => 'fred'
         }
       }
     }

data/spec/resource_spec.rb

@@ -88,6 +88,66 @@ describe Frenetic::Resource do
     end
   end
 
+  describe '.extract_embedded_resources' do
+    let(:resource) do
+      {
+        '_embedded' => {
+          'my_temp_resource' => {
+            'id' => 99
+          }
+        }
+      }
+    end
+
+    before { @stubs.api_description }
+
+    subject do
+      MyNamespace::MyTempResource.extract_embedded_resources(resource)
+    end
+
+    it 'extracts all embedded resources' do
+      expect(subject).to include 'my_temp_resource' => kind_of(MyNamespace::MyTempResource)
+    end
+  end
+
+  describe '.find_resource_class' do
+    let(:params) do
+      {
+        id: 54,
+        _links: {
+          known_resource: {
+            href: '/known_resource'
+          }
+        }
+      }
+    end
+
+    before do
+      @stubs.api_description
+      stub_const('MyNamespace::KnownResource', abstract_resource)
+    end
+
+    subject do
+      MyNamespace::MyTempResource.find_resource_class(resource_name)
+    end
+
+    context 'with a known resource' do
+      let(:resource_name) { 'known_resource' }
+
+      it 'returns the resource class' do
+        expect(subject).to eql MyNamespace::KnownResource
+      end
+    end
+
+    context 'with an unknown resource' do
+      let(:resource_name) { 'unknown_resource' }
+
+      it 'returns an anonymous class' do
+        expect(subject).to eql OpenStruct
+      end
+    end
+  end
+
   describe '.namespace' do
     before do
       stub_const 'MyNamespace::MyTempResource', abstract_resource
@@ -278,9 +338,9 @@ describe Frenetic::Resource do
         expect{subject.gender}.to raise_error(NoMethodError)
       end
 
-      it 'is accessible in @params' do
-        params = subject.instance_variable_get('@params')
-        expect(params).to include 'gender' => 'male'
+      it 'is accessible in @raw_attributes' do
+        raw_attrs = subject.instance_variable_get('@raw_attributes')
+        expect(raw_attrs).to include 'gender' => 'male'
       end
     end
 

data/spec/structure_registry/rebuilder_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Frenetic::StructureRegistry::Rebuilder do
+  let(:signatures) { {} }
+  let(:resource) { Class.new }
+  let(:attributes) do
+    {
+      'id' => 123
+    }
+  end
+  let(:key) { 'MockKey' }
+  let(:signature) { 'abc123def456' }
+
+  subject(:instance) { described_class.new(signatures, resource, attributes, key, signature) }
+
+  after do
+    Struct.send(:remove_const, key) if Struct.constants.include?(key.to_sym)
+  end
+
+  describe '#call' do
+    subject { super().call }
+
+    it 'removes any existing registration' do
+      allow(instance).to receive(:destroy!)
+      subject
+      expect(instance).to have_received(:destroy!)
+    end
+
+    it 'registers the Struct signature' do
+      subject
+      expect(instance.signatures[key]).to eql signature
+    end
+
+    it 'returns a Struct for the given resource' do
+      expect(subject).to eql Struct::MockKey
+    end
+  end
+
+  describe '#destroy!' do
+    let!(:struct) { Struct.new(key) }
+
+    subject { super().destroy! }
+
+    it 'removes the registered signature' do
+      subject
+      expect(instance.signatures).to_not include(key)
+    end
+
+    it 'removes the registered Struct constant' do
+      subject
+      expect{Struct.const_get(key.to_sym)}.to raise_error(NameError, %r[uninitialized constant Struct::#{key}])
+    end
+
+    context 'for a non-existant struct' do
+      before do
+        allow(instance).to receive(:exists?).and_return(false)
+      end
+
+      it 'does nothing' do
+        subject
+        expect(Struct.const_get(key)).to_not be_nil
+      end
+    end
+  end
+
+  describe '#exists?' do
+    subject { super().exists? }
+
+    context 'for a registered resource' do
+      let!(:struct) { Struct.new(key) }
+
+      it 'returns TRUE' do
+        expect(subject).to eql true
+      end
+    end
+
+    context 'for an un-registered resource' do
+      it 'returns FALSE' do
+        expect(subject).to eql false
+      end
+    end
+  end
+end

data/spec/structure_registry/retriever_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Frenetic::StructureRegistry::Retriever do
+  let(:rebuilder_class) { Frenetic::StructureRegistry::Rebuilder }
+  let(:signatures) { {} }
+  let(:resource) { Class.new }
+  let(:attributes) do
+    {
+      'id' => 123
+    }
+  end
+  let(:key) { 'MockKey' }
+
+  subject(:instance) do
+    described_class.new(signatures, resource, attributes, key, rebuilder_class: rebuilder_class)
+  end
+
+  describe '#initialize' do
+    context 'with a blank :key argument' do
+      let(:key) { '  ' }
+
+      it 'raises an error' do
+        expect{subject}.to raise_error(ArgumentError, /non-blank/)
+      end
+    end
+  end
+
+  describe '#call' do
+    let(:rebuilder) { double('Rebuilder') }
+    let(:rebuilder_class) { double('RebuilderClass', new: rebuilder) }
+
+    subject { super().call }
+
+    context 'for an expired resource registration' do
+      before do
+        allow(instance).to receive(:expired?).and_return(true)
+      end
+
+      it 'invokes the Rebuilder' do
+        allow(rebuilder).to receive(:call)
+        subject
+        expect(rebuilder).to have_received(:call)
+      end
+    end
+
+    context 'for an un-expired resource registration' do
+      before do
+        allow(instance).to receive(:expired?).and_return(false)
+      end
+
+      it 'fetches the resource' do
+        allow(instance).to receive(:fetch_structure).and_return(true)
+        subject
+        expect(instance).to have_received(:fetch_structure)
+      end
+    end
+  end
+
+  describe '#expired?' do
+    let(:resource_signature) { 'mock_signature' }
+    let(:signatures) do
+      {
+        key => resource_signature
+      }
+    end
+
+    before do
+      allow(instance).to receive(:struct_signature).and_return resource_signature
+    end
+
+    subject { super().expired? }
+
+    context 'for an un-registered resource' do
+      let(:signatures) { {} }
+
+      it 'returns TRUE' do
+        expect(subject).to eql true
+      end
+    end
+
+    context 'for an expired resource' do
+      let(:signatures) do
+        {
+          key => resource_signature + 'OLD'
+        }
+      end
+
+      it 'returns TRUE' do
+        expect(subject).to eql true
+      end
+    end
+
+    context 'for an un-expired resource' do
+      it 'returns FALSE' do
+        expect(subject).to eql false
+      end
+    end
+  end
+
+  describe '#fetch_structure' do
+    before { Struct.new(key) }
+
+    after { Struct.send(:remove_const, key) }
+
+    subject { super().fetch_structure }
+
+    it 'returns the registered Struct class' do
+      expect(subject).to eql Struct::MockKey
+    end
+  end
+
+  describe '#struct_signature' do
+    subject { super().struct_signature }
+
+    it 'returns a unique signature for a given resource' do
+      expect(subject).to match(/\A[a-z0-9]{40}\z/)
+    end
+  end
+end