capydash 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72ac597d4f4b57d15d412dcdfa56e2cba5600a045e62278d44a082c9ca2e6eff
-  data.tar.gz: c0fb3be58f53129bc4f048f6ea591f1250ef0cc03ca6d004322d86848002b953
+  metadata.gz: aa238074c05a59e8c88ec84c887944dc2c376ae379ffde69c3422b939d052d77
+  data.tar.gz: fdfc24fbe669f5a8d0ff44792383b5eae3abcf69d21ed52810228972d0773959
 SHA512:
-  metadata.gz: 634aabfc97331a3d68d452ac8806bb4a6b979549791c18344725bfdf5ed0bfbee41e27b39afb050d56b87dc6bff06e7b8790afcb231a877acd46fa9e487a2ae3
-  data.tar.gz: 9eddf128a30f7317483eeddc385c1170ec7a14701e0f077100d06e72dcdf63aea188b440483fac9c75502408aad64e2b284f103353693c8f7e09972f1bb5b4e0
+  metadata.gz: b49bd9f834a849025f79fc72fc3c317e971fba0ea74504e09d35026a4bdb18b224f48a86ab6041fb43a78de5dd6897ecba9ca43e9f57bfc356385a318313f0e4
+  data.tar.gz: 9c3f988ea6164e454f73d1600ec61ceddfc63f9f6dbb4220c535df60ecf4662f08653fdbcfc9bf6936616382455d8bef473a5f03336d6af8aba72da328c67428

data/README.md

@@ -1,6 +1,6 @@
 # CapyDash
 
-A live dashboard for Capybara tests that provides real-time visualization of test execution with screenshots, step-by-step tracking, comprehensive error reporting, and search capabilities. Perfect for debugging test failures and understanding test behavior.
+A static HTML dashboard for Capybara tests that provides comprehensive test reporting with screenshots, step-by-step tracking, error reporting, and search capabilities. Perfect for debugging test failures and understanding test behavior.
 
 ## Installation
 
@@ -18,24 +18,44 @@ bundle add capydash
 
 ## Usage
 
-1. **Start the dashboard server** in one terminal:
-   ```bash
-   bundle exec rake capydash:server
-   ```
+### Generate Test Report
 
-2. **Start the frontend** in another terminal:
-   ```bash
-   npx vite
-   ```
+After running your Capybara tests, generate a static HTML report:
 
-3. **Open your browser** to `http://localhost:5173` to view the dashboard
+```bash
+bundle exec rake capydash:report
+```
+
+This will create a `capydash_report/index.html` file with:
+- Test steps in chronological order
+- Embedded screenshots for each step
+- Click-to-open/close functionality for screenshots
+- Typeahead search across test names, step text, and pass/fail status
+- Summary statistics
+
+### View Report in Browser
+
+**Option 1: Open directly in browser**
+```bash
+open capydash_report/index.html
+```
+
+**Option 2: Use the built-in server**
+```bash
+bundle exec rake capydash:server
+```
+
+Then open `http://localhost:5173` in your browser.
+
+### Run Tests with CapyDash
 
-4. **Run your tests** with external WebSocket:
-   ```bash
-   CAPYDASH_EXTERNAL_WS=1 bundle exec rails test
-   ```
+Run your tests normally - CapyDash will automatically instrument them:
+
+```bash
+bundle exec rails test
+```
 
-The dashboard will show your tests running in real-time with screenshots, detailed step information, and search functionality to filter tests by name, status, or content.
+The report will be generated in `capydash_report/index.html` after test completion.
 
 ## Development
 

data/lib/capydash/dashboard_server.rb

@@ -87,7 +87,6 @@ module CapyDash
                     command: args.join(' '),
                     client_id: ws.object_id
                   })
-                  puts "[CapyDash] Running command: #{args.join(' ')}"
 
                   Thread.new do
                     begin
@@ -100,21 +99,16 @@ module CapyDash
                         directory: dummy_app_path,
                         exists: Dir.exist?(dummy_app_path)
                       })
-                      puts "[CapyDash] Running tests in: #{dummy_app_path}"
-                      puts "[CapyDash] Directory exists: #{Dir.exist?(dummy_app_path)}"
 
                       Dir.chdir(dummy_app_path) do
                         # Set Rails environment and ensure CapyDash is loaded
                         ENV["RAILS_ENV"] = "test"
                         ENV["CAPYDASH_EXTERNAL_WS"] = "1"  # Use external WebSocket mode
 
-                        puts "[CapyDash] Current directory: #{Dir.pwd}"
-                        puts "[CapyDash] Running: #{args.join(' ')}"
 
                         # Run the command and capture both stdout and stderr
                         IO.popen(args, err: [:child, :out]) do |io|
                           io.each_line do |line|
-                            puts "[CapyDash] Test output: #{line.strip}"
                             event = { type: "runner", line: line.strip, status: "running", ts: Time.now.to_i }
                             broadcast(event.to_json)
                           end
@@ -132,8 +126,6 @@ module CapyDash
                 end
               rescue => e
                 CapyDash::ErrorHandler.handle_websocket_error(e, ws)
-                warn "[CapyDash] ws.onmessage error: #{e.message}"
-                puts "[CapyDash] Backtrace: #{e.backtrace.first(5).join("\n")}"
               end
             end
 

data/lib/capydash/engine.rb

@@ -34,13 +34,11 @@ module CapyDash
             port: port,
             environment: Rails.env
           })
-          puts "[CapyDash] WebSocket server started on ws://localhost:#{port}"
         else
           CapyDash::Logger.info("Skipping in-process WebSocket server", {
             reason: ENV["CAPYDASH_EXTERNAL_WS"] == "1" ? "external_mode" : "production_environment",
             environment: Rails.env
           })
