ruby_raider 1.1.4 → 3.0.0

data/spec/commands/raider_commands_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../lib/ruby_raider'
+
+RSpec.describe RubyRaider::Raider do
+  describe 'new command' do
+    context 'with parameters' do
+      it 'calls InvokeGenerators.generate_framework with parsed hash' do
+        allow(InvokeGenerators).to receive(:generate_framework)
+
+        described_class.new.invoke(:new, nil, %w[my_project -p framework:rspec automation:selenium])
+
+        expect(InvokeGenerators).to have_received(:generate_framework).with(
+          hash_including(framework: 'rspec', automation: 'selenium', name: 'my_project')
+        )
+      end
+    end
+
+    context 'without parameters' do
+      it 'calls MenuGenerator.generate_choice_menu' do
+        menu = instance_double(MenuGenerator, generate_choice_menu: nil)
+        allow(MenuGenerator).to receive(:new).and_return(menu)
+
+        described_class.new.invoke(:new, nil, %w[my_project])
+
+        expect(menu).to have_received(:generate_choice_menu)
+      end
+    end
+  end
+
+  describe 'version command' do
+    it 'outputs the version from lib/version' do
+      expected_version = File.read(File.expand_path('../../lib/version', __dir__)).strip
+      expect { described_class.new.invoke(:version) }.to output(/#{Regexp.escape(expected_version)}/).to_stdout
+    end
+  end
+
+  describe 'subcommand aliases' do
+    it 'maps n to new' do
+      expect(described_class.map['n']).to eq('new')
+    end
+
+    it 'maps v to version' do
+      expect(described_class.map['v']).to eq('version')
+    end
+
+    it 'maps a to adopt' do
+      expect(described_class.map['a']).to eq('adopt')
+    end
+
+    it 'maps g to generate' do
+      expect(described_class.map['g']).to eq('generate')
+    end
+
+    it 'maps u to utility' do
+      expect(described_class.map['u']).to eq('utility')
+    end
+
+    it 'maps pm to plugin_manager' do
+      expect(described_class.map['pm']).to eq('plugin_manager')
+    end
+  end
+
+  describe 'registered subcommands' do
+    let(:subcommands) { described_class.subcommands }
+
+    it 'includes adopt' do
+      expect(subcommands).to include('adopt')
+    end
+
+    it 'includes generate' do
+      expect(subcommands).to include('generate')
+    end
+
+    it 'includes utility' do
+      expect(subcommands).to include('utility')
+    end
+
+    it 'includes plugin_manager' do
+      expect(subcommands).to include('plugin_manager')
+    end
+  end
+end
+
+RSpec.describe AdoptCommands do
+  let(:source_dir) { 'tmp_cmd_adopt_source' }
+  let(:output_dir) { 'tmp_cmd_adopt_output' }
+
+  before do
+    FileUtils.mkdir_p(source_dir)
+    File.write("#{source_dir}/Gemfile", "gem 'rspec'\ngem 'selenium-webdriver'\n")
+    FileUtils.mkdir_p("#{source_dir}/spec")
+  end
+
+  after do
+    FileUtils.rm_rf(source_dir)
+    FileUtils.rm_rf(output_dir)
+  end
+
+  describe 'project command with parameters' do
+    it 'calls AdoptMenu.adopt with parsed params' do
+      result = { plan: double(warnings: [], output_path: output_dir), results: { pages: 0, tests: 0, features: 0, steps: 0, errors: [] } } # rubocop:disable RSpec/VerifiedDoubles
+      allow(Adopter::AdoptMenu).to receive(:adopt).and_return(result)
+
+      expect do
+        described_class.new.invoke(:project, nil, [source_dir, '-p',
+                                                   "output_path:#{output_dir}",
+                                                   'target_automation:selenium',
+                                                   'target_framework:rspec'])
+      end.to output(/Adoption complete/).to_stdout
+
+      expect(Adopter::AdoptMenu).to have_received(:adopt).with(
+        hash_including(source_path: source_dir, target_automation: 'selenium', target_framework: 'rspec')
+      )
+    end
+  end
+
+  describe 'project command without parameters' do
+    it 'calls AdoptMenu#run' do
+      menu = instance_double(Adopter::AdoptMenu, run: nil)
+      allow(Adopter::AdoptMenu).to receive(:new).and_return(menu)
+
+      described_class.new.invoke(:project, nil, [source_dir])
+
+      expect(menu).to have_received(:run)
+    end
+  end
+end

data/spec/generators/fixtures/templates/test.tt

@@ -0,0 +1 @@
+Test content

data/spec/generators/fixtures/templates/test_partial.tt

@@ -0,0 +1 @@
+Test partial content

data/spec/generators/generator_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../lib/generators/generator'
+
+RSpec.describe Generator do
+  describe '#ruby_version' do
+    it 'returns the default version when no ruby_version arg is present' do
+      generator = described_class.new(%w[selenium rspec test_project])
+      expect(generator.ruby_version).to eq('3.4')
+    end
+
+    it 'returns the specified version from args' do
+      generator = described_class.new(%w[selenium rspec test_project ruby_version:3.3])
+      expect(generator.ruby_version).to eq('3.3')
+    end
+
+    it 'handles version with multiple colons gracefully' do
+      generator = described_class.new(%w[selenium rspec test_project ruby_version:3.2])
+      expect(generator.ruby_version).to eq('3.2')
+    end
+  end
+end

data/spec/generators/template_renderer_spec.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require_relative '../integration/spec_helper'
+require_relative '../../lib/generators/template_renderer'
+require_relative '../../lib/generators/generator'
+
+RSpec.describe TemplateRenderer do
+  # Create a test generator class that includes TemplateRenderer
+  let(:test_generator_class) do
+    Class.new do
+      include TemplateRenderer
+
+      def self.source_paths
+        [File.expand_path('../fixtures/templates', __dir__)]
+      end
+
+      # Mock predicate methods that templates might use
+      def selenium_based?
+        true
+      end
+
+      def watir?
+        false
+      end
+
+      def mobile?
+        false
+      end
+    end
+  end
+
+  let(:test_instance) { test_generator_class.new }
+
+  describe '#partial' do
+    context 'when rendering a simple partial' do
+      it 'renders the partial content' do
+        # This test requires a fixtures directory with test templates
+        # For now, we'll test the API interface
+        expect(test_instance).to respond_to(:partial)
+      end
+
+      it 'accepts a partial name as first argument' do
+        expect { test_instance.partial('test_partial') }.not_to raise_error(ArgumentError)
+      end
+
+      it 'accepts options hash' do
+        expect { test_instance.partial('test', trim_mode: '-', strip: true) }.not_to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with strip option' do
+      it 'applies strip when strip: true' do
+        # Mock the template renderer to verify strip is called
+        allow_any_instance_of(TemplateRenderer::PartialCache).to receive(:render_partial)
+          .and_return("  content  \n")
+
+        result = test_instance.partial('test', strip: true)
+        expect(result).to eq('content')
+      end
+
+      it 'does not apply strip when strip: false (default)' do
+        allow_any_instance_of(TemplateRenderer::PartialCache).to receive(:render_partial)
+          .and_return("  content  \n")
+
+        result = test_instance.partial('test', strip: false)
+        expect(result).to eq("  content  \n")
+      end
+    end
+
+    context 'with trim_mode option' do
+      it 'uses default trim_mode: "-" when not specified' do
+        cache = test_generator_class.template_renderer
+        expect(cache).to receive(:render_partial).with('test', anything, hash_including(trim_mode: '-'))
+        test_instance.partial('test')
+      end
+
+      it 'allows custom trim_mode' do
+        cache = test_generator_class.template_renderer
+        expect(cache).to receive(:render_partial).with('test', anything, hash_including(trim_mode: '<>'))
+        test_instance.partial('test', trim_mode: '<>')
+      end
+
+      it 'disables trim_mode when trim: false' do
+        cache = test_generator_class.template_renderer
+        expect(cache).to receive(:render_partial).with('test', anything, hash_including(trim_mode: nil))
+        test_instance.partial('test', trim: false)
+      end
+    end
+  end
+
+  describe 'ClassMethods' do
+    describe '.template_renderer' do
+      it 'returns a PartialCache instance' do
+        expect(test_generator_class.template_renderer).to be_a(TemplateRenderer::PartialCache)
+      end
+
+      it 'returns the same instance on multiple calls (memoization)' do
+        first = test_generator_class.template_renderer
+        second = test_generator_class.template_renderer
+        expect(first).to be(second)
+      end
+    end
+
+    describe '.clear_template_cache' do
+      it 'clears the template cache' do
+        test_generator_class.template_renderer # Initialize cache
+        test_generator_class.clear_template_cache
+        expect(test_generator_class.instance_variable_get(:@template_renderer)).to be_nil
+      end
+    end
+
+    describe '.template_cache_stats' do
+      it 'returns cache statistics' do
+        stats = test_generator_class.template_cache_stats
+        expect(stats).to have_key(:size)
+        expect(stats).to have_key(:entries)
+        expect(stats).to have_key(:memory_estimate)
+      end
+    end
+  end
+end
+
+RSpec.describe TemplateRenderer::PartialCache do
+  let(:generator_class) do
+    Class.new do
+      def self.source_paths
+        [File.expand_path('../fixtures/templates', __dir__)]
+      end
+    end
+  end
+
+  let(:cache) { described_class.new(generator_class) }
+  let(:test_binding) { binding }
+
+  describe '#render_partial' do
+    context 'when partial does not exist' do
+      it 'raises TemplateNotFoundError' do
+        expect do
+          cache.render_partial('nonexistent', test_binding, {})
+        end.to raise_error(TemplateRenderer::TemplateNotFoundError)
+      end
+
+      it 'includes searched paths in error message' do
+        expect do
+          cache.render_partial('missing', test_binding, {})
+        end.to raise_error(TemplateRenderer::TemplateNotFoundError, /Searched in/)
+      end
+    end
+
+    context 'when partial has syntax errors' do
+      it 'raises TemplateRenderError' do
+        # This would require a fixture file with ERB syntax errors
+        # For now, test that the error class exists
+        expect(TemplateRenderer::TemplateRenderError).to be < TemplateRenderer::TemplateError
+      end
+    end
+  end
+
+  describe '#clear' do
+    it 'clears the cache' do
+      cache.clear
+      expect(cache.stats[:size]).to eq(0)
+    end
+  end
+
+  describe '#stats' do
+    it 'returns cache statistics hash' do
+      stats = cache.stats
+      expect(stats).to be_a(Hash)
+      expect(stats).to have_key(:size)
+      expect(stats).to have_key(:entries)
+      expect(stats).to have_key(:memory_estimate)
+    end
+
+    it 'estimates memory usage' do
+      stats = cache.stats
+      expect(stats[:memory_estimate]).to be >= 0
+    end
+  end
+
+  describe 'caching behavior' do
+    it 'caches compiled ERB objects' do
+      # This test would require actual fixture files
+      # Verifies that repeated renders use cache
+      expect(cache.instance_variable_get(:@cache)).to be_a(Hash)
+    end
+  end
+end
+
+RSpec.describe TemplateRenderer::PartialResolver do
+  let(:generator_class) do
+    Class.new do
+      def self.source_paths
+        [
+          '/path/to/templates',
+          '/another/path/templates'
+        ]
+      end
+    end
+  end
+
+  let(:resolver) { described_class.new(generator_class) }
+  let(:test_binding) { binding }
+
+  describe '#resolve' do
+    it 'attempts to resolve relative to caller first' do
+      # Mock file existence check
+      allow(File).to receive(:exist?).and_return(false)
+
+      expect do
+        resolver.resolve('test', test_binding)
+      end.to raise_error(TemplateRenderer::TemplateNotFoundError)
+    end
+  end
+
+  describe '#search_paths' do
+    it 'returns all paths that were searched' do
+      paths = resolver.search_paths('screenshot', test_binding)
+
+      expect(paths).to be_an(Array)
+      expect(paths).not_to be_empty
+      expect(paths.first).to include('screenshot.tt')
+    end
+
+    it 'includes relative path if caller file is available' do
+      paths = resolver.search_paths('screenshot', test_binding)
+      # Should include relative path attempt
+      expect(paths.length).to be >= 1
+    end
+
+    it 'includes all source_paths in search' do
+      paths = resolver.search_paths('screenshot', test_binding)
+
+      # Should search in all configured source paths
+      expect(paths.any? { |p| p.include?('/path/to/templates') }).to be true
+    end
+  end
+end
+
+RSpec.describe TemplateRenderer::TemplateError do
+  describe TemplateRenderer::TemplateNotFoundError do
+    it 'formats error message with searched paths' do
+      error = described_class.new(
+        'Partial not found',
+        partial_name: 'test',
+        searched_paths: ['/path/1', '/path/2']
+      )
+
+      message = error.to_s
+      expect(message).to include("Partial 'test' not found")
+      expect(message).to include('/path/1')
+      expect(message).to include('/path/2')
+      expect(message).to include('Searched in:')
+    end
+  end
+
+  describe TemplateRenderer::TemplateRenderError do
+    it 'includes original error information' do
+      original = StandardError.new('syntax error')
+      original.set_backtrace(['line 1', 'line 2'])
+
+      error = described_class.new(
+        'Render failed',
+        partial_name: 'test',
+        original_error: original
+      )
+
+      message = error.to_s
+      expect(message).to include('Error rendering partial')
+      expect(message).to include('syntax error')
+      expect(message).to include('Backtrace:')
+    end
+  end
+end
+
+# Integration test with Generator base class
+RSpec.describe Generator do
+  it 'includes TemplateRenderer module' do
+    expect(described_class.ancestors).to include(TemplateRenderer)
+  end
+
+  it 'has partial method available' do
+    # Generator requires arguments, so we'll test the class directly
+    expect(described_class.instance_methods).to include(:partial)
+  end
+
+  it 'has template_renderer class method' do
+    expect(described_class).to respond_to(:template_renderer)
+  end
+
+  it 'has clear_template_cache class method' do
+    expect(described_class).to respond_to(:clear_template_cache)
+  end
+
+  it 'has template_cache_stats class method' do
+    expect(described_class).to respond_to(:template_cache_stats)
+  end
+end

data/spec/integration/commands/scaffolding_commands_spec.rb

@@ -18,7 +18,7 @@ describe ScaffoldingCommands do
   context 'with a spec folder' do
     let(:new_path) { 'test_folder' }
 
-    path = "#{FRAMEWORKS.last}_#{AUTOMATION_TYPES[2]}"
+    path = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
 
     before do
       Dir.chdir path
@@ -63,7 +63,7 @@ describe ScaffoldingCommands do
   context 'with a features folder' do
     let(:new_path) { 'test_folder' }
 
-    path = "#{FRAMEWORKS.first}_#{AUTOMATION_TYPES.last}"
+    path = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
 
     before do
       Dir.chdir path

data/spec/integration/commands/utility_commands_spec.rb

@@ -19,7 +19,7 @@ describe UtilityCommands do
   context 'with a spec folder' do
     let(:new_path) { 'test_folder' }
 
-    path = "#{FRAMEWORKS.last}_#{AUTOMATION_TYPES[2]}"
+    path = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
 
     before do
       Dir.chdir path
@@ -43,17 +43,37 @@ describe UtilityCommands do
       expect(config['browser']).to eql ':firefox'
     end
 
-    it 'updates the browser options', skip: 'review browser options method' do
+    it 'updates the browser options' do
       utility.new.invoke(:browser, nil, %w[:firefox --opts headless start-maximized start-fullscreen])
       config = YAML.load_file('config/config.yml')
       expect(config['browser_options']).to eql %w[headless start-maximized start-fullscreen]
     end
   end
 
+  context 'with timeout and viewport commands' do
+    path = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
+
+    before do
+      Dir.chdir path
+    end
+
+    it 'updates the timeout' do
+      utility.new.invoke(:timeout, nil, %w[30])
+      config = YAML.load_file('config/config.yml')
+      expect(config['timeout']).to eq 30
+    end
+
+    it 'updates the viewport' do
+      utility.new.invoke(:viewport, nil, %w[375x812])
+      config = YAML.load_file('config/config.yml')
+      expect(config['viewport']).to eq({ 'width' => 375, 'height' => 812 })
+    end
+  end
+
   context 'with a features folder' do
     let(:new_path) { 'test_folder' }
 
-    path = "#{FRAMEWORKS.first}_#{AUTOMATION_TYPES.last}"
+    path = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
 
     before do
       Dir.chdir path
@@ -71,7 +91,7 @@ describe UtilityCommands do
       expect(config['feature_path']).to eql path
     end
 
-    it 'updates only the browser options', skip: 'review browser options method' do
+    it 'updates only the browser options' do
       utility.new.invoke(:browser, nil, %w[:firefox --opts headless])
       config = YAML.load_file('config/config.yml')
       expect(config['browser_options']).to eql %w[headless]

data/spec/integration/content/ci_content_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative 'content_helper'
+
+describe 'CI pipeline content' do
+  # --- GitHub Actions ---
+
+  shared_examples 'valid github pipeline' do |project_name|
+    subject(:pipeline) { read_generated("#{project_name}_github", '.github/workflows/test_pipeline.yml') }
+
+    it 'is valid YAML' do
+      expect { YAML.safe_load(pipeline) }.not_to raise_error
+    end
+
+    it 'has name' do
+      expect(pipeline).to match(/^name:/)
+    end
+
+    it 'has jobs section' do
+      expect(pipeline).to include('jobs:')
+    end
+
+    it 'sets up Ruby' do
+      expect(pipeline).to include('ruby')
+    end
+
+    it 'installs dependencies' do
+      expect(pipeline).to include('bundler-cache: true').or include('bundle install')
+    end
+  end
+
+  shared_examples 'github rspec pipeline' do |project_name|
+    subject(:pipeline) { read_generated("#{project_name}_github", '.github/workflows/test_pipeline.yml') }
+
+    it 'runs rspec' do
+      expect(pipeline).to include('rspec')
+    end
+  end
+
+  shared_examples 'github cucumber pipeline' do |project_name|
+    subject(:pipeline) { read_generated("#{project_name}_github", '.github/workflows/test_pipeline.yml') }
+
+    it 'runs cucumber' do
+      expect(pipeline).to include('cucumber')
+    end
+  end
+
+  shared_examples 'github minitest pipeline' do |project_name|
+    subject(:pipeline) { read_generated("#{project_name}_github", '.github/workflows/test_pipeline.yml') }
+
+    it 'runs minitest' do
+      expect(pipeline).to match(/minitest|ruby.*test/)
+    end
+  end
+
+  context 'with rspec and selenium on github' do
+    name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
+    include_examples 'valid github pipeline', name
+    include_examples 'github rspec pipeline', name
+  end
+
+  context 'with cucumber and selenium on github' do
+    name = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
+    include_examples 'valid github pipeline', name
+    include_examples 'github cucumber pipeline', name
+  end
+
+  context 'with minitest and selenium on github' do
+    name = "#{FrameworkIndex::MINITEST}_#{AutomationIndex::SELENIUM}"
+    include_examples 'valid github pipeline', name
+    include_examples 'github minitest pipeline', name
+  end
+
+  context 'with rspec and capybara on github' do
+    name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CAPYBARA}"
+    include_examples 'valid github pipeline', name
+    include_examples 'github rspec pipeline', name
+  end
+
+  context 'with rspec and watir on github' do
+    name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::WATIR}"
+    include_examples 'valid github pipeline', name
+    include_examples 'github rspec pipeline', name
+  end
+
+  # --- GitLab CI ---
+
+  shared_examples 'valid gitlab pipeline' do |project_name|
+    subject(:pipeline) { read_generated("#{project_name}_gitlab", 'gitlab-ci.yml') }
+
+    it 'is valid YAML' do
+      expect { YAML.safe_load(pipeline) }.not_to raise_error
+    end
+
+    it 'has stages' do
+      expect(pipeline).to include('stages:')
+    end
+
+    it 'has script section' do
+      expect(pipeline).to include('script:')
+    end
+  end
+
+  context 'with rspec and selenium on gitlab' do
+    name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
+    include_examples 'valid gitlab pipeline', name
+  end
+
+  context 'with cucumber and selenium on gitlab' do
+    name = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
+    include_examples 'valid gitlab pipeline', name
+  end
+
+  context 'with minitest and selenium on gitlab' do
+    name = "#{FrameworkIndex::MINITEST}_#{AutomationIndex::SELENIUM}"
+    include_examples 'valid gitlab pipeline', name
+  end
+end