ruby_raider 3.0.1 → 3.1.0

data/spec/adopter/migration_plan_spec.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'rspec'
-require_relative '../../lib/adopter/migration_plan'
-
-RSpec.describe Adopter::MigrationPlan do
-  let(:converted_page) do
-    Adopter::ConvertedFile.new(
-      output_path: 'my_project/page_objects/pages/login.rb',
-      content: 'class Login < Page; end',
-      source_file: 'pages/login_page.rb',
-      conversion_notes: 'Converted from capybara to selenium'
-    )
-  end
-
-  let(:plan) do
-    described_class.new(
-      source_path: '/source',
-      output_path: '/output',
-      target_automation: 'selenium',
-      target_framework: 'rspec',
-      ci_platform: 'github',
-      skeleton_structure: { automation: 'selenium', framework: 'rspec', name: '/output' },
-      converted_pages: [converted_page],
-      converted_tests: [],
-      gemfile_additions: %w[faker httparty],
-      config_overrides: { browser: 'chrome', url: 'https://example.com' },
-      warnings: ['Complex matcher needs review'],
-      manual_actions: []
-    )
-  end
-
-  describe '#to_h' do
-    it 'serializes all fields' do # rubocop:disable RSpec/MultipleExpectations
-      hash = plan.to_h
-      expect(hash[:source_path]).to eq('/source')
-      expect(hash[:output_path]).to eq('/output')
-      expect(hash[:target_automation]).to eq('selenium')
-      expect(hash[:target_framework]).to eq('rspec')
-      expect(hash[:converted_pages].length).to eq(1)
-      expect(hash[:gemfile_additions]).to eq(%w[faker httparty])
-      expect(hash[:config_overrides]).to eq(browser: 'chrome', url: 'https://example.com')
-    end
-
-    it 'serializes converted files as hashes' do
-      page_hash = plan.to_h[:converted_pages].first
-      expect(page_hash[:output_path]).to eq('my_project/page_objects/pages/login.rb')
-      expect(page_hash[:source_file]).to eq('pages/login_page.rb')
-    end
-  end
-
-  describe '#to_json' do
-    it 'produces valid JSON' do
-      parsed = JSON.parse(plan.to_json)
-      expect(parsed['source_path']).to eq('/source')
-      expect(parsed['converted_pages'].length).to eq(1)
-    end
-  end
-
-  describe '#summary' do
-    it 'returns counts' do
-      expect(plan.summary).to eq(
-        pages: 1,
-        tests: 0,
-        features: 0,
-        steps: 0,
-        custom_gems: 2,
-        warnings: 1,
-        manual_actions: 0
-      )
-    end
-  end
-
-  describe 'defaults' do
-    it 'initializes with empty arrays and hashes' do
-      empty_plan = described_class.new
-      expect(empty_plan.converted_pages).to eq([])
-      expect(empty_plan.converted_tests).to eq([])
-      expect(empty_plan.gemfile_additions).to eq([])
-      expect(empty_plan.config_overrides).to eq({})
-      expect(empty_plan.warnings).to eq([])
-    end
-  end
-end
-
-RSpec.describe Adopter::ConvertedFile do
-  it 'stores file conversion data' do
-    file = described_class.new(
-      output_path: 'project/spec/login_spec.rb',
-      content: 'describe "Login" do; end',
-      source_file: 'spec/login_spec.rb',
-      conversion_notes: 'Restructured'
-    )
-    expect(file.output_path).to eq('project/spec/login_spec.rb')
-    expect(file.content).to eq('describe "Login" do; end')
-  end
-
-  it 'serializes to hash' do
-    file = described_class.new(
-      output_path: 'out.rb',
-      content: 'code',
-      source_file: 'in.rb',
-      conversion_notes: 'notes'
-    )
-    expect(file.to_h).to eq(
-      output_path: 'out.rb',
-      content: 'code',
-      source_file: 'in.rb',
-      conversion_notes: 'notes'
-    )
-  end
-end

data/spec/adopter/migrator_spec.rb

