fracture 0.9.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in fracture.gemspec
+gemspec

data/README.md

@@ -0,0 +1,186 @@
+# Fracture
+Unified view testing for your view or controller specs.
+
+Fracture allows you to define text or selector once at the top of a spec file. It also allows grouping of multiple text or selectors snippets using one label.
+
+Defining what you are looking for in one place prevents issues when a name (or selector) you are searching for is changed on a view which would only result in one failing spec, the other spec checking for the non exisitence would not fail so you would not find this 'always' passing spec.
+
+
+### Example
+
+A simple example why would you use the fracture gem, assume you have the following tests (without Fracture)
+
+context "admin" 
+```ruby
+ response.body.should have_text("Edit")
+```
+...
+
+(Somewhere further down in your spec file)
+
+...
+
+context "user" 
+```ruby
+ response.body.should_not have_text("Edit")
+```
+If the word 'Edit' was changed in your view to 'Modify' the first test would fail although the second test would not fail. In a small spec this may be obvious to see although in a large file it might not be found. This would leave you with a never failing spec and if the logic controlling the display of this text broke and allowed for it to display when you are a user this would never be detected.
+
+####With Fracture:
+You define the text "Edit" once at the top of your spec and now it can be used multiple times within the spec. If you change the text in the view, you only need to change the Fracture.define_text(:show_edit_button, "Modify") and all test using that definition will change.
+```ruby
+Fracture.define_text(:show_edit_button, "Edit")
+```
+context "admin"
+```ruby
+response.body.should have_fracture(:show_edit_button)
+```
+context "user"
+```ruby
+response.body.should_not have_fracture(:show_edit_button)
+```
+
+## Installation:
+Gemfile
+``` 
+gem "fracture"
+```
+
+## Usage:
+spec_helper.rb
+```ruby
+config.after :all do
+  Fracture.clear
+end
+```
+This is to clear the set Fractures between each spec file
+
+
+#### In your spec
+If you want to test views from the controller spec you will need to add *render_views*, fracture will also work within view specs.
+
+```ruby
+require 'spec_helper'
+
+describe ContactsController do
+  render_views
+
+  Fracture.define_text(:add, "New")
+
+  context "as admin" do
+    describe "as an admin" do
+      it "index" do
+        login_as :admin # psuedo code for example
+        get :index
+        response.body.should have_fracture(:add)
+      end
+    end
+  end
+
+  context "as user" do
+    describe "as an user" do
+      it "index" do
+        login_as :user # psuedo code for example
+        get :index
+        response.body.should have_fracture(:add)
+      end
+    end
+  end
+end
+```
+
+## Definitions
+### Text
+Single
+```ruby
+Fracture.define_text(:edits, "Edit")
+```
+Multiple
+```ruby
+Fracture.define_text(:edits, "Edit", "Edit All")
+```
+### Selector
+```ruby
+Fracture.define_selector(:label_1, "#an_id", ".a_class", ".another_class")
+```
+
+Currently there is no way to build text and selectors into one definition (future feature). Another future feature will be to support 'within'.
+
+## Matchers
+Example Definitions
+```ruby
+Fracture.define_text(:label_1, "Fred")
+Fracture.define_text(:label_2, "Barney", "Betty")
+Fracture.define_text(:label_3, "Wilma")
+```
+
+Page should contain "Barney" and "Betty". Ignores any other definitions
+```ruby
+response.body.should have_fracture(:label_2)
+```
+
+Page should contain "Barney", "Betty", "Fred" and "Wilma"
+```ruby
+response.body.should have_fracture(:label_1, :label_2, :label_3)
+```
+or
+```ruby
+response.body.should have_all_fractures
+```
+
+Page should contain "Barney" and "Betty" and not "Fred" or "Wilma"
+```ruby
+response.body.should have_only_fractures(:label_2)
+```
+
+Page should contain "Barney", "Betty", "Fred" and not "Wilma"
+```ruby
+response.body.should have_all_fractures_except(:label_3)
+```
+
+### Forms
+Check to see if there is a form
+```ruby
+response.body.should have_a_form
+```
+Check to see if its a new form or editing (checks method is POST or PUT)
+```ruby
+response.body.should have_a_form.that_is_new
+response.body.should have_a_form.that_is_edit
+```
+Check to path form posts to
+```ruby
+response.body.should have_a_form.that_is_new.with_path_of("/tickets")
+response.body.should have_a_form.with_path_of(tickets_path)
+```
+
+
+## All Methods:
+
+* have_fracture(*labels)
+* have_all_fractures
+* have_all_fractures_except(*labels)
+* have_only_fractures(*labels)
+* have_a_form
+ - that_is_new
+ - that_is_edit
+ - with_path_of(path)
+
+# TODO
+
+* Support text and selector in one fracture
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+
+
+
+
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/fracture.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fracture/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fracture"
+  s.version     = FractureVersion::VERSION
+  s.authors     = ["Nigel Rausch"]
+  s.email       = ["nigelr@brisbanerails.com"]
+  s.homepage    = ""
+  s.summary     = %q{Unified View testing within Views or Controllers for RSpec}
+  s.description = %q{Fracture allows you to define and group view text or selectors in one place (at the top of a spec) and then refer to them with labels. This prevents issues when checking for existence and non existence of text/selectors if the views value changes only one spec will fail, using fracture you will update both instances}
+
+  s.rubyforge_project = "fracture"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "nokogiri"
+  s.add_runtime_dependency "rspec"
+
+  s.add_development_dependency "rake"
+end

