challah 0.5.2 → 0.5.3

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

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+describe FactoryGirl::DeclarationList, "#attribute_list" do
+  let(:static_attribute_1)  { stub("static attribute 1") }
+  let(:static_attribute_2)  { stub("static attribute 2") }
+  let(:dynamic_attribute_1) { stub("dynamic attribute 1") }
+  let(:static_declaration)  { stub("static declaration", to_attributes: [static_attribute_1, static_attribute_2]) }
+  let(:dynamic_declaration) { stub("static declaration", to_attributes: [dynamic_attribute_1]) }
+
+  it "returns an AttributeList" do
+    subject.attribute_list.should be_a(FactoryGirl::AttributeList)
+  end
+
+  let(:attribute_list) { stub("attribute list", define_attribute: true) }
+
+  it "defines each attribute on the attribute list" do
+    FactoryGirl::AttributeList.stubs(new: attribute_list)
+
+    subject.declare_attribute(static_declaration)
+    subject.declare_attribute(dynamic_declaration)
+
+    subject.attribute_list
+
+    attribute_list.should have_received(:define_attribute).with(static_attribute_1)
+    attribute_list.should have_received(:define_attribute).with(static_attribute_2)
+    attribute_list.should have_received(:define_attribute).with(dynamic_attribute_1)
+  end
+
+  it "creates a new attribute list upon every invocation" do
+    subject.attribute_list.should_not == subject.attribute_list
+  end
+end
+
+describe FactoryGirl::DeclarationList, "#declare_attribute" do
+  let(:declaration_1)              { stub("declaration", name: "declaration 1") }
+  let(:declaration_2)              { stub("declaration", name: "declaration 2") }
+  let(:declaration_with_same_name) { stub("declaration", name: "declaration 1") }
+
+  context "when not overridable" do
+    it "adds the declaration to the list" do
+      subject.declare_attribute(declaration_1)
+      subject.to_a.should == [declaration_1]
+
+      subject.declare_attribute(declaration_2)
+      subject.to_a.should == [declaration_1, declaration_2]
+    end
+  end
+
+  context "when overridable" do
+    before { subject.overridable }
+
+    it "adds the declaration to the list" do
+      subject.declare_attribute(declaration_1)
+      subject.to_a.should == [declaration_1]
+
+      subject.declare_attribute(declaration_2)
+      subject.to_a.should == [declaration_1, declaration_2]
+    end
+
+    it "deletes declarations with the same name" do
+      subject.declare_attribute(declaration_1)
+      subject.to_a.should == [declaration_1]
+
+      subject.declare_attribute(declaration_2)
+      subject.to_a.should == [declaration_1, declaration_2]
+
+      subject.declare_attribute(declaration_with_same_name)
+      subject.to_a.should == [declaration_2, declaration_with_same_name]
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe FactoryGirl::DefinitionProxy, "#add_attribute" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "raises if both a block and value are given" do
+    expect {
+      proxy.add_attribute(:something, "great") { "will raise!" }
+    }.to raise_error(FactoryGirl::AttributeDefinitionError, "Both value and block given")
+  end
+
+  it "declares a static attribute on the factory" do
+    proxy.add_attribute(:attribute_name, "attribute value")
+    subject.should have_static_declaration(:attribute_name).with_value("attribute value")
+  end
+
+  it "declares a dynamic attribute on the factory" do
+    attribute_value = lambda { "dynamic attribute" }
+    proxy.add_attribute(:attribute_name, &attribute_value)
+    subject.should have_dynamic_declaration(:attribute_name).with_value(attribute_value)
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "#add_attribute when the proxy ignores attributes" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject, true) }
+
+  it "raises if both a block and value are given" do
+    expect {
+      proxy.add_attribute(:something, "great") { "will raise!" }
+    }.to raise_error(FactoryGirl::AttributeDefinitionError, "Both value and block given")
+  end
+
+  it "declares a static attribute on the factory" do
+    proxy.add_attribute(:attribute_name, "attribute value")
+    subject.should have_static_declaration(:attribute_name).ignored.with_value("attribute value")
+  end
+
+  it "declares a dynamic attribute on the factory" do
+    attribute_value = lambda { "dynamic attribute" }
+    proxy.add_attribute(:attribute_name, &attribute_value)
+    subject.should have_dynamic_declaration(:attribute_name).ignored.with_value(attribute_value)
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "#ignore" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "makes all attributes added ignored" do
+    proxy.ignore do
+      add_attribute(:attribute_name, "attribute value")
+    end
+
+    subject.should have_static_declaration(:attribute_name).ignored.with_value("attribute value")
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "#method_missing" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "declares an implicit declaration without args or a block" do
+    proxy.bogus
+    subject.should have_implicit_declaration(:bogus).with_factory(subject)
+  end
+
+  it "declares an association when :factory is passed" do
+    proxy.author factory: :user
+    subject.should have_association_declaration(:author).with_options(factory: :user)
+  end
+
+  it "declares a static attribute" do
+    proxy.attribute_name "attribute value"
+    subject.should have_static_declaration(:attribute_name).with_value("attribute value")
+  end
+
+  it "declares a dynamic attribute" do
+    attribute_value = lambda { "dynamic attribute" }
+    proxy.attribute_name &attribute_value
+    subject.should have_dynamic_declaration(:attribute_name).with_value(attribute_value)
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "#sequence" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  before      { FactoryGirl::Sequence.stubs(:new) }
+
+  it "creates a new sequence starting at 1" do
+    proxy.sequence(:great)
+    FactoryGirl::Sequence.should have_received(:new).with(:great, 1)
+  end
+
+  it "creates a new sequence with an overridden starting vaue" do
+    proxy.sequence(:great, "C")
+    FactoryGirl::Sequence.should have_received(:new).with(:great, "C")
+  end
+
+  it "creates a new sequence with a block" do
+    sequence_block = Proc.new {|n| "user+#{n}@example.com" }
+    proxy.sequence(:great, 1, &sequence_block)
+    FactoryGirl::Sequence.should have_received(:new).with(:great, 1, &sequence_block)
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "#association" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "declares an association" do
+    proxy.association(:association_name)
+    subject.should have_association_declaration(:association_name)
+  end
+
+  it "declares an association with options" do
+    proxy.association(:association_name, { name: "Awesome" })
+    subject.should have_association_declaration(:association_name).with_options(name: "Awesome")
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "adding callbacks" do
+  subject        { FactoryGirl::Definition.new }
+  let(:proxy)    { FactoryGirl::DefinitionProxy.new(subject) }
+  let(:callback) { lambda { "my awesome callback!" } }
+
+  context "#after_build" do
+    before { proxy.after_build(&callback) }
+    it     { should have_callback(:after_build).with_block(callback) }
+  end
+
+  context "#after_create" do
+    before { proxy.after_create(&callback) }
+    it     { should have_callback(:after_create).with_block(callback) }
+  end
+
+  context "#after_stub" do
+    before { proxy.after_stub(&callback) }
+    it     { should have_callback(:after_stub).with_block(callback) }
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "#to_create" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "accepts a block to run in place of #save!" do
+    to_create_block = lambda {|record| record.persist }
+    proxy.to_create(&to_create_block)
+    subject.to_create.should == to_create_block
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "#factory" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "without options" do
+    proxy.factory(:child)
+    proxy.child_factories.should include([:child, {}, nil])
+  end
+
+  it "with options" do
+    proxy.factory(:child, { awesome: true })
+    proxy.child_factories.should include([:child, { awesome: true }, nil])
+  end
+
+  it "with a block" do
+    child_block = lambda { }
+    proxy.factory(:child, {}, &child_block)
+    proxy.child_factories.should include([:child, {}, child_block])
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "#trait" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "declares a trait" do
+    male_trait = Proc.new { gender("Male") }
+    proxy.trait(:male, &male_trait)
+    subject.should have_trait(:male).with_block(male_trait)
+  end
+end
+
+describe FactoryGirl::DefinitionProxy, "#initialize_with" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "defines the constructor on the definition" do
+    constructor = Proc.new { Array.new }
+    proxy.initialize_with(&constructor)
+    subject.constructor.should == constructor
+  end
+end

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

@@ -0,0 +1,104 @@
+require "spec_helper"
+
+describe FactoryGirl::Definition do
+  it { should delegate(:declare_attribute).to(:declarations) }
+  it { should delegate(:attributes).to(:declarations).as(:attribute_list) }
+end
+
+describe FactoryGirl::Definition, "with a name" do
+  let(:name) { :"great name" }
+  subject    { FactoryGirl::Definition.new(name) }
+
+  it "creates a new attribute list with the name passed" do
+    FactoryGirl::DeclarationList.stubs(:new)
+    subject
+    FactoryGirl::DeclarationList.should have_received(:new).with(name)
+  end
+end
+
+describe FactoryGirl::Definition, "#overridable" do
+  let(:list) { stub("declaration list", overridable: true) }
+  before { FactoryGirl::DeclarationList.stubs(new: list) }
+
+  it "sets the declaration list as overridable" do
+    subject.overridable.should == subject
+    list.should have_received(:overridable).once
+  end
+end
+
+describe FactoryGirl::Definition, "defining traits" do
+  let(:trait_1) { stub("trait") }
+  let(:trait_2) { stub("trait") }
+
+  it "maintains a list of traits" do
+    subject.define_trait(trait_1)
+    subject.define_trait(trait_2)
+    subject.defined_traits.should == [trait_1, trait_2]
+  end
+end
+
+describe FactoryGirl::Definition, "adding callbacks" do
+  let(:callback_1) { stub("callback") }
+  let(:callback_2) { stub("callback") }
+
+  it "maintains a list of callbacks" do
+    subject.add_callback(callback_1)
+    subject.add_callback(callback_2)
+    subject.callbacks.should == [callback_1, callback_2]
+  end
+end
+
+describe FactoryGirl::Definition, "#to_create" do
+  its(:to_create) { should be_a(Proc) }
+
+  it "calls save! on the object when run" do
+    instance = stub("model instance", :save! => true)
+    subject.to_create[instance]
+    instance.should have_received(:save!).once
+  end
+
+  it "returns the assigned value when given a block" do
+    block = proc { nil }
+    subject.to_create(&block)
+    subject.to_create.should == block
+  end
+end
+
+describe FactoryGirl::Definition, "#processing_order" do
+  let(:female_trait) { FactoryGirl::Trait.new(:female) }
+  let(:admin_trait)  { FactoryGirl::Trait.new(:admin) }
+
+  before do
+    subject.define_trait(female_trait)
+    FactoryGirl.stubs(trait_by_name: admin_trait)
+  end
+
+  context "without base traits" do
+    it "returns the definition without any traits" do
+      subject.processing_order.should == [subject]
+    end
+
+    it "finds the correct traits after inheriting" do
+      subject.inherit_traits([:female])
+      subject.processing_order.should == [subject, female_trait]
+    end
+
+    it "looks for the trait on FactoryGirl" do
+      subject.inherit_traits([:female, :admin])
+      subject.processing_order.should == [subject, female_trait, admin_trait]
+    end
+  end
+
+  context "with base traits" do
+    subject { FactoryGirl::Definition.new("my definition", [:female]) }
+
+    it "returns the base traits and definition" do
+      subject.processing_order.should == [female_trait, subject]
+    end
+
+    it "finds the correct traits after inheriting" do
+      subject.inherit_traits([:admin])
+      subject.processing_order.should == [female_trait, subject, admin_trait]
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe FactoryGirl::EvaluatorClassDefiner do
+  let(:simple_attribute)                    { stub("simple attribute",   name: :simple, to_proc: lambda { 1 }) }
+  let(:relative_attribute)                  { stub("relative attribute", name: :relative, to_proc: lambda { simple + 1 }) }
+  let(:attribute_that_raises_a_second_time) { stub("attribute that would raise without a cache", name: :raises_without_proper_cache, to_proc: lambda { raise "failed" if @run; @run = true; nil }) }
+  let(:callbacks) { [stub("callback 1"), stub("callback 2")] }
+
+  let(:attributes)    { [simple_attribute, relative_attribute, attribute_that_raises_a_second_time] }
+  let(:class_definer) { FactoryGirl::EvaluatorClassDefiner.new(attributes, callbacks, FactoryGirl::Evaluator) }
+  let(:evaluator)     { class_definer.evaluator_class.new(stub("build strategy", add_observer: true)) }
+
+  it "returns an evaluator when accessing the evaluator class" do
+    evaluator.should be_a(FactoryGirl::Evaluator)
+  end
+
+  it "adds each attribute to the evaluator" do
+    evaluator.simple.should == 1
+  end
+
+  it "evaluates the block in the context of the evaluator" do
+    evaluator.relative.should == 2
+  end
+
+  it "only instance_execs the block once even when returning nil" do
+    expect {
+      2.times { evaluator.raises_without_proper_cache }
+    }.to_not raise_error
+  end
+
+  it "sets attributes on the evaluator class" do
+    class_definer.evaluator_class.attribute_lists.should == [attributes]
+  end
+
+  it "sets callbacks on the evaluator class" do
+    class_definer.evaluator_class.callbacks.should == callbacks
+  end
+
+  context "with a custom evaluator as a parent class" do
+    let(:child_callbacks)  { [stub("child callback 1"), stub("child callback 2")] }
+    let(:child_attributes) { [stub("child attribute", name: :simple, to_proc: lambda { 1 })] }
+    let(:child_definer)    { FactoryGirl::EvaluatorClassDefiner.new(child_attributes, child_callbacks, class_definer.evaluator_class) }
+
+    subject { child_definer.evaluator_class }
+
+    it "bases its attribute lists on itself and its parent evaluator" do
+      subject.attribute_lists.should == [attributes, child_attributes]
+    end
+
+    it "bases its callbacks on itself and its parent evaluator" do
+      subject.callbacks.should == callbacks + child_callbacks
+    end
+  end
+end

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

