ruby_raider 3.0.1 → 3.1.0

data/spec/llm/response_parser_spec.rb

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

@@ -1,97 +0,0 @@
-# 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/scaffolding/page_introspector_spec.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require_relative '../../lib/scaffolding/page_introspector'
-
-RSpec.describe PageIntrospector do
-  subject(:introspector) { described_class.new(page_file) }
-
-  let(:tmp_dir) { 'tmp_introspector_test' }
-  let(:page_file) { "#{tmp_dir}/login_page.rb" }
-
-  before do
-    FileUtils.mkdir_p(tmp_dir)
-    File.write(page_file, <<~RUBY)
-      class LoginPage < Page
-        def url(_page)
-          '/login'
-        end
-
-        def login(username, password)
-          username_field.send_keys username
-          password_field.send_keys password
-          login_button.click
-        end
-
-        def welcome_message
-          driver.find_element(css: '.welcome').text
-        end
-
-        private
-
-        def username_field
-          driver.find_element(id: 'username')
-        end
-
-        def password_field
-          driver.find_element(id: 'password')
-        end
-
-        def login_button
-          driver.find_element(id: 'login-btn')
-        end
-      end
-    RUBY
-  end
-
-  after do
-    FileUtils.rm_rf(tmp_dir)
-  end
-
-  it 'extracts class name' do
-    expect(introspector.class_name).to eq('LoginPage')
-  end
-
-  it 'extracts public methods' do
-    method_names = introspector.methods.map { |m| m[:name] }
-    expect(method_names).to include('login')
-    expect(method_names).to include('welcome_message')
-  end
-
-  it 'skips url method' do
-    method_names = introspector.methods.map { |m| m[:name] }
-    expect(method_names).not_to include('url')
-  end
-
-  it 'skips private methods' do
-    method_names = introspector.methods.map { |m| m[:name] }
-    expect(method_names).not_to include('username_field')
-    expect(method_names).not_to include('password_field')
-    expect(method_names).not_to include('login_button')
-  end
-
-  it 'extracts method parameters' do
-    login_method = introspector.methods.find { |m| m[:name] == 'login' }
-    expect(login_method[:params]).to eq(%w[username password])
-  end
-
-  it 'handles methods with no parameters' do
-    welcome = introspector.methods.find { |m| m[:name] == 'welcome_message' }
-    expect(welcome[:params]).to eq([])
-  end
-end

data/spec/scaffolding/url_analyzer_spec.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../lib/scaffolding/url_analyzer'
-
-RSpec.describe UrlAnalyzer do
-  subject(:analyzer) { described_class.new('https://example.com/login') }
-
-  let(:sample_html) do
-    <<~HTML
-      <html>
-        <body>
-          <form>
-            <input type="text" id="username" name="username" />
-            <input type="password" id="password" name="password" />
-            <input type="hidden" name="csrf" value="token123" />
-            <select id="role" name="role"><option>Admin</option></select>
-            <textarea id="bio" name="bio"></textarea>
-            <button id="login-btn">Log In</button>
-            <input type="submit" id="submit-btn" value="Submit" />
-            <a href="/forgot">Forgot Password</a>
-          </form>
-        </body>
-      </html>
-    HTML
-  end
-
-  before do
-    stub_request = instance_double(Net::HTTPSuccess, body: sample_html)
-    allow(Net::HTTP).to receive(:get_response).and_return(stub_request)
-  end
-
-  describe '#analyze' do
-    before { analyzer.analyze }
-
-    it 'parses input elements (excluding hidden)' do
-      inputs = analyzer.elements.select { |e| e[:type] == :input }
-      expect(inputs.length).to eq(2)
-      names = inputs.map { |e| e[:name] }
-      expect(names).to include('username', 'password')
-    end
-
-    it 'parses select elements' do
-      selects = analyzer.elements.select { |e| e[:type] == :select }
-      expect(selects.length).to eq(1)
-      expect(selects.first[:name]).to eq('role')
-    end
-
-    it 'parses textarea elements' do
-      textareas = analyzer.elements.select { |e| e[:type] == :textarea }
-      expect(textareas.length).to eq(1)
-    end
-
-    it 'parses button elements' do
-      buttons = analyzer.elements.select { |e| e[:type] == :button }
-      expect(buttons.length).to eq(1)
-      expect(buttons.first[:text]).to eq('Log In')
-    end
-
-    it 'parses submit inputs' do
-      submits = analyzer.elements.select { |e| e[:type] == :submit }
-      expect(submits.length).to eq(1)
-    end
-
-    it 'parses link elements' do
-      links = analyzer.elements.select { |e| e[:type] == :link }
-      expect(links.length).to eq(1)
-      expect(links.first[:name]).to eq('forgot_password')
-    end
-
-    it 'prefers id locators' do
-      username = analyzer.elements.find { |e| e[:name] == 'username' }
-      expect(username[:locator]).to eq(type: :id, value: 'username')
-    end
-  end
-
-  describe '#page_name' do
-    it 'derives name from URL path' do
-      expect(analyzer.page_name).to eq('login')
-    end
-
-    it 'uses name override when provided' do
-      custom = described_class.new('https://example.com/login', name_override: 'auth')
-      expect(custom.page_name).to eq('auth')
-    end
-
-    it 'defaults to home for root URL' do
-      root = described_class.new('https://example.com/')
-      expect(root.page_name).to eq('home')
-    end
-  end
-
-  describe '#to_h' do
-    it 'returns structured hash' do
-      analyzer.analyze
-      result = analyzer.to_h
-      expect(result).to include(:page_name, :url, :url_path, :elements)
-      expect(result[:url_path]).to eq('/login')
-    end
-  end
-
-  describe 'AI mode' do
-    let(:ai_analyzer) { described_class.new('https://example.com/login', ai: true) }
-
-    it 'falls back to regex parsing when LLM is unavailable' do
-      allow_any_instance_of(described_class).to receive(:analyze_with_llm).and_return(nil)
-      ai_analyzer.analyze
-      expect(ai_analyzer.elements).not_to be_empty
-    end
-  end
-end