blueprints 0.8.2 → 0.9.0

data/spec/unit/configuration_spec.rb

@@ -36,4 +36,15 @@ describe Blueprints::Configuration do
     @config.filename = "my_file.rb"
     @config.filename.should == [Pathname.new("my_file.rb")]
   end
+
+  describe "default attributes" do
+    it "should be name by default" do
+      @config.default_attributes.should == [:name]
+    end
+
+    it "should automatically convert them to array" do
+      @config.default_attributes = :id
+      @config.default_attributes.should == [:id]
+    end
+  end
 end

data/spec/unit/context_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Blueprints::Context do
+  subject do
+    context_with_attrs_and_deps
+  end
+
+  let :child_context do
+    Blueprints::Context.new(:parent => subject, :attributes => {:attr3 => 30, :attr2 => 20}, :dependencies => [:dep3, 'dep2'])
+  end
+
+  describe "initializing" do
+    it "should have attributes and and dependencies merged with parent" do
+      child_context.attributes.should == {:attr1 => 1, :attr2 => 20, :attr3 => 30}
+      child_context.dependencies.should == [:dep1, :dep2, :dep3]
+    end
+
+    it "should return own or parent file" do
+      subject.file.should == file
+      child_context.file.should == file
+    end
+
+    it "should return own or parent namespace" do
+      subject.namespace.should == namespace
+      child_context.namespace.should == namespace
+    end
+  end
+
+  describe "with context" do
+    it "should allow eval within context" do
+      File.expects(:read).with('my_file1').returns('method(1)')
+      Blueprints::Context.any_instance.expects(:method).with(1)
+      Blueprints::Context.eval_within_context(:file => 'my_file1')
+    end
+
+    it "should return context" do
+      Blueprints::Context.eval_within_context(:dependencies => [:within_dep]).dependencies.should == [:within_dep]
+    end
+
+    it "should instance eval with current context set" do
+      Blueprints::Context.any_instance.expects(:method).with(1)
+      Blueprints::Context.send(:class_variable_get, :@@chain) << context
+
+      Blueprints::Context.eval_within_context(:dependencies => [:within_dep]) do
+        method(1)
+        Blueprints::Context.current.dependencies.should == [:within_dep]
+      end
+      Blueprints::Context.current.should == context
+    end
+  end
+
+  describe "child contexts" do
+    it "should yield and return child context with attributes" do
+      yielded_context = nil
+      subject.attributes(:attr3 => 3) { yielded_context = self }.should == yielded_context
+      yielded_context.should be_instance_of(Blueprints::Context)
+      yielded_context.attributes.should == {:attr1 => 1, :attr2 => 2, :attr3 => 3}
+    end
+
+    it "should yield and return child context with dependencies" do
+      yielded_context = nil
+      subject.depends_on('the_dep') { yielded_context = self }.should == yielded_context
+      yielded_context.should be_instance_of(Blueprints::Context)
+      yielded_context.dependencies.should == [:dep1, :dep2, :the_dep]
+    end
+  end
+
+  describe "blueprints and namespaces" do
+    it "should allow creating blueprint" do
+      blueprint = subject.blueprint :blueprint
+      blueprint.should be_instance_of(Blueprints::Blueprint)
+      blueprint.name.should == :blueprint
+      blueprint.instance_variable_get(:@context).should == subject
+    end
+
+    it "should allow creating namespace" do
+      namespace = subject.namespace :namespace
+      namespace.should be_instance_of(Blueprints::Namespace)
+      namespace.name.should == :namespace
+      namespace.instance_variable_get(:@context).should == subject
+    end
+
+    it "should allow creating blueprint inside namespace" do
+      bp        = nil
+      namespace = subject.namespace(:namespace) { bp = self.blueprint :blueprint }
+      bp.namespace.should == namespace
+      namespace.children.should == {:blueprint => bp}
+    end
+
+    it "should allow creating blueprint with inferred name" do
+      blueprint = subject.attributes(:name => 'bp').blueprint
+      blueprint.name.should == :bp
+    end
+
+    it "should allow setting dependency" do
+      dep = context.d(:bp, :option => 'val')
+      dep.should be_instance_of(Blueprints::Dependency)
+    end
+  end
+end

data/spec/unit/dependency_spec.rb

@@ -2,48 +2,53 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Blueprints::Dependency do
   before do
-    Blueprints::RootNamespace.root.context.instance_eval do
-      @value = :value
-    end
+    stage.instance_variable_set(:@value, :value)
+    options_blueprint
+  end
+
+  let :stage do
+    Blueprints::Namespace.root.eval_context
+  end
 
-    mock = @mock
-    @value = value = Mocha::Mockery.instance.unnamed_mock
-    @blueprint = Blueprints::Blueprint.new(:blueprint, __FILE__) do
-      @value = value
-      options.present? ? options : mock
-    end
+  def value(dep)
+    stage.instance_eval(context, {}, &dep)
   end
 
   it "should allow getting instance variable value" do
-    Blueprints::Dependency.new(:blueprint).blueprint_value.should == @mock
+    value(Blueprints::Dependency.new(:options_blueprint)).should == mock1
   end
 
   it "should allow getting another instance variable" do
-    Blueprints::Dependency.new(:blueprint, :value).blueprint_value.should == @value
+    value(Blueprints::Dependency.new(:options_blueprint, :value)).should == mock2
+  end
+
+  it "should replace . in instance variable name with _" do
+    namespace_blueprint
+    value(Blueprints::Dependency.new(:'namespace.blueprint')).should == mock1
   end
 
   it "should allow passing options for building" do
-    Blueprints::Dependency.new(:blueprint, :option => 'value').blueprint_value.should == {:option => 'value'}
+    value(Blueprints::Dependency.new(:options_blueprint, :option => 'value')).should == {:option => 'value'}
   end
 
   it "should record all missing methods" do
-    dependency = Blueprints::Dependency.new(:blueprint)
+    dependency = Blueprints::Dependency.new(:options_blueprint)
     dependency.method1.method2(1).method3 {|val| val.method4 }
 
-    @mock.expects(:method1).with().returns(mock1 = mock)
-    mock1.expects(:method2).with(1).returns(mock2 = mock)
-    mock2.expects(:method3).with().yields(mock(:method4 => true)).returns(result = mock)
+    mock1.expects(:method1).with().returns(mock2 = mock)
+    mock2.expects(:method2).with(1).returns(mock3 = mock)
+    mock3.expects(:method3).with().yields(mock(:method4 => true)).returns(result = mock)
 
-    dependency.blueprint_value.should == result
+    value(dependency).should == result
   end
 
   it "should record to_s, id and other standard methods" do
-    dependency = Blueprints::Dependency.new(:blueprint)
+    dependency = Blueprints::Dependency.new(:options_blueprint)
     dependency.id.to_s
 
     @mock.expects(:id).returns(mock1 = mock)
     mock1.expects(:to_s).returns(result = mock)
 
-    dependency.blueprint_value.should == result
+    value(dependency).should == result
   end
 end

data/spec/unit/eval_context_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Blueprints::EvalContext do
+  subject do
+    Blueprints::EvalContext.new
+  end
+
+  it "should contain no instance variables" do
+    subject.instance_variables.should == []
+  end
+
+  describe "instance variables" do
+    it "should allow copying variables to other context" do
+      subject.instance_variable_set(:@var, :value)
+      subject.copy_instance_variables(context = Object.new)
+      context.instance_variables.collect(&:to_sym).should == [:@var]
+      context.instance_variable_get(:@var).should == :value
+    end
+  end
+
+  describe "instance eval" do
+    subject do
+      Blueprints::EvalContext.new
+    end
+
+    it "should allow to access to options" do
+      subject.instance_eval(context, :option => 'value') do
+        options.should == {:option => 'value'}
+      end
+    end
+
+    it "should allow to access to attributes" do
+      subject.instance_eval(context_with_attrs_and_deps, :option => 'value') do
+        attributes.should == {:option => 'value', :attr1 => 1, :attr2 => 2}
+      end
+    end
+
+    it "should normalize options and attributes" do
+      blueprint.build(subject)
+      subject.instance_variable_set(:@value, 2)
+      context = Blueprints::Context.new(:attributes => {:attr => Blueprints::Dependency.new(:blueprint)})
+
+      subject.instance_eval(context, :attr2 => lambda { @value + 2 }, :attr3 => :value) do
+        options.should == {:attr2 => 4, :attr3 => :value}
+        attributes.should == {:attr => @blueprint, :attr2 => 4, :attr3 => :value}
+      end
+    end
+  end
+
+  describe "build" do
+    it "should allow building blueprint" do
+      blueprint
+      subject.build(:blueprint).should == mock1
+    end
+  end
+end

