rest-in-peace 1.4.0 → 2.0.0

data/spec/rest_in_peace/active_model_api_spec.rb

@@ -0,0 +1,201 @@
+require 'rest_in_peace'
+require 'rest_in_peace/active_model_api'
+require 'ostruct'
+
+describe RESTinPeace do
+  let(:api_double) { double('IamAnAPI') }
+  let(:response) { OpenStruct.new(body: 'string!') }
+  let(:extended_class) do
+    Class.new do
+      include RESTinPeace
+
+      rest_in_peace do
+        attributes do
+          read :id, :name
+          write :description, :title
+        end
+
+        resource do
+          put :save, '/class/:id'
+          post :create, '/class'
+        end
+
+        acts_as_active_model
+      end
+    end
+  end
+
+  let(:id) { 1 }
+  let(:name) { 'pony one' }
+  let(:description) { nil }
+  let(:attributes) do
+    {
+      id: id,
+      name: name,
+      description: description,
+    }
+  end
+  let(:instance) { extended_class.new(attributes) }
+
+  context 'class methods' do
+    describe '::acts_as_active_model' do
+      context 'missing save method' do
+        let(:extended_class) do
+          Class.new do
+            include RESTinPeace
+            rest_in_peace do
+              acts_as_active_model
+            end
+          end
+        end
+
+        it 'raises an error when no save method specified' do
+          expect { extended_class.new }.to raise_error(RESTinPeace::ActiveModelAPI::MissingMethod)
+        end
+      end
+
+      context 'missing create method' do
+        let(:extended_class) do
+          Class.new do
+            include RESTinPeace
+            rest_in_peace do
+              resource do
+                put :save, '/yolo'
+              end
+              acts_as_active_model
+            end
+          end
+        end
+
+        it 'raises an error when no create method specified' do
+          expect { extended_class.new }.to raise_error(RESTinPeace::ActiveModelAPI::MissingMethod)
+        end
+      end
+    end
+
+    describe '::model_name' do
+      before do
+        def extended_class.model_name
+          ActiveModel::Name.new(self, nil, 'TemporaryClassForTests')
+        end
+      end
+      specify { expect(extended_class.model_name).to eq('TemporaryClassForTests') }
+      specify { expect(extended_class.model_name).to respond_to(:route_key) }
+    end
+
+    describe 'validation handling' do
+      specify { expect(extended_class).to respond_to(:human_attribute_name).with(2).arguments }
+      specify { expect(extended_class.human_attribute_name(:description)).to eq('description') }
+
+      specify { expect(extended_class).to respond_to(:lookup_ancestors).with(0).arguments }
+      specify { expect(extended_class.lookup_ancestors).to eq([extended_class]) }
+    end
+  end
+
+  context 'instance methods' do
+    before do
+      extended_class.api = api_double
+      allow(api_double).to receive(:put).and_return(response)
+      allow(api_double).to receive(:post).and_return(response)
+    end
+
+    describe '#changed?' do
+      context 'a new instance' do
+        specify { expect(instance.changed?).to eq(false) }
+      end
+
+      context 'a modified instance' do
+        before do
+          instance.description = 'new value'
+        end
+        specify { expect(instance.changed?).to eq(true) }
+      end
+
+      context 'a saved instance' do
+        before do
+          instance.description = 'new value'
+          instance.save
+        end
+        specify { expect(instance.changed?).to eq(false) }
+      end
+    end
+
+    describe 'attribute methods' do
+      specify { expect(instance).to respond_to(:description_changed?) }
+      specify { expect(instance).to respond_to(:title_changed?) }
+    end
+
+    describe '#to_key' do
+      specify { expect(instance.to_key).to eq([1]) }
+    end
+
+    describe '#persisted?' do
+      context 'persisted model' do
+        specify { expect(instance.persisted?).to eq(true) }
+      end
+
+      context 'not yet persisted model' do
+        let(:id) { nil }
+        specify { expect(instance.persisted?).to eq(false) }
+      end
+    end
+
+    describe '#save' do
+      context 'without errors' do
+        let(:response) { OpenStruct.new(body: { name: 'new name from api' }) }
+
+        specify { expect { instance.save }.to_not raise_error }
+        specify { expect(instance.save.object_id).to eq(instance.object_id) }
+        specify { expect { instance.save }.to change(instance, :name) }
+      end
+
+      context 'with errors' do
+        before do
+          instance.description = 'value!'
+        end
+        let(:response) { OpenStruct.new(body: { errors: { 'description' => ['is not empty'] } }) }
+
+        specify { expect { instance.save }.to change { instance.errors.any? } }
+        specify { expect { instance.save }.to_not change { instance.description } }
+        specify { expect { instance.save }.to_not change { instance.name } }
+      end
+    end
+
+    describe '#create' do
+      context 'without errors' do
+        let(:response) { OpenStruct.new(body: { name: 'new name from api' }) }
+
+        specify { expect { instance.create }.to_not raise_error }
+        specify { expect(instance.create.object_id).to eq(instance.object_id) }
+        specify { expect { instance.create }.to change(instance, :name) }
+      end
+
+      context 'with errors' do
+        before do
+          instance.description = 'value!'
+        end
+        let(:response) { OpenStruct.new(body: { errors: { 'description' => ['is not empty'] } }) }
+
+        specify { expect { instance.create }.to change { instance.errors.any? } }
+        specify { expect { instance.create }.to_not change { instance.description } }
+        specify { expect { instance.create }.to_not change { instance.name } }
+      end
+    end
+
+    describe 'validation handling' do
+      let(:description) { 'desc' }
+
+      specify { expect(instance).to respond_to(:read_attribute_for_validation).with(1).argument }
+      specify { expect(instance.read_attribute_for_validation(:description)).to eq('desc') }
+
+      describe '#errors' do
+        specify { expect(instance.errors).to be_instance_of(ActiveModel::Errors) }
+      end
+
+      describe '#errors=' do
+        let(:errors) { { description: ['must not be empty'] } }
+        specify { expect { instance.errors = errors }.to change { instance.errors.count } }
+      end
+    end
+  end
+end

