arstotzka 1.0.0

data/spec/lib/arstotzka/wrapper_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Arstotzka::Wrapper do
+  let(:options) { {} }
+  let(:subject) { described_class.new options }
+  let(:hash) { { a: 1 } }
+
+  describe '#wrap' do
+    let(:value) { hash }
+    let(:result) { subject.wrap(value) }
+
+    context 'with default options' do
+      it 'does not change the json value' do
+        expect(result).to eq(value)
+      end
+
+      context 'with an array as value' do
+        let(:value) { [hash] }
+
+        it 'does not change the array' do
+          expect(result).to eq(value)
+        end
+      end
+    end
+
+    context 'with clazz otpion' do
+      let(:options) { { clazz: OpenStruct } }
+
+      it 'creates new instance from given class' do
+        expect(result).to be_a(OpenStruct)
+        expect(result.a).to eq(hash[:a])
+      end
+
+      context 'with an array as value' do
+        let(:value) { [hash] }
+
+        it 'returns an array of objects of the given class' do
+          expect(result).to be_a(Array)
+          expect(result.first).to be_a(OpenStruct)
+        end
+      end
+    end
+
+    context 'with type otpion' do
+      let(:type) { :integer }
+      let(:value) { '1' }
+      let(:options) { { type: type } }
+      let(:cast) { result }
+
+      it_behaves_like 'casts basic types'
+
+      context 'when processing an array' do
+        let(:value) { [1.0] }
+        let(:cast) { result.first }
+
+        it_behaves_like 'casts basic types'
+
+        it do
+          expect(result).to be_a(Array)
+        end
+      end
+
+      context 'with nil value' do
+        let(:value) { nil }
+
+        it do
+          expect(result).to be_nil
+        end
+
+        context 'when passing clazz parameter' do
+          let(:options) { { type: type, clazz: Arstotzka::Wrapper::Dummy } }
+
+          it do
+            expect(result).to be_nil
+          end
+        end
+      end
+
+      context 'with blank value' do
+        let(:value) { '' }
+
+        it_behaves_like 'a result that is type cast', {
+          integer: NilClass,
+          float: NilClass,
+          string: String
+        }
+
+        context 'when passing clazz parameter' do
+          let(:options) { { type: type, clazz: Arstotzka::Wrapper::Dummy } }
+
+          it_behaves_like 'a result that is type cast', {
+            integer: NilClass,
+            float: NilClass,
+            string: Arstotzka::Wrapper::Dummy
+          }
+        end
+      end
+
+      context 'when passing clazz parameter' do
+        let(:value) { 1 }
+        let(:options) { { type: type, clazz: Arstotzka::Wrapper::Dummy } }
+        let(:cast) { result.value }
+
+        it_behaves_like 'casts basic types'
+
+        it 'wraps the result inside the given class' do
+          expect(result).to be_a(Arstotzka::Wrapper::Dummy)
+        end
+      end
+
+      context 'with none for type' do
+        let(:type) { :none }
+        let(:value) { 1.0 }
+
+        it 'does not cast the value' do
+          expect(result).to eq(value)
+        end
+      end
+    end
+  end
+end