@@ -1,277 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'rspec'
-require_relative '../../lib/adopter/migration_plan'
-require_relative '../../lib/adopter/migrator'
-
-RSpec.describe Adopter::Migrator do
-  let(:output_dir) { 'tmp_migrator_test' }
-
-  after { FileUtils.rm_rf(output_dir) }
-
-  describe '#execute' do
-    context 'with skeleton generation' do
-      let(:plan) do
-        Adopter::MigrationPlan.new(
-          source_path: 'dummy_source',
-          output_path: output_dir,
-          target_automation: 'selenium',
-          target_framework: 'rspec',
-          ci_platform: 'github',
-          skeleton_structure: {
-            automation: 'selenium',
-            framework: 'rspec',
-            name: output_dir,
-            ci_platform: 'github'
-          }
-        )
-      end
-
-      it 'generates a raider project skeleton' do
-        described_class.new(plan).execute
-
-        expect(File).to exist("#{output_dir}/Gemfile")
-        expect(File).to exist("#{output_dir}/Rakefile")
-        expect(File).to exist("#{output_dir}/page_objects/pages")
-        expect(File).to exist("#{output_dir}/spec")
-      end
-    end
-
-    context 'writing converted pages' do
-      let(:plan) do
-        Adopter::MigrationPlan.new(
-          source_path: 'dummy_source',
-          output_path: output_dir,
-          target_automation: 'selenium',
-          target_framework: 'rspec',
-          skeleton_structure: {
-            automation: 'selenium',
-            framework: 'rspec',
-            name: output_dir
-          },
-          converted_pages: [
-            Adopter::ConvertedFile.new(
-              output_path: "#{output_dir}/page_objects/pages/login.rb",
-              content: "# frozen_string_literal: true\n\nclass LoginPage < Page\nend\n",
-              source_file: 'pages/login_page.rb',
-              conversion_notes: 'Restructured'
-            )
-          ]
-        )
-      end
-
-      it 'writes converted page files over the skeleton' do
-        results = described_class.new(plan).execute
-
-        expect(results[:pages]).to eq(1)
-        content = File.read("#{output_dir}/page_objects/pages/login.rb")
-        expect(content).to include('class LoginPage < Page')
-      end
-    end
-
-    context 'writing converted tests' do
-      let(:plan) do
-        Adopter::MigrationPlan.new(
-          source_path: 'dummy_source',
-          output_path: output_dir,
-          target_automation: 'selenium',
-          target_framework: 'rspec',
-          skeleton_structure: {
-            automation: 'selenium',
-            framework: 'rspec',
-            name: output_dir
-          },
-          converted_tests: [
-            Adopter::ConvertedFile.new(
-              output_path: "#{output_dir}/spec/login_spec.rb",
-              content: "# frozen_string_literal: true\n\ndescribe 'Login' do\nend\n",
-              source_file: 'spec/login_spec.rb',
-              conversion_notes: 'Restructured'
-            )
-          ]
-        )
-      end
-
-      it 'writes converted test files' do
-        results = described_class.new(plan).execute
-
-        expect(results[:tests]).to eq(1)
-        content = File.read("#{output_dir}/spec/login_spec.rb")
-        expect(content).to include("describe 'Login'")
-      end
-    end
-
-    context 'writing cucumber features and steps' do
-      let(:plan) do
-        Adopter::MigrationPlan.new(
-          source_path: 'dummy_source',
-          output_path: output_dir,
-          target_automation: 'selenium',
-          target_framework: 'cucumber',
-          skeleton_structure: {
-            automation: 'selenium',
-            framework: 'cucumber',
-            name: output_dir
-          },
-          converted_features: [
-            Adopter::ConvertedFile.new(
-              output_path: "#{output_dir}/features/login.feature",
-              content: "Feature: Login\n  Scenario: Valid login\n",
-              source_file: 'features/login.feature',
-              conversion_notes: 'Copied as-is'
-            )
-          ],
-          converted_steps: [
-            Adopter::ConvertedFile.new(
-              output_path: "#{output_dir}/features/step_definitions/login_steps.rb",
-              content: "Given('I am on the login page') do\nend\n",
-              source_file: 'features/step_definitions/login_steps.rb',
-              conversion_notes: 'Updated page references'
-            )
-          ]
-        )
-      end
-
-      it 'writes feature and step files' do
-        results = described_class.new(plan).execute
-
-        expect(results[:features]).to eq(1)
-        expect(results[:steps]).to eq(1)
-        expect(File).to exist("#{output_dir}/features/login.feature")
-        expect(File).to exist("#{output_dir}/features/step_definitions/login_steps.rb")
-      end
-    end
-
-    context 'merging custom gems into Gemfile' do
-      let(:plan) do
-        Adopter::MigrationPlan.new(
-          source_path: 'dummy_source',
-          output_path: output_dir,
-          target_automation: 'selenium',
-          target_framework: 'rspec',
-          skeleton_structure: {
-            automation: 'selenium',
-            framework: 'rspec',
-            name: output_dir
-          },
-          gemfile_additions: %w[faker httparty]
-        )
-      end
-
-      it 'appends custom gems to the generated Gemfile' do
-        described_class.new(plan).execute
-
-        gemfile = File.read("#{output_dir}/Gemfile")
-        expect(gemfile).to include("gem 'faker'")
-        expect(gemfile).to include("gem 'httparty'")
-        expect(gemfile).to include('# Gems from source project')
-      end
-
-      it 'does not duplicate gems already in the Gemfile' do
-        described_class.new(plan).execute
-
-        # Selenium Gemfile already has 'rspec' — adding it again should be skipped
-        plan2 = Adopter::MigrationPlan.new(
-          source_path: 'dummy_source',
-          output_path: output_dir,
-          target_automation: 'selenium',
-          target_framework: 'rspec',
-          skeleton_structure: {
-            automation: 'selenium',
-            framework: 'rspec',
-            name: output_dir
-          },
-          gemfile_additions: %w[faker new_gem]
-        )
-        described_class.new(plan2).execute
-
-        gemfile = File.read("#{output_dir}/Gemfile")
-        expect(gemfile.scan("gem 'faker'").length).to eq(1)
-        expect(gemfile).to include("gem 'new_gem'")
-      end
-    end
-
-    context 'applying config overrides' do
-      let(:plan) do
-        Adopter::MigrationPlan.new(
-          source_path: 'dummy_source',
-          output_path: output_dir,
-          target_automation: 'selenium',
-          target_framework: 'rspec',
-          skeleton_structure: {
-            automation: 'selenium',
-            framework: 'rspec',
-            name: output_dir
-          },
-          config_overrides: { browser: 'firefox', url: 'https://example.com' }
-        )
-      end
-
-      it 'updates config.yml with overridden values' do
-        described_class.new(plan).execute
-
-        config = YAML.safe_load(File.read("#{output_dir}/config/config.yml"), permitted_classes: [Symbol])
-        expect(config['browser']).to eq('firefox')
-        expect(config['url']).to eq('https://example.com')
-      end
-    end
-
-    context 'error handling' do
-      let(:plan) do
-        Adopter::MigrationPlan.new(
-          source_path: 'dummy_source',
-          output_path: output_dir,
-          target_automation: 'selenium',
-          target_framework: 'rspec',
-          skeleton_structure: {
-            automation: 'selenium',
-            framework: 'rspec',
-            name: output_dir
-          },
-          converted_pages: [
-            Adopter::ConvertedFile.new(
-              output_path: '/dev/null/impossible/path/file.rb',
-              content: 'content',
-              source_file: 'pages/bad.rb',
-              conversion_notes: 'Will fail'
-            )
-          ]
-        )
-      end
-
-      it 'captures write errors without stopping execution' do
-        results = described_class.new(plan).execute
-
-        expect(results[:errors]).not_to be_empty
-        expect(results[:errors].first).to include('Failed to write')
-      end
-    end
-
-    context 'results tracking' do
-      let(:plan) do
-        Adopter::MigrationPlan.new(
-          source_path: 'dummy_source',
-          output_path: output_dir,
-          target_automation: 'selenium',
-          target_framework: 'rspec',
-          skeleton_structure: {
-            automation: 'selenium',
-            framework: 'rspec',
-            name: output_dir
-          }
-        )
-      end
-
-      it 'returns zero counts when no files to convert' do
-        results = described_class.new(plan).execute
-
-        expect(results[:pages]).to eq(0)
-        expect(results[:tests]).to eq(0)
-        expect(results[:features]).to eq(0)
-        expect(results[:steps]).to eq(0)
-        expect(results[:errors]).to be_empty
-      end
-    end
-  end
-end

data/spec/adopter/plan_builder_spec.rb

@@ -1,298 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'rspec'
-require_relative '../../lib/adopter/project_analyzer'
-require_relative '../../lib/adopter/plan_builder'
-
-RSpec.describe Adopter::PlanBuilder do
-  let(:project_dir) { 'tmp_plan_builder_project' }
-
-  before { FileUtils.mkdir_p(project_dir) }
-
-  after { FileUtils.rm_rf(project_dir) }
-
-  describe '#build' do
-    context 'with a selenium + rspec project converting to same' do
-      let(:params) do
-        {
-          source_path: project_dir,
-          output_path: 'my_raider_project',
-          target_automation: 'selenium',
-          target_framework: 'rspec',
-          ci_platform: 'github'
-        }
-      end
-
-      before do
-        File.write("#{project_dir}/Gemfile", <<~GEMFILE)
-          gem 'rspec'
-          gem 'selenium-webdriver'
-          gem 'faker'
-        GEMFILE
-        FileUtils.mkdir_p("#{project_dir}/pages")
-        FileUtils.mkdir_p("#{project_dir}/spec")
-
-        File.write("#{project_dir}/pages/login_page.rb", <<~RUBY)
-          class LoginPage < BasePage
-            def login(user, pass)
-              driver.find_element(id: 'user').send_keys user
-            end
-          end
-        RUBY
-
-        File.write("#{project_dir}/spec/login_spec.rb", <<~RUBY)
-          describe 'Login' do
-            it 'can log in' do
-              expect(result).to eq 'ok'
-            end
-          end
-        RUBY
-      end
-
-      it 'builds a valid migration plan' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan).to be_a(Adopter::MigrationPlan)
-        expect(plan.source_path).to eq(project_dir)
-        expect(plan.output_path).to eq('my_raider_project')
-        expect(plan.target_automation).to eq('selenium')
-        expect(plan.target_framework).to eq('rspec')
-      end
-
-      it 'builds correct skeleton structure' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan.skeleton_structure).to eq(
-          automation: 'selenium',
-          framework: 'rspec',
-          name: 'my_raider_project',
-          ci_platform: 'github'
-        )
-      end
-
-      it 'converts pages with raider paths' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan.converted_pages.length).to eq(1)
-        page = plan.converted_pages.first
-        expect(page.output_path).to eq('my_raider_project/page_objects/pages/login.rb')
-        expect(page.source_file).to eq('pages/login_page.rb')
-      end
-
-      it 'converts tests with raider paths' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan.converted_tests.length).to eq(1)
-        test = plan.converted_tests.first
-        expect(test.output_path).to eq('my_raider_project/spec/login_spec.rb')
-      end
-
-      it 'identifies custom gems' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan.gemfile_additions).to eq(['faker'])
-      end
-
-      it 'adds frozen_string_literal when missing' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        page_content = plan.converted_pages.first.content
-        expect(page_content).to include('frozen_string_literal: true')
-      end
-    end
-
-    context 'converting to minitest output paths' do
-      let(:params) do
-        {
-          source_path: project_dir,
-          output_path: 'output',
-          target_automation: 'selenium',
-          target_framework: 'minitest'
-        }
-      end
-
-      before do
-        File.write("#{project_dir}/Gemfile", "gem 'rspec'\ngem 'selenium-webdriver'\n")
-        FileUtils.mkdir_p("#{project_dir}/spec")
-
-        File.write("#{project_dir}/spec/login_spec.rb", <<~RUBY)
-          describe 'Login' do
-            it 'works' do
-              expect(true).to be true
-            end
-          end
-        RUBY
-      end
-
-      it 'generates minitest-style output paths' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        test = plan.converted_tests.first
-        expect(test.output_path).to eq('output/test/test_login.rb')
-      end
-    end
-
-    context 'converting to cucumber' do
-      let(:params) do
-        {
-          source_path: project_dir,
-          output_path: 'output',
-          target_automation: 'selenium',
-          target_framework: 'cucumber'
-        }
-      end
-
-      before do
-        File.write("#{project_dir}/Gemfile", "gem 'cucumber'\ngem 'selenium-webdriver'\n")
-        FileUtils.mkdir_p("#{project_dir}/features/step_definitions")
-
-        File.write("#{project_dir}/features/login.feature", <<~GHERKIN)
-          Feature: Login
-          Scenario: Valid login
-            Given I am on the login page
-        GHERKIN
-
-        File.write("#{project_dir}/features/step_definitions/login_steps.rb", <<~RUBY)
-          Given('I am on the login page') do
-            @page = LoginPage.new(driver)
-          end
-        RUBY
-      end
-
-      it 'plans feature file copies' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan.converted_features.length).to eq(1)
-        expect(plan.converted_features.first.output_path).to eq('output/features/login.feature')
-      end
-
-      it 'plans step definition conversions' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan.converted_steps.length).to eq(1)
-        expect(plan.converted_steps.first.output_path).to eq('output/features/step_definitions/login_steps.rb')
-      end
-
-      it 'skips rspec-style test conversion for cucumber target' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan.converted_tests).to be_empty
-      end
-    end
-
-    context 'converting capybara to selenium' do
-      let(:params) do
-        {
-          source_path: project_dir,
-          output_path: 'output',
-          target_automation: 'selenium',
-          target_framework: 'rspec'
-        }
-      end
-
-      before do
-        File.write("#{project_dir}/Gemfile", "gem 'capybara'\ngem 'rspec'\n")
-        FileUtils.mkdir_p("#{project_dir}/pages")
-
-        File.write("#{project_dir}/pages/login_page.rb", <<~RUBY)
-          class LoginPage < BasePage
-            include Capybara::DSL
-            def login(email, password)
-              fill_in 'email', with: email
-              click_button 'Login'
-            end
-          end
-        RUBY
-      end
-
-      it 'adds a warning when no converter is registered' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan.warnings).to include(match(/No converter for capybara.*selenium/))
-      end
-
-      it 'still includes the page with identity conversion' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan.converted_pages.length).to eq(1)
-      end
-    end
-
-    context 'with config overrides' do
-      let(:params) do
-        {
-          source_path: project_dir,
-          output_path: 'output',
-          target_automation: 'selenium',
-          target_framework: 'rspec',
-          browser: 'firefox',
-          url: 'https://override.com'
-        }
-      end
-
-      before do
-        File.write("#{project_dir}/Gemfile", "gem 'rspec'\ngem 'selenium-webdriver'\n")
-        FileUtils.mkdir_p("#{project_dir}/config")
-        File.write("#{project_dir}/config/config.yml", "browser: chrome\nurl: 'https://original.com'\n")
-      end
-
-      it 'uses parameter overrides over detected values' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        expect(plan.config_overrides[:browser]).to eq('firefox')
-        expect(plan.config_overrides[:url]).to eq('https://override.com')
-      end
-    end
-
-    context 'converting to capybara updates page instantiation' do
-      let(:params) do
-        {
-          source_path: project_dir,
-          output_path: 'output',
-          target_automation: 'capybara',
-          target_framework: 'cucumber'
-        }
-      end
-
-      before do
-        File.write("#{project_dir}/Gemfile", "gem 'cucumber'\ngem 'selenium-webdriver'\n")
-        FileUtils.mkdir_p("#{project_dir}/features/step_definitions")
-
-        File.write("#{project_dir}/features/login.feature", <<~GHERKIN)
-          Feature: Login
-          Scenario: Test
-            Given I am on the login page
-        GHERKIN
-
-        File.write("#{project_dir}/features/step_definitions/login_steps.rb", <<~RUBY)
-          Given('I am on the login page') do
-            @page = LoginPage.new(driver)
-          end
-        RUBY
-      end
-
-      it 'removes driver argument from page instantiation in steps' do
-        analysis = Adopter::ProjectAnalyzer.new(project_dir).analyze
-        plan = described_class.new(analysis, params).build
-
-        step_content = plan.converted_steps.first.content
-        expect(step_content).to include('LoginPage.new')
-        expect(step_content).not_to include('LoginPage.new(driver)')
-      end
-    end
-  end
-end