keycloak-api-rails 0.12.4 → 1.0.1

data/lib/keycloak-api-rails/configuration.rb

@@ -1,14 +1,13 @@
-module Keycloak
+module KeycloakApiRails
   class Configuration
-    include ActiveSupport::Configurable
-    config_accessor :server_url
-    config_accessor :realm_id
-    config_accessor :skip_paths
-    config_accessor :opt_in
-    config_accessor :token_expiration_tolerance_in_seconds
-    config_accessor :public_key_cache_ttl
-    config_accessor :custom_attributes
-    config_accessor :logger
-    config_accessor :ca_certificate_file
+    attr_accessor :server_url
+    attr_accessor :realm_id
+    attr_accessor :skip_paths
+    attr_accessor :opt_in
+    attr_accessor :token_expiration_tolerance_in_seconds
+    attr_accessor :public_key_cache_ttl
+    attr_accessor :custom_attributes
+    attr_accessor :logger
+    attr_accessor :ca_certificate_file
   end
 end

data/lib/keycloak-api-rails/helper.rb

@@ -1,4 +1,4 @@
-module Keycloak
+module KeycloakApiRails
   class Helper
 
     CURRENT_USER_ID_KEY          = "keycloak:keycloak_id"
@@ -83,11 +83,11 @@ module Keycloak
     end
 
     def self.read_token_from_query_string(uri)
-      if uri.present?
+      if uri && !uri.strip.empty?
         parsed_uri         = URI.parse(uri)
         query              = URI.decode_www_form(parsed_uri.query || "")
         query_string_token = query.detect { |param| param.first == QUERY_STRING_TOKEN_KEY }
-        query_string_token&.second
+        query_string_token&.at(1)
       else
         ""
       end

data/lib/keycloak-api-rails/http_client.rb

@@ -1,4 +1,4 @@
-module Keycloak
+module KeycloakApiRails
   class HTTPClient
     def initialize(configuration, logger)
       @server_url          = configuration.server_url
@@ -20,7 +20,7 @@ module Keycloak
           response.value
           JSON.parse(response.body)
         rescue
-          @logger.error("Keycloak responded with an error when calling '#{path}'. Status #{response.code}. Payload: #{response.body}")
+          @logger.error("KeycloakApiRails responded with an error when calling '#{path}'. Status #{response.code}. Payload: #{response.body}")
         end
       end
     end

data/lib/keycloak-api-rails/middleware.rb

@@ -1,4 +1,4 @@
-module Keycloak
+module KeycloakApiRails
 
   class Middleware
     def initialize(app)
@@ -41,15 +41,15 @@ module Keycloak
     end
 
     def service
-      Keycloak.service
+      KeycloakApiRails.service
     end
 
     def logger
-      Keycloak.logger
+      KeycloakApiRails.logger
     end
 
     def config
-      Keycloak.config
+      KeycloakApiRails.config
     end
   end
 end

data/lib/keycloak-api-rails/public_key_cached_resolver.rb

@@ -1,4 +1,4 @@
-module Keycloak
+module KeycloakApiRails
   class PublicKeyCachedResolver
     attr_reader :cached_public_key_retrieved_at
 
@@ -24,7 +24,7 @@ module Keycloak
     private
 
     def public_keys_are_outdated?
-      @cached_public_keys.nil? || @cached_public_key_retrieved_at.nil? || Time.now > (@cached_public_key_retrieved_at + @public_key_cache_ttl.seconds)
+      @cached_public_keys.nil? || @cached_public_key_retrieved_at.nil? || Time.now > (@cached_public_key_retrieved_at + @public_key_cache_ttl)
     end
   end
 end

data/lib/keycloak-api-rails/public_key_resolver.rb

@@ -1,4 +1,4 @@
-module Keycloak
+module KeycloakApiRails
   class PublicKeyResolver
     def initialize(http_client, realm_id)
       @realm_id    = realm_id

data/lib/keycloak-api-rails/railtie.rb

@@ -1,9 +1,9 @@
-module Keycloak
+module KeycloakApiRails
   class Railtie < Rails::Railtie
     railtie_name :keycloak_api_rails
 
     initializer("keycloak.insert_middleware") do |app|
-      app.config.middleware.use(Keycloak::Middleware)
+      app.config.middleware.use(KeycloakApiRails::Middleware)
     end
   end
 end

