droid_services 0.0.1

data/spec/services/decorator_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module DroidServices
+  describe Decorator do
+    let(:decorable) { mock(foo:'bar') }
+    subject { DroidServices::Decorator.new(decorable) }
+
+    its(:resource) { should eq(decorable) }
+
+    it 'should translate missing methods to decorable' do
+      subject.foo.should eq('bar')
+    end
+
+    it 'should not translate missing methods' do
+      expect {
+        subject.bar
+      }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/services/extensions/has_callbacks_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module DroidServices
+  describe DroidServices::Extensions::HasCallbacks do
+    include DroidServices::Extensions::HasCallbacks
+
+    describe '#invoke_callback' do
+      context 'when callback handler class is not defined' do
+        let(:name) { mock }
+        let(:resource) { mock }
+        before { self.class.stub!(:resource_callbacks_handler_class) }
+        it { invoke_callback(name, resource).should be_nil }
+      end
+
+      context 'when callback handler class is defined' do
+        let(:name) { "foo" }
+        let(:resource) { mock }
+        let(:handle_class) { double.as_null_object }
+        before { self.class.stub!(:resource_callbacks_handler_class).and_return(handle_class) }
+
+        it 'initializes handle class instance' do
+          handle_class.should_receive(:new).with(resource)
+          invoke_callback(name, resource)
+        end
+
+        it 'calls corresponding method on instance' do
+          instance = double.as_null_object
+          handle_class.stub!(:new).and_return(instance)
+          instance.should_receive(:foo)
+          invoke_callback(name, resource)
+        end
+      end
+    end
+
+    describe '#callbacks_handler' do
+      it 'should define callbacks handler class' do
+        self.class.callbacks_handler('Foo')
+        self.class.resource_callbacks_handler_class.should eq('Foo')
+      end
+    end
+  end
+end

data/spec/services/extensions/has_decorator_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+class Foo;
+  attr_accessor :a
+  def initialize(arg)
+    @a = arg
+  end
+
+  def ==(other)
+    self.a == other.a
+  end
+end
+
+module DroidServices
+  describe DroidServices::Extensions::HasDecorator do
+    include DroidServices::Extensions::HasDecorator
+
+    describe 'class attributes' do
+      subject { self.class }
+      it { should respond_to(:decorator_class_name) }
+    end
+
+    describe 'class methods' do
+      describe '#decorator' do
+        before { self.class.decorator(:foo) }
+        subject { self }
+
+        its(:decorator_class_name) { should eq('foo') }
+      end
+    end
+
+    describe 'instance methods' do
+      subject { self }
+
+      describe '#decorator_class' do
+        before { self.class.decorator(:foo) }
+        its(:decorator_class) { should eq(Foo) }
+      end
+
+      describe '#decorable?' do
+        context 'when `decorator_class_name` present' do
+          before { self.class.decorator(:foo) }
+          its(:decorable?) { should be_true }
+        end
+
+        context 'when `decorator_class_name` empty' do
+          its(:decorable?) { should be_false }
+        end
+      end
+
+      describe '#decorated_collection' do
+        context 'when `decorable?`' do
+          before { subject.stub!(:decorable?).and_return(true) }
+          it 'should return decorated result' do
+            subject.should_receive(:build_decorated_collection)
+            subject.decorated_collection
+          end
+        end
+        context 'when not `decorable?`' do
+          before { subject.stub!(:decorable?).and_return(false) }
+          it 'should return raw result' do
+            subject.should_not_receive(:build_decorated_collection)
+            subject.should_receive(:build_collection)
+            subject.decorated_collection
+          end
+        end
+      end
+
+      describe '#build_decorated_collection' do
+        before do
+          self.class.decorator(:foo)
+          subject.stub!(:prepare_collection_for_decorate).and_return([:bar])
+        end
+
+        it 'returns array of decorator instances' do
+          subject.send(:build_decorated_collection).should eq([Foo.new(:bar)])
+        end
+      end
+
+      describe '#prepare_collection_for_decorate' do
+        subject { self.send(:prepare_collection_for_decorate) }
+
+        context 'when #build_collection returns array' do
+          before { self.stub!(:build_collection).and_return([:bar]) }
+          it { should eq([:bar]) }
+        end
+
+        context 'when #build_collection returns any object except array' do
+          before { self.stub!(:build_collection).and_return(:bar) }
+          it { should eq([:bar]) }
+        end
+
+        context 'when #build_collection returns any object which responds to #all method' do
+          let(:obj) { mock(:all => [:bar] ) }
+          before { self.stub!(:build_collection).and_return(obj) }
+
+          it { should eq([:bar]) }
+        end
+      end
+    end
+  end
+end

