blueprints 0.8.2 → 0.9.0

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+@orm, @version = (ENV['ORM'] || 'active_record').split('.', 2)
+gem_mappings = {'active_record' => 'activerecord'}
+gem gem_mappings[@orm], "~> #{@version}" if @version
+require @orm unless @orm == 'none'
+
+Root = Pathname.new(__FILE__).dirname.join('..')
+$: << Root.to_s
+
+require 'logger'
+@logger_file = Root.join('debug.log')
+@logger = Logger.new(@logger_file)
+
+require 'lib/blueprints'
+require "spec/support/#{@orm}/initializer"
+
+config_class = if @rspec1
+  gem 'rspec', '~> 1.0'
+  require 'spec'
+  Spec::Runner
+else
+  gem 'rspec', '>= 2.0.0.beta'
+  require 'rspec'
+  RSpec
+end
+
+config_class.configure do |config|
+  config.mock_with :mocha
+end
+
+Blueprints.enable do |config|
+  config.root = Root.join('spec')
+  config.prebuild = :big_cherry
+  config.transactions = @transactions
+end

data/spec/support/active_record/database.yml.example

@@ -0,0 +1,7 @@
+adapter: mysql2
+socket: /var/run/mysqld/mysqld.sock
+encoding: utf8
+database: blueprints_test
+username: root
+password:
+host: localhost

data/spec/support/active_record/initializer.rb

@@ -0,0 +1,15 @@
+class Fruit < ActiveRecord::Base
+  belongs_to :tree
+end
+
+class Tree < ActiveRecord::Base
+  attr_protected :size
+  has_many :fruits
+end
+
+db_config = YAML::load(Root.join("spec/support/active_record/database.yml").read)
+ActiveRecord::Base.establish_connection(db_config)
+ActiveRecord::Base.logger = @logger
+
+@rspec1 = @version.to_s[0, 1] == '2'
+@transactions = true

data/spec/support/dm-core/initializer.rb

@@ -0,0 +1,31 @@
+class Fruit
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :species, String
+  property :average_diameter, Integer
+
+  belongs_to :tree, :required => false, :default => nil
+end
+
+class Tree
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :name, String
+  property :size, String, :writer => :private
+
+  has n, :fruits
+end
+
+DataMapper::Model.raise_on_save_failure = true
+
+require 'dm-transactions'
+require 'dm-migrations'
+
+DataMapper::Logger.new(@logger_file, :debug)
+DataMapper.setup(:default, 'mysql://localhost/blueprints_test')
+DataMapper.finalize
+DataMapper.auto_migrate!
+
+@transactions = true

data/spec/support/mongo_mapper/database.yml.example

@@ -0,0 +1,2 @@
+database: blueprints_test
+host: localhost

data/spec/support/mongo_mapper/initializer.rb

@@ -0,0 +1,20 @@
+class Fruit
+  include MongoMapper::Document
+
+  key :species, String
+  key :average_diameter, Integer
+
+  belongs_to :tree
+end
+
+class Tree
+  include MongoMapper::Document
+
+  key :size
+
+  attr_protected :size
+  many :fruits
+end
+
+MongoMapper.connection = Mongo::Connection.new('localhost')
+MongoMapper.database = 'blueprints_test'

data/spec/support/mongoid/database.yml.example

@@ -0,0 +1,2 @@
+database: blueprints_test
+host: localhost

data/spec/support/mongoid/initializer.rb

@@ -0,0 +1,23 @@
+class Fruit
+  include Mongoid::Document
+
+  field :species
+  field :average_diameter, :type => Integer
+
+  referenced_in :tree, :inverse_of => :fruits
+end
+
+class Tree
+  include Mongoid::Document
+
+  field :size
+
+  attr_protected :size
+  references_many :fruits
+end
+
+Mongoid.configure do |config|
+  config.logger = @logger
+  config.from_hash YAML.load_file(Root.join('spec/support/mongoid/database.yml'))
+end
+

data/spec/support/none/initializer.rb

@@ -0,0 +1,63 @@
+class NoneOrm
+  include Blueprints::Extensions::Blueprintable
+
+  class << self
+    def add (record)
+      @all ||= []
+      @all << record
+    end
+
+    def destroy(record)
+      @all.delete record
+    end
+
+    def count
+      all.size
+    end
+
+    def all(options = {})
+      Array(@all).clone.tap do |result|
+        result.reject! do |record|
+          options[:conditions].any? { |key, value| record.send(key) != value }
+        end if options[:conditions]
+      end
+    end
+
+    def first(options = {})
+      all(options).first
+    end
+
+    def last(options = {})
+      all(options).last
+    end
+  end
+
+  def initialize #(params)
+#    params.each { |param, value| instance_variable_set("@#{param}", value) }
+    self.class.add(self)
+  end
+
+  def reload
+    self
+  end
+
+  def destroy
+    self.class.destroy(self)
+  end
+end
+
+class Fruit < NoneOrm
+  attr_accessor :species, :average_diameter, :tree
+end
+
+class Tree < NoneOrm
+  attr_accessor :name, :size, :fruits
+end
+
+RSpec.configure do |config|
+  config.before do
+    [Fruit, Tree].each do |klass|
+      klass.instance_variables.each { |iv| klass.send(:remove_instance_variable, iv) }
+    end
+  end
+end

