challah 0.5.2 → 0.5.3

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/find_definitions_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+share_examples_for "finds definitions" do
+  before do
+    FactoryGirl.stubs(:load)
+    FactoryGirl.find_definitions
+  end
+
+  subject { FactoryGirl }
+end
+
+RSpec::Matchers.define :load_definitions_from do |file|
+  match do |given|
+    @has_received = have_received(:load).with(File.expand_path(file))
+    @has_received.matches?(given)
+  end
+
+  description do
+    "load definitions from #{file}"
+  end
+
+  failure_message_for_should do
+    @has_received.failure_message
+  end
+end
+
+describe "definition loading" do
+  def self.in_directory_with_files(*files)
+    before do
+      @pwd = Dir.pwd
+      @tmp_dir = File.join(File.dirname(__FILE__), 'tmp')
+      FileUtils.mkdir_p @tmp_dir
+      Dir.chdir(@tmp_dir)
+
+      files.each do |file|
+        FileUtils.mkdir_p File.dirname(file)
+        FileUtils.touch file
+      end
+    end
+
+    after do
+      Dir.chdir(@pwd)
+      FileUtils.rm_rf(@tmp_dir)
+    end
+  end
+
+  describe "with factories.rb" do
+    in_directory_with_files 'factories.rb'
+    it_should_behave_like "finds definitions" do
+      it { should load_definitions_from('factories.rb') }
+    end
+  end
+
+  %w(spec test).each do |dir|
+    describe "with a factories file under #{dir}" do
+      in_directory_with_files File.join(dir, 'factories.rb')
+      it_should_behave_like "finds definitions" do
+        it { should load_definitions_from("#{dir}/factories.rb") }
+      end
+    end
+
+    describe "with a factories file under #{dir}/factories" do
+      in_directory_with_files File.join(dir, 'factories', 'post_factory.rb')
+      it_should_behave_like "finds definitions" do
+        it { should load_definitions_from("#{dir}/factories/post_factory.rb") }
+      end
+    end
+
+    describe "with several factories files under #{dir}/factories" do
+      in_directory_with_files File.join(dir, 'factories', 'post_factory.rb'),
+                              File.join(dir, 'factories', 'person_factory.rb')
+      it_should_behave_like "finds definitions" do
+        it { should load_definitions_from("#{dir}/factories/post_factory.rb") }
+        it { should load_definitions_from("#{dir}/factories/person_factory.rb") }
+      end
+    end
+
+    describe "with several factories files under #{dir}/factories in non-alphabetical order" do
+      in_directory_with_files File.join(dir, 'factories', 'b.rb'),
+                              File.join(dir, 'factories', 'a.rb')
+      it "loads the files in the right order" do
+        FactoryGirl.stubs(:load)
+        sorted_load_order = sequence("load order")
+        FactoryGirl.expects(:load).with(includes("a.rb")).in_sequence(sorted_load_order)
+        FactoryGirl.expects(:load).with(includes("b.rb")).in_sequence(sorted_load_order)
+        FactoryGirl.find_definitions
+      end
+    end
+
+    describe "with nested and unnested factories files under #{dir}" do
+      in_directory_with_files File.join(dir, 'factories.rb'),
+                              File.join(dir, 'factories', 'post_factory.rb'),
+                              File.join(dir, 'factories', 'person_factory.rb')
+      it_should_behave_like "finds definitions" do
+        it { should load_definitions_from("#{dir}/factories.rb") }
+        it { should load_definitions_from("#{dir}/factories/post_factory.rb") }
+        it { should load_definitions_from("#{dir}/factories/person_factory.rb") }
+      end
+    end
+
+    describe "with deeply nested factory files under #{dir}" do
+      in_directory_with_files File.join(dir, 'factories', 'subdirectory', 'post_factory.rb'),
+                              File.join(dir, 'factories', 'subdirectory', 'person_factory.rb')
+      it_should_behave_like "finds definitions" do
+        it { should load_definitions_from("#{dir}/factories/subdirectory/post_factory.rb") }
+        it { should load_definitions_from("#{dir}/factories/subdirectory/person_factory.rb") }
+      end
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/null_factory_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe FactoryGirl::NullFactory do
+  it { should delegate(:defined_traits).to(:definition) }
+  it { should delegate(:callbacks).to(:definition) }
+  it { should delegate(:attributes).to(:definition) }
+  it { should delegate(:constructor).to(:definition) }
+
+  its(:compile)         { should be_nil }
+  its(:class_name)      { should be_nil }
+  its(:attributes)      { should be_an_instance_of(FactoryGirl::AttributeList) }
+  its(:evaluator_class) { should == FactoryGirl::Evaluator }
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/null_object_spec.rb

