arstotzka 1.0.0

data/spec/lib/arstotzka/crawler_spec.rb

@@ -0,0 +1,276 @@
+require 'spec_helper'
+
+describe Arstotzka::Crawler do
+  let(:subject) do
+    described_class.new default_options.merge(options), &block
+  end
+  let(:block) { proc { |v| v } }
+  let(:path) { '' }
+  let(:default_options) { { path: path, case_type: :lower_camel} }
+  let(:options) { {} }
+  let(:json_file) { 'arstotzka.json' }
+  let(:json) { load_json_fixture_file(json_file) }
+  let(:value) { subject.value(json) }
+
+  context 'when parsing with a path' do
+    let(:path) { %w(user name) }
+
+    it 'retrieves attribute from base json' do
+      expect(value).to eq(json['user']['name'])
+    end
+
+    context 'when calling twice' do
+      before { subject.value(json) }
+
+      it 'can still crawl' do
+        expect(value).to eq(json['user']['name'])
+      end
+    end
+  end
+
+  context 'crawler finds a nil attribute' do
+    let(:path) { %w(car model) }
+
+    it 'returns nil' do
+      expect(value).to be_nil
+    end
+
+    it do
+      expect { value }.not_to raise_error
+    end
+  end
+
+  context 'when there is an array of arrays' do
+    let(:json_file) { 'accounts.json' }
+    let(:path) { %w(banks accounts balance) }
+
+    it 'returns the values as array of arrays' do
+      expect(value).to eq([[1000.0, 1500.0], [50.0, -500.0]])
+    end
+
+    context 'when there is a missing node' do
+      let(:json_file) { 'accounts_missing.json' }
+
+      it 'returns the missing values as nil' do
+        expect(value).to eq([[1000.0, nil, nil], nil, nil])
+      end
+
+      context 'when setting a default' do
+        let(:options) { { default: 10 } }
+
+        it 'returns the missing values as default' do
+          expect(value).to eq([[1000.0, 10, nil], 10, 10])
+        end
+      end
+
+      context 'when setting compact' do
+        let(:options) { { compact: true } }
+        it 'returns the missing values as nil' do
+          expect(value).to eq([[1000.0]])
+        end
+      end
+    end
+  end
+
+  context 'when json is empty' do
+    let(:json) { nil }
+    let(:path) { %w(car model) }
+
+    it 'returns nil' do
+      expect(value).to be_nil
+    end
+
+    it do
+      expect { value }.not_to raise_error
+    end
+  end
+
+  context 'with an snake case path' do
+    let(:path) { ['has_money'] }
+
+    it 'returns camel cased value' do
+      expect(value).to eq(json['hasMoney'])
+    end
+  end
+
+  context 'when dealing with json inside arrays' do
+    let(:path) { %w(animals race species name)}
+    let(:expected) do
+      ['European squid', 'Macaque monkey', 'Mexican redknee tarantula']
+    end
+
+    it do
+      expect(value).to be_a(Array)
+    end
+
+    it 'parses them mapping arrays as sub parse' do
+      expect(value).to eq(expected)
+    end
+
+    context 'when there are nil values' do
+      context 'with compact option as false' do
+        let(:options) { { compact: false } }
+        before do
+          json["animals"].last['race'] = nil
+        end
+        let(:expected) do
+          ['European squid', 'Macaque monkey', nil]
+        end
+
+        it 'eliminate nil values' do
+          expect(value).to eq(expected)
+        end
+      end
+
+      context 'with compact option' do
+        let(:options) { { compact: true } }
+        before do
+          json["animals"].last['race'] = nil
+        end
+        let(:expected) do
+          ['European squid', 'Macaque monkey']
+        end
+
+        it 'eliminate nil values' do
+          expect(value).to eq(expected)
+        end
+      end
+    end
+  end
+
+  context 'with default option' do
+    let(:default_value) { 'NotFound' }
+    let(:options) { { default: default_value } }
+    let(:path) { %w(projects name) }
+
+    context 'when there is a key missing' do
+      it 'returns the default value' do
+        expect(value).to eq(default_value)
+      end
+
+      context 'when wrapping it with a class' do
+        let(:block) { proc { |v| Person.new(v) } }
+
+        it 'wrap it with the class' do
+          expect(value).to be_a(Person)
+        end
+
+        it 'wraps the default value' do
+          expect(value.name).to eq(default_value)
+        end
+      end
+    end
+
+    context 'when the key is not missing but the value is nil' do
+      let(:json_file) { 'person.json' }
+      let(:path) { %w(user name) }
+
+      it { expect(value).to be_nil }
+
+      context 'when wrapping it with a class' do
+        let(:block) { proc { |v| Person.new(v) } }
+
+        it 'wrap it with the class' do
+          expect(value).to be_a(Person)
+        end
+
+        it 'wraps the default value' do
+          expect(value.name).to be_nil
+        end
+      end
+    end
+
+    context 'when the key last key is missing but the value is nil' do
+      let(:json_file) { 'person.json' }
+      let(:path) { %w(user nick_name) }
+
+      it 'returns the default value' do
+        expect(value).to eq(default_value)
+      end
+
+      context 'when wrapping it with a class' do
+        let(:block) { proc { |v| Person.new(v) } }
+
+        it 'wrap it with the class' do
+          expect(value).to be_a(Person)
+        end
+
+        it 'wraps the default value' do
+          expect(value.name).to eq(default_value)
+        end
+      end
+    end
+
+    context 'when the node is missing but default has the same node' do
+      let(:default_value) { { node: { value: 1 } } }
+      let(:path) { %w(node node node) }
+      let(:json) { {} }
+
+      it 'does not crawl through default value' do
+        expect(value).to eq(default_value)
+      end
+    end
+  end
+
+  context 'when using a snake case' do
+    let(:json) { { snake_cased: 'snake', snakeCased: 'Camel' }.stringify_keys }
+    let(:path) { [ 'snake_cased' ] }
+    let(:options) { { case_type: :snake } }
+
+    it 'fetches from snake cased fields' do
+      expect(value).to eq('snake')
+    end
+  end
+
+  context 'when using a upper camel case' do
+    let(:json) { { UpperCase: 'upper', upperCase: 'lower' }.stringify_keys }
+    let(:path) { [ 'upper_case' ] }
+    let(:options) { { case_type: :upper_camel } }
+
+    it 'fetches from upper camel cased fields' do
+      expect(value).to eq('upper')
+    end
+  end
+
+  context 'when using a symbol keys' do
+    let(:json) { load_json_fixture_file('arstotzka.json').symbolize_keys }
+    let(:path) { [ 'id' ] }
+
+    it 'fetches from symbol keys' do
+      expect(value).to eq(json[:id])
+    end
+
+    context 'crawler finds a nil attribute' do
+      let(:path) { %w(car model) }
+
+      it 'returns nil' do
+        expect(value).to be_nil
+      end
+
+      it do
+        expect { value }.not_to raise_error
+      end
+    end
+  end
+
+  context 'when using key with false value' do
+    let(:path) { ['has_money'] }
+    before do
+      json['hasMoney'] = false
+    end
+
+    context 'with string keys' do
+      it { expect(value).to be_falsey }
+      it { expect(value).not_to be_nil }
+    end
+
+    context 'with symbol keys' do
+      before do
+        json.symbolize_keys!
+      end
+
+      it { expect(value).to be_falsey }
+      it { expect(value).not_to be_nil }
+    end
+  end
+end

