riak-client 1.4.5 → 2.0.0.rc1

data/lib/riak/i18n.rb

@@ -1,5 +1,7 @@
 require 'i18n'
 
+I18n.config.enforce_available_locales = true unless I18n.config.enforce_available_locales == false
+
 Dir.glob(File.expand_path("../locale/*.yml", __FILE__)).each do |locale_file|
   I18n.load_path << locale_file
 end

data/lib/riak/json.rb

@@ -9,7 +9,7 @@ require 'riak/core_ext/json'
 module Riak
   class << self
     # Options that will be passed to the JSON parser and encoder.
-    # Defaults to {:max_nesting => 20}
+    # Defaults to `{:max_nesting => 20}`
     attr_accessor :json_options
   end
   self.json_options = {:max_nesting => 20}

data/lib/riak/locale/en.yml

@@ -9,6 +9,14 @@ en:
     counter:
       bucket_needs_allow_mult: "Counters require allow_mult to be enabled on their bucket."
       increment_by_integer: "Counters can only be incremented or decremented by integers."
+    crdt:
+      precondition_error: "Riak server returned precondition error: %{message}"
+      set_removal_without_context: "CRDT Sets do not support removal without context. Store and reload the set before removing members."
+      unknown_field: "Unknown field type %{symbol}, expected one of :counter, :map, or :set."
+      unknown_inner_field: "Unknown field type %{symbol}, expected one of :counter, :flag, :map, :register, or :set."
+      serialize_no_ops: "Can't serialize an empty list of CRDT operations."
+      flag:
+        not_boolean: "Flags can only be true or false."
     deprecated:
       port: "DEPRECATION: Riak::Client#port has been deprecated, use #http_port or #pb_port for the appropriate protocol.\n%{backtrace}"
       search: "DEPRECATION: Riak Search features are included in the main client, you no longer need to require 'riak/search'.\n%{backtrace}"
@@ -42,13 +50,19 @@ en:
     loading_bucket: "while loading bucket '%{name}'"    
     list_buckets: "Riak::Client#buckets is an expensive operation that should not be used in production.\n    %{backtrace}"
     list_keys: "Riak::Bucket#keys is an expensive operation that should not be used in production.\n    %{backtrace}"
-    luwak_unsupported: "Riak server does not support Luwak. Enable it in app.config before using."
     missing_block: "A block must be given."
     missing_host_and_port: "You must specify a host and port, or use the defaults of 127.0.0.1:8098"
     module_function_pair_required: "function must have two elements when an array"
     not_found: "The requested object was not found."
     no_pipes: "Could not find or open pipes for Riak console in %{path}."
     object_in_conflict: "The object is in conflict (has siblings) and cannot be treated singly or saved: %{robject}"
+    pbc:
+      failed_header: "Failed to receive a header from Riak."
+      unexpected_eof: "Unexpected EOF on PBC socket"
+      user_not_username: "Authentication hash expects :user, not :username."
+      wanted_index_resp: "Expected IndexResp during secondary index query"
+      wanted_dt_fetch_resp: "Expected PBC DtFetchResp during CRDT fetch"
+      wanted_dt_update_resp: "Expected PBC DtUpdateResp during CRDT update"
     port_invalid: "port must be an integer between 0 and 65535"
     protobuffs_failed_request: "Expected success from Riak but received %{code}. %{body}"
     protobuffs_configuration: "The %{backend} Protobuffs backend cannot be used. Please check its requirements."
@@ -58,6 +72,14 @@ en:
     search_remove_requires_id_or_query: "Search index documents to be removed must have 'id' or 'query' keys."
     serializer_not_implemented: "No serializer has been registered for content type %{content_type}"
     source_and_root_required: "Riak::Node configuration must include :source and :root keys."
+    ssl:
+      cert_host_mismatch: "The presented SSL/TLS certificate did not match the hostname."
+      cert_not_in_valid_range: "The presented SSL/TLS certificate is either expired or premature."
+      cert_revoked: "The presented SSL/TLS certificate has been revoked."
+      eof_during_init: "Unexpected EOF during SSL/TLS initialization."
+      read_data_error: "Tried to read cert or key from %{candidate}, caught error %{actual}."
+      unexpected_during_init: "Expected %{expected}, got %{actual} with body %{body} during SSL/TLS initialization."
+      unknown_key_type: "Can't figure out what the client key is. Expected it to be some kind of OpenSSL::PKey::PKey subclass, a filename string, or string data representing the key itself."
     stale_write_prevented: "Stale write prevented by client."
     stored_function_invalid: "function must have :bucket and :key when a hash"
     streaming_bucket_list_without_block: "Streaming bucket list was requested but no block was given."
@@ -67,3 +89,6 @@ en:
     wrong_argument_count_walk_spec: "wrong number of arguments (one Hash or bucket,tag,keep required)"
     zero_length_bucket: "bucket name cannot be a String of zero length"
     zero_length_key: "key cannot be a String of zero length"
+    zero_length_index: "index name cannot be a String of zero length"
+    zero_length_schema: "schema name cannot be a String of zero length"
+    zero_length_content: "content cannot be a String of zero length"

data/lib/riak/locale/fr.yml

@@ -30,7 +30,6 @@ fr:
     loading_bucket: "pendant le chargement du bucket '%{name}'"
     list_buckets: "Riak::Client#buckets est une opération coûteuse et ne doit pas être utilisée en production.\n    %{backtrace}"
     list_keys: "Riak::Bucket#keys est une opération coûteuse et ne doit pas être utilisée en production.\n    %{backtrace}"
-    luwak_unsupported: "Le serveur Riak ne supporte pas Luwak. Activez-le dans app.config avant de l'utiliser"
     missing_block: "Un bloc doit être fourni."
     missing_host_and_port: "Vous devez spécifier un hôte et un port, utiliser la valeur par défaut : 127.0.0.1:8098"
     module_function_pair_required: "la fonction doit avoir deux élément lorsqu'elle est définie par un tableau"

data/lib/riak/map_reduce.rb

@@ -5,7 +5,7 @@ require 'riak/client'
 require 'riak/bucket'
 require 'riak/robject'
 require 'riak/walk_spec'
-require 'riak/failed_request'
+require 'riak/errors/failed_request'
 require 'riak/map_reduce_error'
 require 'riak/map_reduce/phase'
 require 'riak/map_reduce/filter_builder'

data/lib/riak/map_reduce/results.rb

@@ -12,7 +12,7 @@ module Riak
 
       # Adds a new result to the collector
       # @param [Fixnum] phase the phase index
-      # @param [Array] data the phase result
+      # @param [Array] result the phase result
       def add(phase, result)
         @hash[phase] += result
       end

data/lib/riak/multiget.rb

@@ -1,6 +1,5 @@
 require 'riak/client'
 require 'riak/bucket'
-require 'riak/cluster'
 
 module Riak
   # Coordinates a parallel fetch operation for multiple values.
@@ -25,7 +24,7 @@ module Riak
     # Perform a Riak Multiget operation.
     # @param [Client] client the {Riak::Client} that will perform the multiget
     # @param [Array<Bucket, String>] fetch_list an {Array} of {Bucket} and {String} keys to fetch
-    # @return [Hash<fetch_list_entry, RObject] result_hash a {Hash} of {Bucket} and {String} key pairs to {Robject} instances
+    # @return [Hash<fetch_list_entry, RObject] result_hash a {Hash} of {Bucket} and {String} key pairs to {RObject} instances
     def self.get_all(client, fetch_list)
       multi = new client, fetch_list
       multi.fetch

data/lib/riak/rcontent.rb

@@ -68,7 +68,10 @@ module Riak
       @data
     end
 
