test-prof 0.1.0.pre5 → 0.1.0

data/spec/test_prof/ext/float_duration_spec.rb

@@ -1,12 +0,0 @@
-# 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

@@ -1,84 +0,0 @@
-# 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

data/spec/test_prof/rspec_stamp/parser_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "test_prof/rspec_stamp/parser"
-
-describe TestProf::RSpecStamp::Parser do
-  subject { described_class }
-
-  describe ".parse" do
-    it "handles simple expr" do
-      res = subject.parse('it "works"')
-      expect(res.fname).to eq 'it'
-      expect(res.desc).to eq 'works'
-      expect(res.tags).to be_nil
-      expect(res.htags).to be_nil
-    end
-
-    it "handles missing desc" do
-      res = subject.parse('it ')
-      expect(res.fname).to eq 'it'
-      expect(res.desc).to be_nil
-      expect(res.tags).to be_nil
-      expect(res.htags).to be_nil
-    end
-
-    it "handles parentheses" do
-      res = subject.parse('    it("is") ')
-      expect(res.fname).to eq 'it'
-      expect(res.desc).to eq 'is'
-      expect(res.tags).to be_nil
-      expect(res.htags).to be_nil
-    end
-
-    it "handles several args" do
-      res = subject.parse('  it "is o\'h", :cool, :bad ')
-      expect(res.fname).to eq 'it'
-      expect(res.desc).to eq "is o'h"
-      expect(res.tags).to eq(%i[cool bad])
-      expect(res.htags).to be_nil
-    end
-
-    it "handles hargs" do
-      res = subject.parse('  it "is", cool: :bad, type: "feature" ')
-      expect(res.fname).to eq 'it'
-      expect(res.desc).to eq "is"
-      expect(res.tags).to be_nil
-      expect(res.htags).to eq([%i[cool bad], [:type, "feature"]])
-    end
-
-    it "handles args and hargs" do
-      res = subject.parse('  it "is", :cool, :bad, type: :feature ')
-      expect(res.fname).to eq 'it'
-      expect(res.desc).to eq "is"
-      expect(res.tags).to eq(%i[cool bad])
-      expect(res.htags).to eq([%i[type feature]])
-    end
-  end
-end

data/spec/test_prof/rspec_stamp_spec.rb

@@ -1,281 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "test_prof/rspec_stamp"
-
-describe TestProf::RSpecStamp do
-  subject { described_class }
-
-  describe "#config" do
-    after { described_class.remove_instance_variable(:@config) }
-
-    subject { described_class.config }
-
-    it "handles array tags" do
-      subject.tags = [:todo]
-      expect(subject.tags).to eq([:todo])
-    end
-
-    it "handles string tags" do
-      subject.tags = "todo"
-      expect(subject.tags).to eq([:todo])
-    end
-
-    it "handle string hash tags" do
-      subject.tags = "fix:me"
-      expect(subject.tags).to eq([{ fix: :me }])
-    end
-
-    it "handle several tags" do
-      subject.tags = "todo,fix:me"
-      expect(subject.tags).to eq([:todo, { fix: :me }])
-    end
-  end
-
-  describe ".apply_tags" do
-    let(:code) { source.split("\n") }
-
-    let(:lines) { [1] }
-
-    let(:tags) { [:todo] }
-
-    subject { described_class.apply_tags(code, lines, tags) }
-
-    let(:source) do
-      <<~CODE
-        it "doesn't do what it should do" do
-          expect(subject.body).to eq("OK")
-        end
-      CODE
-    end
-
-    let(:expected) do
-      <<~CODE
-        it "doesn't do what it should do", :todo do
-          expect(subject.body).to eq("OK")
-        end
-      CODE
-    end
-
-    specify do
-      is_expected.to eq 0
-      expect(code.join("\n")).to eq expected.strip
-    end
-
-    context "with several examples" do
-      let(:source) do
-        <<~CODE
-          it 'succeeds' do
-            expect(subject.body).to eq("OK")
-          end
-
-          context "not found" do
-            let(:post) { draft_post }
-
-            it 'fails' do
-              expect(subject.body).to eq("Not Found")
-            end
-          end
-        CODE
-      end
-
-      let(:expected) do
-        <<~CODE
-          it 'succeeds' do
-            expect(subject.body).to eq("OK")
-          end
-
-          context "not found" do
-            let(:post) { draft_post }
-
-            it 'fails', :todo do
-              expect(subject.body).to eq("Not Found")
-            end
-          end
-        CODE
-      end
-
-      let(:lines) { [8] }
-
-      specify do
-        is_expected.to eq 0
-        expect(code.join("\n")).to eq expected.strip
-      end
-
-      context "patch all" do
-        let(:expected) do
-          <<~CODE
-            it 'succeeds', :todo do
-              expect(subject.body).to eq("OK")
-            end
-
-            context "not found" do
-              let(:post) { draft_post }
-
-              it 'fails', :todo do
-                expect(subject.body).to eq("Not Found")
-              end
-            end
-          CODE
-        end
-
-        let(:lines) { [1, 8] }
-
-        specify do
-          is_expected.to eq 0
-          expect(code.join("\n")).to eq expected.strip
-        end
-      end
-    end
-
-    context "without description" do
-      let(:source) do
-        <<~CODE
-          specify do
-            expect(subject.body).to eq("Not Found")
-          end
-        CODE
-      end
-
-      let(:expected) do
-        <<~CODE
-          specify 'works', :todo do
-            expect(subject.body).to eq("Not Found")
-          end
-        CODE
-      end
-
-      specify do
-        is_expected.to eq 0
-        expect(code.join("\n")).to eq expected.strip
-      end
-    end
-
-    context "one-liner" do
-      let(:source) do
-        <<~CODE
-          it("is") { expect(subject.body).to eq("Not Found") }
-        CODE
-      end
-
-      let(:expected) do
-        <<~CODE
-          it('is', :todo) { expect(subject.body).to eq("Not Found") }
-        CODE
-      end
-
-      specify do
-        is_expected.to eq 0
-        expect(code.join("\n")).to eq expected.strip
-      end
-    end
-
-    context "one-liner without description" do
-      let(:source) do
-        <<~CODE
-          it { expect(subject.body).to eq("Not Found") }
-        CODE
-      end
-
-      let(:expected) do
-        <<~CODE
-          it('works', :todo) { expect(subject.body).to eq("Not Found") }
-        CODE
-      end
-
-      specify do
-        is_expected.to eq 0
-        expect(code.join("\n")).to eq expected.strip
-      end
-    end
-
-    context "with existing tags" do
-      let(:source) do
-        <<~CODE
-          it 'is "KOI"', :log do
-            expect(subject.body).to eq("Not Found")
-          end
-        CODE
-      end
-
-      let(:expected) do
-        <<~CODE
-          it 'is "KOI"', :log, :todo do
-            expect(subject.body).to eq("Not Found")
-          end
-        CODE
-      end
-
-      specify do
-        is_expected.to eq 0
-        expect(code.join("\n")).to eq expected.strip
-      end
-    end
-
-    context "with several tags" do
-      let(:source) do
-        <<~CODE
-          specify do
-            expect(subject.body).to eq("Not Found")
-          end
-        CODE
-      end
-
-      let(:expected) do
-        <<~CODE
-          specify 'works', :todo, a: :b, c: 'd' do
-            expect(subject.body).to eq("Not Found")
-          end
-        CODE
-      end
-
-      let(:tags) { [{ a: :b }, :todo, { c: 'd' }] }
-
-      specify do
-        is_expected.to eq 0
-        expect(code.join("\n")).to eq expected.strip
-      end
-
-      context "with existing tags" do
-        let(:source) do
-          <<~CODE
-            it 'is', :log, level: :debug do
-              expect(subject.body).to eq("Not Found")
-            end
-          CODE
-        end
-
-        let(:expected) do
-          <<~CODE
-            it 'is', :log, :todo, level: :debug, a: :b, c: 'd' do
-              expect(subject.body).to eq("Not Found")
-            end
-          CODE
-        end
-
-        specify do
-          is_expected.to eq 0
-          expect(code.join("\n")).to eq expected.strip
-        end
-      end
-    end
-
-    context "with multiline description" do
-      let(:source) do
-        <<~CODE
-          it %q{
-            succeeds
-            this time
-          } do
-            expect(subject.body).to eq("OK")
-          end
-        CODE
-      end
-
-      specify do
-        is_expected.to eq 1
-        expect(code.join("\n")).to eq source.strip
-      end
-    end
-  end
-end

data/spec/test_prof/ruby_prof_spec.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe TestProf::RubyProf do
-  # Use fresh config all for every example
-  after { described_class.remove_instance_variable(:@config) }
-
-  describe ".config" do
-    subject { described_class.config }
-
-    specify "defaults", :aggregate_failiures do
-      expect(subject.printer).to eq :call_stack
-      expect(subject.mode).to eq :wall
-      expect(subject.min_percent).to eq 1
-      expect(subject.include_threads).to eq false
-    end
-
-    describe "#resolve_printer" do
-      it "works with custom class" do
-        subject.printer = TestProf
-        expect(subject.resolve_printer).to eq(['custom', TestProf])
-      end
-
-      it "raises when unknown printer" do
-        subject.printer = 'unknown'
-        expect { subject.resolve_printer }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#profile" do
-    let(:ruby_prof) { double("ruby_prof") }
-    let(:profile) { double("profile") }
-
-    before do
-      stub_const("RubyProf::Profile", ruby_prof)
-      expect(profile).to receive(:start)
-    end
-
-    specify "with default config" do
-      expect(ruby_prof).to receive(:new).with(
-        merge_fibers: true,
-        include_threads: [Thread.current]
-      ).and_return(profile)
-
-      expect(described_class.profile).to be_a(described_class::Report)
-    end
-
-    specify "with custom config" do
-      described_class.config.include_threads = true
-
-      expect(ruby_prof).to receive(:new).with(
-        merge_fibers: true
-      ).and_return(profile)
-
-      described_class.profile
-    end
-  end
-
-  describe "Report#dump" do
-    let(:ruby_prof) { double("ruby_prof") }
-    let(:profile) { double("profile") }
-    let(:result) { double("result") }
-    let(:printer_class) { double("printer_class") }
-    let(:printer) { double("printer") }
-
-    before do
-      stub_const("::RubyProf::Profile", ruby_prof)
-      expect(ruby_prof).to receive(:new).and_return(profile)
-      expect(profile).to receive(:start)
-      expect(profile).to receive(:stop).and_return(result)
-    end
-
-    subject { described_class.profile }
-
-    specify "with default config" do
-      expect(result).to receive(:eliminate_methods!)
-
-      stub_const("::RubyProf::CallStackPrinter", printer_class)
-      expect(printer_class).to receive(:new).with(result).and_return(printer)
-      expect(printer).to receive(:print).with(anything, min_percent: 1).and_return("")
-
-      subject.dump("stub")
-
-      expect(File.exist?("tmp/ruby-prof-report-call_stack-wall-stub.html")).to eq true
-    end
-
-    specify "with custom config" do
-      described_class.config.printer = :flat
-      described_class.config.eliminate_methods = []
-      described_class.config.min_percent = 2
-      described_class.config.mode = :cpu
-
-      TestProf.config.timestamps = true
-
-      expect(result).not_to receive(:eliminate_methods!)
-
-      stub_const("RubyProf::FlatPrinter", printer_class)
-      expect(printer_class).to receive(:new).with(result).and_return(printer)
-      expect(printer).to receive(:print).with(anything, min_percent: 2).and_return("")
-      expect(Time).to receive(:now).and_return(double("now", to_i: 123_454_321))
-
-      subject.dump("stub")
-
-      expect(File.exist?("tmp/ruby-prof-report-flat-cpu-stub-123454321.html")).to eq true
-    end
-  end
-end