data/spec/unit/fixtures.rb

@@ -0,0 +1,61 @@
+def file
+  __FILE__
+end
+
+def mock1
+  @mock ||= Mocha::Mockery.instance.unnamed_mock
+end
+
+def mock2
+  @mock2 ||= Mocha::Mockery.instance.unnamed_mock
+end
+
+def stage
+  @stage ||= Blueprints::EvalContext.new
+end
+
+def context
+  @context ||= Blueprints::Context.new(:file => file, :namespace => Blueprints::Namespace.root)
+end
+
+def context2
+  @context2 ||= Blueprints::Context.new(:parent => context, :namespace => namespace)
+end
+
+def context_with_attrs_and_deps
+  @context_with_attrs_and_deps ||= Blueprints::Context.new(:attributes => {:attr1 => 1, :attr2 => 2}, :dependencies => [:dep1, :dep2], :file => file, :namespace => namespace)
+end
+
+def blueprint(&block)
+  result = mock1
+  block ||= proc { result }
+  @blueprint ||= context.blueprint(:blueprint, &block)
+end
+
+def blueprint2(&block)
+  result = mock1
+  block ||= proc { result }
+  @blueprint2 ||= context.blueprint(:blueprint2, &block)
+end
+
+def options_blueprint
+  result, value = mock1, mock2
+  @options_blueprint ||= Blueprints::Blueprint.new(:options_blueprint, context) do
+    @value = value
+    options.present? ? options : result
+  end
+end
+
+def namespace
+  @namespace ||= context.namespace(:namespace)
+end
+
+def namespace_blueprint
+  result = mock1
+  @namespace_blueprint ||= context2.blueprint(:blueprint) { result }
+end
+
+def namespace_blueprint2
+  result = mock2
+  @namespace_blueprint2 ||= context2.blueprint(:blueprint2) { result }
+end

data/spec/unit/namespace_spec.rb

@@ -1,23 +1,71 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Blueprints::Namespace do
-  before do
-    mock = @mock
+  describe "children" do
+    it "should allow adding children to namespace" do
+      namespace.add_child(blueprint)
+      namespace[:blueprint].should == blueprint
+    end
+
+    it "should warn when adding children overwrites existing one" do
+      namespace_blueprint
+      Blueprints.expects(:warn).with("Overwriting existing blueprint", blueprint)
+      namespace.add_child(blueprint)
+    end
+
+    it "should allow recursive finding of children" do
+      namespace_blueprint
+      Blueprints::Namespace.root['namespace.blueprint'].should == namespace_blueprint
+    end
+
+    it "should raise error if blueprint can't be found" do
+      namespace_blueprint
+      expect {
+        Blueprints::Namespace.root['namespace.blueprint2']
+      }.to raise_error(Blueprints::BlueprintNotFoundError)
+    end
+  end
+
+  describe "children context" do
+    before do
+      namespace_blueprint
+    end
 
-    old_root = Blueprints::Namespace.root
-    @namespace = Blueprints::Namespace.root = Blueprints::Namespace.new(:namespace)
-    Blueprints::Blueprint.new(:blueprint1, __FILE__) { mock }
-    Blueprints::Blueprint.new(:blueprint2, __FILE__) { mock }
-    Blueprints::Namespace.root = old_root
+    it "should update attributes and dependencies of children when updating those of namespace" do
+      namespace.attributes(:parent => 1).depends_on(:parent_depends)
+      namespace_blueprint.attributes[:parent].should == 1
+      namespace_blueprint.dependencies.should include(:parent_depends)
+    end
+  end
+
+  describe "build" do
+    before do
+      blueprint
+      namespace_blueprint
+      namespace_blueprint2
+    end
 
-    Blueprints::Blueprint.new(:outside_namespace, __FILE__) { mock }
-    Blueprints::Namespace.root.build :namespace
+    it "should set result to results of all blueprints in namespace" do
+      result = namespace.build(stage)
+      result.should =~ [mock1, mock2]
+    end
+
+    it "should pass build once and eval context params" do
+      namespace_blueprint.expects(:build).with(instance_of(Blueprints::EvalContext), false, :option => 'value')
+      namespace_blueprint2.expects(:build).with(instance_of(Blueprints::EvalContext), false, :option => 'value')
+      namespace.build(stage, false, :option => 'value')
+    end
   end
 
   describe "demolish" do
     it "should allow to demolish namespace" do
