cistern 2.2.3 → 2.2.4

data/spec/model_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe "Cistern::Model" do
-  describe "#update" do
+describe 'Cistern::Model' do
+  describe '#update' do
     class UpdateSpec < Sample::Model
       identity :id
       attribute :name
@@ -12,22 +12,22 @@ describe "Cistern::Model" do
       end
     end
 
-    it "should merge and save attributes" do
-      model = UpdateSpec.new(name: "steve")
+    it 'should merge and save attributes' do
+      model = UpdateSpec.new(name: 'steve')
       model.save
 
-      expect(model.update(name: "karen")).to eq(name: "karen")
+      expect(model.update(name: 'karen')).to eq(name: 'karen')
     end
   end
 
-  context "#new_record?" do
-    it "does not require identity" do
+  context '#new_record?' do
+    it 'does not require identity' do
       identity_less = Class.new(Sample::Model)
 
       expect(identity_less.new.new_record?).to eq(true)
     end
 
-    it "is false if identity is set" do
+    it 'is false if identity is set' do
       identity_full = Class.new(Sample::Model) {
         identity :id
       }
@@ -37,7 +37,7 @@ describe "Cistern::Model" do
     end
   end
 
-  it "should set singular resource service method" do
+  it 'should set singular resource service method' do
     class ModelService
       include Cistern::Client
     end
@@ -49,7 +49,7 @@ describe "Cistern::Model" do
     expect(ModelService.new.jimbob).to be_a(ModelService::Jimbob)
   end
 
-  it "should set specific singular resource service method" do
+  it 'should set specific singular resource service method' do
     class SpecificModelService
       include Cistern::Client
     end
@@ -63,24 +63,24 @@ describe "Cistern::Model" do
     expect(SpecificModelService.new.john_boy).to be_a(SpecificModelService::Jimbob)
   end
 
-  it "should duplicate a model" do
+  it 'should duplicate a model' do
     class DupSpec < Sample::Model
       identity :id
       attribute :name
       attribute :properties
     end
 
-    model = DupSpec.new(id: 1, name: "string", properties: {value: "something", else: "what"})
+    model = DupSpec.new(id: 1, name: 'string', properties: { value: 'something', else: 'what' })
     duplicate = model.dup
 
     expect(duplicate).to eq(model)
     expect(duplicate).to eql(model)
 
-    model.name = "anotherstring"
-    expect(duplicate.name).to eq("string")
+    model.name = 'anotherstring'
+    expect(duplicate.name).to eq('string')
   end
 
-  context "attribute parsing" do
+  context 'attribute parsing' do
     class TypeSpec < Sample::Model
       identity :id
       attribute :name, type: :string
@@ -89,125 +89,125 @@ describe "Cistern::Model" do
       attribute :list, type: :array
       attribute :number, type: :integer
       attribute :floater, type: :float
-      attribute :butternut_id, squash: ["squash", "id"], type: :integer
-      attribute :butternut_type, squash: ["squash", "type"]
+      attribute :butternut_id, squash: %w(squash id), type: :integer
+      attribute :butternut_type, squash: %w(squash type)
       attribute :squash
-      attribute :vegetable, aliases: "squash"
+      attribute :vegetable, aliases: 'squash'
       attribute :custom, parser: lambda { |v, _| "X!#{v}" }
-      attribute :default, default: "im a squash"
+      attribute :default, default: 'im a squash'
 
-      attribute :same_alias_1, aliases: "nested"
-      attribute :same_alias_2, aliases: "nested"
+      attribute :same_alias_1, aliases: 'nested'
+      attribute :same_alias_2, aliases: 'nested'
 
-      attribute :same_alias_squashed_1, squash: ["nested", "attr_1"]
-      attribute :same_alias_squashed_2, squash: ["nested", "attr_2"]
-      attribute :same_alias_squashed_3, squash: ["nested", "attr_2"]
-      attribute :adam_attributes, aliases: "attributes"
+      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
 
-    it "should parse string" do
-      expect(TypeSpec.new(name: 1).name).to eq("1")
+    it 'should parse string' do
+      expect(TypeSpec.new(name: 1).name).to eq('1')
     end
 
     it "should handle a 'attributes' aliased attribute" do
-      expect(TypeSpec.new(attributes: "x").adam_attributes).to eq("x")
+      expect(TypeSpec.new(attributes: 'x').adam_attributes).to eq('x')
     end
 
-    it "should parse time" do
+    it 'should parse time' do
       time = Time.now
       created_at = TypeSpec.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
+    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: 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
     end
 
-    it "should parse an array" do
+    it 'should parse an array' do
       expect(TypeSpec.new(list: []).list).to eq([])
-      expect(TypeSpec.new(list: "item").list).to eq(["item"])
+      expect(TypeSpec.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)
+    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)
     end
 
-    it "should use custom parser" do
-      expect(TypeSpec.new(custom: "15").custom).to eq("X!15")
+    it 'should use custom parser' do
+      expect(TypeSpec.new(custom: '15').custom).to eq('X!15')
     end
 
-    it "should squash, cast, alias an attribute and keep a vanilla reference" do
+    it 'should squash, cast, alias an attribute and keep a vanilla reference' do
       # 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(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
-      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(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
-      expect(TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).squash).to eq({"id" => "12", "type" => "fred"})
+      expect(TypeSpec.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(TypeSpec.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 'should set a default value' do
+      expect(TypeSpec.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")
+    it 'should override a default value' do
+      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"})
-        expect(type_spec.same_alias_1).to eq("bamboo")
-        expect(type_spec.same_alias_2).to eq("bamboo")
+    context 'allowing the same alias for multiple attributes' do
+      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')
       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")
+      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')
       end
     end
 
-    it "should slice out unaccounted for attributes" do
-      expect(TypeSpec.new({"something" => {"id" => "12"}}).attributes.keys).not_to include("something")
+    it 'should slice out unaccounted for attributes' do
+      expect(TypeSpec.new({ 'something' => { 'id' => '12' } }).attributes.keys).not_to include('something')
     end
 
-    describe "#requires" do
-      it "should raise if attribute not provided" do
-        expect { TypeSpec.new({"service" => "fake", "something" => {"id" => "12"}}).save }.to raise_exception(ArgumentError)
+    describe '#requires' do
+      it 'should raise if attribute not provided' do
+        expect { TypeSpec.new({ 'service' => 'fake', 'something' => { 'id' => '12' } }).save }.to raise_exception(ArgumentError)
       end
 
-      it "should raise if attribute is provided and is nil" do
-        expect { TypeSpec.new({"service" => "fake", "custom" => nil}).save }.to raise_exception(ArgumentError)
+      it 'should raise if attribute is provided and is nil' do
+        expect { TypeSpec.new({ 'service' => 'fake', 'custom' => nil }).save }.to raise_exception(ArgumentError)
       end
     end
   end
 
-  context "attribute coverage info collecting", :coverage do
+  context 'attribute coverage info collecting', :coverage do
     class CoverageSpec < Sample::Model
       identity :id
 
@@ -215,20 +215,20 @@ describe "Cistern::Model" do
       attribute :unused, type: :string
     end
 
-    let!(:obj) { CoverageSpec.new(used: "foo", unused: "bar") }
+    let!(:obj) { CoverageSpec.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
+      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
+    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__)
     end
 
-    it "should store the line number where the attribute was defined" do
+    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/)

data/spec/request_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Cistern::Request" do
+describe 'Cistern::Request' do
   class SampleService < Cistern::Service
     recognizes :key
 
@@ -18,20 +18,20 @@ describe "Cistern::Request" do
     service_method :list_all_samples
 
     def real(*args)
-      service.service_args + args + ["real"]
+      service.service_args + args + ['real']
     end
 
     def mock(*args)
-      args + ["mock"]
+      args + ['mock']
     end
   end
 
-  it "should execute a new-style request" do
-    expect(SampleService.new.list_all_samples("sample1")).to eq([{}, "sample1", "real"])
-    expect(SampleService::Real.new.list_all_samples("sample2")).to eq(["sample2", "real"])
-    expect(SampleService::Mock.new.list_all_samples("sample3")).to eq(["sample3", "mock"])
+  it 'should execute a new-style request' do
+    expect(SampleService.new.list_all_samples('sample1')).to eq([{}, 'sample1', 'real'])
+    expect(SampleService::Real.new.list_all_samples('sample2')).to eq(%w(sample2 real))
+    expect(SampleService::Mock.new.list_all_samples('sample3')).to eq(%w(sample3 mock))
 
     # service access
-    expect(SampleService.new(:key => "value").list_all_samples("stat")).to eq([{:key => "value"}, "stat", "real"])
+    expect(SampleService.new(key: 'value').list_all_samples('stat')).to eq([{ key: 'value' }, 'stat', 'real'])
   end
 end

data/spec/singular_spec.rb

@@ -1,26 +1,25 @@
 require 'spec_helper'
 
-describe "Cistern::Singular" do
+describe 'Cistern::Singular' do
   class SampleSingular < Sample::Singular
-
     attribute :name
     attribute :count, type: :number
 
     def fetch_attributes
-      #test that initialize waits for service to be defined
-      raise "missing service" unless service
+      # test that initialize waits for service to be defined
+      fail 'missing service' unless service
 
       @counter ||= 0
       @counter += 1
-      {name: "amazing", count: @counter}
+      { name: 'amazing', count: @counter }
     end
   end
 
-  it "should work" do
-    expect(Sample.new.sample_singular.name).to eq("amazing")
+  it 'should work' do
+    expect(Sample.new.sample_singular.name).to eq('amazing')
   end
 
-  it "should reload" do
+  it 'should reload' do
     singular = Sample.new.sample_singular
     old_count = singular.count
     expect(singular.count).to eq(old_count)

data/spec/spec_helper.rb

@@ -1,10 +1,10 @@
-if ENV["TRAVIS"]
-  require "codeclimate-test-reporter"
+if ENV['TRAVIS']
+  require 'codeclimate-test-reporter'
   CodeClimate::TestReporter.start
 end
 
 require File.expand_path('../../lib/cistern', __FILE__)
-Dir[File.expand_path("../{support,shared,matchers,fixtures}/*.rb", __FILE__)].each{|f| require(f)}
+Dir[File.expand_path('../{support,shared,matchers,fixtures}/*.rb', __FILE__)].each { |f| require(f) }
 
 Bundler.require(:test)
 

data/spec/wait_for_spec.rb

@@ -9,19 +9,19 @@ end
 class WaitForModels < Sample::Collection
   model WaitForModel
 
-  def get(identity)
+  def get(_identity)
     self
   end
 end
 
 describe 'Cistern#wait_for' do
-  it "should return false if timeout exceeded" do
+  it 'should return false if timeout exceeded' do
     expect(Cistern.wait_for(0, 0) { false }).to be_falsey
   end
 end
 
 describe 'Cistern#wait_for!' do
-  it "should raise if timeout exceeded" do
+  it 'should raise if timeout exceeded' do
     expect { Cistern.wait_for!(0, 0) { false } }.to raise_exception(Cistern::Timeout)
   end
 end
@@ -30,17 +30,16 @@ describe 'Cistern::Model#wait_for!' do
   let(:service) { Sample.new }
   let(:model)   { service.wait_for_models.new(identity: 1) }
 
-  it "should raise if timeout exceeded" do
+  it 'should raise if timeout exceeded' do
     expect { model.wait_for!(0, 0) { false } }.to raise_exception(Sample::Timeout)
   end
 end
 
-
-describe "WaitForModel#timeout" do
+describe 'WaitForModel#timeout' do
   let(:service) { Sample.new }
   let(:model)   { service.wait_for_models.new(identity: 1) }
 
-  it "should use service-specific timeout in #wait_for" do
+  it 'should use service-specific timeout in #wait_for' do
     service.class.timeout = 0.1
     service.class.poll_interval = 0
 
@@ -53,7 +52,7 @@ describe "WaitForModel#timeout" do
     end
   end
 
-  it "should favor explicit timeout" do
+  it 'should favor explicit timeout' do
     service.class.timeout = 1
     service.class.poll_interval = 0
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cistern
 version: !ruby/object:Gem::Version
-  version: 2.2.3
+  version: 2.2.4
 platform: ruby
 authors:
 - Josh Lane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-27 00:00:00.000000000 Z
+date: 2015-11-27 00:00:00.000000000 Z
 dependencies: []
 description: API client framework extracted from Fog
 email: