warp 1.0.1 → 1.1.0

data/lib/warp/matcher.rb

@@ -0,0 +1,30 @@
+module Warp
+  class Matcher
+    # Composable matchers are new in RSpec 3.
+    # Define basic helpers in their absence.
+    if defined?(RSpec::Matchers::Composable)
+      include RSpec::Matchers::Composable
+    else
+      def description_of(object)
+        object.inspect
+      end
+
+      def values_match?(expected, actual)
+        expected === actual || actual == expected
+      end
+    end
+
+    # RSpec 2 and 3 have different methods
+    # that they call on matcher to get the
+    # failure messages.
+    if RSpec::Version::STRING[0] == "2"
+      def failure_message_for_should
+        failure_message
+      end
+
+      def failure_message_for_should_not
+        failure_message_when_negated
+      end
+    end
+  end
+end

data/lib/warp/model_matchers/association_matcher.rb

@@ -0,0 +1,56 @@
+module Warp
+  module ModelMatchers
+    class AssociationMatcher < Warp::ModelMatchers::Matcher
+      attr_reader :macro, :key
+      attr_reader :failure_message, :failure_message_when_negated, :description
+
+      def initialize(macro, key)
+        @macro = macro
+        @key = key
+      end
+
+      def matches?(model_or_instance)
+        if association = model(model_or_instance).reflect_on_association(key)
+          actual_macro = association.macro
+          @failure_message = "expected to have association #{macro} :#{key}, but had #{actual_macro} :#{key}"
+          @failure_message_when_negated = "expected to not have association #{macro} :#{key}"
+          actual_macro == macro
+        else
+          @failure_message = "expected to have association #{macro} :#{key}"
+          @failure_message_when_negated = "expected to not have association #{macro} :#{key}"
+          false
+        end
+      end
+
+      private
+
+      def model(model_or_instance)
+        if model_or_instance.is_a? Class
+          model_or_instance
+        else
+          model_or_instance.class
+        end
+      end
+    end
+
+    def have_many(key)
+      AssociationMatcher.new(:has_many, key)
+    end
+
+    def have_one(key)
+      AssociationMatcher.new(:has_one, key)
+    end
+
+    def belong_to(key)
+      AssociationMatcher.new(:belongs_to, key)
+    end
+
+    def have_and_belong_to_many(key)
+      if ActiveRecord::VERSION::STRING[0] == "4" && ActiveRecord::VERSION::STRING[3] != "0"
+        raise NotImplementedError, "In Rail 4.1+ the has_and_belongs_to_many helper produces a has_many :through association."
+      else
+        AssociationMatcher.new(:has_and_belongs_to_many, key)
+      end
+    end
+  end
+end

data/lib/warp/model_matchers/attribute_matcher.rb

@@ -0,0 +1,32 @@
+module Warp
+  module ModelMatchers
+    class AttributeMatcher < Warp::ModelMatchers::Matcher
+      attr_reader :attr_name
+      attr_reader :failure_message, :failure_message_when_negated, :description
+
+      def initialize(attr_name)
+        @attr_name = attr_name.to_sym
+      end
+
+      def matches?(model_or_instance)
+        if attributes(model_or_instance).any? {|actual| values_match?(attr_name, actual) }
+          @failure_message = "expected to have attribute #{description_of(attr_name)}"
+          @failure_message_when_negated = "expected to not have attribute #{description_of(attr_name)}"
+          true
+        else
+          @failure_message = "expected to have attribute #{description_of(attr_name)}"
+          @failure_message_when_negated = "expected to not have attribute #{description_of(attr_name)}"
+          false
+        end
+      end
+
+      def attributes(model_or_instance)
+        model(model_or_instance).column_names.map(&:to_sym)
+      end
+    end
+
+    def have_attribute(attr_name)
+      AttributeMatcher.new(attr_name)
+    end
+  end
+end

data/lib/warp/model_matchers/error_matcher.rb

@@ -0,0 +1,12 @@
+module Warp
+  module ModelMatchers
+    class ErrorMatcher < Warp::Matcher
+
+
+    end
+
+    def have_error
+
+    end
+  end
+end

