radius-spec 0.1.0

data/lib/radius/spec/model_factory.rb

@@ -0,0 +1,472 @@
+# frozen_string_literal: true
+
+module Radius
+  module Spec
+    # Basic Model Factory
+    #
+    # This factory is **not** Rails specific. It works for any object type that
+    # responds to `new` with a hash of attributes or keywords; including
+    # `Struct` using the new Ruby 2.5 `keyword_init` flag.
+    #
+    # To make this feature available require it after the gem:
+    #
+    # ```ruby
+    # require 'radius/spec'
+    # require 'radius/spec/model_factory'
+    # ```
+    #
+    # ### Storing Factory Templates
+    #
+    # Our convention is to store all of a project's factory templates in the
+    # file `spec/support/model_factories.rb`. As this is our convention, when
+    # the model factory is required it will attempt to load this file
+    # automatically as a convenience.
+    #
+    # ### Including Helpers in Specs
+    #
+    # There are multiple ways you can build object instances using this model
+    # factory. Which method you choose depends on how much perceived
+    # magic/syntactic sugar you want:
+    #
+    #   - call the model factory directly
+    #   - manually include the factory helper methods in the specs
+    #   - use metadata to auto load this feature and include it in the specs
+    #
+    # When using the metadata option you do not need to explicitly require the
+    # model factory feature. This gem registers metadata with the RSpec
+    # configuration when it loads and `RSpec` is defined. When the metadata is
+    # first used it will automatically require the model factory feature and
+    # include the helpers.
+    #
+    # Any of following metadata will include the factory helpers:
+    #
+    #   - `:model_factory`
+    #   - `:model_factories`
+    #   - `type: :controller`
+    #   - `type: :feature`
+    #   - `type: :job`
+    #   - `type: :model`
+    #   - `type: :request`
+    #   - `type: :system`
+    #
+    # @example defining a single factory template
+    #   require 'radius/spec/model_factory'
+    #
+    #   Radius::Spec::ModelFactory.define_factory(
+    #     "AnyClass",
+    #     attr1: :any_value,
+    #     attr2: :another_value,
+    #   )
+    # @example defining multiple templates
+    #   require 'radius/spec/model_factory'
+    #
+    #   Radius::Spec::ModelFactory.catalog do |c|
+    #     c.factory "AnyClass", attr1: :any_value, attr2: :another_value
+    #
+    #     c.factory "AnotherClass",
+    #               attr1: :any_value,
+    #               attr2: :another_value,
+    #               attr3: %i[any list of values]
+    #   end
+    # @example building a domain model from a factory template
+    #   an_instance = Radius::Spec::ModelFactory.build("AnyClass")
+    # @example building a domain model with custom attributes
+    #   an_instance = Radius::Spec::ModelFactory.build(
+    #     "AnyClass",
+    #     attr1: "Any Custom Value",
+    #     attr2: %w[any custom array],
+    #   )
+    # @example call the model factory directly in specs
+    #   require 'radius/spec/model_factory'
+    #
+    #   RSpec.describe AnyClass do
+    #     it "includes the factory helpers" do
+    #       an_object = Radius::Spec::ModelFactory.build("AnyClass")
+    #       expect(an_object.name).to eq "Any Name"
+    #     end
+    #   end
+    # @example manually include the factory helper methods
+    #   require 'radius/spec/model_factory'
+    #
+    #   RSpec.describe AnyClass do
+    #     include Radius::Spec::ModelFactory
+    #
+    #     it "includes the factory helpers" do
+    #       an_object = build(AnyClass)
+    #       expect(an_object.name).to eq "Any Name"
+    #     end
+    #   end
+    # @example use metadata to auto include the factory helper methods
+    #   RSpec.describe AnyClass, :model_factory do
+    #     it "includes the factory helpers" do
+    #       an_object = build("AnyClass")
+    #       expect(an_object.name).to eq "Any Name"
+    #     end
+    #   end
+    # @since 0.1.0
+    module ModelFactory
+      # Indicates that a model does not have a template registered with the
+      # factory {Radius::Spec::ModelFactory.catalog}.
+      class TemplateNotFound < KeyError; end
+
+      class << self
+        # Suggested method for defining multiple factory templates at once.
+        #
+        # Most projects end up having many domain models which need factories
+        # defined. Having to reference the full module constant every time you
+        # want to define a factory is tedious. Use this to define all of your
+        # model templates within a block.
+        #
+        # @example
+        #   require 'radius/spec/model_factory'
+        #
+        #   Radius::Spec::ModelFactory.catalog do |c|
+        #     c.factory "AnyClass", attr1: :any_value, attr2: :another_value
+        #
+        #     c.factory "AnotherClass",
+        #               attr1: :any_value,
+        #               attr2: :another_value,
+        #               attr3: %i[any list of values]
+        #   end
+        # @yieldparam catalog current catalog storing the registered templates
+        # @return [void]
+        # @see .factory
+        def catalog
+          yield self
+        end
+
+        # Convenience helper for registering a template to the current catalog.
+        #
+        # Registers the `class_name` in the catalog mapped to the provided
+        # `attrs` attribute template.
+        #
+        # ### Lazy Class Loading
+        #
+        # When testing in isolation we often don't want to wait a long time for
+        # a lot of unnecessary project/app code to load. With that in mind we
+        # want to keep loading the model factory and all factory templates as
+        # fast as possible. This mean not loading the associated project/app
+        # code at factory template definition time. This way if you only need
+        # one or two factories your remaining domain model code won't be
+        # loaded.
+        #
+        # Lazy class loading occurs when you register factory template using a
+        # string or symbol for the fully qualified `class_name`. The only
+        # requirement for this feature is that the class must be loaded by the
+        # project/app, or made available via some auto-loading mechanism, by
+        # the time the first instance is built by the factory.
+        #
+        # ### Template Attribute Keys
+        #
+        # Attribute keys may be defined using either strings or symbols.
+        # However, they will be stored internally as symbols. This means that
+        # when an object instance is create using the factory the **attribute
+        # hash will be provided to `new` with _symbol_ keys**.
+        #
+        # ### Dynamic Attribute Values (i.e. Generators)
+        #
+        # Dynamic attributes values may be registered by providing a `Proc` for
+        # the value. For any template attribute which has a `Proc` for a value
+        # making an instance through the factory will send `call` to the proc
+        # with no args.
+        #
+        # <div class="note notetag">
+        # <strong>Note:</strong>
+        # <div class="inline">
+        # <p>
+        # This only applies to template values which are instances of
+        # <code>Proc</code>. If you define a template value using another
+        # object which responds to <code>call</code> that object will be set as
+        # the built instance's attribute value without receiving
+        # <code>call</code>.
+        # </p>
+        # </div>
+        # </div>
+        #
+        # While this is a powerful technique we suggest keeping it's use to a
+        # minimum. There's a lot of benefit to generative, mutation, and fuzzy
+        # testing. We just aren't convinced it should be the default when you
+        # generate unit / general integration test data.
+        #
+        # ### Optional and Required attributes
+        #
+        # Templates may use the special symbols `:optional` and `:required` as
+        # a means of documenting attributes. These special symbols are meant as
+        # descriptive placeholders for developers reading the factory
+        # definition. Any template attribute with a value of `:optional`, which
+        # is not overwritten by a custom value, will be removed just prior to
+        # building a new instance.
+        #
+        # Those attributes marked as `:required` will not be removed. Instead
+        # the symbol `:required` will be set as the attribute's value if it
+        # isn't overwritten by the custom data. This type of value is a _benign
+        # default_ meant to cause errors to provide a more helpful description
+        # (i.e. this attribute is required).
+        #
+        # For Rails projects, we suggest using `:required` for any association
+        # that is necessary for the object to be valid. We do not recommend
+        # attempting to generate default records within the factory as this can
+        # lead to unexpected database state; and hide relevant information away
+        # from the specs which may depend on it.
+        #
+        # ### "Safe" Attribute Duplication
+        #
+        # In an effort to help limit accidental state leak between instances
+        # the factory will duplicate all non-frozen template values prior to
+        # building the instance. Duplication is only applied to the values
+        # registered for the templates. Custom values provided when building
+        # the instance are not duplicated.
+        #
+        # @example register a domain template using class constant
+        #   Radius::Spec::ModelFactory.define_factory AnyClass,
+        #                                             any_attr: :any_value
+        # @example register a domain template using lazy class loading
+        #   Radius::Spec::ModelFactory.define_factory :AnyClass,
+        #                                             any_attr: :any_value
+        # @example register a nested class using lazy class loading
+        #   Radius::Spec::ModelFactory.define_factory "AnyModule::AnyClass",
+        #                                             any_attr: :any_value
+        # @example advanced example using additional features
+        #   Radius::Spec::ModelFactory.define_factory(
+        #     "AnyClass",
+        #     dynamic: -> { rand(0..100) },
+        #     safe_array: [1, 2, 3],
+        #   )
+        #
+        #   AnyClass = Struct.new(:dynamic, :safe_array, keyword_init: true)
+        #
+        #   instance_a = Radius::Spec::ModelFactory.build("AnyClass")
+        #   # => #<struct AnyClass dynamic=10, safe_array=[1, 2, 3]>
+        #
+        #   instance_a.safe_array << 4
+        #   # => #<struct AnyClass dynamic=10, safe_array=[1, 2, 3, 4]>
+        #
+        #   instance_b = Radius::Spec::ModelFactory.build("AnyClass")
+        #   # => #<struct AnyClass dynamic=32, safe_array=[1, 2, 3]>
+        # @param class_name [Class, String, Symbol] fully qualified domain
+        #   model class name or constant
+        # @param attrs [Hash{String,Symbol => Object}] hash of attributes and
+        #   default values to register
+        # @return [void]
+        def define_factory(class_name, attrs = {})
+          templates[class_name.to_s] = attrs.transform_keys(&:to_sym).freeze
+        end
+        alias_method :factory, :define_factory
+
+        # @private
+        def safe_transform(value)
+          return value.call if value.is_a?(Proc)
+          return value if value.frozen?
+          value.dup
+        end
+
+        # @private
+        def template(name)
+          templates.fetch(name) {
+            raise TemplateNotFound, "template not found: #{name}"
+          }
+        end
+
+        # @private
+        def templates
+          @templates ||= {}
+        end
+      end
+
+    module_function
+
+      # Convenience wrapper for building a model template.
+      #
+      # All `custom_attrs` values are provided as is to the class initializer
+      # (i.e. they are **not** duplicate or modified in any way). When an
+      # attribute exists in both the registered template and `custom_attrs` the
+      # value in `custom_attrs` will be used. The `custom_attrs` may also
+      # include new attributes not defined in the factory template.
+      #
+      # ### Optional Block
+      #
+      # The `block` is optional. When provided it is passed directly to `new`
+      # when initializing the instance. This is to support the common Ruby
+      # idiom of yielding `self` within initialize:
+      #
+      # ```ruby
+      # class AnyClass
+      #   def initialize(attrs = {})
+      #     # setup attrs
+      #     yield self if block_given?
+      #   end
+      # end
+      # ```
+      #
+      # <div class="note notetag">
+      # <strong>Note:</strong>
+      # <div class="inline">
+      # <p>
+      # Since Ruby always supports passing a block to a method, even if the
+      # method does not use the block, it's possible the block will not run if
+      # the class being instantiated does yield to it.
+      # </p>
+      # <p>
+      # Also, while the common idiom is to <code>yield self</code> classes are
+      # free to yield anything. You need to be aware of how the class normally
+      # behaves when passing a block to <code>new</code>.
+      # </p>
+      # </div>
+      # </div>
+      #
+      # The examples below show different ways of interacting with the
+      # following domain model and registered factory template:
+      #
+      # ```ruby
+      # Radius::Spec::ModelFactory.factory "AnyClass",
+      #                                    simple_attr: "any value",
+      #                                    array_attr:  %w[any value],
+      #                                    optional_attr: :optional,
+      #                                    dynamic_attr: -> { rand(0..100) }
+      #
+      # class AnyClass
+      #   def initialize(**opts)
+      #     opts.each do |k, v|
+      #       public_send "#{k}=", v
+      #     end
+      #     yield self if block_given?
+      #   end
+      #
+      #   attr_accessor :array_attr, :dynamic_attr, :optional_attr, :simple_attr
+      # end
+      # ```
+      #
+      # @example building the default template using lazy class loading
+      #   Radius::Spec::ModelFactory.build("AnyClass")
+      #   # => #<AnyClass @array_attr=["any", "value"],
+      #   #               @dynamic_attr=88,
+      #   #               @simple_attr="any value">
+      # @example building the default template using class constant
+      #   Radius::Spec::ModelFactory.build(AnyClass)
+      #   # => #<AnyClass @array_attr=["any", "value"],
+      #   #               @dynamic_attr=3,
+      #   #               @simple_attr="any value">
+      # @example building the default template with a block
+      #   Radius::Spec::ModelFactory.build("AnyClass") { |instance|
+      #     instance.simple_attr = "Block Value"
+      #   }
+      #   # => #<AnyClass @array_attr=["any", "value"],
+      #   #               @dynamic_attr=27,
+      #   #               @simple_attr="Block Value">
+      # @example building an instance with custom attributes
+      #   Radius::Spec::ModelFactory.build(
+      #     "AnyClass",
+      #     simple_attr: "Custom Value",
+      #     dynamic_attr: "Static Value",
+      #     optional_attr: "Optional Value",
+      #   )
+      #   # => #<AnyClass @array_attr=["any", "value"],
+      #   #               @dynamic_attr="Static Value",
+      #   #               @optional_attr="Optional Value",
+      #   #               @simple_attr="Custom Value">
+      # @example registered template values are safe from modification
+      #   instance_a = Radius::Spec::ModelFactory.build("AnyClass")
+      #   instance_b = Radius::Spec::ModelFactory.build("AnyClass")
+      #   instance_a.simple_attr.upcase!
+      #   instance_a.array_attr << "modified"
+      #   puts "#{instance_a.simple_attr}: #{instance_a.array_attr}"
+      #   puts "#{instance_b.simple_attr}: #{instance_b.array_attr}"
+      #
+      #   # Outputs:
+      #   # ANY VALUE: ["any", "value", "modified"]
+      #   # any value: ["any", "value"]
+      # @example building instances with custom shared data
+      #   shared_array = %w[this is shared]
+      #   instance_a = Radius::Spec::ModelFactory.build(
+      #     "AnyClass",
+      #     array_attr: shared_array,
+      #     simple_attr: "Instance A",
+      #   )
+      #   instance_b = Radius::Spec::ModelFactory.build(
+      #     "AnyClass",
+      #     array_attr: shared_array,
+      #     simple_attr: "Instance B",
+      #   )
+      #   instance_a.array_attr << "modified"
+      #   puts "#{instance_a.simple_attr}: #{instance_a.array_attr}"
+      #   puts "#{instance_b.simple_attr}: #{instance_b.array_attr}"
+      #
+      #   # Outputs:
+      #   # Instance A: ["this", "is", "shared", "modified"]
+      #   # Instance B: ["this", "is", "shared", "modified"]
+      # @param name [Class, String, Symbol] fully qualified domain model class
+      #   name or constant
+      # @param custom_attrs [Hash{String,Symbol => Object}] hash of custom
+      #   attributes to replace registered template default values
+      # @param block optional block which is passed through to `new` when
+      #   instantiating `name`
+      # @return instance of `name` instantiated with `custom_attrs` and the
+      #   registered template attributes
+      # @raise [TemplateNotFound] when no template is defined for `name`
+      # @see .define_factory
+      def build(name, custom_attrs = {}, &block)
+        name = name.to_s
+        template = ::Radius::Spec::ModelFactory.template(name)
+        template_only = template.keys - custom_attrs.keys
+        attrs = template.slice(*template_only)
+                        .delete_if { |_, v| :optional == v }
+                        .transform_values! { |v|
+                          ::Radius::Spec::ModelFactory.safe_transform(v)
+                        }
+                        .merge(custom_attrs)
+        # TODO: Always yield to the provided block even if new doesn't
+        ::Object.const_get(name).new(attrs, &block)
+      end
+
+      # Convenience wrapper for building, and persisting, a model template.
+      #
+      # This is a thin wrapper around `build(name, attrs).tap(&:save!)`. The
+      # persistence message `save!` will only be called on objects which
+      # respond to it.
+      #
+      # ### Avoid for New Code
+      #
+      # It is strongly suggested that you avoid using `create` for new code.
+      # Instead be explicit about when and how objects are persisted. This
+      # allows you to have fine grain control over how your data is setup.
+      #
+      # We suggest that you create instances which need to be persisted before
+      # your specs using the following syntax:
+      #
+      # ```ruby
+      # let(:an_instance) { build("AnyClass") }
+      #
+      # before do
+      #   an_instance.save!
+      # end
+      # ```
+      #
+      # Alternatively if you really want for the instance be lazy instantiated,
+      # and persisted, pass the appropriate persistence method as the block:
+      #
+      # ```ruby
+      # let(:an_instance) { build("AnyClass", &:save!) }
+      # ```
+      #
+      # @param (see .build)
+      # @return (see .build)
+      # @raise (see .build)
+      # @see .build
+      # @see .define_factory
+      def create(name, custom_attrs = {}, &block)
+        instance = build(name, custom_attrs, &block)
+        instance.save! if instance.respond_to?(:save!)
+        instance
+      end
+    end
+  end
+end
+
+# Try to load the factories defined for the specs
+# rubocop:disable Lint/HandleExceptions
+begin
+  require 'support/model_factories'
+rescue LoadError
+  # Ignore as this is an optional convenience feature
+end
+# rubocop:enable Lint/HandleExceptions

