acfs 1.3.3 → 1.3.4

data/spec/acfs/collection_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Collection do
+  let(:model) { MyUser }
+
+  describe 'Pagination' do
+    let(:params) { {} }
+    let!(:collection) { model.all params }
+
+    subject { Acfs.run; collection }
+
+    context 'without explicit page parameter' do
+      before do
+        stub_request(:get, 'http://users.example.org/users')
+          .to_return response([{id: 1, name: 'Anon', age: 12, born_at: 'Berlin'}],
+            headers: {
+              'X-Total-Pages' => '2',
+              'X-Total-Count' => '10'
+            })
+      end
+
+      its(:total_pages) { should eq 2 }
+      its(:current_page) { should eq 1 }
+      its(:total_count) { should eq 10 }
+    end
+
+    context 'with page parameter' do
+      let(:params) { {page: 2} }
+      before do
+        stub_request(:get, 'http://users.example.org/users?page=2')
+          .to_return response([{id: 1, name: 'Anon', age: 12, born_at: 'Berlin'}],
+            headers: {
+              'X-Total-Pages' => '2',
+              'X-Total-Count' => '10'
+            })
+      end
+
+      its(:total_pages) { should eq 2 }
+      its(:current_page) { should eq 2 }
+      its(:total_count) { should eq 10 }
+    end
+
+    context 'with non-numerical page parameter' do
+      let(:params) { {page: 'e546f5'} }
+      before do
+        stub_request(:get, 'http://users.example.org/users?page=e546f5')
+          .to_return response([{id: 1, name: 'Anon', age: 12, born_at: 'Berlin'}],
+            headers: {
+              'X-Total-Pages' => '2',
+              'X-Total-Count' => '10'
+            })
+      end
+
+      its(:total_pages) { should eq 2 }
+      its(:current_page) { should eq 'e546f5' }
+      its(:total_count) { should eq 10 }
+    end
+
+    describe '#next_page' do
+      before do
+        stub_request(:get, 'http://users.example.org/users')
+          .to_return response([{id: 1, name: 'Anon', age: 12, born_at: 'Berlin'}],
+            headers: {
+              'X-Total-Pages' => '2',
+              'Link' => '<http://users.example.org/users?page=2>; rel="next"'
+            })
+      end
+      let!(:req) do
+        stub_request(:get, 'http://users.example.org/users?page=2').to_return response([])
+      end
+      let!(:collection) { model.all }
+      subject { Acfs.run; collection.next_page }
+
+      it { should be_a Acfs::Collection }
+
+      it 'should have fetched page 2' do
+        subject
+        Acfs.run
+        expect(req).to have_been_requested
+      end
+    end
+
+    describe '#prev_page' do
+      before do
+        stub_request(:get, 'http://users.example.org/users?page=2')
+          .to_return response([{id: 2, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+            headers: {
+              'X-Total-Pages' => '2',
+              'Link' => '<http://users.example.org/users>; rel="prev"'
+            })
+      end
+      let!(:req) do
+        stub_request(:get, 'http://users.example.org/users').to_return response([])
+      end
+      let!(:collection) { model.all page: 2 }
+      subject { Acfs.run; collection.prev_page }
+
+      it { should be_a Acfs::Collection }
+
+      it 'should have fetched page 1' do
+        subject
+        Acfs.run
+        expect(req).to have_been_requested
+      end
+    end
+
+    describe '#first_page' do
+      before do
+        stub_request(:get, 'http://users.example.org/users?page=2')
+          .to_return response([{id: 2, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+            headers: {
+              'X-Total-Pages' => '2',
+              'Link' => '<http://users.example.org/users>; rel="first"'
+            })
+      end
+      let!(:req) do
+        stub_request(:get, 'http://users.example.org/users').to_return response([])
+      end
+      let!(:collection) { model.all page: 2 }
+      subject { Acfs.run; collection.first_page }
+
+      it { should be_a Acfs::Collection }
+
+      it 'should have fetched page 1' do
+        subject
+        Acfs.run
+        expect(req).to have_been_requested
+      end
+    end
+
+    describe '#last_page' do
+      before do
+        stub_request(:get, 'http://users.example.org/users?page=2')
+          .to_return response([{id: 2, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+            headers: {
+              'X-Total-Pages' => '2',
+              'Link' => '<http://users.example.org/users?page=12>; rel="last"'
+            })
+      end
+      let!(:req) do
+        stub_request(:get, 'http://users.example.org/users?page=12').to_return response([])
+      end
+      let!(:collection) { model.all page: 2 }
+      subject { Acfs.run; collection.last_page }
+
+      it { should be_a Acfs::Collection }
+
+      it 'should have fetched page 1' do
+        subject
+        Acfs.run
+        expect(req).to have_been_requested
+      end
+    end
+  end
+end

data/spec/acfs/configuration_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Configuration do
+  let(:cfg) { Acfs::Configuration.new }
+  before { @configuration = Acfs::Configuration.current.dup }
+  after { Acfs::Configuration.set @configuration }
+
+  describe 'Acfs.configure' do
+    it 'should invoke configure on current configuration' do
+      expect(Acfs::Configuration.current).to receive(:configure).once.and_call_original
+
+      Acfs.configure do |c|
+        expect(c).to be_a Acfs::Configuration
+      end
+    end
+  end
+
+  describe '.load' do
+    it 'should be able to load YAML' do
+      cfg.configure do
+        load 'spec/fixtures/config.yml'
+      end
+
+      expect(cfg.locate(UserService).to_s).to be == 'http://localhost:3001/'
+      expect(cfg.locate(CommentService).to_s).to be == 'http://localhost:3002/'
+    end
+
+    context 'with RACK_ENV' do
+      before { @env = ENV['RACK_ENV']; ENV['RACK_ENV'] = 'production' }
+      after  { ENV['RACK_ENV'] = @env }
+
+      it 'should load ENV block' do
+        cfg.configure do
+          load 'spec/fixtures/config.yml'
+        end
+
+        expect(cfg.locate(UserService).to_s).to be == 'http://user.example.org/'
+        expect(cfg.locate(CommentService).to_s).to be == 'http://comment.example.org/'
+      end
+    end
+  end
+
+  describe '#adapter' do
+    let(:object) { Object.new }
+
+    it 'should be a accessor' do
+      cfg.adapter = object
+      expect(cfg.adapter).to eq object
+    end
+  end
+end

data/spec/acfs/global_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class NotificationCollector
+  def call(*args)
+    events << ActiveSupport::Notifications::Event.new(*args)
+  end
+
+  def events
+    @events ||= []
+  end
+end
+
+describe ::Acfs::Global do
+  let(:adapter) { ::NullAdapter.new }
+  let(:runner) { double 'runner' }
+  let(:collector) { NotificationCollector.new }
+  let(:acfs) { Object.new.tap {|o| o.extend ::Acfs::Global } }
+
+  describe 'instrumentation' do
+    before do
+      # allow(runner).to receive(:start)
+      allow(acfs).to receive(:runner).and_return runner
+    end
+
+    describe '#run' do
+      before do
+        ::ActiveSupport::Notifications.subscribe 'acfs.run', collector
+      end
+      it 'should trigger event' do
+        Acfs.run
+        expect(collector.events).to have(1).items
+      end
+    end
+
+    describe '#reset' do
+      before do
+        ::ActiveSupport::Notifications.subscribe 'acfs.reset', collector
+      end
+      it 'should trigger event' do
+        Acfs.reset
+        expect(collector.events).to have(1).items
+      end
+    end
+  end
+
+  describe '#on' do
+    before do
+      stub_request(:get, %r{http://users.example.org/users/\d+}).to_return(
+        status: 200,
+        body: '{}',
+        headers: {'Content-Type' => 'application/json'}
+      )
+    end
+
+    it 'should invoke when both resources' do
+      user1 = MyUser.find 1
+      user2 = MyUser.find 2
+
+      expect do |cb|
+        Acfs.on(user1, user2, &cb)
+        Acfs.run
+      end.to yield_with_args(user1, user2)
+    end
+
+    it 'should invoke when both resources when loaded' do
+      user1 = MyUser.find 1
+      user2 = MyUser.find 2
+
+      Acfs.on(user1, user2) do |u1, u2|
+        expect(u1).to be_loaded
+        expect(u2).to be_loaded
+      end
+      Acfs.run
+    end
+
+    context 'with an empty result for a find_by call' do
+      before do
+        stub_request(:get, %r{http://users.example.org/users})
+          .with(query: {id: '2'})
+          .to_return(
+            status: 200,
+            body: '{}',
+            headers: {'Content-Type' => 'application/json'}
+          )
+      end
+
+      it 'invokes once both requests are finished' do
+        user1 = MyUser.find 1
+        user2 = MyUser.find_by id: 2
+
+        expect do |cb|
+          Acfs.on(user1, user2, &cb)
+          Acfs.run
+        end.to yield_with_args(user1, be_nil)
+      end
+
+      it 'invokes once remaining requests are finished' do
+        user1 = MyUser.find 1
+        Acfs.run # Finish the first request
+
+        user2 = MyUser.find_by id: 2
+
+        expect do |cb|
+          Acfs.on(user1, user2, &cb)
+          Acfs.run
+        end.to yield_with_args(user1, be_nil)
+      end
+
+      it 'invokes immediately when all requests have already been finished' do
+        user1 = MyUser.find 1
+        user2 = MyUser.find_by id: 2
+        Acfs.run
+
+        expect do |cb|
+          Acfs.on(user1, user2, &cb)
+        end.to yield_with_args(user1, be_nil)
+      end
+    end
+  end
+
+  describe '#runner' do
+    it 'returns per-thread runner' do
+      runner1 = Thread.new { acfs.runner } .value
+      runner2 = Thread.new { acfs.runner } .value
+
+      expect(runner1).to_not equal runner2
+    end
+
+    it 'uses configurated adapter' do
+      adapter = double :adapter
+      expect(Acfs::Configuration.current).to receive(:adapter).and_return(-> { adapter })
+
+      runner = Thread.new { acfs.runner }.value
+
+      expect(runner.adapter).to equal adapter
+    end
+  end
+end

data/spec/acfs/location_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ::Acfs::Location do
+  let(:location) { described_class.new(uri, args) }
+  let(:uri)      { 'http://localhost/users/:id' }
+  let(:args)     { {id: 4} }
+
+  describe '#str' do
+    subject(:str) { location.str }
+
+    it 'replaces variables with values' do
+      expect(str).to eq 'http://localhost/users/4'
+    end
+
+    context 'with special characters' do
+      let(:args) { {id: '4 [@(\/!^$'} }
+
+      it 'escapes special characters' do
+        expect(str).to eq 'http://localhost/users/4+%5B%40%28%5C%2F%21%5E%24'
+      end
+    end
+  end
+end

data/spec/acfs/middleware/json_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Middleware::JSON do
+  let(:data)     { [{id: 1, name: 'Anon'}, {id: 2, name: 'John', friends: [1]}] }
+  let(:body)     { '' }
+  let(:headers)  { {} }
+  let(:request)  { Acfs::Request.new 'url', method: 'GET', data: data }
+  let(:response) { Acfs::Response.new request, status: 200, headers: headers, body: body }
+  let(:decoder)  { Acfs::Middleware::JSON.new ->(req) { req } }
+
+  before do
+    decoder.call request
+  end
+
+  describe 'encode' do
+    context 'with not serialized request' do
+      it 'should set Content-Type' do
+        expect(request.headers['Content-Type']).to eq 'application/json'
+      end
+
+      it 'should append Accept header' do
+        expect(request.headers['Accept']).to eq 'application/json;q=1'
+      end
+
+      it 'should serialize data to JSON' do
+        expect(JSON.parse(request.body)).to eq data.map(&:stringify_keys)
+      end
+    end
+  end
+
+  describe 'decode' do
+    context 'with JSON response' do
+      let(:headers) { {'Content-Type' => 'application/json; charset=utf-8'} }
+      let(:body)    { data.to_json }
+
+      it 'should decode body data' do
+        request.complete! response
+
+        expect(response.data).to be == data.map(&:stringify_keys)
+      end
+    end
+
+    context 'with invalid JSON response' do
+      let(:headers) { {'Content-Type' => 'application/json'} }
+      let(:body)    { data.to_json[4..-4] }
+
+      it 'should raise an error' do
+        expect { request.complete! response }.to raise_error(MultiJson::LoadError)
+      end
+    end
+
+    context 'without JSON response' do
+      let(:headers) { {'Content-Type' => 'application/text'} }
+      let(:body)    { data.to_json }
+
+      it 'should not decode non-JSON encoded responses' do
+        request.complete! response
+
+        expect(response.data).to be_nil
+      end
+    end
+  end
+end

data/spec/acfs/middleware/msgpack_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Middleware::MessagePack do
+  let(:data)     { [{id: 1, name: 'Anon'}, {id: 2, name: 'John', friends: [1]}] }
+  let(:body)     { '' }
+  let(:headers)  { {} }
+  let(:request)  { Acfs::Request.new 'url', data: data }
+  let(:response) { Acfs::Response.new request, status: 200, headers: headers, body: body }
+  let(:decoder)  { Acfs::Middleware::MessagePack.new ->(req) { req } }
+
+  before do
+    decoder.call request
+  end
+
+  describe 'encode' do
+    context 'with not serialized request' do
+      it 'should set Content-Type' do
+        expect(request.headers['Content-Type']).to eq 'application/x-msgpack'
+      end
+
+      it 'should append Accept header' do
+        expect(request.headers['Accept']).to eq 'application/x-msgpack;q=1'
+      end
+
+      context 'with JSON chained' do
+        let(:decoder) { Acfs::Middleware::JSON.new super(), q: 0.5 }
+
+        it 'should append to Accept header' do
+          expect(request.headers['Accept']).to eq 'application/json;q=0.5,application/x-msgpack;q=1'
+        end
+      end
+
+      it 'should serialize data to MessagePack' do
+        expect(MessagePack.unpack(request.body)).to eq data.map(&:stringify_keys)
+      end
+    end
+  end
+
+  context 'with Message Pack response' do
+    let(:headers) { {'Content-Type' => 'application/x-msgpack'} }
+    let(:body)    { MessagePack.pack data }
+
+    it 'should decode body data' do
+      request.complete! response
+
+      expect(response.data).to be == data.map(&:stringify_keys)
+    end
+  end
+
+  context 'without Message Pack response' do
+    let(:headers) { {'Content-Type' => 'application/text'} }
+    let(:body)    { data.to_json }
+
+    it 'should not decode non-MessagePack encoded responses' do
+      request.complete! response
+
+      expect(response.data).to be_nil
+    end
+  end
+end