dhs 1.0.0

data/spec/concerns/record/request_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record::Request do
+  subject do
+    Class.new do
+      include DHS::Record::Configuration
+      include DHS::Record::Request
+    end
+  end
+
+  describe 'prepare_options_for_include_all_request' do
+    it 'calls correct prepare method for nil' do
+      expect(subject).to receive(:prepare_option_for_include_all_request!)
+        .with(nil).and_return('ignore')
+      expect(subject.send(:prepare_options_for_include_all_request!, nil)).to be_nil
+    end
+
+    it 'calls correct prepare method for a Hash' do
+      expect(subject).to receive(:prepare_option_for_include_all_request!)
+        .with(abc: 'def').and_return('ignore')
+      expect(subject.send(:prepare_options_for_include_all_request!, abc: 'def')).to eq(abc: 'def')
+    end
+
+    it 'calls correct prepare method for a Hash (collection)' do
+      expect(subject).to receive(:prepare_option_for_include_all_request!)
+        .with(abc: 'def').and_return('ignore')
+      expect(subject).to receive(:prepare_option_for_include_all_request!)
+        .with(hij: 'kel').and_return('ignore')
+      expect(subject.send(:prepare_options_for_include_all_request!, [{ abc: 'def' }, { hij: 'kel' }]))
+        .to eq([{ abc: 'def' }, { hij: 'kel' }])
+    end
+  end
+
+  describe 'prepare_option_for_incldue_all_request' do
+    it 'removes all limit and offset parameters' do
+      option = { url: 'http://localhost:3000/test/resource?abc=def&limit=1&offset=3&test=2' }
+      expect(subject.send(:prepare_option_for_include_all_request!, option))
+        .to eq(option)
+      expect(option).to eq(url: 'http://localhost:3000/test/resource',
+                           params: { limit: 100, abc: 'def', test: '2' })
+    end
+
+    it 'do nothing without url' do
+      option = { param: { abc: 'def' } }
+      expect(subject.send(:prepare_option_for_include_all_request!, option))
+        .to eq(option)
+      expect(option).to eq(param: { abc: 'def' })
+    end
+
+    it 'raises an exception when url invalid' do
+      option = { param: { abc: 'def' }, url: 'http://ab de.com/resource' }
+      expect { subject.send(:prepare_option_for_include_all_request!, option) }
+        .to raise_exception(URI::InvalidURIError)
+      expect(option).to eq(param: { abc: 'def' }, url: 'http://ab de.com/resource')
+    end
+
+    it 'keeps current params over url params' do
+      option = { url: 'http://localhost:3000/test/resource?abc=def&limit=1&offset=3&test=2',
+                 params: { abc: '123' } }
+      expect(subject.send(:prepare_option_for_include_all_request!, option))
+        .to eq(option)
+      expect(option).to eq(url: 'http://localhost:3000/test/resource',
+                           params: { limit: 100, abc: '123', test: '2' })
+    end
+
+    it 'removes including and referening options' do
+      option = { url: 'http://localhost:3000/test/resource',
+                 including: 'all',
+                 referencing: 'nothing' }
+      expect(subject.send(:prepare_option_for_include_all_request!, option))
+        .to eq(option)
+      expect(option).to eq(url: 'http://localhost:3000/test/resource',
+                           params: { limit: 100 })
+    end
+  end
+end

data/spec/data/collection_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Data do
+  let(:json) do
+    load_json(:feedbacks)
+  end
+
+  let(:data) do
+    DHS::Data.new(json, nil, Record)
+  end
+
+  before do
+    class Record < DHS::Record
+      endpoint '{+datastore}/v2/data'
+    end
+  end
+
+  context 'empty collection' do
+    let(:collection) do
+      DHS::Data.new({ items: [] }, nil, Record)
+    end
+
+    it 'provides correct count and length' do
+      expect(collection.count).to eq 0
+      expect(collection.length).to eq 0
+    end
+
+    it 'returns an empty array or map' do
+      expect(collection.map { |x| }).to eq []
+    end
+  end
+
+  context 'collections' do
+    it 'forwards calls to the collection' do
+      expect(data.count).to be_kind_of Integer
+      expect(data[0]).to be_kind_of Record
+      expect(data.sample).to be_kind_of Record
+    end
+
+    it 'provides a total method to get the number of total records' do
+      expect(data.total).to be_kind_of Integer
+    end
+  end
+
+  context 'collections from arrays' do
+    let(:data) do
+      DHS::Data.new([1, 2, 3, 4])
+    end
+
+    it 'uses collection as proxy for arrays' do
+      expect(data._proxy).to be_kind_of DHS::Collection
+    end
+  end
+end

data/spec/data/equality_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Data do
+  context 'equality' do
+    before do
+      class Record < DHS::Record
+        endpoint 'http://depay.fi/records'
+      end
+    end
+
+    let(:raw) do
+      { name: 'Steve' }
+    end
+
+    it 'is equal when two data objects share the same raw data' do
+      expect(
+        DHS::Data.new(raw, nil, Record)
+      ).to eq DHS::Data.new(raw, nil, Record)
+    end
+  end
+end

data/spec/data/inspect_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Data do
+  context 'inspect' do
+    def expect_inspect_to_look_like(data, string)
+      expect(data.inspect).to eq string.gsub(/  +/, '').strip
+    end
+
+    before do
+      class Record < DHS::Record
+        endpoint 'http://depay.fi/records'
+        endpoint 'http://depay.fi/records/{id}'
+      end
+    end
+
+    let(:raw) do
+      { pets: [
+        {
+          name: 'Steve',
+          kind: {
+            animal: {
+              type: 'Monkey'
+            }
+          }
+        }
+      ] }
+    end
+
+    let(:record) do
+      stub_request(:get, 'http://depay.fi/records/1').to_return(body: raw.to_json)
+      Record.find(1)
+    end
+
+    let(:data) do
+      DHS::Data.new(raw, nil, Record).pets.first
+    end
+
+    it 'prints inspected data on multiple lines' do
+      expect_inspect_to_look_like data, %{
+        Data of Record #{data.object_id}
+        > pets > 0
+        :name => \"Steve\"
+        :kind => {:animal=>{:type=>\"Monkey\"}}
+      }
+    end
+
+    context 'breadcrumb' do
+      let(:data) { record.pets.first.kind.animal }
+
+      it 'prints the breadcrumb that shows you the current location within the main record' do
+        expect_inspect_to_look_like data, %{
+          Data of Record #{data.object_id}
+          > pets > 0 > kind > animal
+          :type => \"Monkey\"
+        }
+      end
+    end
+
+    context 'href as id' do
+      let(:href) { 'http://datastore/places/1' }
+      let(:raw) { { href: href, items: [{ name: 'Steve' }] } }
+      let(:data) { record.first }
+
+      it 'prints href as object id' do
+        expect_inspect_to_look_like data, %{
+          Record #{href}
+          :name => \"Steve\"
+        }
+      end
+    end
+
+    context 'id attribute as id' do
+      let(:id) { 1 }
+      let(:raw) { { id: id, name: 'Steve' } }
+      let(:data) { record }
+
+      it 'prints id attribute as object id' do
+        expect_inspect_to_look_like data, %{
+          Record #{id}
+          :id => 1
+          :name => \"Steve\"
+        }
+      end
+    end
+  end
+end

data/spec/data/is_item_or_collection_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Data do
+  before do
+    class Record < DHS::Record
+      endpoint 'http://depay.fi/records'
+    end
+  end
+
+  let(:item) do
+    {
+      customer: {
+        addresses: [
+          {
+            first_line: 'Bachstr. 6'
+          }
+        ]
+      }
+    }
+  end
+
+  let(:data) do
+    DHS::Data.new(
+      {
+        href: 'http://depay.fi/records',
+        items: [item]
+      }, nil, Record
+    )
+  end
+
+  it 'provides the information which type of proxy data ist' do
+    expect(data.collection?).to eq true
+    expect(data.first.item?).to eq true
+    expect(data.first.customer.item?).to eq true
+    expect(data.first.customer.addresses.collection?).to eq true
+    expect(data.first.customer.addresses.first.item?).to eq true
+  end
+end

data/spec/data/item_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Data do
+  before do
+    class Record < DHS::Record
+      endpoint '{+datastore}/v2/{campaign_id}/feedbacks'
+      endpoint '{+datastore}/v2/feedbacks'
+    end
+  end
+
+  let(:json) do
+    load_json(:feedbacks)
+  end
+
+  let(:data) do
+    DHS::Data.new(json, nil, Record)
+  end
+
+  let(:item) do
+    data[0]
+  end
+
+  context 'item' do
+    it 'makes data accessible' do
+      expect(item.href).to be_kind_of String
+      expect(item.recommended).to be_kind_of TrueClass
+      expect(item.average_rating).to be_kind_of Float
+    end
+
+    it 'returns nil if no data is present' do
+      expect(item.something).to eq nil
+    end
+
+    it 'returns TimeWithZone if string can be parsed as date_time' do
+      expect(item.created_date).to be_kind_of ActiveSupport::TimeWithZone
+    end
+
+    it 'returns date if string can be parsed as date' do
+      expect(item.valid_from).to be_kind_of Date
+    end
+  end
+
+  context 'different date time formats' do
+    context 'with numbered time zone' do
+      let(:item) do
+        item = data[0]
+        item._raw[:created_date] = '2016-07-09T13:45:00+02:00'
+        item
+      end
+
+      it 'returns TimeWithZone if string can be parsed as date_time' do
+        expect(item.created_date).to be_kind_of ActiveSupport::TimeWithZone
+      end
+
+      it 'has UTC time zone' do
+        expect(item.created_date.zone).to eq('UTC')
+      end
+
+      it 'has the right time' do
+        expect(item.created_date.hour).to eq(11)
+      end
+    end
+
+    context 'with lettered time zone' do
+      let(:item) do
+        item = data[0]
+        item._raw[:created_date] = '2016-07-09T13:45:00Z'
+        item
+      end
+
+      it 'returns TimeWithZone if string can be parsed as date_time' do
+        expect(item.created_date).to be_kind_of ActiveSupport::TimeWithZone
+      end
+
+      it 'has UTC time zone' do
+        expect(item.created_date.zone).to eq('UTC')
+      end
+
+      it 'has the right time' do
+        expect(item.created_date.hour).to eq(13)
+      end
+    end
+
+    context 'without seconds' do
+      let(:item) do
+        item = data[0]
+        item._raw[:created_date] = '2016-07-09T13:45Z'
+        item
+      end
+
+      it 'returns TimeWithZone if string can be parsed as date_time' do
+        expect(item.created_date).to be_kind_of ActiveSupport::TimeWithZone
+      end
+
+      it 'has UTC time zone' do
+        expect(item.created_date.zone).to eq('UTC')
+      end
+
+      it 'has the right time' do
+        expect(item.created_date.hour).to eq(13)
+      end
+    end
+  end
+end

data/spec/data/merge_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Data do
+  before do
+    class Record < DHS::Record
+      endpoint '{+datastore}/v2/{campaign_id}/feedbacks'
+      endpoint '{+datastore}/v2/feedbacks'
+    end
+  end
+
+  let(:data) do
+    DHS::Data.new({ href: 'http://www.depay.fi/v2/stuff' }, nil, Record)
+  end
+
+  let(:loaded_data) do
+    DHS::Data.new({ href: 'http://www.depay.fi/v2/stuff', id: '123123123' }, nil, Record)
+  end
+
+  context 'merging' do
+    it 'merges data' do
+      data.merge_raw!(loaded_data)
+      expect(data.id).to eq loaded_data.id
+    end
+  end
+end

data/spec/data/parent_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Data do
+  before do
+    class Record < DHS::Record
+      endpoint 'http://depay.fi/records'
+    end
+  end
+
+  let(:item) do
+    {
+      customer: {
+        address: {
+          first_line: 'Bachstr. 6'
+        }
+      }
+    }
+  end
+
+  let(:data) do
+    DHS::Data.new(
+      {
+        href: 'http://depay.fi/records',
+        items: [item]
+      }, nil, Record
+    )
+  end
+
+  it 'possible to navigate the parent' do
+    expect(
+      data.first.customer.address.parent
+    ).to eq data.first.customer
+    expect(
+      data.first.customer.address.parent.parent
+    ).to eq data.first
+  end
+end