-          puts "[CapyDash] Skipping in-process WebSocket server (external mode)" if ENV["CAPYDASH_EXTERNAL_WS"] == "1"
         end
       rescue => e
         CapyDash::ErrorHandler.handle_error(e, {

data/lib/capydash/forwarder.rb

@@ -34,37 +34,31 @@ module CapyDash
 
     def connect
       url = "ws://127.0.0.1:#{@port}"
-      puts "[CapyDash Forwarder] Attempting to connect to #{url}"
       @ws = Faye::WebSocket::Client.new(url)
 
       @ws.on(:open) do |_event|
         @connected = true
-        puts "[CapyDash Forwarder] Connected to WebSocket server"
         flush_queue
       end
 
       @ws.on(:close) do |_event|
         @connected = false
-        puts "[CapyDash Forwarder] Disconnected from WebSocket server"
         # attempt reconnect after short delay
         EM.add_timer(0.5) { connect }
       end
 
       @ws.on(:error) do |event|
-        puts "[CapyDash Forwarder] WebSocket error: #{event.inspect}"
         # keep trying; errors are expected if server not yet up
       end
     end
 
     def send_message(raw_message)
       message = raw_message.is_a?(String) ? raw_message : JSON.dump(raw_message)
-      puts "[CapyDash Forwarder] Sending message: #{message[0..100]}..."
       @mutex.synchronize do
         if @connected && @ws
           @ws.send(message)
         else
           @queue << message
-          puts "[CapyDash Forwarder] Queued message (not connected)"
         end
       end
     end

data/lib/capydash/instrumentation.rb

@@ -3,8 +3,6 @@ require 'capydash/dashboard_server'
 require 'base64'
 require 'fileutils'
 
-puts "[CapyDash] Instrumentation file loaded"
-
 module CapyDash
   module Instrumentation
     def visit(path)
@@ -22,7 +20,18 @@ module CapyDash
     private
 
     def emit_step(step_name, detail)
-      # take screenshot
+      # emit "running" event first (without screenshot)
+      CapyDash::EventEmitter.broadcast(
+        step_name: step_name,
+        detail: detail,
+        test_name: (defined?(CapyDash) ? CapyDash.current_test : nil),
+        status: "running"
+      )
+
+      # run the original step
+      yield
+
+      # take screenshot AFTER the action is completed
       base_dir = if CapyDash.respond_to?(:configuration)
         CapyDash.configuration&.screenshot_path || "tmp/capydash_screenshots"
       else
@@ -40,16 +49,12 @@ module CapyDash
       if defined?(Capybara)
         begin
           current_driver = Capybara.current_driver
-          puts "[CapyDash] Current Capybara driver: #{current_driver}"
-          if current_driver == :rack_test
-            puts "[CapyDash] Skipping screenshot (rack_test driver)"
-          else
+          if current_driver != :rack_test
             if respond_to?(:page)
               page.save_screenshot(screenshot_path)
             else
               Capybara.current_session.save_screenshot(screenshot_path)
             end
-            puts "[CapyDash] Saved screenshot: #{screenshot_path}"
 
             # Try to find the actual screenshot file location
             actual_screenshot_path = nil
@@ -66,43 +71,74 @@ module CapyDash
             if actual_screenshot_path && File.exist?(actual_screenshot_path)
               encoded = Base64.strict_encode64(File.binread(actual_screenshot_path))
               data_url = "data:image/png;base64,#{encoded}"
-              puts "[CapyDash] Generated data URL for screenshot from: #{actual_screenshot_path}"
-            else
-              puts "[CapyDash] Screenshot file not found. Tried: #{absolute_screenshot_path} and #{capybara_path rescue 'N/A'}"
             end
           end
         rescue => e
-          warn "[CapyDash] Screenshot capture failed: #{e.message}"
+          # Silently handle screenshot capture failures
         end
       end
 
-      # emit event
-      CapyDash::EventEmitter.broadcast(
-        step_name: step_name,
-        detail: detail,
-        screenshot: screenshot_path,
-        data_url: data_url,
-        test_name: (defined?(CapyDash) ? CapyDash.current_test : nil),
-        status: "running"
-      )
-
-      # run the original step
-      yield
-
-      # mark success
+      # mark success with screenshot
       CapyDash::EventEmitter.broadcast(
         step_name: step_name,
         detail: detail,
-        screenshot: screenshot_path,
+        screenshot: actual_screenshot_path || screenshot_path,
         data_url: data_url,
         test_name: (defined?(CapyDash) ? CapyDash.current_test : nil),
         status: "passed"
       )
     rescue => e
+      # take screenshot even on failure (after the action was attempted)
+      base_dir = if CapyDash.respond_to?(:configuration)
+        CapyDash.configuration&.screenshot_path || "tmp/capydash_screenshots"
+      else
+        "tmp/capydash_screenshots"
+      end
+      FileUtils.mkdir_p(base_dir) unless Dir.exist?(base_dir)
+      timestamp = Time.now.strftime('%Y%m%d-%H%M%S-%L')
+      safe_step = step_name.gsub(/\s+/, '_')
+      screenshot_path = File.join(base_dir, "#{safe_step}-#{timestamp}.png")
+
+      # Ensure we have an absolute path for Base64 encoding
+      absolute_screenshot_path = File.absolute_path(screenshot_path)
+
+      data_url = nil
+      if defined?(Capybara)
+        begin
+          current_driver = Capybara.current_driver
+          if current_driver != :rack_test
+            if respond_to?(:page)
+              page.save_screenshot(screenshot_path)
+            else
+              Capybara.current_session.save_screenshot(screenshot_path)
+            end
+
+            # Try to find the actual screenshot file location
+            actual_screenshot_path = nil
+            if File.exist?(absolute_screenshot_path)
+              actual_screenshot_path = absolute_screenshot_path
+            else
+              # Check if it was saved in the capybara tmp directory
+              capybara_path = File.join(Dir.pwd, "tmp", "capybara", screenshot_path)
+              if File.exist?(capybara_path)
+                actual_screenshot_path = capybara_path
+              end
+            end
+
+            if actual_screenshot_path && File.exist?(actual_screenshot_path)
+              encoded = Base64.strict_encode64(File.binread(actual_screenshot_path))
+              data_url = "data:image/png;base64,#{encoded}"
+            end
+          end
+        rescue => e
+          # Silently handle screenshot capture failures
+        end
+      end
+
       CapyDash::EventEmitter.broadcast(
         step_name: step_name,
         detail: detail,
-        screenshot: screenshot_path,
+        screenshot: actual_screenshot_path || screenshot_path,
         data_url: data_url,
         test_name: (defined?(CapyDash) ? CapyDash.current_test : nil),
         status: "failed",
@@ -115,4 +151,3 @@ end
 
 # Prepend into Capybara DSL so it wraps all calls
 Capybara::Session.prepend(CapyDash::Instrumentation)
-puts "[CapyDash] Instrumentation prepended into Capybara::Session"

data/lib/capydash/persistence.rb

@@ -10,11 +10,6 @@ module CapyDash
 
         begin
           File.write(file_path, JSON.pretty_generate(test_run_data))
-          Logger.info("Test run saved", {
-            run_id: test_run_data[:id],
-            file_path: file_path,
-            test_count: test_run_data[:tests]&.length || 0
-          })
           file_path
         rescue => e
           ErrorHandler.handle_error(e, {