data/spec/rest_in_peace/definition_proxy/attributes_definitions_spec.rb

@@ -0,0 +1,36 @@
+require 'rest_in_peace'
+require 'rest_in_peace/definition_proxy/attributes_definitions'
+
+describe RESTinPeace::DefinitionProxy::AttributesDefinitions do
+  let(:target) do
+    Class.new do
+      include RESTinPeace
+    end
+  end
+  let(:instance_of_target) { target.new }
+  let(:definitions) { described_class.new(target) }
+
+  subject { definitions }
+
+  describe '#read' do
+    it 'defines a getter for the given attributes' do
+      expect { subject.read(:id) }.to change { instance_of_target.respond_to?(:id) }.from(false).to(true)
+    end
+    it 'does not define a setter for the given attributes' do
+      expect { subject.read(:id) }.to_not change { instance_of_target.respond_to?(:id=) }.from(false)
+    end
+    specify { expect { subject.read(:id) }.to change { target.rip_attributes[:read] }.from([]).to([:id]) }
+    specify { expect { subject.read(:id) }.to_not change { target.rip_attributes[:write] }.from([]) }
+  end
+
+  describe '#write' do
+    it 'defines a getter for the given attributes' do
+      expect { subject.write(:id) }.to change { instance_of_target.respond_to?(:id) }.from(false).to(true)
+    end
+    it 'defines a setter for the given attributes' do
+      expect { subject.write(:id) }.to change { instance_of_target.respond_to?(:id=) }.from(false).to(true)
+    end
+    specify { expect { subject.write(:id) }.to change { target.rip_attributes[:read] }.from([]).to([:id]) }
+    specify { expect { subject.write(:id) }.to change { target.rip_attributes[:write] }.from([]).to([:id]) }
+  end
+end

data/spec/rest_in_peace/definition_proxy/collection_method_definitions_spec.rb

@@ -5,9 +5,8 @@ describe RESTinPeace::DefinitionProxy::CollectionMethodDefinitions do
   let(:method_name) { :find }
   let(:url_template) { '/a/:id' }
   let(:default_params) { {} }
-  let(:struct) { Struct.new(:id, :name) }
   let(:target) do
-    Class.new(struct) do
+    Class.new do
       include RESTinPeace
     end
   end
@@ -71,6 +70,12 @@ describe RESTinPeace::DefinitionProxy::CollectionMethodDefinitions do
             target.find(id: 1)
             expect(default_params).to eq({ per_page: 250 })
           end
+
+          it 'raises an error when param is not a hash' do
+            subject.get(:find, '/a/:id', default_params)
+
+            expect { target.find(1) }.to raise_error(RESTinPeace::DefinitionProxy::InvalidArgument)
+          end
         end
 
         context 'without any attributes' do

data/spec/rest_in_peace/definition_proxy/resource_method_definitions_spec.rb

@@ -2,10 +2,16 @@ require 'rest_in_peace'
 require 'rest_in_peace/definition_proxy/resource_method_definitions'
 
 describe RESTinPeace::DefinitionProxy::ResourceMethodDefinitions do
-  let(:struct) { Struct.new(:id, :name) }
   let(:target) do
-    Class.new(struct) do
+    Class.new do
       include RESTinPeace
+      rest_in_peace do
+        attributes do
+          read :id
+          write :name
+        end
+      end
+
     end
   end
   let(:instance) { target.new }
@@ -16,6 +22,7 @@ describe RESTinPeace::DefinitionProxy::ResourceMethodDefinitions do
 
   before do
     allow(RESTinPeace::ApiCall).to receive(:new).and_return(api_call_double)
+    allow(api_call_double).to receive(http_verb)
   end
 
   shared_examples_for 'an instance method' do
@@ -28,21 +35,30 @@ describe RESTinPeace::DefinitionProxy::ResourceMethodDefinitions do
       subject.send(http_verb, method_name, url_template)
       expect(target.rip_registry[:resource]).to eq([method: http_verb, name: method_name, url: url_template])
     end
+  end
 
-    describe 'the created method' do
-      before do
-        allow(api_call_double).to receive(http_verb)
+  shared_examples_for 'an instance method with parameters' do
+    describe 'parameter and arguments handling' do
+      it 'uses the attributes of the class' do
+        expect(RESTinPeace::ApiCall).to receive(:new).
+          with(target.api, url_template, instance, instance.hash_for_updates).
+          and_return(api_call_double)
+
+        subject.send(http_verb, method_name, url_template)
+        instance.send(method_name)
       end
+    end
+  end
 
-      describe 'parameter and arguments handling' do
-        it 'uses the attributes of the class' do
-          expect(RESTinPeace::ApiCall).to receive(:new).
-            with(target.api, url_template, instance, instance.to_h).
-            and_return(api_call_double)
+  shared_examples_for 'an instance method without parameters' do
+    describe 'parameter and arguments handling' do
+      it 'provides the id only' do
+        expect(RESTinPeace::ApiCall).to receive(:new).
+          with(target.api, url_template, instance, id: instance.id).
+          and_return(api_call_double)
 
-          subject.send(http_verb, method_name, url_template)
-          instance.send(method_name)
-        end
+        subject.send(http_verb, method_name, url_template)
+        instance.send(method_name)
       end
     end
   end
@@ -53,6 +69,14 @@ describe RESTinPeace::DefinitionProxy::ResourceMethodDefinitions do
       let(:method_name) { :reload }
       let(:url_template) { '/a/:id' }
     end
