capydash 0.2.0 → 0.2.2

data/lib/capydash/rspec_integration.rb

@@ -1,285 +0,0 @@
-require 'time'
-require 'securerandom'
-require 'fileutils'
-require 'erb'
-
-module CapyDash
-  module RSpecIntegration
-    class << self
-      def setup!
-        return unless defined?(RSpec)
-        return if @configured
-
-        @results = []
-        @run_id = nil
-        @configured = true
-
-        RSpec.configure do |config|
-          config.before(:suite) do
-            CapyDash::RSpecIntegration.start_test_run
-          end
-
-          config.after(:each) do |example|
-            CapyDash::RSpecIntegration.record_example(example)
-          end
-
-          config.after(:suite) do
-            CapyDash::RSpecIntegration.finish_test_run
-          end
-        end
-      end
-
-      def start_test_run
-        @run_id = generate_run_id
-        @results = []
-        @started_at = Time.now
-      end
-
-      def record_example(example)
-        return unless @run_id
-
-        execution_result = example.execution_result
-
-        # Map RSpec status to our status format
-        status = case execution_result.status.to_s
-        when 'passed'
-          'passed'
-        when 'failed'
-          'failed'
-        when 'pending'
-          'pending'
-        else
-          'unknown'
-        end
-
-        # Extract error message if test failed
-        error_message = nil
-        if execution_result.status == :failed && execution_result.exception
-          error_message = format_exception(execution_result.exception)
-        end
-
-        # Extract class name from example location
-        # RSpec examples are typically in files like spec/features/user_spec.rb
-        # We'll use the file path to determine the "class" name
-        file_path = example.metadata[:file_path] || ''
-        class_name = extract_class_name_from_path(file_path)
-
-        # Create test data structure matching Minitest format
-        test_data = {
-          test_name: "#{class_name}##{example.full_description}",
-          steps: [
-            {
-              step_name: 'test_execution',
-              detail: example.full_description,
-              status: status,
-              error: error_message
-            }
-          ]
-        }
-
-        # Add location information
-        if example.metadata[:location]
-          test_data[:location] = example.metadata[:location]
-        end
-
-        @results << test_data
-      end
-
-      def finish_test_run
-        return unless @run_id
-        return if @results.empty?
-
-        # Calculate summary statistics
-        total_tests = @results.length
-        passed_tests = @results.count { |r| r[:steps].any? { |s| s[:status] == 'passed' } }
-        failed_tests = @results.count { |r| r[:steps].any? { |s| s[:status] == 'failed' } }
-        pending_tests = @results.count { |r| r[:steps].any? { |s| s[:status] == 'pending' } }
-
-        # Create run data structure matching Minitest format
-        run_data = {
-          id: @run_id,
-          created_at: @started_at.iso8601,
-          total_tests: total_tests,
-          passed_tests: passed_tests,
-          failed_tests: failed_tests,
-          tests: @results.map { |r| { test_name: r[:test_name], steps: r[:steps] } }
-        }
-
-        # Save using the existing persistence layer
-        CapyDash.save_test_run(run_data)
-
-        # Generate report
-        generate_report(run_data)
-
-        # Clear state
-        @run_id = nil
-        @results = []
-      end
-
-      private
-
-      def generate_run_id
-        "#{Time.now.to_i}_#{SecureRandom.hex(4)}"
-      end
-
-      def extract_class_name_from_path(file_path)
-        return 'UnknownSpec' if file_path.nil? || file_path.empty?
-
-        # Extract filename without extension and path
-        filename = File.basename(file_path, '.rb')
-
-        # Convert snake_case to PascalCase
-        # e.g., "user_spec" -> "UserSpec", "features/user_flow_spec" -> "UserFlowSpec"
-        filename.split('_').map(&:capitalize).join('')
-      end
-
-      def format_exception(exception)
-        return nil unless exception
-
-        message = exception.message || 'Unknown error'
-        backtrace = exception.backtrace || []
-
-        # Format similar to RSpec's output
-        formatted = "#{exception.class}: #{message}"
-
-        if backtrace.any?
-          # Include first few lines of backtrace
-          formatted += "\n" + backtrace.first(5).map { |line| "  #{line}" }.join("\n")
-        end
-
-        formatted
-      end
-
-      def generate_report(run_data)
-        # Use the existing ReportGenerator but with our RSpec data
-        # We need to adapt it to work with our in-memory data structure
-        report_dir = File.join(Dir.pwd, "capydash_report")
-        FileUtils.mkdir_p(report_dir)
-
-        assets_dir = File.join(report_dir, "assets")
-        FileUtils.mkdir_p(assets_dir)
-
-        screenshots_dir = File.join(report_dir, "screenshots")
-        FileUtils.mkdir_p(screenshots_dir)
-
-        # Generate HTML report using the same template
-        html_content = generate_html(run_data, run_data[:created_at])
-        html_path = File.join(report_dir, "index.html")
-        File.write(html_path, html_content)
-
-        # Generate CSS and JS - use ReportGenerator's private methods via send
-        # These methods are private but we need them for RSpec reports
-        css_content = CapyDash::ReportGenerator.send(:generate_css)
-        css_path = File.join(assets_dir, "dashboard.css")
-        File.write(css_path, css_content)
-
-        js_content = CapyDash::ReportGenerator.send(:generate_javascript)
-        js_path = File.join(assets_dir, "dashboard.js")
-        File.write(js_path, js_content)
-
-        html_path
-      end
-
-      def generate_html(test_data, created_at)
-        # Process test data into a structured format (same as ReportGenerator)
-        processed_tests = process_test_data(test_data)
-
-        # Calculate summary statistics
-        total_tests = processed_tests.sum { |test| test[:methods].length }
-        passed_tests = processed_tests.sum { |test| test[:methods].count { |method| method[:status] == 'passed' } }
-        failed_tests = total_tests - passed_tests
-
-        # Parse created_at if it's a string, otherwise use Time object
-        created_at_time = if created_at.is_a?(String)
-          Time.parse(created_at)
-        else
-          created_at
-        end
-
-        # Generate HTML using ERB template
-        template = File.read(File.join(__dir__, 'templates', 'report.html.erb'))
-        erb = ERB.new(template)
-
-        erb.result(binding)
-      end
-
-      def process_test_data(test_data)
-        return [] unless test_data[:tests]
-
-        # Group tests by class
-        tests_by_class = {}
-
-        test_data[:tests].each do |test|
-          test_name = test[:test_name] || 'UnknownTest'
-
-          # Extract class and method names from test name like "UserSpec#should visit the home page"
-          if test_name.include?('#')
-            class_name, method_name = test_name.split('#', 2)
-          else
-            class_name = extract_class_name(test_name)
-            method_name = extract_method_name(test_name)
-          end
-
-          tests_by_class[class_name] ||= {
-            class_name: class_name,
-            methods: []
-          }
-
-          # Process steps
-          steps = test[:steps] || []
-          processed_steps = steps.map do |step|
-            {
-              name: step[:step_name] || step[:name] || 'unknown_step',
-              detail: step[:detail] || step[:description] || '',
-              status: step[:status] || 'unknown',
-              screenshot: step[:screenshot] ? File.basename(step[:screenshot]) : nil,
-              error: step[:error] || step[:message]
-            }
-          end
-
-          # Filter out "running" steps
-          processed_steps = processed_steps.reject { |step| step[:status] == 'running' }
-
-          # Determine method status
-          method_status = if processed_steps.any? { |s| s[:status] == 'failed' }
-            'failed'
-          elsif processed_steps.any? { |s| s[:status] == 'passed' }
-            'passed'
-          elsif processed_steps.any? { |s| s[:status] == 'pending' }
-            'pending'
-          else
-            'running'
-          end
-
-          tests_by_class[class_name][:methods] << {
-            name: method_name,
-            status: method_status,
-            steps: processed_steps
-          }
-        end
-
-        tests_by_class.values
-      end
-
-      def extract_class_name(test_name)
-        return 'UnknownTest' if test_name.nil? || test_name.empty?
-
-        if test_name.include?('#')
-          test_name.split('#').first
-        else
-          test_name
-        end
-      end
-
-      def extract_method_name(test_name)
-        return 'unknown_method' if test_name.nil? || test_name.empty?
-
-        if test_name.include?('#')
-          test_name.split('#').last
-        else
-          test_name
-        end
-      end
-    end
-  end
-end