data/spec/lib/arstotzka/fetcher_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Arstotzka::Fetcher do
+  let(:subject) do
+    described_class.new json, instance, options.merge(path: path)
+  end
+  let(:path) { '' }
+  let(:instance) { Arstotzka::Fetcher::Dummy.new }
+  let(:json) { load_json_fixture_file('arstotzka.json') }
+  let(:value) { subject.fetch }
+
+  context 'when fetching with no options' do
+    let(:options) { {} }
+    let(:path) { 'id' }
+
+    it 'retrieves attribute from base json' do
+      expect(value).to eq(json['id'])
+    end
+
+    context 'when calling the method twice' do
+      before do
+        subject.fetch
+      end
+
+      it 'retrieves attribute from base json' do
+        expect(value).to eq(json['id'])
+      end
+    end
+
+    context 'when changing json value' do
+      let!(:old_value) { json['id'] }
+      before do
+        subject.fetch
+        json['id'] = 200
+      end
+
+      it 'retrieves the new value' do
+        expect(value).not_to eq(old_value)
+      end
+    end
+  end
+
+  describe 'flatten options' do
+    let(:json) { [[[1,2],[3,4]],[[5,6],[7,8]]] }
+
+    context 'when flatten option is true' do
+      let(:options) { { flatten: true } }
+
+      it 'returns the fetched value flattened' do
+        expect(subject.fetch).to eq((1..8).to_a)
+      end
+
+      context 'when value is not an array' do
+        let(:json) { 1 }
+
+        it 'returns the fetched value flattened' do
+          expect(subject.fetch).to eq(1)
+        end
+      end
+    end
+
+    context 'when flatten option is false' do
+      let(:options) { { flatten: false } }
+
+      it 'returns the fetched value non flattened' do
+        expect(subject.fetch).to eq(json)
+      end
+    end
+  end
+
+  describe 'after option' do
+    let(:instance) { MyParser.new(json) }
+    let(:json) { [ 100, 250, -25] }
+    let(:options) { { after: :sum } }
+
+    it 'applies after call ' do
+      expect(subject.fetch).to eq(325)
+    end
+  end
+
+  describe 'clazz options' do
+    let(:path) { 'name' }
+    let(:name) { 'Robert' }
+    let(:json) { { name: name } }
+    let(:options) { { clazz: wrapper } }
+    let(:wrapper) { Person }
+
+    it 'wraps the result in an object' do
+      expect(subject.fetch).to be_a(wrapper)
+    end
+
+    it 'sets the wrapper with the fetched value' do
+      expect(subject.fetch.name).to eq(name)
+    end
+  end
+end

