zertico 1.3.0 → 2.0.0.alpha.1

data/spec/fake_app/app/interfaces/user.rb

@@ -0,0 +1,32 @@
+class User < ActiveRecord::Base
+  attr_reader :updated, :destroyed
+  attr_accessor :name, :id
+
+  def initialize
+    @updated = false
+    @destroyed = false
+    super
+  end
+
+  def self.all
+    [new, new]
+  end
+
+  def self.find(id)
+    new
+  end
+
+  def self.create(params)
+    new
+  end
+
+  def update_attributes(params)
+    @updated = true
+    true
+  end
+
+  def destroy
+    @destroyed = true
+    true
+  end
+end

data/spec/fake_app/app/permitted_params/users_permitted_params.rb

@@ -0,0 +1,9 @@
+class UsersPermittedParams < Zertico::PermittedParams
+  def create
+    params.require(:user).permit(:name)
+  end
+
+  def update
+    params.require(:user).permit(:id)
+  end
+end

data/spec/fake_app/app/responders/users_responder.rb

@@ -0,0 +1,5 @@
+class UsersResponder < Zertico::Responder
+  include Pjax
+
+  self.update_options = lambda { |controller| { :location => user_path(controller.user) } }
+end

data/spec/fake_app/app/services/admin/user_service.rb

@@ -0,0 +1,6 @@
+module Admin
+  class UserService < Zertico::Service
+    def admin_user
+    end
+  end
+end

data/spec/fake_app/app/services/person/gifts_service.rb

@@ -0,0 +1,4 @@
+module Person
+  class GiftsService < Zertico::Service
+  end
+end

data/spec/fake_app/app/services/person/profile_service.rb

@@ -0,0 +1,4 @@
+module Person
+  class ProfileService < Zertico::Service
+  end
+end

data/spec/fake_app/app/services/user_service.rb

@@ -0,0 +1,5 @@
+class UserService < Zertico::Service
+  use_interface Product
+  use_as_id 'great_id'
+  use_as_variable_name 'great_name'
+end

data/spec/fake_app/app/services/users_service.rb

@@ -0,0 +1,3 @@
+class UsersService < Zertico::Service
+  attr_reader :user, :users
+end

data/spec/fake_app/app/views/layouts/application.html.erb

@@ -0,0 +1 @@
+<%= yield %>

data/spec/fake_app/config/application.rb

@@ -0,0 +1,10 @@
+require 'rails'
+require 'action_controller/railtie'
+
+module RailsApplication
+  class Application < Rails::Application
+    config.root = "#{config.root}/spec/fake_app"
+    config.logger = nil
+    config.secret_key_base = YAML.load(File.open("#{Rails.root}/config/secrets.yml"))[Rails.env]['secret_key_base']
+  end
+end

data/spec/fake_app/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  resources :users
+end

data/spec/fake_app/config/secrets.yml

@@ -0,0 +1,4 @@
+development:
+  secret_key_base: cf8a9ddeff8bc751c177a6c9fd892f23442e94ada03ca27ceeaefd5639bfe882fbba6b79ee4181d8dba71949f3642f56c3427102c4f1659fc023bddf56fee5dc
+test:
+  secret_key_base: 477d9a34cbff7bb338134fa8b9a5aa9e672949a1532f6949f5f69bc950c94ff9b463d035c1c20f008c66508fda1f62454814e8ad6e5b2105bf6fb24a56395845

data/spec/spec_helper.rb

@@ -1,8 +1,22 @@
 require 'rspec'
-require 'coveralls'
+require 'active_record'
 
-Coveralls.wear!
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+ActiveRecord::Migration.create_table :users
+
+if ENV['COVERAGE']
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  SimpleCov.start do
+    add_filter "#{File.dirname(__FILE__)}/fake_app"
+  end
+
+  Coveralls.wear!
+end
 
 require "#{File.dirname(__FILE__)}/../lib/zertico"
 
-Dir["#{File.dirname(__FILE__)}/fake_app/**/*.rb"].sort.each { |f| require f }
+Dir["#{File.dirname(__FILE__)}/fake_app/config/**/*.rb"].sort.each { |f| require f }
+Dir["#{File.dirname(__FILE__)}/fake_app/app/**/*.rb"].sort.each { |f| require f }

