konacha 2.0.0.beta2 → 2.0.0.beta3

data/lib/konacha/reporter/metadata.rb

@@ -0,0 +1,81 @@
+# The Metadata class mimics the public interface of RSpec::Core::Metadata.
+
+module Konacha
+  class Reporter
+    class SpecException < Exception
+      def pending_fixed?
+        false
+      end
+    end
+
+    class Metadata
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
+
+      def [](key)
+        respond_to?(key) ? send(key) : data[key]
+      end
+
+      def update(data)
+        @data.merge!(data)
+      end
+
+      def file_path
+        STDERR.puts "file_path not implemented" if Konacha.config.verbose
+        "" # RSpec's BaseFormatter expects the return value to be a string
+      end
+
+      alias_method :location, :file_path
+
+      def line_number
+        STDERR.puts "line_number not implemented" if Konacha.config.verbose
+        nil
+      end
+
+      def execution_result
+        @execution_result ||= {
+          :status      => data['status'],
+          :started_at  => nil,
+          :finished_at => nil,
+          :run_time    => data['duration'],
+          :exception   => exception
+        }
+      end
+
+      def exception
+        return unless data['status'] == "failed"
+
+        @exception ||= begin
+          e = Reporter::SpecException.new(data['error']['message'])
+          e.set_backtrace([])
+          e
+        end
+      end
+
+      def pending_message
+        STDERR.puts "pending_message not implemented" if Konacha.config.verbose
+        nil
+      end
+
+      def described_class
+        STDERR.puts "described_class not implemented" if Konacha.config.verbose
+        nil
+      end
+
+      def pending
+        data['status'] == "pending"
+      end
+
+      def description
+        data['title']
+      end
+
+      def full_description
+        data['fullTitle']
+      end
+    end
+  end
+end

data/lib/konacha/runner.rb

@@ -1,5 +1,4 @@
 require "capybara"
-require "colorize"
 
 module Konacha
   class Runner
@@ -7,105 +6,52 @@ module Konacha
       new.run
     end
 
-    attr_reader :io, :examples
+    attr_reader :reporter
 
-    def initialize(options = {})
-      @io = options[:output] || STDOUT
+    def initialize
+      @reporter = Konacha::Reporter.new(*formatters)
     end
 
     def run
-      before = Time.now
+      reporter.start
 
       begin
-        session.visit("/")
+        session.visit('/')
 
-        dots_printed = 0
+        events_consumed = 0
+        done = false
         begin
           sleep 0.1
-          done, dots = session.evaluate_script('[Konacha.done, Konacha.dots]')
-          if dots
-            io.write colorize_dots(dots[dots_printed..-1])
-            io.flush
-            dots_printed = dots.length
+          events = JSON.parse(session.evaluate_script('Konacha.getEvents()'))
+          if events
+            events[events_consumed..-1].each do |event|
+              done = true if event['event'] == 'end'
+              reporter.process_mocha_event(event)
+            end
+
+            events_consumed = events.length
           end
         end until done
-
-        @examples = JSON.parse(session.evaluate_script('Konacha.getResults()')).map do |row|
-          Example.new(row)
-        end
       rescue => e
         raise e, "Error communicating with browser process: #{e}", e.backtrace
       end
 
-      io.puts ""
-      io.puts ""
-      failure_messages.each { |msg| io.write("#{msg}\n\n") }
-
-      seconds = "%.2f" % (Time.now - before)
-      io.puts "Finished in #{seconds} seconds"
-      io.puts "#{examples.size} examples, #{failed_examples.size} failures, #{pending_examples.size} pending"
-      passed?
-    end
-
-    def pending_examples
-      examples.select { |example| example.pending? }
-    end
-
-    def failed_examples
-      examples.select { |example| example.failed? }
-    end
-
-    def passed?
-      examples.all? { |example| example.passed? || example.pending? }
-    end
-
-    def failure_messages
-      examples.map { |example| example.failure_message }.compact
+      reporter.finish
+      reporter.passed?
     end
 
     def session
       @session ||= Capybara::Session.new(Konacha.driver, Konacha.application)
     end
 
-    def colorize_dots(dots)
-      dots = dots.chars.map do |d|
-        case d
-        when 'E', 'F'; d.red
-        when 'P'; d.yellow
-        when '.'; d.green
-        else;     d
+    private
+    def formatters
+      if ENV['FORMAT']
+        ENV['FORMAT'].split(',').map do |string|
+          eval(string).new(STDOUT)
         end
-      end
-      dots.join ''
-    end
-  end
-
-  class Example
-    def initialize(row)
-      @row = row
-    end
-
-    def passed?
-      @row['passed']
-    end
-
-    def pending?
-      @row['pending']
-    end
-
-    def failed?
-      !(@row['passed'] || @row['pending'])
-    end
-
-    def failure_message
-      if failed?
-        msg = []
-        msg << "  Failed: #{@row['name']}"
-        msg << "    #{@row['message']}"
-        msg << "    in #{@row['trace']['fileName']}:#{@row['trace']['lineNumber']}" if @row['trace']
-        msg.join("\n").red
-      elsif pending?
-        "  Pending: #{@row['name']}".yellow
+      else
+        [Konacha::Formatter.new(STDOUT)]
       end
     end
   end

data/spec/formatter_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Konacha::Formatter do
+  let(:io) { StringIO.new }
+  subject { described_class.new(io) }
+
+  shared_examples "test result" do |method, dot|
+    it "stores the example in the examples array" do
+      subject.send(method, nil)
+      subject.examples.should be_present
+    end
+    
+    it "outputs the dot" do
+      subject.send(method, nil)
+      io.rewind
+      io.read.should include(dot)
+    end
+  end
+
+  describe "#example_passed" do
+    it_behaves_like "test result", :example_passed, "."
+  end
+
+  describe "#example_failed" do
+    it_behaves_like "test result", :example_failed, "F"
+  end
+
+  describe "#example_pending" do
+    it_behaves_like "test result", :example_pending, "P"
+  end
+
+  describe "#dump_pending" do
+    let(:example) { double('example', :pending? => true, :full_description => "Pending example") }
+    before { subject.stub(:examples => [example]) }
+
+    it "outputs the pending message" do
+      subject.dump_pending
+      io.rewind
+      io.read.should include("  Pending: Pending example")
+    end
+  end
+
+  describe "#dump_failures" do
+    let(:example) do
+      double('example',
+             :failed?            => true,
+             :full_description   => "Failed example",
+             :exception          => double('exception',
+                                           :message   => "exception",
+                                           :backtrace => nil))
+    end
+
+    before { subject.stub(:examples => [example]) }
+
+    it "outputs the failure message" do
+      subject.dump_failures
+      io.rewind
+      io.read.should include("  Failed: Failed example\n    exception")
+    end
+  end
+
+  describe "#dump_summary" do
+    it "outputs the summary" do
+      subject.dump_summary(10, 10, 2, 3)
+      io.rewind
+      io.read.should == "\nFinished in 10.00 seconds\n10 examples, 2 failed, 3 pending\n"
+    end
+  end
+end

data/spec/reporter/example_group_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Konacha::Reporter::ExampleGroup do
+  subject { described_class.new({}, nil) }
+
+  describe "#initialize" do
+    it "loads up a metadata instance and the parent" do
+      data = double('data')
+      parent = double('parent')
+      example_group = described_class.new(data, parent)
+
+      example_group.parent.should == parent
+      example_group.metadata.should be_a(Konacha::Reporter::Metadata)
+      example_group.metadata.data.should == data
+    end
+  end
+
+  describe "delegated methods" do
+    let(:metadata) { double('metadata') }
+    before { Konacha::Reporter::Metadata.stub(:new) { metadata } }
+
+    [:full_description, :description, :file_path, :described_class].each do |method|
+      it "delegates #{method} to metadata" do
+        metadata.should_receive(method)
+        subject.send(method)
+      end
+    end
+  end
+
+  describe "aliased_methods" do
+    it "aliases display_name to description" do
+      subject.display_name.should == subject.description
+    end
+  end
+
+  describe "#parent_groups" do
+    let(:parent) { double('parent') }
+    let(:grandparent) { double('grandparent') }
+
+    before do
+      grandparent.stub(:parent => nil)
+      parent.stub(:parent => grandparent)
+      subject.stub(:parent => parent)
+    end
+
+    it "finds all of this group's ancestors" do
+      subject.parent_groups.should == [parent, grandparent]
+    end
+
+    it "works via #ancestors" do
+      subject.ancestors.should == [parent, grandparent]
+    end
+  end
+
+  describe "#update_metadata" do
+    it "calls metadata.update" do
+      data = double('data')
+      metadata = double('metadata')
+      metadata.should_receive(:update).with(data)
+      Konacha::Reporter::Metadata.stub(:new) { metadata }
+      subject.update_metadata(data)
+    end
+  end
+end

data/spec/reporter/example_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Konacha::Reporter::Example do
+  subject { described_class.new({}, nil) }
+
+  describe "#initialize" do
+    it "loads up a metadata instance and the parent" do
+      data = double('data')
+      parent = double('parent')
+      example = described_class.new(data, parent)
+
+      example.parent.should == parent
+      example.metadata.should be_a(Konacha::Reporter::Metadata)
+      example.metadata.data.should == data
+    end
+  end
+
+  describe "delegated methods" do
+    let(:metadata) { double('metadata') }
+    before { Konacha::Reporter::Metadata.stub(:new) { metadata } }
+
+    [:full_description, :description, :location, :file_path, :line_number, :pending, :pending_message, :exception, :execution_result].each do |method|
+      it "delegates #{method} to metadata" do
+        metadata.should_receive(method)
+        subject.send(method)
+      end
+    end
+  end
+
+  describe "aliased_methods" do
+    it "aliases pending? to pending" do
+      subject.pending?.should == subject.pending
+    end
+
+    it "aliases options to metadata" do
+      subject.options.should == subject.metadata
+    end
+
+    it "aliases example_group to parent" do
+      subject.example_group.should == subject.parent
+    end
+  end
+
+  describe "#passed?" do
+    it "returns true iff execution_result[:status] is passed" do
+      subject.should_receive(:execution_result) { {:status => "passed"} }
+      subject.passed?.should be_true
+    end
+
+    it "returns false" do
+      subject.should_receive(:execution_result) { {} }
+      subject.passed?.should be_false
+    end
+  end
+
+  describe "#failed?" do
+    it "returns true iff execution_result[:status] is failed" do
+      subject.should_receive(:execution_result) { {:status => "failed"} }
+      subject.failed?.should be_true
+    end
+
+    it "returns false" do
+      subject.should_receive(:execution_result) { {} }
+      subject.failed?.should be_false
+    end
+  end
+
+  describe "#update_metadata" do
+    it "calls metadata.update" do
+      data = double('data')
+      metadata = double('metadata')
+      metadata.should_receive(:update).with(data)
+      Konacha::Reporter::Metadata.stub(:new) { metadata }
+      subject.update_metadata(data)
+    end
+  end
+end

data/spec/reporter/metadata_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Konacha::Reporter::Metadata do
+  subject { described_class.new({}) }
+
+  describe "#[]" do
+    it "calls the method on self if available" do
+      subject.should_receive(:full_description)
+      subject[:full_description]
+    end
+
+    it "looks in the data hash" do
+      subject.should_receive(:data) { {} }
+      subject[:title]
+    end
+  end
+
+  describe "#update" do
+    it "merges the new data into the data hash" do
+      subject.update(:title => "test")
+      subject.data.should == {:title => "test"}
+    end
+  end
+
+  describe "#exception" do
+    it "returns unless the spec failed" do
+      subject.exception.should be_nil
+    end
+
+    it "builds a SpecException object" do
+      subject.update('status' => 'failed', 'error' => {'message' => 'expected this to work'})
+      subject.exception.should be_a(Konacha::Reporter::SpecException)
+      subject.exception.message.should == 'expected this to work'
+      subject.exception.backtrace.should == []
+    end
+  end
+
+  describe "#execution_result" do
+    it "returns a hash with execution details" do
+      subject.execution_result.keys.sort.should == [:exception, :finished_at, :run_time, :started_at, :status]
+    end
+  end
+
+  describe "#pending" do
+    it "returns true iff status is pending" do
+      subject.update('status' => 'pending')
+      subject.pending.should be_true
+    end
+
+    it "returns false" do
+      subject.pending.should be_false
+    end
+  end
+
+  describe "#description" do
+    it "looks for data['title']" do
+      subject.update('title' => 'super test')
+      subject.description.should == 'super test'
+    end
+  end
+
+  describe "#full_description" do
+    it "looks for data['fullTitle']" do
+      subject.update('fullTitle' => 'super test')
+      subject.full_description.should == 'super test'
+    end
+  end
+end