data/spec/lib/arstotzka/reader_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+shared_examples 'reader fetchin value' do
+  it do
+    expect { subject.read(json, index) }.not_to raise_error
+  end
+
+  it do
+    expect(subject.read(json, index)).not_to be_nil
+  end
+
+  it 'returns the evaluated value' do
+    expect(subject.read(json, index)).to eq(expected)
+  end
+
+  context 'and the json has symbolized_keys' do
+    it 'returns the evaluated value' do
+      expect(subject.read(sym_json, index)).to eq(expected)
+    end
+  end
+end
+
+describe Arstotzka::Reader do
+  subject do
+    described_class.new(path: path, case_type: case_type)
+  end
+
+  let(:path) { %w(user full_name) }
+  let(:json_file) { 'complete_person.json' }
+  let(:full_json) { load_json_fixture_file(json_file) }
+  let(:json) { full_json  }
+  let(:sym_json) { json.symbolize_keys }
+  let(:case_type) { :snake }
+  let(:index) { 0 }
+
+  describe '#read' do
+    context 'when the key is found' do
+      let(:expected) { json['user'] }
+
+      it_behaves_like 'reader fetchin value'
+
+      context 'when the path case is changed' do
+        let(:json) { full_json['user'] }
+        let(:index) { 1 }
+
+        context 'to snake_case' do
+          let(:path) { %w(user FullName) }
+          let(:expected) { json['full_name'] }
+
+          it_behaves_like 'reader fetchin value'
+        end
+
+        context 'to upper_camel' do
+          let(:case_type) { :upper_camel }
+          let(:path) { %w(user login_name) }
+          let(:expected) { json['LoginName'] }
+
+          it_behaves_like 'reader fetchin value'
+        end
+
+        context 'to lower_camel' do
+          let(:case_type) { :lower_camel }
+          let(:path) { %w(user birth_date) }
+          let(:expected) { json['birthDate'] }
+
+          it_behaves_like 'reader fetchin value'
+        end
+      end
+
+      context 'when key is found but value is null' do
+        let(:json) { full_json['user'] }
+        let(:index) { 1 }
+        let(:path) { %w(user password_reminder) }
+
+        it do
+          expect(subject.read(json, index)).to be_nil
+        end
+
+        context 'but keys are symbol' do
+          it do
+            expect(subject.read(sym_json, index)).to be_nil
+          end
+        end
+      end
+
+      context 'when json has both string and symble' do
+        let(:path) { %w(key) }
+        let(:json) { { key: 'symbol', 'key' => 'string' } }
+
+        it 'fetches the string key first' do
+          expect(subject.read(json, index)).to eq('string')
+        end
+      end
+    end
+
+    context 'when the key is missing' do
+      let(:path) { %w(age) }
+
+      it do
+        expect do
+          subject.read(json, index)
+        end.to raise_error(Arstotzka::Exception::KeyNotFound)
+      end
+    end
+  end
+
+  describe 'is_ended?' do
+    context 'when index is within path' do
+      let(:index) { 1 }
+
+      it { expect(subject.is_ended?(index)).to be_falsey }
+    end
+
+    context 'when index is outside path' do
+      let(:index) { 2 }
+
+      it { expect(subject.is_ended?(index)).to be_truthy }
+    end
+  end
+end