data/lib/warp/model_matchers/matcher.rb

@@ -0,0 +1,15 @@
+module Warp
+  module ModelMatchers
+    class Matcher < Warp::Matcher
+      private
+
+      def model(model_or_instance)
+        if model_or_instance.is_a? Class
+          model_or_instance
+        else
+          model_or_instance.class
+        end
+      end
+    end
+  end
+end

data/lib/warp/model_matchers/validation_matcher.rb

@@ -0,0 +1,12 @@
+module Warp
+  module ModelMatchers
+    class ValidationMatcher < Warp::Matcher
+
+
+    end
+
+    def validate
+
+    end
+  end
+end

data/lib/warp/model_matchers.rb

@@ -0,0 +1,10 @@
+require "warp/model_matchers/matcher"
+
+require "warp/model_matchers/association_matcher"
+require "warp/model_matchers/attribute_matcher"
+# require "warp/model_matchers/error_matcher"
+# require "warp/model_matchers/validation_matcher"
+
+RSpec.configure do |config|
+  config.include Warp::ModelMatchers
+end

data/lib/warp/version.rb

@@ -1,3 +1,15 @@
 module Warp
-  VERSION = "1.0.1"
+  module VERSION
+    MAJOR = 1
+    MINOR = 1
+    PATCH = 0
+
+    BETA = nil
+
+    def self.to_s
+      version_str = [MAJOR, MINOR, PATCH].map(&:to_s).join(".")
+      version_str << ".beta#{BETA}" if BETA
+      version_str
+    end
+  end
 end

data/lib/warp.rb

@@ -2,4 +2,7 @@ require "warp/version"
 
 require "rspec"
 
-require "warp/controller_matchers"
+require "warp/matcher"
+
+require "warp/controller_matchers"
+require "warp/model_matchers"

data/spec/spec_helper.rb

@@ -1,4 +1,15 @@
-require 'bundler'
+require "bundler"
+
+require "simplecov"
+
+if ENV["TRAVIS_CI"]
+  require "coveralls"
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+end
+
+SimpleCov.start do
+  add_filter "/spec/"
+end
 
 if ENV["TRAVIS_CI"]
   Bundler.require
@@ -6,16 +17,14 @@ else
   Bundler.require(:default, :tools)
 end
 
-require "active_support/all"
-require "action_controller"
-
-require "warp"
-
 Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f }
 
 RSpec.configure do |config|
   config.order = 'random'
 
   config.extend ControllerHelpers
+  config.extend FailureMessageHelpers
+  config.extend ModelHelpers
   config.extend WithContextsHelpers
+  config.include MatchHelpers
 end

data/spec/support/failure_message_helpers.rb

@@ -0,0 +1,23 @@
+module FailureMessageHelpers
+  if RSpec::Version::STRING[0] == "3"
+    FAILURE_MESSAGE_METHOD = :failure_message
+    FAILURE_MESSAGE_WHEN_NEGATED_METHOD = :failure_message_when_negated
+  else
+    FAILURE_MESSAGE_METHOD = :failure_message_for_should
+    FAILURE_MESSAGE_WHEN_NEGATED_METHOD = :failure_message_for_should_not
+  end
+
+  def describe_failure_message(&blk)
+    describe "##{FAILURE_MESSAGE_METHOD}" do
+      subject { super().send(FAILURE_MESSAGE_METHOD) }
+      instance_eval(&blk)
+    end
+  end
+
+  def describe_failure_message_when_negated(&blk)
+    describe "##{FAILURE_MESSAGE_WHEN_NEGATED_METHOD}" do
+      subject { super().send(FAILURE_MESSAGE_WHEN_NEGATED_METHOD) }
+      instance_eval(&blk)
+    end
+  end
+end

data/spec/support/match_helpers.rb

@@ -1,18 +1,30 @@
-RSpec::Matchers.define :match do |value|
-  match do |matcher|
-    @matcher = matcher
-    matcher.matches?(value)
-  end
+module MatchHelpers
+  class MatchMatcher
+    attr_reader :value, :matcher
 
-  description do
-    "match #{value}"
-  end
+    def initialize(value)
+      @value = value
+    end
+
+    def matches?(matcher)
+      @matcher = matcher
+      matcher.matches?(value)
+    end
+
+    def description
+      "match #{value}"
+    end
+
+    def failure_message
+      "expect #{matcher} to match #{value} but did not"
+    end
 
-  failure_message do
-    "expect #{@matcher} to match #{value} but did not"
+    def failure_message_when_negated
+      "expect #{matcher} to not match #{value} but did"
+    end
   end
 
-  failure_message_when_negated do
-    "expect #{@matcher} to not match #{value} but did"
+  def match(value)
+    MatchMatcher.new(value)
   end
 end

data/spec/support/model_helpers.rb

@@ -0,0 +1,25 @@
+module ModelHelpers
+  def build_model(&blk)
+    let(:model) do
+      Class.new(ActiveRecord::Base) do
+        def self.name
+          "TestModel"
+        end
+
+        def self.primary_key
+          "id"
+        end
+
+        def self.columns
+          @columns ||= []
+        end
+
+        def self.column(name, sql_type = nil, default = nil, null = true)
+          columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+        end
+
+        instance_eval(&blk)
+      end
+    end
+  end
+end

data/spec/support/with_contexts_helpers.rb

@@ -2,6 +2,8 @@ module WithContextsHelpers
   class WithContextsBuilder
     attr_accessor :contexts, :examples, :group
 
+    delegate :let, :before, :after, :subject, to: :group
+
     def initialize(group)
       @contexts = {}
       @group = group
@@ -11,6 +13,10 @@ module WithContextsHelpers
       self.contexts[name] = blk
     end
 
+    def describe(name, &blk)
+      self.contexts[name] = blk
+    end
+
     def behaviour(&blk)
       self.examples = blk
     end

data/spec/warp/controller_matchers/assign_matcher_spec.rb

@@ -35,9 +35,7 @@ describe Warp::ControllerMatchers::AssignMatcher do
 
         specify { expect(subject).to match(_controller) }
       
-        describe "#failure_message_when_negated" do
-          subject { super().failure_message_when_negated }
-
+        describe_failure_message_when_negated do
           specify { expect(subject).to eq "expected @assign to not be assigned" }
         end
       end
@@ -49,9 +47,7 @@ describe Warp::ControllerMatchers::AssignMatcher do
 
         specify { expect(subject).to_not match(_controller) }
         
-        describe "#failure_message" do
-          subject { super().failure_message }
-
+        describe_failure_message do
           specify { expect(subject).to eq "expected @assign to be assigned" }
         end
       end
@@ -75,9 +71,7 @@ describe Warp::ControllerMatchers::AssignMatcher do
         context "with the right value" do
           specify { expect(subject).to match(_controller) }
         
-          describe "#failure_message_when_negated" do
-            subject { super().failure_message_when_negated }
-
+          describe_failure_message_when_negated do
             specify { expect(subject).to eq "expected @assign to not be assigned with #{expected_assign_value.inspect}" }
           end
         end
@@ -87,9 +81,7 @@ describe Warp::ControllerMatchers::AssignMatcher do
 
           specify { expect(subject).to_not match(_controller) }
           
-          describe "#failure_message" do
-            subject { super().failure_message }
-
+          describe_failure_message do
             specify { expect(subject).to eq "expected @assign to be assigned with #{expected_assign_value.inspect} but was assigned with #{actual_assign_value.inspect}" }
           end
         end
@@ -114,9 +106,7 @@ describe Warp::ControllerMatchers::AssignMatcher do
         context "with the right class" do
           specify { expect(subject).to match(_controller) }
             
-          describe "#failure_message_when_negated" do
-            subject { super().failure_message_when_negated }
-
+          describe_failure_message_when_negated do
             specify { expect(subject).to eq "expected @assign to not be assigned with an instance of #{expected_assign_class.name}" }
           end
         end
@@ -126,9 +116,7 @@ describe Warp::ControllerMatchers::AssignMatcher do
 
           specify { expect(subject).to_not match(_controller) }
           