@@ -0,0 +1,279 @@
+require 'spec_helper'
+
+describe FactoryGirl::Factory do
+  before do
+    @name    = :user
+    @class   = define_class('User')
+    @factory = FactoryGirl::Factory.new(@name)
+    FactoryGirl.register_factory(@factory)
+  end
+
+  it "has a factory name" do
+    @factory.name.should == @name
+  end
+
+  it "has a build class" do
+    @factory.build_class.should == @class
+  end
+
+  it "passes a custom creation block" do
+    strategy = stub("strategy", result: nil, add_observer: true)
+    FactoryGirl::Strategy::Build.stubs(new: strategy)
+    block = lambda {}
+    factory = FactoryGirl::Factory.new(:object)
+    factory.to_create(&block)
+
+    factory.run(FactoryGirl::Strategy::Build, {})
+
+    strategy.should have_received(:result).with(instance_of(FactoryGirl::AttributeAssigner), block)
+  end
+
+  it "returns associations" do
+    factory = FactoryGirl::Factory.new(:post)
+    FactoryGirl.register_factory(FactoryGirl::Factory.new(:admin))
+    factory.declare_attribute(FactoryGirl::Declaration::Association.new(:author, {}))
+    factory.declare_attribute(FactoryGirl::Declaration::Association.new(:editor, {}))
+    factory.declare_attribute(FactoryGirl::Declaration::Implicit.new(:admin, factory))
+    factory.associations.each do |association|
+      association.should be_association
+    end
+    factory.associations.size.should == 3
+  end
+
+  it "includes associations from the parent factory" do
+    association_on_parent = FactoryGirl::Declaration::Association.new(:association_on_parent, {})
+    association_on_child  = FactoryGirl::Declaration::Association.new(:association_on_child, {})
+
+    factory = FactoryGirl::Factory.new(:post)
+    factory.declare_attribute(association_on_parent)
+    FactoryGirl.register_factory(factory)
+
+    child_factory = FactoryGirl::Factory.new(:child_post, parent: :post)
+    child_factory.declare_attribute(association_on_child)
+
+    child_factory.associations.map(&:name).should == [:association_on_parent, :association_on_child]
+  end
+
+  describe "when overriding generated attributes with a hash" do
+    before do
+      @name  = :name
+      @value = 'The price is right!'
+      @hash  = { @name => @value }
+    end
+
+    it "returns the overridden value in the generated attributes" do
+      declaration = FactoryGirl::Declaration::Static.new(@name, 'The price is wrong, Bob!')
+      @factory.declare_attribute(declaration)
+      result = @factory.run(FactoryGirl::Strategy::AttributesFor, @hash)
+      result[@name].should == @value
+    end
+
+    it "does not call a lazy attribute block for an overridden attribute" do
+      declaration = FactoryGirl::Declaration::Dynamic.new(@name, false, lambda { flunk })
+      @factory.declare_attribute(declaration)
+      @factory.run(FactoryGirl::Strategy::AttributesFor, @hash)
+    end
+
+    it "overrides a symbol parameter with a string parameter" do
+      declaration = FactoryGirl::Declaration::Static.new(@name, 'The price is wrong, Bob!')
+      @factory.declare_attribute(declaration)
+      @hash = { @name.to_s => @value }
+      result = @factory.run(FactoryGirl::Strategy::AttributesFor, @hash)
+      result[@name].should == @value
+    end
+  end
+
+  describe "overriding an attribute with an alias" do
+    before do
+      @factory.declare_attribute(FactoryGirl::Declaration::Static.new(:test, 'original'))
+      FactoryGirl.aliases << [/(.*)_alias/, '\1']
+      @result = @factory.run(FactoryGirl::Strategy::AttributesFor,
+                             test_alias: 'new')
+    end
+
+    it "uses the passed in value for the alias" do
+      @result[:test_alias].should == 'new'
+    end
+
+    it "discards the predefined value for the attribute" do
+      @result[:test].should be_nil
+    end
+  end
+
+  it "guesses the build class from the factory name" do
+    @factory.build_class.should == User
+  end
+
+  it "creates a new factory using the class of the parent" do
+    child = FactoryGirl::Factory.new(:child, parent: @factory.name)
+    child.compile
+    child.build_class.should == @factory.build_class
+  end
+
+  it "creates a new factory while overriding the parent class" do
+    child = FactoryGirl::Factory.new(:child, class: String, parent: @factory.name)
+    child.compile
+    child.build_class.should == String
+  end
+end
+
+describe FactoryGirl::Factory, "when defined with a custom class" do
+  subject           { FactoryGirl::Factory.new(:author, class: Float) }
+  its(:build_class) { should == Float }
+end
+
+describe FactoryGirl::Factory, "when given a class that overrides #to_s" do
+  let(:overriding_class) { Overriding::Class }
+
+  before do
+    define_class("Overriding")
+    define_class("Overriding::Class") do
+      def self.to_s
+        "Overriding"
+      end
+    end
+  end
+
+  subject { FactoryGirl::Factory.new(:overriding_class, class: Overriding::Class) }
+
+  it "sets build_class correctly" do
+    subject.build_class.should == overriding_class
+  end
+end
+
+describe FactoryGirl::Factory, "when defined with a class instead of a name" do
+  let(:factory_class) { ArgumentError }
+  let(:name)          { :argument_error }
+
+  subject { FactoryGirl::Factory.new(factory_class) }
+
+  its(:name)        { should == name }
+  its(:build_class) { should == factory_class }
+end
+
+describe FactoryGirl::Factory, "when defined with a custom class name" do
+  subject           { FactoryGirl::Factory.new(:author, class: :argument_error) }
+  its(:build_class) { should == ArgumentError }
+end
+
+describe FactoryGirl::Factory, "with a name ending in s" do
+  let(:name)           { :business }
+  let(:business_class) { Business }
+
+  before  { define_class('Business') }
+  subject { FactoryGirl::Factory.new(name) }
+
+  its(:name)        { should == name }
+  its(:build_class) { should == business_class }
+end
+
+describe FactoryGirl::Factory, "with a string for a name" do
+  let(:name) { :string }
+  subject    { FactoryGirl::Factory.new(name.to_s) }
+  its(:name) { should == name }
+end
+
+describe FactoryGirl::Factory, "for namespaced class" do
+  let(:name)           { :settings }
+  let(:settings_class) { Admin::Settings }
+
+  before do
+    define_class("Admin")
+    define_class("Admin::Settings")
+  end
+
+  context "with a namespaced class with Namespace::Class syntax" do
+    subject { FactoryGirl::Factory.new(name, class: "Admin::Settings") }
+
+    it "sets build_class correctly" do
+      subject.build_class.should == settings_class
+    end
+  end
+
+  context "with a namespaced class with namespace/class syntax" do
+    subject { FactoryGirl::Factory.new(name, class: "admin/settings") }
+
+    it "sets build_class correctly" do
+      subject.build_class.should == settings_class
+    end
+  end
+end
+
+describe FactoryGirl::Factory, "human names" do
+  context "factory name without underscores" do
+    subject           { FactoryGirl::Factory.new(:user) }
+    its(:names)       { should == [:user] }
+    its(:human_names) { should == ["user"] }
+  end
+
+  context "factory name with underscores" do
+    subject           { FactoryGirl::Factory.new(:happy_user) }
+    its(:names)       { should == [:happy_user] }
+    its(:human_names) { should == ["happy user"] }
+  end
+
+  context "factory name with big letters" do
+    subject           { FactoryGirl::Factory.new(:LoL) }
+    its(:names)       { should == [:LoL] }
+    its(:human_names) { should == ["lol"] }
+  end
+
+  context "factory name with aliases" do
+    subject           { FactoryGirl::Factory.new(:happy_user, aliases: [:gleeful_user, :person]) }
+    its(:names)       { should == [:happy_user, :gleeful_user, :person] }
+    its(:human_names) { should == ["happy user", "gleeful user", "person"] }
+  end
+end
+
+describe FactoryGirl::Factory, "running a factory" do
+  subject              { FactoryGirl::Factory.new(:user) }
+  let(:attribute)      { FactoryGirl::Attribute::Static.new(:name, "value", false) }
+  let(:declaration)    { FactoryGirl::Declaration::Static.new(:name, "value", false) }
+  let(:strategy)       { stub("strategy", result: "result", add_observer: true) }
+  let(:attributes)     { [attribute] }
+  let(:attribute_list) { stub('attribute-list', declarations: [declaration], to_a: attributes) }
+
+  before do
+    define_model("User", name: :string)
+    FactoryGirl::Declaration::Static.stubs(new: declaration)
+    declaration.stubs(to_attributes: attributes)
+    FactoryGirl::Strategy::Build.stubs(new: strategy)
+    subject.declare_attribute(declaration)
+  end
+
+  it "creates the right strategy using the build class when running" do
+    subject.run(FactoryGirl::Strategy::Build, {})
+    FactoryGirl::Strategy::Build.should have_received(:new).once
+  end
+
+  it "returns the result from the strategy when running" do
+    subject.run(FactoryGirl::Strategy::Build, {}).should == "result"
+  end
+
+  it "calls the block and returns the result" do
+    block_run = nil
+    block = lambda {|result| block_run = "changed" }
+    subject.run(FactoryGirl::Strategy::Build, { }, &block)
+    block_run.should == "changed"
+  end
+end
+
+describe FactoryGirl::Factory, "#with_traits" do
+  subject            { FactoryGirl::Factory.new(:user) }
+  let(:admin_trait)  { FactoryGirl::Trait.new(:admin) }
+  let(:female_trait) { FactoryGirl::Trait.new(:female) }
+
+  before do
+    FactoryGirl.register_trait(admin_trait)
+    FactoryGirl.register_trait(female_trait)
+  end
+
+  it "returns a factory with the correct traits" do
+    subject.with_traits([:admin, :female]).processing_order[1, 2].should == [admin_trait, female_trait]
+  end
+
+  it "doesn't modify the original factory's processing order" do
+    subject.with_traits([:admin, :female])
+    subject.processing_order.should == [subject.definition]
+  end
+end