dao 3.3.0 → 4.2.1

data/test/conducer_test.rb

@@ -0,0 +1,205 @@
+Testing Dao::Conducer do
+##
+#
+  testing 'that base classes can be constructed and named' do
+    new_foo_conducer_class()
+  end
+
+##
+#
+  testing 'that basic validations/errors work' do
+    c =
+      assert{
+        new_foo_conducer_class do
+          validates_presence_of :bar
+          validates_presence_of :foo, :bar 
+        end
+      }
+
+    o = assert{ c.new }
+    assert{ !o.valid? }
+
+    assert{ !Array(o.errors.get(:bar)).empty? }
+    assert{ !Array(o.errors.get(:foo, :bar)).empty? }
+
+    o.attributes.set :foo, :bar, 42
+    assert{ !o.valid? }
+
+    assert{ Array(o.errors.get(:foo, :bar)).empty? }
+  end
+
+##
+#
+  testing 'that basic form elements work' do
+    c =
+      assert{
+        new_foo_conducer_class do
+          validates_presence_of :bar
+        end
+      }
+
+    o = assert{ c.new }
+    assert{ o.form }
+    assert{ o.form.input(:foo) }
+    assert{ o.form.input(:bar) }
+  end
+
+##
+#
+  context 'class endpoint' do
+    testing '.new' do
+      c = assert{ new_foo_conducer_class }
+      controller = assert{ Dao.mock_controller }
+
+      check = proc do |args|
+        params = args.detect{|arg| arg.is_a?(Hash)} || {}
+        o = assert{ c.new(*args) }
+        assert{ o.is_a?(Dao::Conducer) }
+        assert{ o.attributes =~ params }
+        assert{ o.controller.is_a?(ActionController::Base) }
+      end
+
+      [
+        {},
+        {:k => :v},
+        nil,
+      ].each do |params|
+        check[ [params] ]
+        check[ [controller, params] ]
+        check[ [params, controller] ]
+      end
+    end
+
+    testing '.all' do
+      c = assert{ new_foo_conducer_class }
+      assert{ c.all().is_a?(Array) }
+      assert{ c.all(nil).is_a?(Array) }
+      assert{ c.all({}).is_a?(Array) }
+    end
+
+    testing '.find' do
+      c = assert{ new_foo_conducer_class }
+      o = assert{ c.new }
+      assert{ c.find(o.id).is_a?(Dao::Conducer) }
+    end
+
+    testing '.model_name' do
+      c = assert{ new_foo_conducer_class }
+      assert{ c.model_name }
+      o = assert{ c.new } 
+      assert{ o.model_name }
+    end
+  end
+
+  context 'current' do
+    testing 'class and instance endpoints' do
+      c = assert{ new_foo_conducer_class }
+      o = c.new
+      %w(
+        current_controller
+        current_request
+        current_response
+        current_session
+        current_user
+      ).each do |method|
+        assert{ o.respond_to?(method) }
+        assert{ c.respond_to?(method) }
+      end
+    end
+  end
+
+  context 'instance endpoint' do
+    testing '#save' do
+      params = {:k => :v}
+      o = assert{ new_foo_conducer(params) }
+      assert{ o.save }
+      id = assert{ o.id }
+      assert{ db.foos.find(id)[:k] == o.attributes[:k] }
+      assert{ id == o.id }
+      assert{ o.attributes =~ params.merge(:id => id) }
+    end
+
+    testing '#update_attributes' do
+      params = {:k => :v}
+      o = assert{ new_foo_conducer(params) }
+      t = Time.now
+      assert{ o.update_attributes :t => t }
+      assert{ o.save }
+      id = assert{ o.id }
+      assert{ db.foos.find(id).id == o.id }
+      assert{ db.foos.find(id) =~ params.merge(:id => id, :t => t) }
+    end
+
+    testing '#destroy' do
+      params = {:k => :v}
+      o = assert{ new_foo_conducer(params) }
+      assert{ o.save }
+      id = assert{ o.id }
+      assert{ db.foos.find(id).id == o.id }
+      assert{ o.destroy }
+      assert{ db.foos.find(id).nil? }
+    end
+
+    testing '#to_param' do
+      o = assert{ new_foo_conducer() }
+      assert{ o.to_param.nil? }
+      o.id = 42
+      assert{ o.to_param }
+    end
+
+    testing '#errors' do
+      o = assert{ new_foo_conducer() }
+      assert{ o.errors.respond_to?(:[]) }
+    end
+  end
+
+  
+
+protected
+  def new_foo_conducer_class(&block)
+    name = 'FooConducer'
+    c = assert{ Class.new(Dao::Conducer){ self.name = name; crud! } }
+    assert{ c.name == 'FooConducer' }
+    assert{ c.model_name == 'Foo' }
+    assert{ c.table_name == 'foos' && c.collection_name == 'foos' }
+    assert{ c.module_eval(&block); true } if block
+    c
+  end
+
+  def new_foo_conducer(*args, &block)
+    assert{ new_foo_conducer_class(&block).new(*args) }
+  end
+
+  prepare do
+    $db = Dao::Db.new(:path => 'test/db.yml')
+    Dao::Db.instance = $db
+    collection = $db['foos']
+    %w( a b c ).each do |name|
+      collection.save(
+        :name => name, :created_at => Time.now.to_f, :a => %w( x y z ), :h => {:k => :v}
+      )
+    end
+  end
+
+  cleanup do
+    $db = Dao::Db.new(:path => 'test/db.yml')
+    $db.rm_f
+  end
+
+  def db
+    $db
+  end
+
+  def collection
+    $db[:foos]
+  end
+end
+
+
+BEGIN {
+  testdir = File.dirname(File.expand_path(__FILE__))
+  rootdir = File.dirname(testdir)
+  libdir = File.join(rootdir, 'lib')
+  require File.join(libdir, 'dao')
+  require File.join(testdir, 'testing')
+}

