passenger_spec.rb

# frozen_string_literal: true

require 'spec_helper'

describe 'apache::mod::passenger', type: :class do
  on_supported_os.each do |os, facts|
    context "on #{os}" do
      let :facts do
        facts
      end

      case facts[:os]['family']
      when 'Debian'
        context 'validating all passenger params - using Debian' do
          it { is_expected.to contain_class('apache::params') }
          it { is_expected.to contain_apache__mod('passenger') }
          it { is_expected.to contain_package('libapache2-mod-passenger') }

          it {
            expect(subject).to contain_file('zpassenger.load').with('path' => '/etc/apache2/mods-available/zpassenger.load')
          }

          it {
            expect(subject).to contain_file('passenger.conf').with('path' => '/etc/apache2/mods-available/passenger.conf')
          }

          passenger_config_options = {
            'passenger_allow_encoded_slashes' => { type: 'OnOff', pass_opt: :PassengerAllowEncodedSlashes },
            'passenger_anonymous_telemetry_proxy' => { type: 'String', pass_opt: :PassengerAnonymousTelemetryProxy },
            'passenger_admin_panel_url' => { type: 'String', pass_opt: :PassengerAdminPanelUrl },
            'passenger_admin_panel_auth_type' => { type: 'String', pass_opt: :PassengerAdminPanelAuthType },
            'passenger_admin_panel_username' => { type: 'String', pass_opt: :PassengerAdminPanelUsername },
            'passenger_admin_panel_password' => { type: 'String', pass_opt: :PassengerAdminPanelPassword },
            'passenger_app_env' => { type: 'String', pass_opt: :PassengerAppEnv },
            'passenger_app_group_name' => { type: 'String', pass_opt: :PassengerAppGroupName },
            'passenger_app_log_file' => { type: 'String', pass_opt: :PassengerAppLogFile },
            'passenger_app_root' => { type: 'FullPath', pass_opt: :PassengerAppRoot },
            'passenger_app_type' => { type: 'String', pass_opt: :PassengerAppType },
            'passenger_base_uri' => { type: 'URI', pass_opt: :PassengerBaseURI },
            'passenger_buffer_response' => { type: 'OnOff', pass_opt: :PassengerBufferResponse },
            'passenger_buffer_upload' => { type: 'OnOff', pass_opt: :PassengerBufferUpload },
            'passenger_concurrency_model' => { type: ['process', 'thread'], pass_opt: :PassengerConcurrencyModel },
            'passenger_data_buffer_dir' => { type: 'FullPath', pass_opt: :PassengerDataBufferDir },
            'passenger_debug_log_file' => { type: 'String', pass_opt: :PassengerDebugLogFile },
            'passenger_debugger' => { type: 'OnOff', pass_opt: :PassengerDebugger },
            'passenger_default_group' => { type: 'String', pass_opt: :PassengerDefaultGroup },
            'passenger_default_ruby' => { type: 'FullPath', pass_opt: :PassengerDefaultRuby },
            'passenger_default_user' => { type: 'String', pass_opt: :PassengerDefaultUser },
            'passenger_disable_anonymous_telemetry' => { type: 'Boolean', pass_opt: :PassengerDisableAnonymousTelemetry },
            'passenger_disable_log_prefix' => { type: 'Boolean', pass_opt: :PassengerDisableLogPrefix },
            'passenger_disable_security_update_check' => { type: 'OnOff', pass_opt: :PassengerDisableSecurityUpdateCheck },
            'passenger_dump_config_manifest' => { type: 'String', pass_opt: :PassengerDumpConfigManifest },
            'passenger_enabled' => { type: 'OnOff', pass_opt: :PassengerEnabled },
            'passenger_error_override' => { type: 'OnOff', pass_opt: :PassengerErrorOverride },
            'passenger_file_descriptor_log_file' => { type: 'FullPath', pass_opt: :PassengerFileDescriptorLogFile },
            'passenger_fly_with' => { type: 'FullPath', pass_opt: :PassengerFlyWith },
            'passenger_force_max_concurrent_requests_per_process' => { type: 'Integer', pass_opt: :PassengerForceMaxConcurrentRequestsPerProcess },
            'passenger_friendly_error_pages' => { type: 'OnOff', pass_opt: :PassengerFriendlyErrorPages },
            'passenger_group' => { type: 'String', pass_opt: :PassengerGroup },
            'passenger_high_performance' => { type: 'OnOff', pass_opt: :PassengerHighPerformance },
            'passenger_instance_registry_dir' => { type: 'FullPath', pass_opt: :PassengerInstanceRegistryDir },
            'passenger_load_shell_envvars' => { type: 'OnOff', pass_opt: :PassengerLoadShellEnvvars },
            'passenger_preload_bundler' => { type: 'Boolean', pass_opt: :PassengerPreloadBundler },
            'passenger_log_file' => { type: 'FullPath', pass_opt: :PassengerLogFile },
            'passenger_log_level' => { type: 'Integer', pass_opt: :PassengerLogLevel },
            'passenger_lve_min_uid' => { type: 'Integer', pass_opt: :PassengerLveMinUid },
            'passenger_max_instances' => { type: 'Integer', pass_opt: :PassengerMaxInstances },
            'passenger_max_instances_per_app' => { type: 'Integer', pass_opt: :PassengerMaxInstancesPerApp },
            'passenger_max_pool_size' => { type: 'Integer', pass_opt: :PassengerMaxPoolSize },
            'passenger_max_preloader_idle_time' => { type: 'Integer', pass_opt: :PassengerMaxPreloaderIdleTime },
            'passenger_max_request_queue_size' => { type: 'Integer', pass_opt: :PassengerMaxRequestQueueSize },
            'passenger_max_request_queue_time' => { type: 'Integer', pass_opt: :PassengerMaxRequestQueueTime },
            'passenger_max_request_time' => { type: 'Integer', pass_opt: :PassengerMaxRequestTime },
            'passenger_max_requests' => { type: 'Integer', pass_opt: :PassengerMaxRequests },
            'passenger_memory_limit' => { type: 'Integer', pass_opt: :PassengerMemoryLimit },
            'passenger_meteor_app_settings' => { type: 'FullPath', pass_opt: :PassengerMeteorAppSettings },
            'passenger_min_instances' => { type: 'Integer', pass_opt: :PassengerMinInstances },
            'passenger_nodejs' => { type: 'FullPath', pass_opt: :PassengerNodejs },
            'passenger_pool_idle_time' => { type: 'Integer', pass_opt: :PassengerPoolIdleTime },
            'passenger_pre_start' => { type: 'URI', pass_opt: :PassengerPreStart },
            'passenger_python' => { type: 'FullPath', pass_opt: :PassengerPython },
            'passenger_resist_deployment_errors' => { type: 'OnOff', pass_opt: :PassengerResistDeploymentErrors },
            'passenger_resolve_symlinks_in_document_root' => { type: 'OnOff', pass_opt: :PassengerResolveSymlinksInDocumentRoot },
            'passenger_response_buffer_high_watermark' => { type: 'Integer', pass_opt: :PassengerResponseBufferHighWatermark },
            'passenger_restart_dir' => { type: 'Path', pass_opt: :PassengerRestartDir },
            'passenger_rolling_restarts' => { type: 'OnOff', pass_opt: :PassengerRollingRestarts },
            'passenger_root' => { type: 'FullPath', pass_opt: :PassengerRoot },
            'passenger_ruby' => { type: 'FullPath', pass_opt: :PassengerRuby },
            'passenger_security_update_check_proxy' => { type: 'URI', pass_opt: :PassengerSecurityUpdateCheckProxy },
            'passenger_show_version_in_header' => { type: 'OnOff', pass_opt: :PassengerShowVersionInHeader },
            'passenger_socket_backlog' => { type: 'Integer', pass_opt: :PassengerSocketBacklog },
            'passenger_spawn_dir' => { type: 'FullPath', pass_opt: :PassengerSpawnDir },
            'passenger_spawn_method' => { type: ['smart', 'direct'], pass_opt: :PassengerSpawnMethod },
            'passenger_start_timeout' => { type: 'Integer', pass_opt: :PassengerStartTimeout },
            'passenger_startup_file' => { type: 'RelPath', pass_opt: :PassengerStartupFile },
            'passenger_stat_throttle_rate' => { type: 'Integer', pass_opt: :PassengerStatThrottleRate },
            'passenger_sticky_sessions' => { type: 'OnOff', pass_opt: :PassengerStickySessions },
            'passenger_sticky_sessions_cookie_name' => { type: 'String', pass_opt: :PassengerStickySessionsCookieName },
            'passenger_sticky_sessions_cookie_attributes' => { type: 'QuotedString', pass_opt: :PassengerStickySessionsCookieAttributes },
            'passenger_thread_count' => { type: 'Integer', pass_opt: :PassengerThreadCount },
            'passenger_use_global_queue' => { type: 'String', pass_opt: :PassengerUseGlobalQueue },
            'passenger_user' => { type: 'String', pass_opt: :PassengerUser },
            'passenger_user_switching' => { type: 'OnOff', pass_opt: :PassengerUserSwitching },
            'rack_autodetect' => { type: 'String', pass_opt: :RackAutoDetect },
            'rack_env' => { type: 'String', pass_opt: :RackEnv },
            'rails_autodetect' => { type: 'String', pass_opt: :RailsAutoDetect },
            'rails_env' => { type: 'String', pass_opt: :RailsEnv },
            'rails_framework_spawner_idle_time' => { type: 'String', pass_opt: :RailsFrameworkSpawnerIdleTime }
          }
          passenger_config_options.each do |config_option, config_hash|
            puppetized_config_option = config_option
            case config_hash[:type]
              # UnionStationFilter values are quoted strings
            when 'QuotedString'
              valid_config_values = ['"a quoted string"']
              valid_config_values.each do |valid_value|
                describe "with #{puppetized_config_option} => '#{valid_value.delete('"')}'" do
                  let :params do
                    { puppetized_config_option.to_sym => valid_value }
                  end

                  it { is_expected.to contain_file('passenger.conf').with_content(%r{^  #{config_hash[:pass_opt]} "#{valid_value}"$}) }
                end
              end
            when 'FullPath', 'RelPath', 'Path'
              valid_config_values = ['/some/path/to/somewhere']
              valid_config_values.each do |valid_value|
                describe "with #{puppetized_config_option} => #{valid_value}" do
                  let :params do
                    { puppetized_config_option.to_sym => valid_value }
                  end

                  it { is_expected.to contain_file('passenger.conf').with_content(%r{^  #{config_hash[:pass_opt]} "#{valid_value}"$}) }
                end
              end
            when 'URI', 'String'
              valid_config_values = ['some_value_for_you']
              valid_config_values.each do |valid_value|
                describe "with #{puppetized_config_option} => #{valid_value}" do
                  let :params do
                    { puppetized_config_option.to_sym => valid_value }
                  end

                  it { is_expected.to contain_file('passenger.conf').with_content(%r{^  #{config_hash[:pass_opt]} #{valid_value}$}) }
                end
              end
            when 'Integer'
              valid_config_values = [4711]
              valid_config_values.each do |valid_value|
                describe "with #{puppetized_config_option} => #{valid_value}" do
                  let :params do
                    { puppetized_config_option.to_sym => valid_value }
                  end

                  it { is_expected.to contain_file('passenger.conf').with_content(%r{^  #{config_hash[:pass_opt]} #{valid_value}$}) }
                end
              end
            when 'OnOff'
              valid_config_values = ['on', 'off']
              valid_config_values.each do |valid_value|
                describe "with #{puppetized_config_option} => '#{valid_value}'" do
                  let :params do
                    { puppetized_config_option.to_sym => valid_value }
                  end

                  it { is_expected.to contain_file('passenger.conf').with_content(%r{^  #{config_hash[:pass_opt]} #{valid_value}$}) }
                end
              end
            when 'Boolean'
              valid_config_values = [true, false]
              valid_config_values.each do |valid_value|
                describe "with #{puppetized_config_option} => #{valid_value}" do
                  let :params do
                    { puppetized_config_option.to_sym => valid_value }
                  end

                  let :expected_value do
                    {
                      true => 'On',
                      false => 'Off'
                    }[valid_value]
                  end

                  it { is_expected.to contain_file('passenger.conf').with_content(%r{^  #{config_hash[:pass_opt]} #{expected_value}$}) }
                end
              end
            else
              valid_config_values = config_hash[:type]
              valid_config_values.each do |valid_value|
                describe "with #{puppetized_config_option} => '#{valid_value}'" do
                  let :params do
                    { puppetized_config_option.to_sym => valid_value }
                  end

                  it { is_expected.to contain_file('passenger.conf').with_content(%r{^  #{config_hash[:pass_opt]} #{valid_value}$}) }
                end
              end
            end
          end
        end

        it { is_expected.to contain_class('apache::params') }
        it { is_expected.to contain_apache__mod('passenger') }
        it { is_expected.to contain_package('libapache2-mod-passenger') }

        it {
          expect(subject).to contain_file('zpassenger.load').with('path' => '/etc/apache2/mods-available/zpassenger.load')
        }

        it {
          expect(subject).to contain_file('passenger.conf').with('path' => '/etc/apache2/mods-available/passenger.conf')
        }

        context 'passenger config with passenger_installed_version set', test: true do
          describe 'fails when an option is not valid for $passenger_installed_version' do
            let :params do
              {
                passenger_installed_version: '4.0.0',
                passenger_instance_registry_dir: '/some/path/to/nowhere'
              }
            end

            it { is_expected.to raise_error(%r{passenger_instance_registry_dir is not introduced until version 5.0.0}) }
          end

          describe 'fails when an option is removed' do
            let :params do
              {
                passenger_installed_version: '5.0.0',
                rails_autodetect: 'on'
              }
            end

            it { is_expected.to raise_error(%r{REMOVED PASSENGER OPTION}) }
          end

          describe 'warns when an option is deprecated' do
            let :params do
              {
                passenger_installed_version: '5.0.0',
                passenger_ruby: '/some/path/to/ruby'
              }
            end

            specify { expect { warn(%r{DEPRECATED PASSENGER OPTION}) }.to output(%r{DEPRECATED PASSENGER OPTION}).to_stderr }
          end
        end

        describe "with passenger_root => '/usr/lib/example'" do
          let :params do
            { passenger_root: '/usr/lib/example' }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{PassengerRoot "/usr/lib/example"}) }
        end

        describe 'with passenger_ruby => /usr/lib/example/ruby' do
          let :params do
            { passenger_ruby: '/usr/lib/example/ruby' }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{PassengerRuby "/usr/lib/example/ruby"}) }
        end

        describe 'with passenger_default_ruby => /usr/lib/example/ruby1.9.3' do
          let :params do
            { passenger_ruby: '/usr/lib/example/ruby1.9.3' }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{PassengerRuby "/usr/lib/example/ruby1.9.3"}) }
        end

        describe 'with passenger_high_performance => on' do
          let :params do
            { passenger_high_performance: 'on' }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerHighPerformance on$}) }
        end

        describe 'with passenger_pool_idle_time => 1200' do
          let :params do
            { passenger_pool_idle_time: 1200 }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerPoolIdleTime 1200$}) }
        end

        describe 'with passenger_max_request_queue_size => 100' do
          let :params do
            { passenger_max_request_queue_size: 100 }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerMaxRequestQueueSize 100$}) }
        end

        describe 'with passenger_max_requests => 20' do
          let :params do
            { passenger_max_requests: 20 }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerMaxRequests 20$}) }
        end

        describe 'with passenger_spawn_method => direct' do
          let :params do
            { passenger_spawn_method: 'direct' }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerSpawnMethod direct$}) }
        end

        describe 'with passenger_stat_throttle_rate => 10' do
          let :params do
            { passenger_stat_throttle_rate: 10 }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerStatThrottleRate 10$}) }
        end

        describe 'with passenger_max_pool_size => 16' do
          let :params do
            { passenger_max_pool_size: 16 }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerMaxPoolSize 16$}) }
        end

        describe 'with passenger_min_instances => 5' do
          let :params do
            { passenger_min_instances: 5 }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerMinInstances 5$}) }
        end

        describe 'with passenger_max_instances_per_app => 8' do
          let :params do
            { passenger_max_instances_per_app: 8 }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerMaxInstancesPerApp 8$}) }
        end

        describe 'with rack_autodetect => on' do
          let :params do
            { rack_autodetect: 'on' }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  RackAutoDetect on$}) }
        end

        describe 'with rails_autodetect => on' do
          let :params do
            { rails_autodetect: 'on' }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  RailsAutoDetect on$}) }
        end

        describe 'with passenger_use_global_queue => on' do
          let :params do
            { passenger_use_global_queue: 'on' }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerUseGlobalQueue on$}) }
        end

        describe "with passenger_app_env => 'foo'" do
          let :params do
            { passenger_app_env: 'foo' }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerAppEnv foo$}) }
        end

        describe "with passenger_log_file => '/var/log/apache2/passenger.log'" do
          let :params do
            { passenger_log_file: '/var/log/apache2/passenger.log' }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerLogFile "/var/log/apache2/passenger.log"$}) }
        end

        describe 'with passenger_log_level => 3' do
          let :params do
            { passenger_log_level: 3 }
          end

          it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerLogLevel 3$}) }
        end

        describe "with mod_path => '/usr/lib/foo/mod_foo.so'" do
          let :params do
            { mod_path: '/usr/lib/foo/mod_foo.so' }
          end

          it { is_expected.to contain_file('zpassenger.load').with_content(%r{^LoadModule passenger_module /usr/lib/foo/mod_foo\.so$}) }
        end

        describe "with mod_lib_path => '/usr/lib/foo'" do
          let :params do
            { mod_lib_path: '/usr/lib/foo' }
          end

          it { is_expected.to contain_file('zpassenger.load').with_content(%r{^LoadModule passenger_module /usr/lib/foo/mod_passenger\.so$}) }
        end

        describe "with mod_lib => 'mod_foo.so'" do
          let :params do
            { mod_lib: 'mod_foo.so' }
          end

          it { is_expected.to contain_file('zpassenger.load').with_content(%r{^LoadModule passenger_module /usr/lib/apache2/modules/mod_foo\.so$}) }
        end

        describe "with mod_id => 'mod_foo'" do
          let :params do
            { mod_id: 'mod_foo' }
          end

          it { is_expected.to contain_file('zpassenger.load').with_content(%r{^LoadModule mod_foo /usr/lib/apache2/modules/mod_passenger\.so$}) }
        end

        context 'with defaults' do
          it { is_expected.to contain_file('passenger.conf').with_content(%r{PassengerRoot "/usr/lib/ruby/vendor_ruby/phusion_passenger/locations.ini"}) }
          it { is_expected.to contain_file('passenger.conf').without_content(%r{PassengerRuby}) }
          it { is_expected.to contain_file('passenger.conf').with_content(%r{PassengerDefaultRuby "/usr/bin/ruby"}) }
        end
      when 'RedHat'
        context 'on a RedHat OS' do
          case facts[:os]['release']['major']
          when '6'
            context 'on EL6' do
              it { is_expected.to contain_class('apache::params') }
              it { is_expected.to contain_apache__mod('passenger') }
              it { is_expected.to contain_package('mod_passenger') }

              it {
                expect(subject).to contain_file('passenger_package.conf').with('path' => '/etc/httpd/conf.d/passenger.conf')
              }

              it { is_expected.to contain_file('passenger_package.conf').without_content }
              it { is_expected.to contain_file('passenger_package.conf').without_source }

              it {
                expect(subject).to contain_file('zpassenger.load').with('path' => '/etc/httpd/conf.d/zpassenger.load')
              }

              it { is_expected.to contain_file('passenger.conf').without_content(%r{PassengerRoot}) }
              it { is_expected.to contain_file('passenger.conf').without_content(%r{PassengerRuby}) }

              describe "with passenger_root => '/usr/lib/example'" do
                let :params do
                  { passenger_root: '/usr/lib/example' }
                end

                it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerRoot "/usr/lib/example"$}) }
              end

              describe 'with passenger_ruby => /usr/lib/example/ruby' do
                let :params do
                  { passenger_ruby: '/usr/lib/example/ruby' }
                end

                it { is_expected.to contain_file('passenger.conf').with_content(%r{^  PassengerRuby "/usr/lib/example/ruby"$}) }
              end
            end
          when '7'

            context 'on EL7' do
              it {
                expect(subject).to contain_file('passenger_package.conf').with('path' => '/etc/httpd/conf.d/passenger.conf')
              }

              it {
                expect(subject).to contain_file('zpassenger.load').with('path' => '/etc/httpd/conf.modules.d/zpassenger.load')
              }
            end
          when '8'

            context 'on EL8' do
              it {
                expect(subject).to contain_file('passenger_package.conf').with('path' => '/etc/httpd/conf.d/passenger.conf')
              }

              it {
                expect(subject).to contain_file('zpassenger.load').with('path' => '/etc/httpd/conf.modules.d/zpassenger.load')
              }
            end
          end
        end
      when 'FreeBSD'
        context 'on a FreeBSD OS' do
          it { is_expected.to contain_class('apache::params') }
          it { is_expected.to contain_apache__mod('passenger') }
          it { is_expected.to contain_package('www/rubygem-passenger') }
        end
      when 'Gentoo'
        context 'on a Gentoo OS' do
          it { is_expected.to contain_class('apache::params') }
          it { is_expected.to contain_apache__mod('passenger') }
          it { is_expected.to contain_package('www-apache/passenger') }
        end
      end
    end
  end
end