ruby_raider 1.1.4 → 2.0.0

data/spec/adopter/adopt_menu_spec.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'rspec'
+require_relative '../../lib/adopter/adopt_menu'
+
+RSpec.describe Adopter::AdoptMenu do
+  let(:source_dir) { 'tmp_adopt_menu_source' }
+  let(:output_dir) { 'tmp_adopt_menu_output' }
+
+  before do
+    FileUtils.mkdir_p(source_dir)
+    File.write("#{source_dir}/Gemfile", "gem 'rspec'\ngem 'selenium-webdriver'\ngem 'faker'\n")
+    FileUtils.mkdir_p("#{source_dir}/pages")
+    FileUtils.mkdir_p("#{source_dir}/spec")
+
+    File.write("#{source_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("#{source_dir}/spec/login_spec.rb", <<~RUBY)
+      describe 'Login' do
+        it 'can log in' do
+          expect(result).to eq 'ok'
+        end
+      end
+    RUBY
+  end
+
+  after do
+    FileUtils.rm_rf(source_dir)
+    FileUtils.rm_rf(output_dir)
+  end
+
+  describe '.adopt' do
+    let(:params) do
+      {
+        source_path: source_dir,
+        output_path: output_dir,
+        target_automation: 'selenium',
+        target_framework: 'rspec'
+      }
+    end
+
+    it 'runs the full adoption pipeline' do
+      result = described_class.adopt(params)
+
+      expect(result[:plan]).to be_a(Adopter::MigrationPlan)
+      expect(result[:results][:pages]).to eq(1)
+      expect(result[:results][:tests]).to eq(1)
+      expect(File).to exist("#{output_dir}/Gemfile")
+      expect(File).to exist("#{output_dir}/page_objects/pages/login.rb")
+    end
+
+    it 'merges custom gems into the generated Gemfile' do
+      described_class.adopt(params)
+
+      gemfile = File.read("#{output_dir}/Gemfile")
+      expect(gemfile).to include("gem 'faker'")
+    end
+
+    it 'converts page content with raider conventions' do
+      described_class.adopt(params)
+
+      page = File.read("#{output_dir}/page_objects/pages/login.rb")
+      expect(page).to include('frozen_string_literal: true')
+      expect(page).to include('class LoginPage < Page')
+    end
+
+    context 'with capybara target' do
+      let(:params) do
+        {
+          source_path: source_dir,
+          output_path: output_dir,
+          target_automation: 'capybara',
+          target_framework: 'rspec'
+        }
+      end
+
+      it 'removes driver arguments from page instantiation' do
+        File.write("#{source_dir}/spec/login_spec.rb", <<~RUBY)
+          describe 'Login' do
+            it 'can log in' do
+              @page = LoginPage.new(driver)
+            end
+          end
+        RUBY
+
+        result = described_class.adopt(params)
+        test_content = result[:plan].converted_tests.first.content
+        expect(test_content).to include('LoginPage.new')
+        expect(test_content).not_to include('LoginPage.new(driver)')
+      end
+    end
+
+    context 'with ci_platform' do
+      let(:params) do
+        {
+          source_path: source_dir,
+          output_path: output_dir,
+          target_automation: 'selenium',
+          target_framework: 'rspec',
+          ci_platform: 'github'
+        }
+      end
+
+      it 'generates CI configuration' do
+        described_class.adopt(params)
+
+        expect(File).to exist("#{output_dir}/.github")
+      end
+    end
+  end
+
+  describe '.validate_params!' do
+    it 'raises on missing source_path' do
+      expect { described_class.validate_params!({}) }.to raise_error(ArgumentError, /source_path/)
+    end
+
+    it 'raises on missing output_path' do
+      expect { described_class.validate_params!(source_path: 'x') }.to raise_error(ArgumentError, /output_path/)
+    end
+
+    it 'raises on missing target_automation' do
+      expect {
+        described_class.validate_params!(source_path: 'x', output_path: 'y')
+      }.to raise_error(ArgumentError, /target_automation/)
+    end
+
+    it 'raises on missing target_framework' do
+      expect {
+        described_class.validate_params!(source_path: 'x', output_path: 'y', target_automation: 'selenium')
+      }.to raise_error(ArgumentError, /target_framework/)
+    end
+
+    it 'raises on invalid target_automation' do
+      expect {
+        described_class.validate_params!(
+          source_path: 'x', output_path: 'y',
+          target_automation: 'appium', target_framework: 'rspec'
+        )
+      }.to raise_error(ArgumentError, /target_automation must be/)
+    end
+
+    it 'raises on invalid target_framework' do
+      expect {
+        described_class.validate_params!(
+          source_path: 'x', output_path: 'y',
+          target_automation: 'selenium', target_framework: 'junit'
+        )
+      }.to raise_error(ArgumentError, /target_framework must be/)
+    end
+
+    it 'accepts valid params without raising' do
+      expect {
+        described_class.validate_params!(
+          source_path: 'x', output_path: 'y',
+          target_automation: 'selenium', target_framework: 'rspec'
+        )
+      }.not_to raise_error
+    end
+
+    it 'accepts capybara as valid automation' do
+      expect {
+        described_class.validate_params!(
+          source_path: 'x', output_path: 'y',
+          target_automation: 'capybara', target_framework: 'minitest'
+        )
+      }.not_to raise_error
+    end
+  end
+end

data/spec/adopter/converters/identity_converter_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../../lib/adopter/converters/identity_converter'
+
+RSpec.describe Adopter::Converters::IdentityConverter do
+  describe '#convert_page' do
+    context 'targeting selenium' do
+      let(:converter) { described_class.new('selenium') }
+
+      it 'adds frozen_string_literal if missing' do
+        input = "class LoginPage < BasePage\nend\n"
+        result = converter.convert_page(input, {})
+        expect(result).to start_with('# frozen_string_literal: true')
+      end
+
+      it 'does not duplicate frozen_string_literal' do
+        input = "# frozen_string_literal: true\n\nclass LoginPage < Page\nend\n"
+        result = converter.convert_page(input, {})
+        expect(result.scan('frozen_string_literal').length).to eq(1)
+      end
+
+      it 'updates base class to Page' do
+        input = "class LoginPage < BasePage\nend\n"
+        result = converter.convert_page(input, {})
+        expect(result).to include('class LoginPage < Page')
+      end
+
+      it 'preserves non-page base classes' do
+        input = "class UserFactory < ModelFactory\nend\n"
+        result = converter.convert_page(input, {})
+        expect(result).to include('class UserFactory < ModelFactory')
+      end
+
+      it 'adds require_relative for abstract page' do
+        input = "class LoginPage < BasePage\nend\n"
+        result = converter.convert_page(input, {})
+        expect(result).to include("require_relative '../abstract/page'")
+      end
+
+      it 'does not duplicate page require' do
+        input = "require_relative '../abstract/page'\n\nclass LoginPage < Page\nend\n"
+        result = converter.convert_page(input, {})
+        expect(result.scan("require_relative '../abstract/page'").length).to eq(1)
+      end
+
+      it 'swaps browser to driver in page instantiation' do
+        input = "class Test\n  @page = LoginPage.new(browser)\nend\n"
+        result = converter.convert_page(input, {})
+        expect(result).to include('LoginPage.new(driver)')
+      end
+    end
+
+    context 'targeting capybara' do
+      let(:converter) { described_class.new('capybara') }
+
+      it 'removes driver argument from page instantiation' do
+        input = "class Test\n  @page = LoginPage.new(driver)\nend\n"
+        result = converter.convert_page(input, {})
+        expect(result).to include('LoginPage.new')
+        expect(result).not_to include('LoginPage.new(driver)')
+      end
+
+      it 'removes browser argument from page instantiation' do
+        input = "  @page = LoginPage.new(browser)\n"
+        result = converter.convert_page(input, {})
+        expect(result).to include('LoginPage.new')
+        expect(result).not_to include('LoginPage.new(browser)')
+      end
+    end
+
+    context 'targeting watir' do
+      let(:converter) { described_class.new('watir') }
+
+      it 'swaps driver to browser in page instantiation' do
+        input = "class Test\n  @page = LoginPage.new(driver)\nend\n"
+        result = converter.convert_page(input, {})
+        expect(result).to include('LoginPage.new(browser)')
+      end
+    end
+  end
+
+  describe '#convert_test' do
+    let(:converter) { described_class.new('selenium') }
+
+    it 'adds frozen_string_literal if missing' do
+      input = "describe 'Login' do\nend\n"
+      result = converter.convert_test(input, {})
+      expect(result).to start_with('# frozen_string_literal: true')
+    end
+
+    it 'updates helper require paths for selenium' do
+      input = "require_relative '../support/browser_setup'\n\ndescribe 'x' do; end\n"
+      result = converter.convert_test(input, {})
+      expect(result).to include("require_relative '../helpers/driver_helper'")
+    end
+
+    context 'targeting capybara' do
+      let(:converter) { described_class.new('capybara') }
+
+      it 'updates helper require paths for capybara' do
+        input = "require_relative '../support/driver_helper'\n\ndescribe 'x' do; end\n"
+        result = converter.convert_test(input, {})
+        expect(result).to include("require_relative '../helpers/capybara_helper'")
+      end
+    end
+
+    context 'targeting watir' do
+      let(:converter) { described_class.new('watir') }
+
+      it 'updates helper require paths for watir' do
+        input = "require_relative '../support/driver_setup'\n\ndescribe 'x' do; end\n"
+        result = converter.convert_test(input, {})
+        expect(result).to include("require_relative '../helpers/browser_helper'")
+      end
+    end
+  end
+
+  describe '#convert_step' do
+    context 'targeting capybara' do
+      let(:converter) { described_class.new('capybara') }
+
+      it 'removes driver argument from page instantiation in steps' do
+        input = <<~RUBY
+          Given('I am on the login page') do
+            @page = LoginPage.new(driver)
+          end
+        RUBY
+        result = converter.convert_step(input)
+        expect(result).to include('LoginPage.new')
+        expect(result).not_to include('LoginPage.new(driver)')
+      end
+    end
+
+    context 'targeting selenium' do
+      let(:converter) { described_class.new('selenium') }
+
+      it 'swaps browser to driver in step page instantiation' do
+        input = "  @page = LoginPage.new(browser)\n"
+        result = converter.convert_step(input)
+        expect(result).to include('LoginPage.new(driver)')
+      end
+    end
+  end
+end

data/spec/adopter/migration_plan_spec.rb

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