elabs_matchers 0.0.3 → 0.0.4

data/lib/elabs_matchers/matchers/only_include.rb

@@ -0,0 +1,41 @@
+module ElabsMatchers
+  module Matchers
+    module OnlyInclude
+      rspec
+
+      class OnlyIncludeMatcher < Struct.new(:elements)
+        attr_reader :actual
+
+        def matches?(actual)
+          @actual = actual
+          elements.uniq.length == elements.length and
+          actual.length == elements.length and
+          elements.all? { |element| actual.include?(element) }
+        end
+
+        def failure_message_for_should
+          "Expected #{actual.inspect} to only include #{elements.inspect}."
+        end
+
+        def failure_message_for_should_not
+          "Expected #{actual.inspect} to not only include #{elements.inspect}, but it did."
+        end
+      end
+
+      ##
+      #
+      # Asserts if the array contains exactly the supplied elements.
+      # The order of the element do not have to match.
+      #
+      # @param [*Array] elements      Comma seperated list of arguments
+      #
+      # Example:
+      # ["foo", "bar"].should only_include("bar", "foo")
+      # ["foo", "bar"].should_not only_include("foo")
+
+      def only_include(*elements)
+        OnlyIncludeMatcher.new(elements)
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/persist.rb

@@ -0,0 +1,42 @@
+module ElabsMatchers
+  module Matchers
+    module Persist
+      rspec :type => :model
+
+      class PersistMatcher < Struct.new(:attribute, :value)
+        attr_reader :record
+
+        def matches?(record)
+          record.send(:"#{attribute}=", value)
+          record.save!
+          record = record.class.find(record.id)
+          @final_value = record.send(attribute)
+
+          @final_value == value
+        end
+
+        def failure_message_for_should
+          "Expected #{attribute} to be persisted and retain its value of #{value.inspect} but the value was #{@final_value.inspect}."
+        end
+
+        def failure_message_for_should_not
+          "Expected #{attribute} not to be persisted and retain its value of #{value.inspect} but it did."
+        end
+      end
+
+      ##
+      #
+      # Asserts if an assigned value persistes in the database.
+      #
+      # @param [Symbol] attribute       The name of the attibute to check if it persisted or not
+      # @param [Object] value           The value to persist to the attribute
+      #
+      # Example:
+      # post.should persist(:title, "Blog post")
+
+      def persist(attribute, value)
+        PersistMatcher.new(attribute, value)
+      end
+    end
+  end
+end

data/lib/elabs_matchers/version.rb

@@ -1,3 +1,3 @@
 module ElabsMatchers
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/elabs_matchers.rb

@@ -1,19 +1,99 @@
+require "rspec"
+
 module ElabsMatchers
   require "active_support/core_ext/hash/indifferent_access"
+  require "active_support/core_ext/object/blank"
+  require "active_support/core_ext/array/conversions"
   require "active_support/inflector"
+  require "rspec"
 
-  Dir[File.join(File.expand_path(File.dirname(__FILE__)), "elabs_matchers/**/*.rb")].each do |file|
-    require file unless file.split("/").last == "version.rb"
-  end
+  require "elabs_matchers/extensions/module"
+  require "elabs_matchers/helpers/fixtures"
+  require "elabs_matchers/helpers/normalize_keys"
+  require "elabs_matchers/helpers/reload_record"
+  require "elabs_matchers/helpers/select_year_and_month"
+
+  require "elabs_matchers/matchers/allow"
+  require "elabs_matchers/matchers/contain_hash"
+  require "elabs_matchers/matchers/have_attribute"
+  require "elabs_matchers/matchers/have_fields"
+  require "elabs_matchers/matchers/have_flash"
+  require "elabs_matchers/matchers/have_form_errors_on"
+  require "elabs_matchers/matchers/have_header"
+  require "elabs_matchers/matchers/have_image"
+  require "elabs_matchers/matchers/have_table_row"
+  require "elabs_matchers/matchers/only_include"
+  require "elabs_matchers/matchers/persist"
+
+  class << self
+    attr_accessor :header_selector, :header_selector_type
+    attr_accessor :attribute_selector, :attribute_selector_type
+    attr_accessor :flash_notice_selector, :flash_notice_selector_type, :flash_alert_selector, :flash_alert_selector_type
+    attr_accessor :form_errors_on_selector
+    attr_accessor :image_selector, :image_selector_type
+    attr_accessor :table_row_selector
 
