veneer 0.1.0

data/test/macros/instance_wrapper/new_record_macro.rb

@@ -0,0 +1,35 @@
+class Test::Unit::TestCase
+  def self.veneer_should_implement_new_record?
+    context "on an instance" do
+      should "setup the test correctly" do
+        assert_not_nil @klass
+        assert_kind_of Class, @klass
+        assert_not_nil @valid_attributes
+        assert_kind_of Hash, @valid_attributes
+        assert_kind_of Hash, @invalid_attributes
+      end
+
+      setup do
+        @instance = Veneer(@klass).new(@valid_attributes)
+      end
+
+      context "new_record" do
+        should "return true when the record is new" do
+          assert @instance.new_record?
+        end
+
+        should "return false when the record is successfully saved" do
+          assert @instance.save
+          assert !@instance.new_record?
+        end
+
+        should "return true if the record cannot be saved" do
+          v = Veneer(@klass).new(@invalid_attributes)
+          assert  v.new_record?
+          assert !v.save
+          assert  v.new_record?
+        end
+      end
+    end
+  end
+end

data/test/macros/instance_wrapper/save_macro.rb

@@ -0,0 +1,55 @@
+class Test::Unit::TestCase
+  def self.veneer_should_implement_save
+    context "on an instance" do
+     should "setup the test correctly" do
+        assert_not_nil @klass
+        assert_kind_of Class, @klass
+        assert_not_nil @valid_attributes
+        assert_kind_of Hash, @valid_attributes
+        assert_kind_of Hash, @invalid_attributes
+      end
+
+      setup do
+        @invalid  = Veneer(@klass).new(@invalid_attributes)
+        @valid    = Veneer(@klass).new(@valid_attributes)
+      end
+
+      context "save" do
+        should "return true when it can save" do
+          assert @valid.save
+        end
+
+        should "return false when it can't save" do
+          assert !@invalid.save
+        end
+      end
+    end
+  end
+
+  def self.veneer_should_implement_save!
+    context "save!" do
+      should "setup the test correctly" do
+        assert_not_nil @klass
+        assert_kind_of Class, @klass
+        assert_not_nil @valid_attributes
+        assert_kind_of Hash, @valid_attributes
+        assert_kind_of Hash, @invalid_attributes
+      end
+
+      setup do
+        @invalid  = Veneer(@klass).new(@invalid_attributes)
+        @valid    = Veneer(@klass).new(@valid_attributes)
+      end
+
+      should "return true when successful" do
+        assert @valid.save!
+      end
+
+      should "raise Veneer::Errors::NotSaved when fails to save!" do
+        assert_raises Veneer::Errors::NotSaved do
+          @invalid.save!
+        end
+      end
+    end
+  end
+end

data/test/macros/veneer_constants_interface.rb

@@ -0,0 +1,26 @@
+class Test::Unit::TestCase
+  def self.veneer_should_have_the_required_veneer_constants
+    context "required constants" do
+
+      should "have correctly setup the spec" do
+        assert_kind_of Class, @klass
+      end
+
+      should "have a VeneerInterface constant" do
+        assert_nothing_raised do
+          @klass::VeneerInterface
+        end
+      end
+
+      should "have a VeneerInterface::ClassWrapper" do
+        assert_nothing_raised do
+          @klass::VeneerInterface::ClassWrapper
+        end
+      end
+
+      should "inherit the class wrapper from the base class wrapper" do
+        assert_contains @klass::VeneerInterface::ClassWrapper.ancestors, ::Veneer::Base::ClassWrapper
+      end
+    end
+  end
+end

data/test/support/helpers.rb

@@ -0,0 +1,18 @@
+module Veneer
+  module Test
+    module Helpers
+
+      def clear_constants!(*args)
+        Object.class_eval do
+          args.each do |obj|
+            begin
+              remove_const(obj)
+            rescue
+            end
+          end
+        end
+      end
+
+    end # Helpers
+  end # Test
+end # Veneer

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+Dir[File.join(File.dirname(__FILE__), "support", "**/*.rb")].each{|f| require f}
+Dir[File.join(File.dirname(__FILE__), "macros", "**/*.rb")].each{|f| require f}
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'veneer'
+
+class Test::Unit::TestCase
+  include Veneer::Test::Helpers
+end
+
+

data/test/veneer/adapters/active_record/active_record_setup.rb

@@ -0,0 +1,28 @@
+require 'activerecord'
+require 'veneer/adapters/activerecord'
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+class CreateActiveRecordFoo < ActiveRecord::Migration
+  def self.up
+    create_table :active_record_foos, :force => true do |t|
+      t.string  :name
+      t.integer :order_field1
+    end
+  end
+
+  def self.down
+    drop_table :active_record_foos
+  end
+end
+
+CreateActiveRecordFoo.up
+
+class ActiveRecordFoo < ActiveRecord::Base
+  def self.veneer_spec_reset!
+    delete_all
+  end
+
+  def validate
+    errors.add(:name, "Name cannot be 'invalid'") if name == "invalid"
+  end
+end

data/test/veneer/adapters/active_record/class_wrapper_test.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "test_helper")
+require File.join(File.dirname(__FILE__), "active_record_setup")
+
+module Veneer
+  module Test
+    class ActiveRecordClassWrapper < ::Test::Unit::TestCase
+      context "Active Record Veneer Adapter" do
+        setup do
+          @klass              = ::ActiveRecordFoo
+          @valid_attributes   = {:name => "foo"}
+          @invalid_attributes = {:name => "invalid"}
+        end
+        veneer_should_have_the_required_veneer_constants
+        veneer_should_implement_create_with_valid_attributes
+        veneer_should_impelement_destroy_all
+        veneer_should_implement_create_with_invalid_attributes
+        veneer_should_implement_find
+      end
+    end
+  end
+end

data/test/veneer/adapters/active_record/instance_wrapper_test.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "test_helper")
+require File.join(File.dirname(__FILE__), "active_record_setup")
+
+module Veneer
+  module Test
+    class ActiveRecordInstanceWrapper < ::Test::Unit::TestCase
+      context "Active Record Veneer Adapter" do
+        setup do
+          @klass              = ::ActiveRecordFoo
+          @valid_attributes   = {:name => "foo"}
+          @invalid_attributes = {:name => "invalid"}
+        end
+
+        veneer_should_implement_new_record?
+        veneer_should_implement_save
+        veneer_should_implement_save!
+        veneer_should_implement_destroy
+      end
+    end
+  end
+end

data/test/veneer/adapters/datamapper/class_wrapper_test.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "test_helper")
+require File.join(File.dirname(__FILE__), "datamapper_setup")
+
+module Veneer
+  module Test
+    class DataMapperClassWrapper < ::Test::Unit::TestCase
+      context "DataMapper Veneer Adapter" do
+        setup do
+          @klass = DMFoo
+          @valid_attributes   = {:name => "foo"}
+          @invalid_attributes = {:name => "invalid"}
+        end
+
+        veneer_should_have_the_required_veneer_constants
+        veneer_should_implement_create_with_valid_attributes
+        veneer_should_impelement_destroy_all
+        veneer_should_implement_create_with_invalid_attributes
+        veneer_should_implement_find
+      end
+    end
+  end
+end

data/test/veneer/adapters/datamapper/datamapper_setup.rb

@@ -0,0 +1,25 @@
+require 'dm-core'
+require 'dm-validations'
+require 'veneer/adapters/datamapper'
+
+DataMapper.setup(:default, 'sqlite3::memory:')
+
+class DMFoo
+  include DataMapper::Resource
+
+  property :id,           Serial
+  property :name,         String
+  property :order_field1, Integer
+
+  validates_with_method :name, :method => :check_name
+
+  def check_name
+    if name == "invalid"
+      [false, "Invalid name"]
+    else
+      true
+    end
+  end
+end
+
+DataMapper.auto_migrate!

data/test/veneer/adapters/datamapper/instance_wrapper_test.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "test_helper")
+require File.join(File.dirname(__FILE__), "datamapper_setup")
+
+module Veneer
+  module Test
+    class DataMapperInstanceWrapper < ::Test::Unit::TestCase
+      context "DataMapper Veneer Adapter" do
+        setup do
+          @klass = DMFoo
+          @valid_attributes   = {:name => "foo"}
+          @invalid_attributes = {:name => "invalid"}
+        end
+
+        veneer_should_implement_new_record?
+        veneer_should_implement_save
+        veneer_should_implement_save!
+        veneer_should_implement_destroy
+      end
+    end
+  end
+end

