ruby_raider 1.1.4 → 3.0.0

data/spec/integration/spec_helper.rb

@@ -5,35 +5,70 @@ require 'rspec'
 require_relative '../../lib/generators/invoke_generators'
 require_relative 'settings_helper'
 
-AUTOMATION_TYPES = %w[android ios selenium watir cross_platform axe applitools].freeze
-FRAMEWORKS = %w[cucumber rspec].freeze
+AUTOMATION_TYPES = %w[android ios selenium watir cross_platform capybara].freeze
+FRAMEWORKS = %w[cucumber rspec minitest].freeze
 CI_PLATFORMS = [nil, 'github', 'gitlab'].freeze
 
+# Named constants for readable spec references — no more fragile numeric indices
+module FrameworkIndex
+  CUCUMBER  = FRAMEWORKS[0]
+  RSPEC     = FRAMEWORKS[1]
+  MINITEST  = FRAMEWORKS[2]
+end
+
+module AutomationIndex
+  ANDROID        = AUTOMATION_TYPES[0]
+  IOS            = AUTOMATION_TYPES[1]
+  SELENIUM       = AUTOMATION_TYPES[2]
+  WATIR          = AUTOMATION_TYPES[3]
+  CROSS_PLATFORM = AUTOMATION_TYPES[4]
+  CAPYBARA       = AUTOMATION_TYPES[5]
+end
+
+# Lazy project generation — only generates a project the first time it's needed.
+# Replaces the old before(:all) that generated all 54 combinations upfront.
+module LazyProjectGenerator
+  GENERATED = Set.new
+  MUTEX = Mutex.new
+
+  def ensure_project(framework:, automation:, ci_platform: nil)
+    settings = create_settings(framework:, automation:, ci_platform:)
+    project_name = settings[:name]
+
+    MUTEX.synchronize do
+      unless GENERATED.include?(project_name)
+        generate_framework(settings)
+        GENERATED.add(project_name)
+      end
+    end
+
+    project_name
+  end
+end
+
 RSpec.configure do |config|
   config.include(InvokeGenerators)
   config.include(SettingsHelper)
+  config.include(LazyProjectGenerator)
 
   # rubocop:disable RSpec/BeforeAfterAll
   config.before(:all) do
+    # Generate all projects upfront (preserves existing behavior).
+    # Individual specs can also call ensure_project() for on-demand generation.
     FRAMEWORKS.each do |framework|
       AUTOMATION_TYPES.each do |automation|
         CI_PLATFORMS.each do |ci_platform|
-          settings = create_settings(framework:, automation:, ci_platform:)
-          generate_framework(settings)
+          ensure_project(framework:, automation:, ci_platform:)
         end
       end
     end
   end
 
   config.after(:all) do
-    FRAMEWORKS.each do |framework|
-      AUTOMATION_TYPES.each do |automation|
-        CI_PLATFORMS.each do |ci_platform|
-          settings = create_settings(framework:, automation:, ci_platform:)
-          FileUtils.rm_rf(settings[:name])
-        end
-      end
+    LazyProjectGenerator::GENERATED.each do |project_name|
+      FileUtils.rm_rf(project_name)
     end
+    LazyProjectGenerator::GENERATED.clear
   end
   # rubocop:enable RSpec/BeforeAfterAll
 end

data/spec/llm/client_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/llm/client'
+require_relative '../../lib/llm/provider'
+
+RSpec.describe Llm::Client do
+  let(:mock_provider) { instance_double(Llm::Provider, available?: true) }
+  let(:mock_config) { instance_double(Llm::Config, configured?: true, provider_name: 'ollama', model: 'llama3.2') }
+
+  before do
+    allow(Llm::Config).to receive(:new).and_return(mock_config)
+    allow(mock_config).to receive(:build_provider).and_return(mock_provider)
+  end
+
+  describe '.complete' do
+    it 'delegates to the provider' do
+      allow(mock_provider).to receive(:complete).and_return('AI response')
+      result = described_class.complete('test prompt')
+      expect(result).to eq('AI response')
+    end
+
+    it 'returns nil when not configured' do
+      allow(mock_config).to receive(:configured?).and_return(false)
+      expect(described_class.complete('test prompt')).to be_nil
+    end
+
+    it 'returns nil when provider is not available' do
+      allow(mock_provider).to receive(:available?).and_return(false)
+      expect(described_class.complete('test prompt')).to be_nil
+    end
+
+    it 'retries on failure and returns nil after max retries' do
+      allow(mock_provider).to receive(:complete).and_raise(StandardError, 'network error')
+      allow(described_class).to receive(:sleep) # skip actual sleep
+      expect(described_class.complete('test prompt')).to be_nil
+    end
+
+    it 'passes system_prompt to provider' do
+      allow(mock_provider).to receive(:complete).and_return('ok')
+      result = described_class.complete('prompt', system_prompt: 'system')
+      expect(result).to eq('ok')
+      expect(mock_provider).to have_received(:complete).with('prompt', system_prompt: 'system')
+    end
+  end
+
+  describe '.available?' do
+    it 'returns true when provider is configured and available' do
+      expect(described_class).to be_available
+    end
+
+    it 'returns false when not configured' do
+      allow(mock_config).to receive(:configured?).and_return(false)
+      expect(described_class).not_to be_available
+    end
+
+    it 'returns false when provider is not available' do
+      allow(mock_provider).to receive(:available?).and_return(false)
+      expect(described_class).not_to be_available
+    end
+  end
+
+  describe '.status' do
+    it 'returns configured status with details' do
+      allow(mock_provider).to receive(:available?).and_return(true)
+      status = described_class.status
+      expect(status[:configured]).to be true
+      expect(status[:provider]).to eq('ollama')
+      expect(status[:model]).to eq('llama3.2')
+      expect(status[:available]).to be true
+    end
+
+    it 'returns unconfigured status' do
+      allow(mock_config).to receive(:configured?).and_return(false)
+      status = described_class.status
+      expect(status[:configured]).to be false
+      expect(status[:provider]).to be_nil
+    end
+  end
+end

data/spec/llm/config_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/llm/config'
+
+RSpec.describe Llm::Config do
+  before do
+    allow(ENV).to receive(:fetch).and_call_original
+    %w[RUBY_RAIDER_LLM_PROVIDER RUBY_RAIDER_LLM_API_KEY RUBY_RAIDER_LLM_MODEL RUBY_RAIDER_LLM_URL].each do |key|
+      allow(ENV).to receive(:fetch).with(key, nil).and_return(nil)
+    end
+    allow(File).to receive(:exist?).with('config/config.yml').and_return(false)
+  end
+
+  describe '#configured?' do
+    it 'returns false when no provider is set' do
+      expect(described_class.new).not_to be_configured
+    end
+
+    it 'returns false for unknown provider' do
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_PROVIDER', nil).and_return('unknown')
+      expect(described_class.new).not_to be_configured
+    end
+
+    it 'returns true for ollama without api key' do
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_PROVIDER', nil).and_return('ollama')
+      expect(described_class.new).to be_configured
+    end
+
+    it 'returns false for openai without api key' do
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_PROVIDER', nil).and_return('openai')
+      expect(described_class.new).not_to be_configured
+    end
+
+    it 'returns true for openai with api key' do
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_PROVIDER', nil).and_return('openai')
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_API_KEY', nil).and_return('sk-test')
+      expect(described_class.new).to be_configured
+    end
+
+    it 'returns true for anthropic with api key' do
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_PROVIDER', nil).and_return('anthropic')
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_API_KEY', nil).and_return('sk-ant-test')
+      expect(described_class.new).to be_configured
+    end
+  end
+
+  describe '#build_provider' do
+    it 'returns nil when not configured' do
+      expect(described_class.new.build_provider).to be_nil
+    end
+
+    it 'builds OpenaiProvider for openai' do
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_PROVIDER', nil).and_return('openai')
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_API_KEY', nil).and_return('sk-test')
+      provider = described_class.new.build_provider
+      expect(provider).to be_a(Llm::Providers::OpenaiProvider)
+    end
+
+    it 'builds AnthropicProvider for anthropic' do
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_PROVIDER', nil).and_return('anthropic')
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_API_KEY', nil).and_return('sk-ant-test')
+      provider = described_class.new.build_provider
+      expect(provider).to be_a(Llm::Providers::AnthropicProvider)
+    end
+
+    it 'builds OllamaProvider for ollama' do
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_PROVIDER', nil).and_return('ollama')
+      provider = described_class.new.build_provider
+      expect(provider).to be_a(Llm::Providers::OllamaProvider)
+    end
+  end
+
+  describe 'config file fallback' do
+    it 'reads from config/config.yml when env vars are not set' do
+      allow(File).to receive(:exist?).with('config/config.yml').and_return(true)
+      allow(YAML).to receive(:load_file).with('config/config.yml').and_return(
+        'llm_provider' => 'ollama',
+        'llm_model' => 'codellama'
+      )
+      config = described_class.new
+      expect(config.provider_name).to eq('ollama')
+      expect(config.model).to eq('codellama')
+    end
+
+    it 'env vars take precedence over config file' do
+      allow(ENV).to receive(:fetch).with('RUBY_RAIDER_LLM_PROVIDER', nil).and_return('anthropic')
+      allow(File).to receive(:exist?).with('config/config.yml').and_return(true)
+      allow(YAML).to receive(:load_file).with('config/config.yml').and_return('llm_provider' => 'ollama')
+      expect(described_class.new.provider_name).to eq('anthropic')
+    end
+  end
+end

data/spec/llm/prompts_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/llm/prompts'
+
+RSpec.describe Llm::Prompts do
+  describe '.analyze_page' do
+    it 'includes URL and HTML in prompt' do
+      prompt = described_class.analyze_page('<html>test</html>', 'https://example.com')
+      expect(prompt).to include('https://example.com')
+      expect(prompt).to include('<html>test</html>')
+    end
+
+    it 'truncates HTML at 8000 characters' do
+      long_html = 'x' * 10_000
+      prompt = described_class.analyze_page(long_html, 'https://example.com')
+      expect(prompt.length).to be < 10_000
+    end
+
+    it 'requests JSON output' do
+      prompt = described_class.analyze_page('<html></html>', 'https://example.com')
+      expect(prompt).to include('JSON')
+      expect(prompt).to include('elements')
+    end
+  end
+
+  describe '.generate_test_scenarios' do
+    let(:methods) { [{ name: 'login', params: %w[user pass] }, { name: 'logout', params: [] }] }
+
+    it 'includes class and method info' do
+      prompt = described_class.generate_test_scenarios('LoginPage', methods, 'selenium', 'rspec')
+      expect(prompt).to include('LoginPage')
+      expect(prompt).to include('login(user, pass)')
+      expect(prompt).to include('logout')
+    end
+
+    it 'includes automation and framework context' do
+      prompt = described_class.generate_test_scenarios('LoginPage', methods, 'selenium', 'rspec')
+      expect(prompt).to include('selenium')
+      expect(prompt).to include('rspec')
+    end
+  end
+
+  describe '.system_prompt' do
+    it 'returns a non-empty string' do
+      expect(described_class.system_prompt).to be_a(String)
+      expect(described_class.system_prompt).not_to be_empty
+    end
+  end
+end

data/spec/llm/response_parser_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/llm/response_parser'
+
+RSpec.describe Llm::ResponseParser do
+  describe '.parse_json' do
+    it 'parses raw JSON' do
+      result = described_class.parse_json('{"key": "value"}')
+      expect(result).to eq(key: 'value')
+    end
+
+    it 'parses JSON from markdown code block' do
+      response = "```json\n{\"key\": \"value\"}\n```"
+      result = described_class.parse_json(response)
+      expect(result).to eq(key: 'value')
+    end
+
+    it 'extracts JSON from surrounding text' do
+      response = "Here is the result:\n{\"key\": \"value\"}\nDone."
+      result = described_class.parse_json(response)
+      expect(result).to eq(key: 'value')
+    end
+
+    it 'returns nil for nil input' do
+      expect(described_class.parse_json(nil)).to be_nil
+    end
+
+    it 'returns nil for empty input' do
+      expect(described_class.parse_json('')).to be_nil
+    end
+
+    it 'returns nil for invalid JSON' do
+      expect(described_class.parse_json('not json at all')).to be_nil
+    end
+
+    it 'returns nil for JSON arrays (not hashes)' do
+      expect(described_class.parse_json('[1, 2, 3]')).to be_nil
+    end
+  end
+
+  describe '.extract_elements' do
+    let(:valid_response) do
+      {
+        elements: [
+          { name: 'email_field', type: 'input', locator: { type: 'id', value: 'email' }, purpose: 'Email input' },
+          { name: 'submit_btn', type: 'button', locator: { type: 'id', value: 'submit' }, text: 'Submit' }
+        ]
+      }.to_json
+    end
+
+    it 'extracts and normalizes elements' do
+      elements = described_class.extract_elements(valid_response)
+      expect(elements.length).to eq(2)
+      expect(elements.first[:name]).to eq('email_field')
+      expect(elements.first[:locator][:type]).to eq(:id)
+    end
+
+    it 'skips elements without required fields' do
+      response = { elements: [{ name: 'incomplete' }] }.to_json
+      elements = described_class.extract_elements(response)
+      expect(elements).to be_empty
+    end
+
+    it 'returns nil for non-element response' do
+      expect(described_class.extract_elements('{"other": "data"}')).to be_nil
+    end
+
+    it 'returns nil for nil response' do
+      expect(described_class.extract_elements(nil)).to be_nil
+    end
+  end
+
+  describe '.extract_scenarios' do
+    let(:valid_response) do
+      {
+        scenarios: [
+          { method: 'login', description: 'logs in with valid credentials', assertion_hint: 'expect redirect' }
+        ]
+      }.to_json
+    end
+
+    it 'extracts scenarios' do
+      scenarios = described_class.extract_scenarios(valid_response)
+      expect(scenarios.length).to eq(1)
+      expect(scenarios.first[:method]).to eq('login')
+    end
+
+    it 'returns nil for non-scenario response' do
+      expect(described_class.extract_scenarios('{"other": "data"}')).to be_nil
+    end
+  end
+end

data/spec/menus/adopter_adopt_menu_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'rspec'
+require_relative '../../lib/adopter/adopt_menu'
+
+RSpec.describe Adopter::AdoptMenu do # rubocop:disable RSpec/FilePath
+  let(:prompt) { instance_double(TTY::Prompt) }
+  let(:source_dir) { 'tmp_adopt_interactive_source' }
+  let(:output_dir) { 'tmp_adopt_interactive_output' }
+
+  before do
+    allow(TTY::Prompt).to receive(:new).and_return(prompt)
+    allow(prompt).to receive(:say)
+    allow(prompt).to receive(:warn)
+    allow(prompt).to receive(:error)
+
+    FileUtils.mkdir_p(source_dir)
+    File.write("#{source_dir}/Gemfile", "gem 'rspec'\ngem 'selenium-webdriver'\n")
+    FileUtils.mkdir_p("#{source_dir}/spec")
+    File.write("#{source_dir}/spec/login_spec.rb", "describe 'Login' do\n  it('works') { expect(true).to be true }\nend\n")
+  end
+
+  after do
+    FileUtils.rm_rf(source_dir)
+    FileUtils.rm_rf(output_dir)
+  end
+
+  describe '#run' do
+    before do
+      allow(prompt).to receive(:ask).and_return(source_dir, output_dir)
+      allow(prompt).to receive(:select)
+        .with('Select target automation framework:', anything, anything).and_return('Selenium')
+      allow(prompt).to receive(:select)
+        .with('Select target test framework:', anything, anything).and_return('Rspec')
+      allow(prompt).to receive(:select)
+        .with('Configure CI/CD?', anything, anything).and_return(nil)
+    end
+
+    it 'shows detection preview' do
+      described_class.new.run
+
+      expect(prompt).to have_received(:say).with(match(/Detected project settings/))
+      expect(prompt).to have_received(:say).with(match(/Automation: selenium/))
+      expect(prompt).to have_received(:say).with(match(/Framework:.*rspec/))
+    end
+
+    it 'executes adoption and shows results' do
+      described_class.new.run
+
+      expect(prompt).to have_received(:say).with(match(/Adoption complete/))
+      expect(prompt).to have_received(:say).with(match(/Pages converted/))
+      expect(prompt).to have_received(:say).with(match(/Tests converted/))
+    end
+
+    it 'generates the output project' do
+      described_class.new.run
+
+      expect(File).to exist("#{output_dir}/Gemfile")
+    end
+
+    it 'shows output path and bundle install instruction' do
+      described_class.new.run
+
+      expect(prompt).to have_received(:say).with(match(/Output: #{output_dir}/))
+      expect(prompt).to have_received(:say).with(match(/bundle install/))
+    end
+  end
+
+  describe '#run with mobile source project' do
+    before do
+      File.write("#{source_dir}/Gemfile", "gem 'rspec'\ngem 'appium_lib'\n")
+      allow(prompt).to receive(:ask).and_return(source_dir, output_dir)
+      allow(prompt).to receive(:select).and_return('Selenium', 'Rspec', nil)
+    end
+
+    it 'shows MobileProjectError message' do
+      described_class.new.run
+
+      expect(prompt).to have_received(:error).with(match(/Mobile.*Appium.*cannot be adopted/))
+    end
+  end
+
+  describe 'validation constants' do
+    it 'defines web automations' do
+      expect(described_class::WEB_AUTOMATIONS).to contain_exactly('selenium', 'capybara', 'watir')
+    end
+
+    it 'defines test frameworks' do
+      expect(described_class::TEST_FRAMEWORKS).to contain_exactly('rspec', 'cucumber', 'minitest')
+    end
+
+    it 'defines CI platforms' do
+      expect(described_class::CI_PLATFORMS).to contain_exactly('github', 'gitlab')
+    end
+  end
+end