capydash 0.1.7 → 0.2.1

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

data/lib/tasks/capydash.rake

@@ -1,67 +0,0 @@
-namespace :capydash do
-  desc "Start local server to view static HTML report"
-  task server: :environment do
-    require 'webrick'
-    require 'capydash/report_generator'
-
-    report_dir = File.join(Dir.pwd, "capydash_report")
-
-    unless Dir.exist?(report_dir)
-      puts "No report directory found. Run 'bundle exec rake capydash:report' first."
-      exit 1
-    end
-
-    # Try different ports if 5173 is busy
-    port = 5173
-    begin
-      server = WEBrick::HTTPServer.new(
-        Port: port,
-        DocumentRoot: report_dir,
-        Logger: WEBrick::Log.new(nil, WEBrick::Log::ERROR),
-        AccessLog: [],
-        BindAddress: '127.0.0.1'
-      )
-    rescue Errno::EADDRINUSE
-      port = 8080
-      puts "Port 5173 is busy, trying port #{port}..."
-      server = WEBrick::HTTPServer.new(
-        Port: port,
-        DocumentRoot: report_dir,
-        Logger: WEBrick::Log.new(nil, WEBrick::Log::ERROR),
-        AccessLog: [],
-        BindAddress: '127.0.0.1'
-      )
-    end
-
-    puts "Starting static file server on http://localhost:#{port}"
-    puts "Report available at: http://localhost:#{port}/index.html"
-    puts "Press Ctrl+C to stop the server"
-
-    trap("INT") {
-      puts "\nShutting down server..."
-      server.shutdown
-    }
-
-    begin
-      server.start
-    rescue => e
-      puts "Error starting server: #{e.message}"
-      exit 1
-    end
-  end
-
-  desc "Generate static HTML test report"
-  task report: :environment do
-    require 'capydash/report_generator'
-
-    report_path = CapyDash::ReportGenerator.generate_report
-
-    if report_path
-      puts "Report generated: file://#{File.absolute_path(report_path)}"
-    else
-      puts "No test data found. Run some tests first to generate a report."
-      exit 1
-    end
-  end
-
-end