data/spec/zertico/controller_integration_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'rspec/rails'
+
+describe UsersController, :type => :controller do
+  let(:user) { User.new }
+  
+  context '#index' do
+    before :each do
+      get :index
+    end
+
+    it 'should initialize a collection of users' do
+      expect(assigns(:users)).to be_an_instance_of(Array)
+    end
+
+    it 'should initialize a collection with two itens' do
+      expect(assigns(:users).size).to be_equal 2
+    end
+  end
+
+  context '#new' do
+    before :each do
+      get :new
+    end
+
+    it 'should initialize an user' do
+      expect(assigns(:user)).to be_an_instance_of(User)
+    end
+  end
+
+  context '#show' do
+    before :each do
+      get :show, :id => 1
+    end
+
+    it 'should find and initialize an user' do
+      expect(assigns(:user)).to be_an_instance_of(User)
+    end
+  end
+
+  context '#edit' do
+    before :each do
+      get :edit, :id => 1
+    end
+
+    it 'should find and initialize an user' do
+      expect(assigns(:user)).to be_an_instance_of(User)
+    end
+  end
+
+  context '#create' do
+    before :each do
+      post :create, :user => { :name => 'name' }
+    end
+
+    it 'should pass the right parameters to the model' do
+      expect(User).to receive(:create).with(:name => 'name').and_return(user)
+      post :create, :user => { :name => 'name' }
+    end
+
+    it 'should create a new user' do
+      expect(assigns(:user)).to be_an_instance_of(User)
+    end
+  end
+
+  context '#update' do
+    before :each do
+      allow(User).to receive(:find).and_return(user)
+      allow(user).to receive(:id).and_return(3)
+      put :update, :id => 1, :user => { :id => 23 }
+    end
+
+    it 'should pass the right parameters to the model' do
+      expect(user).to receive(:update_attributes).with('id' => '23').and_return(true)
+      put :update, :id => 1, :user => { :id => 23 }
+    end
+
+    it 'should update an user' do
+      expect(assigns(:user)).to be_an_instance_of(User)
+    end
+  end
+
+  context '#destroy' do
+    before :each do
+      delete :destroy, :id => 1
+    end
+
+    it 'should destroy the user' do
+      expect(assigns(:user)).to be_an_instance_of(User)
+    end
+  end
+end

data/spec/zertico/controller_spec.rb

@@ -1,168 +1,31 @@
 require 'spec_helper'
 
 describe Zertico::Controller do
-  let(:controller) { Zertico::Controller.new }
-  let(:user_controller) { UserController.new }
-  let(:admin_controller) { Admin::UserController.new }
-
-  context 'not being nested' do
-    it 'should find on the correct id' do
-      user_controller.send(:interface_id).should  == 'id'
-    end
-  end
-
-  context 'being nested' do
-    it 'should find on the correct id' do
-      admin_controller.send(:interface_id).should  == 'user_id'
-    end
-  end
+  let(:controller) { UsersController.new }
+  let(:zertico_controller) { Zertico::Controller.new }
+  let(:service) { Zertico::Service.new }
 
   context 'without a custom service' do
-    it 'should extend Zertico::Service' do
-      controller.should respond_to :all
+    it 'should initialize Zertico::Service' do
+      expect(zertico_controller.service).to be_an_instance_of(Zertico::Service)
     end
   end
 
   context 'with a custom service' do
-    it 'should extend Zertico::Service' do
-      user_controller.should respond_to :all
-    end
-
-    it 'should extend it!' do
-      user_controller.should respond_to :user
+    it 'should initialize it!' do
+      expect(controller.service).to be_an_instance_of(UsersService)
     end
   end
 
-  context 'actions' do
-    before :each do
-      controller.instance_variable_set('@options', 'options')
-      controller.stub(:respond_with).with('responder', 'options')
-    end
-
-    context '#index' do
-      before :each do
-        controller.stub(:all => 'responder')
-      end
-
-      after :each do
-        controller.index
-      end
-
-      it 'should initialize a collection of objects' do
-        controller.should_receive(:all)
-      end
-
-      it 'should respond correctly' do
-        controller.should_receive(:respond_with).with('responder', 'options')
-      end
-    end
-
-    context '#new' do
-      before :each do
-        controller.stub(:build => 'responder')
-      end
-
-      after :each do
-        controller.new
-      end
-
-      it 'should initialize an object' do
-        controller.should_receive(:build)
-      end
-
-      it 'should respond correctly' do
-        controller.should_receive(:respond_with).with('responder', 'options')
-      end
-    end
-
-    context '#show' do
-      before :each do
-        controller.stub(:find => 'responder')
-      end
-
-      after :each do
-        controller.show
-      end
-
-      it 'should initialize an object' do
-        controller.should_receive(:find)
-      end
-
-      it 'should respond correctly' do
-        controller.should_receive(:respond_with).with('responder', 'options')
-      end
+  context 'without a custom responder' do
+    it 'should initialize Zertico::Responder' do
+      expect(zertico_controller.responder).to be == Zertico::Responder
     end
+  end
 