data/lib/keycloak-api-rails/service.rb

@@ -1,12 +1,12 @@
-module Keycloak
+module KeycloakApiRails
   class Service
     
     def initialize(key_resolver)
       @key_resolver                          = key_resolver
-      @skip_paths                            = Keycloak.config.skip_paths
-      @opt_in                                = Keycloak.config.opt_in
-      @logger                                = Keycloak.config.logger
-      @token_expiration_tolerance_in_seconds = Keycloak.config.token_expiration_tolerance_in_seconds
+      @skip_paths                            = KeycloakApiRails.config.skip_paths
+      @opt_in                                = KeycloakApiRails.config.opt_in
+      @logger                                = KeycloakApiRails.config.logger
+      @token_expiration_tolerance_in_seconds = KeycloakApiRails.config.token_expiration_tolerance_in_seconds
     end
 
     def decode_and_verify(token)
@@ -53,8 +53,8 @@ module Keycloak
     end
 
     def expired?(token)
-      token_expiration = Time.at(token["exp"]).to_datetime
-      token_expiration < Time.now + @token_expiration_tolerance_in_seconds.seconds
+      token_expiration = Time.at(token["exp"])
+      token_expiration < Time.now + @token_expiration_tolerance_in_seconds
     end
   end
 end

data/lib/keycloak-api-rails/version.rb

@@ -1,3 +1,3 @@
-module Keycloak
-  VERSION = "0.12.4"
+module KeycloakApiRails
+  VERSION = "1.0.1"
 end

data/lib/keycloak-api-rails.rb

@@ -15,10 +15,10 @@ require_relative "keycloak-api-rails/service"
 require_relative "keycloak-api-rails/middleware"
 require_relative "keycloak-api-rails/railtie" if defined?(Rails)
 
-module Keycloak
+module KeycloakApiRails
 
   def self.configure
-    yield @configuration ||= Keycloak::Configuration.new
+    yield @configuration ||= KeycloakApiRails::Configuration.new
   end
 
   def self.config
@@ -26,7 +26,7 @@ module Keycloak
   end
 
   def self.http_client
-    @http_client ||= Keycloak::HTTPClient.new(config, logger)
+    @http_client ||= KeycloakApiRails::HTTPClient.new(config, logger)
   end
 
   def self.public_key_resolver
@@ -34,7 +34,7 @@ module Keycloak
   end
 
   def self.service
-    @service ||= Keycloak::Service.new(public_key_resolver)
+    @service ||= KeycloakApiRails::Service.new(public_key_resolver)
   end
 
   def self.logger

data/spec/keycloak-api-rails/activesupport_free_spec.rb

@@ -0,0 +1,18 @@
+require "rbconfig"
+
+RSpec.describe "The library without ActiveSupport" do
+
+  let(:probe) { File.expand_path("../../support/activesupport_free_probe.rb", __FILE__) }
+
+  # RUBYOPT is cleared so that nothing set up by bundler is preloaded in the probe process.
+  def run_probe
+    output = IO.popen({ "RUBYOPT" => nil }, [RbConfig.ruby, probe], err: [:child, :out], &:read)
+    [$?.exitstatus, output]
+  end
+
+  it "loads and behaves the same way when ActiveSupport is not available" do
+    status, output = run_probe
+
+    expect(status).to eq(0), "The library relies on ActiveSupport:\n#{output}"
+  end
+end

data/spec/keycloak-api-rails/authentication_spec.rb

@@ -1,10 +1,10 @@
 require "spec_helper"
 
-describe Keycloak::Authentication do
+describe KeycloakApiRails::Authentication do
   class ExampleController < ActionController::Base
-    include Keycloak::Authentication
+    include KeycloakApiRails::Authentication
     # Mark protected methods public so they may be called in tests
-    public(*Keycloak::Authentication.protected_instance_methods)
+    public(*KeycloakApiRails::Authentication.protected_instance_methods)
   end
 
   let(:controller) { ExampleController.new }
@@ -17,6 +17,44 @@ describe Keycloak::Authentication do
     }
   end
 
