riakrest 0.1.0 → 0.1.2

data/spec/core/jiak_client_spec.rb

@@ -10,9 +10,9 @@ end
 
 describe "JiakClient" do
   before do
-    @base_uri = 'http://127.0.0.1:8002/jiak/'
+    @base_uri = SERVER_URI
     @client = JiakClient.new(@base_uri)
-    @params = {:reads => 1, :writes => 2, :durable_writes => 3, :waits => 4}
+    @params = {:reads => 1, :writes => 2, :durable_writes => 3, :deletes => 4}
     @opts = @params.merge({:proxy => 'proxy_uri'})
   end
 
@@ -20,16 +20,49 @@ describe "JiakClient" do
     @client.should respond_to(:set_schema,:schema,:keys)
     @client.should respond_to(:proxy,:proxy=)
     @client.should respond_to(:params,:set_params,:params=)
-    @client.should respond_to(:get,:store,:delete,:walk)
+    @client.should respond_to(:store,:get,:delete)
+    @client.should respond_to(:exist?,:walk)
     @client.should respond_to(:==,:eql?)
   end
 
+  it "should protect constants" do
+    no_no = lambda {JiakClient::APP_JSON << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+
+    no_no = lambda {JiakClient::RETURN_BODY << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+
+    no_no = lambda {JiakClient::READS << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+
+    no_no = lambda {JiakClient::WRITES << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+
+    no_no = lambda {JiakClient::DURABLE_WRITES << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+
+    no_no = lambda {JiakClient::DELETES << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+
+    no_no = lambda {JiakClient::VALID_PARAMS << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+
+    no_no = lambda {JiakClient::VALID_OPTS << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+    
+    no_no = lambda {JiakClient::KEYS << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+    
+    no_no = lambda {JiakClient::SCHEMA << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+  end
+
   it "should default to base URI" do
     @client.server.should match @base_uri
   end
 
   it "should allow specified base URI" do
-    base_uri = 'http://localhost:1234/tmp/'
+    base_uri = 'http://host:port/base/'
     client = JiakClient.new base_uri
     client.server.should match base_uri
   end
@@ -69,12 +102,12 @@ describe "JiakClient" do
     @client.params = @params
     @params.each {|k,v| @client.params[k].should == @params[k]}
 
-    @client.set_params(:writes => 1, :waits => nil)
+    @client.set_params(:writes => 1, :deletes => nil)
     params = @client.params
     params[:reads].should eql 1
     params[:writes].should eql 1
     params[:durable_writes].should eql 3
-    params[:waits].should eql nil
+    params[:deletes].should eql nil
 
     bad_opts = lambda {@client.set_params(:junk => 'junk')}
     bad_opts.should raise_error(JiakClientException,/option/)
@@ -87,7 +120,7 @@ end
 
 describe "JiakClient URI handling" do
   before do
-    @base_uri = 'http://127.0.0.1:8002/jiak/'
+    @base_uri = SERVER_URI
     @client = JiakClient.new @base_uri
     @bucket = JiakBucket.new('uri_bucket',FooBarBaz)
     @key = 'uri_key'
@@ -96,7 +129,7 @@ end
 
 describe "JiakClient processing" do
   before do
-    @base_uri = 'http://127.0.0.1:8002/jiak/'
+    @base_uri = SERVER_URI
     @client = JiakClient.new @base_uri
   end
 
@@ -107,7 +140,24 @@ describe "JiakClient processing" do
       @client.set_schema(@bucket)
     end
 
-    it "should create and fetch a bucket schema" do
+    it "should fetch schema by bucket or bucket name" do
+      @client.schema(@bucket).should eql FooBarBaz.schema
+      @client.schema(@bucket.name).should eql FooBarBaz.schema
+    end
+
+    it "should fetch default schema" do
+      bucket_name = "wide open"
+      bucket = JiakBucket.new(bucket_name,FooBarBaz)
+      @client.schema(bucket).should eql JiakSchema::WIDE_OPEN
+    end
+
+    it "should set and fetch a wide open schema" do
+      @client.schema(@bucket).should_not eql JiakSchema::WIDE_OPEN
+      @client.set_schema(@bucket.name,JiakSchema::WIDE_OPEN)
+      @client.schema(@bucket).should eql JiakSchema::WIDE_OPEN
+    end
+
+    it "should set and fetch a bucket schema" do
       schema = @client.schema(@bucket)
       
       ['allowed_fields',
@@ -129,7 +179,6 @@ describe "JiakClient processing" do
       resp_schema.required_fields.should be_empty
       resp_schema.read_mask.should include :baz
       resp_schema.write_mask.should include :baz
-
     end
 
     it "should get a list of keys for a bucket" do
@@ -159,7 +208,11 @@ describe "JiakClient processing" do
     before do
       @bucket = JiakBucket.new('bucket_2',FooBarBaz)
       @client.set_schema(@bucket)
-      @data = FooBarBaz.new(:foo => 'foo val')
+      @data = FooBarBaz.new(:foo => 'Foo',:bar => 'Bar')
+    end
+
+    after do
+      @client.keys(@bucket).each {|key| @client.delete(@bucket,key)}
     end
 
     describe "storage" do
@@ -205,10 +258,17 @@ describe "JiakClient processing" do
     end
 
     describe "fetching" do
+      it "should check for resource existence" do
+        jobj = JiakObject.new(:bucket => @bucket, :data => @data)
+        key = @client.store(jobj)
+        
+        @client.exist?(@bucket,key).should be true
+        @client.exist?(@bucket,'nope').should be false
+      end
+
       it "should get a previously stored JiakObject" do
-        key = 'fetch_key_1'
-        jobj = JiakObject.new(:bucket => @bucket, :key => key, :data => @data)
-        @client.store(jobj)
+        jobj = JiakObject.new(:bucket => @bucket, :data => @data)
+        key = @client.store(jobj)
 
         fetched = @client.get(@bucket,key)
         fetched.should be_a JiakObject
@@ -222,6 +282,16 @@ describe "JiakClient processing" do
         fetched.should be_a JiakObject
       end
 
+      it "should accept write and read parameters" do
+        key = 'fetch_key_wr'
+        jobj = JiakObject.new(:bucket => @bucket, :key => key, :data => @data)
+        jobj = @client.store(jobj, 
+                             :writes => 3, :reads => 3,
+                             :return => :object)
+
+        jobj = @client.get(@bucket, key, :reads => 1)
+      end
+
       it "should raise JiakResourceNotFound for a non-existent key" do
         get_nope = lambda {@client.get(@bucket,'nope')}
         get_nope.should raise_error(JiakResourceNotFound)
@@ -275,7 +345,7 @@ end
 
 describe "JiakClient links" do
   before do
-    @base_uri = 'http://127.0.0.1:8002/jiak/'
+    @base_uri = SERVER_URI
     @client = JiakClient.new @base_uri
 
     @p_bucket = JiakBucket.new('parent',PersonData)

data/spec/core/jiak_schema_spec.rb

@@ -28,6 +28,14 @@ describe "JiakSchema" do
     @jiak_schema.should respond_to(:==,:eql?)
   end
 
+  it "should protect constants" do
+    no_no = lambda {JiakSchema::WIDE_OPEN.allow :x}
+    no_no.should raise_error(StandardError,/frozen/)
+
+    no_no = lambda {JiakSchema::WILDCARD << 'a'}
+    no_no.should raise_error(StandardError,/frozen/)
+  end
+
   it "should create using defaults from allowed_fields" do
     jiak_schema = JiakSchema.new({:allowed_fields => @allowed_fields})
     jiak_schema.allowed_fields.should eql @allowed_fields
@@ -136,6 +144,7 @@ describe "JiakSchema" do
   it "should ignore duplicate fields" do
     hash = @hash.clone
     hash[:allowed_fields] << @allowed_fields[0].to_s
+
     jiak_schema = JiakSchema.new(hash)
     jiak_schema.should eql @jiak_schema
 
@@ -144,15 +153,55 @@ describe "JiakSchema" do
 
     hash[:read_mask] << @read_mask[0]
     jiak_schema.read_mask = hash[:read_mask]
-    jiak_schema.read_mask.should eql @hash[:read_mask]
+    jiak_schema.read_mask.should eql @jiak_schema.read_mask
 
     hash[:write_mask] << @write_mask[0]
     jiak_schema.write_mask = hash[:write_mask]
-    jiak_schema.write_mask.should eql @hash[:write_mask]
+    jiak_schema.write_mask.should eql @jiak_schema.write_mask
 
     jiak_schema.readwrite = hash[:read_mask]
-    jiak_schema.read_mask.should eql @hash[:read_mask]
-    jiak_schema.write_mask.should eql @hash[:read_mask]
+    jiak_schema.read_mask.should eql @jiak_schema.read_mask
+    jiak_schema.write_mask.should eql @jiak_schema.read_mask
+  end
+
+  it "should be independent of init arg" do
+    @jiak_schema.allowed_fields.should eql @hash[:allowed_fields]
+    @hash[:allowed_fields] << :junk
+    @jiak_schema.allowed_fields.should_not eql @hash[:allowed_fields]
+
+    @jiak_schema.required_fields.should eql @hash[:required_fields]
+    @hash[:required_fields] << :junk
+    @jiak_schema.required_fields.should_not eql @hash[:required_fields]
+
+    @jiak_schema.read_mask.should eql @hash[:read_mask]
+    @hash[:read_mask] << :junk
+    @jiak_schema.read_mask.should_not eql @hash[:read_mask]
+
+    @jiak_schema.write_mask.should eql @hash[:write_mask]
+    @hash[:write_mask] << :junk
+    @jiak_schema.write_mask.should_not eql @hash[:write_mask]
+
+    arr = [:a,:b]
+    jiak_schema = JiakSchema.new(arr)
+    jiak_schema.allowed_fields.should eql arr
+    arr << :c
+    jiak_schema.allowed_fields.should_not eql arr
+  end
+
+  it "should init with wildcards" do
+    jiak_schema = JiakSchema.new(JiakSchema::WILDCARD)
+    jiak_schema.allowed_fields.should eql JiakSchema::WILDCARD
+    jiak_schema.required_fields.should be_empty
+    jiak_schema.read_mask.should eql JiakSchema::WILDCARD
+    jiak_schema.write_mask.should eql JiakSchema::WILDCARD
+  end
+
+  it "should init a wide open schema" do
+    jiak_schema = JiakSchema::WIDE_OPEN
+    jiak_schema.allowed_fields.should eql JiakSchema::WILDCARD
+    jiak_schema.required_fields.should be_empty
+    jiak_schema.read_mask.should eql JiakSchema::WILDCARD
+    jiak_schema.write_mask.should eql JiakSchema::WILDCARD
   end
 
   it "should update individual arrays" do
@@ -194,6 +243,59 @@ describe "JiakSchema" do
     jiak_schema.write_mask.should eql arr123
   end
 
+  it "should update wild card arrays" do
+    array = [:f1]
+    jiak_schema = JiakSchema.new(JiakSchema::WILDCARD)
+    jiak_schema.allow :f1
+    jiak_schema.allowed_fields.should eql array
+    jiak_schema.required_fields.should be_empty
+    jiak_schema.read_mask.should eql JiakSchema::WILDCARD
+    jiak_schema.write_mask.should eql JiakSchema::WILDCARD
+
+    array << :f2
+    jiak_schema = JiakSchema.new(JiakSchema::WILDCARD)
+    jiak_schema.readable array
+    jiak_schema.allowed_fields.should eql array
+    jiak_schema.required_fields.should be_empty
+    jiak_schema.read_mask.should eql array
+    jiak_schema.write_mask.should eql JiakSchema::WILDCARD
+
+    array << :f3
+    jiak_schema = JiakSchema.new(JiakSchema::WILDCARD)
+    jiak_schema.writable array
+    jiak_schema.allowed_fields.should eql array
+    jiak_schema.required_fields.should be_empty
+    jiak_schema.read_mask.should eql JiakSchema::WILDCARD
+    jiak_schema.write_mask.should eql array
+
+    array << :f4
+    jiak_schema = JiakSchema.new(JiakSchema::WILDCARD)
+    jiak_schema.readwrite array
+    jiak_schema.allowed_fields.should eql array
+    jiak_schema.required_fields.should be_empty
+    jiak_schema.read_mask.should eql array
+    jiak_schema.write_mask.should eql array
+  end
+
+  it "should set wild card arrays" do
+    @jiak_schema.allowed_fields = JiakSchema::WILDCARD
+    @jiak_schema.allowed_fields.should eql JiakSchema::WILDCARD
+    @jiak_schema.read_mask.should eql @read_mask
+    @jiak_schema.write_mask.should eql @write_mask
+
+    @jiak_schema.read_mask = JiakSchema::WILDCARD
+    @jiak_schema.allowed_fields.should eql JiakSchema::WILDCARD
+    @jiak_schema.read_mask.should eql JiakSchema::WILDCARD
+    @jiak_schema.write_mask.should eql @write_mask
+
+    @jiak_schema.write_mask = JiakSchema::WILDCARD
+    @jiak_schema.allowed_fields.should eql JiakSchema::WILDCARD
+    @jiak_schema.read_mask.should eql JiakSchema::WILDCARD
+    @jiak_schema.write_mask.should eql JiakSchema::WILDCARD
+
+    @jiak_schema.required_fields.should eql @required_fields
+  end
+
   it "should return added fields when updating individual arrays" do
     arr12 = [:f1,:f2]
     arr23 = [:f2,:f3]
@@ -262,7 +364,7 @@ describe "JiakSchema" do
   end
 
   it "should convert to json" do
-    @jiak_schema.to_jiak.should eql ({:schema => @hash})
+    @jiak_schema.to_jiak.should eql({:schema => @hash})
   end
 
   it "should equal an equal JiakSchema" do

data/spec/resource/jiak_resource_spec.rb

@@ -3,29 +3,28 @@ require File.dirname(__FILE__) + '/../spec_helper.rb'
 describe "JiakResource default" do
   class Rsrc           # :nodoc:
     include JiakResource
-    server        'http://localhost:8002/jiak/'
+    server        SERVER_URI
     jattr_accessor :f1, :f2
   end
 
   before do
-    @server = 'http://localhost:8002/jiak/'
+    @server_uri = SERVER_URI
     @group = 'rsrc'
     @schema = JiakSchema.new [:f1,:f2]
-    Rsrc.pov
   end
 
   describe "class creation" do
     it "should respond to" do
       Rsrc.should respond_to(:server,:group)
       Rsrc.should respond_to(:jattr_reader,:jattr,:jattr_writer,:jattr_accessor)
-      Rsrc.should respond_to(:params,:auto_update,:schema,:keys)
-      Rsrc.should respond_to(:point_of_view,:pov,:point_of_view?,:pov?)
+      Rsrc.should respond_to(:params,:auto_update,:keys)
+      Rsrc.should respond_to(:schema,:push_schema,:server_schema?)
       Rsrc.should respond_to(:post,:put,:get,:delete)
       Rsrc.should respond_to(:refresh,:update,:exist?)
       Rsrc.should respond_to(:link,:bi_link,:query,:walk)
       Rsrc.should respond_to(:auto_post,:auto_update,:auto_manage)
       Rsrc.should respond_to(:auto_post,:auto_update,:auto_manage?)
-      Rsrc.jiak.should respond_to(:server,:uri,:group,:data,:bucket)
+      Rsrc.jiak.should respond_to(:client,:uri,:group,:data,:bucket)
     end
     
     it "should have specified settings" do
@@ -34,8 +33,8 @@ describe "JiakResource default" do
       Rsrc.schema.should eql @schema
       
       Rsrc.jiak.should be_a Struct
-      Rsrc.jiak.server.should be_a JiakClient
-      Rsrc.jiak.uri.should eql @server
+      Rsrc.jiak.client.should be_a JiakClient
+      Rsrc.jiak.uri.should eql @server_uri
       Rsrc.jiak.group.should eql @group
       Rsrc.jiak.data.should include JiakData
       Rsrc.jiak.bucket.should be_a JiakBucket
@@ -51,7 +50,7 @@ describe "JiakResource default" do
     end
 
     it "should respond to" do
-      @rsrc.should respond_to(:jiak,:jiak=)
+      @rsrc.should respond_to(:jiak)
       @rsrc.should respond_to(:auto_update=,:auto_update?)
       @rsrc.should respond_to(:post,:put,:delete)
       @rsrc.should respond_to(:update,:push,:refresh,:pull)
@@ -82,14 +81,37 @@ describe "JiakResource default" do
   end
 end
 
+describe "JiakResource schema" do
+  class People           # :nodoc:
+    include JiakResource
+    server         SERVER_URI
+    group          'schema'
+    jattr_accessor  :name, :age
+    keygen { name }
+  end
+
+  it "should have data schema" do
+    jiak_schema = JiakSchema.new([:name,:age])
+    People.schema.should eql jiak_schema
+  end
+
+  it "should push/check server schema" do
+    People.server_schema?.should be false
+    People.push_schema
+    People.server_schema?.should be true
+
+    People.push_schema(JiakSchema::WIDE_OPEN)
+    People.server_schema?.should be false
+  end
+end
+
 describe "JiakResource default class-level auto-post/auto-update" do
   class People           # :nodoc:
     include JiakResource
-    server         'http://localhost:8002/jiak'
+    server         SERVER_URI
     group          'people'
     jattr_accessor  :name, :age
     keygen { name }
-    point_of_view
   end
 
   before do
@@ -135,11 +157,10 @@ end
 describe "JiakResource class auto-post" do
   class People           # :nodoc:
     include JiakResource
-    server         'http://localhost:8002/jiak'
+    server         SERVER_URI
     group          'people'
     jattr_accessor  :name, :age
     keygen { name }
-    point_of_view
   end
 
   before do
@@ -214,11 +235,10 @@ end
 describe "JiakResource class auto-update" do
   class Dogs           # :nodoc:
     include JiakResource
-    server         'http://localhost:8002/jiak'
+    server         SERVER_URI
     group          'dogs'
     jattr_accessor  :name, :age
     keygen { name }
-    point_of_view
     auto_manage
   end
 
@@ -309,11 +329,10 @@ end
 describe "JiakResource simple" do
   class Dogs           # :nodoc:
     include JiakResource
-    server         'http://localhost:8002/jiak'
+    server         SERVER_URI
     group          'dogs'
     jattr_accessor  :name, :age
     keygen { name }
-    point_of_view
     auto_manage
   end
 
@@ -370,10 +389,9 @@ end
 describe "JiakResource complex" do
   class Parents           # :nodoc:
     include JiakResource
-    server        'http://localhost:8002/jiak'
+    server        SERVER_URI
     jattr_accessor :name
     keygen { name }
-    point_of_view
   end
 
   Children = Parents.dup

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 begin
   require 'spec'
+  require 'json'
 rescue LoadError
   require 'rubygems' unless ENV['NO_RUBYGEMS']
   gem 'rspec'
@@ -10,3 +11,5 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 
 require 'riakrest'
 include RiakRest
+
+SERVER_URI = 'http://localhost:8002/jiak'  unless(defined?(SERVER_URI))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: riakrest
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors: 
 - Paul Rogers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-17 00:00:00 -08:00
+date: 2009-11-29 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,6 +22,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.0.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.9
+    version: 
 - !ruby/object:Gem::Dependency 
   name: rest-client
   type: :development
@@ -32,6 +42,26 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.0.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+    version: 
 - !ruby/object:Gem::Dependency 
   name: rspec
   type: :development
@@ -43,7 +73,7 @@ dependencies:
         version: 1.2.9
     version: 
 description: "    RiakRest provides structured, RESTful interaction with\n    the HTTP/JSON interface of a Riak[http://riak.basho.com] document data\n    store. RiakRest provides two levels of interaction: Core Client and\n    Resource. Core Client works at the Jiak level and exposes Jiak\n    internals. JiakResource is an abstraction built on top of the Core Client\n    that gives a true RESTful feel.\n"
-email: paul@dingosky.com
+email: riak@dingosky.com
 executables: []
 
 extensions: []
@@ -62,10 +92,8 @@ files:
 - examples/auto_update_links.rb
 - examples/basic_client.rb
 - examples/basic_resource.rb
+- examples/example_helper.rb
 - examples/linked_resources.rb
-- examples/links_only_pov.rb
-- examples/multiple_pov.rb
-- examples/ruby_json_data.rb
 - lib/riakrest.rb
 - lib/riakrest/core/exceptions.rb
 - lib/riakrest/core/jiak_bucket.rb
@@ -131,9 +159,5 @@ test_files:
 - examples/auto_update_links.rb
 - examples/basic_client.rb
 - examples/basic_resource.rb
-- examples/bucket_schemas.rb
+- examples/example_helper.rb
 - examples/linked_resources.rb
-- examples/links_only_pov.rb
-- examples/multiple_pov.rb
-- examples/rest_interaction.rb
-- examples/ruby_json_data.rb

data/examples/bucket_schemas.rb

@@ -1,38 +0,0 @@
-require 'riakrest'
-include RiakRest
-
-DogData = JiakDataFields.create(:name,:age,:breeds)
-DogData.keygen { name.downcase }
-
-# client = JiakClient.new("http://localhost:8002/jiak")
-client = JiakClient.new("http://localhost:8002/jiak",
-                        :proxy=>"http://localhost:8888")
-bucket = JiakBucket.new("dogs", DogData)
-chili = JiakObject.new(:bucket => bucket,
-                       :data => DogData.new(:name => "Chili",
-                                            :age => 6,
-                                            :breeds => ["heeler","akita"]))
-client.set_schema(bucket)
-client.store(chili)
-chili = client.get(bucket,'chili')
-
-DogBreedsData = JiakDataFields.create(:name,:breeds)
-bucket.data_class = DogBreedsData
-client.set_schema(bucket)
-chili = client.get(bucket,'chili')
-chili.data.breeds = ["heeler","mutt"]
-
-
-DogAgeData = JiakDataFields.create(:name,:age)
-diego = JiakObject.new(:bucket => bucket,
-                       :data => DogAgeData.new(:name => "Diego",
-                                            :age => 7))
-client.store(diego)
-
-addie = JiakObject.new(:bucket => bucket,
-                       :data => DogData.new(:name => "Adelaide",
-                                            :age => 14,
-                                            :breeds => ["heeler"]))
-client.store(addie)
-
-addie = client.get(bucket,'addie')

data/examples/links_only_pov.rb

@@ -1,38 +0,0 @@
-require 'riakrest'
-include RiakRest
-
-# class with 10 fields
-class Fields
-  include JiakResource
-  server         'http://localhost:8002/jiak'
-  jattr_accessor (0...10).map {|n| "f#{n}".to_sym}
-  auto_manage
-end
-
-class Links
-  include JiakResource
-  server       'http://localhost:8002/jiak'
-  auto_manage
-end
-
-# populate two Fields objects with (meaningless) stuff
-Fields.pov
-fields = ["fields1","fields2"]
-fields1,fields2 =
-  fields.map {|o| Fields.new(Fields.schema.write_mask.inject({}) do |h,f|
-                               h[f]="#{o.upcase}-#{f.hash}"
-                               h
-                             end)}
-
-Links.pov
-links1 = Links.get(fields1.jiak.key)
-links1.link(fields2,'link')
-
-Fields.pov
-fields2.f1 = "new f1"
-
-linked = fields1.query(Fields,'link')[0]
-puts linked.f1 == fields2.f1                        # => true
-
-fields1.delete
-fields2.delete