test-prof 0.1.0.beta4 → 0.1.0.pre2

data/spec/integrations/fixtures/rspec/factory_doctor_fixture.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)
+require_relative "../../../support/ar_models"
+require "test-prof"
+
+describe "User" do
+  let(:user) { FactoryGirl.create(:user) }
+
+  it "generates random names" do
+    user2 = FactoryGirl.create(:user)
+    expect(user.name).not_to eq user2.name
+  end
+
+  it "validates name" do
+    user.name = ''
+    expect(user).not_to be_valid
+  end
+
+  it "creates and reloads user" do
+    user = FactoryGirl.create(:user, name: 'John')
+    expect(User.find(user.id).name).to eq 'John'
+  end
+
+  it "clones" do
+    expect(user.clone.name).to include("(cloned)")
+  end
+
+  it "is ignored", :fd_ignore do
+    user.name = ''
+    expect(user).not_to be_valid
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "test-prof"
+require "pry-byebug"
+require "open3"
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.order = :random
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+
+  config.define_derived_metadata(file_path: %r{/spec/integrations/}) do |metadata|
+    metadata[:type] = :integration
+  end
+
+  config.include IntegrationHelpers, type: :integration
+
+  config.before(:suite) do
+    FileUtils.mkdir_p("tmp")
+  end
+
+  config.before(:each) do
+    allow(TestProf).to receive(:require).and_return(true)
+    # Clear global configuration
+    TestProf.remove_instance_variable(:@config) if
+      TestProf.instance_variable_defined?(:@config)
+    TestProf.config.output = StringIO.new
+  end
+
+  config.after(:suite) do
+    FileUtils.rm_rf("tmp")
+  end
+end

data/spec/support/ar_models.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "factory_girl"
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveRecord::Schema.define do
+  create_table :users do |t|
+    t.string :name
+  end
+
+  create_table :posts do |t|
+    t.text :text
+    t.integer :user_id
+  end
+end
+
+class User < ActiveRecord::Base
+  validates :name, presence: true
+  has_many :posts, dependent: :destroy
+
+  def clone
+    copy = dup
+    copy.name = "#{name} (cloned)"
+    copy
+  end
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+end
+
+FactoryGirl.define do
+  factory :user do
+    name { |n| "John #{n}" }
+  end
+
+  factory :post do
+    text { |n| "Post ##{n}}" }
+    user
+  end
+end

data/spec/support/instrumenter_stub.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module InstrumenterStub
+  class << self
+    def subscribe(event, &block)
+      listeners[event] = block
+    end
+
+    def notify(event, time)
+      listeners[event].call(time)
+    end
+
+    private
+
+    def listeners
+      @listeners ||= {}
+    end
+  end
+end

data/spec/support/integration_helpers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module IntegrationHelpers
+  def run_rspec(path, env: {})
+    output, status = Open3.capture2(
+      env,
+      "rspec #{path}_fixture.rb",
+      chdir: File.expand_path("../../integrations/fixtures/rspec", __FILE__)
+    )
+    expect(status).to be_success
+    output
+  end
+end

data/spec/support/transactional_context.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+shared_context "transactional", transactional: true do
+  prepend_before(:each) do
+    ActiveRecord::Base.connection.begin_transaction(joinable: false)
+  end
+
+  append_after(:each) do
+    ActiveRecord::Base.connection.rollback_transaction
+  end
+end

data/spec/test_prof/any_fixture_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "test_prof/any_fixture"
+
+describe TestProf::AnyFixture, :transactional do
+  subject { described_class }
+
+  after { described_class.reset }
+
+  describe "#register" do
+    it "invokes block only once for the same id" do
+      block = double('block', call: 1)
+      block2 = double('block2', call: 2)
+
+      expect(block).to receive(:call)
+      expect(block2).not_to receive(:call)
+
+      expect(subject.register(:test) { block.call })
+        .to eq 1
+
+      expect(subject.register(:test) { block2.call })
+        .to eq 1
+    end
+  end
+
+  describe "#clean" do
+    it "tracks AR queries and delete affected tables" do
+      # add a record outside of any fixture to check
+      # that we delete all records from the tables
+      FactoryGirl.create(:user)
+
+      expect do
+        subject.register(:user) { FactoryGirl.create(:user) }
+      end.to change(User, :count).by(1)
+
+      expect do
+        subject.register(:post) { FactoryGirl.create(:post) }
+      end.to change(User, :count).by(1)
+                                 .and change(Post, :count).by(1)
+
+      subject.clean
+
+      # Try to re-register user - should have no effect
+      subject.register(:user) { FactoryGirl.create(:user) }
+
+      expect(User.count).to eq 0
+      expect(Post.count).to eq 0
+    end
+  end
+
+  describe "#reset" do
+    it "delete affected tables and reset cache" do
+      expect do
+        subject.register(:user) { FactoryGirl.create(:user) }
+      end.to change(User, :count).by(1)
+
+      subject.reset
+      expect(User.count).to eq 0
+
+      subject.register(:user) { FactoryGirl.create(:user) }
+
+      expect(User.count).to eq 1
+    end
+  end
+end

data/spec/test_prof/event_prof_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe TestProf::EventProf do
+  # Use fresh config all for every example
+  after { described_class.remove_instance_variable(:@config) }
+
+  before { stub_const("ActiveSupport::Notifications", double(subscribe: nil)) }
+
+  subject { described_class.build }
+
+  describe ".config" do
+    specify "defaults", :aggregate_failiures do
+      expect(subject.top_count).to eq 5
+      expect(subject.rank_by).to eq :time
+    end
+  end
+
+  describe ".build" do
+    before { described_class.config.event = 'test.event' }
+
+    it "subscribes to event" do
+      expect(TestProf::EventProf::Instrumentations::ActiveSupport)
+        .to receive(:subscribe).with('test.event')
+      subject
+    end
+
+    it "sets options" do
+      expect(subject.event).to eq 'test.event'
+      expect(subject.rank_by).to eq :time
+      expect(subject.top_count).to eq 5
+    end
+  end
+
+  describe "#result" do
+    let(:results) do
+      described_class.config.event = 'test.event'
+      described_class.config.instrumenter = InstrumenterStub
+
+      subject
+
+      subject.group_started 'A'
+
+      subject.example_started 'A1'
+      InstrumenterStub.notify 'test.event', 100
+      subject.example_finished 'A1'
+
+      subject.group_finished 'A'
+
+      subject.group_started 'B'
+
+      subject.example_started 'B1'
+      InstrumenterStub.notify 'test.event', 140
+      InstrumenterStub.notify 'test.event', 240
+      subject.example_finished 'B1'
+
+      subject.example_started 'B2'
+      InstrumenterStub.notify 'test.event', 40
+      subject.example_finished 'B2'
+
+      subject.group_finished 'B'
+
+      subject.group_started 'C'
+
+      subject.example_started 'C1'
+      InstrumenterStub.notify 'test.event', 400
+      InstrumenterStub.notify 'test.event', 40
+      subject.example_finished 'C1'
+
+      subject.example_started 'C2'
+      subject.example_finished 'C2'
+
+      subject.group_finished 'C'
+
+      subject.results
+    end
+
+    it "returns top slow groups and totals" do
+      expect(results).to eq(
+        groups: [
+          { id: 'C', examples: 2, time: 440, count: 2 },
+          { id: 'B', examples: 2, time: 420, count: 3 },
+          { id: 'A', examples: 1, time: 100, count: 1 }
+        ]
+      )
+      expect(subject.total_time).to eq 960
+      expect(subject.total_count).to eq 6
+    end
+
+    context "when rank by count" do
+      before { described_class.config.rank_by = :count }
+
+      it "returns top groups by event occurances" do
+        expect(results).to eq(
+          groups: [
+            { id: 'B', examples: 2, time: 420, count: 3 },
+            { id: 'C', examples: 2, time: 440, count: 2 },
+            { id: 'A', examples: 1, time: 100, count: 1 }
+          ]
+        )
+      end
+    end
+
+    context "when top_count is specified" do
+      before { described_class.config.top_count = 2 }
+
+      it "returns top groups by event occurances" do
+        expect(results).to eq(
+          groups: [
+            { id: 'C', examples: 2, time: 440, count: 2 },
+            { id: 'B', examples: 2, time: 420, count: 3 }
+          ]
+        )
+      end
+    end
+
+    context "when per_example is true" do
+      before { described_class.config.per_example = true }
+
+      it "returns top groups and examples" do
+        expect(results).to eq(
+          groups: [
+            { id: 'C', examples: 2, time: 440, count: 2 },
+            { id: 'B', examples: 2, time: 420, count: 3 },
+            { id: 'A', examples: 1, time: 100, count: 1 }
+          ],
+          examples: [
+            { id: 'C1', time: 440, count: 2 },
+            { id: 'B1', time: 380, count: 2 },
+            { id: 'A1', time: 100, count: 1 },
+            { id: 'B2', time: 40,  count: 1 }
+          ]
+        )
+      end
+    end
+  end
+end

data/spec/test_prof/ext/float_duration_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "test_prof/ext/float_duration"
+
+using TestProf::FloatDuration
+
+describe TestProf::FloatDuration do
+  it "works" do
+    expect((27 * 60 + 41.05142).duration).to eq "27:41.051"
+  end
+end

data/spec/test_prof/factory_doctor_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Init FactoryDoctor and patch FactoryGirl
+TestProf::FactoryDoctor.init
+
+describe TestProf::FactoryDoctor, :transactional do
+  before { described_class.start }
+  after { described_class.stop }
+
+  # Ensure meta-queries have been performed
+  before(:all) { User.first }
+
+  describe "#result" do
+    subject(:result) { described_class.result }
+
+    it "is not bad when nothing created" do
+      FactoryGirl.build_stubbed(:user)
+      User.first
+      expect(result).not_to be_bad
+      expect(result.count).to eq 0
+      expect(result.time).to eq 0
+      expect(result.queries_count).to eq 1
+    end
+
+    it "detects one useless object" do
+      FactoryGirl.create(:user)
+      expect(result).to be_bad
+      expect(result.count).to eq 1
+      expect(result.time).to be > 0
+    end
+
+    it "detects not useless object when select" do
+      user = FactoryGirl.create(:user)
+      user.reload
+
+      expect(result).not_to be_bad
+      expect(result.count).to eq 1
+      expect(result.queries_count).to eq 1
+      expect(result.time).to be > 0
+    end
+
+    it "detects not useless object when update" do
+      user = FactoryGirl.create(:user)
+      user.update!(name: 'Phil')
+
+      expect(result).not_to be_bad
+      expect(result.count).to eq 1
+      expect(result.queries_count).to eq 1
+      expect(result.time).to be > 0
+    end
+
+    it "detects many objects" do
+      FactoryGirl.create_pair(:user)
+
+      expect(result).to be_bad
+      expect(result.count).to eq 2
+      expect(result.time).to be > 0
+    end
+
+    describe "#ignore" do
+      it "does not track create" do
+        described_class.ignore do
+          FactoryGirl.create(:user)
+        end
+
+        expect(result).not_to be_bad
+        expect(result.count).to eq 0
+        expect(result.time).to eq 0
+      end
+
+      it "does not track queries" do
+        user = FactoryGirl.create(:user)
+
+        described_class.ignore { user.reload }
+
+        expect(result).to be_bad
+        expect(result.count).to eq 1
+        expect(result.time).to be > 0
+      end
+    end
+  end
+end