+  describe "when included" do
+    it "declares keycloak_authenticate as a helper method when the base class supports helpers" do
+      declared_helper_methods = []
+      base = Class.new do
+        define_singleton_method(:helper_method) { |*names| declared_helper_methods.concat(names) }
+      end
+
+      base.include(KeycloakApiRails::Authentication)
+
+      expect(declared_helper_methods).to eq [:keycloak_authenticate]
+    end
+
+    it "declares the helper method on a real controller" do
+      expect(ExampleController._helper_methods).to include :keycloak_authenticate
+    end
+
+    it "does not fail when the base class does not support helpers" do
+      expect {
+        Class.new.include(KeycloakApiRails::Authentication)
+      }.to_not raise_error
+    end
+
+    it "exposes its methods as protected instance methods" do
+      expect(KeycloakApiRails::Authentication.protected_instance_methods).to match_array %i[
+        keycloak_authenticate
+        authentication_failed
+        authentication_succeeded
+      ]
+    end
+
+    it "does not add any public method to the including class" do
+      base = Class.new.include(KeycloakApiRails::Authentication)
+
+      expect(base.public_instance_methods).to_not include :keycloak_authenticate
+      expect(base.protected_instance_methods).to include :keycloak_authenticate
+    end
+  end
+
   describe "#keycloak_authenticate" do
     before do
       # Mock request object because we aren't using real request spec
@@ -24,7 +62,7 @@ describe Keycloak::Authentication do
     end
 
     it "it authenticates with request header" do
-      expect_any_instance_of(Keycloak::Service).to receive(:decode_and_verify).with(token).and_return("A User")
+      expect_any_instance_of(KeycloakApiRails::Service).to receive(:decode_and_verify).with(token).and_return("A User")
       expect(controller).to receive(:authentication_succeeded)
       controller.keycloak_authenticate
     end

data/spec/keycloak-api-rails/configuration_spec.rb

@@ -0,0 +1,101 @@
+RSpec.describe KeycloakApiRails::Configuration do
+
+  # Every attribute that used to be declared through ActiveSupport's `config_accessor`.
+  let(:attribute_names) do
+    %i[
+      server_url
+      realm_id
+      skip_paths
+      opt_in
+      token_expiration_tolerance_in_seconds
+      public_key_cache_ttl
+      custom_attributes
+      logger
+      ca_certificate_file
+    ]
+  end
+
+  describe "attributes" do
+    let(:configuration) { KeycloakApiRails::Configuration.new }
+
+    it "exposes a reader and a writer for each attribute" do
+      attribute_names.each do |name|
+        expect(configuration).to respond_to name
+        expect(configuration).to respond_to "#{name}="
+      end
+    end
+
+    it "returns nil for each attribute that has not been assigned" do
+      attribute_names.each do |name|
+        expect(configuration.public_send(name)).to be_nil
+      end
+    end
+
+    it "returns the value that has been assigned" do
+      attribute_names.each do |name|
+        configuration.public_send("#{name}=", "a value for #{name}")
+        expect(configuration.public_send(name)).to eq "a value for #{name}"
+      end
+    end
+
+    it "does not respond to an unknown attribute" do
+      expect(configuration).to_not respond_to :not_a_configuration_attribute
+      expect {
+        configuration.not_a_configuration_attribute
+      }.to raise_error NoMethodError
+    end
+  end
+
+  describe "#configure" do
+    after(:each) do
+      KeycloakApiRails.load_configuration
+    end
+
+    it "yields the configuration" do
+      expect { |block| KeycloakApiRails.configure(&block) }.to yield_with_args KeycloakApiRails::Configuration
+    end
+
+    it "keeps the values assigned within the block" do
+      KeycloakApiRails.configure do |config|
+        config.server_url          = "http://keycloak:8080"
+        config.realm_id            = "a-realm"
+        config.ca_certificate_file = "/etc/ssl/a-certificate.pem"
+      end
+
+      expect(KeycloakApiRails.config.server_url).to eq "http://keycloak:8080"
+      expect(KeycloakApiRails.config.realm_id).to eq "a-realm"
+      expect(KeycloakApiRails.config.ca_certificate_file).to eq "/etc/ssl/a-certificate.pem"
+    end
+
+    it "always returns the same configuration instance" do
+      expect(KeycloakApiRails.config).to be KeycloakApiRails.config
+    end
+  end
+
+  describe "#load_configuration" do
+    before(:each) do
+      KeycloakApiRails.load_configuration
+    end
+
+    after(:each) do
+      KeycloakApiRails.load_configuration
+    end
+
+    it "applies the documented default values" do
+      config = KeycloakApiRails.config
+
+      expect(config.server_url).to be_nil
+      expect(config.realm_id).to be_nil
+      expect(config.logger).to be_a ::Logger
+      expect(config.skip_paths).to eq({})
+      expect(config.opt_in).to be false
+      expect(config.token_expiration_tolerance_in_seconds).to eq 10
+      expect(config.public_key_cache_ttl).to eq 86400
+      expect(config.custom_attributes).to eq []
+    end
+
+    it "exposes the logger through KeycloakApiRails.logger" do
+      expect(KeycloakApiRails.logger).to be KeycloakApiRails.config.logger
+    end
+  end
+end

