marley 0.3.0 → 0.4.0

data/lib/marley/test_helpers.rb

@@ -1,7 +1,6 @@
 require "rack/test"
 require 'marley/reggae'
 module Marley
-  #simple mocking framework; could be expanded to a general use client by adding display code.
   class TestClient
     CRUD2REST={'create' => 'post','read' => 'get','update' => 'put', 'del' => 'delete'}
     DEFAULT_OPTS={:url => nil,:root_url => nil, :resource_name => nil, :instance_id => nil, :method => nil, :extention =>nil, :auth => nil, :code => nil, :debug => nil}
@@ -10,7 +9,7 @@ module Marley
     def app
       Marley::Router.new
     end
-    def initialize(opts)
+    def initialize(opts={})
       @opts=DEFAULT_OPTS.merge(opts)
     end
     def make_url(opts=nil)

data/lib/marley/utils.rb

@@ -0,0 +1,36 @@
+
+module Marley
+  module Utils
+    def self.hash_keys_to_syms(hsh)
+      hsh.inject({}) {|h,(k,v)| h[k.to_sym]= v.class==Hash ? hash_keys_to_syms(v) : v;h }
+    end
+    # @todo:  make options inheritable?
+    def self.rest_opts_mod(name,opts,key_proc)
+      Module.new do |m|
+        @create_opts=[name,opts,key_proc]
+        def self.create_opts
+          @create_opts
+        end
+        def self.new(name=nil,opts=nil,key_proc=nil)
+          Marley::Utils.rest_opts_mod(*@create_opts)
+        end
+        opts.each {|opt| attr_accessor "#{name}_#{opt}"}
+        define_method "rest_#{name}" do
+          if opts.find {|opt| send(:"#{name}_#{opt}").to_s > ""}
+            foo=opts.inject({}) do |h,k|
+              i=send("#{name}_#{k}".sub(/^_/,''))
+              h[k.to_sym]=i.class==Hash ? i[key_proc.call] : i
+              h
+            end
+            if Marley.constants.include?("Reggae#{name.camelcase}")
+              Marley.const_get(:"Reggae#{name.camelcase}").new(foo)
+            else
+              foo 
+            end
+          end
+        end
+      end
+    end
+  end
+  RestActions=Utils.rest_opts_mod('actions',['get','post','put','delete'],lambda {$request[:user].class})
+end

data/lib/sequel/plugins/rest_convenience.rb

@@ -1,91 +1,87 @@
 
-RESTRICT_HIDE=1
-RESTRICT_RO=2
-RESTRICT_REQ=4
-TYPE_INDEX=0
-NAME_INDEX=1
-RESTRICTIONS_INDEX=2
-module Sequel::Plugins::RestConvenience
-  module ClassMethods
-    def controller
-      Marley::ModelController.new(self)
-    end
-    def resource_name
-      self.name.sub(/.*::/,'').underscore
-    end
-    def reggae_link(action=nil)
-      [:link,{:url => "/#{self.resource_name}/#{action}",:title => "#{action.humanize} #{self.resource_name.humanize}".strip}]
-    end
-    def list(params=nil)
-      user=$request[:user]
-      if user.respond_to?(otm=self.resource_name.pluralize)
-        if user.method(otm).arity==0  
-          if (relationship=user.send(otm)).respond_to?(:filter)
-            relationship.filter($request[:get_params][resource_name.to_sym] || {}).all
+module Sequel
+  module Plugins::RestConvenience
+    module ClassMethods
+      include Marley::RestActions
+      def controller
+        Marley::ModelController.new(self)
+      end
+      def resource_name
+        self.name.sub(/.*::/,'').underscore
+      end
+      def reggae_link(action=nil)
+        [:link,{:url => "/#{self.resource_name}/#{action}",:title => "#{action.humanize} #{self.resource_name.humanize}".strip}]
+      end
+      def list(params=nil)
+        user=$request[:user]
+        if user.respond_to?(otm=self.resource_name.pluralize)
+          if user.method(otm).arity==0  
+            if (relationship=user.send(otm)).respond_to?(:filter)
+              relationship.filter($request[:get_params][resource_name.to_sym] || {}).all
+            else
+              user.send(otm)
+            end
           else
-            user.send(otm)
+            user.send(otm,$request[:get_params][resource_name.to_sym])
           end
         else
-          user.send(otm,$request[:get_params][resource_name.to_sym])
+          raise Marley::AuthorizationError
         end
-      else
-        raise Marley::AuthorizationError
+      end
+      def autocomplete(input_content)
+        filter(:name.like("#{input_content.strip}%")).map {|rec| [rec.id, rec.name]}
       end
     end
