devformance 0.1.0

data/spec/fixtures/devformance/file_result.rb

@@ -0,0 +1,34 @@
+FactoryBot.define do
+  factory :file_result, class: "Devformance::FileResult" do
+    run_id { SecureRandom.hex(8) }
+    file_key { "posts_controller_spec" }
+    file_path { "spec/requests/posts_controller_spec.rb" }
+    status { :pending }
+    total_tests { 0 }
+    passed_tests { 0 }
+    failed_tests { 0 }
+    slow_query_count { 0 }
+    n1_count { 0 }
+    coverage { nil }
+    duration_ms { nil }
+    log_path { nil }
+  end
+
+  trait :passed do
+    status { :passed }
+    total_tests { 10 }
+    passed_tests { 10 }
+    failed_tests { 0 }
+    coverage { 95.5 }
+    duration_ms { 2500 }
+  end
+
+  trait :failed do
+    status { :failed }
+    total_tests { 10 }
+    passed_tests { 7 }
+    failed_tests { 3 }
+    coverage { 85.0 }
+    duration_ms { 3000 }
+  end
+end

data/spec/fixtures/devformance/slow_query.rb

@@ -0,0 +1,11 @@
+FactoryBot.define do
+  factory :slow_query, class: "Devformance::SlowQuery" do
+    model_class { "User" }
+    line_number { 42 }
+    fix_suggestion { "Use includes to eager load associations" }
+    run_id { SecureRandom.hex(8) }
+    sql { "SELECT * FROM users WHERE active = true" }
+    duration_ms { 150.5 }
+    file_key { "users_controller_spec" }
+  end
+end

data/spec/lib/devmetrics/log_writer_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Devformance::LogWriter do
+  let(:tmpdir) { Dir.mktmpdir }
+
+  after { FileUtils.rm_rf(tmpdir) }
+
+  describe ".open" do
+    subject(:writer) { described_class.open(run_id, file_key) }
+
+    let(:run_id)   { "abc123" }
+    let(:file_key) { "users_spec" }
+
+    before { allow(Rails.root).to receive(:join).with("log", "devformance", "runs").and_return(Pathname.new(tmpdir)) }
+
+    it "returns a LogWriter instance" do
+      expect(writer).to be_a(described_class)
+    ensure
+      writer.close
+    end
+
+    it "creates the run directory" do
+      writer
+      expect(File.directory?(File.join(tmpdir, run_id))).to be true
+    ensure
+      writer.close
+    end
+
+    it "creates a log file at the expected path" do
+      writer
+      expect(File.exist?(File.join(tmpdir, run_id, "#{file_key}.log"))).to be true
+    ensure
+      writer.close
+    end
+  end
+
+  describe "#path" do
+    subject(:writer) { described_class.new(log_path) }
+
+    let(:log_path) { Pathname.new(tmpdir).join("test.log") }
+
+    it "returns the path as a string" do
+      expect(writer.path).to eq(log_path.to_s)
+    ensure
+      writer.close
+    end
+  end
+
+  describe "#write" do
+    subject(:writer) { described_class.new(log_path) }
+
+    let(:log_path) { Pathname.new(tmpdir).join("output.log") }
+
+    it "writes the line to the file with a newline" do
+      writer.write("hello world")
+      writer.close
+      expect(File.read(log_path)).to eq("hello world\n")
+    end
+
+    it "flushes immediately so content is readable before close" do
+      writer.write("flushed")
+      expect(File.read(log_path)).to include("flushed")
+    ensure
+      writer.close
+    end
+  end
+
+  describe "#close" do
+    subject(:writer) { described_class.new(log_path) }
+
+    let(:log_path) { Pathname.new(tmpdir).join("close_test.log") }
+
+    it "closes the underlying file" do
+      io = writer.instance_variable_get(:@file)
+      writer.close
+      expect(io).to be_closed
+    end
+  end
+end