@@ -0,0 +1,8 @@
+require "spec_helper"
+
+describe FactoryGirl::NullObject do
+  its(:id)     { should be_nil }
+  its(:age)    { should be_nil }
+  its(:name)   { should be_nil }
+  its(:admin?) { should be_nil }
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/registry_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe FactoryGirl::Registry do
+  let(:aliases)              { [:thing, :widget] }
+  let(:sequence)             { FactoryGirl::Sequence.new(:email) { |n| "somebody#{n}@example.com" } }
+  let(:factory)              { FactoryGirl::Factory.new(:object) }
+  let(:other_factory)        { FactoryGirl::Factory.new(:string) }
+  let(:factory_with_aliases) { FactoryGirl::Factory.new(:string, aliases: aliases) }
+  let(:registry_name)        { "Factory" }
+
+  subject { FactoryGirl::Registry.new(registry_name) }
+
+  it { should be_kind_of(Enumerable) }
+
+  it "finds a registered a factory" do
+    subject.add(factory)
+    subject.find(factory.name).should == factory
+  end
+
+  it "raises when finding an unregistered factory" do
+    expect { subject.find(:bogus) }.to raise_error(ArgumentError, "Factory not registered: bogus")
+  end
+
+  it "adds and returns a factory" do
+    subject.add(factory).should == factory
+  end
+
+  it "knows that a factory is registered by symbol" do
+    subject.add(factory)
+    subject.should be_registered(factory.name.to_sym)
+  end
+
+  it "knows that a factory is registered by string" do
+    subject.add(factory)
+    subject.should be_registered(factory.name.to_s)
+  end
+
+  it "knows that a factory isn't registered" do
+    subject.should_not be_registered("bogus")
+  end
+
+  it "can be accessed like a hash" do
+    subject.add(factory)
+    subject[factory.name].should == factory
+  end
+
+  it "iterates registered factories" do
+    subject.add(factory)
+    subject.add(other_factory)
+    subject.to_a.should =~ [factory, other_factory]
+  end
+
+  it "iterates registered factories uniquely with aliases" do
+    subject.add(factory)
+    subject.add(factory_with_aliases)
+    subject.to_a.should =~ [factory, factory_with_aliases]
+  end
+
+  it "registers an sequence" do
+    subject.add(sequence)
+    subject.find(:email).should == sequence
+  end
+
+  it "doesn't allow a duplicate name" do
+    expect { 2.times { subject.add(factory) } }.
+      to raise_error(FactoryGirl::DuplicateDefinitionError, "Factory already registered: object")
+  end
+
+  it "registers aliases" do
+    subject.add(factory_with_aliases)
+    aliases.each do |name|
+      subject.find(name).should == factory_with_aliases
+    end
+  end
+
+  it "clears registered factories" do
+    subject.add(factory)
+    subject.clear
+    subject.count.should be_zero
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/sequence_spec.rb

@@ -0,0 +1,47 @@
+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 == name }
+    its(:names) { should == [name] }
+    its(:next)  { should == "=1" }
+
+    describe "when incrementing" do
+      before     { subject.next }
+      its(:next) { should == "=2" }
+    end
+  end
+
+  describe "a custom sequence" do
+    subject    { FactoryGirl::Sequence.new(:name, "A") {|n| "=#{n}" } }
+    its(:next) { should == "=A" }
+
+    describe "when incrementing" do
+      before     { subject.next }
+      its(:next) { should == "=B" }
+    end
+  end
+
+  describe "a basic sequence without a block" do
+    subject    { FactoryGirl::Sequence.new(:name) }
+    its(:next) { should == 1 }
+
+    describe "when incrementing" do
+      before     { subject.next }
+      its(:next) { should == 2 }
+    end
+  end
+
+  describe "a custom sequence without a block" do
+    subject    { FactoryGirl::Sequence.new(:name, "A") }
+    its(:next) { should == "A" }
+
+    describe "when incrementing" do
+      before     { subject.next }
+      its(:next) { should == "B" }
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/strategy/attributes_for_spec.rb

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

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/strategy/build_spec.rb

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

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/strategy/create_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe FactoryGirl::Strategy::Create do
+  it_should_behave_like "strategy with association support", FactoryGirl::Strategy::Create
+  it_should_behave_like "strategy with callbacks", :after_build, :after_create
+
+  it "runs a custom create block" do
+    block_run = false
+    block = lambda {|instance| block_run = true }
+    subject.result(stub("assigner", object: stub("result instance")), block)
+    block_run.should be_true
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/strategy/stub_spec.rb

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

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/strategy_calculator_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe FactoryGirl::StrategyCalculator, "with a FactoryGirl::Strategy object" do
+  let(:strategy) { FactoryGirl::Strategy::Build }
+
+  it "returns the strategy object" do
+    FactoryGirl::StrategyCalculator.new(strategy).strategy.should == strategy
+  end
+end
+
+describe FactoryGirl::StrategyCalculator, "with a non-FactoryGirl::Strategy object" do
+  before { define_class "MyAwesomeStrategy" }
+
+  let(:strategy) { MyAwesomeStrategy }
+
+  it "returns the strategy object" do
+    expect { FactoryGirl::StrategyCalculator.new(strategy).strategy }.to raise_error "unrecognized method MyAwesomeStrategy"
+  end
+end
+
+describe FactoryGirl::StrategyCalculator do
+  it "returns the correct strategy object for :build" do
+    FactoryGirl::StrategyCalculator.new(:build).strategy.should == FactoryGirl::Strategy::Build
+  end
+
+  it "returns the correct strategy object for :create" do
+    FactoryGirl::StrategyCalculator.new(:create).strategy.should == FactoryGirl::Strategy::Create
+  end
+
+  it "raises when passing a bogus strategy" do
+    expect { FactoryGirl::StrategyCalculator.new(:bogus_strategy).strategy }.to raise_error "unrecognized method bogus_strategy"
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/strategy_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe FactoryGirl::Strategy do
+  it "raises an error when asking for the result" do
+    expect { subject.result(stub("assigner"), lambda {|instance| instance }) }.to raise_error(NotImplementedError, "Strategies must return a result")
+  end
+
+  it "raises an error when asking for the association" do
+    expect { subject.association(stub("runner")) }.to raise_error(NotImplementedError, "Strategies must return an association")
+  end
+end
+
+describe FactoryGirl::Strategy, ".ensure_strategy_exists!" do
+  it "raises when passed a nonexistent strategy" do
+    expect { FactoryGirl::Strategy.ensure_strategy_exists!(:nonexistent) }.to raise_error(ArgumentError, "Unknown strategy: nonexistent")
+  end
+
+  it "doesn't raise when passed a valid strategy" do
+    expect { FactoryGirl::Strategy.ensure_strategy_exists!(:create) }.to_not raise_error
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl_spec.rb

@@ -0,0 +1,22 @@
+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)
+    FactoryGirl.factory_by_name(factory.name).should == factory
+  end
+
+  it "finds a registered sequence" do
+    FactoryGirl.register_sequence(sequence)
+    FactoryGirl.sequence_by_name(sequence.name).should == sequence
+  end
+
+  it "finds a registered trait" do
+    FactoryGirl.register_trait(trait)
+    FactoryGirl.trait_by_name(trait.name).should == trait
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH << File.join(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'rspec'
+require 'rspec/autorun'
+
+require "simplecov"
+SimpleCov.start
+
+require 'factory_girl'
+require "mocha"
+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
+    FactoryGirl.reload
+  end
+end