cistern 2.4.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d74b41f098f699d93b5d42a8cc0915ac2169162
-  data.tar.gz: 1171cb486f3155fb05faf470bad810349d3a7a36
+  metadata.gz: 51b4a1fc74578d0a0a8f89bb9b041501ab850ac9
+  data.tar.gz: 3f24e1b8145497a84d6f6b0fa449aa11b7d5e7f1
 SHA512:
-  metadata.gz: 697575fd1b7a88143f1c6ed754ed38fc1813584e2bf22faa324499f3eb8ae503cb02413c799aa14bafc5f9b97af44c721aaf03cafe9ae9502af78337edffbb60
-  data.tar.gz: 285daf44f8c9048ed45321c9c270c2be04c0a5d181ef867c8aee5a1a421b81e0ce231e3d535c522ba9f9e4f9ae54d93bba15ccda689306a3c9651af1414128c0
+  metadata.gz: 2f7a72df05bb6c95d5176a36b8e8d0d17f9c9bd3179cec7424e4fc66e216e24f148bff977e4ba19f1bcee0d5afad60757e193a83bf926401a9d40be70e75a223
+  data.tar.gz: f2221f974e0817e5410e88a8d4586f28881756fcbea1836e52d8440ec97f50dfe689ae3758820e1225c2de006bfcfb0dbc0065ab70cbc0980fc2fda2f8a96b78

data/CHANGELOG.md

@@ -2,7 +2,14 @@
 
 ## [Unreleased](https://github.com/lanej/cistern/tree/HEAD)
 