data/lib/radius/spec/rails.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Ensure the gem, and default RSpec config, are already loaded
+require 'radius/spec'
+require 'radius/spec/rspec'
+require 'rspec/rails'
+
+RSpec.configure do
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = ::Rails.root.join("spec", "fixtures")
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # Filter lines from Rails gems in backtraces.
+  config.filter_rails_from_backtrace!
+  # arbitrary gems may also be filtered via:
+  # config.filter_gems_from_backtrace("gem name")
+
+  # Skip system tests by default.
+  #
+  # This is what Rails does by default:
+  #
+  # > By default, running `bin/rails` test won't run your system tests. Make
+  # > sure to run `bin/rails test:system` to actually run them.
+  #
+  # Running system tests often requires additional external dependencies. Not
+  # every project is setup to install all of the system test dependencies by
+  # default. To avoid issues across projects we default to excluding these
+  # specs. Projects are free to overwrite this filter in their custom RSpec
+  # configuration.
+  #
+  # This can be overridden on the command line:
+  #
+  #     bin/rspec -t type:system
+  #
+  # See:
+  #   - http://guides.rubyonrails.org/v5.1.4/testing.html#implementing-a-system-test
+  #   - https://relishapp.com/rspec/rspec-core/v/3-7/docs/filtering/exclusion-filters
+  #   - http://rspec.info/documentation/3.7/rspec-core/RSpec/Core/Configuration.html#filter_run_excluding-instance_method
+  config.filter_run_excluding type: "system"
+
+  # Always clear the cache before specs to avoid state leak problems
+  config.before do
+    Rails.cache.clear
+  end
+end

