are_we_there_yet 0.2.1 → 1.0.0

data/lib/are_we_there_yet/profiler.rb

@@ -0,0 +1,60 @@
+module AreWeThereYet
+  class Profiler
+    def initialize(db_connection_string)
+      @db = AreWeThereYet::Persistence::Connection.create(db_connection_string)
+    end
+
+    def list_files
+      averages_by_file = get_average_per_key(metrics_by_file)
+
+      sorted_output(transform_averages_for_sorting(averages_by_file, :file))
+    end
+
+    def list_examples(file_path)
+      if metrics_by_file[file_path]
+        metrics_by_example = metrics_by_file[file_path].group_by { |m| m.description }
+
+        averages_by_example = get_average_per_key(metrics_by_example)
+
+        sorted_output(transform_averages_for_sorting(averages_by_example, :example))
+      else
+        []
+      end
+    end
+
+    private
+
+    def sorted_output(data_to_sort)
+      data_to_sort.sort { |x,y| y[:average_execution_time] <=> x[:average_execution_time] }
+    end
+
+    def find_average_time_for(runs)
+      total_per_run = runs.inject([]) do |memo, (run,metrics)|
+        memo << metrics.inject(0.0) { |total,m| total + m.execution_time }
+      end
+
+      (total_per_run.inject(:+))/total_per_run.size
+    end
+
+    def metrics_by_file
+      @metrics_by_file || Metric.all(@db).group_by { |m| m.path }
+    end
+
+    def get_average_per_key(metric_set)
+      # Merging a hash with itself is really just a sneaky way to do a map
+      metrics_by_key_per_run = metric_set.merge(metric_set) do |key,metrics,metrics|
+        metrics.group_by { |m| m.run_id }
+      end
+
+      averages_by_key = metrics_by_key_per_run.merge(metrics_by_key_per_run) do |key, runs, runs|
+        find_average_time_for runs
+      end
+    end
+
+    def transform_averages_for_sorting(averages_by_key, key_name)
+      averages_by_key.map do |key, average_execution_time|
+        { key_name.to_sym => key, :average_execution_time => average_execution_time }
+      end
+    end
+  end
+end

data/lib/are_we_there_yet/profiler_ui.rb

@@ -0,0 +1,15 @@
+module AreWeThereYet
+  class ProfilerUI
+    class UnknownListingError < StandardError; end
+    def self.get_profiler_output(location, output, options={})
+      profiler = Profiler.new(location)
+      if options[:list] == 'files'
+        output.write(Formatter.format_for_output(profiler.list_files))
+      elsif options[:list] == 'examples'
+        output.write(Formatter.format_for_output(profiler.list_examples(options[:file_path])))
+      else
+        raise UnknownListingError
+      end
+    end
+  end
+end

data/lib/are_we_there_yet/recorder.rb

@@ -0,0 +1,47 @@
+module AreWeThereYet
+  class Recorder < Spec::Runner::Formatter::BaseFormatter
+    def initialize(options,where)
+      @db = AreWeThereYet::Persistence::Connection.create(where)
+
+      AreWeThereYet::Persistence::Schema.create(@db)
+
+      log_run
+    end
+
+    def example_started(example)
+      @start = Time.now
+    end
+
+    def example_passed(example)
+      persist_metric(example)
+    end
+
+    def close
+      @run.finish(@db)
+      @db.disconnect
+    end
+
+    private
+
+    def log_run
+      @run = AreWeThereYet::Run.new
+      @run.start(@db)
+    end
+
+    def get_file_path_from(example)
+      example.location.split(':').first
+    end
+
+    def persist_metric(example)
+
+      metric = AreWeThereYet::Metric.new(
+        :execution_time => Time.now - @start,
+        :path => get_file_path_from(example),
+        :description => example.description,
+        :run_id => @run.id
+      )
+
+      metric.save(@db)
+    end
+  end
+end

data/lib/are_we_there_yet/run.rb

@@ -0,0 +1,12 @@
+module AreWeThereYet
+  class Run
+    attr_reader :id
+    def start(database)
+      @id = database[:runs].insert(:started_at => Time.now.utc)
+    end
+
+    def finish(database)
+      database[:runs].where(:id => id).update(:ended_at => Time.now.utc)
+    end
+  end
+end

data/spec/lib/formatter_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe AreWeThereYet::Formatter do
+  it "returns formatted data for file metrics" do
+    input = [
+      { :file => "/path/to/spec", :average_execution_time => 32.0 },
+      { :file => "/path/to/other/spec", :average_execution_time => 5.0 },
+    ]
+    output = [
+      %Q{"File Path","Average Execution Time"},
+      "",
+      %Q{"#{input[0][:file]}",#{input[0][:average_execution_time]}},
+      %Q{"#{input[1][:file]}",#{input[1][:average_execution_time]}},
+    ].join("\n") + "\n"
+
+    AreWeThereYet::Formatter.format_for_output(input).should == output
+  end
+
+  it "returns formatted data for exampel metrics" do
+    input = [
+      { :example => "blaah", :average_execution_time => 20.0 },
+      { :example => "blah", :average_execution_time => 12.0 }
+    ]
+    output = [
+      %Q{"Example","Average Execution Time"},
+      "",
+      %Q{"#{input[0][:example]}",#{input[0][:average_execution_time]}},
+      %Q{"#{input[1][:example]}",#{input[1][:average_execution_time]}},
+    ].join("\n") + "\n"
+
+    AreWeThereYet::Formatter.format_for_output(input).should == output
+  end
+end

data/spec/lib/metric_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe AreWeThereYet::Metric do
+  before(:each) do
+    @db_name = "/tmp/are_we_there_yet_#{Time.now.to_i}_#{rand(100000000)}_spec.sqlite"
+    @db = AreWeThereYet::Persistence::Connection.create("sqlite://#{@db_name}")
+    AreWeThereYet::Persistence::Schema.create(@db)
+
+    @properties = {:id => 9999, :execution_time => 30.0, :path => '/path/to/file', :run_id => 99, :description => 'blah'}
+  end
+
+  after(:each) do
+    @db.disconnect
+    File.unlink(@db_name) if File.exists? @db_name
+  end
+
+  it "is instantiated from a hash of options" do
+    m = AreWeThereYet::Metric.new(@properties)
+    m.id.should == @properties[:id]
+    m.execution_time.should == @properties[:execution_time]
+    m.path.should == @properties[:path]
+    m.run_id.should == @properties[:run_id]
+    m.description.should == @properties[:description]
+  end
+
+  it "returns all metrics currently in the provided database" do
+    @db[:metrics].insert_multiple([{:path => 'abc'}, {:path => 'def'}])
+
+    all_metrics = AreWeThereYet::Metric.all(@db)
+    all_metrics.first.path.should == 'abc'
+    all_metrics.last.path.should == 'def'
+  end
+
+  it "persists itself to the database" do
+    AreWeThereYet::Metric.all(@db).should be_empty
+    m = AreWeThereYet::Metric.new(@properties)
+    m.save(@db)
+
+    metric = AreWeThereYet::Metric.all(@db).first
+    metric.id.should_not == @properties[:id] # even if an id is provided it is not saved - no provision for updates
+    metric.execution_time.should  == @properties[:execution_time]
+    metric.path.should == @properties[:path]
+    metric.description.should == @properties[:description]
+    metric.run_id.should == @properties[:run_id]
+  end
+
+  it "sets a UTC timestamp in the database to indicate when it was created" do
+    fake_created_at = Time.at(0) #use an obviously fake time
+
+    Time.stub_chain(:now, :utc).and_return(fake_created_at)
+    m = AreWeThereYet::Metric.new(@properties)
+    m.save(@db)
+
+    @db[:metrics].first[:created_at].should == fake_created_at
+  end
+
+  it "overwrites any existing id with the id of the record created" do
+    m = AreWeThereYet::Metric.new(@properties)
+    m.save(@db)
+
+    m.id.should == 1
+  end
+end

data/spec/lib/persistence/connection_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe AreWeThereYet::Persistence::Connection do
+  before(:each) do
+    @db_name = "/tmp/arewethereyet.sqlite"
+    @db = "sqlite://#{@db_name}"
+
+    File.unlink(@db_name) if File.exists? @db_name
+  end
+
+  it "returns a connection object for the database uri provided" do
+    db = AreWeThereYet::Persistence::Connection.create(@db)
+    db.url.should == "sqlite:/#{@db_name}"
+    db.test_connection.should be_true
+  end
+
+  it "raises an error if it cannot connect to the URI specified" do
+    expect { AreWeThereYet::Persistence::Connection.create('obviously_bogus') }.
+      should raise_error(AreWeThereYet::Persistence::Connection::InvalidDBLocation, /check that the location is valid/)
+  end
+end

data/spec/lib/persistence/schema_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+RSpec::Matchers.define :have_field do |expected|
+  def find_field_entry(actual,expected)
+    field_entries = actual.select { |f| f.first == expected[:field] }
+    field_entries.any? ? field_entries.first : nil
+  end
+
+  def attributes_match?(actual_attributes, expected_attributes)
+    expected_attributes.each do |attr,value|
+      return false if actual_attributes[attr] != value
+    end
+
+    true
+  end
+
+  match do |actual|
+    (actual_field = find_field_entry(actual,expected)) && attributes_match?(actual_field.last, expected[:attributes])
+  end
+
+  failure_message_for_should do |actual|
+    "expected that #{actual.inspect} would have a field conforming to #{expected.inspect}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected that #{actual.inspect} would not have a field conforming to #{expected.inspect}"
+  end
+
+  description do
+    "has a field conforming to #{expected}"
+  end
+end
+
+describe AreWeThereYet::Persistence::Schema do
+  before(:each) do
+    @db_name = "/tmp/arewethereyet.sqlite"
+    @db = "sqlite://#{@db_name}"
+
+    File.unlink(@db_name) if File.exists? @db_name
+
+    @connection = Sequel.connect(@db)
+  end
+
+  it "creates a table for tracking spec runs" do
+    AreWeThereYet::Persistence::Schema.create(@connection)
+
+    schema = @connection.schema(:runs)
+    schema.should have_field :field => :id, :attributes => {:type => :integer, :primary_key => true}
+    schema.should have_field :field => :started_at, :attributes => {:type => :datetime}
+    schema.should have_field :field => :ended_at, :attributes => {:type => :datetime}
+  end
+
+  it "creates a table for tracking metrics" do
+    AreWeThereYet::Persistence::Schema.create(@connection)
+
+    schema = @connection.schema(:metrics)
+    schema.should have_field :field => :id, :attributes => {:type => :integer, :primary_key => true}
+    schema.should have_field :field => :path, :attributes => {:type => :string}
+    schema.should have_field :field => :description, :attributes => {:type => :string}
+    schema.should have_field :field => :execution_time, :attributes => {:type => :float}
+    schema.should have_field :field => :created_at, :attributes => {:type => :datetime}
+    schema.should have_field :field => :run_id, :attributes => {:type => :integer}
+
+    @connection.indexes(:metrics).should == {
+      :metrics_path_index => {:unique=>false, :columns=>[:path]},
+      :metrics_description_index => { :unique => false, :columns => [:description]}
+    }
+  end
+
+  it "rolls back table creation if there is a problem creating any one of the tables" do
+    broken_connection = mock(Sequel::SQLite::Database, :tables => [])
+    broken_connection.stub(:create_table) do |arg, bl|
+      if arg == :metrics
+        raise RuntimeError
+      else
+        @connection.create_table(arg, &bl)
+      end
+    end
+
+    expect { AreWeThereYet::Persistence::Schema.create(broken_connection) }.should raise_error
+
+    @connection.tables.should be_empty
+  end
+
+  it "does not create tables if there already tables present in the database" do
+    @connection.create_table(:dummy) do
+      primary_key :id
+    end
+
+    AreWeThereYet::Persistence::Schema.create(@connection)
+
+    @connection.tables.should == [:dummy]
+  end
+end

data/spec/lib/profiler_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe AreWeThereYet::Profiler do
+  before(:all) do
+    @db_name = "/tmp/are_we_there_yet_#{Time.now.to_i}_#{rand(100000000)}_spec.sqlite"
+    @db = "sqlite://#{@db_name}"
+
+    @connection = AreWeThereYet::Persistence::Connection.create(@db)
+    AreWeThereYet::Persistence::Schema.create(@connection)
+
+    @connection[:metrics].insert_multiple(
+      [
+        { :path => "/path/to/spec", :description => "blah", :execution_time => 5, :run_id => 1 },
+        { :path => "/path/to/spec", :description => "blaah", :execution_time => 10, :run_id => 1 },
+        { :path => "/path/to/other/spec", :description => "asdfghij", :execution_time => 5, :run_id => 1 },
+        { :path => "/path/to/spec", :description => "blah", :execution_time => 18, :run_id => 2 },
+        { :path => "/path/to/spec", :description => "blaah", :execution_time => 30, :run_id => 2 },
+      ]
+    )
+
+    @profiler = AreWeThereYet::Profiler.new(@db)
+  end
+
+  after(:all) do
+    @connection.disconnect
+    File.unlink(@db_name) if File.exists? @db_name
+  end
+
+  it "returns a list of the spec files ordered by descending average execution time" do
+    file_list = @profiler.list_files
+    file_list.should == [
+      { :file => "/path/to/spec", :average_execution_time => 31.5 },
+      { :file => "/path/to/other/spec", :average_execution_time => 5.0 },
+    ]
+  end
+
+  it "returns a sorted list of examples together with run times for a given file" do
+    examples_for_file = @profiler.list_examples("/path/to/spec")
+    examples_for_file.should == [
+      { :example => "blaah", :average_execution_time => 20.0 },
+      { :example => "blah", :average_execution_time => 11.5 }
+    ]
+  end
+
+  it "returns an empty list of examples if the given file path cannot be found" do
+    examples_for_file = @profiler.list_examples("/un/known/file")
+
+    examples_for_file.should respond_to :each
+    examples_for_file.should be_empty
+  end
+end

data/spec/lib/profiler_ui_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe AreWeThereYet::ProfilerUI do
+  before(:all) do
+    @db_name = "/tmp/are_we_there_yet_#{Time.now.to_i}_#{rand(100000000)}_spec.sqlite"
+    @db = "sqlite://#{@db_name}"
+    @connection = AreWeThereYet::Persistence::Connection.create(@db)
+    AreWeThereYet::Persistence::Schema.create(@connection)
+
+    @path = "/path/to/spec"
+    @time = 9.5
+    @description = "blaah"
+
+    @connection[:metrics].insert(:path => @path, :description => @description, :execution_time => @time, :run_id => 1)
+  end
+
+  before(:each) do
+    @mock_io = double(IO)
+  end
+
+  after(:all) do
+    @connection.disconnect
+    File.unlink(@db_name) if File.exists? @db_name
+  end
+
+  context "file listing" do
+    it "writes a file listing togther with headers to STDOUT" do
+      output_matcher = /File Path.*Average Execution Time.*\n\n.*#{@path}.*#{@time}\n/
+      @mock_io.should_receive(:write).with(output_matcher)
+
+      AreWeThereYet::ProfilerUI.get_profiler_output(@db, @mock_io, :list => 'files')
+    end
+  end
+
+  context "example listing" do
+    it "outputs an example listing for a given file" do
+      output_matcher = /Example.*Average Execution Time.*\n\n.*#{@description}.*#{@time}\n/
+      @mock_io.should_receive(:write).with(output_matcher)
+
+      AreWeThereYet::ProfilerUI.get_profiler_output(@db, @mock_io, :list => 'examples', :file_path => '/path/to/spec')
+    end
+  end
+
+  context "unknown listing" do
+    it "raises an exception" do
+      expect { AreWeThereYet::ProfilerUI.get_profiler_output(@db, @mock_io, :list => 'awesome') }.
+        should raise_error AreWeThereYet::ProfilerUI::UnknownListingError
+    end
+  end
+end