data/lib/fracture.rb

@@ -0,0 +1,4 @@
+require "fracture/version"
+require "fracture/fracture"
+require "rspec"
+require "fracture/matchers/matcher.rb"

data/lib/fracture/fracture.rb

@@ -0,0 +1,112 @@
+class Fracture
+  attr_accessor :label, :items, :is_text
+
+  def initialize label, items, is_text
+    self.label = label
+    self.items = Array(items)
+    self.is_text = is_text
+  end
+
+  def self.define_text label, *items
+    @all ||= {}
+    raise "#{label} has already been defined" if @all[label.to_s]
+    @all[label.to_s] = self.new(label, items.flatten, true)
+  end
+
+  def self.define_selector label, *items
+    @all ||= {}
+    raise "#{label} has already been defined" if @all[label.to_s]
+    @all[label.to_s] = self.new(label, items.flatten, false)
+  end
+
+  def text?
+    !!is_text
+  end
+
+  def self.find label
+    #if labels.is_a? Array
+    #  ret = []
+    #  labels.map do |label|
+    #    p label
+    #    ret = all[label.to_s]
+    #    raise "Fracture with Label of '#{label}' was not found" unless ret
+    #  end
+    #  p ret
+    #else
+      raise "No Fractures have been defined" if all.empty?
+      ret = all[label.to_s]
+      raise "Fracture with Label of '#{label}' was not found" unless ret
+    #end
+    ret
+  end
+
+  def self.all
+    @all || {}
+  end
+
+  def self.clear
+    @all = {}
+  end
+
+  def self.list_to_s items
+    items.map { |item| item.to_s }
+  end
+
+  def self.have_only_test page, is_not, only_fractures
+    test_fractures page, is_not, only_fractures, all_keys_less(only_fractures)
+  end
+
+  def self.have_all_except_test page, is_not, except_fractures
+    test_fractures page, is_not, all_keys_less(except_fractures), except_fractures
+  end
+
+  def self.all_keys_less fractures
+    all.keys - list_to_s(Array(fractures).flatten)
+  end
+
+  def do_check page, label
+    #page = page.response.body if page.is_a? CompaniesController
+    page = Nokogiri::HTML.parse(page)
+    if text?
+      page.text.include?(label)
+    else
+      page.at label
+    end
+  end
+
+  def self.test_fractures(page, is_not, fracture_labels, reverse_fracture_labels=[])
+    failures = {}
+    failures[:should] = []
+    failures[:should_not] = []
+    Array(fracture_labels).flatten.each do |fracture_label|
+      fracture = Fracture.find(fracture_label)
+      fracture.items.each do |label|
+        if is_not
+          if fracture.do_check(page, label)
+            failures[:should_not] << {fracture_label: fracture_label, label: label}
+          end
+        else
+          unless fracture.do_check(page, label)
+            failures[:should] << {fracture_label: fracture_label, label: label}
+          end
+        end
+      end
+    end
+    Array(reverse_fracture_labels).flatten.each do |fracture_label|
+      fracture = Fracture.find(fracture_label)
+      fracture.items.each do |label|
+        unless is_not
+          if fracture.do_check(page, label)
+            failures[:should_not] << {fracture_label: fracture_label, label: label}
+          end
+        else
+          unless fracture.do_check(page, label)
+            failures[:should] << {fracture_label: fracture_label, label: label}
+          end
+        end
+      end
+    end
+    failures.merge!(passed: (failures[:should].empty? && failures[:should_not].empty?))
+    failures
+  end
+end

data/lib/fracture/matchers/matcher.rb

@@ -0,0 +1,113 @@
+RSpec::Matchers.define :have_fracture do |*fracture_labels|
+  match do |page|
+    @results = Fracture.test_fractures page, false, fracture_labels, nil
+    @results[:passed]
+  end
+
+  match_for_should_not do |page|
+    @results = Fracture.test_fractures page, true, fracture_labels, nil
+    @results[:passed]
+  end
+
+  failure_message_for_should { |actual| common_error(actual, @results) }
+  failure_message_for_should_not { |actual| common_error(actual, @results) }
+end
+
+RSpec::Matchers.define :have_all_fractures do
+  match do |page|
+    @results = Fracture.test_fractures page, false, Fracture.all.keys, nil
+    @results[:passed]
+  end
+
+  match_for_should_not do |page|
+    @results = Fracture.test_fractures page, true, Fracture.all.keys, nil
+    @results[:passed]
+  end
+
+  failure_message_for_should { |actual| common_error(actual, @results) }
+  failure_message_for_should_not { |actual| common_error(actual, @results) }
+end
+
+RSpec::Matchers.define :have_all_fractures_except do |*fracture_labels|
+  match do |page|
+    @results = Fracture.have_all_except_test(page, false, fracture_labels)
+    @results[:passed]
+  end
+
+  match_for_should_not do |page|
+    @results = Fracture.have_all_except_test(page, true, fracture_labels)
+    @results[:passed]
+  end
+
+  failure_message_for_should { |actual| common_error(actual, @results) }
+  failure_message_for_should_not { |actual| common_error(actual, @results) }
+end
+
+RSpec::Matchers.define :have_only_fractures do |*fracture_labels|
+  match do |page|
+    @results = Fracture.have_only_test(page, false, fracture_labels)
+    @results[:passed]
+  end
+
+  match_for_should_not do |page|
+    @results = Fracture.have_only_test(page, true, fracture_labels)
+    @results[:passed]
+  end
+
+  failure_message_for_should { |actual| common_error(actual, @results) }
+  failure_message_for_should_not { |actual| common_error(actual, @results) }
+end
+
+def common_error(actual, results)
+  errors = ""
+  unless results[:should].empty?
+    errors += "expected to find '#{results[:should].map { |i| i[:label] }.join(", ")}'"
+  end
+  unless results[:should_not].empty?
+    errors += "expected not to find '#{results[:should_not].map { |i| i[:label] }.join(", ")}'"
+  end
+  errors += "\non page of\n #{actual}"
+end
+
+RSpec::Matchers.define :have_a_form do
+  match do |page|
+    page = Nokogiri::HTML.parse(page)
+    @edit_found = page.at("input[type='hidden'][name='_method'][value='put']")
+    @has_form = page.at("form[method='post']")
+    #TODO refactor this
+    #@found_action = page.at("form[action]").try(:attributes).try(:fetch, "action", nil).try(:value)
+    @found_action = page.at("form[action]") &&
+        page.at("form[action]").attributes &&
+        page.at("form[action]").attributes.fetch("action", nil) &&
+        page.at("form[action]").attributes.fetch("action", nil).value
+    @has_form && !(@new_form && @edit_found) && (!@edit_form || @edit_found) && (!@expected_path || (@found_action == @expected_path))
+  end
+
+  match_for_should_not do |page|
+    raise "Cannot use should_not chained with .is_for, .that_is_edit or .with_path_of " if @new_form || @edit_form || @expected_path
+    page = Nokogiri::HTML.parse(page)
+    !page.at("form[method='post']")
+  end
+
+  #chain(:for_action) { |action #new:edit| @new_form = true }
+  chain(:that_is_new) { @new_form = true }
+  chain(:that_is_edit) { @edit_form = true }
+  #chain(:with_path) { |path| @expected_path = path }
+  chain(:with_path_of) { |path| @expected_path = path }
+  failure_message_for_should do
+    ret = case
+      when !@has_form
+        "expected to find a form on the page\n"
+      when @new_form && @edit_found
+        'Form is an edit'
+      when @edit_form && !@edit_found
+        'Form is not an edit'
+      when @expected_path
+        "Expected to find forms action of '/#{@expected_path}' but found '/#@found_action'"
+      else
+        raise "Unexpected have_form state."
+    end
+    ret
+  end
+  failure_message_for_should_not { "expected not to find a form on the page" }
+end