data/lib/radius/spec/rspec.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+    mocks.allow_message_expectations_on_nil = false
+    mocks.verify_doubled_constant_names = (
+      ENV.key?("CI") || !config.files_to_run.one?
+    )
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # RSpec will exit with code 0 indicating success if no examples are defined.
+  # This option allows you to configure RSpec to exit with code 1 indicating
+  # failure. This is useful in CI environments, as it helps detect when you've
+  # misconfigured RSpec to look for specs in the wrong place or with the wrong
+  # pattern. See http://rspec.info/blog/2017/05/rspec-3-6-has-been-released/#core-configfailifnoexamples
+  config.fail_if_no_examples = true
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10 if ENV["CI"]
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  config.when_first_matching_example_defined(
+    :model_factory,
+    :model_factories,
+  ) do
+    require 'radius/spec/model_factory'
+    config.include Radius::Spec::ModelFactory, :model_factory, :model_factories
+  end
+
+  config.when_first_matching_example_defined(type: :controller) do
+    require 'radius/spec/model_factory'
+    config.include Radius::Spec::ModelFactory, type: :controller
+  end
+
+  config.when_first_matching_example_defined(type: :feature) do
+    require 'radius/spec/model_factory'
+    config.include Radius::Spec::ModelFactory, type: :feature
+  end
+
+  config.when_first_matching_example_defined(type: :job) do
+    require 'radius/spec/model_factory'
+    config.include Radius::Spec::ModelFactory, type: :job
+  end
+
+  config.when_first_matching_example_defined(type: :model) do
+    require 'radius/spec/model_factory'
+    config.include Radius::Spec::ModelFactory, type: :model
+  end
+
+  config.when_first_matching_example_defined(type: :request) do
+    require 'radius/spec/model_factory'
+    config.include Radius::Spec::ModelFactory, type: :request
+  end
+
+  config.when_first_matching_example_defined(type: :system) do
+    require 'radius/spec/model_factory'
+    config.include Radius::Spec::ModelFactory, type: :system
+  end
+end

data/lib/radius/spec/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Radius
+  module Spec
+    VERSION = "0.1.0"
+  end
+end

data/lib/radius/spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "radius/spec/version"
+
+module Radius
+  # Namespace for RSpec plug-ins and helpers
+  module Spec
+  end
+end
+
+require "radius/spec/rspec" if defined?(RSpec)