factory_girl 4.5.0 → 4.7.0

data/spec/support/matchers/callback.rb

@@ -1,9 +0,0 @@
-RSpec::Matchers.define :have_callback do |callback_name|
-  match do |instance|
-    instance.callbacks.include?(FactoryGirl::Callback.new(callback_name, @block))
-  end
-
-  chain :with_block do |block|
-    @block = block
-  end
-end

data/spec/support/matchers/declaration.rb

@@ -1,83 +0,0 @@
-module DeclarationMatchers
-  def have_static_declaration(name)
-    DeclarationMatcher.new(:static).named(name)
-  end
-
-  def have_dynamic_declaration(name)
-    DeclarationMatcher.new(:dynamic).named(name)
-  end
-
-  def have_association_declaration(name)
-    DeclarationMatcher.new(:association).named(name)
-  end
-
-  def have_implicit_declaration(name)
-    DeclarationMatcher.new(:implicit).named(name)
-  end
-
-  class DeclarationMatcher
-    def initialize(declaration_type)
-      @declaration_type = declaration_type
-    end
-
-    def matches?(subject)
-      subject.declarations.include?(expected_declaration)
-    end
-
-    def named(name)
-      @name = name
-      self
-    end
-
-    def ignored
-      @ignored = true
-      self
-    end
-
-    def with_value(value)
-      @value = value
-      self
-    end
-
-    def with_factory(factory)
-      @factory = factory
-      self
-    end
-
-    def with_options(options)
-      @options = options
-      self
-    end
-
-    def failure_message
-      [
-        "expected declarations to include declaration of type #{@declaration_type}",
-        @options ? "with options #{options}" : nil
-      ].compact.join ' '
-    end
-
-    private
-
-    def expected_declaration
-      case @declaration_type
-      when :static      then FactoryGirl::Declaration::Static.new(@name, @value, ignored?)
-      when :dynamic     then FactoryGirl::Declaration::Dynamic.new(@name, ignored?, @value)
-      when :implicit    then FactoryGirl::Declaration::Implicit.new(@name, @factory, ignored?)
-      when :association
-        if @options
-          FactoryGirl::Declaration::Association.new(@name, options)
-        else
-          FactoryGirl::Declaration::Association.new(@name)
-        end
-      end
-    end
-
-    def ignored?
-      !!@ignored
-    end
-
-    def options
-      @options || {}
-    end
-  end
-end

data/spec/support/matchers/delegate.rb

@@ -1,44 +0,0 @@
-RSpec::Matchers.define :delegate do |delegated_method|
-  chain :to do |target_method|
-    @target_method = target_method
-  end
-
-  chain :as do |method_on_target|
-    @method_on_target = method_on_target
-  end
-
-  chain :with_arguments do |args|
-    @args = args
-  end
-
-  match do |instance|
-    extend Mocha::API
-
-    @instance = instance
-    @args ||= []
-    return_value = 'stubbed return value'
-    method_on_target = @method_on_target || delegated_method
-    stubbed_target = stub('stubbed_target', method_on_target => return_value)
-    @instance.stubs(@target_method => stubbed_target)
-    begin
-      @instance.send(delegated_method, *@args) == return_value
-    rescue NoMethodError
-      false
-    end
-  end
-
-  failure_message_for_should do
-    if Class === @instance
-      message = "expected #{@instance.name} "
-      prefix = '.'
-    else
-      message = "expected #{@instance.class.name} "
-      prefix = '#'
-    end
-    message << "to delegate #{prefix}#{delegated_method} to #{prefix}#{@target_method}"
-    if @method_on_target
-      message << ".#{@method_on_target}"
-    end
-    message
-  end
-end

data/spec/support/matchers/trait.rb

@@ -1,11 +0,0 @@
-RSpec::Matchers.define :have_trait do |trait_name|
-  match do |instance|
-    instance.defined_traits.any? do |trait|
-      trait.name == trait_name && trait.send(:block) == @block
-    end
-  end
-
-  chain :with_block do |block|
-    @block = block
-  end
-end

data/spec/support/shared_examples/strategy.rb

@@ -1,90 +0,0 @@
-shared_examples_for "strategy without association support" do
-  let(:factory)   { stub("associate_factory") }
-  let(:attribute) { FactoryGirl::Attribute::Association.new(:user, :user, {}) }
-
-  def association_named(name, overrides)
-    runner = FactoryGirl::FactoryRunner.new(name, :build, [overrides])
-    subject.association(runner)
-  end
-
-  before do
-    FactoryGirl.stubs(factory_by_name: factory)
-    factory.stubs(:compile)
-    factory.stubs(:run)
-  end
-
-  it "returns nil when accessing an association" do
-    expect(association_named(:user, {})).to be_nil
-  end
-end
-
-shared_examples_for "strategy with association support" do |factory_girl_strategy_name|
-  let(:factory) { stub("associate_factory") }
-
-  def association_named(name, strategy, overrides)
-    runner = FactoryGirl::FactoryRunner.new(name, strategy, [overrides])
-    subject.association(runner)
-  end
-
-  before do
-    FactoryGirl.stubs(factory_by_name: factory)
-    factory.stubs(:compile)
-    factory.stubs(:run)
-  end
-
-  it "runs the factory with the correct overrides" do
-    association_named(:author, factory_girl_strategy_name, great: "value")
-    expect(factory).to have_received(:run).with(factory_girl_strategy_name, great: "value")
-  end
-
-  it "finds the factory with the correct factory name" do
-    association_named(:author, factory_girl_strategy_name, great: "value")
-    expect(FactoryGirl).to have_received(:factory_by_name).with(:author)
-  end
-end
-
-shared_examples_for "strategy with strategy: :build" do |factory_girl_strategy_name|
-  let(:factory) { stub("associate_factory") }
-
-  def association_named(name, overrides)
-    runner = FactoryGirl::FactoryRunner.new(name, overrides[:strategy], [overrides.except(:strategy)])
-    subject.association(runner)
-  end
-
-  before do
-    FactoryGirl.stubs(factory_by_name: factory)
-    factory.stubs(:compile)
-    factory.stubs(:run)
-  end
-
-  it "runs the factory with the correct overrides" do
-    association_named(:author, strategy: :build, great: "value")
-    expect(factory).to have_received(:run).with(factory_girl_strategy_name, { great: "value" })
-  end
-
-  it "finds the factory with the correct factory name" do
-    association_named(:author, strategy: :build, great: "value")
-    expect(FactoryGirl).to have_received(:factory_by_name).with(:author)
-  end
-end
-
-shared_examples_for "strategy with callbacks" do |*callback_names|
-  let(:result_instance) do
-    define_class("ResultInstance") do
-      attr_accessor :id
-    end.new
-  end
-
-  let(:evaluation) { stub("evaluation", object: result_instance, notify: true, create: nil) }
-
-  it "runs the callbacks #{callback_names} with the evaluation's object" do
-    subject.result(evaluation)
-    callback_names.each do |name|
-      expect(evaluation).to have_received(:notify).with(name, evaluation.object)
-    end
-  end
-
-  it "returns the object from the evaluation" do
-    expect(subject.result(evaluation)).to eq evaluation.object
-  end
-end