test: Faker::Loader tests

Author: thdaraujo

lib/faker/loader.rb

@@ -13,7 +13,7 @@ def initialize(base_dir, config)
 
     def load_const(context_name, class_name)
       @mutex.synchronize do
-        if lazy_loading?
+        if loading_strategy == :lazy
           resolve_const(context_name, class_name)
         else
           eager_load!
@@ -31,24 +31,40 @@ def install_on(klass)
       end
     end
 
+    def loading_strategy
+      if defined?(@loading_strategy)
+        @loading_strategy
+      else
+        @loading_strategy = if @config.lazy_loading?
+                              :lazy
+                            else
+                              :eager
+                            end
+      end
+    end
+
+    private
+
     def resolve_const(context_name, class_name)
       load_path = build_path(context_name, class_name)
 
-      require(load_path)
+      require load_path
     rescue LoadError
       # try to load default generators
-      require(load_path.gsub('faker/', 'faker/default/'))
+      require load_path.gsub('faker/', 'faker/default/')
     end
 
-    private
-
     def eager_load!
       return if @eager_loaded
 
       @eager_loaded = true
 
-      Dir.glob(["#{@base_dir}/faker/*.rb", "#{@base_dir}/faker/**/*.rb"])
-         .each { |f| require f }
+      paths = [
+        "#{@base_dir}/faker/*.rb",
+        "#{@base_dir}/faker/**/*.rb"
+      ]
+
+      Dir.glob(paths).uniq.each { |f| require f }
     end
 
     def build_path(*constants)
@@ -62,9 +78,5 @@ def build_path(*constants)
           .downcase
       end.join('/')
     end
-
-    def lazy_loading?
-      @lazy_loading ||= @config.lazy_loading?
-    end
   end
 end

test/faker/test_loader.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+
+class TestLoader < Test::Unit::TestCase
+  FIXTURES_DIR = File.expand_path('../fixtures', __dir__)
+
+  FakeConfig = Struct.new(:lazy_loading?)
+
+  def eager_loader = Faker::Loader.new(FIXTURES_DIR, FakeConfig.new(false))
+  def lazy_loader = Faker::Loader.new(FIXTURES_DIR, FakeConfig.new(true))
+
+  def with_require_spy(fail_if: nil)
+    original = Kernel.instance_method(:require)
+    loaded_files = []
+    mutex = Mutex.new
+
+    Kernel.define_method(:require) do |f|
+      if fail_if&.call(f)
+        raise LoadError
+      end
+
+      mutex.synchronize { loaded_files << f }
+    end
+
+    yield loaded_files
+  ensure
+    Kernel.define_method(:require, original)
+  end
+
+  def test_strategy_does_not_change_after_first_use
+    config = FakeConfig.new(false)
+    loader = Faker::Loader.new(FIXTURES_DIR, config)
+
+    with_require_spy do
+      loader.load_const('Faker', :Gadget)
+
+      config[:lazy_loading?] = true
+
+      assert_equal :eager, loader.loading_strategy
+    end
+  end
+
+  def test_falls_back_to_default_path_on_load_error
+    loader = lazy_loader
+
+    fail_when_requiring_non_default_path = ->(f) { f.end_with?('faker/gadget') }
+
+    with_require_spy(fail_if: fail_when_requiring_non_default_path) do |loaded_files|
+      loader.load_const('Faker', :Gadget)
+
+      assert loaded_files.any? { |f| f.include?('faker/default/gadget') }
+    end
+  end
+
+  def test_inflection_resolves_correctly
+    loader = lazy_loader
+
+    with_require_spy do |loaded_files|
+      loader.load_const('Faker::Games', :DnD)
+
+      assert_includes loaded_files.first, 'faker/games/dnd'
+      refute_includes loaded_files.first, 'dn_d'
+    end
+  end
+
+  def test_install_on_installs_const_missing
+    loader = lazy_loader
+    klass = Class.new
+
+    loader.install_on(klass)
+
+    assert_equal klass.singleton_class, klass.method(:const_missing).owner
+  end
+
+  def test_eager_loads_all_files_on_first_const_access
+    loader = eager_loader
+
+    with_require_spy do |loaded_files|
+      loader.load_const('Faker', :Gadget)
+
+      actual_files = loaded_files.map do |loaded|
+        loaded.match(/fixtures\/(?<path>.*)/)[:path]
+      end.uniq
+
+      expected_files = %w[
+        faker/gadget.rb
+        faker/default/widget.rb
+        faker/games/dnd.rb
+      ]
+
+      expected_files.each do |file|
+        assert_includes actual_files, file, "expected #{file} to be loaded"
+      end
+    end
+  end
+
+  def test_eager_loads_only_once
+    loader = eager_loader
+
+    with_require_spy do |loaded_files|
+      loader.load_const('Faker', :Gadget)
+
+      count = loaded_files.size
+
+      loader.load_const('Faker', :Gadget)
+
+      assert_equal count, loaded_files.size
+    end
+  end
+
+  def test_lazy_loads_single_file_on_const_access
+    loader = lazy_loader
+
+    with_require_spy do |loaded_files|
+      loader.load_const('Faker', :Gadget)
+
+      assert_equal 1, loaded_files.size
+      assert_includes loaded_files.first, 'faker/gadget'
+    end
+  end
+
+  def test_eager_loads_only_once_across_threads
+    loader = eager_loader
+
+    with_require_spy do |loaded_files|
+      threads = 10.times.map do
+        Thread.new { loader.load_const('Faker', :Gadget) }
+      end
+
+      threads.each(&:join)
+
+      actual_files = loaded_files.map do |loaded|
+        loaded.match(/fixtures\/(?<path>.*)/)[:path]
+      end.compact
+
+      assert_equal actual_files.uniq, actual_files
+    end
+  end
+
+  def test_raises_on_unknown_const
+    loader = lazy_loader
+
+    assert_raises(LoadError) { loader.load_const('Faker', :NonExistent) }
+  end
+end

test/fixtures/faker/default/widget.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Faker
+  class Default
+    # rubocop:disable Lint/EmptyClass
+    class Widget
+    end
+    # rubocop:enable Lint/EmptyClass
+  end
+end

test/fixtures/faker/gadget.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Faker
+  # rubocop:disable Lint/EmptyClass
+  class Gadget
+  end
+  # rubocop:enable Lint/EmptyClass
+end

test/fixtures/faker/games/dnd.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Faker
+  class Games
+    # rubocop:disable Lint/EmptyClass
+    class DnD
+    end
+    # rubocop:enable Lint/EmptyClass
+  end
+end