data/spec/services/extensions/has_logger_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module DroidServices
+  describe DroidServices::Extensions::HasLogger do
+    include DroidServices::Extensions::HasLogger
+
+    before { self.class.stub!(:rails_log_path).and_return('./log') }
+
+    describe '#logger' do
+      it { logger.should be_kind_of(Yell::Logger) }
+    end
+
+    describe '#format_message' do
+      context 'when String' do
+        let(:message) { 'Some test' }
+        it { format_message(message).should be_kind_of(String) }
+        it { format_message(message).should eq('Some test')}
+      end
+
+      context 'when Hash' do
+        let(:message) { {'dog' => 'canine', 'cat' => 'feline', 12 => 'number', user: {nick: 'Guru', 'name' => 'User'}} }
+        it { format_message(message).should be_kind_of(String) }
+        it { format_message(message).should eq("{\n  \"dog\": \"canine\",\n  \"cat\": \"feline\",\n  \"12\": \"number\",\n  \"user\": {\n    \"nick\": \"Guru\",\n    \"name\": \"User\"\n  }\n}") }
+      end
+
+      context 'when Array' do
+        let(:message) { ['dog', 'cat', 'number'] }
+        it { format_message(message).should be_kind_of(String) }
+        it { format_message(message).should eq("[\n  \"dog\",\n  \"cat\",\n  \"number\"\n]") }
+      end
+
+      context 'when some object' do
+        let(:message) { mock }
+        it 'should inspect object' do
+          message.should_receive(:inspect)
+          format_message(message)
+        end
+      end
+    end
+  end
+end

data/spec/services/extensions/has_resource_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+class Bar; end
+class Foo; end
+
+module DroidServices
+  describe DroidServices::Extensions::HasResource do
+    include DroidServices::Extensions::HasResource
+
+    describe 'class attributes' do
+      subject { self.class }
+      it { should respond_to(:resource_name) }
+      it { should respond_to(:resource_class_name) }
+    end
+
+    describe 'class methods' do
+      describe '#resource' do
+        before { self.class.resource(:foo, class_name:'bar', name:'bazz') }
+        subject { self }
+
+        its(:resource_name) { should eq('foo') }
+        its(:resource_class_name) { should eq('bar') }
+      end
+    end
+
+    describe 'instance methods' do
+      subject { self }
+
+      describe '#resource_name' do
+        before { self.class.resource(:foo) }
+        its(:resource_name) { should eq('foo') }
+      end
+
+      describe '#collection_name' do
+        before { self.class.resource(:foo) }
+        its(:collection_name) { should eq('foos') }
+      end
+
+      describe '#resource_class' do
+        context 'when `class_name` option is supplied' do
+          before { self.class.resource(:foo, class_name:'Bar') }
+          its(:resource_class) { should eq(Bar) }
+        end
+
+        context 'when `class_name` option is omited' do
+          before { self.class.resource(:foo) }
+          its(:resource_class) { should eq(Foo) }
+        end
+      end
+
+      describe '#resource_scope' do
+        before { subject.stub!(:resource_class).and_return(Foo) }
+        its(:resource_scope) { should eq(Foo) }
+      end
+
+      describe '#build_collection' do
+        before { subject.stub!(:resource_class).and_return(Foo) }
+        its(:build_collection) { should eq(Foo) }
+      end
+
+      describe '#find_resource' do
+        let(:resource_scope) { mock }
+        before { subject.stub!(:resource_scope).and_return(resource_scope) }
+        it 'finds resource by id' do
+          allow_message_expectations_on_nil
+          resource_scope.should_receive(:find).with(123)
+          subject.find_resource(123)
+        end
+      end
+
+      describe '#build_resource' do
+        context 'when id is nil' do
+          let(:resource_scope) { mock }
+          before { subject.stub!(:resource_scope).and_return(resource_scope) }
+          it 'initializes new object' do
+            allow_message_expectations_on_nil
+            resource_scope.should_receive(:new).with({foo: 'bar'})
+            subject.build_resource(nil, {foo: 'bar'})
+          end
+        end
+        context 'when id is present' do
+          let(:resource) { mock.as_null_object }
+          it 'finds resource' do
+            subject.should_receive(:find_resource).with(123).and_return(resource)
+            subject.build_resource(123, {foo: 'bar'})
+          end
+
+          it 'assigns provided attributes' do
+            subject.stub!(:find_resource).and_return(resource)
+            resource.should_receive(:attributes=).with({foo: 'bar'})
+            subject.build_resource(123, {foo: 'bar'})
+          end
+        end
+      end
+
+      describe '#resource_attributes' do
+        let(:dirty_resource_attributes) { mock }
+        before { subject.stub!(:dirty_resource_attributes).and_return(dirty_resource_attributes)}
+        it 'filters dirty attributes' do
+          subject.should_receive(:filter_attributes).with(dirty_resource_attributes)
+          subject.resource_attributes
+        end
+      end
+    end
+
+    describe 'private methods' do
+      subject { self }
+      describe '#dirty_resource_attributes' do
+        context 'when params are present' do
+          it 'should return from params by resource_name' do
+            subject.stub!(:resource_name).and_return(:foo)
+            subject.stub!(:params).and_return({foo: {bar: 'bazz'}})
+            subject.send(:dirty_resource_attributes).should eq({bar: 'bazz'})
+          end
+        end
+        context 'when there are no params' do
+          it 'should return empty hash' do
+            subject.stub!(:resource_name).and_return(:foo)
+            subject.stub!(:params).and_return({})
+            subject.send(:dirty_resource_attributes).should eq({})
+          end
+        end
+      end
+      describe '#default_resource_attributes' do
+        it 'should return empty hash by default' do
+          subject.send(:default_resource_attributes).should eq({})
+        end
+      end
+
+      describe '#filter_attributes' do
+        it 'should return supplied attributes by default' do
+          subject.send(:filter_attributes, {foo: 'bar'}).should eq({foo: 'bar'})
+        end
+      end
+    end
+
+  end
+end

data/spec/services/extensions/has_response_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module DroidServices
+  describe DroidServices::Extensions::HasResponse do
+    include DroidServices::Extensions::HasResponse
+
+    subject { self }
+
+    describe '#set_message' do
+      it 'should set message' do
+        subject.set_message('foo')
+        subject.instance_variable_get(:@_message).should eq('foo')
+      end
+    end
+
+    describe '#add_error' do
+      it 'should add error' do
+        subject.add_error('foo')
+        subject.instance_variable_get(:@_errors).should include('foo')
+      end
+    end
+
+    describe '#add_error_unless' do
+      it 'should add error when condition false' do
+        subject.add_error_unless('foo', 1==0)
+        subject.instance_variable_get(:@_errors).should include('foo')
+      end
+
+      it 'should not add error when condition true' do
+        subject.add_error_unless('foo', 1==1)
+        subject.instance_variable_get(:@_errors).should be_nil
+      end
+    end
+
+    describe '#add_errors_from' do
+      let(:messages) { [[:foo, 'bar'], [:bar, 'bazz']]}
+      let(:errors) { mock(messages: messages)}
+      let(:model) { mock(errors: errors) }
+
+      it 'should add errors from model error messages' do
+        subject.add_errors_from(model)
+        subject.instance_variable_get(:@_errors).should eq(['foo: bar', 'bar: bazz'])
+      end
+    end
+
+    describe '#assign_resource' do
+      it 'should set assignments' do
+        subject.assign_resource('foo', 'bar')
+        subject.instance_variable_get(:@_assignments).should eq({foo: 'bar'})
+      end
+    end
+
+    describe '#respond_with' do
+      before { subject.stub!(:resource_name).and_return(:foo) }
+      it 'calls DroidServices::Response' do
+        DroidServices::Response.should_receive(:new).with(:foo, 'bar').and_return(mock.as_null_object)
+        subject.respond_with('bar')
+      end
+
+      it 'should return DroidServices::Response instance' do
+        subject.respond_with('bar').should be_a_kind_of(DroidServices::Response)
+      end
+
+      it 'should assign message, errors and additional assignments to response object' do
+        response = mock
+        DroidServices::Response.should_receive(:new).and_return(response)
+        response.should_receive(:message=)
+        response.should_receive(:errors=)
+        response.should_receive(:assignments=)
+        subject.respond_with('bar')
+      end
+    end
+  end
+end

data/spec/services/response_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+module DroidServices
+  describe Response do
+    subject { DroidServices::Response.new('some_resource', 'some_result')}
+
+    describe '#with_message' do
+      before { subject.with_message('some message') }
+      it { should be_kind_of(DroidServices::Response) }
+      its(:message) { should be }
+      its(:message) { should eq('some message') }
+    end
+
+    describe '#with_errors' do
+      before { subject.with_errors(['some', 'errors']) }
+      it { should be_kind_of(DroidServices::Response) }
+      its(:errors) { should be }
+      its(:errors) { should eq(['some', 'errors']) }
+    end
+
+    describe '#success?' do
+      context 'when there are no errors' do
+        before { subject.with_errors([]) }
+        its(:success?) { should be_true }
+      end
+
+      context 'when there are errors' do
+        before { subject.with_errors(['some', 'errors']) }
+        its(:success?) { should be_false }
+      end
+    end
+
+    describe '#failure?' do
+      context 'when there are no errors' do
+        before { subject.with_errors([]) }
+        its(:failure?) { should be_false }
+      end
+
+      context 'when there are errors' do
+        before { subject.with_errors(['some', 'errors']) }
+        its(:failure?) { should be_true }
+      end
+    end
+
+    describe '#notice' do
+      before { subject.with_message('some message') }
+      context 'when there are no errors' do
+        before { subject.with_errors([]) }
+        its(:notice) { should be }
+        its(:notice) { should eq('some message') }
+      end
+
+      context 'when there are errors' do
+        before { subject.with_errors(['some', 'errors']) }
+        its(:notice) { should be_nil }
+      end
+    end
+
+    describe '#error' do
+      context 'when there are no errors' do
+        before { subject.with_errors([]) }
+        its(:error) { should be_nil }
+      end
+
+      context 'when there are errors' do
+        before { subject.with_errors(['some', 'message']) }
+        its(:error) { should be }
+        its(:error) { should eq('some') }
+      end
+
+      context 'when message is present' do
+        before { subject.with_message('some message').with_errors(['some', 'message']) }
+        its(:error) { should be }
+        its(:error) { should eq('some message') }
+      end
+    end
+
+    describe '#has_error?' do
+      context 'when there are no errors' do
+        before { subject.with_errors([]) }
+        specify { subject.has_error?('foo').should be_false }
+      end
+
+      context 'when there are errors' do
+        before { subject.with_errors(['some', 'message']) }
+        specify { subject.has_error?('some').should be_true }
+        specify { subject.has_error?('foo').should be_false }
+      end
+    end
+
+    describe '#method_missing' do
+      before { subject.assignments = {foo: 'bar'} }
+      its(:foo) { should eq('bar') }
+      specify { expect{ subject.bar }.to raise_error(NoMethodError) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'droid_services'

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: droid_services
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Droidlabs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yell
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Droid DroidServices
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/droid_services/base.rb
+- lib/droid_services/base_resource.rb
+- lib/droid_services/callbacks.rb
+- lib/droid_services/decorator.rb
+- lib/droid_services/extensions/has_callbacks.rb
+- lib/droid_services/extensions/has_decorator.rb
+- lib/droid_services/extensions/has_logger.rb
+- lib/droid_services/extensions/has_resource.rb
+- lib/droid_services/extensions/has_response.rb
+- lib/droid_services/extensions/has_service.rb
+- lib/droid_services/response.rb
+- lib/droid_services/version.rb
+- lib/droid_services.rb
+- LICENSE.txt
+- Rakefile
+- README.md
+- spec/services/base_resource_spec.rb
+- spec/services/base_spec.rb
+- spec/services/callbacks_spec.rb
+- spec/services/decorator_spec.rb
+- spec/services/extensions/has_callbacks_spec.rb
+- spec/services/extensions/has_decorator_spec.rb
+- spec/services/extensions/has_logger_spec.rb
+- spec/services/extensions/has_resource_spec.rb
+- spec/services/extensions/has_response_spec.rb
+- spec/services/response_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Droid DroidServices
+test_files:
+- spec/services/base_resource_spec.rb
+- spec/services/base_spec.rb
+- spec/services/callbacks_spec.rb
+- spec/services/decorator_spec.rb
+- spec/services/extensions/has_callbacks_spec.rb
+- spec/services/extensions/has_decorator_spec.rb
+- spec/services/extensions/has_logger_spec.rb
+- spec/services/extensions/has_resource_spec.rb
+- spec/services/extensions/has_response_spec.rb
+- spec/services/response_spec.rb
+- spec/spec_helper.rb