From 18a62b71641bfc5498429a55e1ac85bd0b67fd72 Mon Sep 17 00:00:00 2001
From: Dmitri Dolguikh <dmitri@appliedlogic.ca>
Date: Mon, 16 May 2016 10:59:30 +0100
Subject: [PATCH] Fixes #15025 - do not show foreman_proxy startup messages.

---
 config.ru                               |   2 +-
 lib/launcher.rb                         |   8 +-
 lib/proxy/pluggable.rb                  |  19 ++--
 lib/proxy/plugin.rb                     |  16 +---
 lib/proxy/plugin_initializer.rb         | 114 ++++++++++++++++--------
 lib/proxy/plugins.rb                    |  23 ++++-
 modules/root/root.rb                    |   1 +
 modules/root/root_api.rb                |   9 +-
 modules/root/root_module_loader.rb      |  11 +++
 modules/root/root_plugin.rb             |   5 +-
 test/plugins/module_loader_test.rb      |   5 +-
 test/plugins/plugin_group_test.rb       |  72 +++++++++++++--
 test/plugins/plugin_initializer_test.rb |  13 +--
 test/plugins/plugin_test.rb             |  33 -------
 test/root/root_api_test.rb              |  18 ++--
 15 files changed, 224 insertions(+), 125 deletions(-)
 create mode 100644 modules/root/root_module_loader.rb