+
+    describe 'the created method' do
+      it_behaves_like 'an instance method with parameters' do
+        let(:http_verb) { :get }
+        let(:method_name) { :reload }
+        let(:url_template) { '/a/:id' }
+      end
+    end
   end
 
   context '#patch' do
@@ -61,6 +85,14 @@ describe RESTinPeace::DefinitionProxy::ResourceMethodDefinitions do
       let(:method_name) { :save }
       let(:url_template) { '/a/:id' }
     end
+
+    describe 'the created method' do
+      it_behaves_like 'an instance method with parameters' do
+        let(:http_verb) { :patch }
+        let(:method_name) { :save }
+        let(:url_template) { '/a/:id' }
+      end
+    end
   end
 
   context '#post' do
@@ -69,6 +101,14 @@ describe RESTinPeace::DefinitionProxy::ResourceMethodDefinitions do
       let(:method_name) { :create }
       let(:url_template) { '/a/:id' }
     end
+
+    describe 'the created method' do
+      it_behaves_like 'an instance method with parameters' do
+        let(:http_verb) { :post }
+        let(:method_name) { :create }
+        let(:url_template) { '/a/:id' }
+      end
+    end
   end
 
   context '#put' do
@@ -77,6 +117,14 @@ describe RESTinPeace::DefinitionProxy::ResourceMethodDefinitions do
       let(:method_name) { :update }
       let(:url_template) { '/a/:id' }
     end
+
+    describe 'the created method' do
+      it_behaves_like 'an instance method with parameters' do
+        let(:http_verb) { :put }
+        let(:method_name) { :update }
+        let(:url_template) { '/a/:id' }
+      end
+    end
   end
 
   context '#delete' do
@@ -85,6 +133,14 @@ describe RESTinPeace::DefinitionProxy::ResourceMethodDefinitions do
       let(:method_name) { :destroy }
       let(:url_template) { '/a/:id' }
     end
+
+    describe 'the created method' do
+      it_behaves_like 'an instance method without parameters' do
+        let(:http_verb) { :delete }
+        let(:method_name) { :destroy }
+        let(:url_template) { '/a/:id' }
+      end
+    end
   end
 
 end

data/spec/rest_in_peace/definition_proxy_spec.rb

@@ -1,9 +1,12 @@
+require 'rest_in_peace'
 require 'rest_in_peace/definition_proxy'
+require 'ostruct'
 
 describe RESTinPeace::DefinitionProxy do
   let(:resource_definitions) { object_double(RESTinPeace::DefinitionProxy::ResourceMethodDefinitions) }
   let(:collection_definitions) { object_double(RESTinPeace::DefinitionProxy::CollectionMethodDefinitions) }
-  let(:target) { }
+  let(:attributes_definitions) { object_double(RESTinPeace::DefinitionProxy::AttributesDefinitions) }
+  let(:target) { double('Target') }
   let(:proxy) { RESTinPeace::DefinitionProxy.new(target) }
   let(:test_proc) { ->() {} }
 
@@ -14,6 +17,8 @@ describe RESTinPeace::DefinitionProxy do
       to receive(:new).with(target).and_return(resource_definitions)
     allow(RESTinPeace::DefinitionProxy::CollectionMethodDefinitions).
       to receive(:new).with(target).and_return(collection_definitions)
+    allow(RESTinPeace::DefinitionProxy::AttributesDefinitions).
+      to receive(:new).with(target).and_return(attributes_definitions)
   end
 
   describe '#resource' do
@@ -33,4 +38,32 @@ describe RESTinPeace::DefinitionProxy do
       subject.collection(&test_proc)
     end
   end
