factory_girl 4.5.0 → 4.7.0

data/spec/factory_girl/null_object_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-describe FactoryGirl::NullObject do
-  let(:methods_to_respond_to)     { %w[id age name admin?] }
-  let(:methods_to_not_respond_to) { %w[email date_of_birth title] }
-
-  subject { FactoryGirl::NullObject.new(methods_to_respond_to) }
-
-  it "responds to the given methods" do
-    methods_to_respond_to.each do |method_name|
-      expect(subject.__send__(method_name)).to be_nil
-      expect(subject).to respond_to(method_name)
-    end
-  end
-
-  it "does not respond to other methods" do
-    methods_to_not_respond_to.each do |method_name|
-      expect { subject.__send__(method_name) }.to raise_error(NoMethodError)
-      expect(subject).not_to respond_to(method_name)
-    end
-  end
-end

data/spec/factory_girl/registry_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe FactoryGirl::Registry do
-  let(:registered_object)        { stub("registered object") }
-  let(:second_registered_object) { stub("second registered object") }
-
-  subject { FactoryGirl::Registry.new("Great thing") }
-
-  it { should be_kind_of(Enumerable) }
-
-  it "finds a registered object" do
-    subject.register(:object_name, registered_object)
-    expect(subject.find(:object_name)).to eq registered_object
-  end
-
-  it "finds a registered object with square brackets" do
-    subject.register(:object_name, registered_object)
-    expect(subject[:object_name]).to eq registered_object
-  end
-
-  it "raises when an object cannot be found" do
-    expect { subject.find(:object_name) }.to raise_error(ArgumentError, "Great thing not registered: object_name")
-  end
-
-  it "adds and returns the object registered" do
-    expect(subject.register(:object_name, registered_object)).to eq registered_object
-  end
-
-  it "knows that an object is registered by symbol" do
-    subject.register(:object_name, registered_object)
-    expect(subject).to be_registered(:object_name)
-  end
-
-  it "knows that an object is registered by string" do
-    subject.register(:object_name, registered_object)
-    expect(subject).to be_registered("object_name")
-  end
-
-  it "knows when an object is not registered" do
-    expect(subject).not_to be_registered("bogus")
-  end
-
-  it "iterates registered objects" do
-    subject.register(:first_object, registered_object)
-    subject.register(:second_object, second_registered_object)
-    expect(subject.to_a).to eq [registered_object, second_registered_object]
-  end
-
-  it "does not include duplicate objects with registered under different names" do
-    subject.register(:first_object, registered_object)
-    subject.register(:second_object, registered_object)
-    expect(subject.to_a).to eq [registered_object]
-  end
-
-  it "clears registered factories" do
-    subject.register(:object_name, registered_object)
-    subject.clear
-    expect(subject.count).to be_zero
-  end
-
-  it "registers classes" do
-    define_class("User")
-    subject.register(User, registered_object)
-    expect(subject.to_a).to eq [registered_object]
-    expect(subject.find(:user)).to eq registered_object
-    expect(subject.find(User)).to eq registered_object
-  end
-end

data/spec/factory_girl/sequence_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-describe FactoryGirl::Sequence do
-  describe "a basic sequence" do
-    let(:name) { :test }
-    subject    { FactoryGirl::Sequence.new(name) { |n| "=#{n}" } }
-
-    its(:name)  { should eq name }
-    its(:names) { should eq [name] }
-    its(:next)  { should eq "=1" }
-
-    describe "when incrementing" do
-      before     { subject.next }
-      its(:next) { should eq "=2" }
-    end
-  end
-
-  describe "a custom sequence" do
-    subject    { FactoryGirl::Sequence.new(:name, "A") { |n| "=#{n}" } }
-    its(:next) { should eq "=A" }
-
-    describe "when incrementing" do
-      before     { subject.next }
-      its(:next) { should eq "=B" }
-    end
-  end
-
-  describe "a sequence with aliases using default value" do
-    subject     { FactoryGirl::Sequence.new(:test, aliases: [:alias, :other]) { |n| "=#{n}" } }
-    its(:next)  { should eq "=1" }
-    its(:names) { should eq [:test, :alias, :other] }
-
-    describe "when incrementing" do
-      before     { subject.next }
-      its(:next) { should eq "=2" }
-    end
-  end
-
-  describe "a sequence with custom value and aliases" do
-    subject    { FactoryGirl::Sequence.new(:test, 3, aliases: [:alias, :other]) { |n| "=#{n}" } }
-    its(:next) { should eq "=3" }
-
-    describe "when incrementing" do
-      before     { subject.next }
-      its(:next) { should eq "=4" }
-    end
-  end
-
-  describe "a basic sequence without a block" do
-    subject    { FactoryGirl::Sequence.new(:name) }
-    its(:next) { should eq 1 }
-
-    describe "when incrementing" do
-      before     { subject.next }
-      its(:next) { should eq 2 }
-    end
-  end
-
-  describe "a custom sequence without a block" do
-    subject    { FactoryGirl::Sequence.new(:name, "A") }
-    its(:next) { should eq "A" }
-
-    describe "when incrementing" do
-      before     { subject.next }
-      its(:next) { should eq "B" }
-    end
-  end
-
-  describe "iterating over items in an enumerator" do
-    subject { FactoryGirl::Sequence.new(:name, %w[foo bar].to_enum) { |n| "=#{n}" } }
-
-    it "navigates to the next items until no items remain" do
-      expect(subject.next).to eq "=foo"
-      expect(subject.next).to eq "=bar"
-      expect { subject.next }.to raise_error(StopIteration)
-    end
-  end
-
-  describe "a custom sequence and scope" do
-    subject { FactoryGirl::Sequence.new(:name, 'A') { |n| "=#{n}#{foo}" } }
-    let(:scope) { stub('scope', foo: 'attribute') }
-
-    it 'increments within the correct scope' do
-      expect(subject.next(scope)).to eq '=Aattribute'
-    end
-
-    describe 'when incrementing' do
-      before { subject.next(scope) }
-
-      it 'increments within the correct scope' do
-        expect(subject.next(scope)).to eq '=Battribute'
-      end
-    end
-  end
-end

data/spec/factory_girl/strategy/attributes_for_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe FactoryGirl::Strategy::AttributesFor do
-  let(:result)     { { name: "John Doe", gender: "Male", admin: false } }
-  let(:evaluation) { stub("evaluation", hash: result) }
-
-  it_should_behave_like "strategy without association support"
-
-  it "returns the hash from the evaluation" do
-    expect(subject.result(evaluation)).to eq result
-  end
-
-  it "does not run the to_create block" do
-    expect do
-      subject.result(evaluation)
-    end.to_not raise_error
-  end
-end

data/spec/factory_girl/strategy/build_spec.rb

@@ -1,7 +0,0 @@
-require "spec_helper"
-
-describe FactoryGirl::Strategy::Build do
-  it_should_behave_like "strategy with association support", :create
-  it_should_behave_like "strategy with callbacks", :after_build
-  it_should_behave_like "strategy with strategy: :build", :build
-end

data/spec/factory_girl/strategy/create_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe FactoryGirl::Strategy::Create do
-  it_should_behave_like "strategy with association support", :create
-  it_should_behave_like "strategy with callbacks", :after_build, :before_create, :after_create
-
-  it "runs a custom create block" do
-    evaluation_class = Class.new do
-      def initialize
-        @block_run = false
-      end
-
-      attr_reader :block_run
-
-      def create(*instance)
-        @block_run = true
-      end
-    end
-
-    evaluation = evaluation_class.new
-    evaluation.stubs(object: nil, notify: nil)
-    subject.result(evaluation)
-    expect(evaluation.block_run).to be_true
-  end
-end

data/spec/factory_girl/strategy/stub_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe FactoryGirl::Strategy::Stub do
-  it_should_behave_like "strategy with association support", :build_stubbed
-  it_should_behave_like "strategy with callbacks", :after_stub
-  it_should_behave_like "strategy with strategy: :build", :build_stubbed
-
-  context "asking for a result" do
-    before { Timecop.freeze(Time.now) }
-    let(:result_instance) do
-      define_class("ResultInstance") do
-        attr_accessor :id
-      end.new
-    end
-
-    let(:evaluation)  { stub("evaluation", object: result_instance, notify: true) }
-
-    it { expect(subject.result(evaluation)).not_to be_new_record }
-    it { expect(subject.result(evaluation)).to be_persisted }
-
-    it "assigns created_at" do
-      created_at = subject.result(evaluation).created_at
-      expect(created_at).to eq Time.now
-
-      Timecop.travel(150000)
-
-      expect(subject.result(evaluation).created_at).to eq created_at
-    end
-
-    [:save, :destroy, :connection, :reload, :update_attribute, :update_column].each do |database_method|
-      it "raises when attempting to connect to the database by calling #{database_method}" do
-        expect do
-          subject.result(evaluation).send(database_method)
-        end.to raise_error(RuntimeError, "stubbed models are not allowed to access the database - #{subject.result(evaluation).class}##{database_method}()")
-      end
-    end
-  end
-end

data/spec/factory_girl/strategy_calculator_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-describe FactoryGirl::StrategyCalculator do
-  let(:strategy) do
-    define_class("MyAwesomeClass")
-  end
-
-  context "when a class" do
-    subject { FactoryGirl::StrategyCalculator.new(strategy).strategy }
-
-    it "returns the class passed" do
-      expect(subject).to eq strategy
-    end
-  end
-
-  context "when a symbol" do
-    before  { FactoryGirl.stubs(:strategy_by_name).returns(strategy) }
-    subject { FactoryGirl::StrategyCalculator.new(:build).strategy }
-
-    it "finds the strategy by name" do
-      subject
-      expect(FactoryGirl).to have_received(:strategy_by_name).with(:build)
-    end
-
-    it "returns the strategy found" do
-      expect(subject).to eq strategy
-    end
-  end
-end

data/spec/factory_girl_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-describe FactoryGirl do
-  let(:factory)  { FactoryGirl::Factory.new(:object) }
-  let(:sequence) { FactoryGirl::Sequence.new(:email) }
-  let(:trait)    { FactoryGirl::Trait.new(:admin) }
-
-  it "finds a registered factory" do
-    FactoryGirl.register_factory(factory)
-    expect(FactoryGirl.factory_by_name(factory.name)).to eq factory
-  end
-
-  it "finds a registered sequence" do
-    FactoryGirl.register_sequence(sequence)
-    expect(FactoryGirl.sequence_by_name(sequence.name)).to eq sequence
-  end
-
-  it "finds a registered trait" do
-    FactoryGirl.register_trait(trait)
-    expect(FactoryGirl.trait_by_name(trait.name)).to eq trait
-  end
-end

data/spec/spec_helper.rb

@@ -1,26 +0,0 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
-$LOAD_PATH << File.join(File.dirname(__FILE__))
-
-require 'rubygems'
-require 'rspec'
-require 'rspec/autorun'
-
-require "simplecov"
-
-require 'factory_girl'
-require "mocha/api"
-require "bourne"
-require "timecop"
-
-Dir["spec/support/**/*.rb"].each { |f| require File.expand_path(f) }
-
-RSpec.configure do |config|
-  config.mock_framework = :mocha
-
-  config.include DeclarationMatchers
-
-  config.after do
-    Timecop.return
-    FactoryGirl.reload
-  end
-end

data/spec/support/macros/define_constant.rb

@@ -1,86 +0,0 @@
-require 'active_record'
-
-module DefineConstantMacros
-  def define_class(path, base = Object, &block)
-    namespace, class_name = *constant_path(path)
-    klass = Class.new(base)
-    namespace.const_set(class_name, klass)
-    klass.class_eval(&block) if block_given?
-    @defined_constants << path
-    klass
-  end
-
-  def define_model(name, columns = {}, &block)
-    model = define_class(name, ActiveRecord::Base, &block)
-    create_table(model.table_name) do |table|
-      columns.each do |column_name, type|
-        table.column column_name, type
-      end
-    end
-    model
-  end
-
-  def create_table(table_name, &block)
-    connection = ActiveRecord::Base.connection
-
-    begin
-      connection.execute("DROP TABLE IF EXISTS #{table_name}")
-      connection.create_table(table_name, &block)
-      @created_tables << table_name
-      connection
-    rescue Exception => exception
-      connection.execute("DROP TABLE IF EXISTS #{table_name}")
-      raise exception
-    end
-  end
-
-  def constant_path(constant_name)
-    names = constant_name.split('::')
-    class_name = names.pop
-    namespace = names.inject(Object) { |result, name| result.const_get(name) }
-    [namespace, class_name]
-  end
-
-  def default_constants
-    @defined_constants ||= []
-    @created_tables    ||= []
-  end
-
-  def clear_generated_constants
-    @defined_constants.reverse.each do |path|
-      namespace, class_name = *constant_path(path)
-      namespace.send(:remove_const, class_name)
-    end
-
-    @defined_constants.clear
-  end
-
-  def clear_generated_tables
-    @created_tables.each do |table_name|
-      ActiveRecord::Base.
-        connection.
-        execute("DROP TABLE IF EXISTS #{table_name}")
-    end
-    @created_tables.clear
-  end
-end
-
-RSpec.configure do |config|
-  config.include DefineConstantMacros
-
-  config.before(:all) do
-    ActiveRecord::Base.establish_connection(
-      adapter:  'sqlite3',
-      database: File.join(File.dirname(__FILE__), 'test.db')
-    )
-  end
-
-  config.before do
-    default_constants
-  end
-
-  config.after do
-    clear_generated_constants
-    clear_generated_tables
-  end
-end