-  RSpec.configure do |config|
-    Dir[File.join(File.expand_path(File.dirname(__FILE__)), "elabs_matchers/helpers/*.rb")].each do |file|
-      file = file.split("/").last.split(".").first
-      file = file[0].chr.upcase + file[1..-1]
-      module_to_include = eval("ElabsMatchers::Helpers::#{file}")
+    ##
+    #
+    # Configure ElabsMatchers to suit your needs. The spec/spec_helper.rb
+    # file is a good place to put your configurations in.
+    #
+    #     ElabsMatchers.configure do |config|
+    #       config.header_selector = "//h1"
+    #       config.header_selector_type = :xpath
+    #       config.image_selector = lambda { |src| "img[src='#{src}']" }
+    #     end
+    #
+    # === Configurable options
+    #
+    # [header_selctor = String]               The selector to use when finding header tags (Default: "h1,h2")
+    # [header_selector_type = Symbol]         The type of selector to use, :css or :xpath (Default: :css)
+    #
+    # [image_selctor = lamda]                 The selector to use when finding images (Default: see matcher)
+    # [image_selector_type = Symbol]          The type of selector to use, :css or :xpath (Default: :css)
+    #
+    # [attribute_selector = lambda]           A lambda that takes label and value as arguments and return a selector (Default: see matcher)
+    # [attribute_selector_type = Symbol]      The type of selector to use, :css or :xpath (Default: :xpath)
+    #
+    # [flash_notice_selector = String]        The selector to use when finding the flash notice (Default: "#flash.notice, #flash .notice, .flash.notice")
+    # [flash_notice_selector_type = Symbol]   The type of selector to use, :css or :xpath (Default: :css)
+    # [flash_alert_selector = String]         The selector to use when finding the flash alert (Default: "#flash.alert, #flash .alert, .flash.alert")
+    # [flash_alert_selector_type = Symbol]    The type of selector to use, :css or :xpath (Default: :css)
+    #
+    # [form_errors_on_selector = String]      A xpath expression to be used when finding associated error notices (Default: see matcher)
+    #
+    # [table_row_selector = lambda]           A lambda that takes table row return a selector (Default: see matcher)
 
-      config.include(module_to_include)
-      World(module_to_include) if defined?(World)
+    def configure
+      yield self
+    end
+
+    ##
+    #
+    # Reset Elabs matchers to use the default configuration.
+
+    def use_default_configuration!
+      configure do |config|
+        config.header_selector = "h1,h2"
+        config.header_selector_type = :css
+
+        config.image_selector = nil
+        config.image_selector_type = :css
+
+        config.attribute_selector = nil
+        config.attribute_selector_type = :xpath
+
+        config.flash_notice_selector = "#flash.notice, #flash .notice, .flash.notice"
+        config.flash_notice_selector_type = :css
+        config.flash_alert_selector = "#flash.alert, #flash .alert, .flash.alert"
+        config.flash_alert_selector_type = :css
+
+        config.form_errors_on_selector = nil
+
+        config.table_row_selector = nil
+      end
     end
   end
 end
+
+ElabsMatchers.use_default_configuration!

data/spec/elabs_matchers/helpers/fixtures_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ElabsMatchers::Helpers::Fixtures do
   describe "#fixture_file" do

data/spec/elabs_matchers/helpers/{common_spec.rb → normalize_keys_spec.rb}

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe ElabsMatchers::Helpers::Common do
+describe ElabsMatchers::Helpers::NormalizeKeys do
   describe "normalize_keys" do
     it "turns the keys into symbols" do
       normalize_keys("First name" => "Adam").keys.first.should == "first_name"

data/spec/elabs_matchers/helpers/{orm_spec.rb → reload_record_spec.rb}

@@ -1,6 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
+require "fixtures/post.rb"
 
-describe ElabsMatchers::Helpers::Orm do
+describe ElabsMatchers::Helpers::ReloadRecord do
   let(:post) { ElabsMatchers::Orm::Post.create(:title => "New") }
 
   describe "#save_and_reload" do

data/spec/elabs_matchers/helpers/select_year_and_month_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe ElabsMatchers::Helpers::SelectYearAndMonth do
+  let(:page) { Capybara::Session.new(:rack_test, proc { |env| [200, {}, [html]]}) }
+  let(:html) do
+    %Q{
+      <label for="post_date_1i">Date</label>
+      <select id="post_date_1i" name="post[date(1i)]">
+        <option value="2009" selected="selected">2009</option>
+        <option value="2010">2010</option>
+      </select>
+      <select id="post_date_2i" name="post[date(2i)]">
+        <option value="1" selected="selected">January</option>
+        <option value="2">February</option>
+      </select>
+    }
+  end
+
+  before do
+    page.extend(ElabsMatchers::Helpers::SelectYearAndMonth)
+    page.visit "/"
+  end
+
+  describe "#select_year_and_month" do
+    it "selects the year and momth selects" do
+      page.select_year_and_month("2010", "February", :from => "Date")
+
+      page.find("#post_date_1i").find("option[selected]").text.should == "2010"
+      page.find("#post_date_2i").find("option[selected]").text.should == "February"
+    end
+  end
+end

data/spec/elabs_matchers/matchers/{rspec/allow_spec.rb → allow_spec.rb}

@@ -1,6 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
+require "fixtures/post"
 
-describe ElabsMatchers::Matchers::Rspec::Allow do
+describe ElabsMatchers::Matchers::Allow do
   let(:post) { ElabsMatchers::Orm::Post.create }
   subject { post }
 
@@ -33,7 +34,7 @@ describe ElabsMatchers::Matchers::Rspec::Allow do
 
       it { expect { should allow("Elabs", "").as(:title) }.to fail_assertion }
       it { expect { should_not allow("", "Elabs").as(:title) }.to fail_assertion }
-      it { expect { should_not allow("", "Elabs").as(:signature) }.to fail_assertion }
+      it { should allow("", "Elabs").as(:signature) }
     end
 
     context "with several attributes" do
@@ -77,4 +78,4 @@ describe ElabsMatchers::Matchers::Rspec::Allow do
       it { expect { should_not allow(9, "9", "9e3", 0.1).as(:price) }.to fail_assertion }
     end
   end
-end
+end

data/spec/elabs_matchers/matchers/contain_hash_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe ElabsMatchers::Matchers::ContainHash do
+  describe "#contain_hash" do
+    context "with a simple hash" do
+      subject { { "foo" => "bar", "baz" => "quox" } }
+
+      it "returns true with the given value" do
+        should contain_hash({ "foo" => "bar" })
+        should contain_hash({ "baz" => "quox" })
+
+        expect { should contain_hash({ "foo" => "baz" }) }.to fail_assertion
+        expect { should contain_hash({ "bar" => "bar" }) }.to fail_assertion
+      end
+
+      it "returns false if key or value don't match" do
+        should_not contain_hash({ "foo" => "quox" })
+        should_not contain_hash({ "baz" => "bar" })
+
+        expect { should_not contain_hash({ "foo" => "bar" }) }.to fail_assertion
+      end
+    end
+
+    context "with a simple array" do
+      subject { %w[foo quox] }
+
+      it "returns true with the given value" do
+        should contain_hash(["foo"])
+        should contain_hash(["quox"])
+        should contain_hash(%w[foo quox])
+
+        expect { should contain_hash(["bar"]) }.to fail_assertion
+      end
+
+      it "returns false if the array doesn't contain the given value" do
+        should_not contain_hash(["blah"])
+        expect { should_not contain_hash(["foo"]) }.to fail_assertion
+      end
+    end
+
+    context "with a nested hash" do
+      subject { { "foo" => { "foo1" => "bar1", "foo2" => "bar2" }} }
+
+      it "returns true with the given value" do
+        should contain_hash({ "foo" => { "foo1" => "bar1" }})
+        should contain_hash({ "foo" => { "foo2" => "bar2" }})
+
+        expect { should contain_hash({ "foo" => { "foo1" => "bar2" }}) }.to fail_assertion
+        expect { should contain_hash({ "bar" => { "foo1" => "bar1" }}) }.to fail_assertion
+        expect { should contain_hash({ "foo" => { "foo2" => "bar1" }}) }.to fail_assertion
+      end
+
+      it "returns false if key or value don't match" do
+        should_not contain_hash({ "foo" => { "foo1" => "bar2" }})
+        should_not contain_hash({ "foo" => { "foo2" => "bar1" }})
+        should_not contain_hash({ "foo" => { "monkey" => "baz" }})
+        should_not contain_hash({ "foo" => "monkey" })
+
+        expect { should_not contain_hash({ "foo" => { "foo1" => "bar1" }}) }.to fail_assertion
+      end
+    end
+
+    context "with a nested array" do
+      subject { { "foo" => ["quox", { "bar" => "baz" }]} }
+
+      it "returns true with the given value" do
+        should contain_hash({ "foo" => [{ "bar" => "baz" }]})
+        should contain_hash({ "foo" => ["quox"]})
+
+        expect { should contain_hash({ "foo" => [{ "bar" => "quox" }] }) }.to fail_assertion
+        expect { should contain_hash({ "foo" => [{ "foo" => "baz" }] }) }.to fail_assertion
+        expect { should contain_hash({ "bar" => [{ "bar" => "baz" }] }) }.to fail_assertion
+        expect { should contain_hash({ "foo" => ["bar"] }) }.to fail_assertion
+      end
+
+      it "returns false if array doesn't contain the given sequence" do
+        should_not contain_hash({ "foo" => [{ "bar" => "quox" }]})
+        should_not contain_hash({ "foo" => ["bar"]})
+        should_not contain_hash({ "foo" => "monkey"})
+
+        expect { should_not contain_hash({ "foo" => [{ "bar" => "baz" }] }) }.to fail_assertion
+        expect { should_not contain_hash({ "foo" => ["quox"] }) }.to fail_assertion
+      end
+    end
+  end
+end

data/spec/elabs_matchers/matchers/have_attribute_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe ElabsMatchers::Matchers::HaveAttribute, :type => :feature do
+  describe "#have_attribute" do
+    subject { Capybara.string(html) }
+
+    shared_examples "a have attribute matcher" do
+      it "returns true when the label exists with the supplied value" do
+        should have_attribute("Title", "First")
+        should have_attribute("Title", "First")
+
+        expect { should have_attribute("Title", "Last") }.to fail_assertion
+        expect { should have_attribute("Name", "First") }.to fail_assertion
+      end
+
+      it "returns false when the label exists with but the value is wrong" do
+        should_not have_attribute("Title", "Wrong")
+        expect { should_not have_attribute("Title", "First") }.to fail_assertion
+      end
+
+      it "returns false when the label does not exist even if the value does" do
+        should_not have_attribute("Wrong", "First")
+      end
+    end
+
+    context "using default configuration" do
+      it_behaves_like "a have attribute matcher" do
+        let(:html) do
+          %Q{<div class="show_for post" id="post_1">
+            <p class="wrapper post_status"><strong class="label">Title</strong><br />First</p>
+            <p class="wrapper post_status"><strong class="label">Author</strong><br />Adam</p>
+          </div>}
+        end
+      end
+    end
+
+    context "configured with a css selector" do
+      before do
+        ElabsMatchers.attribute_selector_type = :css
+        ElabsMatchers.attribute_selector = lambda do |label, value|
+          "a[title='#{label}'] img[alt='#{value}']"
+        end
+      end
+
+      it_behaves_like "a have attribute matcher" do
+        let(:html) { %Q{<div><a title="Title"><img alt="First" src="/f.png"></a><a title="Author"><img alt="Adam" src="/a.png"></a></div>} }
+      end
+    end
+
+    context "configured with xpath selector" do
+      before do
+        ElabsMatchers.attribute_selector_type = :xpath
+        ElabsMatchers.attribute_selector = lambda do |label, value|
+          XPath.generate do |x|
+            x.descendant(:a)[x.attr(:title).contains(label)][x.contains(value)]
+          end
+        end
+      end
+
+      it_behaves_like "a have attribute matcher" do
+        let(:html) { %Q{<div><a title="Title">First</a><a title="Author">Adam</a></div>} }
+      end
+    end
+  end
+end

data/spec/elabs_matchers/matchers/have_fields_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe ElabsMatchers::Matchers::HaveFields, :type => :feature do
+  describe "#have_fields" do
+    let(:html) do
+      Capybara.string(%Q{
+        <form>
+          <label for="author">Author</label>
+          <input type="text" name="author" id="author" value="Adam" />
+          <label for="year">Year</label>
+          <input type="text" name="year" id="year" value="2011" />
+        </form>
+      })
+    end
+    subject { html }
+
+    it "returns true with several fields if both labels and values are correct" do
+      should have_fields("Author" => "Adam", "Year" => "2011")
+
+      expect { should have_fields("Author" => "Adam", "Year" => "2012") }.to fail_assertion
+      expect { should have_fields("Author" => "Adam", "Week" => "2011") }.to fail_assertion
+    end
+
+    it "returns true with one field if both labels and values are correct" do
+      should have_fields("Year" => "2011")
+      expect { should have_fields("Week" => "2011") }.to fail_assertion
+    end
+
+    it "returns false if the label is correct but the value is not" do
+      should_not have_fields("Author" => "David")
+      expect { should_not have_fields("Author" => "Adam") }.to fail_assertion
+    end
+
+    it "returns false if the label is correct but the value is not" do
+      should_not have_fields("Wrong" => "Adam")
+    end
+
+    it "returns false if the one of the pairs is incorrect" do
+      should_not have_fields("Author" => "Goliath", "Year" => "2012")
+
+      expect { should_not have_fields("Author" => "Adam", "Year" => "2012") }.to fail_assertion
+      expect { should_not have_fields("Author" => "Adam", "Year" => "2011") }.to fail_assertion
+    end
+  end
+end
+