elabs_matchers 0.0.3 → 0.0.4

data/spec/elabs_matchers/matchers/have_flash_spec.rb

@@ -0,0 +1,97 @@
+require "spec_helper"
+
+describe ElabsMatchers::Matchers::HaveFlash, :type => :feature do
+  subject { Capybara.string(html + "<h1>Elabs</h1>") }
+
+  describe "#have_flash_notice" do
+    shared_examples "a have flash notice matcher" do
+      it "returns true if given the content of the flash notice" do
+        should have_flash_notice("Success")
+        expect { should have_flash_notice("Elabs") }.to fail_assertion
+      end
+
+      it "returns false if given content outside the flash notice" do
+        should_not have_flash_notice("Elabs")
+        expect { should_not have_flash_notice("Success") }.to fail_assertion
+      end
+
+      it "returns false if the content doesn't exist on the page" do
+        should_not have_flash_notice("Failure")
+      end
+    end
+
+    context "with default configuration" do
+      it_behaves_like "a have flash notice matcher" do
+        let(:html) { %Q{<div id="flash" class="notice">Success</div>} }
+      end
+    end
+
+    context "configured with xpath selector" do
+      before do
+        ElabsMatchers.flash_notice_selector_type = :xpath
+        ElabsMatchers.flash_notice_selector = XPath.descendant(:div)[XPath.attr(:class).contains("flash-notice")].to_s
+      end
+
+      it_behaves_like "a have flash notice matcher" do
+        let(:html) { %Q{<div class="flash-notice">Success</div>} }
+      end
+    end
+
+    context "configured with xpath selector" do
+      before do
+        ElabsMatchers.flash_notice_selector_type = :css
+        ElabsMatchers.flash_notice_selector = ".flash-notice"
+      end
+
+      it_behaves_like "a have flash notice matcher" do
+        let(:html) { %Q{<div class="flash-notice">Success</div>} }
+      end
+    end
+  end
+
+  describe "#have_flash_alert" do
+    shared_examples "a have flash alert matcher" do
+      it "returns true if given the content of the flash alert" do
+        should have_flash_alert("Failure")
+        expect { should have_flash_alert("Elabs") }.to fail_assertion
+      end
+
+      it "returns false if given content outside the flash alert" do
+        should_not have_flash_alert("Elabs")
+        expect { should_not have_flash_alert("Failure") }.to fail_assertion
+      end
+
+      it "returns false if the content doesn't exist on the page" do
+        should_not have_flash_alert("Success")
+      end
+    end
+
+    context "with default configuration" do
+      it_behaves_like "a have flash alert matcher" do
+        let(:html) { %Q{<div id="flash" class="alert">Failure</div>} }
+      end
+    end
+
+    context "configured with xpath selector" do
+      before do
+        ElabsMatchers.flash_alert_selector_type = :xpath
+        ElabsMatchers.flash_alert_selector = XPath.descendant(:div)[XPath.attr(:class).contains("flash-alert")].to_s
+      end
+
+      it_behaves_like "a have flash alert matcher" do
+        let(:html) { %Q{<div class="flash-alert">Failure</div>} }
+      end
+    end
+
+    context "configured with xpath selector" do
+      before do
+        ElabsMatchers.flash_alert_selector_type = :css
+        ElabsMatchers.flash_alert_selector = ".flash-alert"
+      end
+
+      it_behaves_like "a have flash alert matcher" do
+        let(:html) { %Q{<div class="flash-alert">Failure</div>} }
+      end
+    end
+  end
+end

data/spec/elabs_matchers/matchers/have_form_errors_on_spec.rb