data/lib/fracture/version.rb

@@ -0,0 +1,3 @@
+module FractureVersion
+  VERSION = "0.9.0"
+end

data/spec/fracture_spec.rb

@@ -0,0 +1,75 @@
+require "rspec"
+require "fracture/fracture"
+require 'nokogiri'
+
+
+describe Fracture do
+
+  before { Fracture.clear }
+
+  context "without data" do
+    it("should be empty before use") { Fracture.all.should == {} }
+    it "should not fail when no data set" do
+      expect {Fracture.find(:nothing) }.to raise_error(RuntimeError, /No Fractures have been defined/)
+    end
+  end
+
+  context "with data" do
+    before do
+      @first = Fracture.define_text(:a, "a")
+      Fracture.define_text(:bc, "b", "c")
+      Fracture.define_selector(:x, "x")
+      Fracture.define_selector(:yz, "y", "z")
+    end
+
+    describe "#clear" do
+      before { Fracture.clear }
+      it("should clear all") { Fracture.all.should == {} }
+    end
+
+    describe ".text?" do
+      it("should be text search") { Fracture.find(:a).text?.should be_true }
+      it("should not be text search") { Fracture.find(:x).text?.should be_false }
+    end
+
+    context "reuse" do
+      context "of same text label" do
+        it("should raise error if a label is reused") { expect { Fracture.define_text(:bc, "reused") }.to raise_error(RuntimeError, /bc has already been defined/) }
+      end
+      context "of same selector label" do
+        it("should raise error if a label is reused") { expect { Fracture.define_selector(:x, "reused") }.to raise_error(RuntimeError, /x has already been defined/) }
+      end
+    end
+
+    context "reuse of same text or selector" do
+      it "should display warning when same text is defined"
+      it "should display warning when same label is defined"
+    end
+
+    describe "#find" do
+      context "existing" do
+        it("should find label using symbol") { Fracture.find(:a).items == ["a"] }
+        it("should find label using string") { Fracture.find("a").items == ["a"] }
+      end
+      context "should raise error if label does not exist" do
+        it("single") { expect { Fracture.find(:ab) }.to raise_error(RuntimeError, /Fracture with Label of 'ab' was not found/) }
+      end
+    end
+
+    describe "#all" do
+      context "should return all Fractures" do
+        subject {Fracture.all }
+        its(:length) {should == 4}
+        its(:keys) {should =~ ["a", "bc", "x", "yz"]}
+      end
+    end
+
+    #TODO move from matcher_spec
+    describe "test_fracture"
+
+    describe ".do_check" do
+      it("should find it") { @first.do_check("z a b", "a").should be_true }
+      it("should not find it") { @first.do_check("z b", "a").should be_false }
+    end
+  end
+end

data/spec/matcher_spec.rb

@@ -0,0 +1,350 @@
+require 'rspec'
+require 'nokogiri'
+require "fracture/fracture"
+require "fracture/matchers/matcher"
+
+describe Fracture do
+  context "form" do
+    context "when no form exists" do
+      before { @page = "<p>not a form</p>" }
+      it("should not have a form") { @page.should_not have_a_form }
+      it("should have a form") { expect { @page.should have_a_form }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected to find a form on the page/) }
+    end
+    context "when form exists" do
+      before { @page = "<form method='post' action='/companies'>" }
+      it("should have a form") { @page.should have_a_form }
+      it("should not have a form") { expect { @page.should_not have_a_form }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected not to find a form on the page/) }
+      context "that_is_new" do
+        it("should be a new form") { @page.should have_a_form.that_is_new }
+        it("should not be an edit") { expect { @page.should have_a_form.that_is_edit }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /Form is not an edit/) }
+      end
+      context "that_is_edit" do
+        before { @page += "<input type='hidden' name='_method' value='put'>" }
+        it "should not be a new form" do
+          expect { @page.should have_a_form.that_is_new }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /Form is an edit/)
+        end
+        it("should be an edit form") { @page.should have_a_form.that_is_edit }
+        it("should have a form") { @page.should have_a_form }
+      end
+      context "with_path_of" do
+        it "should match path" do
+          @page.should have_a_form.with_path_of("/companies")
+        end
+        it "should not match path" do
+          expect { @page.should have_a_form.with_path_of("/fred") }.to raise_error(RSpec::Expectations::ExpectationNotMetError, "Expected to find forms action of '//fred' but found '//companies'")
+        end
+      end
+    end
+    context "not support should_not when chained" do
+      it "should raise error if that_is_edit" do
+        expect { @page.should_not have_a_form.that_is_edit }.to raise_error(RuntimeError, "Cannot use should_not chained with .is_for, .that_is_edit or .with_path_of ")
+      end
+      it "should raise error if that_is_new" do
+        expect { @page.should_not have_a_form.that_is_new }.to raise_error(RuntimeError, "Cannot use should_not chained with .is_for, .that_is_edit or .with_path_of ")
+      end
+      it "should raise error if with_path_of" do
+        expect { @page.should_not have_a_form.with_path_of("/abc") }.to raise_error(RuntimeError, "Cannot use should_not chained with .is_for, .that_is_edit or .with_path_of ")
+      end
+    end
+  end
+
+  context "Fracture" do
+    it "non existent fracture label" do
+      expect { @page.should have_fracture(:dont_exist) }.to raise_error(RuntimeError, "Fracture with Label of 'dont_exist' was not found")
+    end
+
+    before do
+      Fracture.clear
+      @page = <<sample
+                  <h1>Opening</h1>
+                  <table>
+                    <tr>
+                      <th>abc</th>
+                      <th>def</th>
+                    </tr>
+                    <tr>
+                      <td class='left'>123</td>
+                      <td id='second'>456</td>
+                    </tr>
+                  </table>
+                  <p class='big'>Title 1</p>
+                  The Main Body
+sample
+
+      Fracture.define_text(:text_1, "Title 1")
+      Fracture.define_text(:text_2, "Main", "Opening")
+    end
+
+    let(:nsel_1) { Fracture.define_selector(:nsel_1, "table > td") }
+    let(:ntext_1) { Fracture.define_text(:ntext_1, "sex") }
+    let(:b11) { Fracture.define_text(:b11, "please") }
+    let(:bb1) { Fracture.define_text(:bb1, "Main", "sex") }
+    let(:bb2) { Fracture.define_text(:bb2, "Sex", "Main") }
+    let(:bb3) { Fracture.define_text(:bb3, "Sex", "please") }
+
+    context "when selector" do
+      describe "Fracture" do
+        before do
+          Fracture.define_selector(:sel_1, "tr>td:contains('123')")
+          Fracture.define_selector(:sel_2, "tr>th:contains('abc')", "tr>td:contains('456')")
+        end
+
+        it "should find sel_1" do
+          Fracture.test_fractures(@page, false, :sel_1).should == {passed: true, should: [], should_not: []}
+        end
+        it 'should find sel_2' do
+          Fracture.test_fractures(@page, false, :sel_2).should == {passed: true, should: [], should_not: []}
+        end
+        it "should not have sel_1 present" do
+          Fracture.test_fractures(@page, true, :sel_1).should == {passed: false,
+                                                                  should: [],
+                                                                  should_not: [{fracture_label: :sel_1, label: "tr>td:contains('123')"}]}
+        end
+        it "cant find nsel_1 on page" do
+          nsel_1
+          Fracture.test_fractures(@page, false, :nsel_1).should == {passed: false,
+                                                                    should: [{fracture_label: :nsel_1, :label => "table > td"}],
+                                                                    should_not: []}
+        end
+        it "should not find nsel_1 on page" do
+          nsel_1
+          Fracture.test_fractures(@page, true, :nsel_1).should == {passed: true,
+                                                                   should: [],
+                                                                   should_not: []}
+        end
+      end
+
+      context "have_fracture" do
+        it "should find fracture of :class_1" do
+          Fracture.define_selector(:class_1, "td.left")
+          @page.should have_fracture :class_1
+        end
+        it "should find fracture of :id_1" do
+          Fracture.define_selector(:id_1, "td#second")
+          @page.should have_fracture :id_1
+        end
+        it "should not find missing fracture" do
+          Fracture.define_selector(:id_2, "th#second")
+          @page.should_not have_fracture :id_2
+        end
+        it "should fail to find a fracture" do
+          Fracture.define_selector(:id_3, "th#second")
+          expect { @page.should have_fracture(:id_3) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected to find 'th#second'/)
+        end
+      end
+    end
+
+    context "when text" do
+      describe "Fracture" do
+        context "when passing only one fracture list" do
+          context "should" do
+            context "when 1 fracture" do
+              it "1 found" do
+                Fracture.test_fractures(@page, false, :text_1).should == {passed: true, should: [], should_not: []}
+              end
+              it "2 found" do
+                Fracture.test_fractures(@page, false, :text_2).should == {passed: true, should: [], should_not: []}
+              end
+              it "1 not found" do
+                ntext_1
+                Fracture.test_fractures(@page, false, :ntext_1).should == {passed: false,
+                                                                      should: [{fracture_label: :ntext_1, label: "sex"}],
+                                                                      should_not: []}
+              end
+              it "2 not found" do
+                bb3
+                Fracture.test_fractures(@page, false, :bb3).should == {passed: false,
+                                                                       should: [{fracture_label: :bb3, label: "Sex"}, {fracture_label: :bb3, label: "please"}],
+                                                                       should_not: []}
+              end
+              it "1 not found and 1 found" do
+                bb1
+                Fracture.test_fractures(@page, false, :bb1).should == {passed: false,
+                                                                       should: [{fracture_label: :bb1, label: "sex"}],
+                                                                       should_not: []}
+              end
+            end
+            context "when list of 2 fractures" do
+              it "3 found" do
+                Fracture.test_fractures(@page, false, [:text_1, :text_2]).should == {passed: true, should: [], should_not: []}
+              end
+              it "2 not found" do
+                ntext_1
+                b11
+                Fracture.test_fractures(@page, false, [:ntext_1, :b11]).should == {passed: false,
+                                                                              should: [{:fracture_label => :ntext_1, :label => "sex"}, {:fracture_label => :b11, :label => "please"}],
+                                                                              should_not: []}
+              end
+            end
+          end
+          context "should_not" do
+            context "when 1 fracture" do
+              it "1 found (not)" do
+                Fracture.test_fractures(@page, true, :text_1).should == {passed: false,
+                                                                         should_not: [{fracture_label: :text_1, label: "Title 1"}],
+                                                                         should: []}
+              end
+              it "not found" do
+                ntext_1
+                Fracture.test_fractures(@page, true, :ntext_1).should == {passed: true, should: [], should_not: []}
+              end
+              it "not found multi" do
+                bb3
+                Fracture.test_fractures(@page, true, :bb3).should == {passed: true, should: [], should_not: []}
+              end
+            end
+            context "when list of 2 fractures" do
+              it "3 found" do
+                Fracture.test_fractures(@page, true, [:text_1, :text_2]).should == {passed: false,
+                                                                                    should_not: [{:fracture_label => :text_1, :label => "Title 1"},
+                                                                                                 {:fracture_label => :text_2, :label => "Main"},
+                                                                                                 {:fracture_label => :text_2, :label => "Opening"}],
+                                                                                    should: []}
+              end
+              it "2 not found" do
+                ntext_1
+                b11
+                Fracture.test_fractures(@page, true, [:ntext_1, :b11]).should == {passed: true, should: [], should_not: []}
+              end
+            end
+          end
+        end
+        context "when passing 2 fracture lists (should find and should not find)" do
+          context "should" do
+            it "exist 1 found and not exist 1 not found" do
+              ntext_1
+              Fracture.test_fractures(@page, false, [:text_1], [:ntext_1]).should == {passed: true, should: [], should_not: []}
+            end
+
+            it "should not find text_2" do
+              Fracture.test_fractures(@page, false, [:text_1], [:text_2]).should == {passed: false, should: [],
+                                                                                     should_not: [{:fracture_label => :text_2, :label => "Main"}, {:fracture_label => :text_2, :label => "Opening"}]}
+            end
+            it "should not find text_1" do
+              ntext_1
+              Fracture.test_fractures(@page, false, [:ntext_1], [:text_1]).should == {passed: false, should:
+                  [{:fracture_label => :ntext_1, :label => "sex"}], should_not: [{fracture_label: :text_1, label: "Title 1"}]}
+            end
+          end
+          context "when should_not" do
+            it "should not find ntext_1 and should find text_1 " do
+              ntext_1
+              Fracture.test_fractures(@page, true, [:ntext_1], [:text_1]).should == {passed: true, should: [], should_not: []}
+            end
+
+            it "exist 1 found and not exist 1 not found" do
+              ntext_1
+              Fracture.test_fractures(@page, true, [:text_1], [:ntext_1]).should == {passed: false,
+                                                                                should: [{:fracture_label => :ntext_1, :label => "sex"}],
+                                                                                should_not: [{fracture_label: :text_1, label: "Title 1"}]}
+            end
+            it "text_1 should_not appear on the page and text_2 should" do
+              Fracture.test_fractures(@page, true, [:text_1], [:text_2]).should == {passed: false,
+                                                                                    should_not: [{fracture_label: :text_1, label: "Title 1"}],
+                                                                                    should: []}
+            end
+          end
+        end
+        context "have_fracture" do
+          context "should" do
+            it "match single" do
+              @page.should have_fracture(:text_1)
+            end
+            it "should match multiple" do
+              @page.should have_fracture(:text_2)
+            end
+            it "should not match multiple when 2nd fracture item does not match" do
+              bb1
+              expect { @page.should have_fracture(:bb1) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected to find 'sex'/)
+            end
+            it "should match with multiple arguments" do
+              @page.should have_fracture(:text_2, :text_1)
+            end
+            it "should not match with multiple argument when last item does not match" do
+              ntext_1
+              expect { @page.should have_fracture(:text_2, :text_1, :ntext_1) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected to find 'sex'/)
+            end
+            it "should fail with missing element" do
+              ntext_1
+              expect { @page.should have_fracture(:ntext_1) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected to find 'sex'/)
+            end
+          end
+          context "should not" do
+            it "fails not match single" do
+              expect { @page.should_not have_fracture(:text_1) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected not to find 'Title 1'/)
+            end
+            it "should not match multiple when 2nd fracture item does exist" do
+              bb2
+              expect { @page.should_not have_fracture(:bb2) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected not to find 'Main'/)
+            end
+            it "should fail when last fracture has items that exist on pag" do
+              bb2
+              bb3
+              expect { @page.should_not have_fracture(:bb3, :bb2) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected not to find 'Main'/)
+            end
+            it "should fail when first fracture has items that exist on pag" do
+              bb2
+              bb3
+              expect { @page.should_not have_fracture([:bb2, :bb3]) }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected not to find 'Main'/)
+            end
+            it "should pass when no items exist" do
+              bb3
+              @page.should_not have_fracture(:bb3)
+            end
+          end
+        end
+      end
+    end
+
+    describe "have_all_fractures" do
+      it "all" do
+        @page.should have_all_fractures
+      end
+      it "not have :ntext_1" do
+        ntext_1
+        expect { @page.should have_all_fractures }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected to find 'sex'/)
+      end
+      it "not have any fractures" do
+        Fracture.clear
+        bb3
+        @page.should_not have_all_fractures
+      end
+    end
+
+    describe "have_all_fractures_except" do
+      it "should have all except ntext_1" do
+        ntext_1
+        @page.should have_all_fractures_except :ntext_1
+      end
+      it "fails when find text_2 on page" do
+        expect { @page.should have_all_fractures_except :text_2 }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected not to find 'Main, Opening'/)
+      end
+
+      it "fails when should_not finds text_1 on the page" do
+        expect { @page.should_not have_all_fractures_except :text_2 }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected not to find 'Title 1'/)
+      end
+
+      it "none" do
+        Fracture.clear
+        Fracture.define_text(:text_1, "Title 1")
+        @page.should_not have_all_fractures_except :text_1
+      end
+    end
+    describe "have_only_fractures" do
+      it "should have only text_1 and text_2" do
+        @page.should have_only_fractures :text_1, :text_2
+      end
+      it "should have only text_1 and text_2 and ignore ntext_1" do
+        ntext_1
+        @page.should have_only_fractures :text_1, :text_2
+      end
+      it "should raise error when one exists" do
+        expect { @page.should have_only_fractures :text_2 }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected not to find 'Title 1'/)
+      end
+      it "should raise error when expected item to exist" do
+        ntext_1
+        expect { @page.should have_only_fractures :text_1, :text_2, :ntext_1 }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected to find 'sex'/)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: fracture
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+  prerelease: 
+platform: ruby
+authors:
+- Nigel Rausch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fracture allows you to define and group view text or selectors in one
+  place (at the top of a spec) and then refer to them with labels. This prevents issues
+  when checking for existence and non existence of text/selectors if the views value
+  changes only one spec will fail, using fracture you will update both instances
+email:
+- nigelr@brisbanerails.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- fracture.gemspec
+- lib/fracture.rb
+- lib/fracture/fracture.rb
+- lib/fracture/matchers/matcher.rb
+- lib/fracture/version.rb
+- spec/fracture_spec.rb
+- spec/matcher_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: fracture
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Unified View testing within Views or Controllers for RSpec
+test_files:
+- spec/fracture_spec.rb
+- spec/matcher_spec.rb