grape-roar 0.4.0 → 0.4.1

data/lib/grape/roar/extensions/relations/validations/misc.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Validations
+          module Misc
+            def invalid_relation(valid, invalid)
+              raise Exceptions::InvalidRelationError,
+                    "Expected #{valid}, got #{invalid}!"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/roar/extensions/relations/validations/mongoid.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Validations
+          module Mongoid
+            include Validations::Misc
+
+            def belongs_to_valid?(relation)
+              relation = klass.reflect_on_association(relation)
+
+              return true if relation[:relation] ==
+                             ::Mongoid::Relations::Referenced::In
+
+              invalid_relation(
+                ::Mongoid::Relations::Referenced::In, relation[:relation]
+              )
+            end
+
+            def embeds_many_valid?(relation)
+              relation = klass.reflect_on_association(relation)
+
+              return true if relation[:relation] ==
+                             ::Mongoid::Relations::Embedded::Many
+
+              invalid_relation(
+                ::Mongoid::Relations::Embedded::Many, relation[:relation]
+              )
+            end
+
+            def embeds_one_valid?(relation)
+              relation = klass.reflect_on_association(relation)
+
+              return true if relation[:relation] ==
+                             ::Mongoid::Relations::Embedded::One
+
+              invalid_relation(
+                ::Mongoid::Relations::Embedded::One, relation[:relation]
+              )
+            end
+
+            # rubocop:disable Style/PredicateName
+            def has_many_valid?(relation)
+              relation = klass.reflect_on_association(relation)
+
+              return true if relation[:relation] ==
+                             ::Mongoid::Relations::Referenced::Many
+
+              invalid_relation(
+                ::Mongoid::Relations::Referenced::Many, relation[:relation]
+              )
+            end
+            # rubocop:enable Style/PredicateName
+
+            # rubocop:disable Style/PredicateName
+            def has_and_belongs_to_many_valid?(relation)
+              relation = klass.reflect_on_association(relation)
+
+              return true if relation[:relation] ==
+                             ::Mongoid::Relations::Referenced::ManyToMany
+
+              invalid_relation(
+                ::Mongoid::Relations::Referenced::ManyToMany,
+                relation[:relation]
+              )
+            end
+            # rubocop:enable Style/PredicateName
+
+            # rubocop:disable Style/PredicateName
+            def has_one_valid?(relation)
+              relation = klass.reflect_on_association(relation)
+
+              return true if relation[:relation] ==
+                             ::Mongoid::Relations::Referenced::One
+
+              invalid_relation(
+                ::Mongoid::Relations::Referenced::One, relation[:relation]
+              )
+            end
+            # rubocop:enable Style/PredicateName
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/roar/formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Formatter
     module Roar

data/lib/grape/roar/representer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Roar
     module Representer

data/lib/grape/roar/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Grape
   module Roar
-    VERSION = '0.4.0'
+    VERSION = '0.4.1'
   end
 end

data/spec/config/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  clients:
+    default:
+      database: grape_roar_test
+      hosts:
+        - localhost:27017

data/spec/decorator_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+
 
 describe Grape::Roar::Decorator do
   subject do

data/spec/extensions/relations/adapters/active_record_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+describe Grape::Roar::Extensions::Relations::Adapters::ActiveRecord, active_record: true do
+  let(:model) { Class.new(ActiveRecord::Base) }
+  subject { described_class.new(model) }
+
+  context '.valid_for?' do
+    it 'is only valid for ActiveRecord::Base descendants' do
+      expect(described_class.valid_for?(model)).to eql(true)
+      expect(described_class.valid_for?('foo')).to eql(false)
+    end
+  end
+
+  context '#collection_methods' do
+    it 'should return all collection methods' do
+      expect(subject.collection_methods)
+        .to match_array(%i[has_many has_and_belongs_to_many])
+    end
+  end
+
+  context '#single_entity_methods' do
+    it 'should return all single entity methods' do
+      expect(subject.single_entity_methods)
+        .to match_array(%i[has_one belongs_to])
+    end
+  end
+end

data/spec/extensions/relations/adapters/adapters_module_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+describe Grape::Roar::Extensions::Relations::Adapters, active_record: true do
+  context '.for' do
+    let(:model) { Class.new(ActiveRecord::Base) }
+
+    it 'looks up the correct adapter for a given class' do
+      expect(described_class.for(model))
+        .to be_an_instance_of(described_class::ActiveRecord)
+    end
+  end
+end

data/spec/extensions/relations/adapters/mongoid_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+describe Grape::Roar::Extensions::Relations::Adapters::Mongoid, mongoid: true do
+  let(:model) { Class.new.tap { |c| c.include(::Mongoid::Document) } }
+  subject { described_class.new(model) }
+
+  context '.valid_for?' do
+    it 'is only valid for classes that mixed in Mongoid::Document' do
+      expect(described_class.valid_for?(model)).to eql(true)
+      expect(described_class.valid_for?('foo')).to eql(false)
+    end
+  end
+
+  context '#collection_methods' do
+    it 'should return all collection methods' do
+      expect(subject.collection_methods)
+        .to match_array(%i[embeds_many has_many has_and_belongs_to_many])
+    end
+  end
+
+  context '#single_entity_methods' do
+    it 'should return all single entity methods' do
+      expect(subject.single_entity_methods)
+        .to match_array(%i[has_one belongs_to embeds_one])
+    end
+  end
+end

data/spec/extensions/relations/dsl_methods_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+describe Grape::Roar::Extensions::Relations::DSLMethods do
+  subject do
+    Class.new.tap { |c| c.singleton_class.include(described_class) }
+  end
+
+  context '#link_relation' do
+    let(:relation) { double }
+    let(:collection) { false }
+
+    before do
+      allow(subject).to receive(:link)
+      allow(subject).to receive(:links)
+    end
+
+    after { subject.link_relation(relation, collection) }
+
+    it 'calls the correct method' do
+      expect(subject).to receive(:link).with(relation)
+    end
+
+    context 'with a collection of objects' do
+      let(:collection) { true }
+
+      it 'uses the links method' do
+        expect(subject).to receive(:links).with(relation)
+      end
+    end
+  end
+
+  context '#name_for_represented' do
+    let(:represented) { double }
+
+    after { subject.name_for_represented(represented) }
+
+    it 'calls the methods correctly' do
+      expect(subject).to receive_message_chain(
+        :relational_mapper, :adapter, :name_for_represented
+      ).with(represented)
+    end
+  end
+
+  context 'with relational mapper' do
+    let(:relational_mapper) { double }
+
+    before do
+      allow(subject).to receive(:relational_mapper)
+        .and_return(relational_mapper)
+    end
+
+    context '#relation' do
+      let(:relation_name) { double }
+      let(:relation_kind) { :has_many }
+      let(:opts) { {} }
+
+      after { subject.relation(relation_kind, relation_name, opts) }
+
+      it 'correctly stores the info in mapper' do
+        expect(relational_mapper).to receive(:[]=).with(
+          relation_name, opts.merge(relation_kind: relation_kind)
+        )
+      end
+    end
+
+    context '#link_self' do
+      after { subject.link_self }
+
+      it 'calls the method correctly' do
+        expect(relational_mapper).to receive(:[]=).with(
+          :self, relation_kind: :self
+        )
+      end
+    end
+  end
+
+  context '#map_base_url' do
+    let(:grape_request) do
+      OpenStruct.new(base_url: 'foo/', script_name: 'v1')
+    end
+
+    let(:opts) { { env: double } }
+
+    before do
+      allow(Grape::Request).to receive(:new).with(opts[:env])
+                                            .and_return(grape_request)
+    end
+
+    it 'provides a default implementation' do
+      expect(subject.map_base_url.call(opts)).to eql('foo/v1')
+    end
+
+    context 'with user provided block' do
+      let(:block) { proc {} }
+
+      it 'should return the user block' do
+        subject.map_base_url(&block)
+        expect(subject.map_base_url).to eql(block)
+      end
+    end
+  end
+
+  context '#map_self_url' do
+    after { subject.map_self_url }
+
+    it 'calls the correct method' do
+      expect(subject).to receive(:link).with(:self)
+    end
+  end
+
+  context '#map_resource_path' do
+    let(:object)   { OpenStruct.new(id: 4) }
+    let(:opts)     { double }
+    let(:relation) { 'baz' }
+
+    it 'provides a default implementation' do
+      expect(
+        subject.map_resource_path.call(opts, object, relation)
+      ).to eql('baz/4')
+    end
+
+    context 'with user provided block' do
+      let(:block) { proc {} }
+
+      it 'should return the user block' do
+        subject.map_resource_path(&block)
+        expect(subject.map_resource_path).to eql(block)
+      end
+    end
+  end
+
+  context '#represent' do
+    let(:object) { double }
+    let(:options) { double }
+
+    let(:relations_mapped) { false }
+
+    before do
+      expect(subject).to receive(:relations_mapped)
+        .and_return(relations_mapped)
+    end
+
+    after { subject.represent(object, options) }
+
+    it 'should map relations and invoke super' do
+      expect(subject).to receive(:map_relations).with(object)
+      expect(subject.superclass).to receive(:represent).with(object, options)
+    end
+
+    context 'with relations mapped' do
+      let(:relations_mapped) { true }
+
+      it 'should not map relations and invoke super' do
+        expect(subject).to_not receive(:map_relations).with(object)
+        expect(subject.superclass).to receive(:represent).with(object, options)
+      end
+    end
+  end
+end