+
+  describe '#attributes' do
+    it 'forwards the given block to a attributes method definition' do
+      expect(attributes_definitions).to receive(:instance_eval) do |&block|
+        expect(block).to be_instance_of(Proc)
+      end
+      subject.attributes(&test_proc)
+    end
+  end
+
+  describe '#namespace_attributes_with' do
+    let(:target) do
+      Class.new do
+        include RESTinPeace
+      end
+    end
+    it 'configures the namespace' do
+      expect { subject.namespace_attributes_with(:blubb) }.
+        to change { target.rip_namespace }.from(nil).to(:blubb)
+    end
+  end
+
+  describe '#acts_as_active_model' do
+    it 'includes RESTinPeace::ActiveModelAPI' do
+      expect(target).to receive(:include).with(RESTinPeace::ActiveModelAPI)
+      subject.acts_as_active_model
+    end
+  end
 end

data/spec/rest_in_peace/response_converter_spec.rb

@@ -1,3 +1,4 @@
+require 'rest_in_peace'
 require 'rest_in_peace/response_converter'
 require 'ostruct'
 
@@ -6,6 +7,16 @@ describe RESTinPeace::ResponseConverter do
   let(:element2) { { name: 'test2' } }
   let(:response) { OpenStruct.new(body: response_body) }
   let(:converter) { RESTinPeace::ResponseConverter.new(response, klass) }
+  let(:extended_class) do
+    Class.new do
+      include RESTinPeace
+      rest_in_peace do
+        attributes do
+          read :name
+        end
+      end
+    end
+  end
 
   describe '#result' do
     subject { converter.result }
@@ -13,13 +24,14 @@ describe RESTinPeace::ResponseConverter do
     shared_examples_for 'an array input' do
       let(:response_body) { [element1, element2] }
       specify { expect(subject).to be_instance_of(Array) }
-      specify { expect(subject).to eq([OpenStruct.new(name: 'test1'), OpenStruct.new(name: 'test2')]) }
+      specify { expect(subject.first).to be_instance_of(extended_class) }
+      specify { expect(subject.map(&:name)).to eq(%w(test1 test2)) }
     end
 
     shared_examples_for 'a hash input' do
       let(:response_body) { element1 }
-      specify { expect(subject).to be_instance_of(OpenStruct) }
-      specify { expect(subject).to eq(OpenStruct.new(name: 'test1')) }
+      specify { expect(subject).to be_instance_of(extended_class) }
+      specify { expect(subject.name).to eq('test1') }
     end
 
     shared_examples_for 'a string input' do
@@ -28,8 +40,13 @@ describe RESTinPeace::ResponseConverter do
       specify { expect(subject).to eq('yolo binary stuff') }
     end
 
+    shared_examples_for 'an unknown input do' do
+      let(:response_body) { Object }
+      specify { expect { subject }.to raise_error(RESTinPeace::ResponseConverter::UnknownConvertStrategy) }
+    end
+
     context 'given type is a class' do
-      let(:klass) { OpenStruct }
+      let(:klass) { extended_class }
       context 'input is an array' do
         it_behaves_like 'an array input'
       end
@@ -44,7 +61,7 @@ describe RESTinPeace::ResponseConverter do
     end
 
     context 'given type is an instance' do
-      let(:klass) { OpenStruct.new }
+      let(:klass) { extended_class.new }
       context 'input is an array' do
         it_behaves_like 'an array input'
       end

data/spec/rest_in_peace/template_sanitizer_spec.rb

@@ -19,6 +19,18 @@ describe RESTinPeace::TemplateSanitizer do
       specify { expect(subject).to eq('/a/1/b/2') }
     end
 
+    context 'tokens with substrings' do
+      let(:params) { { element: 'asd', element_id: 1 } }
+      let(:url_template) { '/a/:element/b/:element_id' }
+      specify { expect(subject).to eq('/a/asd/b/1') }
+    end
+
+    context 'tokens with substrings, reverse order' do
+      let(:params) { { element: 'asd', element_id: 1 } }
+      let(:url_template) { '/a/:element_id/b/:element' }
+      specify { expect(subject).to eq('/a/1/b/asd') }
+    end
+
     context 'incomplete params' do
       let(:params) { {} }
       let(:url_template) { '/a/:id' }