-    def autocomplete(input_content)
-      filter(:name.like("#{input_content.strip}%")).map {|rec| [rec.id, rec.name]}
-    end
-  end
-  module InstanceMethods
-    def get_actions; [];end
-    def edit; self; end
-    def rest_cols
-      columns.reject do |c| 
-        if new?
-          c.to_s.match(/(^id$)|(_type$)|(date_(created|updated))/)
-        else
-          c.to_s.match(/_type$/)
+    module InstanceMethods
+      include Marley::RestActions
+      def edit; self; end
+      def rest_cols 
+        columns.reject do |c| 
+          if new?
+            c.to_s.match(/(^id$)|(_type$)|(date_(created|updated))/)
+          else
+            c.to_s.match(/_type$/)
+          end
         end
       end
-    end
-    def hidden_cols
-      columns.select {|c| c.to_s.match(/(_id$)/)}
-    end
-    def write_cols
-      rest_cols.reject {|c| c.to_s.match(/(^id$)|(date_(created|updated))/)}
-    end
-    def required_cols;[];end
-    def rest_schema
-      rest_cols.map do |col_name|
-        db_spec=db_schema.to_hash[col_name]
-        col_type=db_spec ? db_spec[:db_type].downcase : col_name
-        restrictions=0
-        restrictions|=RESTRICT_HIDE if hidden_cols.include?(col_name)
-        restrictions|=RESTRICT_RO unless write_cols.include?(col_name)
-        restrictions|=RESTRICT_REQ if required_cols.include?(col_name) || (db_spec && !db_spec[:allow_null])
-        [col_type, col_name, restrictions,send(col_name)]
+      def hidden_cols
+        columns.select {|c| c.to_s.match(/(_id$)/)}
       end
-    end
-    def to_s
-      respond_to?('name') ? name : id.to_s
-    end
-    def to_a
-      a=Marley::ReggaeInstance.new( {:name => self.class.resource_name,:url => url ,:new_rec => self.new?,:schema => rest_schema,:get_actions => get_actions.class==Hash ? get_actions[$request[:user].class] : get_actions})
-      if respond_to?(:rest_associations) && ! new?
-        a.contents=rest_associations.map do |assoc|
-          (assoc.class==Symbol ? send(assoc) : assoc).map{|instance| instance.to_a}
+      def write_cols
+        rest_cols.reject {|c| c.to_s.match(/(^id$)|(date_(created|updated))/)}
+      end
+      def required_cols;[];end
+      def rest_schema
+        rest_cols.map do |col_name|
+          db_spec=db_schema.to_hash[col_name]
+          col_type=db_spec ? db_spec[:db_type].downcase : col_name
+          restrictions=0
+          restrictions|=RESTRICT_HIDE if hidden_cols.include?(col_name)
+          restrictions|=RESTRICT_RO unless write_cols.include?(col_name)
+          restrictions|=RESTRICT_REQ if required_cols.include?(col_name) || (db_spec && !db_spec[:allow_null])
+          [col_type, col_name, restrictions,send(col_name)]
         end
       end
-      a
-    end
-    def to_json
-      to_a.to_json
-    end
-    def url(action=nil)
-      "/#{self.class.resource_name}/#{self[:id]}/#{action}".sub('//','/')
-    end
-    def reggae_link(action=nil)
-      [:link,{:url => url,:title => "#{action.humanize}"}]
+      def to_s
+        respond_to?('name') ? name : id.to_s
+      end
+      def to_a
+        a=Marley::ReggaeInstance.new( {:name => self.class.resource_name,:url => url ,:new_rec => self.new?,:schema => rest_schema,:actions => self.class.rest_actions})
+        a.contents=self.class.associations.map do |assoc|
+          assoc=send("#{assoc}_dataset")
+          (assoc.respond_to?(:current_user_dataset) ? assoc.current_user_dataset : assoc).map{|instance| instance.to_a} if assoc.respond_to?(:rest_actions)
+        end.compact unless new?
+        a
+      end
+      def to_json(*args)
+        to_a.to_json
+      end
+      def url(action=nil)
+        "/#{self.class.resource_name}/#{self[:id]}/#{action}".sub('//','/')
+      end
+      def reggae_link(action=nil)
+        [:link,{:url => url,:title => "#{action.humanize}"}]
+      end
     end
   end
 end

data/marley.gemspec

@@ -2,15 +2,17 @@
 
 Gem::Specification.new do |s|
   s.name = %q{marley}
-  s.version = "0.3.0"
+  s.version = "0.4.0"
   s.summary = %q{Irie default restful routes for your models and other objects}
