active_model_serializers_matchers 0.0.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f077a6f2b1a3a40b7ee1b140eb7bcc717a345efd
-  data.tar.gz: ecd3e42fe80ca954a55d2b6de3d7faad34dd9709
+  metadata.gz: 35a767c68d2ab67433d5bf50aba99b4c19f3943d
+  data.tar.gz: d7279bebe1091d1d3ed3dccc0d2ef71e15a2bc6d
 SHA512:
-  metadata.gz: 8234d7c88ae9b5d0075a5399df1fbf38b7d54020b77de42b9fb64547f00888c8294db376956ce31cc8b9b4ab37a10ad536d2ff81f48f7a09fc7632bd58155c2a
-  data.tar.gz: 05f2dcd60af24ee521703f6c25f9e11ec1e7d40f114955b013530f419c00140550f77f33524fa0e7020e5bfade3f4910a8737940ce8a7efd4c840529b583f6c8
+  metadata.gz: 20177840149749d3004b77bf4e7d88d010eb889c4e789202b723bad9515559eb9d1aa7afe31dc3abea2a3e95855d604425909d67023c0a1d5196264a2fc25db2
+  data.tar.gz: 279ccdf1a59374061e675fa282e568dfd7c307196167d476a61d485afe2f527e40c7b3169157f4a58422a31aa0706ecca876cfa927944b3e15c646d82eba4f28

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+before_install:
+  - gem install bundler
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - rbx-2
+  - jruby

data/README.md

@@ -1,13 +1,22 @@
 # ActiveModelSerializersMatchers
+[![Gem Version][gem_version_badge]][rubygems]
+[![Travis CI][travis_badge]][travis]
+[![Coverage Status][coverage_badge]][coverage]
+[![Code Climate][codeclimate_badge]][codeclimate]
+### RSpec Matchers for ActiveModel::Serializer Associations
 