-      @mock.expects(:destroy).twice
-      @namespace.demolish
+      blueprint
+      namespace_blueprint
+      namespace_blueprint2
+      results = namespace.build stage
+      results.each { |result| result.expects(:destroy) }
+
+      @namespace.demolish(stage)
     end
   end
 end

data/spec/unit/spec_helper.rb

@@ -1,27 +1,19 @@
-#require 'logger'
-#require 'active_record'
+Root = Pathname.new(__FILE__).dirname.join('..', '..')
+$: << Root.join('lib').to_s
 
-Dir.chdir File.join(File.dirname(__FILE__), '..', '..')
+require 'rspec'
+require 'blueprints'
+require File.dirname(__FILE__) + '/fixtures'
 
-#ActiveRecord::Base.logger = Logger.new("debug.log")
-
-#databases = YAML::load(IO.read("spec/active_record/fixtures/database.yml"))
-#db_info = databases[ENV["DB"] || "test"]
-#ActiveRecord::Base.establish_connection(db_info)
-
-require 'spec'
-require 'lib/blueprints'
-
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.mock_with :mocha
 
   config.before do
-    Blueprints::Namespace.root.instance_variable_set(:@context, Blueprints::Context.new)
-    @mock = Mocha::Mockery.instance.unnamed_mock
+    Blueprints::Namespace.root.eval_context = Blueprints::EvalContext.new
   end
 
   config.after do
-    Blueprints::Namespace.root.children.clear
+    Blueprints::Namespace.root.instance_variable_get(:@children).clear
     Blueprints::Namespace.root.executed_blueprints.clear
   end
 end

data/test/blueprints_test.rb

@@ -67,16 +67,30 @@ class BlueprintsTest < ActiveSupport::TestCase
     end
   end
 
+  context "build per describe" do
+    unless File.dirname(__FILE__) =~ /test$/
+      build_blueprint :apple
+
+      should "have cherry" do
+        assert(!(@apple.nil?))
+      end
+
+      should "have correct cherry species" do
+        assert(@apple.species == 'apple')
+      end
+    end
+  end
+
   context 'with preloaded cherry scenario' do
     should "have correct size after changed by second test" do
       assert(@cherry.average_diameter == 3)
-      @cherry.update_attribute(:average_diameter, 1)
+      @cherry.blueprint(:average_diameter => 1)
       assert(@cherry.average_diameter == 1)
     end
 
     should "have correct size" do
       assert(@cherry.average_diameter == 3)
-      @cherry.update_attribute(:average_diameter, 5)
+      @cherry.blueprint(:average_diameter => 5)
       assert(@cherry.average_diameter == 5)
     end
 
@@ -94,7 +108,7 @@ class BlueprintsTest < ActiveSupport::TestCase
       demolish :apple
       assert(!Fruit.all.include?(@apple))
       build :apple
-      assert(Fruit.last == @apple)
+      assert(Fruit.all.include?(@apple))
     end
 
     should "overwrite auto created instance variable with another auto created one" do
@@ -120,11 +134,11 @@ class BlueprintsTest < ActiveSupport::TestCase
     end
 
     should "create only one apple" do
-      assert(Fruit.all(:conditions => 'species = "apple"').size == 1)
+      assert(Fruit.all(:conditions => {:species => "apple"}).size == 1)
     end
 
     should "create only two cherries even if they were preloaded" do
-      assert(Fruit.all(:conditions => 'species = "cherry"').size == 2)
+      assert(Fruit.all(:conditions => {:species => "cherry"}).size == 2)
     end
 
     should "contain cherries in basket if basket is loaded in test and cherries preloaded" do
@@ -132,26 +146,6 @@ class BlueprintsTest < ActiveSupport::TestCase
     end
   end
 
-  context 'transactions' do
-    setup do
-      build :apple
-    end
-
-    should "drop only inner transaction" do
-      assert(!(@apple.reload.nil?))
-      begin
-        ActiveRecord::Base.transaction do
-          f = Fruit.create(:species => 'orange')
-          assert(!(f.reload.nil?))
-          raise 'some error'
-        end
-      rescue
-      end
-      assert(!(@apple.reload.nil?))
-      assert(Fruit.find_by_species('orange').nil?)
-    end
-  end
-
   context 'errors' do
     should 'raise ScenarioNotFoundError when scenario could not be found' do
       assert_raise(Blueprints::BlueprintNotFoundError) do
