butternut 0.2.2-java

data/lib/butternut/helpers.rb

@@ -0,0 +1,103 @@
+module Butternut
+  module Helpers
+    def browser
+      @browser ||= Celerity::Browser.new
+    end
+
+    def visit(url)
+      browser.goto(url)
+      @page_changed = true
+    end
+
+    def current_url
+      browser.page.web_response.request_url.to_string
+    end
+
+    def current_page_source
+      return nil    unless browser.page
+
+      string_writer = java.io.StringWriter.new
+      print_writer  = java.io.PrintWriter.new(string_writer)
+
+      root = browser.page.document_element
+      node_to_xml(root, print_writer)
+      print_writer.close
+      string_writer.to_string
+    end
+
+    # Fill in a text field with a value
+    def fill_in(label_or_name, options = {})
+      elt = find_element_by_label_or_name(:text_field, label_or_name)
+      if elt.exist?
+        elt.value = options[:with]
+        @page_changed = true
+      end
+    end
+
+    def select(option_text, options = {})
+      elt = find_element_by_label_or_name(:select_list, options[:from])
+      if elt.exist?
+        elt.select(option_text)
+        @page_changed = true
+      end
+    end
+
+    def click_button(button_value)
+      browser.button(button_value).click
+      @page_changed = true
+    end
+
+    def page_changed?
+      @page_changed
+    end
+
+    def find_element_by_label_or_name(type, label_or_name)
+      elt = browser.send(type, :label, label_or_name)
+      elt.exist? ? elt : browser.send(type, :name, label_or_name)
+    end
+
+    private
+      # NOTE: I have to do this because HtmlUnit's asXml likes to put spaces
+      #       and newlines in the middle of whitespace-sensitive tags (like
+      #       <a> and <textarea>).  Fail.
+      def node_to_xml(node, print_writer)
+        closing_tag = false
+
+        case node
+        when HtmlUnit::Html::DomText
+          # just print out the text
+          print_writer.write(HtmlUnit::Util::StringUtils.escape_xml_chars(node.data))
+        when HtmlUnit::Html::DomCDataSection, HtmlUnit::Html::DomProcessingInstruction
+          # use default printXml here
+          node.print_xml("", print_writer)
+        when HtmlUnit::Html::DomComment
+          print_writer.write("<!-- #{node.data} -->")
+        when HtmlUnit::Html::HtmlTextArea
+          node_print_opening_tag(node, print_writer)
+          print_writer.write(node.text)
+          closing_tag = true
+        else
+          node_print_opening_tag(node, print_writer)
+          closing_tag = true
+        end
+
+        child = node.first_child
+        while child
+          node_to_xml(child, print_writer)
+          child = child.next_sibling
+        end
+
+        node_print_closing_tag(node, print_writer) if closing_tag
+      end
+
+      def node_print_opening_tag(node, print_writer)
+        print_writer.write("<")
+        node.print_opening_tag_content_as_xml(print_writer)
+        print_writer.write(">")
+      end
+
+      def node_print_closing_tag(node, print_writer)
+        print_writer.write("</#{node.tag_name}>")
+      end
+  end
+end

data/lib/butternut/scenario_extensions.rb

@@ -0,0 +1,7 @@
+module Butternut
+  module ScenarioExtensions
+    attr_accessor :last_page_source, :last_page_url
+  end
+end
+
+Cucumber::Ast::Scenario.send(:include, Butternut::ScenarioExtensions)

data/lib/butternut.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'cucumber'
+require 'celerity'
+
+module Butternut
+  def self.setup_hooks(obj)
+    obj.instance_exec do
+      AfterStep do |object|
+        if object.is_a?(Cucumber::Ast::Scenario)
+          if page_changed?
+            object.last_page_source = current_page_source
+            object.last_page_url    = current_url
+          else
+            object.last_page_source = nil
+            object.last_page_url    = nil
+          end
+          @page_changed = false
+        end
+      end
+    end
+  end
+end
+
+require File.dirname(__FILE__) + "/butternut/scenario_extensions"
+require File.dirname(__FILE__) + "/butternut/helpers"
+require File.dirname(__FILE__) + "/butternut/formatter"
+

data/spec/butternut/formatter_spec.rb

