arstotzka 1.3.2 → 1.4.0

data/spec/integration/yard/arstotzka/method_builder_spec.rb

@@ -7,7 +7,6 @@ describe Arstotzka::MethodBuilder do
     subject(:builder) { described_class.new(attributes, klass, options) }
 
     let!(:instance) { klass.new(hash) }
-    let(:options)   { Arstotzka::Options.new(options_hash) }
     let(:hash) do
       {
         'name' => { first: 'John', last: 'Williams' },
@@ -17,9 +16,9 @@ describe Arstotzka::MethodBuilder do
     end
 
     describe '#first_name' do
-      let(:klass)        { Class.new(MyModel) }
-      let(:attributes)   { [:first_name] }
-      let(:options_hash) { { full_path: 'name.first' } }
+      let(:klass)      { Class.new(MyModel) }
+      let(:attributes) { [:first_name] }
+      let(:options)    { { full_path: 'name.first' } }
 
       before do
         builder.build
@@ -31,9 +30,9 @@ describe Arstotzka::MethodBuilder do
     end
 
     describe '#age' do
-      let(:klass)        { Class.new(MyModel) }
-      let(:attributes)   { %i[age cars] }
-      let(:options_hash) { { type: :integer } }
+      let(:klass)      { Class.new(MyModel) }
+      let(:attributes) { %i[age cars] }
+      let(:options)    { { type: :integer } }
 
       before do
         builder.build
@@ -49,9 +48,9 @@ describe Arstotzka::MethodBuilder do
     end
 
     describe '#cars' do
-      let(:klass)        { Class.new(MyModel) }
-      let(:attributes)   { %i[age cars] }
-      let(:options_hash) { { type: :integer } }
+      let(:klass)      { Class.new(MyModel) }
+      let(:attributes) { %i[age cars] }
+      let(:options)    { { type: :integer } }
 
       before do
         builder.build

data/spec/lib/arstotzka/config_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Arstotzka::Config do
+  subject(:config) { Arstotzka.config }
+
+  after do
+    Arstotzka.reset_config
+  end
+
+  describe '#options' do
+    it do
+      expect(config.options).to be_a(Arstotzka::Options)
+    end
+
+    it 'generates options with default values' do
+      expect(config.options.to_h)
+        .to eq(described_class::DEFAULT_CONFIGS)
+    end
+
+    context 'when configuring it' do
+      let(:expected_options_hash) do
+        {
+          after:      :method,
+          after_each: :each_method,
+          cached:     true,
+          case:       :snake,
+          compact:    true,
+          default:    10,
+          flatten:    true,
+          json:       :@hash,
+          klass:      Account,
+          type:       :string
+        }
+      end
+
+      before do
+        Arstotzka.configure do |c|
+          after      :method
+          after_each :each_method
+          cached     true
+          c.case     :snake
+          compact    true
+          default    10
+          flatten    true
+          json       :@hash
+          klass      Account
+          type       :string
+        end
+      end
+
+      it 'generates options with given values' do
+        expect(config.options.to_h)
+          .to eq(expected_options_hash)
+      end
+    end
+
+    context 'when passing a hash' do
+      let(:options_hash) do
+        expected_options_hash
+      end
+
+      let(:expected_options_hash) do
+        {
+          after:      :method,
+          after_each: :each_method,
+          cached:     true,
+          case:       :snake,
+          compact:    true,
+          default:    10,
+          flatten:    true,
+          json:       :@hash,
+          klass:      Account,
+          type:       :string
+        }
+      end
+
+      it 'generates options with given values' do
+        expect(config.options(options_hash).to_h)
+          .to eq(expected_options_hash)
+      end
+    end
+  end
+
+  describe '#after' do
+    it do
+      expect(config.after).to be_falsey
+    end
+
+    context 'when configuring value' do
+      before { Arstotzka.configure { after :method } }
+
+      it 'returns configured value' do
+        expect(config.after).to eq(:method)
+      end
+    end
+  end
+
+  describe '#after_each' do
+    it do
+      expect(config.after).to be_falsey
+    end
+
+    context 'when configuring value' do
+      before { Arstotzka.configure { after_each :each_method } }
+
+      it 'returns configured value' do
+        expect(config.after_each).to eq(:each_method)
+      end
+    end
+  end
+
+  describe '#cached' do
+    it do
+      expect(config.cached).to be_falsey
+    end
+
+    context 'when configuring value' do
+      before { Arstotzka.configure { cached true } }
+
+      it 'returns configured value' do
+        expect(config.cached).to be_truthy
+      end
+    end
+  end
+
+  describe '#case' do
+    it 'returns default case' do
+      expect(config.case).to eq(:lower_camel)
+    end
+
+    context 'when configuring value' do
+      before { Arstotzka.configure { |c| c.case :snake } }
+
+      it 'returns configured value' do
+        expect(config.case).to eq(:snake)
+      end
+    end
+  end
+
+  describe '#compact' do
+    it do
+      expect(config.compact).to be_falsey
+    end
+
+    context 'when configuring value' do
+      before { Arstotzka.configure { compact true } }
+
+      it 'returns configured value' do
+        expect(config.case).to be_truthy
+      end
+    end
+  end
+
+  describe '#default' do
+    it do
+      expect(config.default).to be_nil
+    end
+
+    context 'when configuring value' do
+      before { Arstotzka.configure { default 10 } }
+
+      it 'returns configured value' do
+        expect(config.default).to eq(10)
+      end
+    end
+  end
+
+  describe '#flatten' do
+    it do
+      expect(config.flatten).to be_falsey
+    end
+
+    context 'when configuring value' do
+      before { Arstotzka.configure { flatten true } }
+
+      it 'returns configured value' do
+        expect(config.flatten).to be_truthy
+      end
+    end
+  end
+
+  describe '#json' do
+    it 'returns default json option' do
+      expect(config.json).to eq(:json)
+    end
+
+    context 'when configuring value' do
+      before { Arstotzka.configure { json :@hash } }
+
+      it 'returns configured value' do
+        expect(config.json).to eq(:@hash)
+      end
+    end
+  end
+
+  describe '#klass' do
+    it do
+      expect(config.klass).to be_nil
+    end
+
+    context 'when configuring value' do
+      before { Arstotzka.configure { klass Account } }
+
+      it 'returns configured value' do
+        expect(config.klass).to eq(Account)
+      end
+    end
+  end
+
+  describe '#type' do
+    it 'returns none' do
+      expect(config.type).to eq(:none)
+    end
+
+    context 'when configuring value' do
+      before { Arstotzka.configure { type :string } }
+
+      it 'returns configured value' do
+        expect(config.type).to eq(:string)
+      end
+    end
+  end
+end

data/spec/lib/arstotzka/fetcher/cache_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Arstotzka::Fetcher::Cache do
+  subject(:cache) { described_class.new(options) { 100 } }
+
+  let(:instance) { Object.new }
+  let(:value)    { cache.fetch }
+
+  let(:options) do
+    Arstotzka.config.options(
+      options_hash.merge(instance: instance, key: :the_value)
+    )
+  end
+
+  context 'when option cached is false' do
+    let(:options_hash) { { cached: false } }
+
+    context 'when a variable has not been set' do
+      it 'returns result of the block' do
+        expect(value).to eq(100)
+      end
+
+      it 'does not set the variable' do
+        expect { value }
+          .not_to(change { instance.instance_variable_get(:@the_value) })
+      end
+    end
+
+    context 'when a variable has been set as nil' do
+      before do
+        instance.instance_variable_set('@the_value', nil)
+      end
+
+      it 'returns result of the block' do
+        expect(value).to eq(100)
+      end
+
+      it 'does not set the variable' do
+        expect { value }
+          .not_to(change { instance.instance_variable_get(:@the_value) })
+      end
+    end
+
+    context 'when a variable has been set with value' do
+      before do
+        instance.instance_variable_set('@the_value', :old_value)
+      end
+
+      it 'returns result of the block' do
+        expect(value).to eq(100)
+      end
+
+      it 'does not set the variable' do
+        expect { value }
+          .not_to(change { instance.instance_variable_get(:@the_value) })
+      end
+    end
+  end
+
+  context 'when option cached is true' do
+    let(:options_hash) { { cached: true } }
+
+    context 'when a variable has not been set' do
+      it 'returns result of the block' do
+        expect(value).to eq(100)
+      end
+
+      it 'does sets the variable' do
+        expect { value }
+          .to change { instance.instance_variable_get(:@the_value) }
+          .from(nil).to(100)
+      end
+    end
+
+    context 'when a variable has been set as nil' do
+      before do
+        instance.instance_variable_set('@the_value', nil)
+      end
+
+      it 'returns result of the block' do
+        expect(value).to eq(100)
+      end
+
+      it 'does sets the variable' do
+        expect { value }
+          .to change { instance.instance_variable_get(:@the_value) }
+          .from(nil).to(100)
+      end
+    end
+
+    context 'when a variable has been set with value' do
+      before do
+        instance.instance_variable_set('@the_value', :old_value)
+      end
+
+      it 'returns the cached value' do
+        expect(value).to eq(:old_value)
+      end
+
+      it 'does not update the variable' do
+        expect { value }
+          .not_to(change { instance.instance_variable_get(:@the_value) })
+      end
+    end
+  end
+
+  context 'when option cached is :full' do
+    let(:options_hash) { { cached: :full } }
+
+    context 'when a variable has not been set' do
+      it 'returns result of the block' do
+        expect(value).to eq(100)
+      end
+
+      it 'does sets the variable' do
+        expect { value }
+          .to change { instance.instance_variable_get(:@the_value) }
+          .from(nil).to(100)
+      end
+    end
+
+    context 'when a variable has been set as nil' do
+      before do
+        instance.instance_variable_set('@the_value', nil)
+      end
+
+      it 'returns nil' do
+        expect(value).to be_nil
+      end
+
+      it 'does not update the variable' do
+        expect { value }
+          .not_to(change { instance.instance_variable_get(:@the_value) })
+      end
+    end
+
+    context 'when a variable has been set with value' do
+      before do
+        instance.instance_variable_set('@the_value', :old_value)
+      end
+
+      it 'returns the cached value' do
+        expect(value).to eq(:old_value)
+      end
+
+      it 'does not update the variable' do
+        expect { value }
+          .not_to(change { instance.instance_variable_get(:@the_value) })
+      end
+    end
+  end
+end

data/spec/lib/arstotzka/fetcher_spec.rb

@@ -7,7 +7,7 @@ describe Arstotzka::Fetcher do
     described_class.new options
   end
 
-  let(:options)  { Arstotzka::Options.new(options_hash.merge(instance: instance)) }
+  let(:options)  { Arstotzka.config.options(options_hash.merge(instance: instance)) }
   let(:instance) { Arstotzka::Fetcher::Dummy.new(json) }
   let(:json)     { load_json_fixture_file('arstotzka.json') }
   let(:value)    { fetcher.fetch }
@@ -177,4 +177,44 @@ describe Arstotzka::Fetcher do
       end
     end
   end
+
+  describe 'cached option' do
+    let(:key) { 'id' }
+
+    context 'with cached true' do
+      let(:options_hash) { { key: key, cached: true } }
+
+      it 'retrieves attribute from cache' do
+        expect { json['id'] = Random.rand(1000) }
+          .not_to change(fetcher, :fetch)
+      end
+
+      context 'when initial value is nil' do
+        let(:json) { { id: nil } }
+
+        it 'does not cache nil values' do
+          expect { json['id'] = Random.rand(1000) }
+            .to change(fetcher, :fetch)
+        end
+      end
+    end
+
+    context 'with cached full' do
+      let(:options_hash) { { key: key, cached: :full } }
+
+      it 'retrieves attribute from cache' do
+        expect { json['id'] = Random.rand(1000) }
+          .not_to change(fetcher, :fetch)
+      end
+
+      context 'when initial value is nil' do
+        let(:json) { { id: nil } }
+
+        it 'caches nil values' do
+          expect { json['id'] = Random.rand(1000) }
+            .not_to change(fetcher, :fetch)
+        end
+      end
+    end
+  end
 end