@@ -164,12 +158,6 @@ class BlueprintsTest < ActiveSupport::TestCase
         build :parent_not_existing
       end
     end
-
-    should 'raise TypeError when scenario name is not symbol or string' do
-      assert_raise(TypeError, "Pass blueprint names as strings or symbols only, cannot define blueprint 1") do
-        Blueprints::Blueprint.new(1, __FILE__)
-      end
-    end
   end
 
   context 'with active record blueprints extensions' do
@@ -202,7 +190,7 @@ class BlueprintsTest < ActiveSupport::TestCase
 
     should "normalize attributes when updating with blueprint method" do
       build :cherry, :oak
-      @cherry.blueprint(:tree => :@oak)
+      build :cherry => {:tree => d(:oak)}
       assert(@cherry.tree == @oak)
     end
 
@@ -213,8 +201,7 @@ class BlueprintsTest < ActiveSupport::TestCase
     end
 
     should "allow to pass array of hashes to blueprint method" do
-      Fruit.create
-      fruits = Fruit.blueprint([{:species => 'fruit1'}, {:species => 'fruit2'}])
+      fruits = Fruit.blueprint({:species => 'fruit1'}, {:species => 'fruit2'})
       assert(fruits.collect(&:species) == %w{fruit1 fruit2})
     end
 
@@ -331,23 +318,27 @@ class BlueprintsTest < ActiveSupport::TestCase
     end
   end
 
-  should "allow to build! without checking if it was already built" do
-    build! :big_cherry, :big_cherry => {:species => 'not so big cherry'}
-    assert(Fruit.count == 4)
-    assert(!(Fruit.find_by_species('not so big cherry').nil?))
-  end
+  context "build!" do
+    should "allow to building same blueprint again" do
+      build! :big_cherry, :big_cherry => {:species => 'not so big cherry'}
+      assert(Fruit.count == 4)
+      assert(!(Fruit.first(:conditions => {:species => 'not so big cherry'}).nil?))
+    end
 
-  should "warn when blueprint with same name exists" do
-    STDERR.expects(:puts).with("**WARNING** Overwriting existing blueprint: 'overwritten'")
-    STDERR.expects(:puts).with(regexp_matches(/blueprints_(spec|test)\.rb:\d+:in `new'/))
-    Blueprints::Blueprint.new(:overwritten, __FILE__)
-    Blueprints::Blueprint.new(:overwritten, __FILE__)
+    should "allow building same blueprint n times" do
+      oaks = build! 5, :oak
+      assert(oaks.size == 5)
+      oaks.each do |oak|
+        assert(oak.instance_of?(Tree))
+        assert(oak.name == 'Oak')
+      end
+    end
   end
 
   context 'attributes' do
     should "allow to extract attributes from blueprint" do
-      assert(build_attributes('attributes.cherry') == {:species => 'cherry'})
-      assert(build_attributes('attributes.shortened_cherry') == {:species => 'cherry'})
+      assert(build_attributes('attributes.cherry') == {:species => 'cherry', :average_diameter => 10})
+      assert(build_attributes('attributes.shortened_cherry') == {:species => 'cherry', :average_diameter => 10})
       assert(build_attributes(:big_cherry) == {})
     end
 
@@ -367,13 +358,7 @@ class BlueprintsTest < ActiveSupport::TestCase
     end
 
     should "return build attributes for dependencies" do
-      attrs = build_attributes('attributes.dependent_cherry1')
-      assert(!(@the_pine.nil?))
-      assert(attrs[:tree] == @the_pine)
-    end
-
-    should "return build attributes for :@var" do
-      attrs = build_attributes('attributes.dependent_cherry2')
+      attrs = build_attributes('attributes.dependent_cherry')
       assert(!(@the_pine.nil?))
       assert(attrs[:tree] == @the_pine)
     end
@@ -383,11 +368,7 @@ class BlueprintsTest < ActiveSupport::TestCase
     build :circular_reference
   end
 
-  should "rewrite trace" do
-    begin
-      build :error
-    rescue RuntimeError => e
-      assert(e.backtrace[0] == "spec/active_record/blueprint.rb:2:in blueprint 'error'")
-    end
+  should "allow inferring blueprint name" do
+    assert(build(:infered).name == 'infered')
   end
 end