-RSpec matchers for testing ActiveModel::Serializer
+**Note:** This gem requires `"active_model_serializers", "~> 0.8.0"`:
+- [v0.8.0](https://github.com/rails-api/active_model_serializers/tree/v0.8.0)
+- [v0.8.1](https://github.com/rails-api/active_model_serializers/tree/v0.8.1)
+- [v0.8.2](https://github.com/rails-api/active_model_serializers/tree/v0.8.2)
+- [v0.8.3](https://github.com/rails-api/active_model_serializers/tree/v0.8.3)
 
-## Installation
+### Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'active_model_serializers_matchers', '0.0.3'
+gem 'active_model_serializers_matchers', '0.2.0'
 ```
 
 And then execute:
@@ -18,64 +27,103 @@ Or install it yourself as:
 
     $ gem install active_model_serializers_matchers
 
+### Configure RSpec
+``` ruby
+RSpec.configure do |config|
+  config.include ActiveModelSerializersMatchers, :type => :serializer
+end
+```
+
 ## Usage
-### Simple `has_many` and `has_one` Associations
+
+### Associations
+
+#### has_one and has_many associations
+
+association matcher: `#have_one` and `#have_many`
+
 ``` ruby
 class ListSerializer < ActiveModel::Serializer
   has_one :title
   has_many :items
 end
 
-RSpec.describe ListSerializer do
+RSpec.describe ListSerializer, :type => :serializer do
+  subject { described_class }
   it { should have_one(:title) }
   it { should have_many(:items) }
+  it { should have_many(:cats) }
 end
 
-#=> should have one title
-#=> should have many items
+# ListSerializer
+#   should have one :title
+#   should have many :items
+#   should have many :cats (FAILED - 1)
 ```
 
-### Association Options
-#### Key
-use: `#as`
+#### key option
+
+option matcher: `#as`
+
 ``` ruby
 class ShoeRackSerializer < ActiveModel::Serializer
   has_many :shoes, key: :kicks
 end
 
-RSpec.describe ShoeRackSerializer do
+RSpec.describe ShoeRackSerializer, :type => :serializer do
+  subject { described_class }
   it { should have_many(:shoes).as(:kicks) }
+  it { should have_many(:shoes).as(:ones_and_twos) }
 end
 
-#=> should have many shoes as "kicks"
+# ShoeRackSerializer
+#   should have many :shoes as :kicks
+#   should have many :shoes as :ones_and_twos (FAILED - 1)
 ```
-#### Serializer
-use: `#serialized_with`
+
+#### serializer option
+
+option matcher: `#serialized_with`
+
 ``` ruby
+class ProductSerializer < ActiveModel::Serializer; end
+class SoupCanSerializer < ActiveModel::Serializer; end
+
 class ShoppingCartSerializer < ActiveModel::Serializer
   has_many :items, serializer: ProductSerializer
 end
 
-RSpec.describe ShoppingCartSerializer do
+RSpec.describe ShoppingCartSerializer, :type => :serializer do
+  subject { described_class }
   it { should have_many(:items).serialized_with(ProductSerializer) }
+  it { should have_many(:items).serialized_with(SoupCanSerializer) }
 end
 
-#=> should have many items serialized with ProductSerializer
+# ShoppingCartSerializer
+#   should have many :items serialized with ProductSerializer
+#   should have many :items serialized with SoupCanSerializer (FAILED - 1)
 ```
-#### Chainable
-These can be chained in any order.
+
+#### chaining multiple matchers
+
+Multiple option matchers can be chained onto an association matcher in any order.
+
 ``` ruby
+class FoodSerializer < ActiveModel::Serializer; end
+
 class MenuSerializer < ActiveModel::Serializer
-  has_many :entrees, key: dishes, serializer: FoodSerializer
+  has_many :entrees, key: :dishes, serializer: FoodSerializer
 end
 
-RSpec.describe MenuSerializer do
+RSpec.describe MenuSerializer, :type => :serializer do
+  subject { described_class }
   it { should have_many(:entrees).as(:dishes).serialized_with(FoodSerializer) }
   it { should have_many(:entrees).serialized_with(FoodSerializer).as(:dishes) }
 end
 
-#=> should have many entrees as "dishes" serialized with FoodSerializer
-#=> should have many entrees as "dishes" serialized with FoodSerializer
+# MenuSerializer
+#   should have many :entrees as :dishes serialized with FoodSerializer
+#   should have many :entrees serialized with FoodSerializer as :dishes
 ```
 
 ## Contributing
@@ -85,3 +133,15 @@ end
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+
+[gem_version_badge]: http://img.shields.io/gem/v/active_model_serializers_matchers.svg?style=flat
+[rubygems]: http://rubygems.org/gems/active_model_serializers_matchers
+
+[travis_badge]: http://img.shields.io/travis/tonyta/active_model_serializers_matchers.svg?style=flat
+[travis]: https://travis-ci.org/tonyta/active_model_serializers_matchers
+
+[coverage_badge]: https://img.shields.io/coveralls/tonyta/active_model_serializers_matchers.svg?style=flat
+[coverage]: https://coveralls.io/r/tonyta/active_model_serializers_matchers?branch=objectify-association-matchers
+
+[codeclimate_badge]: https://img.shields.io/codeclimate/github/tonyta/active_model_serializers_matchers.svg?style=flat
+[codeclimate]: https://codeclimate.com/github/tonyta/active_model_serializers_matchers

data/Rakefile

@@ -1,2 +1,7 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
+desc 'Run all specs'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/active_model_serializers_matchers.gemspec

@@ -1,4 +1,4 @@
-# coding: utf-8
+# encoding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'active_model_serializers_matchers/version'
@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = ActiveModelSerializersMatchers::VERSION
   spec.authors       = ["Tony Ta"]
   spec.email         = ["tonyta.tt@gmail.com"]
-  spec.summary       = "RSpec matchers for testing ActiveModel::Serializer"
-  spec.description   = "These matchers will allow you to test associations between serializers."
+  spec.description   = "RSpec Matchers for ActiveModel::Serializer Associations"
+  spec.summary       = "These matchers will allow you to test associations between serializers."
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -18,11 +18,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "active_model_serializers", "~> 0.8.0"
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.add_dependency "active_model_serializers", "0.8.0"
   spec.add_dependency "rspec", "~> 3.0"
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec-its"
-  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "coveralls"
 end

data/lib/active_model_serializers_matchers.rb

@@ -1,21 +1,13 @@
-require "active_support"
-
 require "active_model_serializers_matchers/version"
-require "active_model_serializers_matchers/have_many_association_matcher"
-require "active_model_serializers_matchers/have_one_association_matcher"
+require "active_model_serializers_matchers/association_matcher"
 
 module ActiveModelSerializersMatchers
-  extend ActiveSupport::Concern
-
-  included do
-    subject { described_class }
-  end
 
   def have_many(association_root)
-    HaveManyAssociationMatcher.new(association_root)
+    AssociationMatcher.new(association_root, :has_many)
   end
 
   def have_one(association_root)
-    HaveOneAssociationMatcher.new(association_root)
+    AssociationMatcher.new(association_root, :has_one)
   end
 end

data/lib/active_model_serializers_matchers/association_matcher.rb

@@ -0,0 +1,175 @@
+module ActiveModelSerializersMatchers
+  class AssociationMatcher
+
+    attr_reader :root, :type, :checks
+    attr_reader :actual
+
+    def initialize(root, type)
+      @root = root
+      @type = type
+      @checks = [AssociationCheck.new(self, type)]
+    end
+
+    def matches?(actual)
+      @actual = actual.is_a?(Class) ? actual : actual.class
+      checks.all?(&:pass?)
+    end
+
+    def description
+      checks.map(&:description).join(' ')
+    end
+
+    def failure_message
+      checks.find(&:fail?).failure_message
+    end
+
+    def root_association
+      associations[root]
+    end
+
+    def as(key)
+      checks << KeyCheck.new(self, key)
+      self
+    end
+
+    def serialized_with(serializer)
+      checks << SerializerCheck.new(self, serializer)
+      self
+    end
+
+    private
+
+    def associations
+      actual._associations
+    end
+
+    class AssociationCheck
+
+      attr_reader :matcher, :type
+
+      def initialize(matcher, type)
+        @matcher = matcher
+        @type = type
+      end
+
+      def pass?
+        return false if matcher.root_association.nil?
+        matcher.root_association.superclass == association_type
+      end
+
+      def fail?
+        !pass?
+      end
+
+      def description
+        "#{ association_string } #{ matcher.root.inspect }"
+      end
+
+      def failure_message
+        "expected #{ matcher.actual } to define a '#{ type } #{ matcher.root.inspect }' association"
+      end
+
+      private
+
+      def association_type
+        case type
+        when :has_one
+          ActiveModel::Serializer::Associations::HasOne
+        when :has_many
+          ActiveModel::Serializer::Associations::HasMany
+        else
+          raise ArgumentError, "'#{type}' is an invalid association type."
+        end
+      end
+
+      def association_string
+        case type
+        when :has_one
+          'have one'
+        when :has_many
+          'have many'
+        end
+      end
+    end
+
+    class KeyCheck
+
+      attr_reader :matcher, :key
+
+      def initialize(matcher, key)
+        @matcher = matcher
+        @key = key
+      end
+
+      def pass?
+        actual_key.to_s == key.to_s
+      end
+
+      def fail?
+        !pass?
+      end
+
+      def description
+        "as #{ key.inspect }"
+      end
+
+      def failure_message
+        "expected #{ matcher.actual } '#{ matcher.type } #{ matcher.root.inspect }' association to explicitly have key #{ key.inspect } but instead #{ actual_key_string }"
+      end
+
+      private
+
+      def actual_key
+        matcher.root_association.options[:key]
+      end
+
+      def actual_key_string
+        if actual_key
+          "was #{ actual_key.inspect }"
+        else
+          'has none'
+        end
+      end
+    end
+
+    class SerializerCheck
+
+      attr_reader :matcher, :serializer
+
+      def initialize(matcher, serializer)
+        @matcher = matcher
+        @serializer = serializer
+      end
+
+      def pass?
+        actual_serializer.to_s == serializer.to_s
+      end
+
+      def fail?
+        !pass?
+      end
+
+      def description
+        "serialized with #{ serializer }"
+      end
+
+      def failure_message
+        "expected #{ matcher.actual } '#{ matcher.type } #{ matcher.root.inspect }' association to explicitly have serializer #{ serializer } but instead #{ actual_serializer_string }"
+      end
+
+      private
+
+      def actual_serializer
+        matcher.root_association.options[:serializer]
+      end
+
+      def actual_serializer_string
+        if actual_serializer
+          "was #{ actual_serializer }"
+        else
+          "has none"
+        end
+      end
+    end
+  end
+end

data/lib/active_model_serializers_matchers/version.rb

@@ -1,3 +1,3 @@
 module ActiveModelSerializersMatchers
-  VERSION = "0.0.3"
+  VERSION = "0.2.0"
 end

data/spec/active_model_serializers_matchers/association_matcher_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe ActiveModelSerializersMatchers::AssociationMatcher do
+
+  context 'when given serializer that has_one :foo' do
+    subject do
+      Class.new(ActiveModel::Serializer) { has_one :foo }
+    end
+    it_behaves_like 'it has_one :foo'
+    it_behaves_like 'it has_one :foo and no key'
+    it_behaves_like 'it has_one :foo and no serializer'
+  end
+
+  context 'when given serializer that has_one :foo, key: :bar' do
+    subject do
+      Class.new(ActiveModel::Serializer) { has_one :foo, key: :bar }
+    end
+    it_behaves_like 'it has_one :foo'
+    it_behaves_like 'it has_one :foo and no serializer'
+    it_behaves_like 'it has_one :foo with key :bar'
+  end
+
+  context 'when given serializer that has_one :foo, serializer: FooSerializer' do
+    subject do
+      Class.new(ActiveModel::Serializer) { has_one :foo, serializer: FooSerializer }
+    end
+    it_behaves_like 'it has_one :foo'
+    it_behaves_like 'it has_one :foo and no key'
+    it_behaves_like 'it has_one :foo with serializer FooSerializer'
+  end
+
+  context 'when given serializer that has_one :foo, key: :bar, serializer: FooSerializer' do
+    subject do
+      Class.new(ActiveModel::Serializer) { has_one :foo, key: :bar, serializer: FooSerializer }
+    end
+    it_behaves_like 'it has_one :foo'
+    it_behaves_like 'it has_one :foo with key :bar'
+    it_behaves_like 'it has_one :foo with serializer FooSerializer'
+
+    describe 'should if all chained expectations pass in any order' do
+      it 'should pass a have_one :foo as :bar serialized_with FooSerializer expectation' do
+        expectation = have_one(:foo).as(:bar).serialized_with(FooSerializer)
+        expect(subject).to expectation
+        expect(expectation.description).to eq('have one :foo as :bar serialized with FooSerializer')
+      end
+
+      it 'should pass a have_one :foo serialized_with FooSerializer as :bar expectation' do
+        expectation = have_one(:foo).serialized_with(FooSerializer).as(:bar)
+        expect(subject).to expectation
+        expect(expectation.description).to eq('have one :foo serialized with FooSerializer as :bar')
+      end
+    end
+
+    describe 'should fail with the first encountered expectation message if any chained expectations fail' do
+      it 'should fail a have_one :fuu expectation' do
+        failure_message = "expected #{ subject } to define a 'has_one :fuu' association"
+        expect {
+          expect(subject).to have_one(:fuu).as(:bar).serialized_with(FooSerializer)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_one(:fuu).serialized_with(FooSerializer).as(:bar)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_one(:fuu).as(:bor).serialized_with(BarSerializer)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_one(:fuu).serialized_with(BarSerializer).as(:bor)
+        }.to fail_with(failure_message)
+      end
+
+      it 'should fail a have_one :foo serialized with BarSerializer expectation' do
+        failure_message = "expected #{ subject } 'has_one :foo' association to explicitly have serializer BarSerializer but instead was FooSerializer"
+        expect {
+          expect(subject).to have_one(:foo).as(:bar).serialized_with(BarSerializer)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_one(:foo).serialized_with(BarSerializer).as(:bar)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_one(:foo).serialized_with(BarSerializer).as(:bor)
+        }.to fail_with(failure_message)
+      end
+
+      it 'should fail a have_one :foo as :bor expectation' do
+        failure_message = "expected #{ subject } 'has_one :foo' association to explicitly have key :bor but instead was :bar"
+        expect {
+          expect(subject).to have_one(:foo).serialized_with(FooSerializer).as(:bor)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_one(:foo).as(:bor).serialized_with(FooSerializer)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_one(:foo).as(:bor).serialized_with(BarSerializer)
+        }.to fail_with(failure_message)
+      end
+    end
+  end
+
+  context 'when given serializer that has_many :foos' do
+    subject do
+      Class.new(ActiveModel::Serializer) { has_many :foos }
+    end
+    it_behaves_like 'it has_many :foos'
+    it_behaves_like 'it has_many :foos and no key'
+    it_behaves_like 'it has_many :foos and no serializer'
+  end
+
+  context 'when given serializer that has_many :foos, key: :bars' do
+    subject do
+      Class.new(ActiveModel::Serializer) { has_many :foos, key: :bars }
+    end
+    it_behaves_like 'it has_many :foos'
+    it_behaves_like 'it has_many :foos and no serializer'
+    it_behaves_like 'it has_many :foos with key :bars'
+  end
+
+  context 'when given serializer that has_many :foos, serializer: FooSerializer' do
+    subject do
+      Class.new(ActiveModel::Serializer) { has_many :foos, serializer: FooSerializer }
+    end
+    it_behaves_like 'it has_many :foos'
+    it_behaves_like 'it has_many :foos and no key'
+    it_behaves_like 'it has_many :foos with serializer FooSerializer'
+  end
+
+  context 'when given serializer that has_many :foos, key: :bars, serializer: FooSerializer' do
+    subject do
+      Class.new(ActiveModel::Serializer) { has_many :foos, key: :bars, serializer: FooSerializer }
+    end
+    it_behaves_like 'it has_many :foos'
+    it_behaves_like 'it has_many :foos with key :bars'
+    it_behaves_like 'it has_many :foos with serializer FooSerializer'
+  end
+
+  context 'when given serializer that has_many :foos, key: :bars, serializer: FooSerializer' do
+    subject do
+      Class.new(ActiveModel::Serializer) { has_many :foos, key: :bars, serializer: FooSerializer }
+    end
+    it_behaves_like 'it has_many :foos'
+    it_behaves_like 'it has_many :foos with key :bars'
+    it_behaves_like 'it has_many :foos with serializer FooSerializer'
+
+    describe 'should if all chained expectations pass in any order' do
+      it 'should pass a have_many :foos as :bars serialized_with FooSerializer expectation' do
+        expectation = have_many(:foos).as(:bars).serialized_with(FooSerializer)
+        expect(subject).to expectation
+        expect(expectation.description).to eq('have many :foos as :bars serialized with FooSerializer')
+      end
+
+      it 'should pass a have_many :foos serialized_with FooSerializer as :bars expectation' do
+        expectation = have_many(:foos).serialized_with(FooSerializer).as(:bars)
+        expect(subject).to expectation
+        expect(expectation.description).to eq('have many :foos serialized with FooSerializer as :bars')
+      end
+    end
+
+    describe 'should fail with the first encountered expectation message if any chained expectations fail' do
+      it 'should fail a have_many :fuu expectation' do
+        failure_message = "expected #{ subject } to define a 'has_many :fuus' association"
+        expect {
+          expect(subject).to have_many(:fuus).as(:bars).serialized_with(FooSerializer)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_many(:fuus).serialized_with(FooSerializer).as(:bars)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_many(:fuus).as(:bors).serialized_with(BarSerializer)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_many(:fuus).serialized_with(BarSerializer).as(:bors)
+        }.to fail_with(failure_message)
+      end
+
+      it 'should fail a have_many :foos serialized with BarSerializer expectation' do
+        failure_message = "expected #{ subject } 'has_many :foos' association to explicitly have serializer BarSerializer but instead was FooSerializer"
+        expect {
+          expect(subject).to have_many(:foos).as(:bars).serialized_with(BarSerializer)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_many(:foos).serialized_with(BarSerializer).as(:bars)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_many(:foos).serialized_with(BarSerializer).as(:bors)
+        }.to fail_with(failure_message)
+      end
+
+      it 'should fail a have_many :foos as :bors expectation' do
+        failure_message = "expected #{ subject } 'has_many :foos' association to explicitly have key :bors but instead was :bars"
+        expect {
+          expect(subject).to have_many(:foos).serialized_with(FooSerializer).as(:bors)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_many(:foos).as(:bors).serialized_with(FooSerializer)
+        }.to fail_with(failure_message)
+        expect {
+          expect(subject).to have_many(:foos).as(:bors).serialized_with(BarSerializer)
+        }.to fail_with(failure_message)
+      end
+    end
+  end
+end