@@ -0,0 +1,146 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Butternut
+  describe Formatter do
+    extend SpecHelperDsl
+    include SpecHelper
+
+    def setup_formatter(options = {})
+      @out = StringIO.new
+      @formatter = Butternut::Formatter.new(step_mother, @out, options)
+    end
+
+    def most_recent_html_file(dir)
+      path = Pathname.new(dir)
+      files = path.entries.collect { |file|
+        path+file
+      }.sort { |file1,file2|
+        file2.mtime <=> file1.mtime
+      }
+      files.detect { |f| f.to_s =~ /\.html$/ }
+    end
+
+    it "should be a subclass of the html formatter" do
+      Butternut::Formatter.superclass.should == Cucumber::Formatter::Html
+    end
+
+    describe "running without the --out option" do
+      define_steps do
+        Given(/foo/) do
+          visit("file://" + File.expand_path(File.dirname(__FILE__) + "/../fixtures/foo.html"))
+        end
+      end
+
+      define_feature(<<-FEATURE)
+        Scenario: Monkey goes to the zoo
+          Given foo
+      FEATURE
+
+      it "should raise an error" do
+        lambda {
+          setup_formatter
+          run_defined_feature
+        }.should raise_error
+      end
+    end
+
+    describe "running with the --out option" do
+      before(:each) do
+        dir = File.join(File.dirname(__FILE__), "..", "..", "tmp")
+        @tmp_dir = File.join(dir, "#{Time.now.to_i}-#{rand(1000)}")
+        FileUtils.mkdir(@tmp_dir)
+
+        #@tmp_dir = File.join(dir, "features", Date.today.to_s)
+        #file = most_recent_html_file(@tmp_dir)
+        #@page_doc = Nokogiri.HTML(open(file).read)
+      end
+
+      describe "with a filename specified" do
+        define_steps do
+          Given(/foo/) do
+            visit("file://" + File.join(FIXTURE_DIR, "foo.html"))
+          end
+        end
+
+        define_feature(<<-FEATURE)
+          Scenario: Monkey goes to the zoo
+            Given foo
+            Then bar
+        FEATURE
+
+        before(:each) do
+          setup_formatter({
+            :formats => [
+              ['Butternut::Formatter', File.join(@tmp_dir, "output.html")]
+            ]
+          })
+          run_defined_feature
+          @doc = Nokogiri.HTML(@out.string)
+
+          file = most_recent_html_file(File.join(@tmp_dir, "output"))
+          @page_doc = Nokogiri.HTML(open(file).read)
+        end
+
+        it "creates assets directory" do
+          File.join(@tmp_dir, "output").should be_an_existing_directory
+        end
+
+        it "links to the page source" do
+          step = @doc.at('.feature .scenario .step.passed')
+          link = step.at("a")
+          link.should_not be_nil
+          file = link['href']
+          file.should match(%r{^output/butternut.+\.html})
+        end
+
+        it "saves images and stylesheets and rewrites urls in page source" do
+          @page_doc.at('img:nth(1)')['src'].should == "picard.jpg"
+          File.join(@tmp_dir, "output", "picard.jpg").should be_an_existing_file
+
+          @page_doc.at('link:nth(1)[rel="stylesheet"]')['href'].should == "foo.css"
+          File.join(@tmp_dir, "output", "foo.css").should be_an_existing_file
+
+          @page_doc.at('link:nth(2)[rel="stylesheet"]')['href'].should == "bar.css"
+          File.join(@tmp_dir, "output", "bar.css").should be_an_existing_file
+        end
+
+        it "saves assets and rewrites urls referred to by stylesheets" do
+          foo = open(File.join(@tmp_dir, "output", "foo.css")).read
+          foo.should include("url(facepalm.jpg)")
+          File.join(@tmp_dir, "output", "facepalm.jpg").should be_an_existing_file
+        end
+
+        it "turns off links" do
+          link = @page_doc.at('a')
+          link['href'].should == "#"
+          link.inner_html.should == "Picard song"
+        end
+
+        it "turns off scripts" do
+          @page_doc.css('script').length.should == 0
+        end
+
+        it "disables form elements" do
+          @page_doc.css('input, select, textarea').each do |elt|
+            elt['disabled'].should == "disabled"
+          end
+        end
+
+        it "handles Errno::ENOENT" do
+          @page_doc.at('img:nth(2)')['src'].should == "/roflpwnage/missing_file_omg.gif"
+        end
+
+        it "handles OpenURI::HTTPError" do
+          @page_doc.at('img:nth(3)')['src'].should == "http://google.com/missing_file_omg.gif"
+        end
+
+        it "handles Net::FTPPermError" do
+          @page_doc.at('img:nth(4)')['src'].should == "ftp://mirror.anl.gov/missing_file_omg.gif"
+        end
+
+        it "handles badly formed URI's" do
+        end
+      end
+    end
+  end
+end

data/spec/butternut/helpers_spec.rb

