acfs 1.6.0 → 2.0.0

data/spec/acfs/resource/validation_spec.rb

@@ -10,61 +10,70 @@ describe Acfs::Resource::Validation do
     context 'with valid attributes' do
       subject { model }
 
-      it { should be_valid }
+      it { is_expected.to be_valid }
     end
 
     context 'with invalid attributes' do
-      let(:params) { {name: 'invname'} }
       subject { model }
 
-      it { should_not be_valid }
+      let(:params) { {name: 'invname'} }
+
+      it { is_expected.not_to be_valid }
     end
 
     context 'on resource with service side errors' do
+      subject(:resource) { MyUser.create(params) }
+
       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 }
+      let(:params) { {} }
 
-      it { should_not be_valid }
+      it { is_expected.not_to be_valid }
 
-      it 'should not override errors' do
-        subject.valid?
-        expect(subject.errors.to_hash).to eq(name: ['can\'t be blank'])
+      it 'does not override errors' do
+        resource.valid?
+        expect(resource.errors.to_hash).to eq(name: ['can\'t be blank'])
       end
     end
   end
 
   describe '#errors' do
     context 'with valid attributes' do
+      subject { model.errors }
+
       let(:params) { {name: 'john smith', age: 24} }
+
       before { model.valid? }
-      subject { model.errors }
 
-      it { should be_empty }
+      it { is_expected.to be_empty }
     end
 
     context 'with invalid attributes' do
+      subject(:errors) { model.errors }
+
       let(:params) { {name: 'john'} }
+
       before { model.valid? }
-      subject { model.errors }
 
-      it { should_not be_empty }
-      it { should have(2).items }
+      it { is_expected.not_to be_empty }
+      it { is_expected.to 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']
+      it 'contains a list of error messages' do
+        expect(errors.to_hash).to eq age: ["can't be blank"], name: ['is invalid']
       end
     end
 
     context 'server side errors' do
+      subject { resource.errors.to_hash }
+
       before { Acfs::Stub.enable }
+
       after  { Acfs::Stub.disable }
 
       before do
@@ -74,7 +83,6 @@ describe Acfs::Resource::Validation do
 
       let(:params)   { {} }
       let(:resource) { MyUser.create params }
-      subject { resource.errors.to_hash }
 
       context 'with `field => [messages]` payload' do
         let(:errors) { {name: ['cannot be blank']} }
@@ -97,33 +105,32 @@ describe Acfs::Resource::Validation do
   end
 
   describe '#save!' do
-    subject { -> { model.save! } }
+    subject(:save) { -> { 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 }
+      it { expect { save.call }.to raise_error Acfs::InvalidResource }
     end
 
     context 'on new resource' do
-      it 'should validate with `create` context' do
+      it 'validates with `create` context' do
         expect(model).to receive(:valid?).with(:create).and_call_original
-        subject.call
+        save.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
+      it 'validates with `save` context' do
         expect(model).to receive(:valid?).with(:save).and_call_original
-        subject.call
+        save.call
       end
     end
   end
-
-  describe 'validates with context' do
-  end
 end

data/spec/acfs/response/formats_spec.rb

@@ -13,8 +13,8 @@ describe Acfs::Response::Formats do
   context 'without Content-Type header' do
     let(:headers) { {} }
 
-    it "should fallback on 'text/plain'" do
-      expect(response.content_type).to be == Mime[:text]
+    it "fallbacks on 'text/plain'" do
+      expect(response.content_type).to eq Mime[:text]
     end
   end
 
@@ -22,13 +22,13 @@ describe Acfs::Response::Formats do
     let(:mime_type) { 'application/json' }
 
     describe '#content_type' do
-      it 'should return Mime::JSON' do
-        expect(response.content_type).to be == Mime[:json]
+      it 'returns Mime::JSON' do
+        expect(response.content_type).to eq Mime[:json]
       end
     end
 
     describe '#json?' do
-      it 'should return true' do
+      it 'returns true' do
         expect(response).to be_json
       end
     end
@@ -37,13 +37,13 @@ describe Acfs::Response::Formats 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]
+        it 'returns Mime::JSON' do
+          expect(response.content_type).to eq Mime[:json]
         end
       end
 
       describe '#json?' do
-        it 'should return true' do
+        it 'returns true' do
           expect(response).to be_json
         end
       end

data/spec/acfs/response/status_spec.rb

@@ -14,18 +14,18 @@ describe Acfs::Response::Status 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
+      it 'returns status code' do
+        expect(response.code).to eq 200
+        expect(response.status_code).to eq 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
+      it 'returns zero' do
+        expect(response.code).to eq 0
+        expect(response.status_code).to eq 0
       end
     end
   end
@@ -33,38 +33,45 @@ describe Acfs::Response::Status do
   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 }
+
+      it { expect(response).not_to be_success }
     end
 
     context 'with zero status code' do
       let(:status) { nil }
-      it { expect(response).to_not be_success }
+
+      it { expect(response).not_to 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 }
+
+      it { expect(response).not_to 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

data/spec/acfs/runner_spec.rb

@@ -30,42 +30,42 @@ class NotificationCollector
   end
 end
 
-describe ::Acfs::Runner do
-  let(:adapter) { ::NullAdapter.new }
-  let(:runner) { ::Acfs::Runner.new adapter }
+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
+    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)
+      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}
+      it 'triggers 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}
+      it 'triggers 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}
+      it 'triggers 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
@@ -76,19 +76,21 @@ describe ::Acfs::Runner 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}
+
+    it 'does not do requests when a middleware aborted' do
+      expect(adapter).not_to 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
+      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}
+
+    it 'does not do requests when a middleware aborted' do
+      expect(adapter).not_to receive(:queue)
+      runner.enqueue Acfs::Operation.new MyUser, :read, params: {id: 0}
       runner.start
     end
   end

data/spec/acfs/service/middleware_spec.rb

@@ -13,19 +13,19 @@ describe Acfs::Service::Middleware do
   describe '.use' do
     let(:options) { {abc: 'cde'} }
 
-    it 'should add middleware to list' do
+    it 'adds middleware to list' do
       srv_class.use middleware
 
       expect(srv_class.middleware).to include(middleware)
     end
 
-    it 'should add middleware to stack' do
+    it 'adds 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
+    it 'instantiates middleware object' do
       expect(middleware).to receive(:new).with(anything, options)
 
       srv_class.use middleware, options

data/spec/acfs/service_spec.rb

@@ -14,23 +14,24 @@ describe Acfs::Service do
   describe '#initialize' do
     let(:options) { {path: 'abc', key: 'value'} }
 
-    it 'should set options' do
+    it 'sets 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
+    it 'extracts 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
+      it 'has custom resource path' do
         expect(service.location(resource).to_s).to eq('/abc')
       end
     end
@@ -41,7 +42,7 @@ describe Acfs::Service do
       Acfs::Configuration.current.locate :test, 'http://abc.de/api/v1'
     end
 
-    it 'should return configured URI for service' do
+    it 'returns configured URI for service' do
       expect(srv_class.base_url).to eq('http://abc.de/api/v1')
     end
   end

data/spec/acfs/singleton_resource_spec.rb

@@ -12,6 +12,7 @@ describe Acfs::SingletonResource do
     end
 
     let(:action) { ->(cb) { model.find(&cb) } }
-    it_should_behave_like 'a query method with multi-callback support'
+
+    it_behaves_like 'a query method with multi-callback support'
   end
 end