@@ -0,0 +1,93 @@
+require "spec_helper"
+
+describe ElabsMatchers::Matchers::HaveFormErrorsOn, :type => :feature do
+  subject do
+    Capybara.string("<form>" + html + "</form>")
+  end
+
+  shared_examples "a form error matcher" do
+    it "returns true if the label and the error message is correct" do
+      should have_form_errors_on("Name", "can't be blank")
+
+      expect { should have_form_errors_on("Name", "must be royal") }.to fail_assertion
+      expect { should have_form_errors_on("Message", "can't be blank") }.to fail_assertion
+    end
+
+    it "returns false if the label is correct by the error message is wrong" do
+      should_not have_form_errors_on("Name", "Not good enough")
+      expect { should_not have_form_errors_on("Name", "can't be blank") }.to fail_assertion
+    end
+
+    it "returns false if the label is wrong by the error message is correct" do
+      should_not have_form_errors_on("Author", "can't be blank")
+    end
+  end
+
+  describe "#have_form_errors_on" do
+    context "with error as sibling to input" do
+      it_behaves_like "a form error matcher" do
+        let(:html) { %Q{
+          <span class="error">can't be blank</span>
+          <label for="name">Name</label>
+          <input type="text" name="name" id="name" value="" /> }
+        }
+      end
+    end
+
+    context "with input nested in label" do
+      it_behaves_like "a form error matcher" do
+        let(:html) { %Q{
+          <label for="name">
+            <input type="text" name="name" id="name" value="" />
+            Name
+          </label>
+          <span class="error">can't be blank</span>}
+        }
+      end
+    end
+  end
+
+  context "with error span outside input container" do
+    it_behaves_like "a form error matcher" do
+      let(:html) { %Q{
+        <div class="input string required field_with_errors">
+          <fieldset>
+            <label for="name">Name</label>
+            <input id="name" name="name" type="text" value="">
+          </fieldset>
+          <span class="error">can't be blank</span>
+        </div> }
+      }
+    end
+  end
+
+  context "with twitter bootstrap markup normal inputs" do
+    it_behaves_like "a form error matcher" do
+      let(:html) { %Q{
+        <div class="control-group error">
+          <label for="name">Name</label>
+          <div class="controls">
+            <input id="name" name="name" type="text" value="">
+            <p>can't be blank</p>
+          </div>
+        </div>}
+      }
+    end
+  end
+
+  context "with custom configured xpath selector" do
+    before do
+      ElabsMatchers.form_errors_on_selector = %Q{..//..//li[contains(@class,'error')]}
+    end
+
+    it_behaves_like "a form error matcher" do
+      let(:html) { %Q{
+        <ul>
+          <li><label for="name">Name</label></li>
+          <li><input type="text" name="name" id="name" value="" /></li>
+          <li class="error">can't be blank</li>
+        </ul>}
+      }
+    end
+  end
+end

data/spec/elabs_matchers/matchers/have_header_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe ElabsMatchers::Matchers::HaveHeader, :type => :feature do
+  describe "#have_header" do
+    let(:html) { Capybara.string(%Q{<div><h1>Elabs</h1><h2>Bespoke</h2><h3>Development</h3></div>}) }
+    subject { html }
+
+    it "returns true if given the content of a h1 tag" do
+      should have_header("Elabs")
+      expect { should have_header("Development") }.to fail_assertion
+    end
+
+    it "returns true if given the content of a h2 tag" do
+      should have_header("Bespoke")
+    end
+
+    it "returns false if given the content of a h3 tag" do
+      should_not have_header("Development")
+
+      expect { should_not have_header("Elabs") }.to fail_assertion
+      expect { should_not have_header("Bespoke") }.to fail_assertion
+    end
+
+    it "returns false if the content doesn't exist on the page" do
+      should_not have_header("Bugs")
+    end
+
+    shared_examples "a configured have header matcher" do
+      it "returns true if given the content of a h3" do
+        should have_header("Development")
+        expect { should_not have_header("Development") }.to fail_assertion
+      end
+
+      it "returns false if given the content of a h2" do
+        should_not have_header("Bespoke")
+        expect { should have_header("Bespoke") }.to fail_assertion
+      end
+    end
+
+    context "configured with a css selector" do
+      before { ElabsMatchers.header_selector = "h1,h3" }
+      it_behaves_like "a configured have header matcher"
+    end
+
+    context "configured with xpath selector" do
+      before do
+        ElabsMatchers.header_selector_type = :xpath
+        ElabsMatchers.header_selector = XPath.descendant(:h1, :h3).to_s
+      end
+
+      it_behaves_like "a configured have header matcher"
+    end
+  end
+end

data/spec/elabs_matchers/matchers/have_image_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe ElabsMatchers::Matchers::HaveImage, :type => :feature do
+  describe "#have_image" do
+    subject { Capybara.string("<div>" + html + "</div>") }
+
+    shared_examples "a have image matcher" do
+      it "returns true if the image exists on the page" do
+        should have_image("Logo")
+        expect { should have_image("Avatar") }.to fail_assertion
+      end
+
+      it "returns false if the image doesn't exist on the page" do
+        should_not have_image("Avatar")
+        expect { should_not have_image("Logo") }.to fail_assertion
+      end
+    end
+
+    context "with default configuration" do
+      it_behaves_like "a have image matcher" do
+        let(:html) { %Q{<img src="logo.png" alt="Logo" />} }
+      end
+    end
+
+    context "configured with css selector" do
+      before do
+        ElabsMatchers.image_selector_type = :css
+        ElabsMatchers.image_selector = lambda { |src| "img[class='#{src}']" }
+      end
+
+      it_behaves_like "a have image matcher" do
+        let(:html) { %Q{<img src="logo.png" class="Logo" />} }
+      end
+    end
+
+    context "configured with xpath selector" do
+      before do
+        ElabsMatchers.image_selector_type = :xpath
+        ElabsMatchers.image_selector = lambda do |src|
+          "//img[@class='#{src}']"
+        end
+      end
+
+      it_behaves_like "a have image matcher" do
+        let(:html) { %Q{<img src="logo.png" class="Logo" />} }
+      end
+    end
+  end
+end

data/spec/elabs_matchers/matchers/have_table_row_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe ElabsMatchers::Matchers::HaveTableRow, :type => :feature do
+  describe "#have_table_row" do
+    let(:header) { %Q{
+      <caption>Posts</caption>
+      <thead>
+        <tr><th>Title</th><th>Author</th></tr>
+      </thead>} }
+    subject { Capybara.string("<table>" + header + "<tbody>" + html + "</tbody></table>") }
+
+    shared_examples "a table row matcher" do
+      it "returns true when the one of the pairs in the row exists" do
+        should have_table_row("Posts", "Title" => "First")
+        expect { should have_table_row("Posts", "Foo" => "First") }.to fail_assertion
+      end
+
+      it "returns true when the all of the pairs in the row exists" do
+        should have_table_row("Posts", "Title" => "First", "Author" => "Adam")
+        expect { should have_table_row("Posts", "Title" => "First", "Author" => "Second") }.to fail_assertion
+      end
+
+      it "returns false when the header is wrong and the value is correct" do
+        should_not have_table_row("Posts", "Label" => "First")
+        expect { should_not have_table_row("Posts", "Title" => "First") }.to fail_assertion
+      end
+
+      it "returns false when the header is correct and the value is wrong" do
+        should_not have_table_row("Posts", "Title" => "Forth")
+        expect { should have_table_row("Posts", "Author" => "First") }.to fail_assertion
+      end
+
+      it "returns false when on of the pairs is wrong" do
+        should_not have_table_row("Posts", "Title" => "First", "Author" => "David")
+        expect { should have_table_row("Posts", "Title" => "First", "Author" => "David") }.to fail_assertion
+      end
+
+      it "returns false when given the value of another column" do
+        should_not have_table_row("Posts", "Title" => "Adam")
+        expect { should have_table_row("Posts", "Title" => "Adam") }.to fail_assertion
+      end
+
+      it "returns true when asking for existing blank value" do
+        should have_table_row("Posts", "Author" => "")
+        expect { should have_table_row("Posts", "Third" => "not empty") }.to fail_assertion
+      end
+
+      it "returns false when asking for non-existing blank value" do
+        should_not have_table_row("Posts", "Title" => "")
+        expect { should have_table_row("Posts", "Title" => "") }.to fail_assertion
+      end
+
+      it "returns false if there is no matching table" do
+        should_not have_table_row("Other", "Title" => "First")
+        expect { should_not have_table_row("Posts", "Title" => "First") }.to fail_assertion
+      end
+    end
+
+    context "with text node values" do
+      it_behaves_like "a table row matcher" do
+        let(:html) { %Q{
+          <tr><td>First</td><td>Adam</td></tr>
+          <tr><td>Second</td><td>David</td></tr>
+          <tr><td>Third</td><td></td></tr>}
+        }
+      end
+    end
+
+    context "with input field values" do
+      it_behaves_like "a table row matcher" do
+        let(:html) { %Q{
+          <tr>
+            <td><input type="text" value="First" /></td>
+            <td><input type="text" value="Adam" /></td>
+          </tr>
+          <tr>
+            <td><input type="text" value="Second" /></td>
+            <td><input type="text" value="David" /></td>
+          </tr>
+          <tr>
+            <td><input type="text" value="Third" /></td>
+            <td><input type="text" value="" /></td>
+          </tr>}
+        }
+      end
+    end
+
+    context "configured with xpath selecto" do
+      before do
+        ElabsMatchers.table_row_selector = lambda do |row, table|
+          exps = row.map do |header, value|
+            col_index = table.all("th").index { |th| th.text.include?(header.to_s) }
+            col_index = if col_index then col_index + 1 else 0 end
+
+            XPath.generate do |x|
+              cell = x.child(:td, :th)[col_index.to_s.to_sym]
+
+              if value.blank?
+                cell.child(:span)["not(node())".to_sym]
+              else
+                cell.child(:span)[x.contains(value)]
+              end
+            end
+          end
+
+          XPath.descendant["tr"][exps.reduce(:&)]
+        end
+      end
+
+      it_behaves_like "a table row matcher" do
+        let(:html) { %Q{
+          <tr><td><span>First<span></td><td><span>Adam<span></td></tr>
+          <tr><td><span>Second<span></td><td><span>David<span></td></tr>
+          <tr><td><span>Third<span></td><td><span></span></td></tr>}
+        }
+      end
+    end
+  end
+end

data/spec/elabs_matchers/matchers/only_include_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe ElabsMatchers::Matchers::OnlyInclude do
+  subject { %w[foo bar] }
+
+  describe "#only_include" do
+    it "returns true when all the elements are passed in the wrong order" do
+      should only_include("bar", "foo")
+      expect { should only_include("quox", "foo") }.to fail_assertion
+    end
+
+    it "returns false when given a present element several times" do
+      should_not only_include("foo", "foo")
+      expect { should only_include("foo", "foo") }.to fail_assertion
+    end
+
+    it "returns true when all the elements are passed in the correct order" do
+      should only_include("foo", "bar")
+      expect { should only_include("quox", "baz") }.to fail_assertion
+    end
+
+    it "returns false when one or more element is missing" do
+      should_not only_include("foo")
+      expect { should_not only_include("bar", "foo") }.to fail_assertion
+    end
+
+    it "returns false when one of the element is not in the list" do
+      should_not only_include("foo", "bar", "baz")
+      expect { should_not only_include("foo", "bar") }.to fail_assertion
+    end
+  end
+end