diff --git a/config.ru b/config.ru
index 67deef8c4..fd0118a81 100644
--- a/config.ru
+++ b/config.ru
@@ -2,4 +2,4 @@ $LOAD_PATH.unshift *Dir[File.expand_path("../lib", __FILE__), File.expand_path("
 
 require 'smart_proxy_main'
 ::Proxy::PluginInitializer.new(::Proxy::Plugins.instance).initialize_plugins
-::Proxy::Plugins.instance.enabled_plugins.each {|p| instance_eval(p.https_rackup)}
+::Proxy::Plugins.instance.select {|p| p[:state] == :running && p[:https_enabled]}.each {|p| instance_eval(p[:class].https_rackup)}
diff --git a/lib/launcher.rb b/lib/launcher.rb
index 52a3cf13f..de97385ad 100644
--- a/lib/launcher.rb
+++ b/lib/launcher.rb
@@ -17,8 +17,8 @@ def https_enabled?
     def http_app
       return nil if SETTINGS.http_port.nil?
       app = Rack::Builder.new do
-        ::Proxy::Plugins.instance.enabled_plugins.each do |p|
-          instance_eval(p.http_rackup)
+        ::Proxy::Plugins.instance.select {|p| p[:state] == :running && p[:http_enabled]}.each do |p|
+          instance_eval(p[:class].http_rackup)
         end
       end
 
@@ -38,7 +38,9 @@ def https_app
         nil
       else
         app = Rack::Builder.new do
-          ::Proxy::Plugins.instance.enabled_plugins.each {|p| instance_eval(p.https_rackup)}
+          ::Proxy::Plugins.instance.select {|p| p[:state] == :running && p[:https_enabled]}.each do |p|
+            instance_eval(p[:class].https_rackup)
+          end
         end
 
         ssl_options = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
diff --git a/lib/proxy/pluggable.rb b/lib/proxy/pluggable.rb
index 83d4be7e6..5624bd6d9 100644
--- a/lib/proxy/pluggable.rb
+++ b/lib/proxy/pluggable.rb
@@ -1,3 +1,5 @@
+require 'ostruct'
+
 module Proxy::Pluggable
   attr_reader :plugin_name, :version, :after_activation_blk
 
@@ -25,7 +27,6 @@ def settings_file(apath = nil)
   end
 
   def default_settings(a_hash = {})
-    @settings = nil
     @plugin_default_settings ||= {}
     @plugin_default_settings.merge!(a_hash)
   end
@@ -51,6 +52,15 @@ def validate(*settings)
     settings.each {|setting| validations << {:name => validator_name, :predicate => predicate, :args => validator_args, :setting => setting} }
   end
 
+  def override_module_loader_class(a_class_or_a_class_name)
+    @module_loader_class = case a_class_or_a_class_name
+                           when String
+                             eval(a_class_or_a_class_name)
+                           else
+                             a_class_or_a_class_name
+                           end
+  end
+
   def load_validators(hash_of_validators)
     @custom_validators = hash_of_validators
   end
@@ -75,12 +85,9 @@ def start_services(*di_labels)
   # End of DSL
   #
 
+  attr_writer :settings
   def settings
-    @settings ||= Proxy::Settings.load_plugin_settings(plugin_default_settings, settings_file)
-  end
-
-  def settings=(arg)
-    @settings = arg
+    @settings ||= OpenStruct.new
   end
 
   def module_loader_class
diff --git a/lib/proxy/plugin.rb b/lib/proxy/plugin.rb
index 7320496bf..76fdd7f1f 100644
--- a/lib/proxy/plugin.rb
+++ b/lib/proxy/plugin.rb
@@ -37,22 +37,10 @@ class ::Proxy::Plugin
   class << self
     attr_reader :get_http_rackup_path, :get_https_rackup_path, :get_uses_provider
 
-    def enabled
-      @enabled ||= settings.enabled
-    end
-
-    def http_enabled?
-      [true,'http'].include?(self.enabled)
-    end
-
     def http_rackup_path(path)
       @get_http_rackup_path = path
     end
 
-    def https_enabled?
-      [true,'https'].include?(self.enabled)
-    end
-
     def https_rackup_path(path)
       @get_https_rackup_path = path
     end
@@ -73,11 +61,11 @@ def uses_provider?
     end
 
     def http_rackup
-      (http_enabled? && get_http_rackup_path) ? File.read(get_http_rackup_path) : ""
+      get_http_rackup_path ? File.read(get_http_rackup_path) : ""
     end
 
     def https_rackup
-      (https_enabled? && get_https_rackup_path) ? File.read(get_https_rackup_path) : ""
+      get_https_rackup_path ? File.read(get_https_rackup_path) : ""
     end
   end
 end
diff --git a/lib/proxy/plugin_initializer.rb b/lib/proxy/plugin_initializer.rb
index 6e6bb8a4a..78768b950 100644
--- a/lib/proxy/plugin_initializer.rb
+++ b/lib/proxy/plugin_initializer.rb
@@ -7,17 +7,27 @@ class ::Proxy::PluginGroup
 
   def initialize(a_plugin, providers = [], di_container = ::Proxy::DependencyInjection::Container.new)
     @plugin = a_plugin
-    @state = :starting
+    @state = :uninitialized # :uninitialized -> :starting -> :running, or :uninitialized -> :disabled, or :uninitialized -> :starting -> :failed
     @providers = providers
     @di_container = di_container
+    @http_enabled = false
+    @https_enabled = false
   end
 
-  def failed?
-    @state == :failed
+  def inactive?
+    @state == :failed || @state == :disabled
+  end
+
+  def http_enabled?
+    @http_enabled
+  end
+
+  def https_enabled?
+    @https_enabled
   end
 
   def resolve_providers(all_plugins_and_providers)
-    return if failed?
+    return if inactive?
     return unless @plugin.uses_provider?
 
     used_providers = [@plugin.settings.use_provider].flatten.map(&:to_sym)
@@ -47,22 +57,35 @@ def printable_module_names(names)
   end
 
   def load_plugin_settings
-    plugin.module_loader_class.new(plugin, di_container).load_settings
+    settings = plugin.module_loader_class.new(plugin, di_container).load_settings
+    update_group_initial_state(settings[:enabled])
   rescue Exception => e
     fail_group(e)
   end
 
+  def update_group_initial_state(enabled_setting)
+    @http_enabled = [true, 'http'].include?(enabled_setting) ? true : false
+    @https_enabled = [true, 'https'].include?(enabled_setting) ? true : false
+    @state = (http_enabled? || https_enabled?) ? :starting : :disabled
+  end
+
+  def set_group_state_to_failed
+    @http_enabled = false
+    @https_enabled = false
+    @state =  :failed
+  end
+
   def load_provider_settings
-    return if failed?
+    return if inactive?
     providers.each do |p|
-        p.module_loader_class.new(p, di_container).load_settings(plugin.settings.marshal_dump)
+      p.module_loader_class.new(p, di_container).load_settings(plugin.settings.marshal_dump)
     end
   rescue Exception => e
     fail_group(e)
   end
 
   def configure
-    return if failed?
+    return if inactive?
     members.each {|p| p.module_loader_class.new(p, di_container).configure_plugin }
     @state = :running
   rescue Exception => e
@@ -75,7 +98,7 @@ def fail_group(an_exception)
   end
 
   def fail_group_with_message(a_message, a_backtrace = nil)
-    @state = :failed
+    set_group_state_to_failed
     logger.error(a_message, a_backtrace)
     members.each do |m|
       ::Proxy::LogBuffer::Buffer.instance.failed_module(m.plugin_name, a_message)
@@ -114,15 +137,16 @@ def initialize(plugins)
   end
 
   def initialize_plugins
-    # find all enabled plugins
-    enabled_plugins = plugins.loaded.select {|plugin| plugin[:class].ancestors.include?(::Proxy::Plugin) && plugin[:class].enabled}
+    loaded_plugins = plugins.loaded.select {|plugin| plugin[:class].ancestors.include?(::Proxy::Plugin)}
 
-    grouped_with_providers = enabled_plugins.map {|p| ::Proxy::PluginGroup.new(p[:class], [], Proxy::DependencyInjection::Container.new)}
+    grouped_with_providers = loaded_plugins.map {|p| ::Proxy::PluginGroup.new(p[:class], [], Proxy::DependencyInjection::Container.new)}
 
-    update_plugin_states(plugins, grouped_with_providers)
+    plugins.update(current_state_of_modules(plugins.loaded, grouped_with_providers))
 
     # load main plugin settings, as this may affect which providers will be selected
-    grouped_with_providers.each {|group| group.load_plugin_settings }
+    grouped_with_providers.each {|group| group.load_plugin_settings}
+
+    plugins.update(current_state_of_modules(plugins.loaded, grouped_with_providers))
 
     #resolve provider names to classes
     grouped_with_providers.each {|group| group.resolve_providers(plugins.loaded)}
@@ -130,34 +154,42 @@ def initialize_plugins
     # load provider plugin settings
     grouped_with_providers.each {|group| group.load_provider_settings }
 
+    plugins.update(current_state_of_modules(plugins.loaded, grouped_with_providers))
+
     # configure each plugin & providers
     grouped_with_providers.each {|group| group.configure }
 
     # check prerequisites
     all_enabled = all_enabled_plugins_and_providers(grouped_with_providers)
     grouped_with_providers.each do |group|
-      next if group.failed?
+      next if group.inactive?
       group.validate_dependencies_or_fail(all_enabled)
     end
 
-    update_plugin_states(plugins, grouped_with_providers)
+    plugins.update(current_state_of_modules(plugins.loaded, grouped_with_providers))
   end
 
-  def update_plugin_states(all_plugins, all_groups)
-    to_update = all_plugins.loaded.dup
+  def current_state_of_modules(all_plugins, all_groups)
+    to_update = all_plugins.dup
     all_groups.each do |group|
-      group.members.each do |group_member|
+      # note that providers do not use http_enabled and https_enabled
+      updated = to_update.find {|loaded_plugin| loaded_plugin[:name] == group.plugin.plugin_name}
+      updated[:di_container] = group.di_container
+      updated[:state] = group.state
+      updated[:http_enabled] = group.http_enabled?
+      updated[:https_enabled] = group.https_enabled?
+      group.providers.each do |group_member|
         updated = to_update.find {|loaded_plugin| loaded_plugin[:name] == group_member.plugin_name}
         updated[:di_container] = group.di_container
         updated[:state] = group.state
       end
     end
-    all_plugins.update(to_update)
+    to_update
   end
 
   def all_enabled_plugins_and_providers(all_groups)
     all_groups.inject({}) do |all, group|
-      group.members.each {|p| all[p.plugin_name] = p} unless group.failed?
+      group.members.each {|p| all[p.plugin_name] = p} unless group.inactive?
       all
     end
   end
@@ -200,8 +232,11 @@ def start_services(services, container)
 
 module ::Proxy::DefaultSettingsLoader
   def load_settings(main_plugin_settings = {})
-    settings_file_config = load_configuration(plugin.settings_file)
-    merged_with_defaults = plugin.default_settings.merge(settings_file_config)
+    config_file_settings = load_configuration_file(plugin.settings_file)
+
+    merged_with_defaults = plugin.default_settings.merge(config_file_settings)
+
+    return merged_with_defaults unless module_enabled?(merged_with_defaults)
 
     # load dependencies before loading custom settings and running validators -- they may need those classes
     ::Proxy::BundlerHelper.require_groups(:default, plugin.bundler_group_name)
@@ -211,13 +246,29 @@ def load_settings(main_plugin_settings = {})
     settings = load_programmable_settings(config_merged_with_main)
 
     plugin.settings = ::Proxy::Settings::Plugin.new({}, settings)
-    logger.debug("'#{plugin.plugin_name}' settings: #{used_settings(settings)}")
+
+    log_used_settings(settings)
 
     validate_settings(plugin, settings)
 
     settings
   end
 
+  def module_enabled?(user_settings)
+    return true if plugin.ancestors.include?(::Proxy::Provider)
+    !!user_settings[:enabled]
+  end
+
+  def load_configuration_file(settings_file)
+    begin
+      settings = Proxy::Settings.read_settings_file(settings_file)
+    rescue Errno::ENOENT
+      logger.warn("Couldn't find settings file #{::Proxy::SETTINGS.settings_directory}/#{settings_file}. Using default settings.")
+      settings = {}
+    end
+    settings
+  end
+
   def merge_settings(provider_settings, main_plugin_settings)
     main_plugin_settings.delete(:enabled)
     # all modules have 'enabled' setting, we ignore it when looking for duplicate setting names
@@ -227,20 +278,11 @@ def merge_settings(provider_settings, main_plugin_settings)
     provider_settings.merge(main_plugin_settings)
   end
 
-  def used_settings(settings)
+  def log_used_settings(settings)
     default_settings = plugin.plugin_default_settings
     sorted_keys = settings.keys.map(&:to_s).sort.map(&:to_sym) # ruby 1.8.7 doesn't support sorting of symbols
-    sorted_keys.map {|k| "'%s': %s%s" % [k, settings[k], (default_settings.include?(k) && default_settings[k] == settings[k]) ? " (default)" : ""] }.join(", ")
-  end
-
-  def load_configuration(settings_file)
-    begin
-      settings = Proxy::Settings.read_settings_file(settings_file)
-    rescue Errno::ENOENT
-      logger.warn("Couldn't find settings file #{::Proxy::SETTINGS.settings_directory}/#{settings_file}. Using default settings.")
-      settings = {}
-    end
-    settings
+    to_log = sorted_keys.map {|k| "'%s': %s%s" % [k, settings[k], (default_settings.include?(k) && default_settings[k] == settings[k]) ? " (default)" : ""] }.join(", ")
+    logger.debug "'%s' settings: %s" % [plugin.plugin_name, to_log]
   end
 
   def load_programmable_settings(settings)
diff --git a/lib/proxy/plugins.rb b/lib/proxy/plugins.rb
index 90ba70e01..986d39e1c 100644
--- a/lib/proxy/plugins.rb
+++ b/lib/proxy/plugins.rb
@@ -15,8 +15,19 @@ def plugin_loaded(a_name, a_version, a_class)
     self.loaded += [{:name => a_name, :version => a_version, :class => a_class, :state => :uninitialized}]
   end
 
+  #
+  # each element of the list is a hash containing:
+  #
+  # :name: module name
+  # :version: module version
+  # :class: module class
+  # :state: one of :unitialized, :loaded, :staring, :running, :disabled, or :failed
+  # :di_container: dependency injection container used by the module
+  # :http_enabled: true or false (not used by providers)
+  # :https_enabled: true or false (not used by providers)
+  #
   def loaded
-    @loaded ||= [] # {:name, :version, :class, :factory, :state, :di_container}
+    @loaded ||= []
   end
 
   def loaded=(an_array)
@@ -36,14 +47,20 @@ def find
     end
   end
 
-  def enabled_plugins
-    loaded.select {|p| p[:state] == :running && p[:class].ancestors.include?(::Proxy::Plugin)}.map{|p| p[:class]}
+  def select
+    loaded.select do |plugin|
+      yield plugin
+    end
   end
 
   #
   # below are methods that are going to be removed/deprecated
   #
 
+  def enabled_plugins
+    loaded.select {|p| p[:state] == :running && p[:class].ancestors.include?(::Proxy::Plugin)}.map{|p| p[:class]}
+  end
+
   def plugin_enabled?(plugin_name)
     plugin = loaded.find {|p| p[:name] == plugin_name.to_sym}
     plugin.nil? ? false : plugin[:state] == :running
diff --git a/modules/root/root.rb b/modules/root/root.rb
index 31ac4ad42..37310fa29 100644
--- a/modules/root/root.rb
+++ b/modules/root/root.rb
@@ -1 +1,2 @@
+require 'root/root_module_loader'
 require 'root/root_plugin'
diff --git a/modules/root/root_api.rb b/modules/root/root_api.rb
index aa29b5546..e0bf76ad3 100644
--- a/modules/root/root_api.rb
+++ b/modules/root/root_api.rb
@@ -3,10 +3,10 @@ class Proxy::RootApi < Sinatra::Base
 
   get "/features" do
     begin
-      plugin_names = ::Proxy::Plugins.instance.enabled_plugins.collect(&:plugin_name).collect(&:to_s).sort
-      @features = plugin_names - ['foreman_proxy']
+      enabled_plugins = ::Proxy::Plugins.instance.select {|p| p[:state] == :running && p[:class].ancestors.include?(::Proxy::Plugin)}
+      enabled_plugin_names = (enabled_plugins.map {|p| p[:name].to_s} - ['foreman_proxy']).sort
       content_type :json
-      @features.to_json
+      enabled_plugin_names.to_json
     rescue => e
       log_halt 400, e
     end
@@ -15,7 +15,8 @@ class Proxy::RootApi < Sinatra::Base
   get "/version" do
     begin
       content_type :json
-      modules = Hash[::Proxy::Plugins.instance.enabled_plugins.collect {|plugin| [plugin.plugin_name.to_s, plugin.version.to_s]}].reject { |key| key == 'foreman_proxy' }
+      enabled_plugins = ::Proxy::Plugins.instance.select {|p| p[:state] == :running && p[:class].ancestors.include?(::Proxy::Plugin)}
+      modules = Hash[enabled_plugins.map {|plugin| [plugin[:name].to_s, plugin[:version].to_s]}].reject { |key| key == 'foreman_proxy' }
       {:version => Proxy::VERSION, :modules => modules}.to_json
     rescue => e
       log_halt 400, e
diff --git a/modules/root/root_module_loader.rb b/modules/root/root_module_loader.rb
new file mode 100644
index 000000000..ba9fd2b8d
--- /dev/null
+++ b/modules/root/root_module_loader.rb
@@ -0,0 +1,11 @@
+class ::Proxy::RootPluginLoader < ::Proxy::DefaultModuleLoader
+  # this is a special case: 'root' module doesn't have configuration file
+  def load_configuration_file(settings_file)
+    {}
+  end
+
+  # no need to log setting for this module as they aren't user-configurable and never change
+  def log_used_settings(settings)
+    # noop
+  end
+end
diff --git a/modules/root/root_plugin.rb b/modules/root/root_plugin.rb
index 1079ab49e..b51b240f8 100644
--- a/modules/root/root_plugin.rb
+++ b/modules/root/root_plugin.rb
@@ -5,8 +5,5 @@ class ::Proxy::RootPlugin < ::Proxy::Plugin
   http_rackup_path File.expand_path("http_config.ru", File.expand_path("../", __FILE__))
   https_rackup_path File.expand_path("http_config.ru", File.expand_path("../", __FILE__))
 
-  # this is a special case: 'root' module doesn't have configuration file
-  def self.settings
-    @settings ||= ::Proxy::Settings::Plugin.new(plugin_default_settings, {})
-  end
+  override_module_loader_class ::Proxy::RootPluginLoader
 end
diff --git a/test/plugins/module_loader_test.rb b/test/plugins/module_loader_test.rb
index deabc29a3..bbd802772 100644
--- a/test/plugins/module_loader_test.rb
+++ b/test/plugins/module_loader_test.rb
@@ -21,7 +21,7 @@ def test_merge_settings_should_ignore_enabled
   end
 
   def test_load_configuration_returns_empty_hash_when_config_not_found
-    assert_equal({}, @loader.load_configuration("non_existent_config"))
+    assert_equal({}, @loader.load_configuration_file("non_existent_config"))
   end
 
   def test_compute_runtime_configuration_returns_original_settings_without_runtime_config_loader
@@ -83,11 +83,10 @@ class TestPluginWithCustomValidators < ::Proxy::Plugin
   def test_validate_runtime_config_executes_custom_validators
     loader = ::Proxy::DefaultModuleLoader.new(TestPluginWithCustomValidators, nil)
     results = loader.validate_settings(TestPluginWithCustomValidators, :setting => "value", :evaluate => true)
-
     predicate = TestPluginWithCustomValidators.validations.first[:predicate]
     assert_equal([{:class => TestValidator, :setting => :setting, :args => {:arg1 => "arg1", :arg2 => "arg2"}, :predicate => predicate}], results)
   end
-  
+
   class AnotherTestPluginWithCustomValidators < ::Proxy::Plugin
     validate :setting, :non_existent => true
   end
diff --git a/test/plugins/plugin_group_test.rb b/test/plugins/plugin_group_test.rb
index 5129a70bd..51581b15c 100644
--- a/test/plugins/plugin_group_test.rb
+++ b/test/plugins/plugin_group_test.rb
@@ -1,6 +1,50 @@
 require 'test_helper'
 
 class PluginGroupTest < Test::Unit::TestCase
+  def test_group_initial_state
+    group = ::Proxy::PluginGroup.new(nil)
+
+    assert !group.inactive?
+    assert !group.http_enabled?
+    assert !group.https_enabled?
+  end
+
+  def test_group_listening_ports_when_enabled_setting_is_set_to_http
+    group = ::Proxy::PluginGroup.new(nil)
+    group.update_group_initial_state('http')
+
+    assert !group.inactive?
+    assert group.http_enabled?
+    assert !group.https_enabled?
+  end
+
+  def test_group_listening_ports_when_enabled_setting_is_set_to_https
+    group = ::Proxy::PluginGroup.new(nil)
+    group.update_group_initial_state('https')
+
+    assert !group.inactive?
+    assert !group.http_enabled?
+    assert group.https_enabled?
+  end
+
+  def test_group_listening_ports_when_group_is_disabled
+    group = ::Proxy::PluginGroup.new(nil)
+    group.update_group_initial_state(false)
+
+    assert group.inactive?
+    assert !group.http_enabled?
+    assert !group.https_enabled?
+  end
+
+  def test_group_listening_ports_when_group_failed
+    group = ::Proxy::PluginGroup.new(nil)
+    group.set_group_state_to_failed
+
+    assert group.inactive?
+    assert !group.http_enabled?
+    assert !group.https_enabled?
+  end
+
   class TestPlugin3 < Proxy::Plugin; plugin :test3, "1.0"; uses_provider; default_settings :enabled => true; end
   class TestPlugin4 < Proxy::Provider; plugin :test4, "1.0"; default_settings :enabled => true; end
   def test_resolve_providers
@@ -12,7 +56,6 @@ def test_resolve_providers
     providers = group.resolve_providers(loaded)
 
     assert_equal([TestPlugin4], providers)
-    assert_equal(:starting, group.state)
     assert_equal([TestPlugin4, TestPlugin3], group.members)
   end
 
@@ -39,11 +82,11 @@ def test_validate_dependencies
 
     group1 = ::Proxy::PluginGroup.new(TestPlugin9)
     group1.validate_dependencies_or_fail(enabled)
-    assert_equal(:starting, group1.state)
+    assert !group1.inactive?
 
     group2 = ::Proxy::PluginGroup.new(TestPlugin10)
     group2.validate_dependencies_or_fail(enabled)
-    assert_equal(:starting, group2.state)
+    assert !group2.inactive?
   end
 
   class TestPlugin11 < Proxy::Plugin; plugin :test11, "1.0"; uses_provider; default_settings :enabled => true, :use_provider => :test12; end
@@ -52,7 +95,7 @@ class TestPlugin13 < Proxy::Plugin; plugin :test13, '1.0'; default_settings :ena
   def test_validate_provider_dependencies
     group = ::Proxy::PluginGroup.new(TestPlugin11)
     group.validate_dependencies_or_fail(:test11 => TestPlugin11, :test12 => TestPlugin12, :test13 => TestPlugin13)
-    assert_equal(:starting, group.state)
+    assert !group.inactive?
   end
 
   class TestPlugin14 < Proxy::Plugin; plugin :test14, '1.0'; requires :test_non_existent, '1.0'; end
@@ -68,12 +111,27 @@ def test_validate_dependencies_stops_services_on_failure
     group.validate_dependencies_or_fail(:test14 => TestPlugin14)
   end
 
+  class TestPluginForPassingLoadSettingsTest < ::Proxy::Plugin
+    default_settings :enabled => true
+  end
+  def test_load_plugin_settings_updates_group_initial_state
+    group = ::Proxy::PluginGroup.new(TestPluginForPassingLoadSettingsTest)
+    TestPluginForPassingLoadSettingsTest.module_loader_class.any_instance.expects(:load_settings).returns(:enabled => true)
+
+    assert !group.inactive?
+    group.load_plugin_settings
+
+    assert_equal :starting, group.state
+    assert group.http_enabled?
+    assert group.https_enabled?
+  end
+
   class TestPluginForFailingLoadSettingsTest < ::Proxy::Plugin; end
   def test_load_plugin_settings_changes_state_to_failed_on_failure
     TestPluginForFailingLoadSettingsTest.module_loader_class.any_instance.expects(:load_settings).raises("FAILURE")
     group = ::Proxy::PluginGroup.new(TestPluginForFailingLoadSettingsTest)
 
-    assert_equal :starting, group.state
+    assert !group.inactive?
     group.load_plugin_settings
     assert_equal :failed, group.state
   end
@@ -84,7 +142,7 @@ def test_load_provider_settings_changes_state_to_failed_on_failure
     TestPluginForFailingLoadSettingsTest.settings = OpenStruct.new(:use_provider => :test_provider, :enabled => true)
     group = ::Proxy::PluginGroup.new(TestPluginForFailingLoadSettingsTest, [TestProviderForFailingLoadSettingsTest])
 
-    assert_equal :starting, group.state
+    assert !group.inactive?
     group.load_provider_settings
     assert_equal :failed, group.state
   end
@@ -102,7 +160,7 @@ def test_configure_changes_state_to_failed_on_failure
     group = ::Proxy::PluginGroup.new(PluginForFailingConfigureTest)
     PluginForFailingConfigureTest.module_loader_class.any_instance.expects(:configure_plugin).raises("FAILED")
 
-    assert_equal :starting, group.state
+    assert !group.inactive?
     group.configure
     assert_equal :failed, group.state
   end
diff --git a/test/plugins/plugin_initializer_test.rb b/test/plugins/plugin_initializer_test.rb
index a4cf1ef18..9aea22cbb 100644
--- a/test/plugins/plugin_initializer_test.rb
+++ b/test/plugins/plugin_initializer_test.rb
@@ -28,12 +28,13 @@ def test_initialize_plugins
     assert all_but_uninitialized.all? {|p| p.has_key?(:di_container)}
 
     # filter out :di_container, can't use equality test with it
-    loaded = plugins.loaded.map {|p| [:name, :version, :class, :state].inject({}) {|a, c| a[c] = p[c]; a}}
+    loaded = plugins.loaded.map {|p| [:name, :version, :class, :state, :http_enabled, :https_enabled].inject({}) {|a, c| a[c] = p[c]; a}}
     assert_equal(
-        [{:name => :plugin_1, :version => '1.0', :class => TestPlugin1, :state => :running},
-         {:name => :plugin_2, :version => '1.0', :class => TestPlugin2, :state => :running},
-         {:name => :plugin_3, :version => '1.0', :class => TestPlugin3, :state => :running},
-         {:name => :plugin_4, :version => '1.0', :class => TestPlugin4, :state => :running},
-         {:name => :plugin_5, :version => '1.0', :class => TestPlugin5, :state => :uninitialized}], loaded)
+        [{:name => :plugin_1, :version => '1.0', :class => TestPlugin1, :state => :running, :http_enabled => true, :https_enabled => true},
+         {:name => :plugin_2, :version => '1.0', :class => TestPlugin2, :state => :running, :http_enabled => true, :https_enabled => true},
+         {:name => :plugin_3, :version => '1.0', :class => TestPlugin3, :state => :running, :http_enabled => true, :https_enabled => true},
+         # :http_enabled and :https_enabled are not defined for providers
+         {:name => :plugin_4, :version => '1.0', :class => TestPlugin4, :state => :running, :http_enabled => nil, :https_enabled => nil},
+         {:name => :plugin_5, :version => '1.0', :class => TestPlugin5, :state => :disabled, :http_enabled => false, :https_enabled => false}], loaded)
   end
 end
diff --git a/test/plugins/plugin_test.rb b/test/plugins/plugin_test.rb
index 3e2c75686..f65cdd874 100644
--- a/test/plugins/plugin_test.rb
+++ b/test/plugins/plugin_test.rb
@@ -7,39 +7,6 @@ def test_http_rackup_returns_empty_string_with_missing_rackup_path
     assert_equal "", TestPlugin2.https_rackup
   end
 
-  class TestPlugin10 < Proxy::Plugin; plugin :test10, '1.0'; end
-  def test_enable_of_only_http_is_successful
-    TestPlugin10.load_test_settings(:enabled => 'http')
-    assert TestPlugin10.http_enabled?
-    assert !TestPlugin10.https_enabled?
-  end
-
-  class TestPlugin11 < Proxy::Plugin; plugin :test11, '1.0'; end
-  def test_enable_of_only_https_is_successful
-    TestPlugin11.load_test_settings(:enabled => 'https')
-    assert TestPlugin11.https_enabled?
-    assert !TestPlugin11.http_enabled?
-  end
-
-  class TestPlugin12 < Proxy::Plugin
-    http_rackup_path File.expand_path("http_config.ru", File.expand_path("../", __FILE__))
-    https_rackup_path File.expand_path("http_config.ru", File.expand_path("../", __FILE__))
-
-    default_settings :enabled => 'https'
-    plugin :test12, '1.0'
-  end
-  def test_plugin_loads_http_rack_path
-    assert !TestPlugin12.http_enabled?
-    assert TestPlugin12.https_enabled?
-    assert_equal :test12, TestPlugin12.plugin_name
-
-    # Ensure that the content is read from 'http_config.ru'
-    File.stubs(:read).returns("require 'test12/test12_api'")
-
-    assert_equal TestPlugin12.http_rackup, ''
-    assert_equal "require 'test12/test12_api'", TestPlugin12.https_rackup
-  end
-
   class TestBundlerGroupPlugin < ::Proxy::Plugin
     plugin :test_bundler_group, '1.0'
     bundler_group :test_group
diff --git a/test/root/root_api_test.rb b/test/root/root_api_test.rb
index a65819aef..924c0e378 100644
--- a/test/root/root_api_test.rb
+++ b/test/root/root_api_test.rb
@@ -1,6 +1,6 @@
 require 'test_helper'
 require 'json'
-require 'root/root_plugin'
+require 'root/root'
 require 'root/root_api'
 
 ENV['RACK_ENV'] = 'test'
@@ -25,16 +25,24 @@ def app
   end
 
   def test_features
-    ::Proxy::Plugins.any_instance.stubs(:enabled_plugins).returns([TestPlugin2, TestPlugin3, TestPlugin0])
+    ::Proxy::Plugins.any_instance.expects(:loaded).returns(
+        [{:name => :foreman_proxy, :version => "0.0.1", :class => TestPlugin0, :state => :running},
+         {:name => :test2, :version => "0.0.1", :class => TestPlugin2, :state => :running},
+         {:name => :test2, :version => "0.0.1", :class => TestPlugin3, :state => :disabled}])
     get "/features"
-    assert_equal ['test2', 'test3'], JSON.parse(last_response.body)
+    assert_equal ['test2'], JSON.parse(last_response.body)
   end
 
   def test_version
-    ::Proxy::Plugins.any_instance.stubs(:enabled_plugins).returns([TestPlugin2, TestPlugin3, TestPlugin0])
+    all_modules = [{:name => :foreman_proxy, :version => "0.0.1", :class => TestPlugin0, :state => :running},
+                   {:name => :test2, :version => "0.0.1", :class => TestPlugin2, :state => :running},
+                   {:name => :test2, :version => "0.0.1", :class => TestPlugin3, :state => :disabled}]
+
+    ::Proxy::Plugins.any_instance.expects(:loaded).returns(all_modules)
+
     get "/version"
     assert_equal(Proxy::VERSION, JSON.parse(last_response.body)["version"])
-    modules = Hash[::Proxy::Plugins.instance.enabled_plugins.collect {|plugin| [plugin.plugin_name.to_s, plugin.version.to_s]}].reject { |key| key == 'foreman_proxy' }
+    modules = Hash[all_modules.collect {|plugin| [plugin[:name].to_s, plugin[:version].to_s]}].reject { |key| key == 'foreman_proxy' }
     assert_equal(modules, JSON.parse(last_response.body)["modules"])
   end
 end