-    context '#edit' do
-      before :each do
-        controller.stub(:find => 'responder')
-      end
-
-      after :each do
-        controller.edit
-      end
-
-      it 'should initialize an object' do
-        controller.should_receive(:find)
-      end
-
-      it 'should respond correctly' do
-        controller.should_receive(:respond_with).with('responder', 'options')
-      end
-    end
-
-    context '#create' do
-      before :each do
-        controller.stub(:generate => 'responder')
-      end
-
-      after :each do
-        controller.create
-      end
-
-      it 'should initialize an object' do
-        controller.should_receive(:generate)
-      end
-
-      it 'should respond correctly' do
-        controller.should_receive(:respond_with).with('responder', 'options')
-      end
-    end
-
-    context '#update' do
-      before :each do
-        controller.stub(:modify => 'responder')
-      end
-
-      after :each do
-        controller.update
-      end
-
-      it 'should initialize an object' do
-        controller.should_receive(:modify)
-      end
-
-      it 'should respond correctly' do
-        controller.should_receive(:respond_with).with('responder', 'options')
-      end
-    end
-
-    context '#destroy' do
-      before :each do
-        controller.stub(:delete => 'responder')
-      end
-
-      after :each do
-        controller.destroy
-      end
-
-      it 'should initialize an object' do
-        controller.should_receive(:delete)
-      end
-
-      it 'should respond correctly' do
-        controller.should_receive(:respond_with).with('responder', 'options')
-      end
+  context 'with a custom responder' do
+    it 'should initialize it!' do
+      expect(controller.responder).to be == UsersResponder
     end
   end
 end

data/spec/zertico/delegator_spec.rb

@@ -2,55 +2,104 @@ require 'spec_helper'
 
 describe Zertico::Delegator do
   let(:user) { User.new }
-  let(:user_delegator) { UserDelegator.new(user) }
+  let(:product) { Product.new }
+  let(:user_delegator) { UserDelegator.new }
 
   context 'on a namespaced delegator and interface model' do
     it 'should find the interface model' do
-      Person::ProfileDelegator.send(:interface_class).should == Person::Profile
+      expect(Person::ProfileDelegator.send(:interface_class)).to eq(Person::Profile)
     end
 
     it 'should return a valid instance variable name' do
-      Person::ProfileDelegator.send(:interface_name).should == 'profile'
+      expect(Person::ProfileDelegator.send(:interface_name)).to eq('profile')
     end
   end
 
   context 'on a namespaced delegator and non namespaced interface model' do
     it 'should find the interface model' do
-      Admin::UserDelegator.send(:interface_class).should == User
+      expect(Admin::UserDelegator.send(:interface_class)).to eq(User)
     end
 
     it 'should return a valid instance variable name' do
-      Admin::UserDelegator.send(:interface_name).should == 'user'
+      expect(Admin::UserDelegator.send(:interface_name)).to eq('user')
     end
   end
 
   context 'on a non namespaced delegator and non namespaced interface model' do
     it 'should find the interface model' do
-      UserDelegator.send(:interface_class).should == User
+      expect(UserDelegator.send(:interface_class)).to eq(User)
     end
 
     it 'should return a valid instance variable name' do
-      UserDelegator.send(:interface_name).should == 'user'
+      expect(UserDelegator.send(:interface_name)).to eq('user')
+    end
+  end
+
+  describe '.new' do
+    context 'without params' do
+      it "should initialize an object based on delegator's name" do
+        expect(UserDelegator.new.interface).to be_an_instance_of(User)
+      end
+    end
+
+    context 'with an object as param' do
+      it 'use this object' do
+        expect(UserDelegator.new(product).interface).to be_an_instance_of(Product)
+      end
     end
   end
 
   describe '.find' do
     before :each do
-      User.stub(:find => user)
+      allow(User).to receive(:find).and_return(user)
     end
 
     it 'should return an delegator' do
-      UserDelegator.find(3).should be_an_instance_of(UserDelegator)
+      expect(UserDelegator.find(3)).to be_an_instance_of(UserDelegator)
     end
   end
 
   describe '#interface' do
     before :each do
-      User.stub(:find => user)
+      allow(User).to receive(:find).and_return(user)
     end
 
     it 'should return the interface object' do
-      UserDelegator.find(3).interface.should == user
+      expect(UserDelegator.find(3).interface).to eq(user)
+    end
+  end
+
+  describe '#interface=' do
+    before :each do
+      user_delegator.interface = product
+    end
+
+    it 'should set the interface object' do
+      expect(user_delegator.interface).to eq(product)
+    end
+  end
+
+  describe '.interface_name' do
+    it 'should return the interface name' do
+      expect(UserDelegator.interface_name).to eq('user')
+    end
+  end
+
+  describe '.interface_class' do
+    it 'should return the interface name' do
+      expect(UserDelegator.interface_class).to eq(User)
+    end
+  end
+
+  describe '#interface_name' do
+    it 'should return the interface name' do
+      expect(user_delegator.send(:interface_name)).to eq('user')
+    end
+  end
+
+  describe '#interface_class' do
+    it 'should return the interface name' do
+      expect(user_delegator.send(:interface_class)).to eq(User)
     end
   end
 end