factory_girl 4.5.0 → 4.7.0

data/spec/acceptance/sequence_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe "sequences" do
-  include FactoryGirl::Syntax::Methods
-
-  it "generates several values in the correct format" do
-    FactoryGirl.define do
-      sequence :email do |n|
-        "somebody#{n}@example.com"
-      end
-    end
-
-    first_value = generate(:email)
-    another_value = generate(:email)
-
-    expect(first_value).to match /^somebody\d+@example\.com$/
-    expect(another_value).to match /^somebody\d+@example\.com$/
-    expect(first_value).not_to eq another_value
-  end
-
-  it "generates sequential numbers if no block is given" do
-    FactoryGirl.define do
-      sequence :order
-    end
-
-    first_value = generate(:order)
-    another_value = generate(:order)
-
-    expect(first_value).to eq 1
-    expect(another_value).to eq 2
-    expect(first_value).not_to eq another_value
-  end
-
-  it "generates aliases for the sequence that reference the same block" do
-    FactoryGirl.define do
-      sequence(:size, aliases: [:count, :length]) { |n| "called-#{n}" }
-    end
-
-    first_value  = generate(:size)
-    second_value = generate(:count)
-    third_value  = generate(:length)
-
-    expect(first_value).to eq "called-1"
-    expect(second_value).to eq "called-2"
-    expect(third_value).to eq "called-3"
-  end
-
-  it "generates aliases for the sequence that reference the same block and retains value" do
-    FactoryGirl.define do
-      sequence(:size, "a", aliases: [:count, :length]) { |n| "called-#{n}" }
-    end
-
-    first_value  = generate(:size)
-    second_value = generate(:count)
-    third_value  = generate(:length)
-
-    expect(first_value).to eq "called-a"
-    expect(second_value).to eq "called-b"
-    expect(third_value).to eq "called-c"
-  end
-end

data/spec/acceptance/skip_create_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-describe "skipping the default create" do
-  before do
-    define_model("User", email: :string)
-
-    FactoryGirl.define do
-      factory :user do
-        skip_create
-
-        email "john@example.com"
-      end
-    end
-  end
-
-  it "doesn't execute anything when creating the instance" do
-    expect(FactoryGirl.create(:user)).not_to be_persisted
-  end
-end

data/spec/acceptance/stub_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe "a stubbed instance" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model('User')
-
-    define_model('Post', user_id: :integer) do
-      belongs_to :user
-    end
-
-    FactoryGirl.define do
-      factory :user
-
-      factory :post do
-        user
-      end
-    end
-  end
-
-  subject { build_stubbed(:post) }
-
-  it "acts as if it came from the database" do
-    should_not be_new_record
-  end
-
-  it "assigns associations and acts as if it is saved" do
-    expect(subject.user).to be_kind_of(User)
-    expect(subject.user).not_to be_new_record
-  end
-end
-
-describe "a stubbed instance overriding strategy" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model('User')
-    define_model('Post', user_id: :integer) do
-      belongs_to :user
-    end
-
-    FactoryGirl.define do
-      factory :user
-
-      factory :post do
-        association(:user, strategy: :build)
-      end
-    end
-  end
-
-  subject { build_stubbed(:post) }
-
-  it "acts as if it is saved in the database" do
-    should_not be_new_record
-  end
-
-  it "assigns associations and acts as if it is saved" do
-    expect(subject.user).to be_kind_of(User)
-    expect(subject.user).not_to be_new_record
-  end
-end

data/spec/acceptance/syntax_methods_within_dynamic_attributes_spec.rb

@@ -1,51 +0,0 @@
-require "spec_helper"
-
-describe "syntax methods within dynamic attributes" do
-  before do
-    define_model("Post", title: :string, user_id: :integer) do
-      belongs_to :user
-
-      def generate
-        "generate result"
-      end
-    end
-    define_model("User", email: :string)
-
-    FactoryGirl.define do
-      sequence(:email_address) { |n| "person-#{n}@example.com" }
-
-      factory :user do
-        email { generate(:email_address) }
-      end
-
-      factory :post do
-        title { generate }
-        user { build(:user) }
-      end
-    end
-  end
-
-  it "can access syntax methods from dynamic attributes" do
-    expect(FactoryGirl.build(:user).email).to eq "person-1@example.com"
-    expect(FactoryGirl.attributes_for(:user)[:email]).to eq "person-2@example.com"
-  end
-
-  it "can access syntax methods from dynamic attributes" do
-    expect(FactoryGirl.build(:post).user).to be_instance_of(User)
-  end
-
-  it "can access methods already existing on the class" do
-    expect(FactoryGirl.build(:post).title).to eq "generate result"
-    expect(FactoryGirl.attributes_for(:post)[:title]).to be_nil
-  end
-
-  it 'allows syntax methods to be used when the block has an arity of 1' do
-    FactoryGirl.define do
-      factory :post_using_block_with_variable, parent: :post do
-        user { |_| build(:user) }
-      end
-    end
-
-    expect(FactoryGirl.build(:post_using_block_with_variable).user).to be_instance_of(User)
-  end
-end

data/spec/acceptance/traits_spec.rb

@@ -1,727 +0,0 @@
-require "spec_helper"
-
-describe "an instance generated by a factory with multiple traits" do
-  before do
-    define_model("User",
-                 name:          :string,
-                 admin:         :boolean,
-                 gender:        :string,
-                 email:         :string,
-                 date_of_birth: :date,
-                 great:         :string)
-
-    FactoryGirl.define do
-      factory :user_without_admin_scoping, class: User do
-        admin_trait
-      end
-
-      factory :user do
-        name "John"
-
-        trait :great do
-          great "GREAT!!!"
-        end
-
-        trait :admin do
-          admin true
-        end
-
-        trait :admin_trait do
-          admin true
-        end
-
-        trait :male do
-          name   "Joe"
-          gender "Male"
-        end
-
-        trait :female do
-          name   "Jane"
-          gender "Female"
-        end
-
-        factory :great_user do
-          great
-        end
-
-        factory :admin, traits: [:admin]
-
-        factory :male_user do
-          male
-
-          factory :child_male_user do
-            date_of_birth { Date.parse("1/1/2000") }
-          end
-        end
-
-        factory :female, traits: [:female] do
-          trait :admin do
-            admin true
-            name "Judy"
-          end
-
-          factory :female_great_user do
-            great
-          end
-
-          factory :female_admin_judy, traits: [:admin]
-        end
-
-        factory :female_admin,            traits: [:female, :admin]
-        factory :female_after_male_admin, traits: [:male, :female, :admin]
-        factory :male_after_female_admin, traits: [:female, :male, :admin]
-      end
-
-      trait :email do
-        email { "#{name}@example.com" }
-      end
-
-      factory :user_with_email, class: User, traits: [:email] do
-        name "Bill"
-      end
-    end
-  end
-
-  context "the parent class" do
-    subject      { FactoryGirl.create(:user) }
-    its(:name)   { should eq "John" }
-    its(:gender) { should be_nil }
-    it           { should_not be_admin }
-  end
-
-  context "the child class with one trait" do
-    subject      { FactoryGirl.create(:admin) }
-    its(:name)   { should eq "John" }
-    its(:gender) { should be_nil }
-    it           { should be_admin }
-  end
-
-  context "the other child class with one trait" do
-    subject      { FactoryGirl.create(:female) }
-    its(:name)   { should eq "Jane" }
-    its(:gender) { should eq "Female" }
-    it           { should_not be_admin }
-  end
-
-  context "the child with multiple traits" do
-    subject      { FactoryGirl.create(:female_admin) }
-    its(:name)   { should eq "Jane" }
-    its(:gender) { should eq "Female" }
-    it           { should be_admin }
-  end
-
-  context "the child with multiple traits and overridden attributes" do
-    subject      { FactoryGirl.create(:female_admin, name: "Jill", gender: nil) }
-    its(:name)   { should eq "Jill" }
-    its(:gender) { should be_nil }
-    it           { should be_admin }
-  end
-
-  context "the child with multiple traits who override the same attribute" do
-    context "when the male assigns name after female" do
-      subject      { FactoryGirl.create(:male_after_female_admin) }
-      its(:name)   { should eq "Joe" }
-      its(:gender) { should eq "Male" }
-      it           { should be_admin }
-    end
-
-    context "when the female assigns name after male" do
-      subject      { FactoryGirl.create(:female_after_male_admin) }
-      its(:name)   { should eq "Jane" }
-      its(:gender) { should eq "Female" }
-      it           { should be_admin }
-    end
-  end
-
-  context "child class with scoped trait and inherited trait" do
-    subject      { FactoryGirl.create(:female_admin_judy) }
-    its(:name)   { should eq "Judy" }
-    its(:gender) { should eq "Female" }
-    it           { should be_admin }
-  end
-
-  context "factory using global trait" do
-    subject     { FactoryGirl.create(:user_with_email) }
-    its(:name)  { should eq "Bill" }
-    its(:email) { should eq "Bill@example.com"}
-  end
-
-  context "factory created with alternate syntax for specifying trait" do
-    subject      { FactoryGirl.create(:male_user) }
-    its(:gender) { should eq "Male" }
-  end
-
-  context "factory created with alternate syntax where trait name and attribute are the same" do
-    subject     { FactoryGirl.create(:great_user) }
-    its(:great) { should eq "GREAT!!!" }
-  end
-
-  context "factory created with alternate syntax where trait name and attribute are the same and attribute is overridden" do
-    subject     { FactoryGirl.create(:great_user, great: "SORT OF!!!") }
-    its(:great) { should eq "SORT OF!!!" }
-  end
-
-  context "child factory created where trait attributes are inherited" do
-    subject             { FactoryGirl.create(:child_male_user) }
-    its(:gender)        { should eq "Male" }
-    its(:date_of_birth) { should eq Date.parse("1/1/2000") }
-  end
-
-  context "factory outside of scope" do
-    subject     { FactoryGirl.create(:user_without_admin_scoping) }
-    it { expect { subject }.to raise_error(ArgumentError, "Trait not registered: admin_trait") }
-  end
-
-  context "child factory using grandparents' trait" do
-    subject     { FactoryGirl.create(:female_great_user) }
-    its(:great) { should eq "GREAT!!!" }
-  end
-end
-
-describe "traits with callbacks" do
-  before do
-    define_model("User", name: :string)
-
-    FactoryGirl.define do
-      factory :user do
-        name "John"
-
-        trait :great do
-          after(:create) { |user| user.name.upcase! }
-        end
-
-        trait :awesome do
-          after(:create) { |user| user.name = "awesome" }
-        end
-
-        factory :caps_user, traits: [:great]
-        factory :awesome_user, traits: [:great, :awesome]
-
-        factory :caps_user_implicit_trait do
-          great
-        end
-      end
-    end
-  end
-
-  context "when the factory has a trait passed via arguments" do
-    subject    { FactoryGirl.create(:caps_user) }
-    its(:name) { should eq "JOHN" }
-  end
-
-  context "when the factory has an implicit trait" do
-    subject    { FactoryGirl.create(:caps_user_implicit_trait) }
-    its(:name) { should eq "JOHN" }
-  end
-
-  it "executes callbacks in the order assigned" do
-    expect(FactoryGirl.create(:awesome_user).name).to eq "awesome"
-  end
-end
-
-describe "traits added via strategy" do
-  before do
-    define_model("User", name: :string, admin: :boolean)
-
-    FactoryGirl.define do
-      factory :user do
-        name "John"
-
-        trait :admin do
-          admin true
-        end
-
-        trait :great do
-          after(:create) { |user| user.name.upcase! }
-        end
-      end
-    end
-  end
-
-  context "adding traits in create" do
-    subject { FactoryGirl.create(:user, :admin, :great, name: "Joe") }
-
-    its(:admin) { should be_true }
-    its(:name)  { should eq "JOE" }
-
-    it "doesn't modify the user factory" do
-      subject
-      expect(FactoryGirl.create(:user)).not_to be_admin
-      expect(FactoryGirl.create(:user).name).to eq "John"
-    end
-  end
-
-  context "adding traits in build" do
-    subject { FactoryGirl.build(:user, :admin, :great, name: "Joe") }
-
-    its(:admin) { should be_true }
-    its(:name)  { should eq "Joe" }
-  end
-
-  context "adding traits in attributes_for" do
-    subject { FactoryGirl.attributes_for(:user, :admin, :great) }
-
-    its([:admin]) { should be_true }
-    its([:name])  { should eq "John" }
-  end
-
-  context "adding traits in build_stubbed" do
-    subject { FactoryGirl.build_stubbed(:user, :admin, :great, name: "Jack") }
-
-    its(:admin) { should be_true }
-    its(:name)  { should eq "Jack" }
-  end
-
-  context "adding traits in create_list" do
-    subject { FactoryGirl.create_list(:user, 2, :admin, :great, name: "Joe") }
-
-    its(:length) { should eq 2 }
-
-    it "creates all the records" do
-      subject.each do |record|
-        expect(record.admin).to be_true
-        expect(record.name).to eq "JOE"
-      end
-    end
-  end
-
-  context "adding traits in build_list" do
-    subject { FactoryGirl.build_list(:user, 2, :admin, :great, name: "Joe") }
-
-    its(:length) { should eq 2 }
-
-    it "builds all the records" do
-      subject.each do |record|
-        expect(record.admin).to be_true
-        expect(record.name).to eq "Joe"
-      end
-    end
-  end
-end
-
-describe "traits and dynamic attributes that are applied simultaneously" do
-  before do
-    define_model("User", name: :string, email: :string, combined: :string)
-
-    FactoryGirl.define do
-      trait :email do
-        email { "#{name}@example.com" }
-      end
-
-      factory :user do
-        name "John"
-        email
-        combined { "#{name} <#{email}>" }
-      end
-    end
-  end
-
-  subject        { FactoryGirl.build(:user) }
-  its(:name)     { should eq "John" }
-  its(:email)    { should eq "John@example.com" }
-  its(:combined) { should eq "John <John@example.com>" }
-end
-
-describe "applying inline traits" do
-  before do
-    define_model("User") do
-      has_many :posts
-    end
-
-    define_model("Post", user_id: :integer) do
-      belongs_to :user
-    end
-
-    FactoryGirl.define do
-      factory :user do
-        trait :with_post do
-          posts { [ Post.new ] }
-        end
-      end
-    end
-  end
-
-  it "applies traits only to the instance generated for that call" do
-    expect(FactoryGirl.create(:user, :with_post).posts).not_to be_empty
-    expect(FactoryGirl.create(:user).posts).to be_empty
-    expect(FactoryGirl.create(:user, :with_post).posts).not_to be_empty
-  end
-end
-
-describe "inline traits overriding existing attributes" do
-  before do
-    define_model("User", status: :string)
-
-    FactoryGirl.define do
-      factory :user do
-        status "pending"
-
-        trait(:accepted) { status "accepted" }
-        trait(:declined) { status "declined" }
-
-        factory :declined_user, traits: [:declined]
-        factory :extended_declined_user, traits: [:declined] do
-          status "extended_declined"
-        end
-      end
-    end
-  end
-
-  it "returns the default status" do
-    expect(FactoryGirl.build(:user).status).to eq "pending"
-  end
-
-  it "prefers inline trait attributes over default attributes" do
-    expect(FactoryGirl.build(:user, :accepted).status).to eq "accepted"
-  end
-
-  it "prefers traits on a factory over default attributes" do
-    expect(FactoryGirl.build(:declined_user).status).to eq "declined"
-  end
-
-  it "prefers inline trait attributes over traits on a factory" do
-    expect(FactoryGirl.build(:declined_user, :accepted).status).to eq "accepted"
-  end
-
-  it "prefers attributes on factories over attributes from non-inline traits" do
-    expect(FactoryGirl.build(:extended_declined_user).status).to eq "extended_declined"
-  end
-
-  it "prefers inline traits over attributes on factories" do
-    expect(FactoryGirl.build(:extended_declined_user, :accepted).status).to eq "accepted"
-  end
-
-  it "prefers overridden attributes over attributes from traits, inline traits, or attributes on factories" do
-    expect(FactoryGirl.build(:extended_declined_user, :accepted, status: "completely overridden").status).to eq "completely overridden"
-  end
-end
-
-describe "making sure the factory is properly compiled the first time we want to instantiate it" do
-  before do
-    define_model("User", role: :string, gender: :string, age: :integer)
-
-    FactoryGirl.define do
-      factory :user do
-        trait(:female) { gender "female" }
-        trait(:admin) { role "admin" }
-
-        factory :female_user do
-          female
-        end
-      end
-    end
-  end
-
-  it "can honor traits on the very first call" do
-    user = FactoryGirl.build(:female_user, :admin, age: 30)
-    expect(user.gender).to eq 'female'
-    expect(user.age).to eq 30
-    expect(user.role).to eq 'admin'
-  end
-end
-
-describe "traits with to_create" do
-  before do
-    define_model("User", name: :string)
-
-    FactoryGirl.define do
-      factory :user do
-        trait :with_to_create do
-          to_create { |instance| instance.name = "to_create" }
-        end
-
-        factory :sub_user do
-          to_create { |instance| instance.name = "sub" }
-
-          factory :child_user
-        end
-
-        factory :sub_user_with_trait do
-          with_to_create
-
-          factory :child_user_with_trait
-        end
-
-        factory :sub_user_with_trait_and_override do
-          with_to_create
-          to_create { |instance| instance.name = "sub with trait and override" }
-
-          factory :child_user_with_trait_and_override
-        end
-      end
-    end
-  end
-
-  it "can apply to_create from traits" do
-    expect(FactoryGirl.create(:user, :with_to_create).name).to eq "to_create"
-  end
-
-  it "can apply to_create from the definition" do
-    expect(FactoryGirl.create(:sub_user).name).to eq "sub"
-    expect(FactoryGirl.create(:child_user).name).to eq "sub"
-  end
-
-  it "gives additional traits higher priority than to_create from the definition" do
-    expect(FactoryGirl.create(:sub_user, :with_to_create).name).to eq "to_create"
-    expect(FactoryGirl.create(:child_user, :with_to_create).name).to eq "to_create"
-  end
-
-  it "gives base traits normal priority" do
-    expect(FactoryGirl.create(:sub_user_with_trait).name).to eq "to_create"
-    expect(FactoryGirl.create(:child_user_with_trait).name).to eq "to_create"
-  end
-
-  it "gives base traits lower priority than overrides" do
-    expect(FactoryGirl.create(:sub_user_with_trait_and_override).name).to eq "sub with trait and override"
-    expect(FactoryGirl.create(:child_user_with_trait_and_override).name).to eq "sub with trait and override"
-  end
-
-  it "gives additional traits higher priority than base traits and factory definition" do
-    FactoryGirl.define do
-      trait :overridden do
-        to_create { |instance| instance.name = "completely overridden" }
-      end
-    end
-
-    expect(FactoryGirl.create(:sub_user_with_trait_and_override, :overridden).name).to eq "completely overridden"
-    expect(FactoryGirl.create(:child_user_with_trait_and_override, :overridden).name).to eq "completely overridden"
-  end
-end
-
-describe "traits with initialize_with" do
-  before do
-    define_class("User") do
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-    end
-
-    FactoryGirl.define do
-      factory :user do
-        trait :with_initialize_with do
-          initialize_with { new("initialize_with") }
-        end
-
-        factory :sub_user do
-          initialize_with { new("sub") }
-
-          factory :child_user
-        end
-
-        factory :sub_user_with_trait do
-          with_initialize_with
-
-          factory :child_user_with_trait
-        end
-
-        factory :sub_user_with_trait_and_override do
-          with_initialize_with
-          initialize_with { new("sub with trait and override") }
-
-          factory :child_user_with_trait_and_override
-        end
-      end
-    end
-  end
-
-  it "can apply initialize_with from traits" do
-    expect(FactoryGirl.build(:user, :with_initialize_with).name).to eq "initialize_with"
-  end
-
-  it "can apply initialize_with from the definition" do
-    expect(FactoryGirl.build(:sub_user).name).to eq "sub"
-    expect(FactoryGirl.build(:child_user).name).to eq "sub"
-  end
-
-  it "gives additional traits higher priority than initialize_with from the definition" do
-    expect(FactoryGirl.build(:sub_user, :with_initialize_with).name).to eq "initialize_with"
-    expect(FactoryGirl.build(:child_user, :with_initialize_with).name).to eq "initialize_with"
-  end
-
-  it "gives base traits normal priority" do
-    expect(FactoryGirl.build(:sub_user_with_trait).name).to eq "initialize_with"
-    expect(FactoryGirl.build(:child_user_with_trait).name).to eq "initialize_with"
-  end
-
-  it "gives base traits lower priority than overrides" do
-    expect(FactoryGirl.build(:sub_user_with_trait_and_override).name).to eq "sub with trait and override"
-    expect(FactoryGirl.build(:child_user_with_trait_and_override).name).to eq "sub with trait and override"
-  end
-
-  it "gives additional traits higher priority than base traits and factory definition" do
-    FactoryGirl.define do
-      trait :overridden do
-        initialize_with { new("completely overridden") }
-      end
-    end
-
-    expect(FactoryGirl.build(:sub_user_with_trait_and_override, :overridden).name).to eq "completely overridden"
-    expect(FactoryGirl.build(:child_user_with_trait_and_override, :overridden).name).to eq "completely overridden"
-  end
-end
-
-describe "nested implicit traits" do
-  before do
-    define_class("User") do
-      attr_accessor :gender, :role
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-    end
-  end
-
-  shared_examples_for "assigning data from traits" do
-    it "assigns the correct values" do
-      user = FactoryGirl.create(:user, :female_admin)
-      expect(user.gender).to eq "FEMALE"
-      expect(user.role).to eq "ADMIN"
-      expect(user.name).to eq "Jane Doe"
-    end
-  end
-
-  context "defined outside the factory" do
-    before do
-      FactoryGirl.define do
-        trait :female do
-          gender "female"
-          to_create { |instance| instance.gender = instance.gender.upcase }
-        end
-
-        trait :jane_doe do
-          initialize_with { new("Jane Doe") }
-        end
-
-        trait :admin do
-          role "admin"
-          after(:build) { |instance| instance.role = instance.role.upcase }
-        end
-
-        trait :female_admin do
-          female
-          admin
-          jane_doe
-        end
-
-        factory :user
-      end
-    end
-
-    it_should_behave_like "assigning data from traits"
-  end
-
-  context "defined inside the factory" do
-    before do
-      FactoryGirl.define do
-        factory :user do
-          trait :female do
-            gender "female"
-            to_create { |instance| instance.gender = instance.gender.upcase }
-          end
-
-          trait :jane_doe do
-            initialize_with { new("Jane Doe") }
-          end
-
-          trait :admin do
-            role "admin"
-            after(:build) { |instance| instance.role = instance.role.upcase }
-          end
-
-          trait :female_admin do
-            female
-            admin
-            jane_doe
-          end
-        end
-      end
-    end
-
-    it_should_behave_like "assigning data from traits"
-  end
-end
-
-describe "implicit traits containing callbacks" do
-  before do
-    define_model("User", value: :integer)
-
-    FactoryGirl.define do
-      factory :user do
-        value 0
-
-        trait :trait_with_callback do
-          after(:build) { |user| user.value += 1 }
-        end
-
-        factory :user_with_trait_with_callback do
-          trait_with_callback
-        end
-      end
-    end
-  end
-
-  it "only runs the callback once" do
-    expect(FactoryGirl.build(:user_with_trait_with_callback).value).to eq 1
-  end
-end
-
-describe "traits used in associations" do
-  before do
-    define_model("User", admin: :boolean, name: :string)
-
-    define_model("Comment", user_id: :integer) do
-      belongs_to :user
-    end
-
-    define_model("Order", creator_id: :integer) do
-      belongs_to :creator, class_name: 'User'
-    end
-
-    define_model("Post", author_id: :integer) do
-      belongs_to :author, class_name: 'User'
-    end
-
-    FactoryGirl.define do
-      factory :user do
-        admin false
-
-        trait :admin do
-          admin true
-        end
-      end
-
-      factory :post do
-        association :author, factory: [:user, :admin], name: 'John Doe'
-      end
-
-      factory :comment do
-        association :user, :admin, name: 'Joe Slick'
-      end
-
-      factory :order do
-        association :creator, :admin, factory: :user, name: 'Joe Creator'
-      end
-    end
-  end
-
-  it "allows assigning traits for the factory of an association" do
-    author = FactoryGirl.create(:post).author
-    expect(author).to be_admin
-    expect(author.name).to eq 'John Doe'
-  end
-
-  it "allows inline traits with the default association" do
-    user = FactoryGirl.create(:comment).user
-    expect(user).to be_admin
-    expect(user.name).to eq 'Joe Slick'
-  end
-
-  it "allows inline traits with a specific factory for an association" do
-    creator = FactoryGirl.create(:order).creator
-    expect(creator).to be_admin
-    expect(creator.name).to eq 'Joe Creator'
-  end
-end