acfs 1.3.3 → 1.3.4

data/spec/acfs/resource/validation_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Resource::Validation do
+  let(:params) { {name: 'john smith', age: 24} }
+  let(:model) { MyUserWithValidations.new params }
+
+  describe '#valid?' do
+    context 'with valid attributes' do
+      subject { model }
+
+      it { should be_valid }
+    end
+
+    context 'with invalid attributes' do
+      let(:params) { {name: 'invname'} }
+      subject { model }
+
+      it { should_not be_valid }
+    end
+
+    context 'on resource with service side errors' do
+      before { Acfs::Stub.enable }
+      after  { Acfs::Stub.disable }
+
+      before do
+        Acfs::Stub.resource MyUser, :create, return: {errors: {name: ['can\'t be blank']}}, raise: 422
+      end
+
+      let(:params)   { {} }
+      let(:resource) { MyUser.create params }
+      subject { resource }
+
+      it { should_not be_valid }
+
+      it 'should not override errors' do
+        subject.valid?
+        expect(subject.errors.to_hash).to eq(name: ['can\'t be blank'])
+      end
+    end
+  end
+
+  describe '#errors' do
+    context 'with valid attributes' do
+      let(:params) { {name: 'john smith', age: 24} }
+      before { model.valid? }
+      subject { model.errors }
+
+      it { should be_empty }
+    end
+
+    context 'with invalid attributes' do
+      let(:params) { {name: 'john'} }
+      before { model.valid? }
+      subject { model.errors }
+
+      it { should_not be_empty }
+      it { should have(2).items }
+
+      it 'should contain a list of error messages' do
+        expect(subject.to_hash).to eq age: ["can't be blank"], name: ['is invalid']
+      end
+    end
+
+    context 'server side errors' do
+      before { Acfs::Stub.enable }
+      after  { Acfs::Stub.disable }
+
+      before do
+        Acfs::Stub.resource MyUser, :create,
+          with: {}, return: {errors: errors}, raise: 422
+      end
+
+      let(:params)   { {} }
+      let(:resource) { MyUser.create params }
+      subject { resource.errors.to_hash }
+
+      context 'with `field => [messages]` payload' do
+        let(:errors) { {name: ['cannot be blank']} }
+
+        it { is_expected.to eq(name: ['cannot be blank']) }
+      end
+
+      context 'with `field => message` payload' do
+        let(:errors) { {name: 'cannot be blank'} }
+
+        it { is_expected.to eq(name: ['cannot be blank']) }
+      end
+
+      context 'with `[messages]` payload' do
+        let(:errors) { ['cannot be blank'] }
+
+        it { is_expected.to eq(base: ['cannot be blank']) }
+      end
+    end
+  end
+
+  describe '#save!' do
+    subject { -> { model.save! } }
+    before { allow(model).to receive(:operation) }
+
+    context 'with invalid attributes' do
+      let(:params) { {name: 'john'} }
+
+      it { expect { subject.call }.to raise_error Acfs::InvalidResource }
+    end
+
+    context 'on new resource' do
+      it 'should validate with `create` context' do
+        expect(model).to receive(:valid?).with(:create).and_call_original
+        subject.call
+      end
+    end
+
+    context 'on changed resource' do
+      before { model.loaded! }
+      let(:model) { super().tap {|m| m.id = 1 } }
+
+      it 'should validate with `save` context' do
+        expect(model).to receive(:valid?).with(:save).and_call_original
+        subject.call
+      end
+    end
+  end
+
+  describe 'validates with context' do
+  end
+end

data/spec/acfs/response/formats_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Response::Formats do
+  let(:status)    { 200 }
+  let(:mime_type) { 'application/unknown' }
+  let(:headers)   { {'Content-Type' => mime_type} }
+  let(:request)   { Acfs::Request.new 'fubar' }
+  let(:body)      { nil }
+  let(:response)  { Acfs::Response.new request, status: status, headers: headers, body: body }
+
+  context 'without Content-Type header' do
+    let(:headers) { {} }
+
+    it "should fallback on 'text/plain'" do
+      expect(response.content_type).to be == Mime[:text]
+    end
+  end
+
+  context 'with JSON mimetype' do
+    let(:mime_type) { 'application/json' }
+
+    describe '#content_type' do
+      it 'should return Mime::JSON' do
+        expect(response.content_type).to be == Mime[:json]
+      end
+    end
+
+    describe '#json?' do
+      it 'should return true' do
+        expect(response).to be_json
+      end
+    end
+
+    context 'with charset option' do
+      let(:mime_type) { 'application/json; charset=utf8' }
+
+      describe '#content_type' do
+        it 'should return Mime::JSON' do
+          expect(response.content_type).to be == Mime[:json]
+        end
+      end
+
+      describe '#json?' do
+        it 'should return true' do
+          expect(response).to be_json
+        end
+      end
+    end
+  end
+end

data/spec/acfs/response/status_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Response::Status do
+  let(:status)    { 200 }
+  let(:mime_type) { 'application/unknown' }
+  let(:headers)   { {'Content-Type' => mime_type} }
+  let(:request)   { Acfs::Request.new 'fubar' }
+  let(:body)      { nil }
+  let(:response)  { Acfs::Response.new request, status: status, headers: headers, body: body }
+
+  describe '#status_code alias #code' do
+    context 'when given' do
+      let(:status) { 200 }
+
+      it 'should return status code' do
+        expect(response.code).to be == 200
+        expect(response.status_code).to be == 200
+      end
+    end
+
+    context 'when nil' do
+      let(:status) { nil }
+
+      it 'should return zero' do
+        expect(response.code).to be == 0
+        expect(response.status_code).to be == 0
+      end
+    end
+  end
+
+  describe '#success?' do
+    context 'with success status code' do
+      let(:status) { 200 }
+      it { expect(response).to be_success }
+    end
+
+    context 'with error status code' do
+      let(:status) { 500 }
+      it { expect(response).to_not be_success }
+    end
+
+    context 'with zero status code' do
+      let(:status) { nil }
+      it { expect(response).to_not be_success }
+    end
+  end
+
+  describe '#modified?' do
+    context 'with success status code' do
+      let(:status) { 200 }
+      it { expect(response).to be_modified }
+    end
+
+    context 'with not modified status code' do
+      let(:status) { 304 }
+      it { expect(response).to_not be_modified }
+    end
+
+    context 'with error status code' do
+      let(:status) { 500 }
+      it { expect(response).to be_modified }
+    end
+
+    context 'with zero status code' do
+      let(:status) { nil }
+      it { expect(response).to be_modified }
+    end
+  end
+end

data/spec/acfs/runner_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class NullAdapter < Acfs::Adapter::Base
+  # Start processing queued requests.
+  #
+  def start; end
+
+  # Abort running and queued requests.
+  #
+  def abort; end
+
+  # Run request right now skipping queue.
+  #
+  def run(_); end
+
+  # Enqueue request to be run later.
+  #
+  def queue(_); end
+end
+
+class NotificationCollector
+  def call(*args)
+    events << ActiveSupport::Notifications::Event.new(*args)
+  end
+
+  def events
+    @events ||= []
+  end
+end
+
+describe ::Acfs::Runner do
+  let(:adapter) { ::NullAdapter.new }
+  let(:runner) { ::Acfs::Runner.new adapter }
+  let(:collector) { NotificationCollector.new }
+  let(:collector2) { NotificationCollector.new }
+
+  after do
+    ::ActiveSupport::Notifications.notifier = \
+      ::ActiveSupport::Notifications::Fanout.new
+  end
+
+  describe '#instrumentation' do
+    before do
+      ::ActiveSupport::Notifications.subscribe(/^acfs\.runner/, collector)
+      ::ActiveSupport::Notifications.subscribe(/^acfs\.operation/, collector2)
+    end
+
+    describe '#process' do
+      it 'should trigger event' do
+        runner.process ::Acfs::Operation.new MyUser, :read, params: {id: 0}
+        expect(collector.events).to have(1).items
+        expect(collector2.events).to have(1).items
+      end
+    end
+
+    describe '#run' do
+      it 'should trigger event' do
+        runner.run ::Acfs::Operation.new MyUser, :read, params: {id: 0}
+        expect(collector.events).to have(1).items
+        expect(collector2.events).to have(0).items
+      end
+    end
+
+    describe '#enqueue' do
+      it 'should trigger event' do
+        runner.enqueue ::Acfs::Operation.new MyUser, :read, params: {id: 0}
+        expect(collector.events).to have(1).items
+        expect(collector2.events).to have(0).items
+      end
+    end
+  end
+
+  describe '#run' do
+    before do
+      expect_any_instance_of(UserService).to receive(:prepare).and_return nil
+    end
+    it 'it should not do requests when a middleware aborted' do
+      expect(adapter).to_not receive :run
+      runner.run ::Acfs::Operation.new MyUser, :read, params: {id: 0}
+    end
+  end
+
+  describe '#enqueue' do
+    before do
+      expect_any_instance_of(UserService).to receive(:prepare).and_return nil
+    end
+    it 'it should not do requests when a middleware aborted' do
+      expect(adapter).to_not receive :queue
+      runner.enqueue ::Acfs::Operation.new MyUser, :read, params: {id: 0}
+      runner.start
+    end
+  end
+end

data/spec/acfs/service/middleware_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class TestMiddleware < Acfs::Middleware::Base
+end
+
+describe Acfs::Service::Middleware do
+  let(:srv_class) { Class.new(Acfs::Service) }
+  let(:options) { {} }
+  let(:middleware) { TestMiddleware }
+
+  describe '.use' do
+    let(:options) { {abc: 'cde'} }
+
+    it 'should add middleware to list' do
+      srv_class.use middleware
+
+      expect(srv_class.middleware).to include(middleware)
+    end
+
+    it 'should add middleware to stack' do
+      srv_class.use middleware
+
+      expect(srv_class.middleware.build(1)).to be_a(middleware)
+    end
+
+    it 'should instantiate middleware object' do
+      expect(middleware).to receive(:new).with(anything, options)
+
+      srv_class.use middleware, options
+      srv_class.middleware.build
+    end
+  end
+end

data/spec/acfs/service_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Service do
+  let(:srv_class) { Class.new(Acfs::Service) { identity :test } }
+  let(:options) { {} }
+  let(:service) { srv_class.new options }
+
+  before do
+    Acfs::Configuration.current.locate :test, ''
+  end
+
+  describe '#initialize' do
+    let(:options) { {path: 'abc', key: 'value'} }
+
+    it 'should set options' do
+      expect(service.options).to eq(options)
+    end
+  end
+
+  describe '#location' do
+    let(:resource) { Class.new }
+    before { allow(resource).to receive(:location_default_path, &proc {|_a, p| p }) }
+
+    it 'should extract resource path name from given class' do
+      expect(service.location(resource).to_s).to eq('/classes')
+    end
+
+    context 'with path options' do
+      let(:options) { {path: 'abc'} }
+
+      it 'should have custom resource path' do
+        expect(service.location(resource).to_s).to eq('/abc')
+      end
+    end
+  end
+
+  describe '.base_url' do
+    before do
+      Acfs::Configuration.current.locate :test, 'http://abc.de/api/v1'
+    end
+
+    it 'should return configured URI for service' do
+      expect(srv_class.base_url).to eq('http://abc.de/api/v1')
+    end
+  end
+end

data/spec/acfs/singleton_resource_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::SingletonResource do
+  let(:model) { Single }
+
+  describe '.find' do
+    before do
+      stub_request(:get, 'http://users.example.org/singles')
+        .to_return response id: 1
+    end
+
+    let(:action) { ->(cb) { model.find(&cb) } }
+    it_should_behave_like 'a query method with multi-callback support'
+  end
+end