ruby_raider 2.0.0 → 3.0.0

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

data/spec/menus/menu_generator_spec.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../lib/generators/menu_generator'
+
+RSpec.describe MenuGenerator do
+  let(:prompt) { instance_double(TTY::Prompt) }
+  let(:menu_generator) { described_class.new('test_project') }
+
+  before do
+    allow(TTY::Prompt).to receive(:new).and_return(prompt)
+  end
+
+  describe '#generate_choice_menu' do
+    it 'presents automation framework selection' do
+      menu = double('menu') # rubocop:disable RSpec/VerifiedDoubles
+      allow(menu).to receive(:choice)
+      allow(prompt).to receive(:select).with('Please select your automation framework').and_yield(menu)
+
+      menu_generator.generate_choice_menu
+
+      expect(menu).to have_received(:choice).with(:Selenium, anything)
+      expect(menu).to have_received(:choice).with(:Capybara, anything)
+      expect(menu).to have_received(:choice).with(:Appium, anything)
+      expect(menu).to have_received(:choice).with(:Watir, anything)
+      expect(menu).to have_received(:choice).with(:Quit, anything)
+    end
+  end
+
+  describe '#choose_test_framework' do
+    context 'with a web automation' do
+      it 'presents test framework selection' do
+        menu = double('menu') # rubocop:disable RSpec/VerifiedDoubles
+        allow(menu).to receive(:choice)
+        allow(prompt).to receive(:select).with('Please select your test framework').and_yield(menu)
+
+        menu_generator.choose_test_framework('selenium')
+
+        expect(menu).to have_received(:choice).with(:Cucumber, anything)
+        expect(menu).to have_received(:choice).with(:Rspec, anything)
+        expect(menu).to have_received(:choice).with(:Minitest, anything)
+        expect(menu).to have_received(:choice).with(:Quit, anything)
+      end
+    end
+
+    context 'with appium' do
+      it 'presents mobile platform selection' do
+        menu = double('menu') # rubocop:disable RSpec/VerifiedDoubles
+        allow(menu).to receive(:choice)
+        allow(prompt).to receive(:select).with('Please select your mobile platform').and_yield(menu)
+
+        menu_generator.choose_test_framework('appium')
+
+        expect(menu).to have_received(:choice).with(:iOS, anything)
+        expect(menu).to have_received(:choice).with(:Android, anything)
+        expect(menu).to have_received(:choice).with(:Cross_Platform, anything)
+        expect(menu).to have_received(:choice).with(:Quit, anything)
+      end
+    end
+  end
+
+  describe '#set_up_framework' do
+    let(:options) do
+      { automation: 'selenium', framework: 'rspec', ci_platform: 'github', accessibility: true }
+    end
+
+    before do
+      allow(prompt).to receive(:yes?).and_return(false)
+    end
+
+    it 'calls generate_framework with correct structure' do
+      allow(menu_generator).to receive(:generate_framework)
+      allow(menu_generator).to receive(:system)
+
+      menu_generator.set_up_framework(options)
+
+      expect(menu_generator).to have_received(:generate_framework).with(
+        hash_including(
+          automation: 'selenium',
+          framework: 'rspec',
+          ci_platform: 'github',
+          accessibility: true,
+          name: 'test_project'
+        )
+      )
+    end
+
+    it 'runs bundle install in the generated project' do
+      allow(menu_generator).to receive(:generate_framework)
+      allow(menu_generator).to receive(:system)
+
+      menu_generator.set_up_framework(options)
+
+      expect(menu_generator).to have_received(:system).with('cd test_project && gem install bundler && bundle install')
+    end
+  end
+
+  describe 'full flow: selenium + rspec + no CI' do
+    it 'calls set_up_framework with correct options' do
+      allow(menu_generator).to receive(:generate_framework)
+      allow(menu_generator).to receive(:system)
+      allow(prompt).to receive(:say)
+      allow(prompt).to receive(:yes?).and_return(false)
+
+      menu_generator.send(:create_framework, 'Rspec', 'selenium')
+
+      expect(menu_generator).to have_received(:generate_framework).with(
+        hash_including(automation: 'selenium', framework: 'rspec', name: 'test_project')
+      )
+    end
+  end
+
+  describe 'full flow: capybara + minitest + github' do
+    it 'calls set_up_framework with correct options' do
+      allow(menu_generator).to receive(:generate_framework)
+      allow(menu_generator).to receive(:system)
+      allow(prompt).to receive(:say)
+      allow(prompt).to receive(:yes?).and_return(false)
+
+      menu_generator.send(:create_framework, 'Minitest', 'capybara', ci_platform: 'github')
+
+      expect(menu_generator).to have_received(:generate_framework).with(
+        hash_including(
+          automation: 'capybara',
+          framework: 'minitest',
+          ci_platform: 'github',
+          accessibility: false,
+          name: 'test_project'
+        )
+      )
+    end
+  end
+
+  describe 'full flow: watir + cucumber + gitlab' do
+    it 'calls set_up_framework with correct options' do
+      allow(menu_generator).to receive(:generate_framework)
+      allow(menu_generator).to receive(:system)
+      allow(prompt).to receive(:say)
+      allow(prompt).to receive(:yes?).and_return(false)
+
+      menu_generator.send(:create_framework, 'Cucumber', 'watir', ci_platform: 'gitlab')
+
+      expect(menu_generator).to have_received(:generate_framework).with(
+        hash_including(
+          automation: 'watir',
+          framework: 'cucumber',
+          ci_platform: 'gitlab',
+          accessibility: false,
+          name: 'test_project'
+        )
+      )
+    end
+  end
+
+  describe 'full flow: selenium + rspec + accessibility' do
+    it 'passes accessibility flag through' do
+      allow(menu_generator).to receive(:generate_framework)
+      allow(menu_generator).to receive(:system)
+      allow(prompt).to receive(:say)
+      allow(prompt).to receive(:yes?).and_return(false)
+
+      menu_generator.send(:create_framework, 'Rspec', 'selenium', accessibility: true)
+
+      expect(menu_generator).to have_received(:generate_framework).with(
+        hash_including(automation: 'selenium', framework: 'rspec', accessibility: true)
+      )
+    end
+  end
+
+  describe 'full flow: selenium + rspec + visual' do
+    it 'passes visual flag through' do
+      allow(menu_generator).to receive(:generate_framework)
+      allow(menu_generator).to receive(:system)
+      allow(prompt).to receive(:say)
+      allow(prompt).to receive(:yes?).and_return(false)
+
+      menu_generator.send(:create_framework, 'Rspec', 'selenium', visual: true)
+
+      expect(menu_generator).to have_received(:generate_framework).with(
+        hash_including(automation: 'selenium', framework: 'rspec', visual: true)
+      )
+    end
+  end
+
+  describe 'full flow: selenium + rspec + performance' do
+    it 'passes performance flag through' do
+      allow(menu_generator).to receive(:generate_framework)
+      allow(menu_generator).to receive(:system)
+      allow(prompt).to receive(:say)
+      allow(prompt).to receive(:yes?).and_return(false)
+
+      menu_generator.send(:create_framework, 'Rspec', 'selenium', performance: true)
+
+      expect(menu_generator).to have_received(:generate_framework).with(
+        hash_including(automation: 'selenium', framework: 'rspec', performance: true)
+      )
+    end
+  end
+
+  describe 'ruby version selection menu' do
+    it 'presents ruby version choices' do # rubocop:disable RSpec/MultipleExpectations
+      menu = double('menu') # rubocop:disable RSpec/VerifiedDoubles
+      allow(menu).to receive(:choice)
+      allow(prompt).to receive(:select).with('Select Ruby version for your project').and_yield(menu)
+
+      menu_generator.send(:select_ruby_version, 'Rspec', 'selenium')
+
+      expect(menu).to have_received(:choice).with(:'3.4 (latest)', anything)
+      expect(menu).to have_received(:choice).with(:'3.3', anything)
+      expect(menu).to have_received(:choice).with(:'3.2', anything)
+      expect(menu).to have_received(:choice).with(:'3.1', anything)
+      expect(menu).to have_received(:choice).with(:Quit, anything)
+    end
+  end
+
+  describe 'ruby_version propagation' do
+    it 'passes ruby_version through to generate_framework' do
+      allow(menu_generator).to receive(:generate_framework)
+      allow(menu_generator).to receive(:system)
+      allow(prompt).to receive(:say)
+      allow(prompt).to receive(:yes?).and_return(false)
+
+      menu_generator.send(:create_framework, 'Rspec', 'selenium', ruby_version: '3.3')
+
+      expect(menu_generator).to have_received(:generate_framework).with(
+        hash_including(ruby_version: '3.3')
+      )
+    end
+  end
+
+  describe 'reporter selection menu' do
+    it 'includes JSON and All reporter choices' do # rubocop:disable RSpec/MultipleExpectations
+      menu = double('menu') # rubocop:disable RSpec/VerifiedDoubles
+      allow(menu).to receive(:choice)
+      allow(prompt).to receive(:select).with('Select your test reporter').and_yield(menu)
+
+      menu_generator.send(:select_reporter, 'Rspec', 'selenium')
+
+      expect(menu).to have_received(:choice).with(:JSON, anything)
+      expect(menu).to have_received(:choice).with(:All, anything)
+      expect(menu).to have_received(:choice).with(:Allure, anything)
+      expect(menu).to have_received(:choice).with(:JUnit, anything)
+      expect(menu).to have_received(:choice).with(:Both, anything)
+      expect(menu).to have_received(:choice).with(:None, anything)
+    end
+  end
+
+  describe 'project name propagation' do
+    it 'uses the project name from initialization' do
+      generator = described_class.new('my_custom_project')
+      allow(generator).to receive(:generate_framework)
+      allow(generator).to receive(:system)
+      allow(prompt).to receive(:say)
+      allow(prompt).to receive(:yes?).and_return(false)
+
+      generator.send(:create_framework, 'Rspec', 'selenium')
+
+      expect(generator).to have_received(:generate_framework).with(
+        hash_including(name: 'my_custom_project')
+      )
+    end
+  end
+end