data/test/db.yml

@@ -0,0 +1,9 @@
+--- 
+foos: 
+  "1": 
+    k: :v
+    id: "1"
+  "2": 
+    k: :v
+    id: "2"
+    t: 2011-09-14 19:40:02.939163 -06:00

data/test/form_test.rb

@@ -0,0 +1,42 @@
+Testing Dao::Form do
+  testing '.new' do
+    form = new_form() 
+    form = new_named_form() 
+  end
+
+  testing 'name_for' do
+    assert{ Dao::Form.name_for(:foo, :a, :b) == 'dao[foo][a.b]' }
+    assert{ new_form.name_for(:a, :b) == 'dao[form][a.b]' }
+    assert{ new_named_form.name_for(:a, :b) == 'dao[name][a.b]' }
+    assert{ new_named_form(:foo).name_for(:a, :b) == 'dao[foo][a.b]' }
+  end
+
+protected
+  def new_form
+    assert{ Dao::Form.new }
+  end
+
+  def new_named_form(name = 'name')
+    object = Object.new
+    class << object
+      %w[ name attributes errors ].each{|attr_name| attr_accessor(attr_name)}
+      attr_accessor :name
+    end
+    object.name = name
+    object.attributes = Map.new
+    object.errors = Dao::Errors.new
+    assert{ Dao::Form.new(object) }
+  end
+end
+
+
+
+BEGIN {
+  testdir = File.dirname(File.expand_path(__FILE__))
+  rootdir = File.dirname(testdir)
+  libdir = File.join(rootdir, 'lib')
+
+  require File.join(libdir, 'dao')
+  require File.join(testdir, 'testing')
+  require File.join(testdir, 'helper')
+}

data/test/support_test.rb

@@ -0,0 +1,52 @@
+Testing Dao::Conducer do
+  testing 'that dao has a root' do
+    assert{ Dao.respond_to?(:root) }
+    assert{ Dao.root }
+  end
+
+  testing 'that dao can build a mock controller' do
+    controller = assert{ Dao.mock_controller }
+    assert{ controller.url_for '/' }
+  end
+
+  testing 'that dao can mark the current_controller' do
+    assert{ Dao.current_controller = Dao.mock_controller }
+  end
+
+  testing 'that dao can pre-process parameters' do
+    params = Map.new( 
+      'dao' => {
+        'foos' => {
+          'k' => 'v',
+          'array.0' => '0',
+          'array.1' => '1'
+        },
+
+        'bars' => {
+          'a' => 'b',
+          'hash.k' => 'v'
+        }
+      }
+    )
+
+    assert{ Dao.normalize_parameters(params) }
+    assert{ params[:dao] = :normalized }
+
+    assert{ params[:foos].is_a?(Hash) }
+    assert{ params[:foos][:k] == 'v' }
+    assert{ params[:foos][:array] == %w( 0 1 ) }
+
+    assert{ params[:bars].is_a?(Hash) }
+    assert{ params[:bars][:a] == 'b' }
+    assert{ params[:bars][:hash] == {'k' => 'v'} }
+  end
+end
+
+
+BEGIN {
+  testdir = File.dirname(File.expand_path(__FILE__))
+  rootdir = File.dirname(testdir)
+  libdir = File.join(rootdir, 'lib')
+  require File.join(libdir, 'dao')
+  require File.join(testdir, 'testing')
+}

data/test/testing.rb

@@ -10,43 +10,125 @@ $:.unshift(testdir) unless $:.include?(testdir)
 $:.unshift(libdir) unless $:.include?(libdir)
 $:.unshift(rootdir) unless $:.include?(rootdir)
 
-def Testing(*args, &block)
-  Class.new(Test::Unit::TestCase) do
-
-    def self.slug_for(*args)
+class Testing
+  class Slug < ::String
+    def Slug.for(*args)
       string = args.flatten.compact.join('-')
       words = string.to_s.scan(%r/\w+/)
       words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
       words.delete_if{|word| word.nil? or word.strip.empty?}
-      words.join('-').downcase
+      new(words.join('-').downcase)
     end
+  end
+  
+  class Context
+    attr_accessor :name
 
-    def self.testing_subclass_count
-      @@testing_subclass_count = '0' unless defined?(@@testing_subclass_count) 
-      @@testing_subclass_count
+    def initialize(name, *args)
+      @name = name
     end
 
-    self.testing_subclass_count.succ!
-    slug = slug_for(*args).gsub(%r/-/,'_')
-    name = ['TESTING', '%03d' % self.testing_subclass_count, slug].delete_if{|part| part.empty?}.join('_')
-    name = name.upcase!
-    const_set(:Name, name)
-    def self.name() const_get(:Name) end
-
-    def self.testno()
-      '%05d' % (@testno ||= 0)
-    ensure
-      @testno += 1
+    def to_s
+      Slug.for(name)
     end
+  end
+end
+
+def Testing(*args, &block)
+  Class.new(::Test::Unit::TestCase) do
+
+  ## class methods
+  #
+    class << self
+      def contexts
+        @contexts ||= []
+      end
+
+      def context(*args, &block)
+        return contexts.last if(args.empty? and block.nil?)
 
-    def self.testing(*args, &block)
-      method = ["test", testno, slug_for(*args)].delete_if{|part| part.empty?}.join('_')
-      define_method("test_#{ testno }_#{ slug_for(*args) }", &block)
+        context = Testing::Context.new(*args)
+        contexts.push(context)
+
+        begin
+          block.call(context)
+        ensure
+          contexts.pop
+        end
+      end
+
+      def slug_for(*args)
+        string = [context, args].flatten.compact.join('-')
+        words = string.to_s.scan(%r/\w+/)
+        words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
+        words.delete_if{|word| word.nil? or word.strip.empty?}
+        words.join('-').downcase.sub(/_$/, '')
+      end
+
+      def name() const_get(:Name) end
+
+      def testno()
+        '%05d' % (@testno ||= 0)
+      ensure
+        @testno += 1
+      end
+
+      def testing(*args, &block)
+        method = ["test", testno, slug_for(*args)].delete_if{|part| part.empty?}.join('_')
+        define_method(method, &block)
+      end
+
+      def test(*args, &block)
+        testing(*args, &block)
+      end
+
+      def setup(&block)
+        define_method(:setup, &block) if block
+      end
+
+      def teardown(&block)
+        define_method(:teardown, &block) if block
+      end
+
+      def prepare(&block)
+        @prepare ||= []
+        @prepare.push(block) if block
+        @prepare
+      end
+
+      def cleanup(&block)
+        @cleanup ||= []
+        @cleanup.push(block) if block
+        @cleanup
+      end
     end
 
-    alias_method '__assert__', 'assert'
+  ## configure the subclass!
+  #
+    const_set(:Testno, '0')
+    slug = slug_for(*args).gsub(%r/-/,'_')
+    name = ['TESTING', '%03d' % const_get(:Testno), slug].delete_if{|part| part.empty?}.join('_')
+    name = name.upcase!
+    const_set(:Name, name)
+    const_set(:Missing, Object.new.freeze)
+
+  ## instance methods
+  #
+    alias_method('__assert__', 'assert')
 
     def assert(*args, &block)
+      if args.size == 1 and args.first.is_a?(Hash)
+        options = args.first
+        expected = getopt(:expected, options){ missing }
+        actual = getopt(:actual, options){ missing }
+        if expected == missing and actual == missing
+          actual, expected, *ignored = options.to_a.flatten
+        end
+        expected = expected.call() if expected.respond_to?(:call)
+        actual = actual.call() if actual.respond_to?(:call)
+        assert_equal(expected, actual)
+      end
+
       if block
         label = "assert(#{ args.join(' ') })"
         result = nil
@@ -61,6 +143,23 @@ def Testing(*args, &block)
       end
     end
 
+    def missing
+      self.class.const_get(:Missing)
+    end
+
+    def getopt(opt, hash, options = nil, &block)
+      [opt.to_s, opt.to_s.to_sym].each do |key|
+        return hash[key] if hash.has_key?(key)
+      end
+      default =
+        if block
+          block.call
+        else
+          options.is_a?(Hash) ? options[:default] : nil
+        end
+      return default
+    end
+
     def subclass_of exception
       class << exception
         def ==(other) super or self > other end
@@ -68,7 +167,29 @@ def Testing(*args, &block)
       exception
     end
 
-    module_eval &block
+  ##
+  #
+    module_eval(&block)
+
+    self.setup()
+    self.prepare.each{|b| b.call()}
+
+    at_exit{ 
+      self.teardown()
+      self.cleanup.each{|b| b.call()}
+    }
+
     self
   end
 end
+
+
+if $0 == __FILE__
+
+  Testing 'Testing' do
+    testing('foo'){ assert true }
+    test{ assert true }
+    p instance_methods.grep(/test/)
+  end
+
+end