data/spec/unit/active_record_spec.rb

@@ -1,11 +1,6 @@
 require 'active_record'
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'spec/active_record/fixtures/fruit'
-require 'spec/active_record/fixtures/tree'
-
-databases = YAML::load(IO.read("spec/active_record/fixtures/database.yml"))
-db_info = databases[ENV["DB"] || "test"]
-ActiveRecord::Base.establish_connection(db_info)
+require File.dirname(__FILE__) + '/../support/active_record/initializer'
 
 describe ActiveRecord::Base do
   it "should allow calling blueprint on associations" do

data/spec/unit/blueprint_spec.rb

@@ -1,53 +1,124 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Blueprints::Blueprint do
-  before do
-    mock = @mock
-    @blueprint = Blueprints::Blueprint.new(:blueprint, __FILE__) { mock }
-    Blueprints::Namespace.root.build :blueprint
+  it "should rewrite trace" do
+    context         = Blueprints::Context.new(:file => __FILE__)
+    error_blueprint = Blueprints::Blueprint.new(:error, context) { raise 'error' }
+    begin
+      error_blueprint.build(stage)
+    rescue RuntimeError => e
+      e.backtrace[0].should =~ %r{spec/unit/blueprint_spec.rb:#{__LINE__ - 4}:in blueprint 'error'}
+    end
+  end
+
+  describe "building" do
+    describe "build count" do
+      it "should increase build count" do
+        lambda {
+          blueprint.build(stage)
+        }.should change(blueprint, :uses).by(1)
+      end
+
+      it "should not increase build count if blueprint was already built" do
+        blueprint.build(stage)
+        lambda {
+          blueprint.build(stage, false)
+        }.should_not change(blueprint, :uses)
+      end
+    end
+
+    it "should copy instance variables to container" do
+      result = mock
+      blueprint { @bl = result }.build(stage)
+      stage.instance_variable_get(:@bl).should == result
+    end
+
+    describe "auto set variable" do
+      it "should be set" do
+        blueprint.build(stage)
+        stage.instance_variable_get(:@blueprint).should == mock1
+      end
+
+      it "should not be set if blueprint defines same variable" do
+        result = mock
+        blueprint do
+          @blueprint = result
+          :false_result
+        end.build(stage)
+        stage.instance_variable_get(:@blueprint).should == result
+      end
+
+      it "should reset auto variable" do
+        blueprint.build(stage)
+        stage.instance_variable_set(:@blueprint, :false_result)
+        blueprint.build(stage, false)
+        stage.instance_variable_get(:@blueprint).should == mock1
+      end
+    end
+
+    it "should allow passing options" do
+      (result = mock).expects(:options=).with(:option => 'value')
+      blueprint2 { result.options = options }.build(stage, true, :option => 'value')
+    end
+
+    it "should include attributes for blueprint" do
+      (result = mock).expects(:attributes=).with(:option => 'value')
+      blueprint2 { result.attributes = attributes }.attributes(:option => 'value').build(stage)
+    end
+
+    it "should automatically build dependencies" do
+      blueprint
+      blueprint2.depends_on(:blueprint).build(stage)
+      blueprint.should be_built
+    end
   end
 
   describe "demolish" do
     before do
-      @mock.stubs(:destroy)
+      @result = blueprint.build(stage)
+      @result.stubs(:destroy)
     end
 
     it "should allow to demolish blueprint" do
-      @mock.expects(:destroy)
-      @blueprint.demolish
+      @result.expects(:destroy)
+      blueprint.demolish(stage)
     end
 
     it "should raise error if blueprint is not built" do
-      @blueprint.demolish
-      lambda { @blueprint.demolish }.should raise_error(Blueprints::DemolishError)
+      blueprint.demolish(stage)
+      lambda { blueprint.demolish(stage) }.should raise_error(Blueprints::DemolishError)
     end
 
     it "should set blueprint as not built" do
-      @blueprint.demolish
-      Blueprints::Namespace.root.executed_blueprints.should_not include(@blueprint)
+      blueprint.demolish(stage)
+      Blueprints::Namespace.root.executed_blueprints.should_not include(blueprint)
     end
 
     it "should allow to customize demolishing" do
-      @mock.expects(:demolish)
-      @blueprint.demolish { @blueprint.demolish }
-      @blueprint.demolish
+      @result.expects(:demolish)
+      blueprint.demolish { @blueprint.demolish }
+      blueprint.demolish(stage)
     end
   end
 
   describe "updating" do
+    before do
+      @result = blueprint.build(stage)
+    end
+
     it "should allow building blueprint with different parameters" do
-      @mock.expects(:blueprint).with(:option => 'value')
-      Blueprints::RootNamespace.root.build(:blueprint => {:option => 'value'})
+      @result.expects(:blueprint).with(:option => 'value')
+      blueprint.build stage, true, :option => 'value'
     end
 
     it "should allow customizing update block" do
-      @blueprint.update { @blueprint.update_attributes(options) }
-      @mock.expects(:update_attributes).with(:option => 'value')
-      Blueprints::RootNamespace.root.build(:blueprint => {:option => 'value'})
+      blueprint.update { @blueprint.update_attributes(options) }
+      @result.expects(:update_attributes).with(:option => 'value')
+      blueprint.build stage, true, :option => 'value'
     end
 
     it "should not update if build_once is false" do
-      Blueprints::RootNamespace.root.build({:blueprint => {:option => 'value'}}, nil, false)
+      blueprint.build stage, false, :option => 'value'
     end
   end
 end

data/spec/unit/blueprints_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Blueprints do
+  describe "usage" do
+    before do
+      blueprint
+      blueprint2
+      namespace_blueprint
+      namespace_blueprint2
+    end
+
+    it "should allow getting unused blueprints" do
+      Blueprints::Namespace.root.build [:blueprint, :"namespace.blueprint2"]
+      Blueprints.unused.should =~ ['blueprint2', 'namespace.blueprint']
+    end
+
+    describe "most used" do
+      before do
+        Blueprints::Namespace.root.build [:blueprint, :blueprint2, :"namespace.blueprint"]
+        Blueprints::Namespace.root.executed_blueprints.clear
+        Blueprints::Namespace.root.build [:blueprint2, :"namespace.blueprint"]
+        Blueprints::Namespace.root.executed_blueprints.clear
+        Blueprints::Namespace.root.build [:"namespace.blueprint"]
+      end
+
+      it "should return all blueprints with their usages" do
+        Blueprints.most_used.should == [["namespace.blueprint", 3], ["blueprint2", 2], ["blueprint", 1], ["namespace.blueprint2", 0]]
+      end
+
+      it "should allow getting most used blueprints" do
+        Blueprints.most_used(:count => 2).should == [['namespace.blueprint', 3], ['blueprint2', 2]]
+      end
+
+      it "should allow getting list of blueprints used at least n times" do
+        Blueprints.most_used(:at_least => 1).should == [['namespace.blueprint', 3], ['blueprint2', 2], ["blueprint", 1]]
+      end
+
+      it "should allow mixing at least with count" do
+        Blueprints.most_used(:at_least => 2, :count => 3).should == [['namespace.blueprint', 3], ['blueprint2', 2]]
+        Blueprints.most_used(:at_least => 2, :count => 1).should == [['namespace.blueprint', 3]]
+      end
+    end
+  end
+end

data/spec/unit/buildable_spec.rb

@@ -1,14 +1,45 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Blueprints::Buildable do
-  before do
-    mock = @mock
-    @blueprint = Blueprints::Blueprint.new(:blueprint, __FILE__) { mock }
+  it "should inspect buildable nicely" do
+    namespace_blueprint.attributes(:attr => 'value').depends_on(:dependency)
+    namespace_blueprint.inspect.should == %q(<#Blueprints::Blueprint name: "namespace.blueprint", attributes: {:attr=>"value"}, dependencies: [:dependency]>)
   end
 
-  describe "normalize attributes" do
-    it "should allow passing dependent normalize Blueprints::Dependency object" do
-      Blueprints::Buildable.normalize_attributes(:name => Blueprints::Dependency.new(:blueprint)).should == {:name => @mock} 
+  describe "name" do
+    after do
+      Blueprints.config.default_attributes = :name
+    end
+
+    it 'should raise TypeError when scenario name is not symbol or string' do
+      lambda {
+        Blueprints::Blueprint.new([], context)
+      }.should raise_error(TypeError, "Pass blueprint names as strings or symbols only, cannot define blueprint []")
+    end
+
+    it "should return full name" do
+      namespace_blueprint.full_name.should == 'namespace.blueprint'
+    end
+
+    describe "inferring" do
+      it "should infer name using default attributes" do
+        Blueprints::Buildable.new(nil, context.attributes(:name => 'inferred_name')).name.should == :inferred_name
+      end
+
+      it "should infer name from third default attribute" do
+        Blueprints.config.default_attributes = :name, :to_s, :id
+        Blueprints::Buildable.new(nil, context.attributes(:id => 'third')).name.should == :third
+      end
+
+      it "should parameterize infered name" do
+        Blueprints::Buildable.new(nil, context.attributes(:name => 'my blueprint')).name.should == :my_blueprint
+      end
+
+      it "should raise error if name can't be inferred" do
+        lambda {
+          Blueprints::Buildable.new(nil, context.attributes(:id => 'third')).name.should == :third
+        }.should raise_error(TypeError, "Pass blueprint names as strings or symbols only, cannot define blueprint nil")
+      end
     end
   end
 end