rspec-grape-entity 0.1.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rspec-grape-entity.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rspec_grape_entity"

data/lib/rspec_grape_entity/describe_exposure.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module DescribeExposure
+        # Creates a group named by the entity exposure `attribute`.
+        #
+        # @example
+        #
+        #   class MyEntity < Grape::Entity
+        #     expose :size, safe: true
+        #     expose :name do
+        #       expose :first_name, as: :first
+        #       expose :last_name, as: :last
+        #     end
+        #   end
+        #
+        #   # This ...
+        #   describe MyEntity, type: :entity do
+        #     describe_exposure :size do
+        #       ...
+        #     end
+        #   end
+        #
+        #   # ... generates the same runtime structure as this:
+        #   describe MyEntity, type: :entity do
+        #     describe "size" do
+        #       let(:entity) { described_class }
+        #       let(:exposure) { entity.find_exposure :size }
+        #
+        #       ...
+        #     end
+        #   end
+        #
+        # The attribute can be a `Symbol` or a `String`. Given a `String`
+        # with dots, the result is as though you concatenated that `String`
+        # onto the entities nested exposures.
+        #
+        # @example
+        #
+        #   describe MyEntity, type: :entity do
+        #     describe_exposure "name.first_name" do
+        #       ...
+        #     end
+        #   end
+        #
+        # With an implicit exposure, `is_expected` can be used as an alternative
+        # to `should` (e.g. for one-liner use).
+        #
+        # @example
+        #
+        #   describe MyEntity do
+        #     describe_exposure :size do
+        #       it { should be_safe }
+        #       it { is_expected.to be_safe }
+        #     end
+        #   end
+        def describe_exposure(attribute, *options, &block)
+          raise "Block not given" unless block_given?
+
+          options << {} unless options.last.is_a?(Hash)
+          describe_caller = options.last.fetch(:caller) do
+            caller.reject { |file_line| file_line =~ %r{/lib/rspec_grape_entity/describe_exposure} }
+          end
+
+          parent_described_class = described_class
+
+          describe attribute, caller: describe_caller do
+            include RSpec::Grape::Entity::Matchers::BeAExposureTypeMatcher
+            include RSpec::Grape::Entity::Matchers::BeMergedMatcher
+            include RSpec::Grape::Entity::Matchers::BeSafeMatcher
+            include RSpec::Grape::Entity::Matchers::BeUsingClassMatcher
+            include RSpec::Grape::Entity::Matchers::HaveConditionsMetMatcher
+            include RSpec::Grape::Entity::Matchers::HaveFormattingMatcher
+            include RSpec::Grape::Entity::Matchers::HaveKeyMatcher
+            include RSpec::Grape::Entity::Matchers::IncludeDocumentationMatcher
+            include RSpec::Grape::Entity::Matchers::OverrideExposureMatcher
+
+            let(:described_class) { parent_described_class }
+            let(:entity) { described_class } unless method_defined? :entity
+
+            let(:__attribute_exposure) do
+              exposure_chain = attribute.to_s.split(".")
+              exposure = entity.find_exposure exposure_chain.shift.to_sym
+              exposure_chain.inject(exposure) do |inner_exposure, attr|
+                inner_exposure.find_nested_exposure attr.to_sym
+              end
+            end
+
+            # rubocop:disable Lint/NestedMethodDefinition
+            def is_expected
+              expect(__attribute_exposure)
+            end
+
+            def will(matcher = nil, message = nil)
+              raise ArgumentError, "`will` only supports block expectations" unless matcher.supports_block_expectations?
+
+              expect { __attribute_exposure }.to matcher, message
+            end
+
+            def will_not(matcher = nil, message = nil)
+              unless matcher.supports_block_expectations?
+                raise ArgumentError, "`will_not` only supports block expectations"
+              end
+
+              expect { __attribute_exposure }.to_not matcher, message
+            end
+
+            def should(matcher = nil, message = nil)
+              RSpec::Expectations::PositiveExpectationHandler.handle_matcher(__attribute_exposure, matcher, message)
+            end
+
+            def should_not(matcher = nil, message = nil)
+              RSpec::Expectations::NegativeExpectationHandler.handle_matcher(__attribute_exposure, matcher, message)
+            end
+            # rubocop:enable Lint/NestedMethodDefinition
+
+            instance_eval(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/dsl.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module DSL
+        def self.included(klass)
+          klass.class_eval do
+            extend DescribeExposure
+            extend ItsExposure
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/its_exposure.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module ItsExposure
+        # Creates a nested example group named by the entity exposure `attribute`,
+        # and then generates an example using the submitted block.
+        #
+        # @example
+        #
+        #   class MyEntity < Grape::Entity
+        #     expose :size, safe: true
+        #     expose :name do
+        #       expose :first_name, as: :first
+        #       expose :last_name, as: :last
+        #     end
+        #   end
+        #
+        #   # This ...
+        #   describe MyEntity do
+        #     its_exposure(:size) { is_expected.to be_safe }
+        #   end
+        #
+        #   # ... generates the same runtime structure as this:
+        #   describe MyEntity do
+        #     describe "size" do
+        #       let(:entity) { described_class }
+        #
+        #       it "is_expected.to be_safe" do
+        #         exposure = entity.find_exposure :size
+        #         expect(exposure).to be_safe
+        #       end
+        #     end
+        #   end
+        #
+        # The attribute can be a `Symbol` or a `String`. Given a `String`
+        # with dots, the result is as though you concatenated that `String`
+        # onto the entities nested exposures.
+        #
+        # @example
+        #
+        #   describe MyEntity do
+        #     its_exposure("name.first_name") { should have_key :first }
+        #   end
+        #
+        # With an implicit exposure, `is_expected` can be used as an alternative
+        # to `should` (e.g. for one-liner use).
+        #
+        # @example
+        #
+        #   describe MyEntity do
+        #     its_exposure(:size) { is_expected.to eq(0) }
+        #   end
+        def its_exposure(attribute, *options, &block)
+          its_caller = caller.reject { |file_line| file_line =~ %r{/lib/rspec_grape_entity/its_exposure} }
+
+          describe_exposure attribute, caller: its_caller do
+            options << {} unless options.last.is_a?(Hash)
+            options.last.merge!(caller: its_caller)
+
+            if block
+              example(nil, *options, &block)
+            else
+              example(nil, *options) { is_expected.not_to be_nil }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/be_a_exposure_type_matcher.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module BeAExposureTypeMatcher
+          extend RSpec::Matchers::DSL
+
+          EXPOSURE_TYPES = %i[block delegator formatter_block formatter nesting represent].freeze
+
+          matcher :be_a_exposure_type do |expected|
+            include MatcherHelpers
+
+            match { |actual| actual.is_a? exposure_type(expected) }
+            description { "be exposure type #{expected}" }
+            failure_message { |actual| "expect that #{actual} to be a #{expected} exposure" }
+          end
+
+          EXPOSURE_TYPES.each do |type|
+            matcher :"be_a_#{type}_exposure" do
+              include MatcherHelpers
+
+              match { |actual| actual.is_a? exposure_type(type) }
+              description { "be a #{type} exposure" }
+              failure_message { |actual| "expect that #{actual} to be a #{type} exposure" }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/be_merged_matcher.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module BeMergedMatcher
+          extend RSpec::Matchers::DSL
+
+          matcher :be_merged do
+            include MatcherHelpers
+
+            match { |actual| exposure_attribute(actual, :for_merge) }
+            description { "be merged" }
+            failure_message { |actual| "expect that #{actual} would merge contents" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/be_safe_matcher.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module BeSafeMatcher
+          extend RSpec::Matchers::DSL
+
+          matcher :be_safe do
+            include MatcherHelpers
+
+            match { |actual| exposure_attribute(actual, :is_safe) }
+            description { "be safe" }
+            failure_message { |actual| "expect that #{actual} to be safe" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/be_using_class_matcher.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module BeUsingClassMatcher
+          extend RSpec::Matchers::DSL
+
+          matcher :be_using_class do |expected|
+            include MatcherHelpers
+
+            match { |actual| expect(exposure_attribute(actual, :using_class)).to be expected }
+            description { "be using entity class #{entity_class_name expected}" }
+            failure_message { |actual| "expect that #{actual} would be using class #{entity_class_name expected}" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/have_conditions_met_matcher.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module HaveConditionsMetMatcher
+          extend RSpec::Matchers::DSL
+
+          matcher :have_conditions_met do |object|
+            include MatcherHelpers
+
+            match do |actual|
+              entity_instance = entity.new object
+              actual.conditions_met? entity_instance, options
+            end
+
+            description { "have the conditions met" }
+
+            failure_message do |actual|
+              "expect that #{actual} would have the conditions met for object #{object} with options #{options}"
+            end
+
+            chain :with_options do |options|
+              @options = options
+            end
+
+            def options
+              @options ||= {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/have_formatting_matcher.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module HaveFormattingMatcher
+          extend RSpec::Matchers::DSL
+
+          matcher :have_formatting do |expected|
+            include MatcherHelpers
+
+            match do |actual|
+              if actual.is_a? ::Grape::Entity::Exposure::FormatterBlockExposure
+                instance = entity.new object
+                actual.value(instance, {}) == expected
+              else
+                exposure_attribute(actual, :format_with) == expected
+              end
+            end
+
+            description { "have the formatting #{expected}" }
+
+            failure_message do |actual|
+              if actual.is_a? ::Grape::Entity::Exposure::FormatterBlockExposure
+                instance = entity.new object
+                "expect that \"#{actual.value instance, {}}\" would have the formatting \"#{expected}\""
+              else
+                "expect that \"#{actual}\" would have the formatting \"#{expected}\""
+              end
+            end
+
+            chain :with_object, :object
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/have_key_matcher.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module HaveKeyMatcher
+          extend RSpec::Matchers::DSL
+
+          matcher :have_key do |expected|
+            include MatcherHelpers
+
+            match { |actual| exposure_attribute(actual, :key) == expected }
+            description { "have the key #{expected}" }
+            failure_message { |actual| "expect that #{actual} would have the key #{expected}" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/have_root_matcher.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module HaveRootMatcher
+          extend RSpec::Matchers::DSL
+
+          matcher :have_root do |plural|
+            include MatcherHelpers
+
+            match do |actual|
+              actual_plural = actual.root_element :collection_root
+              actual_singular = actual.root_element :root
+
+              values_match?(plural, actual_plural) &&
+                values_match?(singular, actual_singular)
+            end
+
+            description { "have the formatting #{expected}" }
+
+            failure_message do |actual|
+              "expect that \"#{actual}\" would have the root collection \"#{plural}\" and root \"#{singular}\""
+            end
+
+            chain :with_singular, :singular
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/include_documentation_matcher.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module IncludeDocumentationMatcher
+          extend RSpec::Matchers::DSL
+
+          matcher :include_documentation do |expected|
+            include MatcherHelpers
+
+            match { |actual| expect(documentation(actual)).to include expected }
+            match_when_negated { |actual| expect(documentation(actual)).to_not include expected }
+            description { "include documentation #{expected}" }
+            failure_message { |actual| "expect #{documentation actual} would include the documentation #{expected}" }
+
+            def documentation(actual)
+              exposure_attribute(actual, :documentation) || {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/matcher_helpers.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module MatcherHelpers
+          def entity_class_name(entity)
+            entity.try(:name) || entity.class.name
+          end
+
+          def exposure_attribute(exposure, name)
+            exposure.send name
+          end
+
+          def exposure_type(type)
+            type = type.to_s.split("_").map { |w| w[0].upcase + w[1..] }.join
+            Object.const_get "Grape::Entity::Exposure::#{type}Exposure"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/matchers/override_exposure_matcher.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Grape
+    module Entity
+      module Matchers
+        module OverrideExposureMatcher
+          extend RSpec::Matchers::DSL
+
+          matcher :override_exposure do
+            include MatcherHelpers
+
+            match { |actual| exposure_attribute(actual, :override) }
+            description { "override exposure" }
+            failure_message { |actual| "expect that #{actual} would override exposure" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_grape_entity/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RSpecGrapeEntity
+  VERSION = "0.1.0"
+end

data/lib/rspec_grape_entity.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "grape-entity"
+require "rspec/expectations"
+
+require_relative "rspec_grape_entity/matchers/matcher_helpers"
+require_relative "rspec_grape_entity/matchers/be_a_exposure_type_matcher"
+require_relative "rspec_grape_entity/matchers/be_merged_matcher"
+require_relative "rspec_grape_entity/matchers/be_safe_matcher"
+require_relative "rspec_grape_entity/matchers/be_using_class_matcher"
+require_relative "rspec_grape_entity/matchers/have_conditions_met_matcher"
+require_relative "rspec_grape_entity/matchers/have_formatting_matcher"
+require_relative "rspec_grape_entity/matchers/have_key_matcher"
+require_relative "rspec_grape_entity/matchers/have_root_matcher"
+require_relative "rspec_grape_entity/matchers/include_documentation_matcher"
+require_relative "rspec_grape_entity/matchers/override_exposure_matcher"
+require_relative "rspec_grape_entity/describe_exposure"
+require_relative "rspec_grape_entity/its_exposure"
+require_relative "rspec_grape_entity/dsl"
+require_relative "rspec_grape_entity/version"
+
+RSpec.configure do |rspec|
+  rspec.extend RSpec::Grape::Entity::DescribeExposure, type: :grape_entity
+  rspec.extend RSpec::Grape::Entity::ItsExposure, type: :grape_entity
+  rspec.include RSpec::Grape::Entity::Matchers::HaveRootMatcher, type: :grape_entity
+  rspec.backtrace_exclusion_patterns << %r{/lib/rspec_grape_entity/describe_exposure}
+  rspec.backtrace_exclusion_patterns << %r{/lib/rspec_grape_entity/its_exposure}
+end

data/rspec-grape-entity.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rspec_grape_entity/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rspec-grape-entity"
+  spec.version = RSpecGrapeEntity::VERSION
+  spec.platform = Gem::Platform::RUBY
+  spec.authors = ["James Fawks"]
+  spec.email = ["jefawks3@gmail.com"]
+  spec.summary = "RSpec extension gem for grape-entity"
+  spec.description = 'Provides "it_exposes" and "describe_exposure" methods to test Grape Entities'
+  spec.homepage = "https://github.com/jefawks3/rspec-grape-entity"
+  spec.license = "MIT"
+
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/jefawks3/rspec-grape-entity/issues",
+    "changelog_uri" => "https://github.com/jefawks3/rspec-grape-entity/releases",
+    "documentation_uri" => "https://github.com/jefawks3/rspec-grape-entity",
+    "source_code_uri" => "https://github.com/jefawks3/rspec-grape-entity"
+  }
+
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.add_runtime_dependency "grape-entity", ">= 0.10.0"
+  spec.add_runtime_dependency "rspec-core", ">= 3.0.0"
+  spec.add_runtime_dependency "rspec-expectations", ">= 3.0.0"
+
+  spec.add_development_dependency "bundler",  "> 1.3.0"
+  spec.add_development_dependency "rake",     "~> 13.0.0"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec}/*`.split("\n")
+  spec.require_paths = ["lib"]
+end

data/spec/describe_exposure_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe RSpec::Grape::Entity::DescribeExposure do
+  extend RSpec::Grape::Entity::DescribeExposure
+
+  let(:entity) { TestEntity }
+
+  describe_exposure :id do
+    it { is_expected.to be_a Grape::Entity::Exposure::DelegatorExposure }
+  end
+
+  describe_exposure "id" do
+    it { is_expected.to be_a Grape::Entity::Exposure::DelegatorExposure }
+  end
+
+  describe_exposure "unknown" do
+    it { is_expected.to be_nil }
+  end
+
+  describe_exposure "permissions.read" do
+    it { is_expected.to be_a Grape::Entity::Exposure::DelegatorExposure }
+  end
+
+  describe_exposure "unknown.unknown" do
+    it { expect { __attribute_exposure }.to raise_error NoMethodError }
+  end
+end