cistern 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7013053b6babdbcbc398b16bb018cc889cfd01c7
-  data.tar.gz: 81c10f424574419b9bf216ea4a3fec9ec9327b23
+  metadata.gz: 21564d955c7fdeaa4da5659b23af34e3ef33a502
+  data.tar.gz: 16c0a32c23c662d1711ac3a1b0dd47bf78707fc5
 SHA512:
-  metadata.gz: 9238df8c51907706409456fb98a7b1181610b7c761efee3f8d0bc427fb498d1fec4e21a1cbbab71e9619dad62aa33df0bd448b449c9706a5a5aa8bc8c1e55780
-  data.tar.gz: a162d7a75411925f030e30070fb8ec28c1de78eaa10a897f37ebc8cdd9dee818e47b4d1233701f9061417da3b7d6292f5c39c9c5a859c9b9680ac3d3a2e6efa4
+  metadata.gz: a624addb8fd71e993b43550c1c3b7b6359a84ebd2f4918f46f6483836c177933a17ae2ff13267d8ab109386b5ccf6be91dccdffc85ba4aced97766b92ff5b3c8
+  data.tar.gz: 762a3e88c051ca923ed0a6a07a40ad09a24031df8059490715658e26f26b4277f9f92af65906cc5d303bb2b8ace09d4b5a7b31ff6f4dd9c5d00915c82e6754fd

data/.travis.yml

@@ -1,13 +1,18 @@
 language: ruby
 rvm:
-  - "2.1.1"
-  - "1.9.3"
-  - "jruby-19mode"
+- 2.1.1
+- 1.9.3
+- jruby-19mode
 bundler_args: "--without development"
 before_install:
-  - "gem install bundler -v 1.5.2"
-script: "bundle exec rake --trace"
+- gem install bundler -v 1.5.2
+script: bundle exec rake --trace
 notifications:
   email:
     on_success: never
     on_failure: change
+services:
+- redis-server
+env:
+  matrix:
+    secure: eiDhDgp8jBYKZVOqe891g4StnFsqRXcQwlDSnXthRSuWNMd6oFyFOo/s9aXd9lNFkaTBnSAFrUvywH1t2+H3j+cPMn/91W2s2Ldc+SxVxjrY3mWyr6NIudro/rdK7nIfIcWJFtm0teSXg/1nRPZt0qlXc4bZmvwvN3T8MvdgI2I=

data/Gemfile

@@ -4,10 +4,13 @@ source "https://rubygems.org"
 gemspec
 
 group :test do
-  gem "guard-rspec"
+  gem "guard-rspec", "~> 4.2", require: false
+  gem "guard-bundler", "~> 2.0", require: false
   gem "pry-nav"
   gem "rake"
   gem "rspec", "~> 2.0"
+  gem "redis-namespace"
+  gem "codeclimate-test-reporter", require: false
 end
 
 group :formatters do

data/Guardfile

@@ -1,4 +1,10 @@
-guard 'rspec', cmd: 'bundle exec rspec' do
+guard :bundler do
+  watch('Gemfile')
+  # Uncomment next line if your Gemfile contains the `gemspec' command.
+  watch(/^.+\.gemspec/)
+end
+
+guard 'rspec', all_on_start: true, all_after_pass: true, cmd: 'bundle exec rspec' do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { "spec" }
   watch('spec/spec_helper.rb')  { "spec" }

data/README.md

@@ -13,7 +13,7 @@ This represents the remote service that you are wrapping. If the service name is
 
 #### Requests
 
-Requests are enumerated using the ```request``` method and required immediately via the relative path specified via ```request_path```.
+Requests are enumerated using the `request` method and required immediately via the relative path specified via `request_path`.
 
     class Foo::Client < Cistern::Service
       request_path "my-foo/requests"
@@ -48,13 +48,13 @@ A request is method defined within the context of service and mode (Real or Mock
       end # Mock
     end # Foo::client
 
-All declared requests can be listed via ```Cistern::Service#requests```.
+All declared requests can be listed via `Cistern::Service#requests`.
 
     Foo::Client.requests # => [:get_bar, :get_bars]
 
 #### Models and Collections
 
-Models and collections have declaration semantics similar to requests.  Models and collections are enumerated via ```model``` and ```collection``` respectively.
+Models and collections have declaration semantics similar to requests.  Models and collections are enumerated via `model` and `collection` respectively.
 
     class Foo::Client < Cistern::Service
       model_path "my-foo/models"
@@ -65,7 +65,7 @@ Models and collections have declaration semantics similar to requests.  Models a
 
 #### Initialization
 
-Service initialization parameters are enumerated by ```requires``` and ```recognizes```.  ```recognizes``` parameters are optional.
+Service initialization parameters are enumerated by `requires` and `recognizes`.  `recognizes` parameters are optional.
 
     class Foo::Client < Cistern::Service
       requires :hmac_id, :hmac_secret
@@ -81,9 +81,9 @@ Service initialization parameters are enumerated by ```requires``` and ```recogn
     Foo::Client.new(hmac_id: "1")
 
 
-#### Mocking
+### Mocking
 
-Cistern strongly encourages you to generate mock support for service. Mocking can be enabled using ```mock!```.
+Cistern strongly encourages you to generate mock support for service. Mocking can be enabled using `mock!`.
 
     Foo::Client.mocking?          # falsey
     real = Foo::Client.new        # Foo::Client::Real
@@ -95,10 +95,98 @@ Cistern strongly encourages you to generate mock support for service. Mocking ca
     real.is_a?(Foo::Client::Real) # true
     fake.is_a?(Foo::Client::Mock) # true
 
+#### Data
+
+A uniform interface for mock data is mixed into the `Mock` class by default.
+
+    Foo::Client.mock!
+    client = Foo::Client.new     # Foo::Client::Mock
+    client.data                  # Cistern::Data::Hash
+    client.data["bars"] += ["x"] # ["x"]
+
+Mock data is class-level by default
+
+    Foo::Client::Mock.data["bars"] # ["x"]
+
+`reset!` dimisses the `data` object.
+
+    client.data.object_id # 70199868585600
+    client.reset!
+    client.data["bars"]   # []
+    client.data.object_id # 70199868566840
+
+`clear` removes existing keys and values but keeps the same object.
+
+    client.data["bars"] += ["y"] # ["y"]
+    client.data.object_id        # 70199868378300
+    client.clear
+    client.data["bars"]          # []
+
+    client.data.object_id        # 70199868566840
+
+* `store` and `[]=` write
+* `fetch` and `[]` read
+
+You can make the service bypass Cistern's mock data structures by simply creating a `self.data` function in your service `Mock` declaration.
+
+    class Foo::Client < Cistern::Service
+      class Mock
+        def self.data
+          @data ||= {}
+        end
+      end
+    end
+
+
+#### Requests
+
+Mock requests should be defined within the contextual `Mock` module and interact with the `data` object directly.
+
+    # lib/foo/requests/create_bar.rb
+    class Foo::Client
+      class Mock
+        def create_bar(options={})
+          id = Foo.random_hex(6)
+
+          bar = {
+            "id" => id
+          }.merge(options)
+
+          self.data[:bars][id] = bar
+
+          response(
+            :body   => {"bar" => bar},
+            :status => 201,
+            :path => '/bar',
+          )
+        end
+      end # Mock
+    end # Foo::Client
+
+
+#### Storage
+
+Currently supported storage backends are:
+
+* `:hash` : `Cistern::Data::Hash` (default)
+* `:redis` : `Cistern::Data::Redis`
+
+
+Backends can be switched by using `store_in`.
+
+    # use redis with defaults
+    Patient::Mock.store_in(:redis)
+    # use redis with a specific client
+    Patient::Mock.store_in(:redis, client: Redis::Namespace.new("cistern", redis: Redis.new(host: "10.1.0.1"))
+    # use a hash
+    Patient::Mock.store_in(:hash)
 
 ### Model
 
-```connection``` represents the associated ```Foo::Client``` instance.
+* `connection` represents the associated `Foo::Client` instance.
+* `collection` represents the related collection (if applicable)
+
+Example
 
     class Foo::Client::Bar < Cistern::Model
       identity :id
@@ -136,7 +224,7 @@ Cistern strongly encourages you to generate mock support for service. Mocking ca
 
 ### Collection
 
-```model``` tells Cistern which class is contained within the collection.  ```Cistern::Collection``` inherits from ```Array``` and lazy loads where applicable.
+`model` tells Cistern which class is contained within the collection.  `Cistern::Collection` inherits from `Array` and lazy loads where applicable.
 
     class Foo::Client::Bars < Cistern::Collection
 

data/lib/cistern/data/hash.rb

@@ -0,0 +1,38 @@
+class Cistern::Data::Hash
+  Cistern::Data.backends[:hash] = self
+
+  def initialize(options={}, &default)
+    @hash    = Hash.new
+    @default = default
+  end
+
+  def clear
+    hash.clear
+  end
+
+  def store(key, *args)
+    assign_default(key)
+
+    hash.store(key, *args)
+  end
+
+  alias []= store
+
+  def fetch(key, *args)
+    assign_default(key)
+
+    hash.fetch(key, *args)
+  end
+
+  alias [] fetch
+
+  protected
+
+  attr_reader :hash, :default
+
+  def assign_default(key)
+    if !hash.key?(key) && default
+      default.call(hash, key)
+    end
+  end
+end

data/lib/cistern/data/redis.rb

@@ -0,0 +1,54 @@
+class Cistern::Data::Redis
+  Cistern::Data.backends[:redis] = self
+
+  def self.marshal
+    @marshal ||= begin
+                   require 'multi_json'
+                   MultiJson
+                 rescue LoadError
+                   require 'json'
+                   ::JSON
+                 end
+  end
+
+  def self.marshal=(marshal)
+    @marshal = marshal
+  end
+
+  def initialize(options={}, &block)
+    @client  = options[:client] || ::Redis.new
+    @default = block
+  end
+
+  def clear
+    unless (keys = client.keys("*")).empty?
+      client.del(*keys)
+    end
+  end
+
+  def store(key, value, *args)
+    assign_default(key)
+
+    client.set(key, Cistern::Data::Redis.marshal.dump(value), *args)
+  end
+
+  alias []= store
+
+  def fetch(key, *args)
+    assign_default(key)
+
+    Cistern::Data::Redis.marshal.load(client.get(key, *args))
+  end
+
+  alias [] fetch
+
+  protected
+
+  attr_reader :client, :default
+
+  def assign_default(key)
+    if client.keys(key).empty? && default
+      default.call(client, key)
+    end
+  end
+end

data/lib/cistern/data.rb

@@ -0,0 +1,45 @@
+module Cistern::Data
+  def self.extended(klass)
+    klass.send(:extend, ClassMethods)
+    klass.send(:include, InstanceMethods)
+  end
+
+  def self.backends
+    @backends ||= {}
+  end
+
+  module ClassMethods
+    def data
+      @data ||= Cistern::Data.backends[storage].new(@options || {}) { |d,k| d[k] = [] }
+    end
+
+    def reset!
+      clear!
+      @data = nil
+    end
+
+    def clear!
+      self.data.clear
+    end
+
+    def store_in(storage, options)
+      @storage = storage
+      @options = options
+      @data = nil
+    end
+
+    def storage
+      @storage ||= :hash
+    end
+  end
+
+  module InstanceMethods
+    def data
+      self.class.data
+    end
+
+    def reset!
+      self.class.reset!
+    end
+  end
+end

data/lib/cistern/service.rb

@@ -34,9 +34,13 @@ class Cistern::Service
         end
 
         class Real
+          def initialize(options={})
+          end
         end
 
         class Mock
+          def initialize(options={})
+          end
         end
       EOS
 
@@ -44,6 +48,7 @@ class Cistern::Service
 
       klass::Mock.send(:include, klass::Collections)
       klass::Mock.send(:extend, Cistern::WaitFor)
+      klass::Mock.send(:extend, Cistern::Data)
       klass::Mock.timeout_error = klass::Timeout
       klass::Real.send(:include, klass::Collections)
       klass::Real.send(:extend, Cistern::WaitFor)
@@ -108,12 +113,15 @@ class Cistern::Service
 
     def validate_options(options={})
       required_options = Cistern::Hash.slice(options, *required_arguments)
+
       missing_required_options = required_arguments - required_options.keys
+
       unless missing_required_options.empty?
         raise "Missing required options: #{missing_required_options.inspect}"
       end
-      recognized_options = Cistern::Hash.slice(options, *(required_arguments + recognized_arguments))
+
       unrecognized_options = options.keys - (required_arguments + recognized_arguments)
+
       unless unrecognized_options.empty?
         raise "Unrecognized options: #{unrecognized_options.inspect}"
       end
@@ -132,7 +140,10 @@ class Cistern::Service
           EOS
         end
         requests.each do |request|
-          require File.join(@request_path, request.to_s)
+          unless service::Real.method_defined?(request.to_s)
+            require File.join(@request_path, request.to_s)
+          end
+
           if service::Mock.method_defined?(request)
             mocked_requests << request
           else

data/lib/cistern/version.rb

@@ -1,3 +1,3 @@
 module Cistern
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/cistern.rb

@@ -16,10 +16,13 @@ module Cistern
   require 'cistern/model'
   require 'cistern/service'
   require 'cistern/singular'
+  require 'cistern/data'
+  require 'cistern/data/hash'
+  require 'cistern/data/redis'
 
   extend WaitFor
 
-  autoload :Formatter, 'cistern/formatter'
+  require 'cistern/formatter'
 
   def self.formatter=(formatter); @formatter = formatter; end
 

data/spec/cistern_spec.rb

@@ -26,17 +26,17 @@ describe "#inspect" do
     it "should use formatador" do
       Cistern.formatter = Cistern::Formatter::Formatador
 
-      Inspector.new(id: 1, name: "name").inspect.should == %q{  <Inspector
+      expect(Inspector.new(id: 1, name: "name").inspect).to eq(%q{  <Inspector
     id=1,
     name="name"
-  >}
+  >})
     end
   end
 
   describe "Cistern::Collection" do
     it "should use formatador" do
       Cistern.formatter = Cistern::Formatter::Formatador
-      Inspectors.new.all.inspect.should == %q{  <Inspectors
+      expect(Inspectors.new.all.inspect).to eq(%q{  <Inspectors
     [
       <Inspector
         id=1,
@@ -47,12 +47,12 @@ describe "#inspect" do
         name="4"
       >
     ]
-  >}
+  >})
     end
 
     it "should use awesome_print" do
       Cistern.formatter = Cistern::Formatter::AwesomePrint
-      Inspectors.new.all.inspect.should match(/Inspectors\s+{.*}$/m) # close enough
+      expect(Inspectors.new.all.inspect).to match(/Inspectors\s+{.*}$/m) # close enough
     end
   end
 end

data/spec/collection_spec.rb

@@ -15,33 +15,33 @@ describe "Cistern::Collection" do
 
   it "should give to_s" do
     collection = SampleCollection.new
-    collection.to_s.should_not eq "[]"
-    collection.to_s.gsub(/:[^>]*/,'').should == collection.all.to_s.gsub(/:[^>]*/,'')
+    expect(collection.to_s).not_to eq "[]"
+    expect(collection.to_s.gsub(/:[^>]*/,'')).to eq(collection.all.to_s.gsub(/:[^>]*/,''))
   end
 
   it "should give size and count" do
-    SampleCollection.new.size.should == 3
-    SampleCollection.new.count.should == 3
+    expect(SampleCollection.new.size).to eq(3)
+    expect(SampleCollection.new.count).to eq(3)
   end
 
   it "should give first" do
-    SampleCollection.new.first.should == SampleCollectionModel.new(id: 1)
+    expect(SampleCollection.new.first).to eq(SampleCollectionModel.new(id: 1))
   end
 
   it "should give last" do
-    SampleCollection.new.last.should == SampleCollectionModel.new(id: 2)
+    expect(SampleCollection.new.last).to eq(SampleCollectionModel.new(id: 2))
   end
 
   it "should reject" do
-    SampleCollection.new.reject{|m| m.id == 2}.should == [SampleCollectionModel.new(id: 1), SampleCollectionModel.new(id: 3)]
+    expect(SampleCollection.new.reject{|m| m.id == 2}).to eq([SampleCollectionModel.new(id: 1), SampleCollectionModel.new(id: 3)])
   end
 
   it "should select" do
-    SampleCollection.new.select{|m| m.id == 2}.should == [SampleCollectionModel.new(id: 2)]
+    expect(SampleCollection.new.select{|m| m.id == 2}).to eq([SampleCollectionModel.new(id: 2)])
   end
 
   it "should slice" do
-    SampleCollection.new.slice(0,2).should == [SampleCollectionModel.new(id: 1), SampleCollectionModel.new(id: 3, name: "tom")]
+    expect(SampleCollection.new.slice(0,2)).to eq([SampleCollectionModel.new(id: 1), SampleCollectionModel.new(id: 3, name: "tom")])
   end
 
   it "should ==" do

data/spec/mock_data_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe 'mock data' do
+  class Patient < Cistern::Service
+    request :diagnosis
+    request :treat
+
+    class Real
+      def diagnosis(options={})
+      end
+
+      def treat(options={})
+      end
+    end
+
+    class Mock
+      def diagnosis(diagnosis)
+        #self.data[:diagnosis] << rand(2) == 0 ? "sick" : "healthy"
+        self.data.store(:diagnosis, self.data.fetch(:diagnosis) + [diagnosis])
+      end
+
+      def treat(treatment)
+        self.data[:treatments] += [treatment]
+      end
+    end
+  end
+
+  shared_examples "mock_data#backend" do |backend, options|
+    it "should store mock data" do
+      Patient.mock!
+      Patient::Mock.store_in(backend, options)
+      Patient.reset!
+
+      p = Patient.new
+      p.diagnosis("sick")
+      expect(p.data[:diagnosis]).to eq(["sick"])
+
+      p.reset!
+
+      expect(p.data[:diagnosis]).to eq([])
+
+      p.treat("healthy")
+      expect(p.data[:treatments]).to eq(["healthy"])
+
+      Patient.reset!
+
+      expect(p.data[:treatments]).to eq([])
+    end
+
+  end
+
+  context "with a storage backend" do
+    describe "Cistern::Data::Hash" do
+      include_examples "mock_data#backend", :hash
+    end
+
+    describe "Cistern::Data::Redis" do
+      include_examples "mock_data#backend", :redis
+
+      context "with an explicit client" do
+        before(:each) {
+          @other = Redis::Namespace.new("other_cistern", Redis.new)
+          @other.set("x", "y")
+        }
+
+        include_examples "mock_data#backend", :redis, client: Redis::Namespace.new("cistern", Redis.new)
+
+        after(:each) {
+          expect(@other.get("x")).to eq("y")
+          @other.del("x")
+        }
+      end
+    end
+  end
+end

data/spec/model_spec.rb

@@ -12,11 +12,11 @@ describe "Cistern::Model" do
     model = DupSpec.new(id: 1, name: "string", properties: {value: "something", else: "what"})
     duplicate = model.dup
 
-    duplicate.should == model
-    duplicate.should_not eql model
+    expect(duplicate).to eq(model)
+    expect(duplicate).not_to eql model
 
     model.name= "anotherstring"
-    duplicate.name.should == "string"
+    expect(duplicate.name).to eq("string")
   end
 
   context "attribute parsing" do
@@ -48,95 +48,95 @@ describe "Cistern::Model" do
     end
 
     it "should parse string" do
-      TypeSpec.new(name: 1).name.should == "1"
+      expect(TypeSpec.new(name: 1).name).to eq("1")
     end
 
     it "should parse time" do
       time = Time.now
       created_at = TypeSpec.new(created_at: time.to_s).created_at
-      created_at.should be_a(Time)
-      created_at.to_i.should == time.to_i
+      expect(created_at).to be_a(Time)
+      expect(created_at.to_i).to eq(time.to_i)
     end
 
     it "should parse boolean" do
-      TypeSpec.new(flag: "false").flag.should be_false
-      TypeSpec.new(flag: "true").flag.should be_true
-      TypeSpec.new(flag: false).flag.should be_false
-      TypeSpec.new(flag: true).flag.should be_true
-      TypeSpec.new(flag: "0").flag.should be_false
-      TypeSpec.new(flag: "1").flag.should be_true
-      TypeSpec.new(flag: 0).flag.should be_false
-      TypeSpec.new(flag: 1).flag.should be_true
-      TypeSpec.new(flag: false).should_not be_flag
-      TypeSpec.new(flag: true).should be_flag
+      expect(TypeSpec.new(flag: "false").flag).to be_false
+      expect(TypeSpec.new(flag: "true").flag).to be_true
+      expect(TypeSpec.new(flag: false).flag).to be_false
+      expect(TypeSpec.new(flag: true).flag).to be_true
+      expect(TypeSpec.new(flag: "0").flag).to be_false
+      expect(TypeSpec.new(flag: "1").flag).to be_true
+      expect(TypeSpec.new(flag: 0).flag).to be_false
+      expect(TypeSpec.new(flag: 1).flag).to be_true
+      expect(TypeSpec.new(flag: false)).not_to be_flag
+      expect(TypeSpec.new(flag: true)).to be_flag
     end
 
     it "should parse an array" do
-      TypeSpec.new(list: []).list.should == []
-      TypeSpec.new(list: "item").list.should == ["item"]
+      expect(TypeSpec.new(list: []).list).to eq([])
+      expect(TypeSpec.new(list: "item").list).to eq(["item"])
     end
 
     it "should parse a float" do
-      TypeSpec.new(floater: "0.01").floater.should == 0.01
-      TypeSpec.new(floater: 0.01).floater.should == 0.01
+      expect(TypeSpec.new(floater: "0.01").floater).to eq(0.01)
+      expect(TypeSpec.new(floater: 0.01).floater).to eq(0.01)
     end
 
     it "should use custom parser" do
-      TypeSpec.new(custom: "15").custom.should == "X!15"
+      expect(TypeSpec.new(custom: "15").custom).to eq("X!15")
     end
 
     it "should squash, cast, alias an attribute and keep a vanilla reference" do
       # vanilla squash
-      TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).butternut_type.should == "fred"
-      TypeSpec.new({"squash" => {"id" => "12", "type" => nil}}).butternut_type.should be_nil
-      TypeSpec.new({"squash" => nil}).butternut_type.should be_nil
+      expect(TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).butternut_type).to eq("fred")
+      expect(TypeSpec.new({"squash" => {"id" => "12", "type" => nil}}).butternut_type).to be_nil
+      expect(TypeSpec.new({"squash" => nil}).butternut_type).to be_nil
 
       # composite processors: squash and cast
-      TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).butternut_id.should == 12
-      TypeSpec.new({"squash" => {"id" => nil, "type" => "fred"}}).butternut_id.should be_nil
-      TypeSpec.new({"squash" => {"type" => "fred"}}).butternut_id.should be_nil
+      expect(TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).butternut_id).to eq(12)
+      expect(TypeSpec.new({"squash" => {"id" => nil, "type" => "fred"}}).butternut_id).to be_nil
+      expect(TypeSpec.new({"squash" => {"type" => "fred"}}).butternut_id).to be_nil
 
       # override intermediate processing
-      TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).squash.should == {"id" => "12", "type" => "fred"}
+      expect(TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).squash).to eq({"id" => "12", "type" => "fred"})
 
       # alias of override
-      TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).vegetable.should == {"id" => "12", "type" => "fred"}
+      expect(TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).vegetable).to eq({"id" => "12", "type" => "fred"})
     end
 
     it "should set a default value" do
-      TypeSpec.new.default.should == "im a squash"
+      expect(TypeSpec.new.default).to eq("im a squash")
     end
 
     it "should override a default value" do
-      TypeSpec.new(default: "now im a different squash").default.should == "now im a different squash"
+      expect(TypeSpec.new(default: "now im a different squash").default).to eq("now im a different squash")
     end
 
     context "allowing the same alias for multiple attributes" do
       it "should do so when not squashing" do
         type_spec = TypeSpec.new({"nested" => "bamboo"})
-        type_spec.same_alias_1.should == "bamboo"
-        type_spec.same_alias_2.should == "bamboo"
+        expect(type_spec.same_alias_1).to eq("bamboo")
+        expect(type_spec.same_alias_2).to eq("bamboo")
       end
 
       it "should do so when squashing" do
         type_spec = TypeSpec.new({"nested" => {"attr_1" => "bamboo", "attr_2" => "panda"}})
-        type_spec.same_alias_squashed_1.should == "bamboo"
-        type_spec.same_alias_squashed_2.should == "panda"
-        type_spec.same_alias_squashed_3.should == "panda"
+        expect(type_spec.same_alias_squashed_1).to eq("bamboo")
+        expect(type_spec.same_alias_squashed_2).to eq("panda")
+        expect(type_spec.same_alias_squashed_3).to eq("panda")
       end
     end
 
     it "should slice out unaccounted for attributes" do
-      TypeSpec.new({"something" => {"id" => "12"}}).attributes.keys.should_not include("something")
+      expect(TypeSpec.new({"something" => {"id" => "12"}}).attributes.keys).not_to include("something")
     end
 
     describe "#requires" do
       it "should raise if attribute not provided" do
-        lambda { TypeSpec.new({"connection" => "fake", "something" => {"id" => "12"}}).save }.should raise_exception(ArgumentError)
+        expect { TypeSpec.new({"connection" => "fake", "something" => {"id" => "12"}}).save }.to raise_exception(ArgumentError)
       end
 
       it "should raise if attribute is provided and is nil" do
-        lambda { TypeSpec.new({"connection" => "fake", "custom" => nil}).save }.should raise_exception(ArgumentError)
+        expect { TypeSpec.new({"connection" => "fake", "custom" => nil}).save }.to raise_exception(ArgumentError)
       end
     end
   end
@@ -153,25 +153,25 @@ describe "Cistern::Model" do
 
     before(:each) do
       CoverageSpec.attributes[:used][:coverage_hits] = 0
-      obj.used.should == "foo" # once
-      obj.used.should == "foo" # twice
+      expect(obj.used).to eq("foo") # once
+      expect(obj.used).to eq("foo") # twice
     end
 
     it "should store the file path where the attribute was defined" do
-      CoverageSpec.attributes[:used][:coverage_file].should == __FILE__
-      CoverageSpec.attributes[:unused][:coverage_file].should == __FILE__
+      expect(CoverageSpec.attributes[:used][:coverage_file]).to eq(__FILE__)
+      expect(CoverageSpec.attributes[:unused][:coverage_file]).to eq(__FILE__)
     end
 
     it "should store the line number where the attribute was defined" do
       src_lines = File.read(__FILE__).lines
 
-      src_lines[CoverageSpec.attributes[:used][:coverage_line] - 1].should match(/attribute :used/)
-      src_lines[CoverageSpec.attributes[:unused][:coverage_line] - 1].should match(/attribute :unused/)
+      expect(src_lines[CoverageSpec.attributes[:used][:coverage_line] - 1]).to match(/attribute :used/)
+      expect(src_lines[CoverageSpec.attributes[:unused][:coverage_line] - 1]).to match(/attribute :unused/)
     end
 
     it "should store how many times an attribute's reader is called" do
-      CoverageSpec.attributes[:used][:coverage_hits].should == 2
-      CoverageSpec.attributes[:unused][:coverage_hits].should == 0
+      expect(CoverageSpec.attributes[:used][:coverage_hits]).to eq(2)
+      expect(CoverageSpec.attributes[:unused][:coverage_hits]).to eq(0)
     end
   end
 end

data/spec/singular_spec.rb

@@ -16,13 +16,13 @@ describe "Cistern::Singular" do
   end
 
   it "should work" do
-    SampleSingular.new(connection: :fake).name.should == "amazing"
+    expect(SampleSingular.new(connection: :fake).name).to eq("amazing")
   end
 
   it "should reload" do
     singular = SampleSingular.new(connection: :fake)
     old_count = singular.count
-    singular.count.should == old_count
-    singular.reload.count.should > old_count
+    expect(singular.count).to eq(old_count)
+    expect(singular.reload.count).to be > old_count
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,8 @@
+if ENV["TRAVIS"]
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
 require File.expand_path('../../lib/cistern', __FILE__)
 
 Bundler.require(:test)

data/spec/wait_for_spec.rb

@@ -26,13 +26,13 @@ end
 
 describe 'Cistern#wait_for' do
   it "should return false if timeout exceeded" do
-    Cistern.wait_for(0, 0) { false }.should be_false
+    expect(Cistern.wait_for(0, 0) { false }).to be_false
   end
 end
 
 describe 'Cistern#wait_for!' do
   it "should raise if timeout exceeded" do
-    lambda { Cistern.wait_for!(0, 0) { false } }.should raise_exception(Cistern::Timeout)
+    expect { Cistern.wait_for!(0, 0) { false } }.to raise_exception(Cistern::Timeout)
   end
 end
 
@@ -41,7 +41,7 @@ describe 'Cistern::Model#wait_for!' do
   let(:model)   { service.wait_for_models.new(identity: 1) }
 
   it "should raise if timeout exceeded" do
-    lambda { model.wait_for!(0, 0) { false } }.should raise_exception(WaitForService::Timeout)
+    expect { model.wait_for!(0, 0) { false } }.to raise_exception(WaitForService::Timeout)
   end
 end
 
@@ -57,9 +57,9 @@ describe "WaitForModel#timeout" do
     elapsed = 0
 
     timeout(2) do
-      lambda do
+      expect do
         model.wait_for! { sleep(0.2); elapsed += 0.2; elapsed > 0.2 }
-      end.should raise_exception(WaitForService::Timeout)
+      end.to raise_exception(WaitForService::Timeout)
     end
   end
 
@@ -70,9 +70,9 @@ describe "WaitForModel#timeout" do
     elapsed = 0
 
     timeout(2) do
-      lambda do
+      expect do
         model.wait_for!(0.1) { sleep(0.2); elapsed += 0.2; elapsed > 0.2 }
-      end.should raise_exception(WaitForService::Timeout)
+      end.to raise_exception(WaitForService::Timeout)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cistern
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Josh Lane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-29 00:00:00.000000000 Z
+date: 2014-05-15 00:00:00.000000000 Z
 dependencies: []
 description: API client framework extracted from Fog
 email:
@@ -30,6 +30,9 @@ files:
 - lib/cistern/attributes.rb
 - lib/cistern/collection.rb
 - lib/cistern/coverage.rb
+- lib/cistern/data.rb
+- lib/cistern/data/hash.rb
+- lib/cistern/data/redis.rb
 - lib/cistern/formatter.rb
 - lib/cistern/formatter/awesome_print.rb
 - lib/cistern/formatter/formatador.rb
@@ -43,6 +46,7 @@ files:
 - lib/cistern/wait_for.rb
 - spec/cistern_spec.rb
 - spec/collection_spec.rb
+- spec/mock_data_spec.rb
 - spec/model_spec.rb
 - spec/singular_spec.rb
 - spec/spec_helper.rb
@@ -74,6 +78,7 @@ summary: API client framework
 test_files:
 - spec/cistern_spec.rb
 - spec/collection_spec.rb
+- spec/mock_data_spec.rb
 - spec/model_spec.rb
 - spec/singular_spec.rb
 - spec/spec_helper.rb