riak-client 2.5.0 → 2.6.0

data/spec/riak/beefcake_protobuffs_backend/ts_cell_codec_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-require 'bigdecimal'
-require 'time'
-
-Riak::Client::BeefcakeProtobuffsBackend.configured?
-
-describe Riak::Client::BeefcakeProtobuffsBackend::TsCellCodec do
-  describe 'symmetric serialization' do
-    it { is_expected.to symmetric_serialize("hello", varchar_value: "hello")}
-    it { is_expected.to symmetric_serialize(5, sint64_value: 5)}
-    it { is_expected.to symmetric_serialize(123.45, double_value: 123.45) }
-    it do
-      subject.convert_timestamp = true
-      is_expected.to symmetric_serialize(Time.parse("June 23, 2015 at 9:46:28 EDT"),
-                                         timestamp_value: 1_435_067_188_000)
-    end
-    # GH-274
-    it do
-      subject.convert_timestamp = true
-      ts = 1_459_444_070_103
-      t = Time.at(1_459_444_070, 103_000)
-      is_expected.to symmetric_serialize(t, timestamp_value: ts)
-    end
-    it { is_expected.to symmetric_serialize(true, boolean_value: true) }
-    it { is_expected.to symmetric_serialize(false, boolean_value: false) }
-    it { is_expected.to symmetric_serialize(nil, {}) }
-  end
-
-  describe 'serializing values' do
-    it do
-      is_expected.to serialize(BigDecimal.new("0.1"), double_value: 0.1)
-    end
-
-    it 'refuses to serialize big numbers' do
-      expect{ subject.cell_for 2**64 }.
-        to raise_error Riak::TimeSeriesError::SerializeBigIntegerError
-    end
-
-    it 'refuses to serialize complex numbers' do
-      expect{ subject.cell_for(Complex(1, 1)) }.
-        to raise_error Riak::TimeSeriesError::SerializeComplexNumberError
-    end
-
-    it 'refuses to serialize rational numbers' do
-      expect{ subject.cell_for(Rational(1, 1)) }.
-        to raise_error Riak::TimeSeriesError::SerializeRationalNumberError
-    end
-  end
-
-  # deserialization is handled by the symmetric cases above
-  # describe 'deserializing values'
-
-  describe 'with a collection' do
-    let(:not_serialized){ ['hi', 5, 12.34] }
-    let(:serialized) do
-      [
-        Riak::Client::BeefcakeProtobuffsBackend::TsCell.new(varchar_value: 'hi'),
-        Riak::Client::BeefcakeProtobuffsBackend::TsCell.new(sint64_value: 5),
-        Riak::Client::BeefcakeProtobuffsBackend::TsCell.new(double_value: 12.34)
-      ]
-    end
-
-    it 'serializes' do
-      expect(subject.cells_for(not_serialized)).to eq serialized
-    end
-
-    it 'deserializes' do
-      expect(subject.scalars_for(serialized)).to eq not_serialized
-    end
-  end
-
-  RSpec::Matchers.define :symmetric_serialize do |scalar, cell_options|
-    match do |codec|
-      expect(codec).to(
-        serialize(scalar, cell_options)
-        .and(deserialize(scalar, cell_options)))
-    end
-
-    failure_message do |codec|
-      cell = Riak::Client::BeefcakeProtobuffsBackend::TsCell.new cell_options
-      deserialized = codec.scalar_for cell
-      "expected #{scalar} => #{cell_options} => #{scalar}, got #{scalar} => #{cell.to_hash} => #{deserialized}"
-    end
-
-    description do
-      "serialize #{scalar.class} #{scalar.inspect} to and from TsCell #{cell_options}"
-    end
-  end
-
-  RSpec::Matchers.define :serialize do |measure, options|
-    match do |actual|
-      serialized = actual.cell_for(measure)
-      serialized.to_hash == options
-    end
-
-    failure_message do |actual|
-      serialized = actual.cell_for(measure)
-      "expected #{options}, got #{serialized.to_hash}"
-    end
-
-    description do
-      "serialize #{measure.class} #{measure.inspect} to TsCell #{options}"
-    end
-  end
-
-  RSpec::Matchers.define :deserialize do |expected, options|
-
-    cell = Riak::Client::BeefcakeProtobuffsBackend::TsCell.new options
-
-    match do |codec|
-      deserialized = codec.scalar_for cell
-      deserialized == expected
-    end
-
-    failure_message do |codec|
-      deserialized = codec.scalar_for cell
-      "expected TsCell #{options.inspect} to deserialize to #{expected.class} #{expected.inspect}"
-    end
-
-    description do
-      "deserialize TsCell #{options} to #{expected.class} #{expected.inspect}"
-    end
-  end
-end

data/spec/riak/beefcake_protobuffs_backend_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Client::BeefcakeProtobuffsBackend do
-  before(:all) { expect(described_class).to be_configured }
-  let(:client) { Riak::Client.new }
-  let(:node) { client.nodes.first }
-  let(:backend) { Riak::Client::BeefcakeProtobuffsBackend.new(client, node) }
-  let(:protocol){ double 'protocol' }
-  before(:each) do
-    allow(backend).to receive(:get_server_version).and_return("2.0.0")
-    allow(backend).to receive(:protocol).and_yield(protocol)
-  end
-
-  context "secondary index" do
-    before :each do
-      @socket = double(:socket).as_null_object
-      allow(TCPSocket).to receive(:new).and_return(@socket)
-    end
-
-    it 'raises an appropriate error when 2i is not available' do
-      expect(protocol).to receive(:write)
-      expect(protocol).to receive(:expect).
-        and_raise(
-                  Riak::ProtobuffsErrorResponse.
-                  new(Riak::Client::BeefcakeProtobuffsBackend::
-                      RpbErrorResp.
-                      new(errmsg: '{error,{indexes_not_supported,riak_kv_bitcask_backend}}',
-                          errcode: 0)
-                      )
-                  )
-
-      expect{ backend.get_index 'bucket', 'words', 'asdf' }.to raise_error /Secondary indexes aren't supported/
-      # '
-    end
-
-    context 'when streaming' do
-      it "streams when a block is given" do
-        expect(protocol).to receive(:write) do |msg, req|
-          expect(msg).to eq(:IndexReq)
-          expect(req[:stream]).to eq(true)
-        end
-        expect(protocol).to receive(:expect).
-          and_return(Riak::Client::BeefcakeProtobuffsBackend::RpbIndexResp.new keys: %w{'asdf'}, done: true)
-
-        blk = proc{:asdf}
-
-        backend.get_index('bucket', 'words', 'asdf'..'hjkl', &blk)
-      end
-
-      it "sends batches of results to the block" do
-        expect(protocol).to receive(:write)
-
-        response_sets = [%w{asdf asdg asdh}, %w{gggg gggh gggi}]
-        response_messages = response_sets.map do |s|
-          Riak::Client::BeefcakeProtobuffsBackend::RpbIndexResp.new keys: s
-        end
-        response_messages.last.done = true
-
-        expect(protocol).to receive(:expect).and_return(*response_messages)
-
-        block_body = double 'block'
-        expect(block_body).to receive(:check).with(response_sets.first).once
-        expect(block_body).to receive(:check).with(response_sets.last).once
-
-        blk = proc {|m| block_body.check m }
-
-        backend.get_index 'bucket', 'words', 'asdf'..'hjkl', &blk
-      end
-    end
-
-    it "returns a full batch of results when not streaming" do
-      expect(protocol).to receive(:write) do |msg, req|
-        expect(msg).to eq(:IndexReq)
-        expect(req[:stream]).not_to be
-      end
-
-      response_message = Riak::Client::BeefcakeProtobuffsBackend::
-        RpbIndexResp.new(
-                         keys: %w{asdf asdg asdh}
-                         )
-      expect(protocol).to receive(:expect).
-        and_return(response_message)
-
-      results = backend.get_index 'bucket', 'words', 'asdf'..'hjkl'
-      expect(results).to eq(%w{asdf asdg asdh})
-    end
-
-    it "returns no results when no keys or terms are returned" do
-      expect(protocol).to receive(:write) do |msg, req|
-        expect(msg).to eq(:IndexReq)
-        expect(req[:stream]).not_to be
-      end
-
-      response_message = Riak::Client::BeefcakeProtobuffsBackend::
-        RpbIndexResp.new()
-
-      expect(protocol).to receive(:expect).and_return(response_message)
-
-      results = nil
-      fetch = proc do
-        results = backend.get_index 'bucket', 'words', 'asdf'
-      end
-
-      expect(fetch).not_to raise_error
-      expect(results).to eq([])
-    end
-  end
-
-  context "#mapred" do
-    let(:mapred) { Riak::MapReduce.new(client).add('test').map("function(){}").map("function(){}") }
-
-    it "returns empty sets for previous phases that don't return anything" do
-      expect(protocol).to receive(:write)
-
-      message = double(:message, :phase => 1, :response => [{}].to_json)
-      allow(message).to receive(:done).and_return(false, true)
-
-      expect(protocol).to receive(:expect).
-        twice.
-        and_return(message)
-
-      expect(backend.mapred(mapred)).to eq([{}])
-    end
-  end
-
-  context "preventing stale writes" do
-    before do
-      allow(backend).to receive(:decode_response).and_return(nil)
-      allow(backend).to receive(:get_server_version).and_return("1.0.3")
-    end
-
-    let(:robject) do
-      Riak::RObject.new(client['stale'], 'prevent').tap do |obj|
-        obj.prevent_stale_writes = true
-        obj.raw_data = "stale"
-        obj.content_type = "text/plain"
-      end
-    end
-
-    it "sets the if_none_match field when the object is new" do
-      expect(protocol).to receive(:write) do |msg, req|
-        expect(msg).to eq(:PutReq)
-        expect(req.if_none_match).to be_truthy
-      end
-      expect(protocol).to receive(:expect).
-        and_return(:empty)
-
-      backend.store_object(robject)
-    end
-
-    it "sets the if_not_modified field when the object has a vclock" do
-      robject.vclock = Base64.encode64("foo")
-      expect(protocol).to receive(:write) do |msg, req|
-        expect(msg).to eq(:PutReq)
-        expect(req.if_not_modified).to be_truthy
-      end
-      expect(protocol).to receive(:expect).
-        and_return(:empty)
-      backend.store_object(robject)
-    end
-  end
-end

data/spec/riak/bucket_properties_spec.rb

@@ -1,135 +0,0 @@
-require 'spec_helper'
-require 'riak/bucket_properties'
-
-describe Riak::BucketProperties do
-  let(:client){ instance_double 'Riak::Client' }
-  let(:backend) do
-    instance_double('Riak::Client::BeefcakeProtobuffsBackend').tap do |be|
-      allow(client).to receive(:backend).and_yield be
-    end
-  end
-
-  let(:props_operator) do
-    Riak::Client::BeefcakeProtobuffsBackend.configured?
-    instance_double(
-      'Riak::Client::BeefcakeProtobuffsBackend::BucketPropertiesOperator'
-    ).tap do |po|
-      allow(backend).to receive(:bucket_properties_operator).
-        and_return(po)
-    end
-  end
-
-  let(:bucket) do
-    instance_double('Riak::Bucket').tap do |b|
-      allow(b).to receive(:client).and_return(client)
-      allow(b).to receive(:needs_type?).and_return(false)
-    end
-  end
-
-  let(:typed_bucket) do
-    instance_double('Riak::BucketTyped::Bucket').tap do |b|
-      allow(b).to receive(:client).and_return(client)
-    end
-  end
-
-  let(:index_name){ 'index_name' }
-
-  let(:index) do
-    instance_double('Riak::Search::Index').tap do |i|
-      allow(i).to receive(:name).and_return(index_name)
-      allow(i).to receive(:is_a?).with(Riak::Search::Index).and_return(true)
-    end
-  end
-
-  subject{ described_class.new bucket }
-
-  it 'is initialized with a bucket' do
-    p = nil
-    expect{ p = described_class.new bucket }.to_not raise_error
-    expect(p.client).to eq client
-    expect(p.bucket).to eq bucket
-  end
-
-  it 'initialzies correctly with a bucket-typed bucket' do
-    p = nil
-    expect{ p = described_class.new typed_bucket }.to_not raise_error
-    expect(p.client).to eq client
-    expect(p.bucket).to eq typed_bucket
-  end
-
-  it 'provides hash-like access to properties' do
-    expect(props_operator).to receive(:get).
-      with(bucket).
-      and_return('allow_mult' => true)
-
-    expect(subject['allow_mult']).to be
-
-    subject['allow_mult'] = false
-
-    expect(props_operator).to receive(:put).
-      with(bucket, hash_including('allow_mult' => false))
-
-    subject.store
-  end
-
-  it 'unwraps index objects into names' do
-    expect(props_operator).to receive(:get).
-      with(bucket).
-      and_return('allow_mult' => true)
-
-    expect{ subject['search_index'] = index }.to_not raise_error
-
-    expect(subject['search_index']).to eq index_name
-  end
-
-  it 'merges properties from hashes' do
-    expect(props_operator).to receive(:get).
-      with(bucket).
-      and_return('allow_mult' => true)
-
-    expect(subject['allow_mult']).to be
-
-    property_hash = { 'allow_mult' => false }
-    expect{ subject.merge! property_hash }.to_not raise_error
-
-    expect(props_operator).to receive(:put).
-      with(bucket, hash_including('allow_mult' => false))
-
-    subject.store
-  end
-
-  it 'merges properties from other bucket properties objects' do
-    expect(props_operator).to receive(:get).
-      with(bucket).
-      and_return('allow_mult' => true)
-
-    expect(subject['allow_mult']).to be
-
-    other_props = described_class.new typed_bucket
-    other_props.
-      instance_variable_set :@cached_props, { 'allow_mult' => false}
-
-    expect{ subject.merge! other_props }.to_not raise_error
-
-    expect(props_operator).to receive(:put).
-      with(bucket, hash_including('allow_mult' => false))
-
-    subject.store
-  end
-
-  it 'reloads' do
-    expect(props_operator).to receive(:get).
-      with(bucket).
-      and_return('allow_mult' => true)
-
-    expect(subject['allow_mult']).to be
-
-    expect(props_operator).to receive(:get).
-      with(bucket).
-      and_return('allow_mult' => false)
-
-    expect{ subject.reload }.to_not raise_error
-
-    expect(subject['allow_mult']).to_not be
-  end
-end

data/spec/riak/bucket_spec.rb

@@ -1,275 +0,0 @@
-require 'spec_helper'
-
-describe Riak::Bucket do
-  before :each do
-    @client = Riak::Client.new
-    @backend = double("Backend")
-    allow(@client).to receive(:backend).and_yield(@backend)
-    allow(@client).to receive(:http).and_yield(@backend)
-    @bucket = Riak::Bucket.new(@client, "foo")
-  end
-
-  describe "when initializing" do
-    it "requires a client and a name" do
-      expect { Riak::Bucket.new }.to raise_error ArgumentError
-      expect { Riak::Bucket.new(@client) }.to raise_error ArgumentError
-      expect { Riak::Bucket.new("foo") }.to raise_error ArgumentError
-      expect { Riak::Bucket.new("foo", @client) }.to raise_error ArgumentError
-      expect { Riak::Bucket.new(@client, "foo") }.not_to raise_error
-      expect { Riak::Bucket.new(@client, '') }.to raise_error(ArgumentError)
-    end
-
-    it "sets the client and name attributes" do
-      bucket = Riak::Bucket.new(@client, "foo")
-      expect(bucket.client).to eq(@client)
-      expect(bucket.name).to eq("foo")
-    end
-  end
-
-  describe "accessing keys" do
-    it "lists the keys" do
-      expect(@backend).to receive(:list_keys).with(@bucket, {}).and_return(["bar"])
-      expect(@bucket.keys).to eq(["bar"])
-    end
-
-    it "allows streaming keys through block" do
-      expect(@backend).to receive(:list_keys).with(@bucket, {}).and_yield([]).and_yield(["bar"]).and_yield(["baz"])
-      all_keys = []
-      @bucket.keys do |list|
-        all_keys.concat(list)
-      end
-      expect(all_keys).to eq(%w(bar baz))
-    end
-
-    it "fetches a fresh list of keys" do
-      expect(@backend).to receive(:list_keys).with(@bucket, {}).twice.and_return(["bar"])
-      2.times { expect(@bucket.keys).to eq(['bar']) }
-    end
-
-    it "warns about the expense of list-keys when warnings are not disabled" do
-      Riak.disable_list_keys_warnings = false
-      allow(@backend).to receive(:list_keys).and_return(%w{test test2})
-      expect(@bucket).to receive(:warn)
-      @bucket.keys
-      Riak.disable_list_keys_warnings = true
-    end
-
-    it "allows a specified timeout when listing keys" do
-      expect(@backend).to receive(:list_keys).with(@bucket, timeout: 1234).and_return(%w{bar})
-
-      keys = @bucket.keys timeout: 1234
-
-      expect(keys).to eq(%w{bar})
-    end
-  end
-
-  describe "accessing a counter" do
-    it "returns a counter object" do
-      expect(Riak::Counter).to receive(:new).with(@bucket, 'asdf').and_return('example counter')
-
-      new_counter = @bucket.counter 'asdf'
-
-      expect(new_counter).to eq('example counter')
-    end
-  end
-
-  describe "setting the bucket properties" do
-    it "prefetches the properties when they are not present" do
-      allow(@backend).to receive(:set_bucket_props)
-      expect(@backend).to receive(:get_bucket_props).with(@bucket, {  }).and_return({"name" => "foo"})
-      @bucket.props = {"precommit" => []}
-    end
-
-    it "sets the new properties on the bucket" do
-      @bucket.instance_variable_set(:@props, {}) # Pretend they are there
-      expect(@backend).to receive(:set_bucket_props).with(@bucket, { :name => "foo" }, nil)
-      @bucket.props = { :name => "foo" }
-    end
-
-    it "raises an error if an invalid type is given" do
-      expect { @bucket.props = "blah" }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "fetching the bucket properties" do
-    it "fetches properties on first access" do
-      expect(@bucket.instance_variable_get(:@props)).to be_nil
-      expect(@backend).to receive(:get_bucket_props).with(@bucket, {  }).and_return({"name" => "foo"})
-      expect(@bucket.props).to eq({"name" => "foo"})
-    end
-
-    it "memoizes fetched properties" do
-      expect(@backend).to receive(:get_bucket_props).once.with(@bucket, {  }).and_return({"name" => "foo"})
-      expect(@bucket.props).to eq({"name" => "foo"})
-      expect(@bucket.props).to eq({"name" => "foo"})
-    end
-  end
-
-  describe "clearing the bucket properties" do
-    it "sends the request and delete the internal properties cache" do
-      expect(@client).to receive(:clear_bucket_props).with(@bucket).and_return(true)
-      expect(@bucket.clear_props).to be_truthy
-      expect(@bucket.instance_variable_get(:@props)).to be_nil
-    end
-  end
-
-  describe "fetching an object" do
-    it "fetches the object via the backend" do
-      expect(@backend).to receive(:fetch_object).with(@bucket, "db", {}).and_return(nil)
-      @bucket.get("db")
-    end
-
-    it "uses the specified R quroum" do
-      expect(@backend).to receive(:fetch_object).with(@bucket, "db", {:r => 2}).and_return(nil)
-      @bucket.get("db", :r => 2)
-    end
-
-    it "disallows fetching an object with a zero-length key" do
-      ## TODO: This actually tests the Client object, but there is no suite
-      ## of tests for its generic interface.
-      expect { @bucket.get('') }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "creating a new blank object" do
-    it "instantiates the object with the given key, default to JSON" do
-      obj = @bucket.new('bar')
-      expect(obj).to be_kind_of(Riak::RObject)
-      expect(obj.key).to eq('bar')
-      expect(obj.content_type).to eq('application/json')
-    end
-  end
-
-  describe "fetching or creating a new object" do
-    let(:not_found_error){ Riak::ProtobuffsFailedRequest.new :not_found, 'not found' }
-    let(:other_error){ Riak::ProtobuffsFailedRequest.new :server_error, 'server error' }
-
-    it "returns the existing object if present" do
-      @object = double("RObject")
-      expect(@backend).to receive(:fetch_object).with(@bucket, "db", {}).and_return(@object)
-      expect(@bucket.get_or_new('db')).to eq(@object)
-    end
-
-    it "creates a new blank object if the key does not exist" do
-      expect(@backend).to receive(:fetch_object).and_raise(not_found_error)
-      obj = @bucket.get_or_new('db')
-      expect(obj.key).to eq('db')
-      expect(obj.data).to be_blank
-    end
-
-    it "bubbles up non-ok non-missing errors" do
-      expect(@backend).to receive(:fetch_object).and_raise(other_error)
-      expect { @bucket.get_or_new('db') }.to raise_error(Riak::ProtobuffsFailedRequest)
-    end
-
-    it "passes the given R quorum parameter to the backend" do
-      @object = double("RObject")
-      expect(@backend).to receive(:fetch_object).with(@bucket, "db", {:r => "all"}).and_return(@object)
-      expect(@bucket.get_or_new('db', :r => "all")).to eq(@object)
-    end
-  end
-
-  describe "fetching multiple objects" do
-    it 'gets each object individually' do
-      @object1 = double('obj1')
-      @object2 = double('obj2')
-      expect(@bucket).to receive(:[]).with('key1').and_return(@object1)
-      expect(@bucket).to receive(:[]).with('key2').and_return(@object2)
-
-      @results = @bucket.get_many %w{key1 key2}
-
-      expect(@results['key1']).to eq(@object1)
-      expect(@results['key2']).to eq(@object2)
-    end
-  end
-
-  describe "querying an index" do
-    it "lists the matching keys" do
-      expect(@backend).
-        to receive(:get_index).
-        with(@bucket, "test_bin", "testing", {return_terms: true}).
-        and_return(Riak::IndexCollection.new_from_json({
-                     'results' => [
-                       {'testing' => 'asdf'},
-                       {'testing' => 'hjkl'}]
-                   }.to_json))
-      result = @bucket.get_index("test_bin", "testing", return_terms: true)
-
-      expect(result).to be_a Riak::IndexCollection
-      expect(result.to_a).to eq(%w{asdf hjkl})
-      expect(result.with_terms).to eq({'testing' => %w{asdf hjkl}})
-    end
-  end
-
-  describe "get/set allow_mult property" do
-    before :each do
-      allow(@backend).to receive(:get_bucket_props).and_return({"allow_mult" => false})
-    end
-
-    it "extracts the allow_mult property" do
-      expect(@bucket.allow_mult).to be_falsey
-    end
-
-    it "sets the allow_mult property" do
-      expect(@bucket).to receive(:props=).with(hash_including('allow_mult' => true))
-      @bucket.allow_mult = true
-    end
-  end
-
-  describe "get/set the N value" do
-    before :each do
-      allow(@backend).to receive(:get_bucket_props).and_return({"n_val" => 3})
-    end
-
-    it "extracts the N value" do
-      expect(@bucket.n_value).to eq(3)
-    end
-
-    it "sets the N value" do
-      expect(@bucket).to receive(:props=).with(hash_including('n_val' => 1))
-      @bucket.n_value = 1
-    end
-  end
-
-  [:r, :w, :dw, :rw].each do |q|
-    describe "get/set the default #{q} quorum" do
-      before :each do
-        allow(@backend).to receive(:get_bucket_props).and_return({"r" => "quorum", "w" => "quorum", "dw" => "quorum", "rw" => "quorum"})
-      end
-
-      it "extracts the default #{q} quorum" do
-        expect(@bucket.send(q)).to eq("quorum")
-      end
-
-      it "sets the #{q} quorum" do
-        expect(@bucket).to receive(:props=).with(hash_including("#{q}" => 1))
-        @bucket.send("#{q}=", 1)
-      end
-    end
-  end
-
-  describe "checking whether a key exists" do
-    it "returns true if the object does exist" do
-      expect(@backend).to receive(:fetch_object).and_return(double)
-      expect(@bucket.exists?("foo")).to be_truthy
-    end
-
-    it "returns false if the object doesn't exist" do
-      expect(@backend).to receive(:fetch_object).
-        and_raise(Riak::ProtobuffsFailedRequest.new(:not_found, "not found"))
-      expect(@bucket.exists?("foo")).to be_falsey
-    end
-  end
-
-  describe "deleting an object" do
-    it "deletes a key from within the bucket" do
-      expect(@backend).to receive(:delete_object).with(@bucket, "bar", {})
-      @bucket.delete('bar')
-    end
-
-    it "uses the specified RW quorum" do
-      expect(@backend).to receive(:delete_object).with(@bucket, "bar", {:rw => "all"})
-      @bucket.delete('bar', :rw => "all")
-    end
-  end
-end