data/lib/capydash/test_data_aggregator.rb

@@ -1,221 +0,0 @@
-require 'json'
-require 'time'
-require 'securerandom'
-require 'fileutils'
-
-module CapyDash
-  class TestDataAggregator
-    class << self
-      def start_test_run
-        # Don't start a new run if one is already in progress
-        return if test_run_started?
-
-        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: []
-        }
-
-        # Save initial run data to file
-        save_run_data(run_data)
-
-        # Set current test context
-        set_current_test_context(run_id, nil, [])
-      end
-
-      def test_run_started?
-        get_current_run_id != nil
-      end
-
-      def finish_test_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
-
-        # Save the final test run data
-        CapyDash.save_test_run(run_data)
-
-        # Clear current state
-        clear_current_test_context
-      end
-
-      def handle_event(event)
-        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, run_data)
-        when 'test_finish'
-          finish_current_test(event, run_data)
-        when 'test_result'
-          # This indicates the test is finished
-          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
-          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, run_data)
-        # Extract test name from the current test context
-        test_name = event[:test_name] || CapyDash.current_test || "unknown_test"
-
-        current_test = {
-          test_name: test_name,
-          steps: []
-        }
-
-        # Set current test context
-        set_current_test_context(run_data[:id], current_test, [])
-
-        # Add the test_start step
-        add_test_step(event, run_data)
-      end
-
-      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, 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)
-
-        # Update counters
-        run_data[:total_tests] += 1
-        if test_status == 'passed'
-          run_data[:passed_tests] += 1
-        elsif test_status == 'failed'
-          run_data[:failed_tests] += 1
-        end
-
-        # Add test to current run
-        run_data[:tests] << current_test
-
-        # Save updated run data
-        save_run_data(run_data)
-
-        # Clear current test
-        set_current_test_context(run_data[:id], nil, [])
-      end
-
-      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]
-        }
-
-        # Add screenshot if present
-        if event[:screenshot]
-          step[:screenshot] = event[:screenshot]
-        end
-
-        # Add error if present
-        if event[:error]
-          step[:error] = event[:error]
-        end
-
-        # 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)
-        return 'failed' if steps.any? { |step| step[:status] == 'failed' }
-        return 'passed' if steps.any? { |step| step[:status] == 'passed' }
-        'running'
-      end
-
-      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/test_data_collector.rb

@@ -1,58 +0,0 @@
-require 'capydash/event_emitter'
-
-module CapyDash
-  class TestDataCollector
-    class << self
-      def start_test_run
-        @test_run_started = true
-        @test_count = 0
-        @passed_count = 0
-        @failed_count = 0
-      end
-
-      def finish_test_run
-        return unless @test_run_started
-
-        @test_run_started = false
-      end
-
-      def start_test(test_name, test_class, test_method)
-        return unless @test_run_started
-
-        @test_count += 1
-
-        # Emit test start event
-        CapyDash::EventEmitter.broadcast(
-          step_name: "test_start",
-          detail: "Starting test: #{test_name}",
-          test_name: test_name,
-          status: "running"
-        )
-      end
-
-      def finish_test(test_name, status, error_message = nil)
-        return unless @test_run_started
-
-        if status == "passed"
-          @passed_count += 1
-        elsif status == "failed"
-          @failed_count += 1
-        end
-
-        # Emit test finish event
-        event_data = {
-          step_name: "test_finish",
-          detail: "Test #{status}: #{test_name}",
-          test_name: test_name,
-          status: status
-        }
-
-        if error_message
-          event_data[:error] = error_message
-        end
-
-        CapyDash::EventEmitter.broadcast(event_data)
-      end
-    end
-  end
-end

data/lib/generators/capydash/install_generator.rb

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