-[Full Changelog](https://github.com/lanej/cistern/compare/v2.4.0...HEAD)
+[Full Changelog](https://github.com/lanej/cistern/compare/v2.4.1...HEAD)
+
+**Implemented enhancements:**
+
+- add request\_attributes, dirty\_request\_attributes helpers [\#65](https://github.com/lanej/cistern/pull/65) ([lanej](https://github.com/lanej))
+
+## [v2.4.1](https://github.com/lanej/cistern/tree/v2.4.1) (2016-07-16)
+[Full Changelog](https://github.com/lanej/cistern/compare/v2.4.0...v2.4.1)
 
 **Merged pull requests:**
 

data/lib/cistern/attributes.rb

@@ -265,6 +265,18 @@ module Cistern::Attributes
       @changes ||= {}
     end
 
+    def request_attributes(set = attributes)
+      set.inject({}) do |a,(k,v)|
+        aliases = self.class.attributes[k.to_sym][:aliases]
+        aliases << k if aliases.empty?
+        aliases.each_with_object(a) { |n,r| r[n.to_s] = v }
+      end
+    end
+
+    def dirty_request_attributes
+      request_attributes(dirty_attributes)
+    end
+
     private
 
     def missing_attributes(keys)

data/lib/cistern/version.rb

@@ -1,3 +1,3 @@
 module Cistern
-  VERSION = '2.4.1'
+  VERSION = '2.5.0'
 end

data/spec/attributes_spec.rb

@@ -1,166 +1,260 @@
 require 'spec_helper'
 
-describe Cistern::Attributes, 'requires' do
-  class RequireSpec < Sample::Model
-    identity :id
-    attribute :name, type: :string
-    attribute :type
+describe Cistern::Attributes, '#request_attributes' do
+  subject { Class.new(Sample::Model) }
+
+  it 'returns a reverse-aliased attributes hash' do
+    subject.class_eval do
+      identity :id
+      attribute :name, alias: 'sample_name'
+    end
+
+    model = subject.new(name: 'steve', id: 1)
+
+    expect(model.request_attributes).to eq(
+      'sample_name' => 'steve',
+      'id' => 1
+    )
+  end
+
+  it 'drops duplicates values for multiple aliases' do
+    subject.class_eval do
+      identity :id
+      attribute :name, aliases: ['sample_name', 'other_name']
+    end
+
+    model = subject.new(name: 'steve', id: 1)
+
+    expect(model.request_attributes).to eq(
+      'sample_name' => 'steve',
+      'other_name' => 'steve',
+      'id' => 1
+    )
+  end
+end
+
+describe Cistern::Attributes, '#dirty_request_attributes' do
+  subject { Class.new(Sample::Model) }
+
+  it 'returns a reverse-aliased attributes hash of dirty attributes only' do
+    subject.class_eval do
+      identity :id
+      attribute :name, alias: 'sample_name'
+    end
+
+    model = subject.new
+    model.merge_attributes(name: 'steve', id: 1)
+
+    model.name = 'bob'
+
+    expect(model.dirty_request_attributes).to eq(
+      'sample_name' => 'bob',
+    )
+  end
+
+  it 'drops duplicates values for multiple aliases' do
+    subject.class_eval do
+      identity :id
+      attribute :name, aliases: ['sample_name', 'other_name']
+    end
+
+    model = subject.new(name: 'steve', id: 1)
+
+    expect(model.request_attributes).to eq(
+      'sample_name' => 'steve',
+      'other_name' => 'steve',
+      'id' => 1
+    )
   end
+end
+
+describe Cistern::Attributes, 'requires' do
+  subject {
+    Class.new(Sample::Model) do
+      identity :id
+      attribute :name, type: :string
+      attribute :type
+    end
+  }
 
   it 'raises if required attributes are not present' do
     expect {
-      Sample.new.require_spec.requires :name
+      subject.new.requires :name
     }.to raise_exception(ArgumentError, /name is required/)
 
     data = { name: '1' }
-    return_value = Sample.new.require_spec(data).requires :name
+    return_value = subject.new(data).requires :name
 
     expect(return_value).to eq(data)
 
     expect {
-      Sample.new.require_spec.requires :name, :type
+      subject.new.requires :name, :type
     }.to raise_exception(ArgumentError, /name and type are required/)
 
     data = { name: '1', type: 'sample' }
-    return_values = Sample.new.require_spec(data).requires :name, :type
+    return_values = subject.new(data).requires :name, :type
     expect(return_values).to eq(data)
   end
 
   it 'raises if a required attribute attribute is not present' do
     expect {
-      Sample.new.require_spec.requires_one :name, :type
+      subject.new.requires_one :name, :type
     }.to raise_exception(ArgumentError, /name or type are required/)
 
     data = { name: '1' }
-    return_value = Sample.new.require_spec(data).requires_one :name, :type
+    return_value = subject.new(data).requires_one :name, :type
 
     expect(return_value).to eq(data)
 
     data = { name: '1', type: 'sample' }
-    return_values = Sample.new.require_spec(data).requires_one :name, :type
+    return_values = subject.new(data).requires_one :name, :type
     expect(return_values).to eq(data)
   end
 end
 
 describe Cistern::Attributes, 'parsing' do
-  class TypeSpec < Sample::Model
-    identity :id
-    attribute :name, type: :string
-    attribute :created_at, type: :time
-    attribute :flag, type: :boolean
-    attribute :list, type: :array
-    attribute :number, type: :integer
-    attribute :floater, type: :float
-    attribute :butternut_id, squash: %w(squash id), type: :integer
-    attribute :butternut_type, squash: %w(squash type)
-    attribute :squash
-    attribute :vegetable, aliases: 'squash'
-    attribute :custom, parser: lambda { |v, _| "X!#{v}" }
-    attribute :default, default: 'im a squash'
-    attribute :string_allow_nil, type: :string, allow_nil: true
-
-    attribute :same_alias_1, aliases: 'nested'
-    attribute :same_alias_2, aliases: 'nested'
-
-    attribute :same_alias_squashed_1, squash: %w(nested attr_1)
-    attribute :same_alias_squashed_2, squash: %w(nested attr_2)
-    attribute :same_alias_squashed_3, squash: %w(nested attr_2)
-    attribute :adam_attributes, aliases: 'attributes'
-
-    def save
-      requires :flag
-    end
-  end
+  subject {
+    Class.new(Sample::Model)
+  }
 
   it 'should parse string' do
-    expect(TypeSpec.new(name: 1).name).to eq('1')
-    expect(TypeSpec.new(name: "b").name).to eq('b')
-    expect(TypeSpec.new(name: nil).name).to eq(nil)
-  end
+    subject.class_eval do
+      attribute :name, type: :string
+    end
 
-  it 'should allow nils in string types' do
-    expect(TypeSpec.new(string_allow_nil: nil).string_allow_nil).to eq(nil)
+    expect(subject.new(name: 1).name).to eq('1')
+    expect(subject.new(name: "b").name).to eq('b')
+    expect(subject.new(name: nil).name).to eq(nil)
   end
+
   it "should handle a 'attributes' aliased attribute" do
-    expect(TypeSpec.new(attributes: 'x').adam_attributes).to eq('x')
+    subject.class_eval do
+      attribute :adam_attributes, aliases: 'attributes'
+    end
+    expect(subject.new(attributes: 'x').adam_attributes).to eq('x')
   end
 
   it 'should parse time' do
+    subject.class_eval do
+      attribute :created_at, type: :time
+    end
+
     time = Time.now
-    created_at = TypeSpec.new(created_at: time.to_s).created_at
+    created_at = subject.new(created_at: time.to_s).created_at
     expect(created_at).to be_a(Time)
     expect(created_at.to_i).to eq(time.to_i)
   end
 
   it 'should parse boolean' do
-    expect(TypeSpec.new(flag: 'false').flag).to be_falsey
-    expect(TypeSpec.new(flag: 'true').flag).to be_truthy
-    expect(TypeSpec.new(flag: false).flag).to be_falsey
-    expect(TypeSpec.new(flag: true).flag).to be_truthy
-    expect(TypeSpec.new(flag: '0').flag).to be_falsey
-    expect(TypeSpec.new(flag: '1').flag).to be_truthy
-    expect(TypeSpec.new(flag: 0).flag).to be_falsey
-    expect(TypeSpec.new(flag: 1).flag).to be_truthy
-    expect(TypeSpec.new(flag: false)).not_to be_flag
-    expect(TypeSpec.new(flag: true)).to be_flag
+    subject.class_eval do
+      attribute :flag, type: :boolean
+    end
+
+    ['false', false, '0', 0].each do |falsey|
+      expect(subject.new(flag: falsey).flag).to be_falsey
+    end
+
+    ['true', true, '1', 1].each do |truthy|
+      expect(subject.new(flag: truthy).flag).to be_truthy
+    end
   end
 
   it 'should parse an array' do
-    expect(TypeSpec.new(list: []).list).to eq([])
-    expect(TypeSpec.new(list: 'item').list).to eq(['item'])
+    subject.class_eval do
+      attribute :list, type: :array
+    end
+
+    expect(subject.new(list: []).list).to eq([])
+    expect(subject.new(list: 'item').list).to eq(['item'])
   end
 
   it 'should parse a float' do
-    expect(TypeSpec.new(floater: '0.01').floater).to eq(0.01)
-    expect(TypeSpec.new(floater: 0.01).floater).to eq(0.01)
+    subject.class_eval do
+      attribute :floater, type: :float
+    end
+
+    expect(subject.new(floater: '0.01').floater).to eq(0.01)
+    expect(subject.new(floater: 0.01).floater).to eq(0.01)
   end
 
   it 'should use custom parser' do
-    expect(TypeSpec.new(custom: '15').custom).to eq('X!15')
+    subject.class_eval do
+      attribute :custom, parser: lambda { |v, _| "X!#{v}" }
+    end
+
+    expect(subject.new(custom: '15').custom).to eq('X!15')
   end
 
-  it 'should squash, cast, alias an attribute and keep a vanilla reference' do
+  it 'squashes, casts and aliases an attribute and keeps a vanilla reference' do
+    subject.class_eval do
+      attribute :butternut_id, squash: %w(squash id), type: :integer
+      attribute :butternut_type, squash: %w(squash type)
+      attribute :squash
+      attribute :vegetable, aliases: 'squash'
+    end
+
     # vanilla squash
-    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
+    expect(subject.new({ 'squash' => { 'id' => '12', 'type' => 'fred' } }).butternut_type).to eq('fred')
+    expect(subject.new({ 'squash' => { 'id' => '12', 'type' => nil } }).butternut_type).to be_nil
+    expect(subject.new({ 'squash' => nil }).butternut_type).to be_nil
 
     # composite processors: squash and cast
-    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
+    expect(subject.new({ 'squash' => { 'id' => '12', 'type' => 'fred' } }).butternut_id).to eq(12)
+    expect(subject.new({ 'squash' => { 'id' => nil, 'type' => 'fred' } }).butternut_id).to be_nil
+    expect(subject.new({ 'squash' => { 'type' => 'fred' } }).butternut_id).to be_nil
 
     # override intermediate processing
-    expect(TypeSpec.new({ 'squash' => { 'id' => '12', 'type' => 'fred' } }).squash).to eq({ 'id' => '12', 'type' => 'fred' })
+    expect(subject.new({ 'squash' => { 'id' => '12', 'type' => 'fred' } }).squash).to eq({ 'id' => '12', 'type' => 'fred' })
 
     # alias of override
-    expect(TypeSpec.new({ 'squash' => { 'id' => '12', 'type' => 'fred' } }).vegetable).to eq({ 'id' => '12', 'type' => 'fred' })
+    expect(subject.new({ 'squash' => { 'id' => '12', 'type' => 'fred' } }).vegetable).to eq({ 'id' => '12', 'type' => 'fred' })
   end
 
-  it 'should set a default value' do
-    expect(TypeSpec.new.default).to eq('im a squash')
+  it 'sets a default value' do
+    subject.class_eval do
+      attribute :default, default: 'im a squash'
+    end
+
+    expect(subject.new.default).to eq('im a squash')
   end
 
   it 'should override a default value' do
-    expect(TypeSpec.new(default: 'now im a different squash').default).to eq('now im a different squash')
+    subject.class_eval do
+      attribute :default, default: 'im a squash'
+    end
+
+    expect(subject.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
+    before {
+      subject.class_eval do
+        attribute :same_alias_1, aliases: 'nested'
+        attribute :same_alias_2, aliases: 'nested'
+
+        attribute :same_alias_squashed_1, squash: %w(nested attr_1)
+        attribute :same_alias_squashed_2, squash: %w(nested attr_2)
+        attribute :same_alias_squashed_3, squash: %w(nested attr_2)
+      end
+    }
+
     it 'should do so when not squashing' do
-      type_spec = TypeSpec.new({ 'nested' => 'bamboo' })
-      expect(type_spec.same_alias_1).to eq('bamboo')
-      expect(type_spec.same_alias_2).to eq('bamboo')
+      model = subject.new('nested' => 'bamboo')
+
+      expect(model.same_alias_1).to eq('bamboo')
+      expect(model.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' } })
-      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')
+      model = subject.new('nested' => { 'attr_1' => 'bamboo', 'attr_2' => 'panda' })
+
+      expect(model.same_alias_squashed_1).to eq('bamboo')
+      expect(model.same_alias_squashed_2).to eq('panda')
+      expect(model.same_alias_squashed_3).to eq('panda')
     end
   end
 
   it 'should slice out unaccounted for attributes' do
-    expect(TypeSpec.new({ 'something' => { 'id' => '12' } }).attributes.keys).not_to include('something')
+    expect(subject.new({ 'something' => { 'id' => '12' } }).attributes.keys).not_to include('something')
   end
 end

data/spec/coverage_spec.rb

@@ -1,35 +1,39 @@
 require 'spec_helper'
 
 describe 'coverage', :coverage do
-  class CoverageSpec < Sample::Model
-    identity :id
+  subject {
+    class Sample::Coverage < Sample::Model
+      identity :id
 
-    attribute :used, type: :string
-    attribute :unused, type: :string
-  end
+      attribute :used, type: :string
+      attribute :unused, type: :string
+    end
+
+    Sample::Coverage
+  }
 
-  let!(:obj) { CoverageSpec.new(used: 'foo', unused: 'bar') }
+  let!(:model) { subject.new(used: 'foo', unused: 'bar') }
 
   before(:each) do
-    CoverageSpec.attributes[:used][:coverage_hits] = 0
-    expect(obj.used).to eq('foo') # once
-    expect(obj.used).to eq('foo') # twice
+    subject.attributes[:used][:coverage_hits] = 0
+    expect(model.used).to eq('foo') # once
+    expect(model.used).to eq('foo') # twice
   end
 
   it 'should store the file path where the attribute was defined' do
-    expect(CoverageSpec.attributes[:used][:coverage_file]).to eq(__FILE__)
-    expect(CoverageSpec.attributes[:unused][:coverage_file]).to eq(__FILE__)
+    expect(subject.attributes[:used][:coverage_file]).to eq(__FILE__)
+    expect(subject.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
 
-    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/)
+    expect(src_lines[subject.attributes[:used][:coverage_line] - 1]).to match(/attribute :used/)
+    expect(src_lines[subject.attributes[:unused][:coverage_line] - 1]).to match(/attribute :unused/)
   end
 
   it "should store how many times an attribute's reader is called" do
-    expect(CoverageSpec.attributes[:used][:coverage_hits]).to eq(2)
-    expect(CoverageSpec.attributes[:unused][:coverage_hits]).to eq(3)
+    expect(subject.attributes[:used][:coverage_hits]).to eq(2)
+    expect(subject.attributes[:unused][:coverage_hits]).to eq(1)
   end
 end

data/spec/dirty_spec.rb

@@ -1,19 +1,21 @@
 require 'spec_helper'
 
 describe 'Cistern::Model#dirty' do
-  class DirtySpec < Sample::Model
-    identity :id
+  subject {
+    Class.new(Sample::Model) do
+      identity :id
 
-    attribute :name
-    attribute :properties, type: :array
+      attribute :name
+      attribute :properties, type: :array
 
-    def save
-      merge_attributes(attributes)
+      def save
+        merge_attributes(attributes)
+      end
     end
-  end
+  }
 
   it 'should mark a existing record as dirty' do
-    model = DirtySpec.new(id: 1, name: 'steve')
+    model = subject.new(id: 1, name: 'steve')
     expect(model.changed).to be_empty
 
     expect do

data/spec/mock_data_spec.rb

@@ -1,23 +1,25 @@
 require 'spec_helper'
 
 describe 'mock data' do
-  class Diagnosis < Sample::Request
-    def real(diagnosis)
-    end
+  before {
+    class Sample::Diagnosis < Sample::Request
+      def real(diagnosis)
+      end
 
-    def mock(diagnosis)
-      cistern.data.store(:diagnosis, cistern.data.fetch(:diagnosis) + [diagnosis])
+      def mock(diagnosis)
+        cistern.data.store(:diagnosis, cistern.data.fetch(:diagnosis) + [diagnosis])
+      end
     end
-  end
 
-  class Treat < Sample::Request
-    def real(treatment)
-    end
+    class Sample::Treat < Sample::Request
+      def real(treatment)
+      end
 
-    def mock(treatment)
-      cistern.data[:treatments] += [treatment]
+      def mock(treatment)
+        cistern.data[:treatments] += [treatment]
+      end
     end
-  end
+  }
 
   shared_examples 'mock_data#backend' do |backend, options|
     it 'should store mock data' do

data/spec/singular_spec.rb

@@ -1,24 +1,26 @@
 require 'spec_helper'
 
 describe 'Cistern::Singular' do
-  class Settings < Sample::Singular
-    attribute :name, type: :string
-    attribute :count, type: :number
+  before {
+    class Sample::Settings < Sample::Singular
+      attribute :name, type: :string
+      attribute :count, type: :number
 
-    def save
-      result = @@settings = attributes.merge(dirty_attributes)
+      def save
+        result = @@settings = attributes.merge(dirty_attributes)
 
-      merge_attributes(result)
-    end
+        merge_attributes(result)
+      end
 
-    def get
-      settings = @@settings ||= {}
-      settings[:count] ||= 0
-      settings[:count] += 1
+      def get
+        settings = @@settings ||= {}
+        settings[:count] ||= 0
+        settings[:count] += 1
 
-      merge_attributes(settings)
+        merge_attributes(settings)
+      end
     end
-  end
+  }
 
   let!(:service) { Sample.new }
 

data/spec/support/service.rb

@@ -1 +1,8 @@
+RSpec.configure do |config|
+  config.before(:each) {
+    Object.send(:remove_const, :Sample) if Object.constants.include?(:Sample)
+    class Sample; include Cistern::Client; end
+  }
+end
+
 class Sample; include Cistern::Client; end

data/spec/wait_for_spec.rb

@@ -1,67 +1,70 @@
 require 'spec_helper'
 
-class WaitForModel < Sample::Model
-  identity :id
+describe 'Cistern::WaitFor' do
+  let(:service) { Sample.new }
+  before {
+    class Sample::Wait < Sample::Model
+      identity :id
 
-  attribute :name
-end
+      attribute :name
+    end
 
-class WaitForModels < Sample::Collection
-  model WaitForModel
+    class Sample::Waits < Sample::Collection
+      model Sample::Wait
 
-  def get(_identity)
-    self
-  end
-end
+      def get(_identity)
+        self
+      end
+    end
+  }
 
-describe 'Cistern#wait_for' do
-  it 'should return false if timeout exceeded' do
-    expect(Cistern.wait_for(0, 0) { false }).to be_falsey
+  describe 'Cistern#wait_for' do
+    it 'should return false if timeout exceeded' do
+      expect(Cistern.wait_for(0, 0) { false }).to be_falsey
+    end
   end
-end
 
-describe 'Cistern#wait_for!' do
-  it 'should raise if timeout exceeded' do
-    expect { Cistern.wait_for!(0, 0) { false } }.to raise_exception(Cistern::Timeout)
+  describe 'Cistern#wait_for!' do
+    it 'should raise if timeout exceeded' do
+      expect { Cistern.wait_for!(0, 0) { false } }.to raise_exception(Cistern::Timeout)
+    end
   end
-end
 
-describe 'Cistern::Model#wait_for!' do
-  let(:service) { Sample.new }
-  let(:model)   { service.wait_for_models.new(identity: 1) }
+  describe 'Cistern::Model#wait_for!' do
+    let(:model) { service.waits.new(identity: 1) }
 
-  it 'should raise if timeout exceeded' do
-    expect { model.wait_for!(0, 0) { false } }.to raise_exception(Sample::Timeout)
+    it 'should raise if timeout exceeded' do
+      expect { model.wait_for!(0, 0) { false } }.to raise_exception(Sample::Timeout)
+    end
   end
-end
 
-describe 'WaitForModel#timeout' do
-  let(:service) { Sample.new }
-  let(:model)   { service.wait_for_models.new(identity: 1) }
+  describe 'WaitForModel#timeout' do
+    let(:model) { service.waits.new(identity: 1) }
 
-  it 'should use service-specific timeout in #wait_for' do
-    service.class.timeout = 0.1
-    service.class.poll_interval = 0
+    it 'should use service-specific timeout in #wait_for' do
+      service.class.timeout = 0.1
+      service.class.poll_interval = 0
 
-    elapsed = 0
+      elapsed = 0
 
-    Timeout.timeout(2) do
-      expect do
-        model.wait_for! { sleep(0.2); elapsed += 0.2; elapsed > 0.2 }
-      end.to raise_exception(Sample::Timeout)
+      Timeout.timeout(2) do
+        expect do
+          model.wait_for! { sleep(0.2); elapsed += 0.2; elapsed > 0.2 }
+        end.to raise_exception(Sample::Timeout)
+      end
     end
-  end
 
-  it 'should favor explicit timeout' do
-    service.class.timeout = 1
-    service.class.poll_interval = 0
+    it 'should favor explicit timeout' do
+      service.class.timeout = 1
+      service.class.poll_interval = 0
 
-    elapsed = 0
+      elapsed = 0
 
-    Timeout.timeout(2) do
-      expect do
-        model.wait_for!(0.1) { sleep(0.2); elapsed += 0.2; elapsed > 0.2 }
-      end.to raise_exception(Sample::Timeout)
+      Timeout.timeout(2) do
+        expect do
+          model.wait_for!(0.1) { sleep(0.2); elapsed += 0.2; elapsed > 0.2 }
+        end.to raise_exception(Sample::Timeout)
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cistern
 version: !ruby/object:Gem::Version
-  version: 2.4.1
+  version: 2.5.0
 platform: ruby
 authors:
 - Josh Lane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-16 00:00:00.000000000 Z
+date: 2016-07-19 00:00:00.000000000 Z
 dependencies: []
 description: API client framework extracted from Fog
 email: