ruby_raider 2.0.0 → 3.0.1

data/spec/system/adopt_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative '../../lib/adopter/adopt_menu'
+require_relative 'support/system_test_helper'
+
+describe 'Adopt end-to-end' do
+  include SystemTestHelper
+
+  let(:source_dir) { "tmp_adopt_e2e_source_#{automation}" }
+  let(:output_dir) { "tmp_adopt_e2e_#{automation}_#{framework}" }
+
+  before do
+    FileUtils.mkdir_p("#{source_dir}/pages")
+    FileUtils.mkdir_p("#{source_dir}/spec")
+
+    File.write("#{source_dir}/Gemfile", <<~GEMFILE)
+      gem 'rspec'
+      gem 'selenium-webdriver'
+      gem 'faker'
+    GEMFILE
+
+    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(true).to eq true
+        end
+      end
+    RUBY
+  end
+
+  after do
+    FileUtils.rm_rf(source_dir)
+    FileUtils.rm_rf(output_dir)
+  end
+
+  shared_examples 'valid adopted project' do
+    it 'creates a complete raider project structure' do
+      expect(File).to exist("#{output_dir}/Gemfile")
+      expect(File).to exist("#{output_dir}/Rakefile")
+      expect(File).to exist("#{output_dir}/Readme.md")
+      expect(File).to exist("#{output_dir}/.rubocop.yml")
+    end
+
+    it 'converts pages into raider paths' do
+      expect(File).to exist("#{output_dir}/page_objects/pages/login.rb")
+    end
+
+    it 'adds frozen_string_literal to converted pages' do
+      page = File.read("#{output_dir}/page_objects/pages/login.rb")
+      expect(page).to include('# frozen_string_literal: true')
+    end
+
+    it 'updates base class to Page' do
+      page = File.read("#{output_dir}/page_objects/pages/login.rb")
+      expect(page).to include('class LoginPage < Page')
+    end
+
+    it 'merges custom gems into Gemfile' do
+      gemfile = File.read("#{output_dir}/Gemfile")
+      expect(gemfile).to include("gem 'faker'")
+    end
+  end
+
+  context 'selenium to selenium (identity conversion)' do
+    let(:automation) { 'selenium' }
+    let(:framework) { 'rspec' }
+
+    before do
+      Adopter::AdoptMenu.adopt(
+        source_path: source_dir, output_path: output_dir,
+        target_automation: 'selenium', target_framework: 'rspec'
+      )
+    end
+
+    include_examples 'valid adopted project'
+
+    it 'generates rspec test files' do
+      expect(File).to exist("#{output_dir}/spec")
+    end
+
+    it 'generates selenium helpers' do
+      expect(File).to exist("#{output_dir}/helpers/driver_helper.rb")
+    end
+
+    it 'converts page instantiation to use driver' do
+      result = Adopter::AdoptMenu.adopt(
+        source_path: source_dir, output_path: "#{output_dir}_check",
+        target_automation: 'selenium', target_framework: 'rspec'
+      )
+
+      page = result[:plan].converted_pages.first.content
+      expect(page).not_to include('LoginPage.new(browser)')
+
+      FileUtils.rm_rf("#{output_dir}_check")
+    end
+  end
+
+  context 'selenium to capybara' do
+    let(:automation) { 'capybara' }
+    let(:framework) { 'rspec' }
+
+    before do
+      Adopter::AdoptMenu.adopt(
+        source_path: source_dir, output_path: output_dir,
+        target_automation: 'capybara', target_framework: 'rspec'
+      )
+    end
+
+    include_examples 'valid adopted project'
+
+    it 'generates capybara helpers' do
+      expect(File).to exist("#{output_dir}/helpers/capybara_helper.rb")
+    end
+
+    it 'does not generate driver_helper' do
+      expect(File).not_to exist("#{output_dir}/helpers/driver_helper.rb")
+    end
+  end
+
+  context 'selenium to watir + minitest' do
+    let(:automation) { 'watir' }
+    let(:framework) { 'minitest' }
+
+    before do
+      Adopter::AdoptMenu.adopt(
+        source_path: source_dir, output_path: output_dir,
+        target_automation: 'watir', target_framework: 'minitest'
+      )
+    end
+
+    include_examples 'valid adopted project'
+
+    it 'generates watir helpers' do
+      expect(File).to exist("#{output_dir}/helpers/browser_helper.rb")
+    end
+
+    it 'generates minitest test helper' do
+      expect(File).to exist("#{output_dir}/helpers/test_helper.rb")
+    end
+
+    it 'generates minitest test directory' do
+      expect(File).to exist("#{output_dir}/test")
+    end
+  end
+
+  context 'selenium to selenium + cucumber' do
+    let(:automation) { 'selenium' }
+    let(:framework) { 'cucumber' }
+
+    before do
+      FileUtils.mkdir_p("#{source_dir}/features/step_definitions")
+      File.write("#{source_dir}/features/login.feature", <<~GHERKIN)
+        Feature: Login
+        Scenario: Valid login
+          Given I am on the login page
+      GHERKIN
+      File.write("#{source_dir}/features/step_definitions/login_steps.rb", <<~RUBY)
+        Given('I am on the login page') do
+          @page = LoginPage.new(driver)
+        end
+      RUBY
+      File.write("#{source_dir}/Gemfile", "gem 'cucumber'\ngem 'selenium-webdriver'\ngem 'faker'\n")
+
+      Adopter::AdoptMenu.adopt(
+        source_path: source_dir, output_path: output_dir,
+        target_automation: 'selenium', target_framework: 'cucumber'
+      )
+    end
+
+    include_examples 'valid adopted project'
+
+    it 'copies feature files' do
+      expect(File).to exist("#{output_dir}/features/login.feature")
+    end
+
+    it 'converts step definitions' do
+      expect(File).to exist("#{output_dir}/features/step_definitions/login_steps.rb")
+    end
+
+    it 'generates cucumber support files' do
+      expect(File).to exist("#{output_dir}/features/support/env.rb")
+    end
+  end
+
+  context 'with config overrides' do
+    let(:automation) { 'selenium' }
+    let(:framework) { 'rspec' }
+
+    it 'applies browser and url overrides' do
+      Adopter::AdoptMenu.adopt(
+        source_path: source_dir, output_path: output_dir,
+        target_automation: 'selenium', target_framework: 'rspec',
+        browser: 'firefox', url: 'https://example.com'
+      )
+
+      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 'with CI platform' do
+    let(:automation) { 'selenium' }
+    let(:framework) { 'rspec' }
+
+    it 'generates github CI configuration' do
+      Adopter::AdoptMenu.adopt(
+        source_path: source_dir, output_path: output_dir,
+        target_automation: 'selenium', target_framework: 'rspec',
+        ci_platform: 'github'
+      )
+
+      expect(File).to exist("#{output_dir}/.github")
+    end
+  end
+end

data/spec/system/support/system_test_helper.rb

@@ -2,9 +2,7 @@
 
 require 'open3'
 
-# :reek:UtilityFunction
 module SystemTestHelper
-  # :reek:ControlParameter
   def test_command_for(framework)
     case framework
     when 'cucumber' then 'bundle exec cucumber features --format pretty'

data/spec/utilities/desktop_downloader_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/utilities/desktop_downloader'
+
+describe DesktopDownloader do
+  describe '.platform' do
+    it 'returns a recognized platform string' do
+      expect(%w[mac_arm mac_intel windows linux_appimage linux_deb]).to include(described_class.platform) # rubocop:disable RSpec/ExpectActual
+    end
+  end
+
+  describe '.platform_display_name' do
+    it 'returns a human-readable name' do
+      expect(described_class.platform_display_name).to be_a(String)
+      expect(described_class.platform_display_name).not_to eq('Unknown')
+    end
+
+    it 'matches the detected platform' do
+      expected_names = {
+        'mac_arm' => 'macOS (Apple Silicon)',
+        'mac_intel' => 'macOS (Intel)',
+        'windows' => 'Windows',
+        'linux_deb' => 'Linux (deb)',
+        'linux_appimage' => 'Linux (AppImage)'
+      }
+      expect(described_class.platform_display_name).to eq(expected_names[described_class.platform])
+    end
+  end
+
+  describe 'PLATFORM_PATTERNS' do
+    it 'has patterns for all supported platforms' do
+      expect(described_class::PLATFORM_PATTERNS.keys).to contain_exactly(
+        'mac_arm', 'mac_intel', 'windows', 'linux_deb', 'linux_appimage'
+      )
+    end
+
+    it 'mac patterns match .dmg files' do
+      expect(described_class::PLATFORM_PATTERNS['mac_arm']).to match('Raider-Desktop-1.0.0.dmg')
+      expect(described_class::PLATFORM_PATTERNS['mac_intel']).to match('Raider-Desktop-1.0.0.dmg')
+    end
+
+    it 'windows pattern matches setup.exe files' do
+      expect(described_class::PLATFORM_PATTERNS['windows']).to match('Raider-Desktop-1.0.0-setup.exe')
+    end
+
+    it 'linux deb pattern matches .deb files' do
+      expect(described_class::PLATFORM_PATTERNS['linux_deb']).to match('raider-desktop_1.0.0_amd64.deb')
+    end
+
+    it 'linux appimage pattern matches .AppImage files' do
+      expect(described_class::PLATFORM_PATTERNS['linux_appimage']).to match('Raider-Desktop-1.0.0.AppImage')
+    end
+
+    it 'does not cross-match patterns' do
+      expect(described_class::PLATFORM_PATTERNS['windows']).not_to match('Raider-Desktop.dmg')
+      expect(described_class::PLATFORM_PATTERNS['mac_arm']).not_to match('Raider-Desktop-setup.exe')
+    end
+  end
+
+  describe '.latest_version' do
+    context 'when GitHub API is reachable' do
+      it 'returns a version string or nil' do
+        version = described_class.latest_version
+        # May be nil if rate-limited or offline, that's OK
+        expect(version).to be_nil.or(match(/\Av?\d+\.\d+/))
+      end
+    end
+  end
+
+  describe '.download_url' do
+    context 'when GitHub API is reachable' do
+      it 'returns a URL string or nil' do
+        url = described_class.download_url
+        expect(url).to be_nil.or(match(%r{\Ahttps://}))
+      end
+    end
+  end
+
+  describe 'REPO' do
+    it 'points to the correct GitHub repository' do
+      expect(described_class::REPO).to eq('RaiderHQ/raider_desktop')
+    end
+  end
+
+  describe 'API_URL' do
+    it 'is a valid GitHub releases API endpoint' do
+      expect(described_class::API_URL).to eq(
+        'https://api.github.com/repos/RaiderHQ/raider_desktop/releases/latest'
+      )
+    end
+  end
+end

data/spec/utilities/headless_config_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+require 'erb'
+
+RSpec.describe 'Headless config support in driver templates' do
+  let(:tmp_dir) { 'tmp_headless_test' }
+
+  before do
+    FileUtils.mkdir_p(tmp_dir)
+    Dir.chdir(tmp_dir)
+  end
+
+  after do
+    Dir.chdir('..')
+    FileUtils.rm_rf(tmp_dir)
+  end
+
+  describe 'selenium driver template' do
+    it 'checks config headless key' do
+      content = File.read(File.expand_path('../../lib/generators/templates/helpers/partials/selenium_driver.tt',
+                                           __dir__))
+      expect(content).to include("@config['headless']")
+    end
+
+    it 'checks ENV HEADLESS' do
+      content = File.read(File.expand_path('../../lib/generators/templates/helpers/partials/selenium_driver.tt',
+                                           __dir__))
+      expect(content).to include("ENV['HEADLESS']")
+    end
+  end
+
+  describe 'capybara helper template' do
+    it 'checks config headless key' do
+      content = File.read(File.expand_path('../../lib/generators/templates/helpers/capybara_helper.tt', __dir__))
+      expect(content).to include("config['headless']")
+    end
+  end
+
+  describe 'browser helper template (watir)' do
+    it 'checks config headless key' do
+      content = File.read(File.expand_path('../../lib/generators/templates/helpers/browser_helper.tt', __dir__))
+      expect(content).to include("config['headless']")
+    end
+  end
+
+  describe 'headless via config.yml' do
+    it 'config key is used when YAML has headless: true' do
+      FileUtils.mkdir_p('config')
+      File.write('config/config.yml', <<~YAML)
+        browser: chrome
+        headless: true
+        browser_arguments:
+          chrome:
+            - no-sandbox
+      YAML
+
+      config = YAML.load_file('config/config.yml')
+      args = config['browser_arguments'][config['browser']]
+
+      # Simulate the template logic
+      args += ['--headless'] if (ENV['HEADLESS'] || config['headless']) && !args.include?('--headless')
+
+      expect(args).to include('--headless')
+    end
+
+    it 'config key is not used when headless: false' do
+      FileUtils.mkdir_p('config')
+      File.write('config/config.yml', <<~YAML)
+        browser: chrome
+        headless: false
+        browser_arguments:
+          chrome:
+            - no-sandbox
+      YAML
+
+      config = YAML.load_file('config/config.yml')
+      args = config['browser_arguments'][config['browser']]
+
+      # Temporarily clear ENV to isolate config behavior
+      original_env = ENV.delete('HEADLESS')
+      args += ['--headless'] if (ENV['HEADLESS'] || config['headless']) && !args.include?('--headless')
+      ENV['HEADLESS'] = original_env if original_env
+
+      expect(args).not_to include('--headless')
+    end
+  end
+end

data/spec/utilities/utilities_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+require_relative '../../lib/utilities/utilities'
+
+RSpec.describe Utilities do
+  let(:tmp_dir) { 'tmp_utilities_test' }
+  let(:config_path) { 'config/config.yml' }
+
+  before do
+    FileUtils.mkdir_p(tmp_dir)
+    Dir.chdir(tmp_dir)
+    FileUtils.mkdir_p('config')
+    File.write(config_path, <<~YAML)
+      browser: chrome
+      url: 'http://localhost:3000'
+      timeout: 10
+      viewport:
+        width: 1920
+        height: 1080
+      browser_arguments:
+        chrome:
+          - no-sandbox
+          - disable-dev-shm-usage
+        firefox:
+          - acceptInsecureCerts
+    YAML
+    # Reset cached config between tests
+    described_class.instance_variable_set(:@config, nil)
+  end
+
+  after do
+    Dir.chdir('..')
+    FileUtils.rm_rf(tmp_dir)
+  end
+
+  describe '.browser_options=' do
+    it 'writes to browser_arguments for the current browser' do
+      described_class.browser_options = %w[no-sandbox headless]
+      config = YAML.load_file(config_path)
+      expect(config['browser_arguments']['chrome']).to eq(%w[no-sandbox headless])
+    end
+
+    it 'writes to the correct browser key when browser is firefox' do
+      described_class.browser = 'firefox'
+      described_class.instance_variable_set(:@config, nil)
+      described_class.browser_options = %w[headless]
+      config = YAML.load_file(config_path)
+      expect(config['browser_arguments']['firefox']).to eq(%w[headless])
+    end
+
+    it 'preserves other browser arguments' do
+      described_class.browser_options = %w[headless]
+      config = YAML.load_file(config_path)
+      expect(config['browser_arguments']['firefox']).to eq(%w[acceptInsecureCerts])
+    end
+  end
+
+  describe '.delete_browser_options' do
+    it 'removes browser_arguments for the current browser' do
+      described_class.delete_browser_options
+      config = YAML.load_file(config_path)
+      expect(config['browser_arguments']['chrome']).to be_nil
+    end
+
+    it 'preserves other browser arguments' do
+      described_class.delete_browser_options
+      config = YAML.load_file(config_path)
+      expect(config['browser_arguments']['firefox']).to eq(%w[acceptInsecureCerts])
+    end
+  end
+
+  describe '.headless=' do
+    it 'sets headless to true' do
+      described_class.headless = true
+      config = YAML.load_file(config_path)
+      expect(config['headless']).to be true
+    end
+
+    it 'sets headless to false' do
+      described_class.headless = true
+      described_class.instance_variable_set(:@config, nil)
+      described_class.headless = false
+      config = YAML.load_file(config_path)
+      expect(config['headless']).to be false
+    end
+  end
+
+  describe '.viewport=' do
+    it 'sets viewport dimensions' do
+      described_class.viewport = '375x812'
+      config = YAML.load_file(config_path)
+      expect(config['viewport']).to eq({ 'width' => 375, 'height' => 812 })
+    end
+  end
+
+  describe '.browser_options= writes to browser_arguments not browser_options' do
+    it 'does not create a browser_options key' do
+      described_class.browser_options = %w[headless]
+      config = YAML.load_file(config_path)
+      expect(config).not_to have_key('browser_options')
+    end
+  end
+end