data/spec/extensions/relations/mapper_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+describe Grape::Roar::Extensions::Relations::Mapper do
+  let(:entity) { double }
+  let(:klass)  { double }
+
+  subject { described_class.new(entity) }
+
+  context '#initialize' do
+    it 'assigns the correct variables' do
+      expect(subject.instance_variable_get(:@entity)).to eql(entity)
+      expect(subject.instance_variable_get(:@config)).to eql({})
+      subject
+    end
+  end
+
+  context '#adapter' do
+    let(:klass) { class_double('ActiveRecord::Base') }
+
+    before do
+      subject.instance_variable_set(:@model_klass, klass)
+    end
+
+    after { subject.adapter }
+
+    it 'should call the correct method' do
+      expect(Grape::Roar::Extensions::Relations::Adapters)
+        .to receive(:for).with(klass)
+    end
+  end
+
+  context '#decorate' do
+    let(:adapter) { double }
+    let(:config) do
+      { test_single: {
+        relation_kind: :belongs_to, embedded: true, misc_opt: 'foo'
+      },
+        test_collection: {
+          relation_kind: :has_many, embedded: true, misc_opt: 'baz'
+        } }
+    end
+
+    let(:klass) { double }
+
+    before do
+      allow(subject).to receive(:adapter).and_return(adapter)
+
+      allow(adapter).to receive(:collection_methods).and_return(%i[has_many])
+      allow(adapter).to receive(:single_entity_methods).and_return(%i[belongs_to])
+      allow(entity).to receive(:name).and_return('Foo::Bar')
+
+      subject.instance_variable_set(:@config, config)
+    end
+
+    it 'should correctly decorate the entity' do
+      expect(adapter).to receive(:belongs_to_valid?).with(
+        'test_single'
+      ).and_return(true)
+
+      expect(adapter).to receive(:has_many_valid?).with(
+        'test_collection'
+      ).and_return(true)
+
+      expect(entity).to receive(:collection).with(
+        :test_collection, config[:test_collection]
+      )
+
+      expect(entity).to receive(:property).with(
+        :test_single, config[:test_single]
+      )
+
+      subject.decorate(klass)
+      expect(subject.instance_variable_get(:@model_klass)).to eql(klass)
+    end
+
+    context 'with an invalid relation type' do
+      let(:config) do
+        { test_single: { relation_kind: :has_baz, misc_opt: 'foo' } }
+      end
+
+      it 'will raise the correct exception' do
+        expect { subject.decorate(klass) }.to raise_error(
+          Grape::Roar::Extensions::Relations::Exceptions::UnsupportedRelationError
+        )
+      end
+    end
+  end
+end