data/test/veneer/base/conditonal_test.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+class VeneerBaseConditionalTest < Test::Unit::TestCase
+  context "Conditional from hash" do
+    should "create a conditonal object from a blank hash" do
+      c = Veneer::Conditional.from_hash({})
+      assert_instance_of Veneer::Conditional, c
+    end
+
+    should "create a conditional with a limit" do
+      c = Veneer::Conditional.from_hash(:limit => 5)
+      assert_equal c.limit, 5
+    end
+
+    should "have an offset specified" do
+      c = Veneer::Conditional.from_hash(:offset => 5)
+      assert_equal c.offset, 5
+    end
+
+    context "Veneer::Conditional::Order" do
+      should "let me specify a field" do
+        c = Veneer::Conditional::Order.new("foo")
+        assert_equal c.field, :foo
+      end
+
+      should "be decending in order by default" do
+        c = Veneer::Conditional::Order.new("foo")
+        assert_equal :desc, c.direction
+      end
+
+      should "let me specify an ascending order" do
+        c = Veneer::Conditional::Order.new("foo", "asc")
+        assert_equal :asc, c.direction
+      end
+
+      should "let me specify a decending order" do
+        ["desc", :desc].each do |dir|
+          c = Veneer::Conditional::Order.new("foo", dir)
+          assert_equal :desc, c.direction
+        end
+      end
+    end
+
+    should "have an order specified as an array" do
+      c = Veneer::Conditional.from_hash(:order => ["foo", "bar"])
+      conditionals = [:foo, :bar].map do |f|
+        Veneer::Conditional::Order.new(f)
+      end
+      assert_equal c.order.first, conditionals.first
+      assert_equal c.order.last,  conditionals.last
+    end
+
+    should "let me specify the order with a direction" do
+      c = Veneer::Conditional.from_hash(:order => ["foo asc", "bar", "baz desc"])
+      conditionals = [[:foo, :asc], [:bar, :desc], [:baz, :desc]].map do |(f,d)|
+        Veneer::Conditional::Order.new(f, d)
+      end
+
+      (0..2).each do |i|
+        assert_equal c.order[i], conditionals[i]
+      end
+    end
+
+    context "conditions" do
+      context "condition object" do
+        should "let me specify an equal condition" do
+          c = Veneer::Conditional::Condition.new(:foo, "val", :eql)
+          assert_equal :foo, c.field
+          assert_equal :eql, c.operator
+          assert_equal "val", c.value
+        end
+      end
+
+      should "let me specify conditions" do
+        c = Veneer::Conditional.from_hash(:conditions => {:foo => "bar"})
+        condition = c.conditions.first
+        assert_instance_of Veneer::Conditional::Condition, condition
+      end
+
+      should "let me specify conditions for different operators" do
+        c = Veneer::Conditional.from_hash(:conditions => {
+          "foo not"  => "bar",
+          "bar not"    => 5,
+          "baz gte"   => 6
+        })
+        foo = c.conditions.detect{|x| x.field == :foo}
+        assert_not_nil          foo
+        assert_equal "bar",    foo.value
+        assert_equal :not,     foo.operator
+
+        bar = c.conditions.detect{|x| x.field == :bar}
+        assert_not_nil          bar
+        assert_equal 5,         bar.value
+        assert_equal :not,       bar.operator
+
+        baz = c.conditions.detect{|x| x.field == :baz}
+        assert_not_nil          baz
+        assert_equal  6,        baz.value
+        assert_equal  :gte,     baz.operator
+      end
+
+      should "not error for valid operators" do
+        [:eql, :gt, :gte, :lt, :lte, :in, :not].each do |op|
+          assert_nothing_raised do
+            Veneer::Conditional::Condition.new(:foo, "bar", op)
+          end
+        end
+      end
+
+      should "error if the operator isn't valid" do
+        assert_raises Veneer::Errors::ConditionalOperatorNotSupported do
+          Veneer::Conditional::Condition.new(:foo, "bar", :not_real)
+        end
+      end
+    end
+
+  end
+end

data/test/veneer/proxy_test.rb