data/spec/lib/arstotzka_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Arstotzka do
+  let(:dummy) { Arstotzka::Dummy.new(json) }
+  let(:json) { load_json_fixture_file('arstotzka.json') }
+  let(:value) { dummy.public_send(attribute) }
+
+  context 'when parser is configured with no options' do
+    let(:attribute) { :id }
+
+    it 'retrieves attribute from base json' do
+      expect(value).to eq(json['id'])
+    end
+  end
+
+  context 'when parser is configured with a path' do
+    let(:attribute) { :name }
+
+    it 'retrieves attribute from base json' do
+      expect(value).to eq(json['user']['name'])
+    end
+  end
+
+  context 'when configuring full path' do
+    let(:attribute) { :father_name }
+
+    it 'returns nil' do
+      expect(value).to eq(json['father']['name'])
+    end
+  end
+
+  context 'when caching the value' do
+    let(:attribute) { :age }
+    let!(:old_value) { json['age'] }
+    before do
+      dummy.age
+      json['age'] = old_value + 100
+    end
+
+    it 'returns cached value' do
+      expect(value).to eq(old_value)
+    end
+  end
+
+  context 'when wrapping it with a class' do
+    let(:attribute) { :house }
+
+    it 'returns an onject wrap' do
+      expect(value).to be_a(House)
+    end
+
+    it 'creates the object with the given json' do
+      expect(value.age).to eq(json['house']['age'])
+      expect(value.value).to eq(json['house']['value'])
+      expect(value.floors).to eq(json['house']['floors'])
+    end
+
+    context 'when dealing with an array' do
+      let(:attribute) { :games }
+
+      it 'returns an array of json wrapped' do
+        expect(value).to be_a(Array)
+        value.each do |object|
+          expect(object).to be_a(Game)
+        end
+      end
+
+      context 'when dealing with multiple level arrays' do
+        let(:attribute) { :games }
+        before do
+          json['games'].map! { |j| [j] }
+        end
+
+        it 'returns an array of json wrapped' do
+          expect(value).to be_a(Array)
+          value.each do |object|
+            expect(object).to be_a(Array)
+            object.each do |game|
+              expect(game).to be_a(Game)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'when wrapping it with a class and caching' do
+    let(:attribute) { :old_house }
+    let!(:old_value) { json['oldHouse'] }
+    before do
+      dummy.old_house
+      json['oldHouse'] = {}
+    end
+
+    it 'returns an onject wrap' do
+      expect(value).to be_a(House)
+    end
+
+    it 'creates the object with the given json' do
+      expect(value.age).not_to eq(json['oldHouse']['age'])
+      expect(value.age).to eq(old_value['age'])
+      expect(value.value).not_to eq(json['oldHouse']['value'])
+      expect(value.value).to eq(old_value['value'])
+      expect(value.floors).not_to eq(json['oldHouse']['floors'])
+      expect(value.floors).to eq(old_value['floors'])
+    end
+  end
+
+  context 'when passing an after filter' do
+    let(:attribute) { :games_filtered }
+
+    it 'applies the filter after parsing the json' do
+      expect(value.map(&:publisher)).not_to include('sega')
+    end
+  end
+
+  context 'when casting the result' do
+    class Arstotzka::Dummy
+      expose :float_value, type: :float
+    end
+
+    let(:json) { { floatValue: '1' } }
+    let(:attribute) { :float_value }
+
+    it do
+      expect(value).to be_a(Float)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec/support/models/'
+end
+
+require 'pry-nav'
+require 'arstotzka'
+require 'safe_attribute_assignment'
+
+support_files = File.expand_path("spec/support/**/*.rb")
+Dir[support_files].sort.each { |file| require file  }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.filter_run_excluding :integration unless ENV['ALL']
+
+  config.order = 'random'
+
+  config.before do
+  end
+end

data/spec/support/fixture_helpers.rb

@@ -0,0 +1,19 @@
+require 'active_support'
+
+module FixtureHelpers
+  def load_fixture_file(filename)
+      File.read (['./spec/', 'fixtures', filename].join('/'))
+  end
+
+  def load_json_fixture_file(filename)
+    cached_json_fixture_file(filename)
+  end
+
+  private
+
+  def cached_json_fixture_file(filename)
+      ActiveSupport::JSON.decode(load_fixture_file(filename))
+  end
+end
+
+RSpec.configuration.include FixtureHelpers

data/spec/support/models.rb

@@ -0,0 +1,5 @@
+models = File.expand_path("spec/support/models/*.rb")
+Dir[models].sort.each do |file|
+  autoload file.gsub(/.*\/(.*)\..*/, '\1').camelize.to_sym, file
+end
+

data/spec/support/models/arstotzka/dummy.rb

@@ -0,0 +1,23 @@
+class Arstotzka::Dummy
+  include Arstotzka
+  attr_reader :json
+
+  expose :id
+  expose :name, path: 'user'
+  expose :father_name, full_path: 'father.name'
+  expose :age, cached: true
+  expose :house, class: ::House
+  expose :old_house, class: ::House, cached: true
+  expose :games, class: ::Game
+  expose :games_filtered, class: ::Game, after: :filter_games, full_path: 'games'
+
+  def initialize(json)
+    @json = json
+  end
+
+  def filter_games(games)
+    games.select do |g|
+      g.publisher != 'sega'
+    end
+  end
+end

data/spec/support/models/arstotzka/fetcher/dummy.rb

@@ -0,0 +1,3 @@
+class Arstotzka::Fetcher::Dummy
+end
+

data/spec/support/models/arstotzka/type_cast.rb

@@ -0,0 +1,6 @@
+module Arstotzka::TypeCast
+  def to_money_float(value)
+    value.gsub(/\$ */, '').to_f
+  end
+end
+

data/spec/support/models/arstotzka/wrapper/dummy.rb

@@ -0,0 +1,7 @@
+class Arstotzka::Wrapper::Dummy
+  attr_reader :value
+  def initialize(value)
+    @value = value
+  end
+end
+

data/spec/support/models/game.rb

@@ -0,0 +1,11 @@
+class Game
+  include Arstotzka
+  include SafeAttributeAssignment
+  attr_reader :json
+
+  expose :name, :publisher
+
+  def initialize(json)
+    @json = json
+  end
+end

data/spec/support/models/house.rb

@@ -0,0 +1,11 @@
+class House
+  include Arstotzka
+  include ::SafeAttributeAssignment
+  attr_reader :json
+
+  expose :age, :value, :floors
+
+  def initialize(json)
+    @json = json
+  end
+end

data/spec/support/models/my_parser.rb

@@ -0,0 +1,28 @@
+class MyParser
+  include Arstotzka
+
+  expose :id
+  expose :name, :age, path: :person
+  expose :total_money, full_path: 'accounts.balance', after: :sum,
+                       cached: true, type: :money_float
+  expose :total_owed, full_path: 'loans.value', after: :sum,
+                       cached: true, type: :money_float
+
+  attr_reader :json
+
+  def initialize(json = {})
+    @json = json
+  end
+
+  private
+
+  def sum(balances)
+    balances.sum if balances
+  end
+
+  models = File.expand_path("spec/support/models/my_parser/*.rb")
+  Dir[models].each do |file|
+    autoload file.gsub(/.*\/(.*)\..*/, '\1').camelize.to_sym, file
+  end
+end
+

data/spec/support/models/person.rb

@@ -0,0 +1,8 @@
+class Person
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+  end
+end
+

data/spec/support/models/star.rb

@@ -0,0 +1,7 @@
+class Star
+  attr_reader :name
+
+  def initialize(name:)
+    @name = name
+  end
+end

data/spec/support/models/star_gazer.rb

@@ -0,0 +1,13 @@
+class StarGazer
+  include Arstotzka
+
+  expose :favorite_star, full_path: 'universe.star',
+         default: { name: 'Sun' }, class: ::Star
+
+  attr_reader :json
+
+  def initialize(json = {})
+    @json = json
+  end
+end
+

data/spec/support/shared_examples/wrapper.rb

@@ -0,0 +1,19 @@
+shared_context 'a result that is type cast' do |types|
+  types.each do |type, clazz|
+    context "with #{type} type" do
+      let(:type) { type }
+
+      it do
+        expect(cast).to be_a(clazz)
+      end
+    end
+  end
+end
+
+shared_context 'casts basic types' do
+  it_behaves_like 'a result that is type cast', {
+    integer: Integer,
+    float: Float,
+    string: String
+  }
+end