@@ -0,0 +1,132 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Butternut
+  describe Helpers do
+    include Helpers
+
+    def define_stub_chain
+      # This is what I hate about RSpec.
+      @stub_request_url = stub("fake request url", :to_string => "http://example.com")
+      @stub_response = stub("fake web response", :request_url => @stub_request_url)
+      @stub_page = stub("fake html page", {
+        :as_xml => "<cheese>pepperjack</cheese>",
+        :web_response => @stub_response
+      })
+      @stub_element = stub("fake element", :value= => nil, :select => nil, :click => nil, :exist? => true)
+      @stub_empty = stub("fake empty element", :exist? => false)
+
+      @stub_browser = stub("fake celerity browser", {
+        :goto => @stub_page, :page => @stub_page,
+        :text_field => @stub_element, :select_list => @stub_element,
+        :button => @stub_element
+      })
+      stub!(:browser).and_return(@stub_browser)
+    end
+
+    describe "#browser" do
+      it { browser.should be_a(Celerity::Browser) }
+    end
+
+    describe "#page_changed?" do
+      it { page_changed?.should_not be_true }
+    end
+
+    describe "#visit" do
+      before(:each) { define_stub_chain }
+
+      it "should go to the page" do
+        @stub_browser.should_receive(:goto).with("http://google.com")
+        visit("http://google.com")
+      end
+
+      it "should flag page as changed" do
+        visit("http://google.com")
+        page_changed?.should be_true
+      end
+    end
+
+    describe "#current_url" do
+      before(:each) { define_stub_chain }
+      it do
+        @stub_request_url.should_receive(:to_string).and_return("http://google.com")
+        current_url.should == "http://google.com"
+      end
+    end
+
+    describe "#current_page_source" do
+      before(:each) do
+        @browser = browser
+        visit("file://" + File.expand_path(File.dirname(__FILE__) + "/../fixtures/blargh.html"))
+      end
+
+      it "constructs the current page's source" do
+        # HtmlUnit's text node parsing it a little strange
+        expected = "<html><head>\n    <title>Blargh</title>\n  </head><body>\n    <p>Foo</p>\n    <p>Bar</p>\n  \n</body></html>"
+        current_page_source.should == expected
+      end
+
+      it "returns nil if page is nil" do
+        @browser.stub!(:page).and_return(nil)
+        current_page_source.should be_nil
+      end
+    end
+
+    describe "#fill_in" do
+      before(:each) { define_stub_chain }
+
+      it "should find by label" do
+        @stub_browser.should_receive(:text_field).with(:label, "pants").and_return(@stub_element)
+        @stub_element.should_receive(:value=).with("khakis")
+        fill_in("pants", :with => "khakis")
+      end
+
+      it "should find by name" do
+        @stub_browser.should_receive(:text_field).with(:label, "pants").and_return(@stub_empty)
+        @stub_browser.should_receive(:text_field).with(:name, "pants").and_return(@stub_element)
+        @stub_element.should_receive(:value=).with("khakis")
+        fill_in("pants", :with => "khakis")
+      end
+
+      it "should flag page as changed" do
+        fill_in("pants", :with => "khakis")
+        page_changed?.should be_true
+      end
+    end
+
+    describe "#select" do
+      before(:each) { define_stub_chain }
+
+      it "should find by label" do
+        @stub_browser.should_receive(:select_list).with(:label, "pants").and_return(@stub_element)
+        @stub_element.should_receive(:select).with("khakis")
+        select("khakis", :from => "pants")
+      end
+
+      it "should find by name" do
+        @stub_browser.should_receive(:select_list).with(:label, "pants").and_return(@stub_empty)
+        @stub_browser.should_receive(:select_list).with(:name, "pants").and_return(@stub_element)
+        @stub_element.should_receive(:select).with("khakis")
+        select("khakis", :from => "pants")
+      end
+
+      it "should flag page as changed" do
+        select("khakis", :from => "pants")
+        page_changed?.should be_true
+      end
+    end
+
+    describe "#click_button" do
+      before(:each) { define_stub_chain }
+      it do
+        @stub_browser.should_receive(:button).with("pants").and_return(@stub_element)
+        @stub_element.should_receive(:click)
+        click_button("pants")
+      end
+
+      it "should flag page as changed" do
+        click_button("pants")
+        page_changed?.should be_true
+      end
+    end
+  end
+end

data/spec/butternut_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Butternut do
+  describe "running a scenario" do
+    extend SpecHelperDsl
+    include SpecHelper
+
+    describe "saving last page info" do
+      define_steps do
+        Given('waffles') do
+          visit("file://" + File.expand_path(File.dirname(__FILE__) + "/fixtures/foo.html"))
+        end
+        AfterStep do |scenario|
+          begin
+            scenario.last_page_source.should match(/Foo/)
+            scenario.last_page_url.should match(/foo\.html/)
+          rescue Exception => e
+            p e
+          end
+        end
+      end
+
+      define_feature <<-FEATURE
+        Scenario: Roffle waffles
+          Given waffles
+      FEATURE
+
+      it { run_defined_feature }
+    end
+
+    describe "resetting page_changed" do
+      define_steps do
+        Given('waffles') do
+          visit("file://" + File.expand_path(File.dirname(__FILE__) + "/fixtures/foo.txt"))
+        end
+        AfterStep do |scenario|
+          begin
+            page_changed?.should be_false
+          rescue Exception => e
+            p e
+          end
+        end
+      end
+
+      define_feature <<-FEATURE
+        Scenario: Roffle waffles
+          Given waffles
+      FEATURE
+
+      it { run_defined_feature }
+    end
+  end
+end

data/spec/fixtures/blargh.html

@@ -0,0 +1,9 @@
+<html>
+  <head>
+    <title>Blargh</title>
+  </head>
+  <body>
+    <p>Foo</p>
+    <p>Bar</p>
+  </body>
+</html>

data/spec/fixtures/css/bar.css

@@ -0,0 +1,3 @@
+h1 {
+  font-size: 2em;
+}

data/spec/fixtures/foo.css

@@ -0,0 +1,9 @@
+body {
+  font-family: Verdana;
+}
+
+.facepalm {
+  width: 750px;
+  height: 600px;
+  background: url(../fixtures/facepalm.jpg);
+}

data/spec/fixtures/foo.html

@@ -0,0 +1,27 @@
+<html>
+  <head>
+    <title>Foo</title>
+    <link rel="stylesheet" href="foo.css" type="text/css"/>
+    <link rel="stylesheet" href="css/bar.css" type="text/css"/>
+    <script type="text/javascript" src="foo.js"></script>
+  </head>
+  <body>
+    Foo
+    <img src="picard.jpg"/>
+    <a href="http://picard.ytmnd.com/">Picard song</a>
+    <form action="foo.html" method="post">
+      <input type="text" name="foo" />
+      <select name="bar">
+        <option>pants</option>
+      </select>
+      <textarea name="yar"></textarea>
+      <input type="submit" value="Submit" />
+    </form>
+    <img src="/roflpwnage/missing_file_omg.gif"/>
+    <img src="http://google.com/missing_file_omg.gif"/>
+    <img src="ftp://mirror.anl.gov/missing_file_omg.gif"/>
+    <img src="//baduri/pants.png"/>
+
+    <div class="facepalm">&nbsp;</div>
+  </body>
+</html>

data/spec/fixtures/foo.js

@@ -0,0 +1,3 @@
+function picard() {
+  alert('Make it so!');
+}

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,97 @@
+require 'rubygems'
+gem 'rspec'
+require 'spec'
+require 'spec/autorun'
+require 'fileutils'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'butternut'
+
+require 'cucumber/rb_support/rb_language'
+require 'nokogiri'
+
+module SpecHelperDsl
+  attr_reader :feature_content, :step_defs
+
+  def define_feature(string)
+    @feature_content = string
+  end
+
+  def define_steps(&block)
+    @step_defs = block
+  end
+end
+
+module SpecHelper
+  def run_defined_feature
+    setup_world
+    define_steps
+    features = load_features(self.class.feature_content || raise("No feature content defined!"))
+    run(features)
+  end
+
+  def step_mother
+    @step_mother ||= Cucumber::StepMother.new
+  end
+
+  def load_features(content)
+    feature_file = Cucumber::FeatureFile.new('spec.feature', content)
+    features = Cucumber::Ast::Features.new
+    features.add_feature feature_file.parse(step_mother, {})
+    features
+  end
+
+  def run(features)
+    # options = { :verbose => true }
+    options = {}
+    tree_walker = Cucumber::Ast::TreeWalker.new(step_mother, @formatter ? [@formatter] : [], options, STDOUT)
+    tree_walker.visit_features(features)
+  end
+
+  def dsl
+    unless @dsl
+      rb = step_mother.load_programming_language('rb')
+      @dsl = Object.new
+      @dsl.extend Cucumber::RbSupport::RbDsl
+    end
+    @dsl
+  end
+
+  def define_steps
+    return unless step_defs = self.class.step_defs
+    dsl.instance_exec &step_defs
+  end
+
+  def setup_world
+    dsl.instance_exec do
+      Butternut.setup_hooks(self)
+      World(Butternut::Helpers)
+    end
+  end
+end
+
+FIXTURE_DIR = File.expand_path(File.join(File.dirname(__FILE__), "fixtures"))
+
+Spec::Matchers.define :be_an_existing_file do
+  match { |filename| File.exist?(filename) }
+end
+
+Spec::Matchers.define :be_an_existing_directory do
+  match { |filename| File.directory?(filename) }
+end
+
+Spec::Matchers.define :match_content_of do |expected|
+  match do |actual|
+    raise "expected file doesn't exist" unless File.exist?(expected)
+    raise "actual file doesn't exist"   unless File.exist?(actual)
+    open(expected).read == open(actual).read
+  end
+end
+
+
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    Cucumber::Parser::NaturalLanguage.instance_variable_set(:@languages, nil)
+  end
+end

data/tmp/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore