grape-entity 1.0.2 → 1.0.3

data/spec/grape_entity/exposure/nesting_exposure/nested_exposures_spec.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Entity::Exposure::NestingExposure::NestedExposures do
-  subject(:nested_exposures) { described_class.new([]) }
-
-  describe '#deep_complex_nesting?(entity)' do
-    it 'is reset when additional exposure is added' do
-      subject << Grape::Entity::Exposure.new(:x, {})
-      expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-      subject.deep_complex_nesting?(subject)
-      expect(subject.instance_variable_get(:@deep_complex_nesting)).to_not be_nil
-      subject << Grape::Entity::Exposure.new(:y, {})
-      expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-    end
-
-    it 'is reset when exposure is deleted' do
-      subject << Grape::Entity::Exposure.new(:x, {})
-      expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-      subject.deep_complex_nesting?(subject)
-      expect(subject.instance_variable_get(:@deep_complex_nesting)).to_not be_nil
-      subject.delete_by(:x)
-      expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-    end
-
-    it 'is reset when exposures are cleared' do
-      subject << Grape::Entity::Exposure.new(:x, {})
-      expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-      subject.deep_complex_nesting?(subject)
-      expect(subject.instance_variable_get(:@deep_complex_nesting)).to_not be_nil
-      subject.clear
-      expect(subject.instance_variable_get(:@deep_complex_nesting)).to be_nil
-    end
-  end
-
-  describe '.delete_by' do
-    subject { nested_exposures.delete_by(*attributes) }
-
-    let(:attributes) { [:id] }
-
-    before do
-      nested_exposures << Grape::Entity::Exposure.new(:id, {})
-    end
-
-    it 'deletes matching exposure' do
-      is_expected.to eq []
-    end
-
-    context "when given attribute doesn't exists" do
-      let(:attributes) { [:foo] }
-
-      it 'deletes matching exposure' do
-        is_expected.to eq(nested_exposures)
-      end
-    end
-  end
-end

data/spec/grape_entity/exposure/represent_exposure_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Entity::Exposure::RepresentExposure do
-  subject(:exposure) { described_class.new(:foo, {}, {}, double, double) }
-
-  describe '#setup' do
-    subject { exposure.setup(using_class_name, subexposure) }
-
-    let(:using_class_name) { double(:using_class_name) }
-    let(:subexposure)      { double(:subexposure) }
-
-    it 'sets using_class_name' do
-      expect { subject }.to change(exposure, :using_class_name).to(using_class_name)
-    end
-
-    it 'sets subexposure' do
-      expect { subject }.to change(exposure, :subexposure).to(subexposure)
-    end
-
-    context 'when using_class is set' do
-      before do
-        exposure.using_class
-      end
-
-      it 'resets using_class' do
-        expect { subject }.to change(exposure, :using_class)
-      end
-    end
-  end
-end

data/spec/grape_entity/exposure_spec.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Entity::Exposure do
-  let(:fresh_class) { Class.new(Grape::Entity) }
-  let(:model) { double(attributes) }
-  let(:attributes) do
-    {
-      name: 'Bob Bobson',
-      email: 'bob@example.com',
-      birthday: Time.gm(2012, 2, 27),
-      fantasies: ['Unicorns', 'Double Rainbows', 'Nessy'],
-      characteristics: [
-        { key: 'hair_color', value: 'brown' }
-      ],
-      friends: [
-        double(name: 'Friend 1', email: 'friend1@example.com', characteristics: [], fantasies: [], birthday: Time.gm(2012, 2, 27), friends: []),
-        double(name: 'Friend 2', email: 'friend2@example.com', characteristics: [], fantasies: [], birthday: Time.gm(2012, 2, 27), friends: [])
-      ]
-    }
-  end
-  let(:entity) { fresh_class.new(model) }
-  subject { fresh_class.find_exposure(:name) }
-
-  describe '#key' do
-    it 'returns the attribute if no :as is set' do
-      fresh_class.expose :name
-      expect(subject.key(entity)).to eq :name
-    end
-
-    it 'returns the :as alias if one exists' do
-      fresh_class.expose :name, as: :nombre
-      expect(subject.key(entity)).to eq :nombre
-    end
-
-    it 'returns the result if :as is a proc' do
-      fresh_class.expose :name, as: proc { object.name.reverse }
-      expect(subject.key(entity)).to eq(model.name.reverse)
-    end
-
-    it 'returns the result if :as is a lambda' do
-      fresh_class.expose :name, as: ->(obj, _opts) { obj.name.reverse }
-      expect(subject.key(entity)).to eq(model.name.reverse)
-    end
-  end
-
-  describe '#conditions_met?' do
-    it 'only passes through hash :if exposure if all attributes match' do
-      fresh_class.expose :name, if: { condition1: true, condition2: true }
-
-      expect(subject.conditions_met?(entity, {})).to be false
-      expect(subject.conditions_met?(entity, condition1: true)).to be false
-      expect(subject.conditions_met?(entity, condition1: true, condition2: true)).to be true
-      expect(subject.conditions_met?(entity, condition1: false, condition2: true)).to be false
-      expect(subject.conditions_met?(entity, condition1: true, condition2: true, other: true)).to be true
-    end
-
-    it 'looks for presence/truthiness if a symbol is passed' do
-      fresh_class.expose :name, if: :condition1
-
-      expect(subject.conditions_met?(entity, {})).to be false
-      expect(subject.conditions_met?(entity, condition1: true)).to be true
-      expect(subject.conditions_met?(entity, condition1: false)).to be false
-      expect(subject.conditions_met?(entity, condition1: nil)).to be false
-    end
-
-    it 'looks for absence/falsiness if a symbol is passed' do
-      fresh_class.expose :name, unless: :condition1
-
-      expect(subject.conditions_met?(entity, {})).to be true
-      expect(subject.conditions_met?(entity, condition1: true)).to be false
-      expect(subject.conditions_met?(entity, condition1: false)).to be true
-      expect(subject.conditions_met?(entity, condition1: nil)).to be true
-    end
-
-    it 'only passes through proc :if exposure if it returns truthy value' do
-      fresh_class.expose :name, if: ->(_, opts) { opts[:true] }
-
-      expect(subject.conditions_met?(entity, true: false)).to be false
-      expect(subject.conditions_met?(entity, true: true)).to be true
-    end
-
-    it 'only passes through hash :unless exposure if any attributes do not match' do
-      fresh_class.expose :name, unless: { condition1: true, condition2: true }
-
-      expect(subject.conditions_met?(entity, {})).to be true
-      expect(subject.conditions_met?(entity, condition1: true)).to be true
-      expect(subject.conditions_met?(entity, condition1: true, condition2: true)).to be false
-      expect(subject.conditions_met?(entity, condition1: false, condition2: true)).to be true
-      expect(subject.conditions_met?(entity, condition1: true, condition2: true, other: true)).to be false
-      expect(subject.conditions_met?(entity, condition1: false, condition2: false)).to be true
-    end
-
-    it 'only passes through proc :unless exposure if it returns falsy value' do
-      fresh_class.expose :name, unless: ->(_, opts) { opts[:true] == true }
-
-      expect(subject.conditions_met?(entity, true: false)).to be true
-      expect(subject.conditions_met?(entity, true: true)).to be false
-    end
-  end
-end

data/spec/grape_entity/hash_spec.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Entity do
-  it 'except option for nested entity', :aggregate_failures do
-    module EntitySpec
-      class Address < Grape::Entity
-        expose :post, if: :full
-        expose :city
-        expose :street
-        expose :house
-      end
-
-      class AddressWithString < Grape::Entity
-        self.hash_access = :string
-        expose :post, if: :full
-        expose :city
-        expose :street
-        expose :house, expose_nil: false
-      end
-
-      class Company < Grape::Entity
-        expose :full_name, if: :full
-        expose :name
-        expose :address do |c, o|
-          Address.represent c[:address], Grape::Entity::Options.new(o.opts_hash.except(:full))
-        end
-      end
-
-      class CompanyWithString < Grape::Entity
-        self.hash_access = :string
-        expose :full_name, if: :full
-        expose :name
-        expose :address do |c, o|
-          AddressWithString.represent c['address'], Grape::Entity::Options.new(o.opts_hash.except(:full))
-        end
-      end
-    end
-
-    company = {
-      full_name: 'full_name',
-      name: 'name',
-      address: {
-        post: '123456',
-        city: 'city',
-        street: 'street',
-        house: 'house',
-        something_else: 'something_else'
-      }
-    }
-
-    company_with_string = {
-      'full_name' => 'full_name',
-      'name' => 'name',
-      'address' => {
-        'post' => '123456',
-        'city' => 'city',
-        'street' => 'street',
-        'house' => 'house',
-        'something_else' => 'something_else'
-      }
-    }
-
-    company_without_house_with_string = {
-      'full_name' => 'full_name',
-      'name' => 'name',
-      'address' => {
-        'post' => '123456',
-        'city' => 'city',
-        'street' => 'street',
-        'something_else' => 'something_else'
-      }
-    }
-
-    expect(EntitySpec::CompanyWithString.represent(company_with_string).serializable_hash).to eq \
-      company.slice(:name).merge(address: company[:address].slice(:city, :street, :house))
-
-    expect(EntitySpec::CompanyWithString.represent(company_without_house_with_string).serializable_hash).to eq \
-      company.slice(:name).merge(address: company[:address].slice(:city, :street))
-
-    expect(EntitySpec::CompanyWithString.represent(company_with_string, full: true).serializable_hash).to eq \
-      company.slice(:full_name, :name).merge(address: company[:address].slice(:city, :street, :house))
-
-    expect(EntitySpec::Company.represent(company).serializable_hash).to eq \
-      company.slice(:name).merge(address: company[:address].slice(:city, :street, :house))
-
-    expect(EntitySpec::Company.represent(company, full: true).serializable_hash).to eq \
-      company.slice(:full_name, :name).merge(address: company[:address].slice(:city, :street, :house))
-  end
-end

data/spec/grape_entity/json_spec.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Entity::Json do
-  subject { described_class }
-
-  it { is_expected.to eq(JSON) }
-end

data/spec/grape_entity/options_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Entity::Options do
-  module EntitySpec
-    class Crystalline
-      attr_accessor :prop1, :prop2, :prop3
-
-      def initialize
-        @prop1 = 'value1'
-        @prop2 = 'value2'
-        @prop3 = 'value3'
-      end
-    end
-
-    class CrystallineEntity < Grape::Entity
-      expose :prop1, if: ->(_, options) { options.fetch(:signal) }
-      expose :prop2, if: ->(_, options) { options.fetch(:beam, 'destructive') == 'destructive' }
-    end
-  end
-
-  context '#fetch' do
-    it 'without passing in a required option raises KeyError' do
-      expect { EntitySpec::CrystallineEntity.represent(EntitySpec::Crystalline.new).as_json }.to raise_error KeyError
-    end
-
-    it 'passing in a required option will expose the values' do
-      crystalline_entity = EntitySpec::CrystallineEntity.represent(EntitySpec::Crystalline.new, signal: true)
-      expect(crystalline_entity.as_json).to eq(prop1: 'value1', prop2: 'value2')
-    end
-
-    it 'with an option that is not default will not expose that value' do
-      crystalline_entity = EntitySpec::CrystallineEntity.represent(EntitySpec::Crystalline.new, signal: true, beam: 'intermittent')
-      expect(crystalline_entity.as_json).to eq(prop1: 'value1')
-    end
-  end
-
-  context '#dig', skip: !{}.respond_to?(:dig) do
-    let(:model_class) do
-      Class.new do
-        attr_accessor :prop1
-
-        def initialize
-          @prop1 = 'value1'
-        end
-      end
-    end
-
-    let(:entity_class) do
-      Class.new(Grape::Entity) do
-        expose :prop1, if: ->(_, options) { options.dig(:first, :second) == :nested }
-      end
-    end
-
-    it 'without passing in a expected option hide the value' do
-      entity = entity_class.represent(model_class.new, first: { invalid: :nested })
-      expect(entity.as_json).to eq({})
-    end
-
-    it 'passing in a expected option will expose the values' do
-      entity = entity_class.represent(model_class.new, first: { second: :nested })
-      expect(entity.as_json).to eq(prop1: 'value1')
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'simplecov'
-require 'coveralls'
-
-# This works around the hash extensions not being automatically included in ActiveSupport < 4
-require 'active_support/version'
-require 'active_support/core_ext/hash' if ActiveSupport::VERSION &&
-                                          ActiveSupport::VERSION::MAJOR &&
-                                          ActiveSupport::VERSION::MAJOR < 4
-
-# Skip code covarge on Ruby >= 3.1
-# See https://github.com/simplecov-ruby/simplecov/issues/1003
-unless RUBY_VERSION >= '3.1'
-  SimpleCov.start do
-    add_filter 'spec/'
-  end
-
-  Coveralls.wear! unless RUBY_PLATFORM.eql? 'java'
-end
-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'support'))
-
-require 'rubygems'
-require 'bundler'
-
-Bundler.require :default, :test
-
-RSpec.configure(&:raise_errors_for_deprecations!)