data/spec/lib/devmetrics/run_orchestrator_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Devformance::RunOrchestrator do
+  describe ".call" do
+    subject(:result) { described_class.call }
+
+    before do
+      allow(described_class).to receive(:new).and_return(instance)
+    end
+
+    let(:instance) { instance_double(described_class, call: { run_id: "abc", file_count: 1, files: [] }) }
+
+    it "delegates to a new instance" do
+      result
+      expect(instance).to have_received(:call)
+    end
+
+    it "returns the instance result" do
+      expect(result).to eq({ run_id: "abc", file_count: 1, files: [] })
+    end
+  end
+
+  describe "#call" do
+    subject(:result) { described_class.new.call }
+
+    let(:file_paths) { ["spec/requests/orders_spec.rb", "spec/requests/users_spec.rb"] }
+    let(:run) { instance_double(Devformance::Run, run_id: "deadbeef12345678", total_files: 2) }
+
+    before do
+      allow(Dir).to receive(:glob).and_return(file_paths)
+      allow(File).to receive(:read).and_return("")
+      allow(Devformance::Run).to receive(:create_for_files).and_return(run)
+      allow(Devformance::FileResult).to receive(:create!).and_return(true)
+      allow(ActionCable.server).to receive(:broadcast)
+      allow(Devformance::FileRunnerJob).to receive(:perform_later)
+    end
+
+    context "when spec files are found" do
+      it "returns the run_id" do
+        expect(result[:run_id]).to eq("deadbeef12345678")
+      end
+
+      it "returns the file count" do
+        expect(result[:file_count]).to eq(2)
+      end
+
+      it "returns file metadata for each file" do
+        expect(result[:files].size).to eq(2)
+      end
+
+      it "broadcasts run_started on the run stream" do
+        result
+        expect(ActionCable.server).to have_received(:broadcast).with(
+          "devformance:run:deadbeef12345678",
+          hash_including(type: "run_started", run_id: "deadbeef12345678")
+        )
+      end
+
+      it "enqueues a FileRunnerJob for each file" do
+        result
+        expect(Devformance::FileRunnerJob).to have_received(:perform_later).twice
+      end
+
+      it "creates a FileResult record for each file" do
+        result
+        expect(Devformance::FileResult).to have_received(:create!).twice
+      end
+    end
+
+    context "when no spec files are found" do
+      before { allow(Dir).to receive(:glob).and_return([]) }
+
+      it "returns an error key" do
+        expect(result).to have_key(:error)
+      end
+
+      it "does not enqueue any jobs" do
+        result
+        expect(Devformance::FileRunnerJob).not_to have_received(:perform_later)
+      end
+    end
+
+    context "when some files are tagged with devformance" do
+      let(:tagged_path)   { "spec/requests/tagged_spec.rb" }
+      let(:untagged_path) { "spec/requests/plain_spec.rb" }
+
+      before do
+        allow(Dir).to receive(:glob).and_return([tagged_path, untagged_path])
+        allow(File).to receive(:read).with(tagged_path).and_return("# devformance: true")
+        allow(File).to receive(:read).with(untagged_path).and_return("# plain spec")
+        allow(Devformance::Run).to receive(:create_for_files).with([tagged_path]).and_return(run)
+      end
+
+      it "runs only the tagged files" do
+        result
+        expect(Devformance::Run).to have_received(:create_for_files).with([tagged_path])
+      end
+    end
+  end
+end

data/spec/lib/devmetrics/sql_instrumentor_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Devformance::SqlInstrumentor do
+  describe ".around_run" do
+    it "sets the thread-local collector during the block" do
+      collector_during = nil
+      described_class.around_run { collector_during = Thread.current[described_class::THREAD_KEY] }
+      expect(collector_during).to include(:queries, :start)
+    end
+
+    it "clears the thread-local collector after the block" do
+      described_class.around_run { nil }
+      expect(Thread.current[described_class::THREAD_KEY]).to be_nil
+    end
+
+    it "clears the collector even when the block raises" do
+      expect { described_class.around_run { raise "boom" } }.to raise_error("boom")
+      expect(Thread.current[described_class::THREAD_KEY]).to be_nil
+    end
+
+    it "initializes queries as an empty array" do
+      queries_at_start = nil
+      described_class.around_run { queries_at_start = Thread.current[described_class::THREAD_KEY][:queries] }
+      expect(queries_at_start).to eq([])
+    end
+  end
+
+  describe ".record" do
+    let(:event) do
+      instance_double(ActiveSupport::Notifications::Event,
+        duration: 42.5,
+        payload:  { sql: "SELECT * FROM users" })
+    end
+
+    context "when called outside around_run" do
+      it "returns nil without recording" do
+        expect(described_class.record(event)).to be_nil
+      end
+    end
+
+    context "when called inside around_run" do
+      it "records the query with rounded ms and sql" do
+        recorded = nil
+        described_class.around_run { recorded = described_class.record(event) }
+        expect(recorded).to include(sql: "SELECT * FROM users", ms: 42.5)
+      end
+
+      it "includes an iso8601 timestamp" do
+        recorded = nil
+        described_class.around_run { recorded = described_class.record(event) }
+        expect(recorded[:at]).to match(/\A\d{4}-\d{2}-\d{2}T/)
+      end
+    end
+
+    context "with transaction control statements" do
+      %w[BEGIN COMMIT ROLLBACK SAVEPOINT RELEASE].each do |stmt|
+        context "when sql is #{stmt}" do
+          let(:event) do
+            instance_double(ActiveSupport::Notifications::Event,
+              duration: 1.0,
+              payload:  { sql: stmt })
+          end
+
+          it "does not record the #{stmt} statement" do
+            result = nil
+            described_class.around_run { result = described_class.record(event) }
+            expect(result).to be_nil
+          end
+        end
+      end
+    end
+
+    context "when sql has leading/trailing whitespace" do
+      let(:event) do
+        instance_double(ActiveSupport::Notifications::Event,
+          duration: 10.0,
+          payload:  { sql: "  SELECT id FROM orders  " })
+      end
+
+      it "strips whitespace before recording" do
+        recorded = nil
+        described_class.around_run { recorded = described_class.record(event) }
+        expect(recorded[:sql]).to eq("SELECT id FROM orders")
+      end
+    end
+  end
+
+  describe ".queries" do
+    context "when called outside around_run" do
+      it "returns an empty array" do
+        expect(described_class.queries).to eq([])
+      end
+    end
+
+    context "when called inside around_run after recording" do
+      let(:event) do
+        instance_double(ActiveSupport::Notifications::Event,
+          duration: 5.0,
+          payload:  { sql: "SELECT 1" })
+      end
+
+      it "returns the recorded queries" do
+        queries = nil
+        described_class.around_run do
+          described_class.record(event)
+          queries = described_class.queries
+        end
+        expect(queries.size).to eq(1)
+        expect(queries.first[:sql]).to eq("SELECT 1")
+      end
+    end
+  end
+end

data/spec/models/devmetrics/file_result_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Devformance::FileResult, type: :model do
+  let(:run) do
+    Devformance::Run.create!(
+      run_id:      SecureRandom.hex(8),
+      status:      :running,
+      total_files: 1,
+      started_at:  Time.current
+    )
+  end
+
+  describe ".file_key_for" do
+    subject(:key) { described_class.file_key_for(file_path) }
+
+    context "with a standard spec path" do
+      let(:file_path) { "spec/requests/users_spec.rb" }
+
+      it "returns the basename without .rb extension" do
+        expect(key).to eq("users_spec")
+      end
+    end
+
+    context "with hyphens and uppercase in filename" do
+      let(:file_path) { "spec/requests/my-complex_spec.rb" }
+
+      it "replaces non-alphanumeric characters with underscores" do
+        expect(key).to eq("my_complex_spec")
+      end
+    end
+
+    context "with a deeply nested path" do
+      let(:file_path) { "/home/user/app/spec/requests/api/v1/orders_spec.rb" }
+
+      it "uses only the basename" do
+        expect(key).to eq("orders_spec")
+      end
+    end
+  end
+
+  describe "enum status" do
+    subject(:result) do
+      described_class.create!(
+        run_id:    run.run_id,
+        file_key:  "foo_spec",
+        file_path: "spec/requests/foo_spec.rb",
+        status:    :pending
+      )
+    end
+
+    it "starts as pending" do
+      expect(result).to be_pending
+    end
+
+    it "transitions to running" do
+      result.running!
+      expect(result).to be_running
+    end
+
+    it "transitions to passed" do
+      result.passed!
+      expect(result).to be_passed
+    end
+
+    it "transitions to failed" do
+      result.failed!
+      expect(result).to be_failed
+    end
+  end
+
+  describe "associations" do
+    subject(:result) do
+      described_class.create!(
+        run_id:    run.run_id,
+        file_key:  "foo_spec",
+        file_path: "spec/requests/foo_spec.rb",
+        status:    :pending
+      )
+    end
+
+    it "belongs to a run via run_id" do
+      expect(result.run).to eq(run)
+    end
+  end
+end

data/spec/models/devmetrics/run_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Devformance::Run, type: :model do
+  describe ".create_for_files" do
+    subject(:run) { described_class.create_for_files(file_paths) }
+
+    let(:file_paths) { ["spec/requests/foo_spec.rb", "spec/requests/bar_spec.rb"] }
+
+    it "creates a record with a hex run_id" do
+      expect(run.run_id).to match(/\A[0-9a-f]{16}\z/)
+    end
+
+    it "sets status to running" do
+      expect(run).to be_running
+    end
+
+    it "sets total_files to the number of paths" do
+      expect(run.total_files).to eq(2)
+    end
+
+    it "sets started_at to current time" do
+      freeze_time = Time.current
+      allow(Time).to receive(:current).and_return(freeze_time)
+      expect(run.started_at.to_i).to eq(freeze_time.to_i)
+    end
+
+    it "persists to the database" do
+      expect { run }.to change(described_class, :count).by(1)
+    end
+  end
+
+  describe "enum status" do
+    subject(:run) { described_class.create!(run_id: SecureRandom.hex(8), status: :pending, total_files: 1, started_at: Time.current) }
+
+    it "transitions from pending to running" do
+      run.running!
+      expect(run).to be_running
+    end
+
+    it "transitions to completed" do
+      run.completed!
+      expect(run).to be_completed
+    end
+
+    it "transitions to failed" do
+      run.failed!
+      expect(run).to be_failed
+    end
+  end
+
+  describe "associations" do
+    subject(:run) { described_class.create!(run_id: SecureRandom.hex(8), status: :running, total_files: 1, started_at: Time.current) }
+
+    it "has many file_results" do
+      result = Devformance::FileResult.create!(
+        run_id:    run.run_id,
+        file_key:  "foo_spec",
+        file_path: "spec/requests/foo_spec.rb",
+        status:    :pending
+      )
+      expect(run.file_results).to include(result)
+    end
+  end
+end

data/spec/models/query_log_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe QueryLog, type: :model do
+  describe "#initialize" do
+    subject(:instance) { described_class.new(query: "SELECT 1") }
+
+    it "stores the query attribute" do
+      expect(instance.query).to eq("SELECT 1")
+    end
+  end
+
+  describe "validations" do
+    subject(:log) { described_class.new(query: "SELECT * FROM users", duration: 150, user_id: 1) }
+
+    it "is valid with basic attributes" do
+      expect(log).to be_valid
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,20 @@
+ENV['RAILS_ENV'] ||= 'test'
+require_relative '../config/environment'
+require 'rspec/rails'
+require 'factory_bot'
+require 'simplecov'
+SimpleCov.start 'rails' do
+  enable_coverage :branch
+  add_filter '/spec/'
+end
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.infer_spec_type_from_file_location!
+  config.include FactoryBot::Syntax::Methods
+end
+
+Dir[Rails.root.join("spec/fixtures/devformance/**/*.rb")].each { |f| require f }
+
+require_relative '../spec/support/devformance_formatter'
+require_relative '../spec/support/devformance_metrics'

data/spec/requests/devmetrics/metrics_controller_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Devformance::MetricsController, type: :request do
+  describe "GET /devformance" do
+    subject { get "/devformance" }
+
+    it "returns 200" do
+      subject
+      expect(response).to have_http_status(200)
+    end
+  end
+
+  describe "POST /devformance/run_tests" do
+    subject { post "/devformance/run_tests", headers: { "Content-Type" => "application/json" } }
+
+    context "when the orchestrator succeeds" do
+      let(:orchestrator_result) do
+        { run_id: "abc123", file_count: 2, files: [{ file_key: "a_spec", display_name: "a_spec.rb" }] }
+      end
+
+      before do
+        allow(Devformance::RunOrchestrator).to receive(:call).and_return(orchestrator_result)
+      end
+
+      it "returns 202" do
+        subject
+        expect(response).to have_http_status(202)
+      end
+
+      it "includes the run_id in the response" do
+        subject
+        expect(JSON.parse(response.body)["run_id"]).to eq("abc123")
+      end
+
+      it "includes the files array" do
+        subject
+        expect(JSON.parse(response.body)["files"]).to be_an(Array)
+      end
+    end
+
+    context "when the orchestrator returns an error" do
+      before do
+        allow(Devformance::RunOrchestrator).to receive(:call).and_return({ error: "No request specs found" })
+      end
+
+      it "returns 422" do
+        subject
+        expect(response).to have_http_status(422)
+      end
+
+      it "includes the error message" do
+        subject
+        expect(JSON.parse(response.body)["error"]).to eq("No request specs found")
+      end
+    end
+  end
+
+  describe "GET /devformance/runs/:run_id/status" do
+    let(:run_id) { SecureRandom.hex(8) }
+
+    context "when the run exists" do
+      let!(:run) do
+        Devformance::Run.create!(
+          run_id:      run_id,
+          status:      :running,
+          total_files: 1,
+          started_at:  Time.current
+        )
+      end
+
+      it "returns 200" do
+        get "/devformance/runs/#{run_id}/status"
+        expect(response).to have_http_status(200)
+      end
+
+      it "includes the run status" do
+        get "/devformance/runs/#{run_id}/status"
+        expect(JSON.parse(response.body)["status"]).to eq("running")
+      end
+    end
+
+    context "when the run does not exist" do
+      it "returns 404" do
+        get "/devformance/runs/nonexistent/status"
+        expect(response).to have_http_status(404)
+      end
+    end
+  end
+
+  describe "GET /devformance/runs/:run_id/logs/:file_key/download" do
+    let(:run_id)   { SecureRandom.hex(8) }
+    let(:file_key) { "orders_spec" }
+    let(:run) do
+      Devformance::Run.create!(
+        run_id:      run_id,
+        status:      :completed,
+        total_files: 1,
+        started_at:  Time.current
+      )
+    end
+
+    context "when the file result exists with a readable log" do
+      let(:tmpfile) { Tempfile.new("orders_spec.log") }
+
+      let!(:result) do
+        Devformance::FileResult.create!(
+          run_id:    run.run_id,
+          file_key:  file_key,
+          file_path: "spec/requests/orders_spec.rb",
+          status:    :passed,
+          log_path:  tmpfile.path
+        )
+      end
+
+      after { tmpfile.unlink }
+
+      it "returns 200 and sends the file" do
+        get "/devformance/runs/#{run_id}/logs/#{file_key}/download"
+        expect(response).to have_http_status(200)
+      end
+    end
+
+    context "when the file result does not exist" do
+      it "returns 404" do
+        get "/devformance/runs/#{run_id}/logs/missing/download"
+        expect(response).to have_http_status(404)
+      end
+    end
+
+    context "when the file result exists but log file is missing from disk" do
+      let!(:result) do
+        Devformance::FileResult.create!(
+          run_id:    run.run_id,
+          file_key:  file_key,
+          file_path: "spec/requests/orders_spec.rb",
+          status:    :passed,
+          log_path:  "/tmp/devformance_nonexistent_#{SecureRandom.hex}.log"
+        )
+      end
+
+      it "returns 404" do
+        get "/devformance/runs/#{run_id}/logs/#{file_key}/download"
+        expect(response).to have_http_status(404)
+      end
+    end
+  end
+end