capydash 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa238074c05a59e8c88ec84c887944dc2c376ae379ffde69c3422b939d052d77
-  data.tar.gz: fdfc24fbe669f5a8d0ff44792383b5eae3abcf69d21ed52810228972d0773959
+  metadata.gz: 49eae6d67432aa999fc952f38f9268dd145275fccc64e31ebf9ec325580084f1
+  data.tar.gz: c169ad633644fadf23a8c6a672bb0e73621fdf66c2c16d35662dcea5e7fea0a7
 SHA512:
-  metadata.gz: b49bd9f834a849025f79fc72fc3c317e971fba0ea74504e09d35026a4bdb18b224f48a86ab6041fb43a78de5dd6897ecba9ca43e9f57bfc356385a318313f0e4
-  data.tar.gz: 9c3f988ea6164e454f73d1600ec61ceddfc63f9f6dbb4220c535df60ecf4662f08653fdbcfc9bf6936616382455d8bef473a5f03336d6af8aba72da328c67428
+  metadata.gz: 13a7e91002c75629f074f0e717f585a066296f90847599da479c6d54a6bb622cd354d0449d0e5526a7af253bc702fad7629a5bb595a3426b525f153110546880
+  data.tar.gz: 95432cc4068cd79a74c1f569a5c239eef704d152918fe81f81e8771e451295f0d9664977cf4127680b91483424ea89945991bda8df79a325e1266d44a45c4d10

data/README.md

@@ -16,8 +16,36 @@ Or run:
 bundle add capydash
 ```
 
+## Quick Setup
+
+### One-Command Installation
+
+After adding CapyDash to your Gemfile and running `bundle install`, simply run:
+
+```bash
+bundle exec rails generate capydash:install
+```
+
+This will automatically:
+- ✅ Create the CapyDash initializer
+- ✅ Update your test helper with all necessary hooks
+- ✅ Add rake tasks for report generation
+- ✅ Works with parallel testing out of the box
+
+### Manual Setup (Alternative)
+
+If you prefer to set up CapyDash manually, see the [Manual Setup Guide](#manual-setup) below.
+
 ## Usage
 
+### Run Tests with CapyDash
+
+Run your tests normally - CapyDash will automatically instrument them:
+
+```bash
+bundle exec rails test
+```
+
 ### Generate Test Report
 
 After running your Capybara tests, generate a static HTML report:
@@ -45,17 +73,133 @@ open capydash_report/index.html
 bundle exec rake capydash:server
 ```
 
-Then open `http://localhost:5173` in your browser.
+Then open `http://localhost:4000` in your browser.
 
-### Run Tests with CapyDash
+## Troubleshooting
 
-Run your tests normally - CapyDash will automatically instrument them:
+### Common Issues
 
-```bash
-bundle exec rails test
+1. **"No test data found"**: Make sure you've added the test helper configuration and are running actual Capybara tests (not just unit tests).
+
+2. **"log shifting failed" error**: This is a Rails logger issue, not related to CapyDash. It's harmless but you can fix it by updating your Rails version.
+
+3. **Screenshots not working**: Make sure you're using a driver that supports screenshots (like Selenium, not rack_test).
+
+4. **Tests not appearing in report**: Ensure your tests are using Capybara methods like `visit`, `click_button`, `fill_in`, etc.
+
+5. **"No test data found"**: Make sure you're running system tests that use Capybara methods. CapyDash works with parallel testing by default.
+
+### Example Test
+
+Here's an example test that will work with CapyDash:
+
+```ruby
+require 'test_helper'
+
+class HomepageTest < ActionDispatch::IntegrationTest
+  include Capybara::DSL
+
+  test "homepage loads with correct content" do
+    visit "/"
+    assert_text "Welcome"
+
+    fill_in "Your name", with: "Alice"
+    click_button "Greet"
+    assert_text "Hello, Alice!"
+  end
+end
+```
+
+## Manual Setup
+
+If you prefer to set up CapyDash manually instead of using the generator:
+
+### Step 1: Create CapyDash Initializer
+
+Create `config/initializers/capydash.rb` in your Rails project:
+
+```ruby
+require 'capydash'
+
+# Configure CapyDash
+CapyDash.configure do |config|
+  config.port = 4000
+  config.screenshot_path = "tmp/capydash_screenshots"
+end
+
+# Subscribe to events for test data collection
+CapyDash::EventEmitter.subscribe do |event|
+  # Collect test data for report generation
+  CapyDash::TestDataAggregator.handle_event(event)
+end
 ```
 
-The report will be generated in `capydash_report/index.html` after test completion.
+### Step 2: Update Test Helper
+
+In your `test/test_helper.rb`, add the following:
+
+```ruby
+require 'capydash'
+
+# Start test run data collection
+CapyDash::TestDataCollector.start_test_run
+
+# Hook into test execution to set current test name and manage test runs
+module CapyDash
+  module TestHooks
+    def run(&block)
+      # Set the current test name for CapyDash
+      CapyDash.current_test = self.name
+
+      # Start test run data collection if not already started
+      CapyDash::TestDataAggregator.start_test_run unless CapyDash::TestDataAggregator.instance_variable_get(:@current_run)
+
+      super
+    end
+  end
+end
+
+# Apply the hook to the test case
+class ActiveSupport::TestCase
+  prepend CapyDash::TestHooks
+end
+
+# Hook to finish test run when all tests are done
+Minitest.after_run do
+  CapyDash::TestDataCollector.finish_test_run
+  CapyDash::TestDataAggregator.finish_test_run
+end
+```
+
+### Step 3: Add Rake Tasks
+
+Create `lib/tasks/capydash.rake` in your Rails project:
+
+```ruby
+namespace :capydash do
+  desc "Generate static HTML test report"
+  task :report => :environment do
+    CapyDash::ReportGenerator.generate_report
+  end
+
+  desc "Start local server to view static HTML report"
+  task :server => :environment do
+    CapyDash::DashboardServer.start
+  end
+end
+```
+
+### Step 4: Configure System Tests (Optional)
+
+If you're using system tests, make sure your `test/application_system_test_case.rb` uses a driver that supports screenshots:
+
+```ruby
+require "test_helper"
+
+class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
+  driven_by :selenium, using: :headless_chrome, screen_size: [ 800, 600 ]
+end
+```
 
 ## Development
 

data/capydash.gemspec

@@ -16,6 +16,9 @@ Gem::Specification.new do |spec|
   spec.files         = Dir["lib/**/*", "bin/*", "README.md", "LICENSE*", "*.gemspec"]
   spec.require_paths = ["lib"]
 
+  # Add generator support
+  spec.add_runtime_dependency "railties", ">= 5.0"
+
   # Dependencies
   spec.add_runtime_dependency "capybara", ">= 3.0"
   spec.add_runtime_dependency "faye-websocket"

data/lib/capydash/test_data_aggregator.rb

@@ -1,103 +1,128 @@
 require 'json'
 require 'time'
 require 'securerandom'
+require 'fileutils'
 
 module CapyDash
   class TestDataAggregator
     class << self
       def start_test_run
-        @current_run = {
-          id: generate_run_id,
+        run_id = generate_run_id
+        run_data = {
+          id: run_id,
           created_at: Time.now.iso8601,
           total_tests: 0,
           passed_tests: 0,
           failed_tests: 0,
           tests: []
         }
-        @current_test = nil
-        @test_steps = []
+
+        # Save initial run data to file
+        save_run_data(run_data)
+
+        # Set current test context
+        set_current_test_context(run_id, nil, [])
       end
 
       def finish_test_run
-        return unless @current_run
+        run_id = get_current_run_id
+        return unless run_id
 
-        # Save the test run data
-        CapyDash.save_test_run(@current_run)
+        # Load current run data
+        run_data = load_run_data(run_id)
+        return unless run_data
+
+        # Save the final test run data
+        CapyDash.save_test_run(run_data)
 
         # Clear current state
-        @current_run = nil
-        @current_test = nil
-        @test_steps = nil
+        clear_current_test_context
       end
 
       def handle_event(event)
-        return unless @current_run
+        run_id = get_current_run_id
+        return unless run_id
+
+        # Load current run data
+        run_data = load_run_data(run_id)
+        return unless run_data
 
         case event[:step_name]
         when 'test_start'
-          start_new_test(event)
+          start_new_test(event, run_data)
         when 'test_finish'
-          finish_current_test(event)
+          finish_current_test(event, run_data)
         when 'test_result'
           # This indicates the test is finished
-          finish_current_test(event)
+          finish_current_test(event, run_data)
         else
           # This is a test step (visit, click_button, fill_in, etc.)
           # If we don't have a current test, start one
-          start_new_test(event) unless @current_test
-          add_test_step(event)
+          current_test = get_current_test
+          start_new_test(event, run_data) unless current_test
+          add_test_step(event, run_data)
         end
       end
 
       private
 
-      def start_new_test(event)
+      def start_new_test(event, run_data)
         # Extract test name from the current test context
         test_name = event[:test_name] || CapyDash.current_test || "unknown_test"
 
-        @current_test = {
+        current_test = {
           test_name: test_name,
           steps: []
         }
-        @test_steps = []
+
+        # Set current test context
+        set_current_test_context(run_data[:id], current_test, [])
 
         # Add the test_start step
-        add_test_step(event)
+        add_test_step(event, run_data)
       end
 
-      def finish_current_test(event)
-        return unless @current_test
+      def finish_current_test(event, run_data)
+        current_test = get_current_test
+        return unless current_test
 
         # Add the test_finish step
-        add_test_step(event)
+        add_test_step(event, run_data)
+
+        # Get updated test data
+        current_test = get_current_test
+        test_steps = get_current_test_steps
 
         # Determine test status
-        test_status = determine_test_status(@test_steps)
+        test_status = determine_test_status(test_steps)
 
         # Update counters
-        @current_run[:total_tests] += 1
+        run_data[:total_tests] += 1
         if test_status == 'passed'
-          @current_run[:passed_tests] += 1
+          run_data[:passed_tests] += 1
         elsif test_status == 'failed'
-          @current_run[:failed_tests] += 1
+          run_data[:failed_tests] += 1
         end
 
         # Add test to current run
-        @current_run[:tests] << @current_test
+        run_data[:tests] << current_test
+
+        # Save updated run data
+        save_run_data(run_data)
 
         # Clear current test
-        @current_test = nil
-        @test_steps = nil
+        set_current_test_context(run_data[:id], nil, [])
       end
 
-      def add_test_step(event)
-        return unless @current_test
+      def add_test_step(event, run_data)
+        current_test = get_current_test
+        return unless current_test
 
         step = {
           step_name: event[:step_name],
           detail: event[:detail],
           status: event[:status],
-          test_name: event[:test_name] || CapyDash.current_test || @current_test[:test_name]
+          test_name: event[:test_name] || CapyDash.current_test || current_test[:test_name]
         }
 
         # Add screenshot if present
@@ -110,8 +135,12 @@ module CapyDash
           step[:error] = event[:error]
         end
 
-        @current_test[:steps] << step
-        @test_steps << step
+        # Update current test with new step
+        current_test[:steps] << step
+        test_steps = get_current_test_steps + [step]
+
+        # Save updated test context
+        set_current_test_context(run_data[:id], current_test, test_steps)
       end
 
       def determine_test_status(steps)
@@ -123,6 +152,63 @@ module CapyDash
       def generate_run_id
         "#{Time.now.to_i}_#{SecureRandom.hex(4)}"
       end
+
+      # File-based storage methods for parallel testing support
+      def run_data_file(run_id)
+        File.join(Dir.pwd, "tmp", "capydash_data", "run_#{run_id}.json")
+      end
+
+      def context_file
+        File.join(Dir.pwd, "tmp", "capydash_data", "current_context.json")
+      end
+
+      def save_run_data(run_data)
+        FileUtils.mkdir_p(File.dirname(run_data_file(run_data[:id])))
+        File.write(run_data_file(run_data[:id]), run_data.to_json)
+      end
+
+      def load_run_data(run_id)
+        file_path = run_data_file(run_id)
+        return nil unless File.exist?(file_path)
+
+        JSON.parse(File.read(file_path), symbolize_names: true)
+      end
+
+      def set_current_test_context(run_id, current_test, test_steps)
+        context = {
+          run_id: run_id,
+          current_test: current_test,
+          test_steps: test_steps
+        }
+
+        FileUtils.mkdir_p(File.dirname(context_file))
+        File.write(context_file, context.to_json)
+      end
+
+      def get_current_run_id
+        return nil unless File.exist?(context_file)
+
+        context = JSON.parse(File.read(context_file), symbolize_names: true)
+        context[:run_id]
+      end
+
+      def get_current_test
+        return nil unless File.exist?(context_file)
+
+        context = JSON.parse(File.read(context_file), symbolize_names: true)
+        context[:current_test]
+      end
+
+      def get_current_test_steps
+        return [] unless File.exist?(context_file)
+
+        context = JSON.parse(File.read(context_file), symbolize_names: true)
+        context[:test_steps] || []
+      end
+
+      def clear_current_test_context
+        File.delete(context_file) if File.exist?(context_file)
+      end
     end
   end
 end

data/lib/capydash/version.rb

@@ -1,3 +1,3 @@
 module Capydash
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 end

data/lib/generators/capydash/install_generator.rb

@@ -0,0 +1,124 @@
+require 'rails/generators'
+
+module Capydash
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      desc "Installs CapyDash with all necessary configuration files"
+
+      def create_initializer
+        create_file "config/initializers/capydash.rb", <<~RUBY
+          require 'capydash'
+
+          # Configure CapyDash
+          CapyDash.configure do |config|
+            config.port = 4000
+            config.screenshot_path = "tmp/capydash_screenshots"
+          end
+
+          # Subscribe to events for test data collection
+          CapyDash::EventEmitter.subscribe do |event|
+            # Collect test data for report generation
+            CapyDash::TestDataAggregator.handle_event(event)
+          end
+        RUBY
+      end
+
+      def create_rake_tasks
+        create_file "lib/tasks/capydash.rake", <<~RUBY
+          namespace :capydash do
+            desc "Generate static HTML test report"
+            task :report => :environment do
+              CapyDash::ReportGenerator.generate_report
+            end
+
+            desc "Start local server to view static HTML report"
+            task :server => :environment do
+              CapyDash::DashboardServer.start
+            end
+          end
+        RUBY
+      end
+
+      def update_test_helper
+        test_helper_path = "test/test_helper.rb"
+
+        if File.exist?(test_helper_path)
+          # Read existing test helper
+          content = File.read(test_helper_path)
+
+          # Check if CapyDash is already configured
+          unless content.include?("require 'capydash'")
+            # Add CapyDash configuration
+            capydash_config = <<~RUBY
+
+              # CapyDash configuration
+              require 'capydash'
+
+              # Start test run data collection
+              CapyDash::TestDataCollector.start_test_run
+
+              # Hook into test execution to set current test name and manage test runs
+              module CapyDash
+                module TestHooks
+                  def run(&block)
+                    # Set the current test name for CapyDash
+                    CapyDash.current_test = self.name
+
+                    # Start test run data collection if not already started
+                    CapyDash::TestDataAggregator.start_test_run unless CapyDash::TestDataAggregator.instance_variable_get(:@current_run)
+
+                    super
+                  end
+                end
+              end
+
+              # Apply the hook to the test case
+              class ActiveSupport::TestCase
+                prepend CapyDash::TestHooks
+              end
+
+              # Hook to finish test run when all tests are done
+              Minitest.after_run do
+                CapyDash::TestDataCollector.finish_test_run
+                CapyDash::TestDataAggregator.finish_test_run
+              end
+            RUBY
+
+            # Insert after the last require statement
+            if content.match(/require.*\n/)
+              content = content.gsub(/(require.*\n)/, "\\1#{capydash_config}")
+            else
+              content = capydash_config + content
+            end
+
+            File.write(test_helper_path, content)
+            say "Updated test/test_helper.rb with CapyDash configuration"
+          else
+            say "CapyDash already configured in test/test_helper.rb", :yellow
+          end
+        else
+          say "test/test_helper.rb not found. Please add CapyDash configuration manually.", :red
+        end
+      end
+
+
+      def show_instructions
+        say "\n" + "="*60, :green
+        say "CapyDash has been successfully installed!", :green
+        say "="*60, :green
+        say "\nNext steps:", :yellow
+        say "1. Run your tests: bundle exec rails test"
+        say "2. Generate report: bundle exec rake capydash:report"
+        say "3. View report: open capydash_report/index.html"
+        say "\nImportant:", :yellow
+        say "- CapyDash only captures system tests that use Capybara methods (visit, click, fill_in, etc.)"
+        say "- Unit tests and integration tests without Capybara won't appear in the report"
+        say "- Works with parallel testing - no configuration needed"
+        say "\nFor more information, see the README.md file."
+        say "="*60, :green
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capydash
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Damon Clark
@@ -9,6 +9,20 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: capybara
   requirement: !ruby/object:Gem::Requirement
@@ -119,6 +133,7 @@ files:
 - lib/capydash/test_data_aggregator.rb
 - lib/capydash/test_data_collector.rb
 - lib/capydash/version.rb
+- lib/generators/capydash/install_generator.rb
 - lib/tasks/capydash.rake
 homepage: https://github.com/damonclark/capydash
 licenses: