ruby_raider 2.0.0 → 3.0.1

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

data/spec/scaffolding/name_normalizer_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/scaffolding/name_normalizer'
+
+RSpec.describe NameNormalizer do
+  describe '.normalize' do
+    it 'strips _page suffix' do
+      expect(described_class.normalize('login_page')).to eq('login')
+    end
+
+    it 'strips _spec suffix' do
+      expect(described_class.normalize('login_spec')).to eq('login')
+    end
+
+    it 'strips _steps suffix' do
+      expect(described_class.normalize('login_steps')).to eq('login')
+    end
+
+    it 'strips _helper suffix' do
+      expect(described_class.normalize('login_helper')).to eq('login')
+    end
+
+    it 'converts CamelCase to snake_case' do
+      expect(described_class.normalize('LoginPage')).to eq('login')
+    end
+
+    it 'handles CamelCase without suffix' do
+      expect(described_class.normalize('Dashboard')).to eq('dashboard')
+    end
+
+    it 'preserves nested paths' do
+      expect(described_class.normalize('admin/users')).to eq('admin/users')
+    end
+
+    it 'handles CamelCase nested paths' do
+      expect(described_class.normalize('Admin::UsersPage')).to eq('admin/users')
+    end
+
+    it 'leaves clean names unchanged' do
+      expect(described_class.normalize('login')).to eq('login')
+    end
+  end
+
+  describe '.to_class_name' do
+    it 'converts snake_case to CamelCase' do
+      expect(described_class.to_class_name('login')).to eq('Login')
+    end
+
+    it 'handles underscored names' do
+      expect(described_class.to_class_name('user_profile')).to eq('UserProfile')
+    end
+
+    it 'strips suffixes before converting' do
+      expect(described_class.to_class_name('login_page')).to eq('Login')
+    end
+
+    it 'handles nested names with modules' do
+      expect(described_class.to_class_name('admin/users')).to eq('Admin::Users')
+    end
+
+    it 'appends optional suffix' do
+      expect(described_class.to_class_name('login', 'Page')).to eq('LoginPage')
+    end
+  end
+
+  describe '.to_page_class' do
+    it 'converts to page class name' do
+      expect(described_class.to_page_class('login')).to eq('LoginPage')
+    end
+
+    it 'does not double the Page suffix' do
+      expect(described_class.to_page_class('login_page')).to eq('LoginPage')
+    end
+
+    it 'handles CamelCase input' do
+      expect(described_class.to_page_class('LoginPage')).to eq('LoginPage')
+    end
+  end
+
+  describe '.nested?' do
+    it 'returns true for nested paths' do
+      expect(described_class.nested?('admin/users')).to be true
+    end
+
+    it 'returns false for simple names' do
+      expect(described_class.nested?('login')).to be false
+    end
+  end
+
+  describe '.module_parts' do
+    it 'returns module path for nested names' do
+      expect(described_class.module_parts('admin/users')).to eq(['Admin'])
+    end
+
+    it 'returns empty for simple names' do
+      expect(described_class.module_parts('login')).to eq([])
+    end
+
+    it 'handles deep nesting' do
+      expect(described_class.module_parts('admin/settings/users')).to eq(%w[Admin Settings])
+    end
+  end
+
+  describe '.leaf_name' do
+    it 'returns last segment of nested path' do
+      expect(described_class.leaf_name('admin/users')).to eq('users')
+    end
+
+    it 'returns name itself for simple names' do
+      expect(described_class.leaf_name('login')).to eq('login')
+    end
+  end
+end

data/spec/scaffolding/page_introspector_spec.rb