@@ -0,0 +1,190 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+class VeneerProxyTest < Test::Unit::TestCase
+  context "Veneer::Proxy" do
+    setup do
+      clear_constants! :Foo, :Bar
+
+      class ::Foo
+        attr_accessor :order_field1, :order_field2, :name
+        def self.veneer_spec_reset!
+          collection.clear
+        end
+
+        def self.collection
+          @collection ||= []
+        end
+
+        def initialize(opts = {})
+          @opts = opts
+          [:order_field1, :order_field2, :name].each do |f|
+            send(:"#{f}=", opts[f])
+          end
+          self.class.collection << self
+          @new_record = true
+        end
+
+        def new_record?
+          !!@new_record
+        end
+
+        def save
+          result = @opts[:invalid].nil?
+          @new_record = false if result
+          result
+        end
+
+        def save!
+          raise Veneer::Errors::NotSaved if @opts[:invalid]
+          @new_record = false
+          true
+        end
+
+
+        module VeneerInterface
+          class ClassWrapper < Veneer::Base::ClassWrapper
+            def new(opts)
+              ::Kernel.Veneer(klass.new(opts))
+            end
+
+            def destroy_all
+              klass.collection.clear
+            end
+
+            def find_first(conditional)
+              find_many(conditional).first
+            end
+
+            def find_many(conditional)
+              result = ::Foo.collection
+
+              unless conditional.order.empty?
+                order = conditional.order.first
+                result = result.sort_by{|i| i.send(order.field)}
+                result.reverse! if order.decending?
+              end
+
+              if conditional.offset
+                offset = conditional.offset.to_i
+                result = result[offset..-1]
+              end
+
+              conditional.conditions.each do |condition|
+                filtered = case condition.operator
+                when :eql
+                  result.select{|i| i.send(condition.field) == condition.value}
+                when :not
+                  result.select{|i| i.send(condition.field) != condition.value}
+                when :gt
+                  result.select{|i| !i.send(condition.field).nil? && (i.send(condition.field) > condition.value)}
+                when :gte
+                  result.select{|i| !i.send(condition.field).nil? && (i.send(condition.field) >= condition.value)}
+                when :lt
+                  result.select{|i| !i.send(condition.field).nil? && (i.send(condition.field) < condition.value)}
+                when :lte
+                  result.select{|i| !i.send(condition.field).nil? && (i.send(condition.field) <= condition.value)}
+                when :in
+                  result.select{|i| condition.value.include?(i.send(condition.field))}
+                else
+                  []
+                end
+                result = filtered.flatten.compact
+              end
+              if conditional.limit
+                result = result[0..(conditional.limit - 1)]
+              end
+              result
+            end
+
+          end
+
+          class InstanceWrapper < Veneer::Base::InstanceWrapper
+
+            def new_record?
+              instance.new_record?
+            end
+
+            def save!
+              instance.save!
+            end
+
+            def save
+              instance.save
+            rescue
+              false
+            end
+
+            def destroy
+              instance.class.collection.delete(instance)
+              self
+            end
+          end
+        end
+      end
+    end # setup
+
+    should "be a BasicObject" do
+      assert_equal Veneer::Proxy.ancestors[1], BasicObject
+    end
+
+    context "test implementation" do
+      setup do
+        @klass = ::Foo
+        @valid_attributes   = {:name    => "foo"}
+        @invalid_attributes = {:invalid => true}
+        @instance           = ::Foo.new
+      end
+
+      veneer_should_have_the_required_veneer_constants
+      veneer_should_implement_create_with_valid_attributes
+      veneer_should_implement_create_with_invalid_attributes
+      veneer_should_impelement_destroy_all
+      veneer_should_implement_find
+      veneer_should_implement_new_record?
+      veneer_should_implement_save
+      veneer_should_implement_save!
+      veneer_should_implement_destroy
+    end
+
+    context "all" do
+      setup do
+        ::Foo.collection.clear
+        (0..5).each do |i|
+          ::Foo.new(:name => "foo#{i}", :order_field1 => i)
+        end
+      end
+
+      teardown{ ::Foo.collection.clear }
+
+      should "get all the resources" do
+        assert_equal ::Foo.collection.size, Veneer(::Foo).all.size
+      end
+
+      should "get the resources with a condition" do
+        assert_equal 1, Veneer(::Foo).all(:conditions => {:name => "foo1"}).size
+      end
+
+      should "get the resources with offset, limit" do
+        result = Veneer(::Foo).all(:offset => 1, :limit => 3)
+        assert_equal 3, result.size
+      end
+    end
+
+    context "first" do
+      setup do
+        ::Foo.collection.clear
+        (0..5).each do |i|
+          ::Foo.new(:name => "foo#{i}", :order_field1 => i)
+        end
+      end
+
+      teardown{ ::Foo.collection.clear }
+
+      should "get the correct resource with equal" do
+        expected = ::Foo.collection.select{|i| i.name == "foo1"}.first
+        result = Veneer(::Foo).first(:conditions => {:name => "foo1"})
+        assert_equal expected, result.instance
+      end
+    end
+  end
+end