elabs_matchers 0.0.1

data/lib/elabs_matchers/helpers/fixtures.rb

@@ -0,0 +1,21 @@
+module ElabsMatchers
+  module Helpers
+    module Fixtures
+
+      ##
+      #
+      # Opens a file from the fixtures directory.
+      #
+      # @param [String] file name      A file name, relative to the fixtures folder.
+      #
+      # Example:
+      # fixture_file("file.txt")
+      #
+
+      def fixture_file(path)
+        root = if defined?(Rails) then Rails.root else "../../../spec/" end
+        File.open(File.expand_path("#{root}/fixtures/#{path}", File.dirname(__FILE__)))
+      end
+    end
+  end
+end

data/lib/elabs_matchers/helpers/orm.rb

@@ -0,0 +1,32 @@
+module ElabsMatchers
+  module Helpers
+    module Orm
+      ##
+      #
+      # Finds the record from the database and return a new instance for that record.
+      #
+      # @param [Object] record      An instance of an ORM record
+      #
+      # Example:
+      # reload(post)
+
+      def reload(model)
+        model.class.find(model.id)
+      end
+
+      ##
+      #
+      # Saves the record and fetches it from the database and return a new instance for that record.
+      #
+      # @param [Object] record      An instance of an ORM record
+      #
+      # Example:
+      # save_and_reload(post)
+
+      def save_and_reload(model)
+        model.save!
+        reload(model)
+      end
+    end
+  end
+end

data/lib/elabs_matchers/helpers/session.rb

@@ -0,0 +1,26 @@
+module ElabsMatchers
+  module Helpers
+    module Session
+      ##
+      #
+      # Logs the user into the system. Requires that you login with an email and password
+      # and that your fields are named a certain way
+      # as well as there being a new_user_session path available.
+      #
+      # @param [Object] record      The user record
+      #
+      # Example:
+      # login_as(user)
+
+      attr_reader :current_user
+
+      def login_as(user)
+        visit(new_user_session_path)
+        fill_in('Email', :with => user.email)
+        fill_in('Password', :with => user.password)
+        click_button('Sign in')
+        @current_user = user
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/capybara/common.rb

@@ -0,0 +1,200 @@
+module ElabsMatchers
+  module Matchers
+    module Capybara
+      module Common
+        ##
+        #
+        # Asserts if the select input tag contains the given options.
+        #
+        # @param [Array] options      One or serveral strings seperated by comma
+        #
+        # Example:
+        # find(:xpath, XPath::HTML.select("My input label")).should have_options(options)
+
+        RSpec::Matchers.define :have_options do |*options|
+          match do |select|
+            options.all? { |option| select.all("option").map(&:text).include?(option) }
+          end
+
+          failure_message_for_should do |select|
+            actual_options = select.all("option").map(&:text).inspect
+            "expected options to include '#{options.flatten.inspect}' but it had the options #{actual_options}."
+          end
+          failure_message_for_should_not { |select| "expected options not to include '#{options.flatten.inspect}' but it did." }
+        end
+
+        ##
+        #
+        # Asserts if the supplied table row exists in the table
+        #
+        # @param [String] table name            The tables's caption text.
+        # @param [Hash] column value            A hash representing the column name and value in key-value form.
+        #
+        # Example:
+        # table.should have_table_row('Posts', "Title" => "First", :year => "2012")
+
+        RSpec::Matchers.define :have_table_row do |table_name, row|
+          match do |page|
+            table = page.find(:xpath, XPath::HTML.table(table_name))
+            row_index = nil
+
+            row.all? do |header, value|
+              col_index = table.all("thead th").index { |th| th.text.include?(header) }
+              col_index = if col_index then col_index + 1 else 0 end
+
+              current_row_index = table.all("tbody tr").index { |tr| tr.text.include?(value) }
+              correct_row = row_index.nil? || current_row_index == row_index
+              row_index = current_row_index
+
+              correct_row and table.has_xpath?(".//td[#{col_index}][contains(.,'#{value}')]")
+            end
+          end
+
+          failure_message_for_should do |page|
+            table = page.find(:xpath, XPath::HTML.table(table_name))
+            ascii_table = table.all('tr').map do |tr|
+              '| ' + tr.all('td,th').map { |td| td.text.strip.ljust(21) }.join(' | ') + ' |'
+            end.join("\n")
+            "expected #{row.inspect} to be included in the table #{table_name}, but it wasn't:\n\n#{ascii_table}"
+          end
+          failure_message_for_should_not { |page| "expected there to be no table #{table_name} with row #{row.inspect}, but there was." }
+        end
+
+        ##
+        #
+        # Asserts if the supplied show_for* attribute exists or not
+        #
+        # @param [String] label            The name of the attribute.
+        # @param [String] value            The value of the attribute.
+        #
+        # Example:
+        # page.should have_attribute("Status", "Pending")
+        #
+        # * https://github.com/plataformatec/show_for
+
+        RSpec::Matchers.define :have_attribute do |label, value|
+          match do |page|
+            xpath = XPath.generate { |x| x.descendant(:p)[x.attr(:class).contains('wrapper')][x.child(:strong).contains(label)][x.contains(value)] }
+            page.has_xpath?(xpath)
+          end
+
+          failure_message_for_should do |page|
+            attributes = page.all(:css, 'li.wrapper').map(&:text).to_sentence
+            "expected there to be an attribute #{label}: #{value}, but the only attributes were: #{attributes}."
+          end
+          failure_message_for_should_not { |page| "expected there to be no attribute #{label}: #{value}, but there was." }
+        end
+
+        ##
+        #
+        # Asserts if the supplied image exists or not
+        #
+        # @param [String] alt              The alt attribute content of the image
+        #
+        # Example:
+        # page.should have_image("Logo")
+
+        RSpec::Matchers.define :have_image do |alt|
+          match { |page| page.has_css?("img[alt=\"#{alt}\"]") }
+
+          failure_message_for_should do |page|
+            alts = page.all('img').map { |img| "'#{img[:alt]}'" }.to_sentence
+            "expected image alt to be '#{alt}' but it had the image alts: #{alts}."
+          end
+          failure_message_for_should_not { |page| "expected image not to be '#{alt}' but it was" }
+        end
+
+        ##
+        #
+        # Asserts if the supplied header exists or not
+        #
+        # @param [String] text              The content of the header
+        #
+        # Example:
+        # page.should have_header("Elabs")
+
+        RSpec::Matchers.define :have_header do |text|
+          match { |page| page.has_css?('h1,h2', :text => text) }
+
+          failure_message_for_should do |page|
+            headers = page.all('h1,h2').map { |h| "'#{h.text}'" }.to_sentence
+            "expected header to be '#{text}' but it had the headers #{headers}"
+          end
+          failure_message_for_should_not { |page| "expected header not to be '#{text}' but it was" }
+        end
+
+        ##
+        #
+        # Asserts if the supplied flash notice exists or not
+        #
+        # @param [String] text              The content of the flash notice
+        #
+        # Example:
+        # page.should have_flash_notice("Success")
+
+        RSpec::Matchers.define :have_flash_notice do |text|
+          match { |page| page.has_css?('#flash.notice', :text => text) }
+          failure_message_for_should { |page| "expected flash notice to be '#{text}' but was '#{page.find('#flash.notice').text}'" }
+          failure_message_for_should_not { |page| "expected flash notice not to be '#{text}' but it was" }
+        end
+
+        ##
+        #
+        # Asserts if the supplied flash alert exists or not
+        #
+        # @param [String] text              The content of the flash alert
+        #
+        # Example:
+        # page.should have_flash_alert("Error")
+
+        RSpec::Matchers.define :have_flash_alert do |text|
+          match { |page| page.has_css?('#flash.alert', :text => text) }
+          failure_message_for_should { |page| "expected flash alert to be '#{text}' but was '#{page.find('#flash.alert').text}'" }
+          failure_message_for_should_not { |page| "expected flash alert not to be '#{text}' but it was" }
+        end
+
+        ##
+        #
+        # Asserts if the supplied flash alert exists or not
+        #
+        # @param [String] label              The label content associated with the field.
+        # @param [String] message             The error message expected.
+        #
+        # Example:
+        # page.should have_form_errors_on("Name", "Can't be blank")
+
+        RSpec::Matchers.define :have_form_errors_on do |field, message|
+          xpath = %Q{..//span[contains(@class,'error')]}
+          match { |page| page.has_field?(field) and page.find_field(field).has_xpath?(xpath, :text => message) }
+
+          failure_message_for_should do |page|
+            error = page.find_field(field).all(:xpath, xpath).first
+            if not error
+              "expected field '#{field}' to have an error, but it didn't"
+            elsif error.text != message
+              "expected error message on #{field} to be '#{message}' but was '#{error.text}'"
+            else
+              raise "This should not happen"
+            end
+          end
+          failure_message_for_should_not { |page| "expected error message on '#{field}' not to be '#{text}' but it was" }
+        end
+
+        ##
+        #
+        # Asserts if the supplied fields exists or not
+        #
+        # @param [Hash] field name, value         A hash containing pairs of field name => value
+        #
+        # Example:
+        # page.should have_fields("Author" => "Adam", "Year" => "2011")
+
+        RSpec::Matchers.define :have_fields do |fields|
+          match { |page| fields.all? { |label, value| page.has_field?(label, :with => value.to_s) } }
+          failure_message_for_should { |page| "expected page to have the fields #{fields.inspect}, but it didn't." }
+          failure_message_for_should_not { |page| "expected page not to have the fields #{fields.inspect}, but it did." }
+        end
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/rspec/common.rb

@@ -0,0 +1,59 @@
+module ElabsMatchers
+  module Matchers
+    module Rspec
+      module Common
+        ##
+        #
+        # Asserts if the hash contains the supplied hash.
+        # Works with nested hashes and array of hashes.
+        #
+        # @param [Hash] options      Key => value pairs seperated by comma
+        #
+        # Example:
+        # { "foo" => ['quox', { 'bar' => 'baz'}]}.should contain_hash({ "foo" => [{ "bar" => "baz" }]})
+        # { "foo" => "bar", "baz" => "quox" }.should_not contain_hash({ "baz" => "bar" })
+
+        RSpec::Matchers.define :contain_hash do |expected|
+          match do |actual|
+            contains?(expected, actual)
+          end
+
+          def contains?(expected, actual)
+            return false unless actual.is_a?(expected.class)
+
+            if expected.is_a?(Array)
+              expected.all? do |expected_value|
+                actual.any? do |actual_value|
+                  contains?(expected_value, actual_value)
+                end
+              end
+            elsif expected.is_a?(Hash)
+              expected.all? do |key, value|
+                contains?(value, actual[key])
+              end
+            else
+              actual == expected
+            end
+          end
+        end
+
+        ##
+        #
+        # Asserts if the array contains exactly the supplied elements.
+        # The order of the element do not have to match.
+        #
+        # @param argument list options      comma seperated list of arguments
+        #
+        # Example:
+        # ["foo", "bar"].should only_include("bar", "foo")
+        # ["foo", "bar"].should_not only_include("foo")
+
+        RSpec::Matchers.define :only_include do |*collection|
+          match { |actual| actual.length == collection.length and collection.all? { |element| actual.include?(element) }  }
+          failure_message_for_should { |actual| "Expected #{actual.inspect} to only include #{collection.inspect}." }
+          failure_message_for_should_not { |actual| "Expected #{actual.inspect} to not only include #{collection.inspect}, but it did." }
+        end
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/rspec/orm.rb

@@ -0,0 +1,29 @@
+module ElabsMatchers
+  module Matchers
+    module Rspec
+      module Orm
+        ##
+        #
+        # Asserts if an assigned value persistes in the database.
+        #
+        # @param [Symbol] attribute name      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")
+
+        RSpec::Matchers.define :persist do |attribute, value|
+          match do |actual|
+            actual.send(:"#{attribute}=", value)
+            actual.save!
+            actual = actual.class.find(actual.id)
+            @final_value = actual.send(attribute)
+            @final_value == value
+          end
+          failure_message_for_should { |actual| "Expected #{attribute} to be persisted and retain its value of #{value.inspect} but the value was #{@final_value.inspect}" }
+          failure_message_for_should_not { |actual| "Expected #{attribute} not to be persisted and retain its value of #{value.inspect} but it did." }
+        end
+      end
+    end
+  end
+end

data/lib/elabs_matchers/orm/post.rb

@@ -0,0 +1,27 @@
+module ElabsMatchers
+  module Orm
+    class Post
+      attr_accessor :title
+
+      class << self
+        def find(id)
+          new(:title => @@persisted_post.title)
+        end
+
+        def create(attributes = {})
+          @@persisted_post = new(attributes)
+        end
+      end
+
+      def initialize(attributes = {})
+        self.title = attributes[:title]
+      end
+
+      def save!
+      end
+
+      def id
+      end
+    end
+  end
+end

data/lib/elabs_matchers/version.rb

@@ -0,0 +1,3 @@
+module ElabsMatchers
+  VERSION = "0.0.1"
+end

data/spec/elabs_matchers/cucumber/common_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe ElabsMatchers::Cucumber::Common do
+  describe "LIST_SEPARATOR" do
+    it "matches ," do
+      ", ".should =~ Cucumber::LIST_SEPARATOR
+    end
+
+    it "matches and" do
+      " and ".should =~ Cucumber::LIST_SEPARATOR
+    end
+
+    it "doesn't matches other things" do
+      "foo".should_not =~ Cucumber::LIST_SEPARATOR
+    end
+  end
+
+  describe "LIST_REGEXP" do
+    it "matches just one item" do
+      %Q{"Bart"}.should =~ Cucumber::LIST_REGEXP
+    end
+
+    it "matches a comma seperated list" do
+      %Q{"Bart", "Lisa"}.should =~ Cucumber::LIST_REGEXP
+    end
+
+    it "matches a 'and' seperated list" do
+      %Q{"Bart" and "Lisa"}.should =~ Cucumber::LIST_REGEXP
+    end
+
+    it "matches a comma and 'and' seperated list" do
+      %Q{"Bart", "Lisa" and "Homer"}.should =~ Cucumber::LIST_REGEXP
+    end
+
+    it "matches a comma and 'and' seperated list with several words" do
+      %Q{"Bart Simpsons", "Lisa Simpsons" and "Homer Simpsons"}.should =~ Cucumber::LIST_REGEXP
+    end
+
+    it "doesn't matches other things" do
+      %Q{foo}.should_not =~ Cucumber::LIST_REGEXP
+    end
+  end
+
+  describe "#human_list_to_array" do
+    it "converts a LIST_REGEXP-list to an array" do
+      human_list_to_array(%Q{"Bart", "Lisa" and "Homer"}).should == %w[Bart Lisa Homer]
+    end
+  end
+end