-          describe "#failure_message" do
-            subject { super().failure_message }
-
+          describe_failure_message do
             specify { expect(subject).to eq "expected @assign to be assigned with an instance of #{expected_assign_class.name} but was assigned with an instance of #{actual_assign_class.name}"
      }
           end
@@ -164,9 +152,7 @@ describe Warp::ControllerMatchers::AssignMatcher do
           context "with the right class" do
             specify { expect(subject).to match(_controller) }
 
-            describe "#failure_message_when_negated" do
-              subject { super().failure_message_when_negated }
-
+            describe_failure_message_when_negated do
               specify { expect(subject).to eq "expected @assign to not be assigned with a new instance of #{expected_assign_class.name}" }
             end
           end
@@ -178,9 +164,7 @@ describe Warp::ControllerMatchers::AssignMatcher do
 
             specify { expect(subject).to match(_controller) }
 
-            describe "#failure_message_when_negated" do
-              subject { super().failure_message_when_negated }
-
+            describe_failure_message_when_negated do
               specify { expect(subject).to eq "expected @assign to not be assigned with a new instance of #{expected_assign_class.name}" }
             end 
           end
@@ -190,9 +174,7 @@ describe Warp::ControllerMatchers::AssignMatcher do
 
             specify { expect(subject).to_not match(_controller) }
             
-            describe "#failure_message" do
-              subject { super().failure_message }
-
+            describe_failure_message do
               specify { expect(subject).to eq "expected @assign to be assigned with a new instance of #{expected_assign_class.name} but was assigned with a new instance of #{actual_assign_class.name}"
        }
             end
@@ -205,9 +187,7 @@ describe Warp::ControllerMatchers::AssignMatcher do
           context "with the right class" do
             specify { expect(subject).to_not match(_controller) }
             
-            describe "#failure_message" do
-              subject { super().failure_message }
-
+            describe_failure_message do
               specify { expect(subject).to eq "expected @assign to be assigned with a new instance of #{expected_assign_class.name} but was assigned with a persisted instance of #{actual_assign_class.name}"
        }
             end
@@ -218,15 +198,37 @@ describe Warp::ControllerMatchers::AssignMatcher do
 
             specify { expect(subject).to_not match(_controller) }
             
-            describe "#failure_message" do
-              subject { super().failure_message }
-
+            describe_failure_message do
               specify { expect(subject).to eq "expected @assign to be assigned with a new instance of #{expected_assign_class.name} but was assigned with a persisted instance of #{actual_assign_class.name}"
        }
             end
           end
         end
       end
+
+      context "multiple assertions" do
+        with_contexts do
+          context "with .with and .with_a" do
+            let(:matcher) { super().with(Object.new).with_a(Class.new) }
+          end
+
+          context "with .with_a and .with_a_new" do
+            let(:matcher) { super().with_a(Class.new).with_a_new(Class.new) }
+          end
+
+          context "with .with_a_new and .with" do
+            let(:matcher) { super().with_a_new(Class.new).with(Object.new) }
+          end
+
+          context "with .with, .with_a, and .with_a_new" do
+            let(:matcher) { super().with(Object.new).with_a(Class.new).with_a_new(Class.new) }
+          end
+
+          behaviour do
+            specify { expect{ subject }.to raise_error("Only one of .with, .with_a, and .with_a_new can be used with the assigns matcher.") }
+          end
+        end
+      end
     end
   end
 end

data/spec/warp/controller_matchers/set_flash_matcher_spec.rb

@@ -39,9 +39,7 @@ describe Warp::ControllerMatchers::SetFlashMatcher do
 
         specify { expect(subject).to match(_controller) }
       
-        describe "#failure_message_when_negated" do
-          subject { super().failure_message_when_negated }
-
+        describe_failure_message_when_negated do
           specify { expect(subject).to eq "expected flash[:#{flash_key}] to not be set" }
         end
       end
@@ -49,9 +47,7 @@ describe Warp::ControllerMatchers::SetFlashMatcher do
       context "with no flash set" do
         specify { expect(subject).to_not match(_controller) }
       