-  s.description = %q{Marley implements a web services microframework on top of Rack and Sequel on the server side and Jquery on the client side.}
+  s.description = %q{Marley implements a web services microframework on top of Rack and Sequel on the server side and Jquery on the client side.  After 0.4.0 the joints framework will be redone.  However, I'm releasing this because I still think it's worth playing with and the joint restructuring will take a while.
+  }
   s.authors     = ["Herb Daily"]
   s.email       = 'herb.daily@safe-mail.net'
   s.homepage    = 'http://github.com/herbdaily/marley'
   s.required_rubygems_version = Gem::Requirement.new(">= 1.0.0") if s.respond_to? :required_rubygems_version=
   s.add_runtime_dependency 'sequel', '~>3.27'
   s.add_runtime_dependency 'rack', '~>1.2.2'
+  # add rubydoctest dependency
   s.add_runtime_dependency 'json', '~>1.1.7'
   s.files = Dir.glob(["*","lib/**/*","examples/**/*","test/**/*"])
 end

data/reggae.ebnf

@@ -15,9 +15,9 @@ section_property ::= 'title' | 'description' | 'navigation'
 
 link_property ::= 'title' | 'description' | 'url'
 
-instance_property ::= 'name' | 'url' | 'new_rec' | 'search' | 'schema' | 'get_actions' | 'delete_action'
+instance_property ::= 'name' | 'url' | 'new_rec' | 'search' | 'schema' | 'actions' 
 
-instance_list_property ::='title' | 'description' | 'schema' | 'get_actions' | 'delete_action' | 'items'
+instance_list_property ::='title' | 'description' | 'schema' | 'actions' | 'items'
 
 msg_property ::= 'title' | 'description'
 
@@ -39,11 +39,17 @@ schema_value ::= '[' col_spec (',' colspec)? ']'
 
 items_value ::= '[' '[' col_value (',' col_value)* ']' (',' '[' col_value (',' col_value)* ']')* ']'
 
-get_actions_value ::= '[' action (',' action)*']'
+actions_value ::= '{' '"' ('get' | 'post' | 'put' | 'delete') '"' ':' methods (',' '"' ('get' | 'post' | 'put' | 'delete') '"' ':' methods )* '}'
 
-action ::= string_value
+methods::= '[' ( get_method (',' get_method)* | post_method (',' post_method)* | put_method (',' put_method)* | delete_method (',' delete_method)* ) ']'
 
-delete_action_value ::= 'remove_parent' | 'deactivate' | 'delete'
+get_action ::= string_literal
+
+post_action ::= resource
+
+put_action ::= resource
+
+delete_method ::= 'remove_parent' | 'deactivate' | 'delete'
 
 col_spec ::= '[' col_type ',' col_name ',' col_restrictions (',' col_value)?  ']'
 

data/test/tagged_messaging_tests.rb

@@ -93,7 +93,7 @@ class MessageTests < Test::Unit::TestCase
       end
       should "have reply, reply_all and new_tags instance get actions" do
         resp=@client.read({})
-        assert_same_elements ['reply','reply_all','new_tags'], resp[0].get_actions
+        assert_same_elements ['reply','reply_all','new_tags'], resp[0].actions[:get]
       end
       context "user1 instance actions" do
         setup do
@@ -140,7 +140,7 @@ class MessageTests < Test::Unit::TestCase
           assert_same_elements ["sent", "test", "test2"], @tags.map{|t| t.schema[:tag].col_value}
         end
         should "allow sender to remove his own tags'" do
-          assert_equal 'remove_parent', @tags[0].delete_action
+          assert_equal 'remove_parent', @tags[0].actions[:delete]
           assert @client.del({},{:url => @tags[0].url+@msg.url})
           assert_equal 2, @client.read[0].find_instances('user_tag').length
         end
@@ -159,7 +159,7 @@ class MessageTests < Test::Unit::TestCase
           assert_equal 'test,test2', reply.schema[:tags].col_value
         end
         should "allow receiver to remove his own tags'" do
-          assert_equal 'remove_parent', @tags[0].delete_action
+          assert_equal 'remove_parent', @tags[0].actions[:delete]
           assert @client.del({},{:url => @tags[0].url+@msg.url})
           assert_equal 2, @client.read[0].find_instances('user_tag').length
         end
@@ -273,7 +273,7 @@ class MessageTests < Test::Unit::TestCase
       @client.create(@post.set_values('title' => 'test', 'message' => 'asdf','tags' => 'admintag1,admintag2'),{:auth => @admin_auth})
       @client.auth=@user2_auth
       posts=@client.read({})
