riakrest 0.0.4 → 0.1.0

data/spec/core/jiak_client_spec.rb

@@ -3,51 +3,35 @@ require File.dirname(__FILE__) + '/../spec_helper.rb'
 class FooBarBaz  # :nodoc:
   include JiakData
 
-  allowed  :foo, :bar, :baz
-  required :foo
-  readable :foo, :bar
-  writable :foo, :bar
-
-  def initialize(hsh)
-    hsh.each {|key,val| send("#{key}=",val)}
-  end
-
-  def self.jiak_create(jiak)
-    new(jiak)
-  end
-
-  def for_jiak
-    { :foo => @foo,
-      :bar => @bar
-    }.reject {|k,v| v.nil?}
-  end
-
-  def eql?(other)
-    other.is_a?(FooBarBaz) && other.foo.eql?(@foo) && other.bar.eql?(@bar)
-  end
+  jattr_accessor :foo, :bar
+  require :foo
+  allow   :baz
 end
 
 describe "JiakClient" do
   before do
     @base_uri = 'http://127.0.0.1:8002/jiak/'
-    @client = JiakClient.new @base_uri
+    @client = JiakClient.new(@base_uri)
+    @params = {:reads => 1, :writes => 2, :durable_writes => 3, :waits => 4}
+    @opts = @params.merge({:proxy => 'proxy_uri'})
   end
 
   it "should respond to" do
-    @client.should respond_to(:set_schema, :schema, :keys)
-    @client.should respond_to(:uri)
+    @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(:==,:eql?)
-    @client.should respond_to(:get, :store, :delete, :walk)
   end
 
   it "should default to base URI" do
-    @client.uri.should match @base_uri
+    @client.server.should match @base_uri
   end
 
   it "should allow specified base URI" do
     base_uri = 'http://localhost:1234/tmp/'
     client = JiakClient.new base_uri
-    client.uri.should match base_uri
+    client.server.should match base_uri
   end
 
   it "should equal another JiakClient with the same URI" do
@@ -56,6 +40,49 @@ describe "JiakClient" do
     client.should ==  @client
   end
 
+  it "should initialize proxy and params" do
+    client = JiakClient.new(@base_uri,:proxy => 'proxy_uri',:reads => 1)
+    client.proxy.should eql 'proxy_uri'
+    client.params[:reads].should == 1
+
+    client = JiakClient.new(@base_uri,@opts)
+    client.proxy.should eql 'proxy_uri'
+    client.params.should have_exactly(4).items
+    @params.each {|k,v| client.params[k].should == @params[k]}
+    
+    @opts.delete(:proxy)
+    @opts.delete(:writes)
+    client = JiakClient.new(@base_uri,@opts)
+    client.params.should have_exactly(3).items
+    client.proxy.should be nil
+    client.params[:writes].should be nil
+
+    @opts[:junk] = 'junk'
+    bad_opts = lambda {JiakClient.new(@base_uri,@opts)}
+    bad_opts.should raise_error(JiakClientException,/option/)
+  end
+
+  it "should update proxy and params" do
+    @client.proxy = 'another_proxy'
+    @client.proxy.should eql 'another_proxy'
+
+    @client.params = @params
+    @params.each {|k,v| @client.params[k].should == @params[k]}
+
+    @client.set_params(:writes => 1, :waits => 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
+
+    bad_opts = lambda {@client.set_params(:junk => 'junk')}
+    bad_opts.should raise_error(JiakClientException,/option/)
+    
+    @params[:junk] = 'junk'
+    bad_opts = lambda {@client.params = @params}
+    bad_opts.should raise_error(JiakClientException,/option/)
+  end
 end
 
 describe "JiakClient URI handling" do
@@ -94,14 +121,14 @@ describe "JiakClient processing" do
     end
 
     it "should update an existing bucket schema" do
-      FooBarBazBuz = JiakDataHash.create(:foo,:bar,:baz,:buz)
+      FooBarBazBuz = JiakDataFields.create(:foo,:bar,:baz,:buz)
       @client.set_schema(JiakBucket.new(@bucket_name,FooBarBazBuz))
       
       resp_schema = @client.schema(@bucket)
-      resp_schema.allowed_fields.should include 'buz'
+      resp_schema.allowed_fields.should include :buz
       resp_schema.required_fields.should be_empty
-      resp_schema.read_mask.should include 'baz'
-      resp_schema.write_mask.should include 'baz'
+      resp_schema.read_mask.should include :baz
+      resp_schema.write_mask.should include :baz
 
     end
 
@@ -241,16 +268,18 @@ describe "JiakClient processing" do
 
 end
 
-Parent = JiakDataHash.create(:name)
-Child = JiakDataHash.create(:name)
+class PersonData
+  include JiakData
+  jattr_accessor :name
+end
 
 describe "JiakClient links" do
   before do
     @base_uri = 'http://127.0.0.1:8002/jiak/'
     @client = JiakClient.new @base_uri
 
-    @p_bucket = JiakBucket.new('parent',Parent)
-    @c_bucket = JiakBucket.new('child',Child)
+    @p_bucket = JiakBucket.new('parent',PersonData)
+    @c_bucket = JiakBucket.new('child',PersonData)
     @client.set_schema(@p_bucket)
     @client.set_schema(@c_bucket)
   end
@@ -276,7 +305,7 @@ describe "JiakClient links" do
     #  - create p and c (when necessary)
     #  - add links for p -> c and c -> p
     parent_children.each do |p_name,c_names|
-      p_data = Parent.new(:name => p_name)
+      p_data = PersonData.new(:name => p_name)
       p_obj = JiakObject.new(:bucket => @p_bucket,
                              :key => p_name,
                              :data => p_data)
@@ -286,7 +315,7 @@ describe "JiakClient links" do
         begin
           child = @client.get(@c_bucket,c_name)
         rescue JiakResourceNotFound
-          c_data = Child.new(:name => c_name)
+          c_data = PersonData.new(:name => c_name)
           c_obj = JiakObject.new(:bucket => @c_bucket,
                                  :key => c_name,
                                  :data => c_data)
@@ -330,7 +359,7 @@ describe "JiakClient links" do
     # p's should include links to their c's
     c_link = QueryLink.new(@c_bucket,'child',nil)
     parent_children.each do |p_name,children|
-      @client.walk(@p_bucket,p_name,c_link,Child).each do |c_obj|
+      @client.walk(@p_bucket,p_name,c_link,PersonData).each do |c_obj|
         children.should include c_obj.data.name
       end
     end
@@ -338,14 +367,14 @@ describe "JiakClient links" do
     # c's should include links to their p's
     p_link = QueryLink.new(@p_bucket,'parent',nil)
     child_parents.each do |c_name,parents|
-      @client.walk(@c_bucket,c_name,p_link,Parent).each do |p_obj|
+      @client.walk(@c_bucket,c_name,p_link,PersonData).each do |p_obj|
         parents.should include p_obj.data.name
       end
     end
 
     # c siblings requires a second step
     c1s,c2s,c3s,c4s,c5s,c6s,c7s = child_parents.keys.map do |c|
-      siblings = @client.walk(@c_bucket,c,[p_link,c_link],Child)
+      siblings = @client.walk(@c_bucket,c,[p_link,c_link],PersonData)
       me = @client.get(@c_bucket,c)
       siblings.reject! {|s| s.eql?(me)}
       siblings

data/spec/core/jiak_link_spec.rb

@@ -12,7 +12,7 @@ describe "JiakLink" do
     @jiak_link.should respond_to(:bucket,:key,:tag)
     @jiak_link.should respond_to(:bucket=,:key=,:tag=)
 
-    @jiak_link.should respond_to(:for_jiak)
+    @jiak_link.should respond_to(:to_jiak)
 
     @jiak_link.should respond_to(:eql?,:==)
   end
@@ -60,7 +60,7 @@ describe "JiakLink" do
   end
 
   it "should convert for Jiak" do
-    @jiak_link.for_jiak.should eql [@bucket,@key,@tag]
+    @jiak_link.to_jiak.should eql [@bucket,@key,@tag]
   end
   
   it "should compare to another JiakLink via eql?" do

data/spec/core/jiak_object_spec.rb

@@ -1,20 +1,20 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 
-DataObject = JiakDataHash.create(:f1,:f2,:f3)
+UserData = JiakDataFields.create :f1, :f2, :f3
 
 describe "JiakObject" do
   before do
     @data = 
-      DataObject.new(:f1 => 'f1',:f2 => ['a','b'], :f3 => {:f3_1 => 'f3_1'})
+      UserData.new(:f1 => 'f1',:f2 => ['a','b'], :f3 => {:f3_1 => 'f3_1'})
     @bucket_name = 'bucket'
-    @bucket = JiakBucket.new(@bucket_name,DataObject)
+    @bucket = JiakBucket.new(@bucket_name,UserData)
     @key = 'hey'
     @l1 = JiakLink.new('l1b','l1k','l1t')
     @l2 = JiakLink.new('l2b','l2k','l2t')
     @links = [@l1,@l2]
 
-    object = @data.for_jiak
-    links = @links.map {|link| link.for_jiak}
+    object = @data.to_jiak
+    links = @links.map {|link| link.to_jiak}
 
     core = {
       :bucket => @bucket_name, :key => @key,
@@ -30,7 +30,7 @@ describe "JiakObject" do
   end
 
   it "should respond to" do
-    JiakObject.should respond_to(:new,:from_jiak)
+    JiakObject.should respond_to(:new,:jiak_create)
 
     @object.should respond_to(:bucket,:bucket=)
     @object.should respond_to(:key,:key=)
@@ -73,7 +73,7 @@ describe "JiakObject" do
   it "should initialize from JSON" do
     [@core_json,@full_json].each do |json|
       jiak = JSON.parse(json)
-      jobj = JiakObject.from_jiak(jiak,@bucket.data_class)
+      jobj = JiakObject.jiak_create(jiak,@bucket.data_class)
       jobj.bucket.should eql @object.bucket
       jobj.key.should eql @object.key
       jobj.data.f1.should eql @data.f1
@@ -88,7 +88,7 @@ describe "JiakObject" do
     end
 
     jiak = JSON.parse(@full_json)
-    jobj = JiakObject.from_jiak(jiak,@bucket.data_class)
+    jobj = JiakObject.jiak_create(jiak,@bucket.data_class)
     jobj.riak[:vclock].should eql 'vclock'
     jobj.riak[:vtag].should eql 'vtag'
     jobj.riak[:lastmod].should eql 'last mod'
@@ -124,7 +124,7 @@ describe "JiakObject" do
   end
   
   it "should convert to JSON" do
-    json = @object.to_jiak
+    json = @object.to_jiak.to_json
     json.should eql @core_json
 
     parsed = JSON.parse(json)
@@ -134,13 +134,13 @@ describe "JiakObject" do
     parsed['object']['f2'].should eql @data.f2
     parsed['object']['f3']['f3_1'].should eql @data.f3[:f3_1]
     @links.each_with_index do |link,ndx|
-      parsed['links'][ndx].should eql link.for_jiak
+      parsed['links'][ndx].should eql link.to_jiak
     end
   end
 
   it "should allow attribute updates" do
     bucket_name = 'new bucket'
-    bucket = JiakBucket.new(bucket_name,DataObject)
+    bucket = JiakBucket.new(bucket_name,UserData)
     @object.bucket = bucket
     @object.bucket.should eql bucket
 
@@ -148,7 +148,7 @@ describe "JiakObject" do
     @object.key = key
     @object.key.should eql key
 
-    object = DataObject.new(:f1 => 'new f1',:f2 => [], :f3 => 6)
+    object = UserData.new(:f1 => 'new f1',:f2 => [], :f3 => 6)
     @object.data.should_not eql object
     @object.data = object
     @object.data.should eql object

data/spec/core/jiak_schema_spec.rb

@@ -16,12 +16,13 @@ describe "JiakSchema" do
   end
 
   it "should respond to" do
-    JiakSchema.should respond_to(:from_jiak)
+    JiakSchema.should respond_to(:jiak_create)
 
     @jiak_schema.should respond_to(:allowed_fields,:allowed_fields=)
     @jiak_schema.should respond_to(:required_fields,:required_fields=)
     @jiak_schema.should respond_to(:read_mask,:read_mask=)
     @jiak_schema.should respond_to(:write_mask,:write_mask=)
+    @jiak_schema.should respond_to(:allow,:require,:readable,:writable)
 
     @jiak_schema.should respond_to(:to_jiak)
     @jiak_schema.should respond_to(:==,:eql?)
@@ -83,8 +84,17 @@ describe "JiakSchema" do
     jiak_schema.write_mask.should eql @write_mask
   end
 
+  it "should create an empty schema" do
+    [JiakSchema.new, JiakSchema.new {}].each do |schema|
+      schema.allowed_fields.should be_empty
+      schema.required_fields.should be_empty
+      schema.read_mask.should be_empty
+      schema.write_mask.should be_empty
+    end
+  end
+
   it "should create from json" do
-    schema = JiakSchema.from_jiak(JSON.parse(@hash.to_json))
+    schema = JiakSchema.jiak_create(JSON.parse(@hash.to_json))
     @allowed_fields.same_fields?(schema.allowed_fields).should be true
     @required_fields.same_fields?(schema.required_fields).should be true
     @write_mask.same_fields?(schema.write_mask).should be true
@@ -121,27 +131,96 @@ describe "JiakSchema" do
     bad = lambda {JiakSchema.new(hash)}
     bad.should raise_error(JiakSchemaException,/write_mask.*strings/)
 
+  end
+  
+  it "should ignore duplicate fields" do
     hash = @hash.clone
     hash[:allowed_fields] << @allowed_fields[0].to_s
-    bad = lambda {JiakSchema.new(hash)}
-    bad.should raise_error(JiakSchemaException,/unique/)
+    jiak_schema = JiakSchema.new(hash)
+    jiak_schema.should eql @jiak_schema
 
-    hash = @hash.clone
-    hash[:allowed_fields] << @allowed_fields[0].to_sym
-    bad = lambda {JiakSchema.new(hash)}
-    bad.should raise_error(JiakSchemaException,/unique/)
+    jiak_schema.allowed_fields = hash[:allowed_fields]
+    jiak_schema.allowed_fields.should eql @jiak_schema.allowed_fields
+
+    hash[:read_mask] << @read_mask[0]
+    jiak_schema.read_mask = hash[:read_mask]
+    jiak_schema.read_mask.should eql @hash[: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.readwrite = hash[:read_mask]
+    jiak_schema.read_mask.should eql @hash[:read_mask]
+    jiak_schema.write_mask.should eql @hash[:read_mask]
+  end
+
+  it "should update individual arrays" do
+    arr1    = [:f1]
+    arr12   = [:f1,:f2]
+    arr13   = [:f1,:f3]
+    arr14   = [:f1,:f4]
+    arr123  = [:f1,:f2,:f3]
+    arr1234 = [:f1,:f2,:f3,:f4]
+
+    jiak_schema = JiakSchema.new(arr1)
+    jiak_schema.allow :f2
+    jiak_schema.allowed_fields.should eql arr12
+    jiak_schema.read_mask.should eql arr1
+    jiak_schema.write_mask.should eql arr1
+    jiak_schema.required_fields.should be_empty
+    jiak_schema.readable :f3
+    jiak_schema.read_mask.should eql arr13
+    jiak_schema.write_mask.should eql arr1
+    jiak_schema.allowed_fields.should eql arr123
+    jiak_schema.required_fields.should be_empty
+    jiak_schema.writable :f4
+    jiak_schema.write_mask.should eql arr14
+    jiak_schema.read_mask.should eql arr13
+    jiak_schema.allowed_fields.should eql arr1234
+    jiak_schema.required_fields.should be_empty
+
+    jiak_schema = JiakSchema.new(arr1)
+    jiak_schema.readwrite :f2
+    jiak_schema.read_mask.should eql arr12
+    jiak_schema.write_mask.should eql arr12
+    jiak_schema.allowed_fields.should eql arr12
+    jiak_schema.required_fields.should be_empty
+
+    jiak_schema.require :f3
+    jiak_schema.required_fields.should eql [:f3]
+    jiak_schema.allowed_fields.should eql arr123
+    jiak_schema.read_mask.should eql arr123
+    jiak_schema.write_mask.should eql arr123
   end
 
-  it "should update with validation" do
+  it "should return added fields when updating individual arrays" do
+    arr12 = [:f1,:f2]
+    arr23 = [:f2,:f3]
+    jiak_schema = JiakSchema.new
+    added = jiak_schema.allow arr12
+    added.should eql arr12
+    added = jiak_schema.allow arr23
+    added.should eql [:f3]
+
+    # other add methods call same internal method. previous test checks this is
+    # true so don't need more tests here
+  end
+
+  it "should set arrays with validation" do
     arr = [:f1,'f2']
     @jiak_schema.allowed_fields = arr
-    @jiak_schema.allowed_fields.should eql arr
+    @jiak_schema.allowed_fields.should_not eql arr
+    @jiak_schema.allowed_fields.same_fields?(arr).should eql true
     @jiak_schema.required_fields = arr
-    @jiak_schema.required_fields.should eql arr
+    @jiak_schema.required_fields.should_not eql arr
+    @jiak_schema.required_fields.same_fields?(arr).should eql true
     @jiak_schema.read_mask = arr
-    @jiak_schema.read_mask.should eql arr
+    @jiak_schema.read_mask.should_not eql arr
+    @jiak_schema.read_mask.same_fields?(arr).should eql true
     @jiak_schema.write_mask = arr
-    @jiak_schema.write_mask.should eql arr
+    @jiak_schema.write_mask.should_not eql arr
+    @jiak_schema.write_mask.same_fields?(arr).should eql true
 
     bad = lambda {@jiak_schema.allowed_fields = nil}
     bad.should raise_error(JiakSchemaException,/allowed_fields.*array/)
@@ -151,14 +230,39 @@ describe "JiakSchema" do
 
     bad = lambda {@jiak_schema.read_mask = [:f,1]}
     bad.should raise_error(JiakSchemaException,/read_mask.*symbol/)
-    
-    arr << :f1
-    bad = lambda {@jiak_schema.write_mask = arr}
-    bad.should raise_error(JiakSchemaException,/unique/)
+  end
+
+  it "should ignore duplicates on setting of arrays" do
+    arr    = [:f1,:f2,:f1,:f3]
+    arr123 = [:f1,:f2,:f3]
+
+    @jiak_schema.allowed_fields = arr
+    @jiak_schema.allowed_fields.should eql arr123
+
+    @jiak_schema.required_fields = arr
+    @jiak_schema.required_fields.should eql arr123
+
+    @jiak_schema.read_mask = arr
+    @jiak_schema.read_mask.should eql arr123
+
+    @jiak_schema.write_mask = arr
+    @jiak_schema.write_mask.should eql arr123
+
+    @jiak_schema.allow :f1
+    @jiak_schema.allowed_fields.should eql arr123
+
+    @jiak_schema.readable :f2
+    @jiak_schema.read_mask.should eql arr123
+
+    @jiak_schema.writable :f3
+    @jiak_schema.read_mask.should eql arr123
+
+    @jiak_schema.require :f2
+    @jiak_schema.required_fields.should eql arr123
   end
 
   it "should convert to json" do
-    @jiak_schema.to_jiak.should eql ({:schema => @hash}.to_json)
+    @jiak_schema.to_jiak.should eql ({:schema => @hash})
   end
 
   it "should equal an equal JiakSchema" do