-        describe "#failure_message" do
-          subject { super().failure_message }
-
+        describe_failure_message do
           specify { expect(subject).to eq "expected flash[:#{flash_key}] to be set" }
         end
       end
@@ -76,9 +72,7 @@ describe Warp::ControllerMatchers::SetFlashMatcher do
 
           specify { expect(subject).to match(_controller) }
         
-          describe "#failure_message_when_negated" do
-            subject { super().failure_message_when_negated }
-
+          describe_failure_message_when_negated do
             specify { expect(subject).to eq "expected flash[:#{flash_key}] to not be set to #{expected_flash_value.inspect}" }
           end
         end
@@ -88,9 +82,7 @@ describe Warp::ControllerMatchers::SetFlashMatcher do
 
           specify { expect(subject).to_not match(_controller) }
         
-          describe "#failure_message" do
-            subject { super().failure_message }
-
+          describe_failure_message do
             specify { expect(subject).to eq "expected flash[:#{flash_key}] to be set to #{expected_flash_value.inspect}" }
           end
         end

data/spec/warp/model_helpers/association_matcher_spec.rb

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+describe Warp::ModelMatchers::AssociationMatcher do
+  build_model do
+    belongs_to :foo
+    has_many :bars
+    has_one :baz
+    has_and_belongs_to_many :qux
+  end
+
+  with_contexts do
+    context "with model" do
+      let(:model_or_instance) { model }
+    end
+
+    context "with model instance" do
+      let(:model_or_instance) { model.new }
+    end
+
+    behaviour do
+      if ActiveRecord::VERSION::STRING[0] == "4" && ActiveRecord::VERSION::STRING[3] != "0"
+        specify { expect{ have_and_belong_to_many(:foo) }.to raise_error(NotImplementedError) }
+      end
+
+      with_contexts do
+        let(:no_association_key) { :foobar }
+
+        describe "#have_many" do
+          let(:matcher) { have_many(key) }
+          
+          let(:matcher_macro) { :has_many }
+          let(:association_key) { :bars }
+          let(:wrong_association_key) { :foo }
+        end
+
+        describe "#have_one" do
+          let(:matcher) { have_one(key) }
+          
+          let(:matcher_macro) { :has_one }
+          let(:association_key) { :baz }
+          let(:wrong_association_key) { :foo }
+        end
+
+        describe "#belong_to" do
+          let(:matcher) { belong_to(key) }
+          
+          let(:matcher_macro) { :belongs_to }
+          let(:association_key) { :foo }
+          let(:wrong_association_key) { :bars }
+        end
+
+        
+        unless ActiveRecord::VERSION::STRING[0] == "4" && ActiveRecord::VERSION::STRING[3] != "0"
+          describe "#have_and_belong_to_many" do
+            let(:matcher) { have_and_belong_to_many(key) }
+            
+            let(:matcher_macro) { :has_and_belongs_to_many }
+            let(:association_key) { :qux }
+            let(:wrong_association_key) { :foo }
+          end
+        end
+
+        behaviour do
+          subject { matcher.tap {|m| m.matches?(model_or_instance) } }
+
+          context "when an association exists" do
+            context "and the association macro matches" do
+              let(:key) { association_key }
+
+              specify { expect(subject).to match(model_or_instance) }
+            
+              describe_failure_message_when_negated do
+                specify { expect(subject).to eq "expected to not have association #{matcher_macro} :#{key}" }
+              end
+            end
+
+            context "and the association macro doesn't match" do
+              let(:key) { wrong_association_key }
+              let(:actual_macro) { model.reflect_on_association(key).macro }
+
+              specify { expect(subject).to_not match(model_or_instance) }
+            
+              describe_failure_message do
+                specify { expect(subject).to eq "expected to have association #{matcher_macro} :#{key}, but had #{actual_macro} :#{key}" }
+              end
+            end
+          end
+
+          context "when an association doesn't exists" do
+            let(:key) { no_association_key }
+
+            specify { expect(subject).to_not match(model_or_instance) }
+          
+            describe_failure_message do
+              specify { expect(subject).to eq "expected to have association #{matcher_macro} :#{key}" }
+            end
+          end
+        end
+      end
+    end
+  end
+end