-    # @param [Object] unmarshaled form of the data to be stored in riak. Object will be serialized using {#serialize} if a known content_type is used. Setting this overrides values stored with {#raw_data=}
+    # @param [Object] new_data unmarshaled form of the data to be stored in 
+    #   Riak. Object will be serialized using {#serialize} if a known 
+    #   content_type is used. Setting this overrides values stored with 
+    #   {#raw_data=}
     # @return [Object] the object stored
     def data=(new_data)
       if new_data.respond_to?(:read)
@@ -89,7 +92,9 @@ module Riak
       @raw_data
     end
 
-    # @param [String, IO-like] the raw data to be stored in riak at this key, will not be marshaled or manipulated prior to storage. Overrides any data stored by {#data=}
+    # @param [String, IO-like] new_raw_data the raw data to be stored in Riak
+    #   at this key, will not be marshaled or manipulated prior to storage.
+    #   Overrides any data stored by {#data=}
     # @return [String] the data stored
     def raw_data=(new_raw_data)
       @data = nil
@@ -130,7 +135,7 @@ module Riak
       "#<#{self.class.name} [#{@content_type}]:#{body}>"
     end
 
-    # @hidden
+    # @api private
     def load_map_reduce_value(hash)
       metadata = hash['metadata']
       extract_if_present(metadata, 'X-Riak-VTag', :etag)

data/lib/riak/robject.rb

@@ -29,7 +29,8 @@ module Riak
     alias :vector_clock :vclock
     alias :vector_clock= :vclock=
 
-    # @return [Boolean] whether to attempt to prevent stale writes using conditional PUT semantics, If-None-Match: * or If-Match: {#etag}
+    # @return [Boolean] whether to attempt to prevent stale writes using 
+    #   conditional PUT semantics, If-None-Match: * or If-Match: etag
     # @see http://wiki.basho.com/display/RIAK/REST+API#RESTAPI-Storeaneworexistingobjectwithakey Riak Rest API Docs
     attr_accessor :prevent_stale_writes
 
@@ -182,13 +183,6 @@ module Riak
       "#<#{self.class.name} {#{bucket.name}#{"," + @key if @key}} [#{body}]>"
     end
 
-    # Walks links from this object to other objects in Riak.
-    # @param [Array<Hash,WalkSpec>] link specifications for the query
-    def walk(*params)
-      specs = WalkSpec.normalize(*params)
-      @bucket.client.link_walk(self, specs)
-    end
-
     # Converts the object to a link suitable for linking other objects
     # to it
     # @param [String] tag the tag to apply to the link

data/lib/riak/secondary_index.rb

@@ -5,10 +5,10 @@ module Riak
     include Client::FeatureDetection
 
     # Create a Riak Secondary Index operation
-    # @param [Bucket] the {Riak::Bucket} we'll query against
-    # @param [String] the index name
-    # @param [String,Integer,Range<String,Integer>] a single value or
-    #   range of values to query for
+    # @param [Bucket] bucket the {Riak::Bucket} we'll query against
+    # @param [String] index the index name
+    # @param [String,Integer,Range<String,Integer>] query
+    #   a single value or range of values to query for
     def initialize(bucket, index, query, options={})
       @bucket = bucket
       @client = @bucket.client

data/lib/riak/serializers.rb

@@ -23,7 +23,7 @@ module Riak
 
     def serializer_for(content_type)
       serializers.fetch(content_type[/^[^;\s]+/]) do
-        raise NotImplementedError.new(t('serializer_not_implemented', :content_type => content_type.inspect))
+        raise IOError.new(t('serializer_not_implemented', :content_type => content_type.inspect))
       end
     end
 

data/lib/riak/util/escape.rb

@@ -25,12 +25,12 @@ module Riak
     # being stored. This increases compatibility with the Protocol
     # Buffers transport and reduces inconsistency of link-walking
     # vs. regular operations. If the node you are connecting to has
-    # set {http_url_encoding, on}, set this to true. Default is false.
+    # set `{http_url_encoding, on}`, set this to true. Default is false.
     # @return [true,false] Whether Riak decodes URL-encoded paths and headers
     attr_accessor :url_decoding
   end
 
-  self.escaper = CGI
+  self.escaper = URI
   self.url_decoding = false
 
   module Util
@@ -52,9 +52,7 @@ module Riak
       # @return [String] the escaped path segment
       def escape(bucket_or_key)
         if Riak.escaper == URI
-          Riak.escaper.escape(bucket_or_key.to_s).
-            gsub(" ", "%20").gsub("+", "%2B").gsub("/", "%2F").
-            gsub("[", "%5B").gsub("]", "%5D")
+          Riak.escaper.escape(bucket_or_key.to_s).gsub(" ", "%20").gsub("+", "%2B").gsub('/', "%2F")
         else #CGI
           Riak.escaper.escape(bucket_or_key.to_s).gsub("+", "%20").gsub('/', "%2F")
         end

data/lib/riak/version.rb

@@ -1,3 +1,3 @@
 module Riak
-  VERSION = "1.4.5"
+  VERSION = "2.0.0.rc1"
 end

data/lib/riak/walk_spec.rb

@@ -6,10 +6,14 @@ module Riak
   # The specification of how to follow links from one object to another in Riak,
   # when using the link-walker resource.
   # Example link-walking operation:
-  #   GET /riak/artists/REM/albums,_,_/tracks,_,1
+  #
+  #     GET /riak/artists/REM/albums,_,_/tracks,_,1
+  #
   # This operation would have two WalkSpecs:
-  #   Riak::WalkSpec.new({:bucket => 'albums'})
-  #   Riak::WalkSpec.new({:bucket => 'tracks', :result => true})
+  #
+  #     Riak::WalkSpec.new({:bucket => 'albums'})
+  #     Riak::WalkSpec.new({:bucket => 'tracks', :result => true})
+  #
   class WalkSpec
     include Util::Translation
     extend Util::Translation

data/riak-client.gemspec

@@ -12,18 +12,20 @@ Gem::Specification.new do |gem|
   gem.authors = ["Sean Cribbs", 'Bryce Kerley']
   gem.license = 'Apache 2.0'
 
+  gem.required_ruby_version = '>= 1.9.3'
+
   # Deps
-  gem.add_development_dependency "rspec", "~>2.13.0"
-  gem.add_development_dependency "fakeweb", ">=1.2"
-  gem.add_development_dependency "rack", ">=1.0"
-  gem.add_development_dependency "excon", ">=0.6.1"
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency "instrumentable", "~> 1.1.0"
+  gem.add_development_dependency "rspec", "~> 3.0.0"
+  gem.add_development_dependency 'rake', '~> 10.1.1'
+  gem.add_development_dependency 'yard', '~> 0.8.7'
+  gem.add_development_dependency 'redcarpet', '~> 3.0.0'
+  gem.add_development_dependency 'simplecov', '~> 0.8.2'
+  
   gem.add_runtime_dependency "i18n", ">=0.4.0"
-  gem.add_runtime_dependency "builder", ">= 2.1.2"
-  gem.add_runtime_dependency "beefcake", "~>1.0.0"
+  gem.add_runtime_dependency "beefcake", ">= 1.0.0.pre1"
   gem.add_runtime_dependency "multi_json", "~>1.0"
   gem.add_runtime_dependency "innertube", "~>1.0.2"
+  gem.add_runtime_dependency 'r509-cert-validator', '~> 0.0.4'
 
   # Files
 

data/spec/fixtures/bitcask.txt

@@ -0,0 +1,25 @@
+Bitcask is an Erlang application that provides an API for storing and retrieving key/value data into a log-structured hash table that provides very fast access. The design owes a lot to the principles found in log-structured file systems and draws inspiration from a number of designs that involve log file merging.
+
+Strengths
+Low latency per item read or written
+This is due to the write-once, append-only nature of the Bitcask database files. High throughput, especially when writing an incoming stream of random items Because the data being written doesn't need to be ordered on disk and because the log structured design allows for minimal disk head movement during writes these operations generally saturate the I/O and disk bandwidth.
+
+Ability to handle datasets larger than RAM w/o degradation
+Because access to data in Bitcask is direct lookup from an in-memory hash table finding data on disk is very efficient, even when data sets are very large.
+
+Single Seek to Retrieve Any Value
+Bitcask's in-memory hash-table of keys point directly to locations on disk where the data lives. Bitcask never uses more than one disk seek to read a value and sometimes, due to file-system caching done by the operating system, even that isn't necessary.
+
+Predictable Lookup and Insert Performance
+As you might expect from the description above, read operations have a fixed, predictable behavior. What you might not expect is that this is also true for writes. Write operations are at most a seek to the end of the current file open writing and an append to that file.
+
+Fast, bounded Crash Recovery
+Due to the append-only write once nature of Bitcask files, recovery is easy and fast. The only items that might be lost are partially written records at the tail of the file last opened for writes. Recovery need only review the last record or two written and verify CRC data to ensure that the data is consistent.
+
+Easy Backup
+In most systems backup can be very complicated but here again Bitcask simplifies this process due to its append-only write once disk format. Any utility that archives or copies files in disk-block order will properly backup or copy a Bitcask database.
+
+Weakness
+Keys Must Fit In Memory
+Bitcask keeps all keys in memory at all times, this means that your system must have enough memory to contain your entire keyspace with room for other operational components and operating system resident filesystem buffer space.
+

data/spec/integration/riak/bucket_types_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'riak'
+
+describe 'Bucket Types', test_client: true, integration: true do
+  let(:bucket){ random_bucket 'bucket_type_spec' }
+
+  describe 'performing key-value operations' do
+    # for the sake of having a non-default one, not search
+    let(:bucket_type){ 'yokozuna' }
+    let(:object) do
+      object = bucket.new random_key
+      object.data = 'hello'
+      object.content_type = 'text/plain'
+      object.store type: bucket_type
+      object
+    end
+
+    it 'only retrieves with a bucket type' do
+      expect{ bucket.get object.key, type: bucket_type }.to_not raise_error
+      expect{ bucket.get object.key }.to raise_error /not_found/
+    end
+
+    it 'deletes from the bucket only with a bucket type' do
+      expect(bucket.delete object.key).to eq true
+      expect{ bucket.get object.key, type: bucket_type }.to_not raise_error
+
+      expect{ bucket.delete object.key, type: bucket_type }.to_not raise_error
+      expect{ bucket.get object.key, type: bucket_type }.to raise_error /not_found/
+    end
+
+    it 'self-deletes only with a bucket type' do
+      expect(object.delete).to be
+      expect{ object.reload type: bucket_type }.to_not raise_error
+
+      expect(object.delete type: bucket_type).to be
+      expect{ object.reload type: bucket_type }.to raise_error /not_found/
+    end
+  end
+
+  describe 'performing CRDT set operations' do
+    let(:bucket_type){ Riak::Crdt::DEFAULT_BUCKET_TYPES[:set] }
+    let(:set) do
+      set = Riak::Crdt::Set.new bucket, random_key
+      set.add random_key
+      set
+    end
+
+    it 'retrieves the set blob via key-value using a bucket type' do
+      expect{ bucket.get set.key }.to raise_error /not_found/
+      expect(bucket.get set.key, type: bucket_type).to be
+    end
+
+    it 'deletes the set blob through the bucket type' do
+      expect(bucket.delete set.key).to be
+      expect{ bucket.get set.key, type: bucket_type }.to_not raise_error
+
+      expect(bucket.delete set.key, type: bucket_type).to be
+      expect{ bucket.get set.key, type: bucket_type }.to raise_error /not_found/
+    end
+  end
+end

data/spec/integration/riak/counters_spec.rb

@@ -1,51 +1,36 @@
 require 'spec_helper'
 require 'riak'
 
-describe Riak::Counter, test_server: true, integration: true do
+describe Riak::Counter, test_client: true, integration: true do
   before :all do
-    opts = {
-      http_port: test_server.http_port,
-      pb_port: test_server.pb_port,
-      protocol: 'pbc'
-    }
-    test_server.start
-    @client = Riak::Client.new opts
-    @bucket = @client['counter_spec']
+    @bucket = random_bucket 'counter_spec'
     @bucket.allow_mult = true
 
     @counter = Riak::Counter.new @bucket, 'counter_spec'
   end
 
+  it 'should read and update' do
+    initial = @counter.value
 
-  ['pbc', 'http'].each do |protocol|
-    describe protocol do
-      before :all do
-        @client.protocol = protocol
-      end
-      it 'should read and update' do
-        initial = @counter.value
+    @counter.increment
+    @counter.increment
 
-        @counter.increment
-        @counter.increment
+    expect(@counter.value).to eq(initial + 2)
 
-        @counter.value.should == (initial + 2)
+    @counter.decrement 2
 
-        @counter.decrement 2
+    expect(@counter.value).to eq(initial)
 
-        @counter.value.should == initial
+    5.times do
+      amt = rand(10_000)
+      
+      @counter.increment amt
+      expect(@counter.value).to eq(initial + amt)
 
-        5.times do
-          amt = rand(10_000)
-          
-          @counter.increment amt
-          @counter.value.should == (initial + amt)
+      @counter.decrement (amt * 2)
+      expect(@counter.value).to eq(initial - amt)
 
-          @counter.decrement (amt * 2)
-          @counter.value.should == (initial - amt)
-
-          @counter.increment_and_return(amt).should == initial
-        end
-      end
+      expect(@counter.increment_and_return(amt)).to eq(initial)
     end
   end
 end

data/spec/integration/riak/crdt_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+require 'riak'
+
+describe "CRDTs", integration: true, test_client: true do
+  let(:bucket) { random_bucket }
+
+  describe 'configuration' do
+    it "should allow default bucket-types to be configured for each data type" do
+      expect(Riak::Crdt::Set.new(bucket, 'set').bucket_type).to eq 'sets'
+      
+      Riak::Crdt::DEFAULT_BUCKET_TYPES[:set] = 'new_set_default'
+      expect(Riak::Crdt::Set.new(bucket, 'set').bucket_type).to eq 'new_set_default'
+
+      Riak::Crdt::DEFAULT_BUCKET_TYPES[:set] = 'sets'
+      expect(Riak::Crdt::Set.new(bucket, 'set').bucket_type).to eq 'sets'
+    end
+    
+    it "should allow override bucket-types for instances" do
+      expect(Riak::Crdt::Set.new(bucket, 'set', 'other_bucket_type').bucket_type).to eq 'other_bucket_type'
+    end
+  end
+
+  describe 'an anonymous counter' do
+    subject { Riak::Crdt::Counter.new bucket, nil }
+    it 'accepts a Riak-assigned name' do
+      subject.increment
+      expect(subject.key).to be
+      expect(subject.value).to eq 1
+    end
+  end
+  
+  describe 'counters' do
+    subject { Riak::Crdt::Counter.new bucket, random_key }
+    it 'should allow straightforward counter ops' do
+      start = subject.value
+      subject.increment
+      expect(subject.value).to eq(start + 1)
+      subject.increment
+      expect(subject.value).to eq(start + 2)
+      subject.increment -1
+      expect(subject.value).to eq(start + 1)
+      subject.decrement
+      expect(subject.value).to eq(start)
+    end
+    
+    it 'should allow batched counter ops' do
+      start = subject.value
+      subject.batch do |s|
+        s.increment
+        s.increment 2
+        s.increment
+        s.increment
+      end
+      expect(subject.value).to eq(start + 5)
+    end
+  end
+  describe 'sets' do
+
+    subject { Riak::Crdt::Set.new bucket, random_key }
+    
+    it 'should allow straightforward set ops' do
+      start = subject.members
+      addition = random_key
+
+      subject.add addition
+      expect(subject.include? addition).to be
+      expect(subject.members).to include(addition)
+
+      subject.remove addition
+      expect(subject.include? addition).to_not be
+      expect(subject.members).to_not include(addition)
+      expect(subject.members).to eq(start)
+    end
+    
+    it 'lets Riak silently accept removals after reload' do
+      addition = random_key
+      subject.add addition
+
+      other = Riak::Crdt::Set.new subject.bucket, subject.key
+      expect{ other.remove addition }.to raise_error(Riak::CrdtError::SetRemovalWithoutContextError)
+      other.reload
+      expect{ other.remove addition }.to_not raise_error
+      other.reload
+      expect{ other.remove 'an element not in the set' }.to_not raise_error
+    end
+
+    it 'should allow batched set ops' do
+      subject.add 'zero'
+      subject.reload
+      
+      subject.batch do |s|
+        s.add 'first'
+        s.remove 'zero'
+      end
+
+      expect(subject.members.to_a).to eq %w{first}
+    end
+  end
+  describe 'maps' do
+    subject { Riak::Crdt::Map.new bucket, random_key }
+    
+    it 'should allow straightforward map ops' do
+      subject.registers['first'] = 'hello'
+      expect(subject.registers['first']).to eq('hello')
+
+      subject.sets['arnold'].add 'commando'
+      subject.sets['arnold'].add 'terminator'
+      expect(subject.sets['arnold'].members).to include('commando')
+      subject.sets['arnold'].remove 'commando'
+      expect(subject.sets['arnold'].members).to_not include('commando')
+      expect(subject.sets['arnold'].members).to include('terminator')
+
+      subject.maps['first'].registers['second'] = 'good evening'
+      subject.maps['first'].maps['third'].counters['fourth'].increment
+
+      expect(subject.maps['first'].registers['second']).to eq('good evening')
+      expect(subject.maps['first'].maps['third'].counters['fourth'].value).to eq(1)
+
+      subject.counters['hits'].increment
+      expect(subject.counters['hits'].value).to eq 1
+
+      subject.flags['yes'] = true
+      expect(subject.flags['yes']).to eq true
+
+      expect do
+        subject.registers.delete 'first'
+        subject.sets.delete 'arnold'
+        subject.maps.delete 'first'
+        subject.counters.delete 'hits'
+        subject.flags.delete 'yes'
+      end.to_not raise_error
+    end
+    
+    it 'should allow batched map ops' do
+      subject.batch do |s|
+        s.registers['condiment'] = 'ketchup'
+        s.counters['banana'].increment
+      end
+
+      expect(subject.registers['condiment']).to eq 'ketchup'
+      expect(subject.counters['banana'].value).to eq 1
+    end
+    
+    describe 'containing a map' do
+      it 'should bubble straightforward map ops up' do
+        street_map = subject.maps['street']
+
+        street_map.registers['bird'] = 'avenue'
+        street_map.flags['traffic_light'] = false
+
+        expect(subject.maps['street'])
+      end
+      
+      it 'should include inner-map ops in the outer-map batch' do
+        subject.batch do |m|
+          m.maps['road'].counters['speedbumps'].increment 4
+          m.maps['road'].sets['signs'].add 'yield'
+        end
+
+        expect(subject.maps['road'].counters['speedbumps'].value).to eq 4
+        expect(subject.maps['road'].sets['signs'].include? 'yield').to be
+      end
+    end
+
+    describe 'containing a register' do
+      it 'should bubble straightforward register ops up' do
+        subject.registers['hkey_local_machine'] = 'registry'
+
+        expect(subject.registers['hkey_local_machine']).to eq 'registry'
+      end
+    end
+
+    describe 'containing a flag' do
+      it 'should bubble straightforward flag ops up' do
+        subject.flags['enable_magic'] = true
+
+        expect(subject.flags['enable_magic']).to be
+      end
+    end
+  end
+end