data/spec/keycloak-api-rails/helper_spec.rb

@@ -1,11 +1,72 @@
-RSpec.describe Keycloak::Helper do
+RSpec.describe KeycloakApiRails::Helper do
+  describe "#read_token_from_query_string" do
+
+    subject { KeycloakApiRails::Helper.read_token_from_query_string(uri) }
+
+    context "when the uri is nil" do
+      let(:uri) { nil }
+      it "returns an empty token" do
+        expect(subject).to eq ""
+      end
+    end
+
+    context "when the uri is empty" do
+      let(:uri) { "" }
+      it "returns an empty token" do
+        expect(subject).to eq ""
+      end
+    end
+
+    context "when the uri only contains whitespaces" do
+      let(:uri) { "   " }
+      it "returns an empty token" do
+        expect(subject).to eq ""
+      end
+    end
+
+    context "when the uri has no query string" do
+      let(:uri) { "http://www.an-url.io/health" }
+      it "returns no token" do
+        expect(subject).to be_nil
+      end
+    end
+
+    context "when the uri has a query string but no token" do
+      let(:uri) { "http://www.an-url.io/health?firstName=ouioui" }
+      it "returns no token" do
+        expect(subject).to be_nil
+      end
+    end
+
+    context "when the uri has a token in the query string" do
+      let(:uri) { "http://www.an-url.io/health?authorizationToken=aToken" }
+      it "returns the token" do
+        expect(subject).to eq "aToken"
+      end
+    end
+
+    context "when the uri has a token among other query string parameters" do
+      let(:uri) { "http://www.an-url.io/health?firstName=ouioui&authorizationToken=aToken&lastName=nonnon" }
+      it "returns the token" do
+        expect(subject).to eq "aToken"
+      end
+    end
+
+    context "when the uri has an empty token in the query string" do
+      let(:uri) { "http://www.an-url.io/health?authorizationToken=" }
+      it "returns an empty token" do
+        expect(subject).to eq ""
+      end
+    end
+  end
+
   describe "#create_url_with_token" do
 
     let(:uri)   { "http://www.an-url.io" }
     let(:token) { "aToken" }
 
     before(:each) do
-      @url_with_token = Keycloak::Helper.create_url_with_token(uri, token)
+      @url_with_token = KeycloakApiRails::Helper.create_url_with_token(uri, token)
     end
 
     context "when the uri has no query string yet" do

data/spec/keycloak-api-rails/public_key_cached_resolver_spec.rb

@@ -1,12 +1,12 @@
-RSpec.describe Keycloak::Service do
+RSpec.describe KeycloakApiRails::Service do
 
   let(:public_key_cache_ttl)  { 86400 }
   let(:server_url)            { "whatever:8080" }
   let(:realm_id)              { "pouet" }
-  let!(:resolver)             { Keycloak::PublicKeyCachedResolver.new(server_url, realm_id, public_key_cache_ttl) }
+  let!(:resolver)             { KeycloakApiRails::PublicKeyCachedResolver.new(server_url, realm_id, public_key_cache_ttl) }
 
   before(:each) do
-    resolver.instance_variable_set(:@resolver, Keycloak::PublicKeyResolverStub.new)
+    resolver.instance_variable_set(:@resolver, KeycloakApiRails::PublicKeyResolverStub.new)
     now = Time.local(2018, 1, 9, 12, 0, 0)
     Timecop.freeze(now)
   end

data/spec/keycloak-api-rails/service_spec.rb

@@ -1,9 +1,9 @@
-RSpec.describe Keycloak::Service do
+RSpec.describe KeycloakApiRails::Service do
 
   let!(:private_key)  { OpenSSL::PKey::RSA.generate(2048) }
   let!(:public_key)   { private_key.public_key }
