cistern 2.2.7 → 2.3.0

data/spec/coverage_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe 'coverage', :coverage do
+  class CoverageSpec < Sample::Model
+    identity :id
+
+    attribute :used, type: :string
+    attribute :unused, type: :string
+  end
+
+  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
+  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__)
+  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/)
+  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(0)
+  end
+end

data/spec/mock_data_spec.rb

@@ -6,7 +6,7 @@ describe 'mock data' do
     end
 
     def mock(diagnosis)
-      service.data.store(:diagnosis, service.data.fetch(:diagnosis) + [diagnosis])
+      cistern.data.store(:diagnosis, cistern.data.fetch(:diagnosis) + [diagnosis])
     end
   end
 
@@ -15,7 +15,7 @@ describe 'mock data' do
     end
 
     def mock(treatment)
-      service.data[:treatments] += [treatment]
+      cistern.data[:treatments] += [treatment]
     end
   end
 

data/spec/model_spec.rb

@@ -8,11 +8,11 @@ describe 'Cistern::Model' do
       attribute :properties
 
       def save
-        attributes
+        dirty_attributes
       end
     end
 
-    it 'should merge and save attributes' do
+    it 'should merge and save dirty attributes' do
       model = UpdateSpec.new(name: 'steve')
       model.save
 
@@ -55,7 +55,7 @@ describe 'Cistern::Model' do
     end
 
     class SpecificModelService::Jimbob < SpecificModelService::Model
-      service_method :john_boy
+      cistern_method :john_boy
     end
 
     expect(SpecificModelService.new).not_to respond_to(:jimbob)
@@ -80,170 +80,18 @@ describe 'Cistern::Model' do
     expect(duplicate.name).to eq('string')
   end
 
-  context 'attribute 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
-
-    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("")
-    end
-
-    it 'should allow nils in string types' do
-      expect(TypeSpec.new(string_allow_nil: nil).string_allow_nil).to eq(nil)
-    end
-    it "should handle a 'attributes' aliased attribute" do
-      expect(TypeSpec.new(attributes: 'x').adam_attributes).to eq('x')
-    end
-
-    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
-      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
-    end
-
-    it 'should parse an array' do
-      expect(TypeSpec.new(list: []).list).to eq([])
-      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)
-      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')
-    end
-
-    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
-
-      # 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
-
-      # override intermediate processing
-      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' })
-    end
-
-    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')
-    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')
-      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')
-      end
-    end
-
-    it 'should slice out unaccounted for attributes' do
-      expect(TypeSpec.new({ 'something' => { 'id' => '12' } }).attributes.keys).not_to include('something')
+  describe 'deprecation', :deprecated do
+    class DeprecatedModelService
+      include Cistern::Client
     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)
+    it 'responds to #service' do
+      class Deprecation < DeprecatedModelService::Model
+        service_method :deprecator
       end
 
-      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
-    class CoverageSpec < Sample::Model
-      identity :id
-
-      attribute :used, type: :string
-      attribute :unused, type: :string
-    end
-
-    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
-    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__)
-    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/)
-    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(0)
+      sample = DeprecatedModelService.new.deprecator
+      expect(sample.service).to eq(sample.cistern)
     end
   end
 end

data/spec/request_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe 'Cistern::Request' do
-  class SampleService < Cistern::Service
+  class RequestService
+    include Cistern::Client
+
     recognizes :key
 
     class Real
@@ -14,11 +16,11 @@ describe 'Cistern::Request' do
   end
 
   # @todo Sample::Service.request
-  class ListSamples < SampleService::Request
-    service_method :list_all_samples
+  class ListSamples < RequestService::Request
+    cistern_method :list_all_samples
 
     def real(*args)
-      service.service_args + args + ['real']
+      cistern.service_args + args + ['real']
     end
 
     def mock(*args)
@@ -27,11 +29,30 @@ describe 'Cistern::Request' do
   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(%w(sample2 real))
-    expect(SampleService::Mock.new.list_all_samples('sample3')).to eq(%w(sample3 mock))
+    expect(RequestService.new.list_all_samples('sample1')).to eq([{}, 'sample1', 'real'])
+    expect(RequestService::Real.new.list_all_samples('sample2')).to eq(%w(sample2 real))
+    expect(RequestService::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(RequestService.new(key: 'value').list_all_samples('stat')).to eq([{ key: 'value' }, 'stat', 'real'])
+  end
+
+  describe 'deprecation', :deprecated do
+    class DeprecatedRequestService
+      include Cistern::Client
+    end
+
+    it 'responds to #service' do
+      class ListDeprecations < DeprecatedRequestService::Request
+        service_method :list_deprecations
+
+        def real
+          self
+        end
+      end
+
+      sample = DeprecatedRequestService.new.list_deprecations
+      expect(sample.service).to eq(sample.cistern)
+    end
   end
 end

data/spec/singular_spec.rb

@@ -6,8 +6,8 @@ describe 'Cistern::Singular' do
     attribute :count, type: :number
 
     def fetch_attributes
-      # test that initialize waits for service to be defined
-      fail 'missing service' unless service
+      # test that initialize waits for cistern to be defined
+      fail 'missing cistern' unless cistern
 
       @counter ||= 0
       @counter += 1
@@ -19,6 +19,13 @@ describe 'Cistern::Singular' do
     expect(Sample.new.sample_singular.name).to eq('amazing')
   end
 
+  describe 'deprecation', :deprecated do
+    it 'responds to #service' do
+      sample = Sample.new.sample_singular
+      expect(sample.service).to eq(sample.cistern)
+    end
+  end
+
   it 'should reload' do
     singular = Sample.new.sample_singular
     old_count = singular.count

data/spec/spec_helper.rb

@@ -8,12 +8,18 @@ Dir[File.expand_path('../{support,shared,matchers,fixtures}/*.rb', __FILE__)].ea
 
 Bundler.require(:test)
 
-Cistern.deprecation_warnings = false
+Cistern.deprecation_warnings = !!ENV['DEBUG']
 
-RSpec.configure do |c|
+RSpec.configure do |rspec|
   if Kernel.respond_to?(:caller_locations)
     require File.expand_path('../../lib/cistern/coverage', __FILE__)
   else
-    c.filter_run_excluding(:coverage)
+    rspec.filter_run_excluding(:coverage)
+  end
+  rspec.around(:each, :deprecated) do |example|
+    original_value = Cistern.deprecation_warnings?
+    Cistern.deprecation_warnings = false
+    example.run
+    Cistern.deprecation_warnings = original_value
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cistern
 version: !ruby/object:Gem::Version
-  version: 2.2.7
+  version: 2.3.0
 platform: ruby
 authors:
 - Josh Lane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-13 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies: []
 description: API client framework extracted from Fog
 email:
@@ -50,8 +50,10 @@ files:
 - lib/cistern/timeout.rb
 - lib/cistern/version.rb
 - lib/cistern/wait_for.rb
+- spec/attributes_spec.rb
 - spec/client_spec.rb
 - spec/collection_spec.rb
+- spec/coverage_spec.rb
 - spec/dirty_spec.rb
 - spec/formatter_spec.rb
 - spec/hash_spec.rb
@@ -88,8 +90,10 @@ signing_key:
 specification_version: 4
 summary: API client framework
 test_files:
+- spec/attributes_spec.rb
 - spec/client_spec.rb
 - spec/collection_spec.rb
+- spec/coverage_spec.rb
 - spec/dirty_spec.rb
 - spec/formatter_spec.rb
 - spec/hash_spec.rb