fabrication 1.2.0 → 1.3.0

data/spec/fabrication/attribute_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe Fabrication::Attribute do
-
-  describe ".new" do
-
-    context "with name, params, and a static value" do
-
-      subject do
-        Fabrication::Attribute.new("a", {:b => 1}, "c")
-      end
-
-      its(:name)   { should == "a" }
-      its(:params) { should == {:b => 1} }
-      its(:value)  { should == "c" }
-
-    end
-
-    context "with a block value" do
-
-      subject do
-        Fabrication::Attribute.new("a", nil, Proc.new { "c" })
-      end
-
-      it "has a proc for a value" do
-        Proc.should === subject.value
-      end
-
-    end
-
-    context "with a nil value" do
-
-      subject do
-        Fabrication::Attribute.new("a", nil, nil)
-      end
-
-      its(:value) { should be_nil }
-
-    end
-
-    context "with nil params" do
-
-      subject do
-        Fabrication::Attribute.new("a", nil, nil)
-      end
-
-      its(:params) { should be_nil }
-
-    end
-
-  end
-
-end

data/spec/fabrication/config_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe Fabrication::Config do
-  subject { Fabrication::Config }
-  after { Fabrication::Config.reset_defaults }
-
-  context "default configs" do
-    its(:fabricator_dir) { should == ['test', 'spec'] }
-  end
-
-  describe ".fabricator_dir" do
-    context "with a single folder" do
-      before do
-        Fabrication.configure do |config|
-          config.fabricator_dir = 'lib'
-        end
-      end
-
-      its(:fabricator_dir) { should == ['lib'] }
-    end
-
-    context "with multiple folders" do
-      before do
-        Fabrication.configure do |config|
-          config.fabricator_dir = %w(lib support)
-        end
-      end
-
-      its(:fabricator_dir) { should == ['lib', 'support'] }
-    end
-  end
-end

data/spec/fabrication/cucumber_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-require 'fabrication/cucumber'
-
-describe Fabrication::Cucumber do
-  include described_class
-
-  let(:name) { 'dogs' }
-
-  describe '#klass' do
-    context 'with a schematic for class "Boom"' do
-      subject { StepFabricator.new(name).klass }
-      let(:fabricator_name) { :dog }
-
-      before do
-        Fabrication::Fabricator.schematics.stub(:[])
-          .with(fabricator_name).and_return(stub(:klass => "Boom"))
-      end
-
-      it { should == "Boom" }
-
-      context "given a human name" do
-        let(:name) { "weiner dogs" }
-        let(:fabricator_name) { :weiner_dog }
-        it { should == "Boom" }
-      end
-
-      context "given a titlecase human name" do
-        let(:name) { "Weiner Dog" }
-        let(:fabricator_name) { :weiner_dog }
-        it { should == "Boom" }
-      end
-    end
-  end
-
-  describe "#n" do
-    let(:n) { 3 }
-    let(:fabricator) { StepFabricator.new(name) }
-
-    it "fabricates n times" do
-      Fabrication::Fabricator.should_receive(:generate).with(:dog, anything, {}).exactly(n).times
-      fabricator.n n
-    end
-
-    it "fabricates with attrs" do
-      Fabrication::Fabricator.should_receive(:generate)
-        .with(anything, anything, :collar => 'red').at_least(1)
-      fabricator.n n, :collar => 'red'
-    end
-
-    context 'with a plural subject' do
-      let(:name) { 'dogs' }
-      it 'remembers' do
-        Fabrication::Fabricator.stub(:generate).and_return("dog1", "dog2", "dog3")
-        fabricator.n n
-        Fabrications[name].should == ["dog1", "dog2", "dog3"]
-      end
-    end
-
-    context 'with a singular subject' do
-      let(:name) { 'dog' }
-      it 'remembers' do
-        Fabrication::Fabricator.stub(:generate).and_return("dog1")
-        fabricator.n 1
-        Fabrications[name].should == 'dog1'
-      end
-    end
-
-  end
-
-  describe '#from_table' do
-    it 'maps column names to attribute names' do
-      table = stub(:hashes => [{ 'Favorite Color' => 'pink' }])
-      Fabrication::Fabricator.should_receive(:generate)
-        .with(anything, anything, :favorite_color => 'pink')
-      StepFabricator.new('bears').from_table(table)
-    end
-
-    context 'with a plural subject' do
-      let(:table) { double("ASTable", :hashes => hashes) }
-      let(:hashes) do
-        [{'some' => 'thing'},
-         {'some' => 'panother'}]
-      end
-      it 'fabricates with each rows attributes' do
-        Fabrication::Fabricator.should_receive(:generate)
-          .with(:dog, anything, {:some => 'thing'})
-        Fabrication::Fabricator.should_receive(:generate)
-          .with(:dog, anything, {:some => 'panother'})
-        StepFabricator.new(name).from_table(table)
-      end
-      it 'remembers' do
-        Fabrication::Fabricator.stub(:generate).and_return('dog1', 'dog2')
-        StepFabricator.new(name).from_table(table)
-        Fabrications[name].should == ["dog1", "dog2"]
-      end
-    end
-
-    context 'singular' do
-      let(:name) { 'dog' }
-      let(:table) { double("ASTable", :rows_hash => rows_hash) }
-      let(:rows_hash) do
-        {'some' => 'thing'}
-      end
-      it 'fabricates with each row as an attribute' do
-        Fabrication::Fabricator.should_receive(:generate).with(:dog, anything, {:some => 'thing'})
-        StepFabricator.new(name).from_table(table)
-      end
-      it 'remembers' do
-        Fabrication::Fabricator.stub(:generate).and_return('dog1')
-        StepFabricator.new(name).from_table(table)
-        Fabrications[name].should == "dog1"
-      end
-    end
-  end
-
-end

data/spec/fabrication/fabricator_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe Fabrication::Fabricator do
-
-  subject { Fabrication::Fabricator }
-
-  describe ".define" do
-
-    before(:all) do
-      subject.define(:open_struct) do
-        first_name "Joe"
-        last_name { "Schmoe" }
-      end
-    end
-
-    it "returns the schematic" do
-      subject.define(:something, :class_name => :open_struct) do
-        name "Paul"
-      end.class.should == Fabrication::Schematic
-    end
-
-    it "creates a schematic" do
-      subject.schematics[:open_struct].should be
-    end
-
-    it "has the correct class" do
-      subject.schematics[:open_struct].klass.should == OpenStruct
-    end
-
-    it "has the attributes" do
-      subject.schematics[:open_struct].attributes.size.should == 2
-    end
-
-  end
-
-  describe ".generate" do
-
-    context 'without definitions' do
-
-      before { subject.schematics.clear }
-
-      it "finds definitions if none exist" do
-        Fabrication::Support.should_receive(:find_definitions)
-        lambda { subject.generate(:object) }.should raise_error
-      end
-
-    end
-
-    context 'with definitions' do
-
-      it "raises an error if the class cannot be located" do
-        lambda { subject.define(:somenonexistantclass) }.should raise_error(Fabrication::UnfabricatableError)
-      end
-
-      it "raises an error if the fabricator cannot be located" do
-        lambda { subject.generate(:object) }.should raise_error(Fabrication::UnknownFabricatorError)
-      end
-
-      it 'generates a new object every time' do
-        subject.generate(:person).should_not == subject.generate(:person)
-      end
-
-    end
-
-  end
-
-end

data/spec/fabrication/generator/active_record_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-describe Fabrication::Generator::ActiveRecord do
-
-  describe ".supports?" do
-    subject { Fabrication::Generator::ActiveRecord }
-    it "returns true for active record objects" do
-      subject.supports?(Company).should be_true
-    end
-    it "returns false for non-active record objects" do
-      subject.supports?(Person).should be_false
-    end
-  end
-
-  describe "#after_generation" do
-    let(:instance) { mock(:instance) }
-    let(:generator) { Fabrication::Generator::ActiveRecord.new(Company) }
-
-    before { generator.send(:instance=, instance) }
-
-    it "saves with a true save flag" do
-      instance.should_receive(:save!)
-      generator.send(:after_generation, {:save => true})
-    end
-
-    it "does not save without a true save flag" do
-      instance.should_not_receive(:save)
-      generator.send(:after_generation, {})
-    end
-  end
-
-  describe "#generate" do
-
-    let(:attributes) do
-      Fabrication::Schematic.new(Company) do
-        name 'Company Name'
-        city { |c| c.name.downcase }
-        divisions(:count => 2) { |c, i| Division.create(:company => c, :name => "Division #{i}") }
-      end.attributes
-    end
-
-    let(:generator) { Fabrication::Generator::ActiveRecord.new(Company) }
-    let(:company) { generator.generate({:save => true}, attributes) }
-    before { company }
-
-    it 'does not persist the divisions immediately' do
-      Division.count.should == 0
-    end
-
-    it 'passes the object to blocks' do
-      company.city.should == 'company name'
-    end
-
-    it 'passes the object and count to blocks' do
-      company.divisions.map(&:name).should == ["Division 1", "Division 2"]
-    end
-
-    it 'persists the company upon creation' do
-      Company.find_by_name('Company Name').should be
-    end
-
-    context 'upon accessing the divisions association' do
-
-      let(:divisions) { company.divisions }
-
-      it 'generates the divisions' do
-        divisions.length.should == 2
-      end
-
-      it 'persists the divisions' do
-        divisions
-        Division.find_all_by_company_id(company.id).count.should == 2
-      end
-
-      it 'can load the divisions from the database' do
-        company.reload.divisions.length.should == 2
-      end
-
-    end
-
-  end
-
-end

data/spec/fabrication/generator/base_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-
-describe Fabrication::Generator::Base do
-
-  describe ".supports?" do
-    subject { Fabrication::Generator::Base }
-    it "supports any object" do
-      subject.supports?(Object).should be_true
-    end
-  end
-
-  describe "#generate" do
-
-    let(:generator) { Fabrication::Generator::Base.new(Person) }
-
-    let(:attributes) do
-      Fabrication::Schematic.new(Person) do
-        first_name 'Guy'
-        shoes(:count => 4) do |person, index|
-          "#{person.first_name}'s shoe #{index}"
-        end
-      end.attributes
-    end
-
-    let(:person) { generator.generate({}, attributes) }
-
-    it 'generates an instance' do
-      person.instance_of?(Person).should be_true
-    end
-
-    it 'passes the object and count to blocks' do
-      person.shoes.should == (1..4).map { |i| "Guy's shoe #{i}" }
-    end
-
-    it 'sets the static value' do
-      person.instance_variable_get(:@first_name).should == 'Guy'
-    end
-
-    context "with on_init block" do
-      subject { schematic.generate }
-
-      let(:klass) { Struct.new :arg1, :arg2 }
-
-      context "using init_with" do
-        let(:schematic) do
-          Fabrication::Schematic.new(klass) do
-            on_init { init_with(:a, :b) }
-          end
-        end
-
-        it "sends the return value of the block to the klass' initialize method" do
-          subject.arg1.should == :a
-          subject.arg2.should == :b
-        end
-      end
-
-      context "not using init_with" do
-        let(:schematic) do
-          Fabrication::Schematic.new(klass) do
-            on_init { [ :a, :b ] }
-          end
-        end
-
-        it "sends the return value of the block to the klass' initialize method" do
-          subject.arg1.should == :a
-          subject.arg2.should == :b
-        end
-
-      end
-    end
-
-    context "using an after_create hook" do
-      let(:schematic) do
-        Fabrication::Schematic.new(Person) do
-          first_name "Guy"
-          after_create { |k| k.first_name.upcase! }
-        end
-      end
-
-      it "calls after_create when generated with saving" do
-        schematic.generate(:save => true).first_name.should == "GUY"
-      end
-
-      it "does not call after_create when generated without saving" do
-        schematic.generate(:save => false).first_name.should == "Guy"
-      end
-    end
-
-  end
-
-  describe "#after_generation" do
-    let(:instance) { mock(:instance) }
-    let(:generator) { Fabrication::Generator::Base.new(Object) }
-
-    before { generator.send(:instance=, instance) }
-
-    it "saves with a true save flag" do
-      instance.should_receive(:save!)
-      generator.send(:after_generation, {:save => true})
-    end
-
-    it "does not save without a true save flag" do
-      instance.should_not_receive(:save)
-      generator.send(:after_generation, {})
-    end
-  end
-
-end