-  let!(:key_resolver)  { Keycloak::PublicKeyCachedResolverStub.new(public_key) }
-  let!(:service)       { Keycloak::Service.new(key_resolver) }
+  let!(:key_resolver)  { KeycloakApiRails::PublicKeyCachedResolverStub.new(public_key) }
+  let!(:service)       { KeycloakApiRails::Service.new(key_resolver) }
   
   before(:each) do
     now = Time.local(2018, 1, 9, 12, 0, 0)
@@ -17,7 +17,7 @@ RSpec.describe Keycloak::Service do
   describe "#decode_and_verify" do
     def create_token(private_key, expiration_date, algorithm)
       claim = {
-        iss: "Keycloak",
+        iss: "KeycloakApiRails",
         exp: expiration_date,
         nbf: Time.local(2018, 1, 1, 0, 0, 0)
       }
@@ -80,9 +80,31 @@ RSpec.describe Keycloak::Service do
           end
         end
 
+        # The service reads `token_expiration_tolerance_in_seconds` when it is instantiated:
+        # a token expiring within that tolerance is already considered as expired.
+        context "and token expires within the expiration tolerance" do
+          let(:expiration_date) { Time.now + 5 }
+
+          it "should raise an error :expiration_date" do
+            expect(KeycloakApiRails.config.token_expiration_tolerance_in_seconds).to eq 10
+            expect {
+              service.decode_and_verify(token)
+            }.to raise_error(TokenError, "JWT token is expired")
+          end
+        end
+
+        context "and token expires just after the expiration tolerance" do
+          let(:expiration_date) { Time.now + 30 }
+
+          it "should return a not-nil decoded token" do
+            expect(KeycloakApiRails.config.token_expiration_tolerance_in_seconds).to eq 10
+            expect(service.decode_and_verify(token)).to_not be_nil
+          end
+        end
+
         context "and token is not expired" do
           let(:expiration_date) { Time.now + 2.days }
-          
+
           context "and token is encrypted using RS256" do
             let(:algorithm) { :RS256 }
             
@@ -111,7 +133,7 @@ RSpec.describe Keycloak::Service do
 
 
     before(:each) do
-      Keycloak.config.skip_paths = {
+      KeycloakApiRails.config.skip_paths = {
         post:   [/^\/skip/],
         get:    [/^\/skip/]
       }
@@ -178,8 +200,8 @@ RSpec.describe Keycloak::Service do
 
     context "when configured as opt_in" do
       before do
-        Keycloak.config.opt_in = true
-        service2 = Keycloak::Service.new(key_resolver)
+        KeycloakApiRails.config.opt_in = true
+        service2 = KeycloakApiRails::Service.new(key_resolver)
         @result = service2.need_middleware_authentication?(method, path, headers)
       end
 

data/spec/support/activesupport_free_probe.rb

@@ -0,0 +1,131 @@
+# Loads the library and exercises every code path that used to rely on ActiveSupport,
+# in a process where ActiveSupport is *not* loaded.
+#
+# The regular test suite loads `rails/all`, which makes ActiveSupport available everywhere and
+# therefore cannot detect that the library depends on it again. This probe is executed in a
+# separate process by spec/keycloak-api-rails/activesupport_free_spec.rb.
+#
+# The library files are required one by one on purpose: `lib/keycloak-api-rails.rb` pulls in
+# `json/jwt`, which depends on ActiveSupport. The point of this probe is that *our* code does not
+# use ActiveSupport, not that it never gets loaded by a third party.
+
+require "uri"
+require "date"
+require "logger"
+
+LIB = File.expand_path("../../../lib/keycloak-api-rails", __FILE__)
+
+# Minimal stand-in for the parts of lib/keycloak-api-rails.rb the required files call at runtime.
+module KeycloakApiRails
+  class << self
+    attr_accessor :config
+  end
+end
+
+require "#{LIB}/configuration"
+require "#{LIB}/helper"
+require "#{LIB}/authentication"
+require "#{LIB}/public_key_resolver"
+require "#{LIB}/public_key_cached_resolver"
+require "#{LIB}/service"
+
+$failures = []
+
+def assert(description)
+  $failures << description unless yield
+rescue => e
+  $failures << "#{description} (raised #{e.class}: #{e.message})"
+end
+
+assert("ActiveSupport is not loaded by the library") { !defined?(ActiveSupport) }
+
+### Configuration -- used to be ActiveSupport::Configurable
+configuration = KeycloakApiRails::Configuration.new
+KeycloakApiRails.config = configuration
+
+%i[
+  server_url realm_id skip_paths opt_in token_expiration_tolerance_in_seconds
+  public_key_cache_ttl custom_attributes logger ca_certificate_file
+].each do |name|
+  assert("Configuration##{name} is nil until it is assigned") { configuration.public_send(name).nil? }
+  configuration.public_send("#{name}=", "a value for #{name}")
+  assert("Configuration##{name} returns what was assigned") { configuration.public_send(name) == "a value for #{name}" }
+end
+
+### Authentication -- used to be ActiveSupport::Concern
+declared_helper_methods = []
+controller_with_helpers = Class.new do
+  define_singleton_method(:helper_method) { |*names| declared_helper_methods.concat(names) }
+end
+controller_with_helpers.include(KeycloakApiRails::Authentication)
+assert("Authentication declares keycloak_authenticate as a helper method") do
+  declared_helper_methods == [:keycloak_authenticate]
+end
+assert("Authentication can be included in a class without helper_method") do
+  Class.new.include(KeycloakApiRails::Authentication)
+  true
+end
+assert("Authentication keeps its methods protected") do
+  KeycloakApiRails::Authentication.protected_instance_methods.sort ==
+    %i[authentication_failed authentication_succeeded keycloak_authenticate]
+end
+
+### Helper#read_token_from_query_string -- used to be `present?` and `second`
+{
+  nil                                                             => "",
+  ""                                                              => "",
+  "   "                                                           => "",
+  "http://www.an-url.io/health"                                   => nil,
+  "http://www.an-url.io/health?firstName=ouioui"                  => nil,
+  "http://www.an-url.io/health?authorizationToken=aToken"         => "aToken",
+  "http://www.an-url.io/health?a=1&authorizationToken=aToken&b=2" => "aToken",
+}.each do |uri, expected|
+  assert("Helper.read_token_from_query_string(#{uri.inspect}) returns #{expected.inspect}") do
+    KeycloakApiRails::Helper.read_token_from_query_string(uri) == expected
+  end
+end
+
+### Service#expired? -- used to be `to_datetime` and `seconds`
+configuration.token_expiration_tolerance_in_seconds = 10
+configuration.skip_paths = {}
+configuration.opt_in     = false
+configuration.logger     = ::Logger.new(File::NULL)
+service = KeycloakApiRails::Service.new(nil)
+now = Time.now
+
+{
+  "expiring in one hour"                         => [(now + 3600).to_i, false],
+  "expired two days ago"                         => [(now - 172800).to_i, true],
+  "expiring within the tolerance (5s < 10s)"     => [(now + 5).to_i, true],
+  "expiring after the tolerance (30s > 10s)"     => [(now + 30).to_i, false],
+}.each do |description, (exp, expected)|
+  assert("Service#expired? returns #{expected} for a token #{description}") do
+    service.send(:expired?, { "exp" => exp }) == expected
+  end
+end
+
+### PublicKeyCachedResolver -- used to be `seconds`
+ttl = 86400
+resolver = KeycloakApiRails::PublicKeyCachedResolver.new(nil, "a-realm", ttl)
+assert("PublicKeyCachedResolver considers an empty cache as outdated") do
+  resolver.send(:public_keys_are_outdated?) == true
+end
+resolver.instance_variable_set(:@cached_public_keys, "a-public-key")
+resolver.instance_variable_set(:@cached_public_key_retrieved_at, Time.now - (ttl - 10))
+assert("PublicKeyCachedResolver keeps a cache that is within its TTL") do
+  resolver.send(:public_keys_are_outdated?) == false
+end
+resolver.instance_variable_set(:@cached_public_key_retrieved_at, Time.now - (ttl + 10))
+assert("PublicKeyCachedResolver invalidates a cache that outlived its TTL") do
+  resolver.send(:public_keys_are_outdated?) == true
+end
+
+assert("ActiveSupport has not been loaded while exercising the library") { !defined?(ActiveSupport) }
+
+if $failures.empty?
+  puts "The library behaves correctly without ActiveSupport"
+  exit 0
+else
+  $failures.each { |failure| puts "FAILED: #{failure}" }
+  exit 1
+end