dao 2.2.3 → 3.1.0

data/test/dao_test.rb

@@ -8,7 +8,7 @@ require File.join(testdir, 'helper')
 
 
 Testing Dao do
-# api
+## api
 #
   testing 'that an api class for your application can be built using a simple dsl' do
     assert{
@@ -53,15 +53,101 @@ Testing Dao do
     assert{ result.path.to_s =~ /foo/ }
   end
 
-# results
+  testing 'that an api can be called with different modes' do
+    api_class =
+      assert{
+        Dao.api do
+          call(:foo) do
+            data.modes = []
+
+            Dao::Mode.list.each do |mode|
+              send(mode){ data.modes.push(mode) }
+            end
+          end
+        end
+      }
+    api = assert{ api_class.new }
+
+    Dao::Mode.list.each do |mode|
+      result = api.mode(mode).call(:foo)
+      assert{ result.data.modes.include?(mode) }
+    end
+  end
+
+  testing 'that options/head/get are considered read modes' do
+    read_mode = assert{ Dao::Mode.read }
+
+    api_class =
+      assert{
+        Dao.api do
+          call(:foo) do
+            data.update :modes => []
+            read { data.modes.push(read_mode) }
+          end
+        end
+      }
+    api = assert{ api_class.new }
+
+    Dao::Mode::Read.each do |mode|
+      result = assert{ api.mode(mode).call(:foo) }
+      assert{ result.data.modes == [read_mode] }
+    end
+  end
+
+  testing 'that post/put/delete/trace/connect are considered write modes' do
+    write_mode = assert{ Dao::Mode.write }
+
+    api_class =
+      assert{
+        Dao.api do
+          call(:foo) do
+            data.update :modes => []
+            write { data.modes.push(write_mode) }
+          end
+        end
+      }
+    api = assert{ api_class.new }
+
+    Dao::Mode::Write.each do |mode|
+      result = assert{ api.mode(mode).call(:foo) }
+      assert{ result.data.modes == [write_mode] }
+    end
+  end
+
+  testing 'that the first, most specific, mode block encountered fires first' do
+    api_class =
+      assert{
+        Dao.api do
+          call(:foo) do
+            data.update :modes => []
+            Dao::Mode::Read.each do |mode|
+              send(mode){ data.modes.push(mode) }
+            end
+            read { data.modes.push(Dao::Mode.read) }
+          end
+        end
+      }
+    api = assert{ api_class.new }
+
+    read = Dao::Mode.read
+    result = assert{ api.mode(read).call(:foo) }
+    assert{ result.data.modes == [read] }
+
+    Dao::Mode::Read.each do |mode|
+      result = assert{ api.mode(mode).call(:foo) }
+      assert{ result.data.modes == [mode] }
+    end
+  end
+
+## results
 #
   testing 'that results can be created' do
     result = assert{ Dao::Result.new }
     assert{ result.path }
     assert{ result.status }
-    assert{ result.data }
     assert{ result.errors }
-    assert{ result.validations }
+    assert{ result.params }
+    assert{ result.data }
   end
 
   testing 'that results can be created with a path' do
@@ -80,7 +166,54 @@ Testing Dao do
     assert{ path.pattern.is_a?(Regexp) }
   end
 
-# status
+## routes
+#
+  testing 'that an api has a list of routes' do
+    api_class =
+      assert{
+        Dao.api do
+        end
+      }
+    assert{ api_class.routes.is_a?(Array) }
+  end
+
+  testing 'that routed interfaces call be declared' do
+    api_class =
+      assert{
+        Dao.api do
+          call('/users/:user_id/comments/:comment_id') do
+            data.update(params)
+          end
+        end
+      }
+    api = api_class.new
+  end
+
+  testing 'that routed methods can be called with embedded params' do
+    api_class =
+      assert{
+        Dao.api do
+          call('/users/:user_id/comments/:comment_id') do 
+            data.update(params)
+          end
+        end
+      }
+    api = api_class.new
+
+    {
+      '/users/4/comments/2' => {},
+      #'/users/comments' => {:user_id => 4, :comment_id => 2},
+      '/users/:user_id/comments/:comment_id' => {:user_id => 4, :comment_id => 2},
+    }.each do |path, params|
+      result = assert{ api.call(path, params) }
+      assert{ result.data.user_id.to_s =~ /4/ }
+      assert{ result.data.comment_id.to_s =~ /2/ }
+      assert{ result.path == '/users/4/comments/2' }
+    end
+  end
+
+
+## status
 #
   testing 'Status.for' do
     assert{ Dao::Status.for(:unauthorized).code == 401 }
@@ -100,7 +233,7 @@ Testing Dao do
     assert{ s != Array.new }
   end
 
-# parser
+## parser
 #
   testing 'parsing a simple hash by key' do
     params = {
@@ -136,7 +269,7 @@ Testing Dao do
     assert{
       api_class =
         Dao.api do
-          interface('/foobar'){
+          call('/foobar'){
             data.update(params)
           }
         end
@@ -205,7 +338,7 @@ Testing Dao do
     assert{ parsed =~ expected }
   end
 
-# errors.rb
+## errors
 #
   testing 'that clear does not drop sticky errors' do
     errors = Dao::Errors.new
@@ -235,13 +368,13 @@ Testing Dao do
     assert{ errors[global].nil? }
   end
 
-# validations
+## validations
 #
   testing 'that simple validations work' do
-    result = Dao::Result.new
-    assert{ result.validates(:password){|password| password=='haxor'} }
-    result.data.set(:password, 'haxor')
-    assert{ result.valid? }
+    params = Dao::Params.new
+    assert{ params.validates(:password){|password| password=='haxor'} }
+    params.set(:password, 'haxor')
+    assert{ params.valid? }
   end
 
   testing 'that validations have some syntax sugar' do
@@ -249,38 +382,81 @@ Testing Dao do
       api_class =
         Dao.api do
           interface('/foobar'){
-            result.validates(:a)
-            params.validate(:b)
-            validates(:c)
+            params.validate(:a)
+            validates(:b)
+            validate!
           }
         end
       api = api_class.new
 
-      result = assert{ api.call('/foobar', 'a' => true, 'b' => true, 'c' => true) }
+      result = assert{ api.call('/foobar', 'a' => true, 'b' => true) }
+      assert{ result.status.ok? }
+
+      result = assert{ api.call('/foobar') }
+      assert{ !result.status.ok? }
+      assert{ result.errors.size==2 }
     }
   end
 
-# validating
+  testing 'that validations use instance_exec' do
+    a, b = nil
+
+    api_class =
+      Dao.api do
+        interface('/foobar'){
+          params.validate(:a){ b = get(:b) }
+          params.validate(:b){ a = get(:a) }
+          validate!
+        }
+      end
+    api = api_class.new
+
+    result = assert{ api.call('/foobar', 'a' => 40, 'b' => 2) }
+    assert{ result.status.ok? }
+    assert{ a == 40 }
+    assert{ b == 2 }
+  end
+
+  testing 'simple validates_confirmation_of' do
+    api_class =
+      Dao.api do
+        interface('/foobar'){
+          params.validates_as_email(:email)
+          params.validates_confirmation_of(:email)
+          validate!
+        }
+      end
+    api = api_class.new
+
+    result = assert{ api.call('/foobar', 'email' => 'ara.t.howard@gmail.com', 'email_confirmation' => 'ara.t.howard@gmail.com') }
+    assert{ result.status.ok? }
+    assert{ result.errors.empty? }
+
+    result = assert{ api.call('/foobar', 'email' => 'ara.t.howard@gmail.com', 'email_confirmation' => 'ara@dojo4.com') }
+    assert{ !result.status.ok? }
+    assert{ !result.errors.empty? }
+  end
+
+## validating
 #
   testing 'that validations can be cleared and do not clobber manually added errors' do
-    result = Dao::Result.new
-    data = result.data
-    errors = result.errors
+    params = Dao::Params.new
+    errors = params.errors
 
-    assert{ result.validates(:email){|email| email.to_s.split(/@/).size == 2} }
-    assert{ result.validates(:password){|password| password == 'pa$$w0rd'} }
+    assert{ params.validates(:email){|email| email.to_s.split(/@/).size == 2} }
+    assert{ params.validates(:password){|password| password == 'pa$$w0rd'} }
 
-    data.set(:email => 'ara@dojo4.com', :password => 'pa$$w0rd')
-    assert{ result.valid? }
+    params.set(:email => 'ara@dojo4.com', :password => 'pa$$w0rd')
+    assert{ params.valid? }
 
-    data.set(:password => 'haxor')
-    assert{ !result.valid?(:validate => true) }
+    params.set(:password => 'haxor')
+    assert{ !params.valid?(:validate => true) }
 
     errors.add(:name, 'ara')
-    assert{ not result.valid? }
+    assert{ not params.valid? }
   end
 
-# doc
+## doc
 #
   testing 'that apis can be documented via the api' do
     api_class =
@@ -318,8 +494,13 @@ Testing Dao do
 
 =end
 
-    def hash_equal(a, b)
-      array = lambda{|h| h.to_a.map{|k,v| [k.to_s, v]}.sort}
-      array[a] == array[b]
-    end
+  def hash_equal(a, b)
+    array = lambda{|h| h.to_a.map{|k,v| [k.to_s, v]}.sort}
+    array[a] == array[b]
+  end
+
+  def api(&block)
+    api_class = assert{ Dao.api(&block) }
+    api = assert{ api_class.new }
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dao
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 3
   prerelease: 
   segments: 
-  - 2
-  - 2
   - 3
-  version: 2.2.3
+  - 1
+  - 0
+  version: 3.1.0
 platform: ruby
 authors: 
 - Ara T. Howard
@@ -15,57 +15,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-15 00:00:00 -06:00
+date: 2011-05-17 00:00:00 -06:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: tagz
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 87
-        segments: 
-        - 8
-        - 2
-        - 0
-        version: 8.2.0
-  type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: map
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 19
-        segments: 
-        - 2
-        - 7
-        - 0
-        version: 2.7.0
-  type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: yajl-ruby
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 61
-        segments: 
-        - 0
-        - 8
-        - 1
-        version: 0.8.1
-  type: :runtime
-  version_requirements: *id003
+dependencies: []
+
 description: "description: dao kicks the ass"
 email: ara.t.howard@gmail.com
 executables: []
@@ -75,15 +28,21 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- README
+- Rakefile
+- TODO
+- a.rb
 - dao.gemspec
+- lib/dao.rb
 - lib/dao/active_record.rb
+- lib/dao/api.rb
 - lib/dao/api/context.rb
 - lib/dao/api/dsl.rb
 - lib/dao/api/endpoints.rb
 - lib/dao/api/initializers.rb
 - lib/dao/api/interfaces.rb
 - lib/dao/api/modes.rb
-- lib/dao/api.rb
+- lib/dao/api/routes.rb
 - lib/dao/blankslate.rb
 - lib/dao/data.rb
 - lib/dao/db.rb
@@ -99,8 +58,8 @@ files:
 - lib/dao/params.rb
 - lib/dao/path.rb
 - lib/dao/presenter.rb
-- lib/dao/rails/app/api.rb
-- lib/dao/rails/app/controllers/api_controller.rb
+- lib/dao/rails.rb
+- lib/dao/rails/lib/generators/dao/USAGE
 - lib/dao/rails/lib/generators/dao/api_generator.rb
 - lib/dao/rails/lib/generators/dao/dao_generator.rb
 - lib/dao/rails/lib/generators/dao/templates/api.rb
@@ -108,71 +67,20 @@ files:
 - lib/dao/rails/lib/generators/dao/templates/dao.css
 - lib/dao/rails/lib/generators/dao/templates/dao.js
 - lib/dao/rails/lib/generators/dao/templates/dao_helper.rb
-- lib/dao/rails/lib/generators/dao/USAGE
-- lib/dao/rails.rb
 - lib/dao/result.rb
+- lib/dao/route.rb
 - lib/dao/slug.rb
 - lib/dao/status.rb
 - lib/dao/stdext.rb
 - lib/dao/support.rb
 - lib/dao/validations.rb
-- lib/dao.rb
-- Rakefile
-- README
-- sample/rails_app/app/api.rb
-- sample/rails_app/app/controllers/api_controller.rb
-- sample/rails_app/app/controllers/application_controller.rb
-- sample/rails_app/app/helpers/application_helper.rb
-- sample/rails_app/app/views/layouts/application.html.erb
-- sample/rails_app/config/application.rb
-- sample/rails_app/config/boot.rb
-- sample/rails_app/config/database.yml
-- sample/rails_app/config/environment.rb
-- sample/rails_app/config/environments/development.rb
-- sample/rails_app/config/environments/production.rb
-- sample/rails_app/config/environments/test.rb
-- sample/rails_app/config/initializers/backtrace_silencers.rb
-- sample/rails_app/config/initializers/inflections.rb
-- sample/rails_app/config/initializers/mime_types.rb
-- sample/rails_app/config/initializers/secret_token.rb
-- sample/rails_app/config/initializers/session_store.rb
-- sample/rails_app/config/locales/en.yml
-- sample/rails_app/config/routes.rb
-- sample/rails_app/config.ru
-- sample/rails_app/db/development.sqlite3
-- sample/rails_app/db/seeds.rb
-- sample/rails_app/doc/README_FOR_APP
-- sample/rails_app/Gemfile
-- sample/rails_app/Gemfile.lock
-- sample/rails_app/log/development.log
-- sample/rails_app/log/production.log
-- sample/rails_app/log/server.log
-- sample/rails_app/log/test.log
-- sample/rails_app/pubic/javascripts/dao.js
-- sample/rails_app/public/404.html
-- sample/rails_app/public/422.html
-- sample/rails_app/public/500.html
-- sample/rails_app/public/favicon.ico
-- sample/rails_app/public/images/rails.png
-- sample/rails_app/public/index.html
-- sample/rails_app/public/javascripts/application.js
-- sample/rails_app/public/javascripts/controls.js
-- sample/rails_app/public/javascripts/dragdrop.js
-- sample/rails_app/public/javascripts/effects.js
-- sample/rails_app/public/javascripts/prototype.js
-- sample/rails_app/public/javascripts/rails.js
-- sample/rails_app/public/robots.txt
-- sample/rails_app/Rakefile
-- sample/rails_app/README
-- sample/rails_app/script/rails
-- sample/rails_app/test/performance/browsing_test.rb
-- sample/rails_app/test/test_helper.rb
+- lib/dao/validations/base.rb
+- lib/dao/validations/common.rb
 - test/dao_test.rb
 - test/helper.rb
 - test/testing.rb
-- TODO
 has_rdoc: true
-homepage: http://github.com/ahoward/dao
+homepage: https://github.com/ahoward/dao
 licenses: []
 
 post_install_message: