active_model_serializers_matchers 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aebf6c344b00ad0333dcd6cb258c6c1a76037897
-  data.tar.gz: 44d578eab83b1f8766cb31358fcacadcfc056289
+  metadata.gz: f077a6f2b1a3a40b7ee1b140eb7bcc717a345efd
+  data.tar.gz: ecd3e42fe80ca954a55d2b6de3d7faad34dd9709
 SHA512:
-  metadata.gz: 324fbdb1a050601a50eaa0b949660c91e7a7e00cc702cfeedbce03ffbb6883c4fb6d19e2511d35a20f1d812539847453fa32ff92a458daf36be7d88d36044fa8
-  data.tar.gz: df4d83517d5011d9c858ccea3555a7f9922ef71eff6a1c756decb49d515dacbaed82f4d9621170c941c308310842d4628d5043968be555edb2b7f2e0f5972d9d
+  metadata.gz: 8234d7c88ae9b5d0075a5399df1fbf38b7d54020b77de42b9fb64547f00888c8294db376956ce31cc8b9b4ab37a10ad536d2ff81f48f7a09fc7632bd58155c2a
+  data.tar.gz: 05f2dcd60af24ee521703f6c25f9e11ec1e7d40f114955b013530f419c00140550f77f33524fa0e7020e5bfade3f4910a8737940ce8a7efd4c840529b583f6c8

data/README.md

@@ -7,8 +7,7 @@ RSpec matchers for testing ActiveModel::Serializer
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'active_model_serializers_matchers', '0.0.1',
-  git: 'git://github.com/tonyta/active_model_serializers_matchers.git'
+gem 'active_model_serializers_matchers', '0.0.3'
 ```
 
 And then execute:
@@ -20,8 +19,64 @@ Or install it yourself as:
     $ gem install active_model_serializers_matchers
 
 ## Usage
+### Simple `has_many` and `has_one` Associations
+``` ruby
+class ListSerializer < ActiveModel::Serializer
+  has_one :title
+  has_many :items
+end
 
-TODO: Write usage instructions here
+RSpec.describe ListSerializer do
+  it { should have_one(:title) }
+  it { should have_many(:items) }
+end
+
+#=> should have one title
+#=> should have many items
+```
+
+### Association Options
+#### Key
+use: `#as`
+``` ruby
+class ShoeRackSerializer < ActiveModel::Serializer
+  has_many :shoes, key: :kicks
+end
+
+RSpec.describe ShoeRackSerializer do
+  it { should have_many(:shoes).as(:kicks) }
+end
+
+#=> should have many shoes as "kicks"
+```
+#### Serializer
+use: `#serialized_with`
+``` ruby
+class ShoppingCartSerializer < ActiveModel::Serializer
+  has_many :items, serializer: ProductSerializer
+end
+
+RSpec.describe ShoppingCartSerializer do
+  it { should have_many(:items).serialized_with(ProductSerializer) }
+end
+
+#=> should have many items serialized with ProductSerializer
+```
+#### Chainable
+These can be chained in any order.
+``` ruby
+class MenuSerializer < ActiveModel::Serializer
+  has_many :entrees, key: dishes, serializer: FoodSerializer
+end
+
+RSpec.describe MenuSerializer do
+  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
+```
 
 ## Contributing
 

data/lib/active_model_serializers_matchers.rb

@@ -2,6 +2,7 @@ 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"
 
 module ActiveModelSerializersMatchers
   extend ActiveSupport::Concern
@@ -13,4 +14,8 @@ module ActiveModelSerializersMatchers
   def have_many(association_root)
     HaveManyAssociationMatcher.new(association_root)
   end
+
+  def have_one(association_root)
+    HaveOneAssociationMatcher.new(association_root)
+  end
 end

data/lib/active_model_serializers_matchers/have_many_association_matcher.rb

@@ -10,7 +10,7 @@ module ActiveModelSerializersMatchers
 
     def matches?(actual)
       @actual = actual.is_a?(Class) ? actual : actual.class
-      association and match_root? && match_key? && match_serializer?
+      match_association? && match_key? && match_serializer?
     end
 
     def as(key)
@@ -33,18 +33,18 @@ module ActiveModelSerializersMatchers
     end
 
     def failure_message
