acfs 1.3.2 → 1.3.3

data/spec/acfs/resource/validation_spec.rb

@@ -1,127 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

data/spec/acfs/stub_spec.rb

@@ -1,343 +0,0 @@
-require 'spec_helper'
-
-class SpecialCustomError < StandardError; end
-
-describe Acfs::Stub do
-  let(:stub) { Class.new(Acfs::Stub) }
-
-  before(:all) { Acfs::Stub.enable }
-  after(:all) { Acfs::Stub.disable }
-
-  before do
-    Acfs::Stub.allow_requests = false
-  end
-
-  describe '#called?' do
-    context 'without specified number' do
-      let!(:operation) { Acfs::Stub.resource MyUser, :read, with: {id: 1}, return: {id: 1, name: 'John Smith', age: 32} }
-
-      it 'should allow to test if stub was called' do
-        MyUser.find 1
-        Acfs.run
-
-        expect(operation).to be_called
-      end
-
-      it 'should allow to test if stub was called a specific number of times' do
-        MyUser.find 1
-        Acfs.run
-
-        MyUser.find 1
-        Acfs.run
-
-        expect(operation).to be_called 2.times
-      end
-    end
-  end
-
-  describe '.resource' do
-    context 'with ambiguous stubs' do
-      before do
-        Acfs::Stub.resource MyUser, :read, with: {id: 1}, return: {id: 1, name: 'John Smith', age: 32}
-        Acfs::Stub.resource MyUser, :read, with: {id: 1}, raise: :not_found
-      end
-
-      it 'should raise error' do
-        MyUser.find 1
-
-        expect { Acfs.run }.to raise_error(Acfs::AmbiguousStubError)
-      end
-    end
-
-    context 'with read action' do
-      before do
-        Acfs::Stub.resource MyUser, :read, with: {id: 1}, return: {id: 1, name: 'John Smith', age: 32}
-        Acfs::Stub.resource MyUser, :read, with: {id: 2}, raise: SpecialCustomError
-        Acfs::Stub.resource MyUser, :read, with: {id: 3}, raise: :not_found
-      end
-
-      it 'should allow to stub resource reads' do
-        user = MyUser.find 1
-        Acfs.run
-
-        expect(user.id).to be == 1
-        expect(user.name).to be == 'John Smith'
-        expect(user.age).to be == 32
-      end
-
-      context 'with error' do
-        it 'should allow to raise errors' do
-          MyUser.find 2
-
-          expect { Acfs.run }.to raise_error(SpecialCustomError)
-        end
-
-        it 'should allow to raise symbolic errors' do
-          MyUser.find 3
-
-          expect { Acfs.run }.to raise_error(Acfs::ResourceNotFound)
-        end
-      end
-
-      context 'with type parameter' do
-        before do
-          Acfs::Stub.resource Computer, :read, with: {id: 1}, return: {id: 1, type: 'PC'}
-          Acfs::Stub.resource Computer, :read, with: {id: 2}, return: {id: 2, type: 'Mac'}
-        end
-
-        it 'should create inherited type' do
-          pc = Computer.find 1
-          mac = Computer.find 2
-
-          Acfs.run
-
-          expect(pc).to be_a PC
-          expect(mac).to be_a Mac
-        end
-      end
-    end
-
-    context 'with create action' do
-      before do
-        Acfs::Stub.resource Session, :create, with: {ident: 'john@exmaple.org', password: 's3cr3t'}, return: {id: 'longhash', user: 1}
-        Acfs::Stub.resource Session, :create, with: ->(op) { op.data[:ident] == 'john@exmaple.org' && op.data[:password] == 'wrong' }, raise: 422
-      end
-
-      it 'should allow stub resource creation' do
-        session = Session.create! ident: 'john@exmaple.org', password: 's3cr3t'
-
-        expect(session.id).to be == 'longhash'
-        expect(session.user).to be == 1
-      end
-
-      it 'should allow to raise error' do
-        expect do
-          Session.create! ident: 'john@exmaple.org', password: 'wrong'
-        end.to raise_error(::Acfs::InvalidResource)
-      end
-    end
-
-    context 'with list action' do
-      before do
-        Acfs::Stub.resource MyUser, :list,
-          return: [{id: 1, name: 'John Smith', age: 32}, {id: 2, name: 'Anon', age: 12}]
-      end
-
-      it 'should return collection' do
-        users = MyUser.all
-        Acfs.run
-
-        expect(users).to have(2).items
-      end
-
-      it 'should return defined resources' do
-        users = MyUser.all
-        Acfs.run
-
-        expect(users[0].id).to eq 1
-        expect(users[1].id).to eq 2
-        expect(users[0].name).to eq 'John Smith'
-        expect(users[1].name).to eq 'Anon'
-      end
-
-      context 'with type parameter' do
-        before do
-          Acfs::Stub.resource Computer, :list,
-            return: [{id: 1, type: 'PC'}, {id: 2, type: 'Mac'}]
-        end
-
-        it 'should create inherited type' do
-          computers = Computer.all
-          Acfs.run
-
-          expect(computers.first).to be_a PC
-          expect(computers.last).to be_a Mac
-        end
-      end
-
-      context 'with header' do
-        before do
-          Acfs::Stub.resource Comment, :list,
-            return: [{id: 1, text: 'Foo'}, {id: 2, text: 'Bar'}],
-            headers: headers
-        end
-
-        let!(:comments) { Comment.all }
-        let(:headers) do
-          {
-            'X-Total-Pages' => '2',
-            'X-Total-Count' => '10'
-          }
-        end
-        subject { Acfs.run; comments }
-
-        its(:total_pages) { should eq 2 }
-        its(:total_count) { should eq 10 }
-      end
-    end
-
-    context 'with update action' do
-      before do
-        Acfs::Stub.resource MyUser, :read, with: {id: 1}, return: {id: 1, name: 'John Smith', age: 32}
-        Acfs::Stub.resource MyUser, :update, with: {id: 1, name: 'John Smith', age: 22}, return: {id: 1, name: 'John Smith', age: 23}
-        Acfs::Stub.resource MyUser, :update, with: {id: 1, name: 'John Smith', age: 0}, raise: 422
-      end
-
-      let!(:update_stub) do
-        Acfs::Stub.resource MyUser, :update,
-          with: {id: 1, name: 'Jane Smith'},
-          return: ->(op) { Hash[op.data.map {|k, v| [k, v.to_s.upcase] }] }
-      end
-
-      it 'should allow stub resource update' do
-        user = MyUser.find 1
-        Acfs.run
-
-        user.age = 22
-        user.save!
-
-        expect(user.age).to be == 23
-      end
-
-      it 'should allow to raise error' do
-        user = MyUser.find 1
-        Acfs.run
-
-        user.age = 0
-        user.save
-
-        expect do
-          user.save!
-        end.to raise_error(::Acfs::InvalidResource)
-      end
-
-      it 'should match partial :with' do
-        user = MyUser.find 1
-        Acfs.run
-
-        user.age = 5
-        user.name = 'Jane Smith'
-        user.save!
-
-        expect(update_stub).to be_called
-      end
-
-      it 'should process response body' do
-        user = MyUser.find 1
-        Acfs.run
-
-        user.age = 5
-        user.name = 'Jane Smith'
-        user.save!
-
-        expect(user.name).to eq 'JANE SMITH'
-      end
-    end
-
-    context 'with create action' do
-      before do
-        Acfs::Stub.resource MyUser, :create, with: {name: 'John Smith', age: 0}, raise: 422
-      end
-
-      it 'should allow to raise error' do
-        expect do
-          MyUser.create! name: 'John Smith', age: 0
-        end.to raise_error(::Acfs::InvalidResource)
-      end
-    end
-  end
-
-  describe '.allow_requests=' do
-    context 'when enabled' do
-      before do
-        Acfs::Stub.allow_requests = true
-        stub_request(:get, 'http://users.example.org/users/2').to_return response(id: 2, name: 'John', age: 26)
-      end
-
-      it 'should allow real requests' do
-        @user = MyUser.find 2
-        expect { Acfs.run }.to_not raise_error
-      end
-    end
-
-    context 'when disabled' do
-      before do
-        Acfs::Stub.allow_requests = false
-      end
-
-      it 'should not allow real requests' do
-        @user = MyUser.find 2
-        expect { Acfs.run }.to raise_error(Acfs::RealRequestsNotAllowedError)
-      end
-    end
-  end
-
-  describe 'accept?' do
-    subject { stub.accept?(op) }
-
-    context 'with a match in params' do
-      let(:op) do
-        double('operation').tap do |op|
-          allow(op).to receive(:full_params).and_return(id: 1337, blub: 'abc')
-          allow(op).to receive(:data).and_return({})
-        end
-      end
-
-      let(:stub) { Acfs::Stub.resource MyUser, :read, with: {id: 1337} }
-
-      it { is_expected.to be true }
-    end
-
-    context 'with a match in data' do
-      let(:op) do
-        double('operation').tap do |op|
-          allow(op).to receive(:full_params).and_return({})
-          allow(op).to receive(:data).and_return(id: 1337, blub: 'abc')
-        end
-      end
-
-      let(:stub) { Acfs::Stub.resource MyUser, :read, with: {id: 1337} }
-
-      it { is_expected.to be true }
-    end
-
-    context 'with no match in params nor data' do
-      let(:op) do
-        double('operation').tap do |op|
-          allow(op).to receive(:full_params).and_return(id: 1337)
-          allow(op).to receive(:data).and_return({})
-        end
-      end
-
-      let(:stub) { Acfs::Stub.resource MyUser, :read, with: {abc: '123'} }
-
-      it { is_expected.to be false }
-    end
-
-    context 'with a wrong match' do
-      let(:op) do
-        double('operation').tap do |op|
-          allow(op).to receive(:full_params).and_return(id: 1337, blub: 'abc')
-          allow(op).to receive(:data).and_return({})
-        end
-      end
-
-      let(:stub) { Acfs::Stub.resource MyUser, :read, with: {id: 1337, blub: '123'} }
-
-      it { is_expected.to be false }
-    end
-
-    context 'with a missing match' do
-      let(:op) do
-        double('operation').tap do |op|
-          allow(op).to receive(:full_params).and_return(id: 1337, blub: 'abc')
-          allow(op).to receive(:data).and_return({})
-        end
-      end
-
-      let(:stub) { Acfs::Stub.resource MyUser, :read, with: {id: 1337, answer: 42} }
-
-      it { is_expected.to be false }
-    end
-  end
-end