ruby_raider 1.1.4 → 2.0.0

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::APPLITOOLS}"
 
     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
@@ -53,7 +53,7 @@ describe UtilityCommands do
   context 'with a features folder' do
     let(:new_path) { 'test_folder' }
 
-    path = "#{FRAMEWORKS.first}_#{AUTOMATION_TYPES.last}"
+    path = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::APPLITOOLS}"
 
     before do
       Dir.chdir path

data/spec/integration/end_to_end_spec.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require_relative 'spec_helper'
+require 'timeout'
+require 'open3'
+
+# End-to-end integration tests that verify generated projects actually work
+# These tests:
+# 1. Generate a complete project
+# 2. Install dependencies (bundle install)
+# 3. Run the generated tests (rspec/cucumber)
+# 4. Verify tests pass
+#
+# This ensures the template system produces working, executable test frameworks
+describe 'End-to-End Project Generation and Execution' do
+  # Helper to run commands in a generated project directory
+  def run_in_project(project_name, command, timeout: 300)
+    result = {
+      success: false,
+      stdout: '',
+      stderr: '',
+      exit_code: nil
+    }
+
+    Dir.chdir(project_name) do
+      Bundler.with_unbundled_env do
+        Timeout.timeout(timeout) do
+          stdout, stderr, status = Open3.capture3(command)
+          result[:stdout] = stdout
+          result[:stderr] = stderr
+          result[:exit_code] = status.exitstatus
+          result[:success] = status.success?
+        end
+      end
+    end
+
+    result
+  rescue Timeout::Error
+    result[:stderr] = "Command timed out after #{timeout} seconds"
+    result[:exit_code] = -1
+    result
+  end
+
+  # Helper to install dependencies
+  def bundle_install(project_name)
+    puts "\n📦 Installing dependencies for #{project_name}..."
+    result = run_in_project(project_name, 'bundle install --quiet', timeout: 180)
+
+    unless result[:success]
+      puts '❌ Bundle install failed:'
+      puts result[:stderr]
+      puts result[:stdout]
+    end
+
+    result[:success]
+  end
+
+  # Helper to run RSpec tests
+  def run_rspec(project_name)
+    puts "\n🧪 Running RSpec tests in #{project_name}..."
+    result = run_in_project(project_name, 'bundle exec rspec spec/ --format documentation', timeout: 120)
+
+    puts result[:stdout] if result[:stdout].length.positive?
+
+    unless result[:success]
+      puts '❌ RSpec tests failed:'
+      puts result[:stderr] if result[:stderr].length.positive?
+    end
+
+    result
+  end
+
+  # Helper to run Cucumber tests
+  def run_cucumber(project_name)
+    puts "\n🥒 Running Cucumber tests in #{project_name}..."
+    result = run_in_project(project_name, 'bundle exec cucumber features/ --format pretty', timeout: 120)
+
+    puts result[:stdout] if result[:stdout].length.positive?
+
+    unless result[:success]
+      puts '❌ Cucumber tests failed:'
+      puts result[:stderr] if result[:stderr].length.positive?
+    end
+
+    result
+  end
+
+  # Helper to run Minitest tests
+  def run_minitest(project_name)
+    puts "\nRunning Minitest tests in #{project_name}..."
+    result = run_in_project(project_name, 'bundle exec ruby -Itest test/test_login_page.rb', timeout: 120)
+
+    puts result[:stdout] if result[:stdout].length.positive?
+
+    unless result[:success]
+      puts 'Minitest tests failed:'
+      puts result[:stderr] if result[:stderr].length.positive?
+    end
+
+    result
+  end
+
+  # Shared example for RSpec-based projects
+  shared_examples 'executable rspec project' do |project_name|
+    let(:project) { project_name }
+
+    it 'installs dependencies successfully' do
+      expect(bundle_install(project)).to be true
+    end
+
+    it 'runs generated RSpec tests successfully', :slow do
+      skip 'Bundle install failed' unless bundle_install(project)
+
+      result = run_rspec(project)
+
+      expect(result[:success]).to be(true),
+                                  "RSpec tests failed with exit code #{result[:exit_code]}.\n" \
+                                  "STDOUT: #{result[:stdout]}\n" \
+                                  "STDERR: #{result[:stderr]}"
+    end
+  end
+
+  # Shared example for Cucumber-based projects
+  shared_examples 'executable cucumber project' do |project_name|
+    let(:project) { project_name }
+
+    it 'installs dependencies successfully' do
+      expect(bundle_install(project)).to be true
+    end
+
+    it 'runs generated Cucumber tests successfully', :slow do
+      skip 'Bundle install failed' unless bundle_install(project)
+
+      result = run_cucumber(project)
+
+      expect(result[:success]).to be(true),
+                                  "Cucumber tests failed with exit code #{result[:exit_code]}.\n" \
+                                  "STDOUT: #{result[:stdout]}\n" \
+                                  "STDERR: #{result[:stderr]}"
+    end
+  end
+
+  # Shared example for Minitest-based projects
+  shared_examples 'executable minitest project' do |project_name|
+    let(:project) { project_name }
+
+    it 'installs dependencies successfully' do
+      expect(bundle_install(project)).to be true
+    end
+
+    it 'runs generated Minitest tests successfully', :slow do
+      skip 'Bundle install failed' unless bundle_install(project)
+
+      result = run_minitest(project)
+
+      expect(result[:success]).to be(true),
+                                  "Minitest tests failed with exit code #{result[:exit_code]}.\n" \
+                                  "STDOUT: #{result[:stdout]}\n" \
+                                  "STDERR: #{result[:stderr]}"
+    end
+  end
+
+  # Test Web Frameworks (these can run without external services)
+  context 'Web Automation Frameworks' do
+    describe 'Selenium + RSpec' do
+      include_examples 'executable rspec project', 'rspec_selenium'
+    end
+
+    describe 'Watir + RSpec' do
+      include_examples 'executable rspec project', 'rspec_watir'
+    end
+
+    describe 'Capybara + RSpec' do
+      include_examples 'executable rspec project', 'rspec_capybara'
+    end
+
+    describe 'Selenium + Cucumber' do
+      include_examples 'executable cucumber project', 'cucumber_selenium'
+    end
+
+    describe 'Watir + Cucumber' do
+      include_examples 'executable cucumber project', 'cucumber_watir'
+    end
+
+    describe 'Capybara + Cucumber' do
+      include_examples 'executable cucumber project', 'cucumber_capybara'
+    end
+
+    describe 'Axe + Cucumber' do
+      include_examples 'executable cucumber project', 'cucumber_axe'
+    end
+
+    describe 'Selenium + Minitest' do
+      include_examples 'executable minitest project', 'minitest_selenium'
+    end
+
+    describe 'Watir + Minitest' do
+      include_examples 'executable minitest project', 'minitest_watir'
+    end
+
+    describe 'Capybara + Minitest' do
+      include_examples 'executable minitest project', 'minitest_capybara'
+    end
+  end
+
+  # Mobile and Visual frameworks require external services, so we only verify structure
+  context 'Mobile Automation Frameworks (structure validation only)' do
+    describe 'iOS + RSpec' do
+      it 'generates valid project structure' do
+        expect(File).to exist('rspec_ios/helpers/spec_helper.rb')
+        expect(File).to exist('rspec_ios/Gemfile')
+        expect(File).to exist('rspec_ios/spec')
+      end
+
+      it 'has valid Ruby syntax in generated files' do
+        result = run_in_project('rspec_ios', 'ruby -c helpers/spec_helper.rb')
+        expect(result[:success]).to be true
+      end
+    end
+
+    describe 'Android + Cucumber' do
+      it 'generates valid project structure' do
+        expect(File).to exist('cucumber_android/features/support/env.rb')
+        expect(File).to exist('cucumber_android/Gemfile')
+        expect(File).to exist('cucumber_android/features')
+      end
+
+      it 'has valid Ruby syntax in generated files' do
+        result = run_in_project('cucumber_android', 'ruby -c features/support/env.rb')
+        expect(result[:success]).to be true
+      end
+    end
+
+    describe 'Cross-Platform + RSpec' do
+      it 'generates valid project structure' do
+        expect(File).to exist('rspec_cross_platform/helpers/appium_helper.rb')
+        expect(File).to exist('rspec_cross_platform/Gemfile')
+      end
+    end
+  end
+
+  context 'Minitest Mobile Frameworks (structure validation only)' do
+    describe 'Android + Minitest' do
+      it 'generates valid project structure' do
+        expect(File).to exist('minitest_android/helpers/test_helper.rb')
+        expect(File).to exist('minitest_android/Gemfile')
+        expect(File).to exist('minitest_android/test')
+      end
+
+      it 'has valid Ruby syntax in generated files' do
+        result = run_in_project('minitest_android', 'ruby -c helpers/test_helper.rb')
+        expect(result[:success]).to be true
+      end
+    end
+
+    describe 'iOS + Minitest' do
+      it 'generates valid project structure' do
+        expect(File).to exist('minitest_ios/helpers/test_helper.rb')
+        expect(File).to exist('minitest_ios/Gemfile')
+        expect(File).to exist('minitest_ios/test')
+      end
+
+      it 'has valid Ruby syntax in generated files' do
+        result = run_in_project('minitest_ios', 'ruby -c helpers/test_helper.rb')
+        expect(result[:success]).to be true
+      end
+    end
+  end
+
+  context 'Visual Testing Frameworks (structure validation only)' do
+    describe 'Applitools + RSpec' do
+      it 'generates valid project structure with visual helper' do
+        expect(File).to exist('rspec_applitools/helpers/visual_helper.rb')
+        expect(File).to exist('rspec_applitools/helpers/spec_helper.rb')
+      end
+
+      it 'includes Applitools dependencies' do
+        gemfile = File.read('rspec_applitools/Gemfile')
+        expect(gemfile).to include('eyes_selenium')
+      end
+
+      it 'has valid Ruby syntax in generated files' do
+        result = run_in_project('rspec_applitools', 'ruby -c helpers/visual_helper.rb')
+        expect(result[:success]).to be true
+      end
+    end
+  end
+
+  # Verify template system performance (caching working)
+  context 'Template System Performance' do
+    it 'benefits from template caching on second generation' do
+      require_relative '../../lib/generators/generator'
+
+      # Clear cache
+      Generator.clear_template_cache
+
+      # First generation (cache miss)
+      start_time = Time.now
+      settings1 = create_settings(framework: 'rspec', automation: 'selenium')
+      settings1[:name] = 'test_cache_1'
+      generate_framework(settings1)
+      first_duration = Time.now - start_time
+
+      # Second generation (cache hit)
+      start_time = Time.now
+      settings2 = create_settings(framework: 'rspec', automation: 'selenium')
+      settings2[:name] = 'test_cache_2'
+      generate_framework(settings2)
+      second_duration = Time.now - start_time
+
+      # Second generation should be faster (or similar if I/O dominates)
+      # At minimum, cache should not slow things down
+      expect(second_duration).to be <= (first_duration * 1.2)
+
+      # Cleanup
+      FileUtils.rm_rf('test_cache_1')
+      FileUtils.rm_rf('test_cache_2')
+
+      # Verify cache has entries
+      stats = Generator.template_cache_stats
+      expect(stats[:size]).to be > 0
+      puts "\n📊 Template cache: #{stats[:size]} entries, ~#{stats[:memory_estimate] / 1024}KB"
+    end
+  end
+end