rspec-tag_matchers 0.1.0

data/spec/lib/rspec/tag_matchers/has_select_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe RSpec::TagMatchers::HasSelect do
+  include RSpec::TagMatchers
+
+  describe "matching select tags" do
+    context "have_select" do
+      subject { have_select }
+      it { should_not match("<input />") }
+      it { should     match("<select />") }
+      it { should     match("<SELECT />") }
+      it { should_not match("<selector />") }
+      it { should_not match("select") }
+    end
+  end
+
+  describe "matching input names" do
+    context "have_select.for(:user => :role)" do
+      subject { have_select.for(:user => :role) }
+      it      { should_not match("<select />") }
+      it      { should_not match("<select name='user' />") }
+      it      { should     match("<select name='user[role]' />") }
+      it      { should_not match("<select name='user[role][admin]' />") }
+    end
+  end
+end

data/spec/lib/rspec/tag_matchers/has_tag_spec.rb

@@ -0,0 +1,294 @@
+require 'spec_helper'
+
+describe RSpec::TagMatchers::HasTag do
+  include RSpec::TagMatchers
+
+  describe "inputs" do
+    let(:string)   { "<foo></foo>" }
+    let(:document) { Nokogiri::HTML::Document.parse(string) }
+    let(:node_set) { document.css("foo") }
+
+    subject { have_tag(:foo) }
+
+    it "should match against String" do
+      subject.should match(string)
+    end
+
+    it "should match against Nokogiri::XML::NodeSet" do
+      subject.should match(node_set)
+    end
+  end
+
+  describe "tag name matching" do
+    context "matches with symbol" do
+      context 'have_tag(:foo)' do
+        subject { have_tag(:foo) }
+        it      { should     match("<foo></foo>") }
+        it      { should     match("<foo bar='baz'></foo>") }
+        it      { should     match("<FOO></FOO>") }
+        it      { should_not match("<foobar></foobar>") }
+        it      { should_not match("<bar></bar>") }
+        it      { should_not match("foo") }
+      end
+
+      context 'have_tag(:bar)' do
+        subject { have_tag(:bar) }
+        it      { should     match("<bar></bar>") }
+        it      { should_not match("<foo></foo>") }
+      end
+    end
+
+    context "matches with string" do
+      context 'have_tag("foo")' do
+        subject { have_tag("foo") }
+        it      { should     match("<foo></foo>") }
+        it      { should     match("<foo bar='1'></foo>") }
+        it      { should     match("<FOO></FOO>") }
+        it      { should_not match("<foobar></foobar>") }
+        it      { should_not match("<bar></bar>") }
+        it      { should_not match("foo") }
+      end
+
+      context 'have_tag("bar")' do
+        subject { have_tag("bar") }
+        it      { should     match("<bar></bar>") }
+        it      { should_not match("<foo></foo>") }
+      end
+    end
+  end
+
+  describe "attribute value matching" do
+    context "true matches presence of attribute" do
+      context 'have_tag(:foo).with_attribute(:bar => true)' do
+        subject { have_tag(:foo).with_attribute(:bar => true) }
+        it      { should_not match("<foo></foo>") }
+        it      { should     match("<foo bar='baz'></foo>") }
+        it      { should     match("<foo bar='qux'></foo>") }
+        it      { should     match("<foo bar></foo>") }
+        it      { should_not match("<foo qux='baz'></foo>") }
+        it      { should_not match("<foo>bar</foo>") }
+        it      { should_not match("<foo></foo><qux bar='baz'></qux>") }
+      end
+
+      context 'have_tag(:foo).with_attribute(:qux => true)' do
+        subject { have_tag(:foo).with_attribute(:qux => true) }
+        it      { should_not match("<foo></foo>") }
+        it      { should_not match("<foo bar='baz'></foo>") }
+        it      { should     match("<foo qux='baz'></foo>") }
+        it      { should     match("<foo qux></foo>") }
+        it      { should_not match("<foo></foo><qux bar='baz'></qux>") }
+      end
+    end
+
+    context "false matches absence of attribute" do
+      context 'have_tag(:foo).with_attribute(:bar => false)' do
+        subject { have_tag(:foo).with_attribute(:bar => false) }
+        it      { should     match("<foo></foo>") }
+        it      { should_not match("<foo bar='baz'></foo>") }
+        it      { should_not match("<foo bar='qux'></foo>") }
+        it      { should_not match("<foo bar></foo>") }
+        it      { should     match("<foo qux='baz'></foo>") }
+      end
+
+      context 'have_tag(:foo).with_attribute(:qux => false)' do
+        subject { have_tag(:foo).with_attribute(:qux => false) }
+        it      { should     match("<foo></foo>") }
+        it      { should     match("<foo bar='baz'></foo>") }
+        it      { should_not match("<foo qux='baz'></foo>") }
+        it      { should_not match("<foo qux></foo>") }
+      end
+    end
+
+    context "string matches exactly" do
+      context 'have_tag(:foo).with_attribute(:bar => "baz")' do
+        subject { have_tag(:foo).with_attribute(:bar => "baz") }
+        it      { should_not match("<foo></foo>") }
+        it      { should     match("<foo bar='baz'></foo>") }
+        it      { should_not match("<foo bar='qux'></foo>") }
+        it      { should_not match("<foo bar='BAZ'></foo>") }
+        it      { should_not match("<foo bar='baza'></foo>") }
+        it      { should_not match("<foo bar='abaz'</foo>") }
+        it      { should_not match("<foo qux='baz'></foo>") }
+      end
+
+      context 'have_tag(:foo).with_attribute(:bar => "qux")' do
+        subject { have_tag(:foo).with_attribute(:bar => "qux") }
+        it      { should_not match("<foo></foo>") }
+        it      { should_not match("<foo bar='baz'></foo>") }
+        it      { should     match("<foo bar='qux'></foo>") }
+        it      { should_not match("<foo qux='baz'></foo>") }
+      end
+
+      context 'have_tag(:foo).with_attribute(:qux => "baz")' do
+        subject { have_tag(:foo).with_attribute(:qux => "baz") }
+        it      { should_not match("<foo></foo>") }
+        it      { should_not match("<foo bar='baz'></foo>") }
+        it      { should_not match("<foo bar='qux'></foo>") }
+        it      { should     match("<foo qux='baz'></foo>") }
+      end
+    end
+
+    context "symbol matches ignoring case" do
+      context 'have_tag(:foo).with_attribute(:bar => :baz)' do
+        subject { have_tag(:foo).with_attribute(:bar => :baz) }
+        it      { should_not match("<foo></foo>") }
+        it      { should     match("<foo bar='baz'></foo>") }
+        it      { should     match("<foo bar='BAZ'></foo>") }
+        it      { should_not match("<foo bar='qux'></foo>") }
+        it      { should_not match("<foo bar='baza'></foo>") }
+        it      { should_not match("<foo bar='abaz'</foo>") }
+        it      { should_not match("<foo qux='baz'></foo>") }
+      end
+
+      context 'have_tag(:foo).with_attribute(:bar => :qux)' do
+        subject { have_tag(:foo).with_attribute(:bar => :qux) }
+        it      { should_not match("<foo></foo>") }
+        it      { should_not match("<foo bar='baz'></foo>") }
+        it      { should     match("<foo bar='qux'></foo>") }
+        it      { should_not match("<foo qux='baz'></foo>") }
+      end
+
+      context 'have_tag(:foo).with_attribute(:qux => :baz)' do
+        subject { have_tag(:foo).with_attribute(:qux => :baz) }
+        it      { should_not match("<foo></foo>") }
+        it      { should_not match("<foo bar='baz'></foo>") }
+        it      { should_not match("<foo bar='qux'></foo>") }
+        it      { should     match("<foo qux='baz'></foo>") }
+      end
+    end
+
+    context "regex matches with regex" do
+      context 'have_tag(:foo).with_attribute(:bar => /baz/)' do
+        subject { have_tag(:foo).with_attribute(:bar => /baz/) }
+        it      { should_not match("<foo></foo>") }
+        it      { should     match("<foo bar='baz'></foo>") }
+        it      { should_not match("<foo bar='BAZ'></foo>") }
+        it      { should_not match("<foo bar='qux'></foo>") }
+        it      { should     match("<foo bar='baza'></foo>") }
+        it      { should     match("<foo bar='abaz'</foo>") }
+        it      { should_not match("<foo qux='baz'></foo>") }
+      end
+
+      context 'have_tag(:foo).with_attribute(:bar => /qux/)' do
+        subject { have_tag(:foo).with_attribute(:bar => /qux/) }
+        it      { should_not match("<foo></foo>") }
+        it      { should_not match("<foo bar='baz'></foo>") }
+        it      { should     match("<foo bar='qux'></foo>") }
+        it      { should_not match("<foo qux='baz'></foo>") }
+      end
+
+      context 'have_tag(:foo).with_attribute(:qux => /baz/)' do
+        subject { have_tag(:foo).with_attribute(:qux => /baz/) }
+        it      { should_not match("<foo></foo>") }
+        it      { should_not match("<foo bar='baz'></foo>") }
+        it      { should_not match("<foo bar='qux'></foo>") }
+        it      { should     match("<foo qux='baz'></foo>") }
+      end
+    end
+
+    context "matches multiple attributes" do
+      context 'have_tag(:foo).with_attribute(:bar => true, :baz => true)' do
+        subject { have_tag(:foo).with_attribute(:bar => true, :baz => true) }
+        it      { should     match("<foo bar='1' baz='2'></foo>") }
+        it      { should_not match("<foo bar='1'></foo>") }
+        it      { should_not match("<foo baz='2'></foo>") }
+        it      { should_not match("<foo></foo>") }
+      end
+    end
+  end
+
+  describe "extra criteria" do
+    context "as symbol" do
+      context "have_tag(:foo).with_criteria(:custom_filter)" do
+        subject { have_tag(:foo).with_criteria(:custom_filter) }
+
+        it "should call custom_filter with Nokogiri::XML::Element as argument" do
+          RSpec::TagMatchers::HasTag.any_instance.should_receive(:custom_filter).with(an_instance_of(Nokogiri::XML::Element))
+          subject.matches?("<foo></foo>")
+        end
+
+        context "when custom_filter returns true" do
+          before { RSpec::TagMatchers::HasTag.any_instance.stub(:custom_filter) { true } }
+          it     { should     match("<foo></foo>") }
+          it     { should_not match("<bar></bar>") }
+        end
+
+        context "when custom_filter returns false" do
+          before { RSpec::TagMatchers::HasTag.any_instance.stub(:custom_filter) { false } }
+          it     { should_not match("<foo></foo>") }
+          it     { should_not match("<bar></bar>") }
+        end
+      end
+    end
+
+    context "as block" do
+      context "have_tag(:foo).with_criteria { |element| ... }" do
+        let!(:block) { lambda { |element| true } }
+        subject      { have_tag(:foo).with_criteria { |element| block.call(element) } }
+
+        it "should call the block with Nokogiri::XML::Element as argument" do
+          block.should_receive(:call).with(an_instance_of(Nokogiri::XML::Element))
+          subject.matches?("<foo></foo>")
+        end
+
+        context "when block returns true" do
+          before { block.stub(:call) { true } }
+          it     { should     match("<foo></foo>") }
+          it     { should_not match("<bar></bar>") }
+        end
+
+        context "when block returns false" do
+          before { block.stub(:call) { false } }
+          it     { should_not match("<foo></foo>") }
+          it     { should_not match("<bar></bar>") }
+        end
+      end
+    end
+
+    context "multiple criteria" do
+      context "have_tag(:foo).with_criteria(:filter_1).with_criteria(:filter_2)" do
+        subject { have_tag(:foo).with_criteria(:filter_1).with_criteria(:filter_2) }
+
+        context "both filters return true" do
+          before do
+            RSpec::TagMatchers::HasTag.any_instance.stub(:filter_1) { true }
+            RSpec::TagMatchers::HasTag.any_instance.stub(:filter_2) { true }
+          end
+
+          it { should     match("<foo></foo>") }
+          it { should_not match("<bar></bar>") }
+        end
+
+        context "filter_1 returns false" do
+          before do
+            RSpec::TagMatchers::HasTag.any_instance.stub(:filter_1) { false }
+            RSpec::TagMatchers::HasTag.any_instance.stub(:filter_2) { true }
+          end
+
+          it { should_not match("<foo></foo>") }
+          it { should_not match("<bar></bar>") }
+        end
+
+        context "filter_2 returns false" do
+          before do
+            RSpec::TagMatchers::HasTag.any_instance.stub(:filter_1) { true }
+            RSpec::TagMatchers::HasTag.any_instance.stub(:filter_2) { false }
+          end
+
+          it { should_not match("<foo></foo>") }
+          it { should_not match("<bar></bar>") }
+        end
+
+        context "both filters return false" do
+          before do
+            RSpec::TagMatchers::HasTag.any_instance.stub(:filter_1) { false }
+            RSpec::TagMatchers::HasTag.any_instance.stub(:filter_2) { false }
+          end
+
+          it { should_not match("<foo></foo>") }
+          it { should_not match("<bar></bar>") }
+        end
+      end
+    end
+  end
+end

data/spec/lib/rspec/tag_matchers/has_time_select_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe RSpec::TagMatchers::HasTimeSelect do
+  include RSpec::TagMatchers
+
+  let(:start_time_hour)   { "<select name='event[start_time(4i)]'></select>" }
+  let(:start_time_minute) { "<select name='event[start_time(5i)]'></select>" }
+  let(:start_time_second) { "<select name='event[start_time(6i)]'></select>" }
+
+  let(:end_time_hour)     { "<select name='event[end_time(4i)]'></select>" }
+  let(:end_time_minute)   { "<select name='event[end_time(5i)]'></select>" }
+  let(:end_time_second)   { "<select name='event[end_time(6i)]'></select>" }
+
+  let(:start_time_with_hour_and_minute)        { start_time_hour + start_time_minute }
+  let(:start_time_with_hour_minute_and_second) { start_time_hour + start_time_minute + start_time_second }
+
+  let(:end_time_with_hour_and_minute)          { end_time_hour + end_time_minute }
+  let(:end_time_with_hour_minute_and_second)   { end_time_hour + end_time_minute + end_time_second }
+
+  describe "time select matching" do
+    context "have_time_select" do
+      subject { have_time_select }
+
+      it      { should     match(start_time_with_hour_and_minute) }
+      it      { should     match(start_time_with_hour_minute_and_second) }
+      it      { should_not match(start_time_hour) }
+      it      { should_not match(start_time_minute) }
+      it      { should_not match(start_time_second) }
+
+      it      { should     match(end_time_with_hour_and_minute) }
+      it      { should     match(end_time_with_hour_minute_and_second) }
+      it      { should_not match(end_time_hour) }
+      it      { should_not match(end_time_minute) }
+      it      { should_not match(end_time_second) }
+    end
+  end
+
+  describe "matching input names" do
+    context "have_time_select.for(:event => :start_time)" do
+      subject { have_time_select.for(:event => :start_time) }
+
+      it      { should     match(start_time_with_hour_and_minute) }
+      it      { should     match(start_time_with_hour_minute_and_second) }
+
+      it      { should_not match(end_time_with_hour_and_minute) }
+      it      { should_not match(end_time_with_hour_minute_and_second) }
+    end
+
+    context "have_time_select.for(:event => :end_time)" do
+      subject { have_time_select.for(:event => :end_time) }
+
+      it      { should     match(end_time_with_hour_and_minute) }
+      it      { should     match(end_time_with_hour_minute_and_second) }
+
+      it      { should_not match(start_time_with_hour_and_minute) }
+      it      { should_not match(start_time_with_hour_minute_and_second) }
+    end
+  end
+end

data/spec/lib/rspec/tag_matchers/multiple_input_matcher_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe RSpec::TagMatchers::MultipleInputMatcher do
+  let(:foo_matcher) { mock("'foo' input matcher") }
+  let(:bar_matcher) { mock("'bar' input matcher") }
+  let(:html)        { "<input name='foo' /><input name='bar' />" }
+
+  let(:multiple_matcher) do
+    RSpec::TagMatchers::MultipleInputMatcher.new(2 => foo_matcher, 3 => bar_matcher)
+  end
+
+  before do
+    # prevent unexpected messages from causing test failures
+    foo_matcher.stub(:with_attribute).with(:name => /\(2i\)/)
+    bar_matcher.stub(:with_attribute).with(:name => /\(3i\)/)
+  end
+
+  describe "#initialize" do
+    it "should add criteria for input indices" do
+      foo_matcher.should_receive(:with_attribute).with(:name => /\(2i\)/)
+      bar_matcher.should_receive(:with_attribute).with(:name => /\(3i\)/)
+      multiple_matcher
+    end
+  end
+
+  describe "#for" do
+    it "should add indices, e.g., '(2i)', to last part of each input's name" do
+      foo_matcher.should_receive(:for).with("example", "foobar(2i)")
+      bar_matcher.should_receive(:for).with("example", "foobar(3i)")
+      multiple_matcher.for("example" => "foobar")
+    end
+
+    it "should return self" do
+      foo_matcher.should_receive(:for)
+      bar_matcher.should_receive(:for)
+      multiple_matcher.for("example" => "foobar").should == multiple_matcher
+    end
+  end
+
+  describe "#matches?" do
+    context "all matchers pass" do
+      before do
+        foo_matcher.should_receive(:matches?).with(html).and_return(true)
+        bar_matcher.should_receive(:matches?).with(html).and_return(true)
+      end
+
+      subject { multiple_matcher.matches?(html) }
+      it      { should be_true }
+    end
+
+    context "some matchers fail" do
+      before do
+        foo_matcher.should_receive(:matches?).with(html).and_return(false)
+        bar_matcher.should_receive(:matches?).with(html).and_return(true)
+      end
+
+      subject { multiple_matcher.matches?(html) }
+      it      { should be_false }
+    end
+
+    context "all matchers fail" do
+      before do
+        foo_matcher.should_receive(:matches?).with(html).and_return(false)
+        bar_matcher.should_receive(:matches?).with(html).and_return(false)
+      end
+
+      subject { multiple_matcher.matches?(html) }
+      it      { should be_false }
+    end
+  end
+
+  describe "#failure_message" do
+    let(:failure_message_for_foo) { "failure message for foo" }
+    let(:failure_message_for_bar) { "failure message for bar" }
+
+    context "foo_matcher fails" do
+      before do
+        foo_matcher.should_receive(:matches?).with(html).and_return(false)
+        bar_matcher.should_receive(:matches?).with(html).and_return(true)
+        multiple_matcher.matches?(html)
+
+        foo_matcher.should_receive(:failure_message).and_return(failure_message_for_foo)
+      end
+
+      subject { multiple_matcher.failure_message }
+      it      { should == failure_message_for_foo }
+    end
+
+    context "bar_matcher fails" do
+      before do
+        foo_matcher.should_receive(:matches?).with(html).and_return(true)
+        bar_matcher.should_receive(:matches?).with(html).and_return(false)
+        multiple_matcher.matches?(html)
+
+        bar_matcher.should_receive(:failure_message).and_return(failure_message_for_bar)
+      end
+
+      subject { multiple_matcher.failure_message }
+      it      { should == failure_message_for_bar }
+    end
+
+    context "all matchers fail" do
+      before do
+        foo_matcher.should_receive(:matches?).with(html).and_return(false)
+        bar_matcher.should_receive(:matches?).with(html).and_return(false)
+        multiple_matcher.matches?(html)
+
+        foo_matcher.should_receive(:failure_message).and_return(failure_message_for_foo)
+        bar_matcher.should_receive(:failure_message).and_return(failure_message_for_bar)
+      end
+
+      subject { multiple_matcher.failure_message }
+      it      { should include(failure_message_for_foo) }
+      it      { should include(failure_message_for_bar) }
+      it      { should include(" and ") }
+    end
+  end
+
+  describe "#negative_failure_message" do
+    let(:negative_failure_message_for_foo) { "negative failure message for foo" }
+    let(:negative_failure_message_for_bar) { "negative failure message for bar" }
+
+    context "all matchers pass" do
+      before do
+        foo_matcher.should_receive(:matches?).with(html).and_return(true)
+        bar_matcher.should_receive(:matches?).with(html).and_return(true)
+        multiple_matcher.matches?(html)
+
+        foo_matcher.should_receive(:negative_failure_message).and_return(negative_failure_message_for_foo)
+        bar_matcher.should_receive(:negative_failure_message).and_return(negative_failure_message_for_bar)
+      end
+
+      subject { multiple_matcher.negative_failure_message }
+      it      { should include(negative_failure_message_for_foo) }
+      it      { should include(negative_failure_message_for_bar) }
+      it      { should include(" and ") }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'rspec-tag_matchers'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end
+
+RSpec::Matchers.define :match do |rendered|
+  match do |matcher|
+    matcher.matches?(rendered)
+  end
+end