-      assert_same_elements ['reply','new_tags','new_user_tags'], posts[0].get_actions
+      assert_same_elements ['reply','new_tags','new_user_tags'], posts[0].actions[:get]
       reply=@client.read({},{:instance_id => posts[0].schema[:id].col_value,:method => 'reply'})
       tags=@client.read({},{:instance_id => posts[0].schema[:id].col_value,:method => 'new_tags'})
       user_tags=@client.read({},{:instance_id => posts[0].schema[:id].col_value,:method => 'new_user_tags'})

data/test/user_tests.rb

@@ -42,7 +42,7 @@ class UserTests < Test::Unit::TestCase
   context "existing user logged in" do
     setup do
       @client.code=201
-      assert @client.create(:'user[name]' => 'user1',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf')
+      assert @client.create({:'user[name]' => 'user1',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf'})
       assert @client.create(:'user[name]' => 'user2',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf')
       @client.code=200
       @client.auth=['user1','asdfasdf']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: marley
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Herb Daily
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-20 00:00:00 -03:00
+date: 2011-12-01 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,7 +42,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.1.7
     version: 
-description: Marley implements a web services microframework on top of Rack and Sequel on the server side and Jquery on the client side.
+description: "Marley implements a web services microframework on top of Rack and Sequel on the server side and Jquery on the client side.  After 0.4.0 the joints framework will be redone.  However, I'm releasing this because I still think it's worth playing with and the joint restructuring will take a while.\n  "
 email: herb.daily@safe-mail.net
 executables: []
 
@@ -51,15 +51,17 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- marley-0.3.0.gem
 - marley.gemspec
 - Rakefile
 - Favicon.ico
 - README.rdoc
 - TODO
 - reggae.ebnf
-- forum_tests.rb
+- marley-0.4.0.gem
 - lib/marley.rb
 - lib/marley/test_helpers.rb
+- lib/marley/utils.rb
 - lib/marley/joint.rb
 - lib/marley/controllers.rb
 - lib/marley/reggae.rb
@@ -73,7 +75,6 @@ files:
 - lib/joints/basic_messaging.rb
 - lib/joints/basic_user.rb
 - lib/joints/tagging.rb
-- lib/joints/user_based_navigation.rb
 - lib/joints/basic_menu_system.rb
 - lib/joints/tagged_messaging.rb
 - examples/forum.js

data/forum_tests.rb

@@ -1,356 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-EXAMPLES_DIR=File.dirname(__FILE__) + '/../examples'
-
-ENV['MARLEY_TESTING']='true'
-`cp #{EXAMPLES_DIR}/empty.sqlite3 #{EXAMPLES_DIR}/forum_test.sqlite3`
-require "#{EXAMPLES_DIR}/forum.rb"
-require "#{EXAMPLES_DIR}/../lib/marley/test_helpers"
-
-class UserTests < Test::Unit::TestCase
-  def setup
-    Marley::Resources::User.delete
-    @client=Marley::TestClient.new(:resource_name => 'user',:code => 400)
-  end
-  should "return login form with no params" do
-    assert @client.read({},{:resource_name => '',:code => 200})
-  end
-  should "not allow access to menus, private messages, or posts" do
-    assert @client.read({:resource_name =>'pm_menu'},{:code => 401})
-    assert @client.read({:resource_name =>'post_menu'},{:code => 401})
-    assert @client.read({:resource_name =>'private_message'},{:code => 401})
-    assert @client.read({:resource_name =>'post'},{:code => 401})
-  end
-  should "validate new user properly" do
-    assert resp=@client.create
-    assert_equal :error, resp.resource_type
-    assert_equal "validation", resp.error_type
-    assert_equal ["is required"], resp.error_details[:name]
-    resp=@client.create({:'user[name]' => 'asdf'})
-    assert_equal :error, resp.resource_type
-    assert_equal "validation", resp.error_type
-    resp=@client.create({:'user[name]' => 'asdf',:'user[password]' => 'asdfaf'})
-    assert_equal :error, resp.resource_type
-    assert_equal "validation", resp.error_type
-    assert_equal ["Password must contain at least 8 characters"], resp.error_details[:password]
-    resp=@client.create(:'user[name]' => 'asdf',:'user[password]' => 'asdfasdf')
-    assert_equal :error, resp.resource_type
-    assert_equal "validation", resp.error_type
-    assert_equal ["Passwords do not match"], resp.error_details[:confirm_password]
-  end
-  should "allow creation of a new user and disallow user with the same name" do
-    @client.code=200
-    @client.create(:'user[name]' => 'asdf',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf')
-    assert @client.create({:'user[name]' => 'asdf',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf'},{:code => 400})
-  end
-  context "existing user logged in" do
-    setup do
-      @client.code=201
-      assert @client.create(:'user[name]' => 'user1',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf')
-      assert @client.create(:'user[name]' => 'user2',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf')
-      @client.code=200
-      @client.auth=['user1','asdfasdf']
-    end
-    should "show menus" do
-      menu= @client.read({},:resource_name => '')
-      assert_same_elements ["User Info", "Private Messages", "Public Posts"], menu.navigation.map{|n| n.title}
-      assert @client.read({},:resource_name => 'private_message/section')
-      assert @client.read({},:resource_name => 'post/section')
-    end
-    should "allow viewing and changing of user columns with proper validation" do
-      @client.instance_id=1
-      assert user=@client.read({})
-      params=user.to_params
-      assert @client.update(params,{:code => 204})
-      assert err=@client.update(params.update('user[password]' => 'zxcvzxcv'),{:code => 400})
-      assert_equal :error, err.resource_type
-      assert_equal "validation", err.error_type
-      assert @client.update(params.update('user[password]' => 'zxcvzxcv','user[confirm_password]' => 'zxcvzxcv', 'user[old_password]' => 'asdfasdf'),:code => 204)
-      assert @client.read({},:code => 401)
-      @client.auth=['user1','zxcvzxcv']
-      assert @client.read({})
-      @client.instance_id=2
-      assert @client.update(params.update('user[password]' => 'zxcvzxcv','user[confirm_password]' => 'zxcvzxcv', 'user[old_password]' => 'asdfasdf'),:code => 403)
-    end
-  end
-end
-class MessageTests < Test::Unit::TestCase
-  def setup
-    Marley::Resources::User.delete
-    Marley::Resources::Message.delete
-    Marley::Resources::Tag.delete
-    DB[:messages_tags].delete
-    @client=Marley::TestClient.new(:resource_name => 'user')
-    @client.create(:'user[name]' => 'user1',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf')
-    @client.create(:'user[name]' => 'user2',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf')
-    @client.create(:'user[name]' => 'admin',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf')
-    @admin_auth=['admin','asdfasdf']
-    @user1_auth=['user1','asdfasdf']
-    @user2_auth=['user2','asdfasdf']
-    Marley::Resources::User[:name => 'admin'].update(:user_type => 'Admin')
-  end
-  context "Private Messages" do
-    setup do
-      @client.resource_name='private_message'
-    end
-    context "regular user (user1) logged in" do
-      setup do
-        @client.auth=@user1_auth
-      end
-      should "show PM list" do
-        assert @client.read({})
-      end
-      should "validate new user generated PMs properly" do
-        #reject a PM with only recipients
-        resp=@client.create({:'private_message[recipients]' => 'user2'},{:code => 400})
-        assert_equal :error, resp.resource_type
-        assert_equal "validation", resp.error_type
-        assert_equal ["is required"], resp.error_details[:title]
-        assert_equal ["is required"], resp.error_details[:message]
-        #reject a PM to a non-existent user
-        resp=@client.create({:'private_message[recipients]' => 'asdfasdfasdfasdf',:'private_message[title]' => 'asdf',:'private_message[message]' => 'asdf'},{:code => 400})
-        assert_equal :error, resp.resource_type
-        assert_equal "validation", resp.error_type
-        assert resp.error_details[:recipients][0]
-        #reject a PM from user to user
-        resp=@client.create({:'private_message[recipients]' => 'user2',:'private_message[title]' => 'asdf',:'private_message[message]' => 'asdf'},{:code => 400})
-        assert_equal :error, resp.resource_type
-        assert_equal "validation", resp.error_type
-        assert resp.error_details[:recipients][0]
-      end
-      should "accept a PM to admin" do
-         assert @client.create({:'private_message[recipients]' => 'admin',:'private_message[title]' => 'asdf',:'private_message[message]' => 'asdf'})
-      end
-    end
-    context "admin logged in" do
-      setup do
-        @client.auth=@admin_auth
-      end
-      should "validate new admin generated PMs properly" do
-        resp=@client.create({:'private_message[recipients]' => 'user2'},{:code => 400})
-        assert_equal :error, resp.resource_type
-        assert_equal "validation", resp.error_type
-        assert_equal ["is required"], resp.error_details[:title]
-        assert_equal ["is required"], resp.error_details[:message]
-      end
-      should "accept a PM to user1" do
-         assert @client.create({:'private_message[recipients]' => 'user1',:'private_message[title]' => 'asdf',:'private_message[message]' => 'asdf'})
-      end
-    end
-    context "message with no tags" do
-      setup do
-        @client.auth=@admin_auth
-        @client.create({:'private_message[recipients]' => 'user1',:'private_message[title]' => 'asdf',:'private_message[message]' => 'asdf'})
-      end
-      should "show up in PM list of sender and receiver" do
-        resp=@client.read({})
-        assert_equal 1, resp.length
-        resp=@client.read({},{:auth => @user1_auth})
-        assert_equal 1, resp.length
-      end
-      should "have sent tag for sender" do
-        resp=@client.read({})
-        assert_equal 3, resp[0].length
-        assert_equal "sent", resp.find_instances('user_tag')[0].schema[:tag].col_value
-      end
-      should "have inbox tag for receiver" do
-        resp=@client.read({},{:auth => @user1_auth})
-        assert_equal 3, resp[0].length
-        assert_equal "inbox", resp.find_instances('user_tag')[0].schema[:tag].col_value
-      end
-      should "have reply, reply_all and new_tags instance get actions" do
-        resp=@client.read({})
-        assert_same_elements ['reply','reply_all','new_tags'], resp[0].get_actions
-      end
-      context "user1 instance actions" do
-        setup do
-          @client.auth=@user1_auth
-          @msg=@client.read({})[0]
-          @client.instance_id=@msg.schema[:id].col_value
-          @reply=@client.read({},{:method => 'reply'})
-          @new_tags=@client.read({},:method => 'new_tags')
-        end
-        context "reply" do
-          should "have author in to field and default title beginning with 're:'" do
-            assert_equal 'admin', @reply.schema[:recipients].col_value
-            assert_equal 're: ', @reply.schema[:title].col_value[0 .. 3]
-          end
-          should "accept reply" do
-            assert @client.create(@reply.to_params.merge('private_message[message]' => 'asdf'),{:method => nil,:instance_id => nil})
-          end
-        end
-        context "new tags" do
-          should "return tag instance with name tag and same url as original message" do
-            assert_equal 'tags', @new_tags.name
-            assert_equal "#{@msg.url}tags", @new_tags.url
-          end
-          should "accept new tags, which should then show up with the original message" do
-            assert @client.create({'private_message[tags]' => 'added_tag1, added_tag2'},{:method => 'tags'})
-            msg=@client.read({})
-            user_tags=msg.find_instances('user_tag')
-            assert_same_elements ["inbox", "added_tag1", "added_tag2"], user_tags.map{|t| t.schema[:tag].col_value}
-          end
-        end
-      end
-    end
-    context "message with 2 tags" do
-      setup do
-        @client.auth=@admin_auth
-        @client.create({:'private_message[recipients]' => 'user1',:'private_message[title]' => 'asdf',:'private_message[message]' => 'asdf', :'private_message[tags]' => 'test,test2'})
-      end
-      context "sender (admin) logged in" do
-        setup do
-          @msg=@client.read[0]
-          @tags=@msg.find_instances('user_tag')
-        end
-        should "have sent tag and both specified tags for sender" do
-          assert_same_elements ["sent", "test", "test2"], @tags.map{|t| t.schema[:tag].col_value}
-        end
-        should "allow sender to remove his own tags'" do
-          assert_equal 'remove_parent', @tags[0].delete_action
-          assert @client.del({},{:url => @tags[0].url+@msg.url})
-          assert_equal 2, @client.read[0].find_instances('user_tag').length
-        end
-      end
-      context "receiver (user1)" do
-        setup do
-          @client.auth=@user1_auth
-          @msg=@client.read[0]
-          @tags=@msg.find_instances('user_tag')
-        end
-        should "have inbox tag and both specified tags" do
-          assert_same_elements ["inbox", "test", "test2"], @tags.map{|t| t.schema[:tag].col_value}
-        end
-        should "have specified tags in reply" do
-          reply=@client.read({},{:instance_id => @msg.schema[:id].col_value,:method => 'reply'})
-          assert_equal 'test,test2', reply.schema[:tags].col_value
-        end
-        should "allow receiver to remove his own tags'" do
-          assert_equal 'remove_parent', @tags[0].delete_action
-          assert @client.del({},{:url => @tags[0].url+@msg.url})
-          assert_equal 2, @client.read[0].find_instances('user_tag').length
-        end
-      end
-      context 'user2' do
-        should "have no messages" do
-          assert resp=@client.read({},{:auth => @user2_auth})
-          assert_equal 0, resp.length
-        end
-      end
-    end
-    context "message with 2 tags and 2 receivers" do
-      setup do
-        @client.create({:'private_message[recipients]' => 'user1,user2',:'private_message[title]' => 'asdf',:'private_message[message]' => 'asdf', :'private_message[tags]' => 'test,test2'},{:auth => @admin_auth})
-      end
-      should "have sent tag and both specified for sender" do
-        resp=@client.read({},{:auth => @admin_auth})
-        user_tags=resp[0].find_instances('user_tag')
-        assert_same_elements ["sent", "test", "test2"], user_tags.map{|t| t.schema[:tag].col_value}
-      end
-      should "have inbox tag and both specified for 1st receiver (user1)" do
-        resp=@client.read({},{:auth => @user1_auth})
-        user_tags=resp[0].find_instances('user_tag')
-        assert_same_elements ["inbox", "test", "test2"], user_tags.map{|t| t.schema[:tag].col_value}
-      end
-      should "have inbox tag and both specified for 2st receiver (user2)" do
-        resp=@client.read({},{:auth => @user2_auth})
-        user_tags=resp[0].find_instances('user_tag')
-        assert_same_elements ["inbox", "test", "test2"], user_tags.map{|t| t.schema[:tag].col_value}
-      end
-    end
-    context "message listing" do
-      setup do
-        #3 messages with tag "test" for user 1
-        @client.create({:'private_message[recipients]' => 'user1',:'private_message[title]' => 'title1',:'private_message[message]' => 'body1', :'private_message[tags]' => 'test'},{:auth => @admin_auth})
-        @client.create({:'private_message[recipients]' => 'user1',:'private_message[title]' => 'title2',:'private_message[message]' => 'body2', :'private_message[tags]' => 'test'},{:auth => @admin_auth})
-        @client.create({:'private_message[recipients]' => 'user1',:'private_message[title]' => 'title3',:'private_message[message]' => 'body3', :'private_message[tags]' => 'test'},{:auth => @admin_auth})
-        #2 messages with tag "test1" for user1 and user2
-        @client.create({:'private_message[recipients]' => 'user2,user1',:'private_message[title]' => 'title1',:'private_message[message]' => 'body1', :'private_message[tags]' => 'test1'},{:auth => @admin_auth})
-        @client.create({:'private_message[recipients]' => 'user2,user1',:'private_message[title]' => 'title2',:'private_message[message]' => 'body2', :'private_message[tags]' => 'test1'},{:auth => @admin_auth})
-      end
-      should "for sender (admin) show 3 messages with 'test' tag,2 messages with 'test1' tag, and 5 messages with 'sent' tag" do
-        @client.auth=@admin_auth
-        assert_equal 3, @client.read({:'private_message[tags]' => 'test'}).length
-        assert_equal 2, @client.read({:'private_message[tags]' => 'test1'}).length
-        assert_equal 5, @client.read({:'private_message[tags]' => 'sent'}).length
-      end
-      should "for user1 show 3 messages with 'test' tag, 2 messages with 'test1' tag, 5 messages with 'inbox' tag, and 5 messages with 'test' or 'test1' tags" do
-        @client.auth=@user1_auth
-        assert_equal 3, @client.read({:'private_message[tags]' => 'test'}).length
-        assert_equal 2, @client.read({:'private_message[tags]' => 'test1'}).length
-        assert_equal 5, @client.read({:'private_message[tags]' => 'inbox'}).length
-        assert_equal 5, @client.read({:'private_message[tags]' => 'test,test1'}).length
-      end
-      should "for user2 show 0 messages with 'test' tag, 2 messages with 'test1' tag, 2 messages with 'inbox' tag and 2 messages with 'test' or 'test1' tags" do
-        @client.auth=@user2_auth
-        assert_equal 0, @client.read({:'private_message[tags]' => 'test'}).length
-        assert_equal 2, @client.read({:'private_message[tags]' => 'test1'}).length
-        assert_equal 2, @client.read({:'private_message[tags]' => 'inbox'}).length
-        assert_equal 2, @client.read({:'private_message[tags]' => 'test,test1'}).length
-      end
-    end
-  end
-  context "Posts" do
-    setup do
-      @client.resource_name='post'
-    end
-    context 'validation' do
-      should "get a validation error trying to post without a title or message as admin, user1, or user2" do
-        resp=@client.create({},{:code => 400,:auth => @admin_auth})
-        assert_equal :error, resp.resource_type
-        assert_equal "validation", resp.error_type
-        assert_equal ["is required"], resp.error_details[:title]
-        assert_equal ["is required"], resp.error_details[:message]
-        user1_resp=@client.create({},{:code => 400,:auth => @user1_auth})
-        assert_equal user1_resp, resp
-        user2_resp=@client.create({},{:code => 400,:auth => @user2_auth})
-        assert_equal user2_resp, resp
-      end
-      should "be able to post with title and message as admin, user1, or user2" do
-        assert @client.create({'post[title]' => 'test', 'post[message]' => 'asdf'},{:auth => @admin_auth})
-        assert_equal 1, @client.read({},{:auth => @user1_auth}).length
-        assert @client.create({'post[title]' => 'test', 'post[message]' => 'asdf'},{:auth => @user1_auth})
-        assert_equal 2, @client.read({},{:auth => @user2_auth}).length
-        assert @client.create({'post[title]' => 'test', 'post[message]' => 'asdf'},{:auth => @user2_auth})
-        assert_equal 3, @client.read({},{:auth => @admin_auth}).length
-      end
-    end
-    should 'list posts by public tags' do
-      @client.create({'post[title]' => 'test', 'post[message]' => 'asdf','post[tags]' => 'admintag1,admintag2'},{:auth => @admin_auth})
-      @client.create({'post[title]' => 'test', 'post[message]' => 'asdf','post[tags]' => 'admintag1,admintag2,admintag3'},{:auth => @admin_auth})
-      @client.create({'post[title]' => 'test', 'post[message]' => 'asdf','post[tags]' => 'user1tag1'},{:auth => @user1_auth})
-      @client.create({'post[title]' => 'test', 'post[message]' => 'asdf','post[tags]' => 'user1tag1,user1tag2'},{:auth => @user1_auth})
-      @client.create({'post[title]' => 'test', 'post[message]' => 'asdf','post[tags]' => 'user1tag1,user1tag2,user1tag3'},{:auth => @user1_auth})
-      @client.create({'post[title]' => 'test', 'post[message]' => 'asdf','post[tags]' => 'user2tag1,user2tag2,user2tag3'},{:auth => @user2_auth})
-      @client.create({'post[title]' => 'test', 'post[message]' => 'asdf','post[tags]' => 'user2tag1,user2tag2,user2tag3,user2tag4'},{:auth => @user2_auth})
-      assert_equal 7, @client.read({},{:auth => @admin_auth}).length
-      assert_equal 7, @client.read({'post[title]' => 'test'},{:auth => @admin_auth}).length
-      assert_equal 7, @client.read({'post[title]' => 'test'},{:auth => @user1_auth}).length
-      assert_equal 7, @client.read({'post[title]' => 'test'},{:auth => @user2_auth}).length
-      assert_equal 2, @client.read({'post[tags]' => 'admintag1'},{:auth => @admin_auth}).length
-      assert_equal 2, @client.read({'post[tags]' => 'admintag1'},{:auth => @user1_auth}).length
-      assert_equal 1, @client.read({'post[tags]' => 'admintag3'},{:auth => @user2_auth}).length
-      assert_equal 1, @client.read({'post[tags]' => 'admintag3'},{:auth => @admin_auth}).length
-      assert_equal 2, @client.read({'post[tags]' => 'user1tag2'},{:auth => @admin_auth}).length
-      assert_equal 3, @client.read({'post[tags]' => 'user1tag1'},{:auth => @admin_auth}).length
-      assert_equal 3, @client.read({'post[tags]' => 'user1tag1'},{:auth => @user2_auth}).length
-    end
-    should 'have usable reply, new_tags, and new_user_tags instance actions' do
-      @client.create({'post[title]' => 'test', 'post[message]' => 'asdf','post[tags]' => 'admintag1,admintag2'},{:auth => @admin_auth})
-      @client.auth=@user2_auth
-      posts=@client.read({})
-      assert_same_elements ['reply','new_tags','new_user_tags'], posts[0].get_actions
-      reply=@client.read({},{:instance_id => posts[0].schema[:id].col_value,:method => 'reply'})
-      tags=@client.read({},{:instance_id => posts[0].schema[:id].col_value,:method => 'new_tags'})
-      user_tags=@client.read({},{:instance_id => posts[0].schema[:id].col_value,:method => 'new_user_tags'})
-      assert_equal 're: test', reply.schema[:title].col_value
-      assert @client.create(reply.to_params.merge('post[message]' => 'asdf'),{:method => nil,:instance_id => nil})
-      assert @client.create(tags.to_params.merge('post[tags]' => '1,2,3'),{:url => tags.url})
-      assert_same_elements ['1','2','3','admintag1','admintag2'], @client.read[0].find_instances('public_tag').map{|t| t.schema[:tag].col_value}
-      assert @client.create(user_tags.to_params.merge('post[user_tags]' => '4,5,6'),{:url => user_tags.url})
-      assert_same_elements ['4','5','6'], @client.read[0].find_instances('user_tag').map{|t| t.schema[:tag].col_value}
-      assert_equal [], @client.read({},{:auth => @user1_auth})[0].find_instances('user_tag').map{|t| t.schema[:tag].col_value}
-    end
-  end
-end