-      if association && match_root?
-        "expected #{actual} association options for #{root}: #{association.options} to include: #{expected_association}"
+      if match_association?
+        "expected #{actual} association options for #{root}: #{root_association.options} to include: #{expected_association}"
       else
-        "expected #{actual} associations: #{associations.keys} to include: #{root.inspect}"
+        "expected #{actual} associations: #{associations} to include: {#{root.inspect}=>(subclass of ActiveModel::Serializer::Associations::HasMany)}"
       end
     end
 
     def failure_message_when_negated
-      if association && match_root?
-        "expected #{actual} associations: #{associations.keys} to not include: #{root.inspect}"
+      if match_association?
+        "expected #{actual} associations: #{associations} to not include: {#{root.inspect}=>(subclass of ActiveModel::Serializer::Associations::HasMany)}"
       else
-        "expected #{actual} association options for #{root}: #{association.options} to not include: #{expected_options}"
+        "expected #{actual} association options for #{root}: #{root_association.options} to not include: #{expected_options}"
       end
     end
 
@@ -61,23 +61,23 @@ module ActiveModelSerializersMatchers
       actual._associations
     end
 
-    def association
-      return false if associations[root].nil?
+    def root_association
       associations[root]
     end
 
-    def match_root?
-      association.options[:root] == root
+    def match_association?
+      return false if root_association.nil?
+      root_association.superclass == ActiveModel::Serializer::Associations::HasMany
     end
 
     def match_key?
       return true unless key_check
-      association.options[:key] == key
+      root_association.options[:key] == key
     end
 
     def match_serializer?
       return true unless serializer_check
-      association.options[:serializer].to_s == serializer.to_s
+      root_association.options[:serializer].to_s == serializer.to_s
     end
   end
 end

data/lib/active_model_serializers_matchers/have_one_association_matcher.rb

@@ -0,0 +1,83 @@
+module ActiveModelSerializersMatchers
+  class HaveOneAssociationMatcher
+    attr_accessor :actual, :root, :key, :serializer, :key_check, :serializer_check
+
+    def initialize(root)
+      @root             = root
+      @key_check        = false
+      @serializer_check = false
+    end
+
+    def matches?(actual)
+      @actual = actual.is_a?(Class) ? actual : actual.class
+      match_association? && match_key? && match_serializer?
+    end
+
+    def as(key)
+      self.key_check = true
+      self.key = key
+      self
+    end
+
+    def serialized_with(serializer)
+      self.serializer_check = true
+      self.serializer = serializer
+      self
+    end
+
+    def description
+      msg = "have one #{root}"
+      msg << " as \"#{key}\"" if key_check
+      msg << " serialized with #{serializer}" if serializer_check
+      msg
+    end
+
+    def failure_message
+      if match_association?
+        "expected #{actual} association options for #{root}: #{root_association.options} to include: #{expected_association}"
+      else
+        "expected #{actual} associations: #{associations} to include: {#{root.inspect}=>(subclass of ActiveModel::Serializer::Associations::HasOne)}"
+      end
+    end
+
+    def failure_message_when_negated
+      if match_association?
+        "expected #{actual} associations: #{associations} to not include: {#{root.inspect}=>(subclass of ActiveModel::Serializer::Associations::HasOne)}"
+      else
+        "expected #{actual} association options for #{root}: #{root_association.options} to not include: #{expected_options}"
+      end
+    end
+
+    def expected_options
+      expected = { root: root }
+      expected[:key] = key if key_check
+      expected[:serializer] = serializer if serializer_check
+      expected
+    end
+
+    private
+
+    def associations
+      actual._associations
+    end
+
+    def root_association
+      associations[root]
+    end
+
+    def match_association?
+      return false if root_association.nil?
+      root_association.superclass == ActiveModel::Serializer::Associations::HasOne
+    end
+
+    def match_key?
+      return true unless key_check
+      root_association.options[:key] == key
+    end
+
+    def match_serializer?
+      return true unless serializer_check
+      root_association.options[:serializer].to_s == serializer.to_s
+    end
+  end
+end

data/lib/active_model_serializers_matchers/version.rb

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

data/spec/active_model_serializers_matchers/have_many_association_matcher_spec.rb

@@ -9,7 +9,7 @@ describe ActiveModelSerializersMatchers::HaveManyAssociationMatcher do
   describe '#matches?' do
     context 'when called with a class' do
       it 'sets @actual to that class' do
-        allow(subject).to receive(:association)
+        allow(subject).to receive(:root_association)
         subject.matches?(Object)
         expect(subject.actual).to be Object
       end
@@ -17,25 +17,24 @@ describe ActiveModelSerializersMatchers::HaveManyAssociationMatcher do
 
     context 'when called with an instance of class' do
       it 'sets @actual to the class of that instance' do
-        allow(subject).to receive(:association)
+        allow(subject).to receive(:root_association)
         subject.matches?(Object.new)
         expect(subject.actual).to be Object
       end
     end
 
     describe 'return value' do
-      context 'when association, match_root?, match_key?, and match_serializer? are all true' do
+      context 'when match_association?, match_key?, and match_serializer? are all true' do
         before do
-          expect(subject).to receive(:association      ) { true }
-          expect(subject).to receive(:match_root?      ) { true }
-          expect(subject).to receive(:match_key?       ) { true }
-          expect(subject).to receive(:match_serializer?) { true }
+          expect(subject).to receive(:match_association?) { true }
+          expect(subject).to receive(:match_key?        ) { true }
+          expect(subject).to receive(:match_serializer? ) { true }
         end
         specify { expect(subject.matches?(serializer)).to be true }
       end
 
-      context 'when any association, match_root?, match_key?, or match_serializer? is false' do
-        match_check_methods = [:association, :match_root?, :match_key?, :match_serializer?]
+      context 'when any match_association?, match_key?, or match_serializer? is false' do
+        match_check_methods = [:match_association?, :match_key?, :match_serializer?]
 
         match_check_methods.each do |false_method|
           before do
@@ -83,9 +82,17 @@ describe ActiveModelSerializersMatchers::HaveManyAssociationMatcher do
     end
   end
 
-  describe 'integration tests' do
+  describe 'feature tests' do
     include ActiveModelSerializersMatchers
 
+    context 'a serializer with one foo' do
+      subject do
+        Class.new(ActiveModel::Serializer) { has_one :foo }
+      end
+      it { should_not have_many :foo  }
+      it { should_not have_many :foos }
+    end
+
     context 'a serializer with many foos' do
       subject do
         Class.new(ActiveModel::Serializer) { has_many :foos }

data/spec/active_model_serializers_matchers/have_one_association_matcher_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe ActiveModelSerializersMatchers::HaveOneAssociationMatcher do
+
+  subject { described_class.new(:foos) }
+
+  let(:serializer) { Class.new(ActiveModel::Serializer) }
+
+  describe '#matches?' do
+    context 'when called with a class' do
+      it 'sets @actual to that class' do
+        allow(subject).to receive(:root_association)
+        subject.matches?(Object)
+        expect(subject.actual).to be Object
+      end
+    end
+
+    context 'when called with an instance of class' do
+      it 'sets @actual to the class of that instance' do
+        allow(subject).to receive(:root_association)
+        subject.matches?(Object.new)
+        expect(subject.actual).to be Object
+      end
+    end
+
+    describe 'return value' do
+      context 'when match_association?, match_key?, and match_serializer? are all true' do
+        before do
+          expect(subject).to receive(:match_association?) { true }
+          expect(subject).to receive(:match_key?        ) { true }
+          expect(subject).to receive(:match_serializer? ) { true }
+        end
+        specify { expect(subject.matches?(serializer)).to be true }
+      end
+
+      context 'when any match_association?, match_key?, or match_serializer? is false' do
+        match_check_methods = [:match_association?, :match_key?, :match_serializer?]
+
+        match_check_methods.each do |false_method|
+          before do
+            match_check_methods.each do |method|
+              allow(subject).to receive(method) { method == false_method ? false : true }
+            end
+          end
+          specify { expect(subject.matches?(serializer)).to be false }
+        end
+      end
+    end
+  end
+
+  describe '#as' do
+    it 'should return self' do
+      expect(subject.as(:a_key)).to be subject
+    end
+
+    context 'when it is not called' do
+      its(:key_check) { should be false }
+      its(:key) { should be_nil }
+    end
+
+    context 'when it is called with :a_key' do
+      before { subject.as(:a_key) }
+      its(:key_check) { should be true }
+      its(:key) { should be :a_key }
+    end
+  end
+
+  describe '#serialized_with' do
+    it 'should return self' do
+      expect(subject.serialized_with(:a_serializer)).to be subject
+    end
+
+    context 'when it is not called' do
+      its(:serializer_check) { should be false }
+      its(:serializer) { should be_nil }
+    end
+
+    context 'when it is called with :a_serializer' do
+      before { subject.serialized_with(:a_serializer) }
+      its(:serializer_check) { should be true }
+      its(:serializer) { should be :a_serializer }
+    end
+  end
+
+  describe 'feature tests' do
+    include ActiveModelSerializersMatchers
+
+    context 'a serializer with one foo' do
+      subject do
+        Class.new(ActiveModel::Serializer) { has_many :foos }
+      end
+      it { should_not have_one :foo  }
+      it { should_not have_one :foos }
+    end
+
+    context 'a serializer with one foo' do
+      subject do
+        Class.new(ActiveModel::Serializer) { has_one :foo }
+      end
+      it { should     have_one(:foo) }
+      it { should_not have_one(:bar) }
+      it { should_not have_one(:foo).as(:bar) }
+      it { should_not have_one(:foo).serialized_with(:baz) }
+    end
+
+    context 'a serializer with one foo as bar' do
+      subject do
+        Class.new(ActiveModel::Serializer) { has_one :foo, key: :bar }
+      end
+      it { should     have_one(:foo) }
+      it { should     have_one(:foo).as(:bar) }
+      it { should_not have_one(:foo).as(:baz) }
+    end
+
+    context 'a serializer with one foo serialized with baz' do
+      subject do
+        Class.new(ActiveModel::Serializer) { has_one :foo, serializer: :baz }
+      end
+      it { should     have_one(:foo) }
+      it { should     have_one(:foo).serialized_with(:baz) }
+      it { should_not have_one(:foo).serialized_with(:bar) }
+    end
+
+    context 'a serializer with one foo as bar serialized with baz' do
+      subject do
+        Class.new(ActiveModel::Serializer) { has_one :foo, key: :bar, serializer: :baz }
+      end
+      it { should     have_one(:foo) }
+      it { should     have_one(:foo).as(:bar) }
+      it { should     have_one(:foo).serialized_with(:baz) }
+      it { should     have_one(:foo).as(:bar).serialized_with(:baz) }
+      it { should_not have_one(:fuu).as(:bar).serialized_with(:baz) }
+      it { should_not have_one(:foo).as(:bor).serialized_with(:baz) }
+      it { should_not have_one(:foo).as(:bar).serialized_with(:biz) }
+    end
+  end
+end

data/spec/active_model_serializers_matchers_spec.rb

@@ -11,4 +11,12 @@ describe ActiveModelSerializersMatchers do
       have_many(:association_root)
     end
   end
+
+  describe '#have_one' do
+    it 'instantiates a new HaveOneAssociationMatcher' do
+      expect(described_class::HaveOneAssociationMatcher)
+        .to receive(:new).with(:association_root)
+      have_one(:association_root)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_model_serializers_matchers
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Tony Ta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-23 00:00:00.000000000 Z
+date: 2014-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -110,8 +110,10 @@ files:
 - active_model_serializers_matchers.gemspec
 - lib/active_model_serializers_matchers.rb
 - lib/active_model_serializers_matchers/have_many_association_matcher.rb
+- lib/active_model_serializers_matchers/have_one_association_matcher.rb
 - lib/active_model_serializers_matchers/version.rb
 - spec/active_model_serializers_matchers/have_many_association_matcher_spec.rb
+- spec/active_model_serializers_matchers/have_one_association_matcher_spec.rb
 - spec/active_model_serializers_matchers_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -140,5 +142,6 @@ specification_version: 4
 summary: RSpec matchers for testing ActiveModel::Serializer
 test_files:
 - spec/active_model_serializers_matchers/have_many_association_matcher_spec.rb
+- spec/active_model_serializers_matchers/have_one_association_matcher_spec.rb
 - spec/active_model_serializers_matchers_spec.rb
 - spec/spec_helper.rb