@@ -0,0 +1,82 @@
+# 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/scaffold_project_detector_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative '../../lib/scaffolding/project_detector'
+
+RSpec.describe ScaffoldProjectDetector do
+  let(:tmp_dir) { 'tmp_project_detector_test' }
+
+  before do
+    FileUtils.mkdir_p(tmp_dir)
+    Dir.chdir(tmp_dir)
+  end
+
+  after do
+    Dir.chdir('..')
+    FileUtils.rm_rf(tmp_dir)
+  end
+
+  context 'with selenium project' do
+    before do
+      File.write('Gemfile', "gem 'rspec'\ngem 'selenium-webdriver'\n")
+      FileUtils.mkdir_p('spec')
+    end
+
+    it 'detects selenium automation' do
+      expect(described_class.detect_automation).to eq('selenium')
+    end
+
+    it 'detects rspec framework' do
+      expect(described_class.detect_framework).to eq('rspec')
+    end
+
+    it 'reports selenium?' do
+      expect(described_class.selenium?).to be true
+    end
+
+    it 'reports not capybara?' do
+      expect(described_class.capybara?).to be false
+    end
+  end
+
+  context 'with capybara project' do
+    before do
+      File.write('Gemfile', "gem 'capybara'\ngem 'cucumber'\n")
+      FileUtils.mkdir_p('features')
+    end
+
+    it 'detects capybara automation' do
+      expect(described_class.detect_automation).to eq('capybara')
+    end
+
+    it 'detects cucumber framework' do
+      expect(described_class.detect_framework).to eq('cucumber')
+    end
+
+    it 'reports capybara?' do
+      expect(described_class.capybara?).to be true
+    end
+  end
+
+  context 'with watir project' do
+    before do
+      File.write('Gemfile', "gem 'watir'\ngem 'minitest'\n")
+      FileUtils.mkdir_p('test')
+    end
+
+    it 'detects watir automation' do
+      expect(described_class.detect_automation).to eq('watir')
+    end
+
+    it 'detects minitest framework' do
+      expect(described_class.detect_framework).to eq('minitest')
+    end
+
+    it 'reports watir?' do
+      expect(described_class.watir?).to be true
+    end
+  end
+
+  context 'with no Gemfile' do
+    it 'defaults to selenium' do
+      expect(described_class.detect_automation).to eq('selenium')
+    end
+
+    it 'defaults to rspec' do
+      expect(described_class.detect_framework).to eq('rspec')
+    end
+  end
+
+  describe '.validate_project' do
+    it 'warns when Gemfile is missing' do
+      warnings = described_class.validate_project
+      expect(warnings).to include(match(/Gemfile not found/))
+    end
+
+    it 'warns when config/config.yml is missing' do
+      File.write('Gemfile', "gem 'rspec'\n")
+      warnings = described_class.validate_project
+      expect(warnings).to include(match(/config\.yml not found/))
+    end
+
+    it 'returns no warnings for valid project' do
+      File.write('Gemfile', "gem 'rspec'\n")
+      FileUtils.mkdir_p('config')
+      File.write('config/config.yml', "browser: chrome\n")
+      expect(described_class.validate_project).to be_empty
+    end
+  end
+
+  describe '.config' do
+    it 'returns empty hash when config missing' do
+      expect(described_class.config).to eq({})
+    end
+
+    it 'parses valid config' do
+      FileUtils.mkdir_p('config')
+      File.write('config/config.yml', "browser: chrome\nurl: http://localhost\n")
+      expect(described_class.config).to eq({ 'browser' => 'chrome', 'url' => 'http://localhost' })
+    end
+
+    it 'raises Error on malformed YAML' do
+      FileUtils.mkdir_p('config')
+      File.write('config/config.yml', "browser: chrome\n  bad:\nindent")
+      expect { described_class.config }.to raise_error(ScaffoldProjectDetector::Error, /invalid YAML syntax/)
+    end
+  end
+
+  describe '.detect' do
+    before do
+      File.write('Gemfile', "gem 'selenium-webdriver'\ngem 'rspec'\n")
+      FileUtils.mkdir_p('spec')
+    end
+
+    it 'returns full detection hash' do
+      result = described_class.detect
+      expect(result[:automation]).to eq('selenium')
+      expect(result[:framework]).to eq('rspec')
+      expect(result[:has_spec]).to be true
+      expect(result[:has_features]).to be false
+    end
+  end
+end