lolita 3.2.0.rc.7 → 3.2.0.rc.9

data/spec/extensions/authentication/proxy_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../simple_spec_helper')
+
+describe Lolita::Extensions::Authentication::Proxy do 
+  let(:klass){ Lolita::Extensions::Authentication::Proxy }
+  let(:proxy){ klass.new(Object.new,{}) }
+
+  it "should create new proxy" do
+    expect do
+      klass.new(Object.new,{})
+    end.not_to raise_error
+  end
+
+  it "should have #current_user" do
+    proxy.respond_to?(:current_user).should be_true
+  end
+  
+  it "should have #user_signed_in?" do
+    proxy.respond_to?(:user_signed_in?).should be_true
+  end
+
+  it "should have #adapter" do
+    proxy.adapter.is_a?(Object)
+  end
+
+  it "should have #authenticate_user!" do
+    proxy.respond_to?(:authenticate_user!).should be_true
+  end
+
+  it "should have #sign_out_path" do
+    proxy.respond_to?(:sign_out_path).should be_true
+  end
+
+  it "should have #sign_out_via" do
+    proxy.respond_to?(:sign_out_via).should be_true
+  end
+
+  it "should have #edit_path" do
+    proxy.respond_to?(:edit_path).should be_true
+  end
+
+  describe 'Connecting adapter' do
+    context 'default adapter' do
+      it "should create when Authentication is not specified" do
+        proxy.adapter.should be_a(Lolita::Extensions::Authentication::DefaultAdapter)
+      end
+    end
+    context 'devise adapter' do
+      it "should create when Lolita.authentication is specified" do
+        Lolita.authentication = :test
+        proxy.adapter.should be_a(Lolita::Extensions::Authentication::DeviseAdapter)
+        Lolita.authentication = nil
+      end
+    end
+  end
+end

data/spec/extensions/authorization/cancan_adapter_spec.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../simple_spec_helper')
+
+class TestApplicationController
+  include Lolita::Extensions
+
+  def authorize! *args
+    "context_response"
+  end
+end
+
+class TestAbility
+  def initialize *args
+  end
+
+  def can? action,klass
+    action == :read && klass == String
+  end
+
+  def cannot? *args
+    !can?(*args)
+  end
+
+  def authorize! *args
+    "ability_response"
+  end
+end
+
+module CanCan
+end
+
+describe Lolita::Extensions::Authorization::CanCanAdapter do
+  let(:klass){ Lolita::Extensions::Authorization::CanCanAdapter }
+  around(:each){|example|
+    Lolita.authorization = 'CanCan'
+    Lolita.ability_class = TestAbility
+    example.run
+    Lolita.authorization = nil
+    Lolita.ability_class = nil
+  }
+  let(:adapter){ klass.new(TestApplicationController.new,{}) }
+
+  it "should create new" do
+    expect do
+      klass.new(TestApplicationController.new,{})
+    end.not_to raise_error
+  end
+
+  it "should raise error without authorization" do
+    expect do
+      Lolita.authorization = nil
+      klass.new(TestApplicationController.new,{})
+    end.to raise_error(Lolita::NoAuthorizationDefinedError)
+  end
+
+  context "current user" do
+
+    it "can do some action with current abilities" do
+      adapter.can?(:read,"HiddenText".class).should be_true
+      adapter.can?(:create,"HiddenText".class).should be_false
+    end
+
+    it "can ONLY ado ctions from abilities" do
+      adapter.cannot?(:read,"HiddenText".class).should be_false
+      adapter.cannot?(:create,"HiddenText".class).should be_true
+    end
+
+    it "should have current ability" do
+      adapter.current_ability.should be_a(Lolita.ability_class)
+    end
+    
+    it "should authorize resource" do
+      adapter2 = klass.new(nil)
+      expect do
+        adapter2.authorize!(:read,Object).should == "ability_response"
+        adapter.authorize!(:read,Object).should == "context_response"
+      end.not_to raise_error
+    end
+  end
+
+  describe 'Integration with proxy' do
+    let(:proxy){ 
+      mock_class = Object.new
+      mock_class.class_eval{include Lolita::Extensions}
+      Lolita::Extensions::Authorization::Proxy.new(mock_class,{}) 
+    }
+    it "should have the same method results for adapter and proxy" do
+      proxy.adapter = adapter
+      %w(can? cannot? authorize!).each do |name|
+        proxy.send(name,:read,String).should eql(adapter.send(name,:read,String))
+      end
+      proxy.adapter.current_ability == adapter.current_ability
+    end
+  end
+end

data/spec/extensions/authorization/default_adapter_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../simple_spec_helper')
+
+describe Lolita::Extensions::Authorization::DefaultAdapter do
+  let(:klass){ Lolita::Extensions::Authorization::DefaultAdapter }
+  let(:adapter){ klass.new(Object.new,{}) }
+
+  it "should create new" do
+    expect do
+      klass.new(Object.new,{})
+    end.not_to raise_error
+  end
+  
+  context "current user" do
+
+    it "can do all" do
+      adapter.can?(:read,Object.new).should be_true
+    end
+
+    it "cannot do nothing" do
+      adapter.cannot?([]).should be_false
+    end
+
+    it "should not have current ability" do
+      adapter.current_ability.should be_nil
+    end
+    
+    it "should be authorized for all" do
+      expect do
+        adapter.authorize!
+      end.not_to raise_error
+    end
+  end
+
+  describe 'Integration with proxy' do
+    let(:proxy){ Lolita::Extensions::Authorization::Proxy.new(Object.new,{}) }
+      it "should have the same method results for adapter and proxy" do
+        proxy.adapter = adapter
+        %w(can? cannot? current_ability authorize!).each do |name|
+          proxy.send(name).should eql(adapter.send(name))
+        end
+      end
+  end
+end

data/spec/extensions/authorization/proxy_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../simple_spec_helper')
+
+class TestAbility
+  def initialize(*args)
+  end
+end
+
+describe Lolita::Extensions::Authorization::Proxy do 
+  let(:klass){ Lolita::Extensions::Authorization::Proxy }
+  let(:proxy){ klass.new(Object.new,{}) }
+  around(:each) do |example|
+    Lolita.ability_class = TestAbility
+    example.run
+    Lolita.ability_class = nil
+  end
+  
+  it "should create new proxy" do
+    expect do
+      klass.new(Object.new,{})
+    end.not_to raise_error
+  end
+
+  it "should have #can?" do
+    proxy.respond_to?(:can?).should be_true
+  end
+  
+  it "should have #cannot?" do
+    proxy.respond_to?(:cannot?).should be_true
+  end
+
+  it "should have #authorize!" do
+    proxy.respond_to?(:authorize!).should be_true
+  end
+
+  it "should have #current_ability" do
+    proxy.respond_to?(:current_ability).should be_true
+  end
+
+  describe 'Connecting adapter' do
+    context 'default adapter' do
+      it "should create when authorization is not specified or is 'Default'" do
+        proxy.adapter.should be_a(Lolita::Extensions::Authorization::DefaultAdapter)
+        Lolita.authorization = 'Default'
+        proxy.adapter.should be_a(Lolita::Extensions::Authorization::DefaultAdapter)
+      end
+    end
+    context 'devise adapter' do
+      let(:proxy){ 
+        mock_class = Object.new
+        mock_class.class_eval{include Lolita::Extensions}
+        klass.new(mock_class,{}) 
+      }
+      it "should create when Lolita.authentication is specified" do
+        Lolita.authorization = 'CanCan'
+        proxy.adapter.should be_a(Lolita::Extensions::Authorization::CanCanAdapter)
+        Lolita.authorization = nil
+      end
+    end
+  end
+end

data/spec/extensions/extensions_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/../simple_spec_helper')
+
+class WithLolitaExtensions
+  include Lolita::Extensions
+end
+
+module Lolita::Extensions::Test
+  class Proxy
+    def initialize *args
+    end
+  end
+end
+
+describe Lolita::Extensions do
+  let(:test_class){ WithLolitaExtensions.new }
+  let(:object){
+    klass = Object.new
+    klass.class_eval{include Lolita::Extensions}
+    klass
+  }
+  
+  it "should load all extensions proxies" do
+    Lolita::Extensions.add(:test)
+    test_class.load_extensions_proxies(object)
+    test_class.test_proxy.should be_a(Lolita::Extensions::Test::Proxy)
+  end
+  
+  context "default extensions" do
+    it "should have default extensions proxies" do
+      test_class.load_extensions_proxies(object)
+      Lolita::Extensions::EXTENSIONS.each do |name|
+        test_class.send(:"#{name}_proxy").should be_a("Lolita::Extensions::#{name.to_s.camelize}::Proxy".constantize)
+      end
+    end
+  end
+
+  context "default configuration" do
+
+    it "should have authentication adapter" do
+      test_class.load_extensions_proxies(object)
+      test_class.authentication_proxy.respond_to?(:adapter).should be_true
+    end
+
+  end
+end

data/spec/fabricators/category_fabricator.rb

@@ -0,0 +1,3 @@
+Fabricator(:category) do 
+  name{Faker::Name.name}
+end

data/spec/fabricators/post_fabricator.rb

@@ -0,0 +1,4 @@
+Fabricator(:post) do 
+  title{Faker::Lorem.sentence}
+  category
+end

data/spec/fabricators/tag_fabricator.rb

@@ -0,0 +1,3 @@
+Fabricator(:tag) do 
+  name{Faker::Name.name}
+end

data/spec/lolita_spec.rb

@@ -8,6 +8,7 @@ describe Lolita do
         config.class.should == Lolita::SystemConfiguration::Base
       end
     end
+
   end
 end
 

data/spec/orm/mongoid.rb

@@ -1,3 +1,4 @@
+Bundler.setup(:mongoid)
 require 'mongoid'
 
 Mongoid.configure do |config|

data/spec/rails_app/app/mongoid/category.rb

@@ -1,6 +1,19 @@
+
 class Category
   include Mongoid::Document
   include Lolita::Configuration
   field :name, type: String
-  has_many :post
+  has_many :posts
+
+  lolita do
+    list do
+      list(:posts) do
+        column :comments do
+          list do
+            column :body
+          end
+        end
+      end
+    end
+  end
 end

data/spec/rails_app/app/mongoid/post.rb

@@ -15,7 +15,15 @@ class Post
   default_scope order_by([:title, :asc])
   accepts_nested_attributes_for :comments, :reject_if => :all_blank
 
-  lolita
+  lolita do
+    list do
+      column :comments do
+        list do
+          column :body
+        end
+      end
+    end
+  end
 
   def self.custom_search query,request=nil,dbi=nil
     self.where(:expire_date.gt => Date.today)

data/spec/rails_app/config/application.rb

@@ -7,10 +7,6 @@ require "sprockets/railtie"
 
 Bundler.require(:default, LOLITA_ORM, Rails.env) if defined?(Bundler)
 
-require 'lolita'
-require "lolita/rails/all"
-require 'kaminari'
-
 module RailsApp
 	class Application < Rails::Application
 		# Add additional load paths for your own custom dirs

data/spec/rails_app/config/boot.rb

@@ -5,8 +5,7 @@ LOLITA_ORM=:mongoid unless defined?(LOLITA_ORM)
 gemfile = File.expand_path('../../Gemfile', __FILE__)
 begin
   ENV['BUNDLE_GEMFILE'] = gemfile
-  require 'bundler'
-  Bundler.setup(:default,Rails.env,LOLITA_ORM)
+  Bundler.setup(Rails.env)
 rescue Bundler::GemNotFound => e
   STDERR.puts e.message
   STDERR.puts "Try running `bundle install`."

data/spec/register_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/simple_spec_helper')
+
+describe Lolita::Register do
+  let(:register){ Lolita::Register.new }
+  it "should create new" do
+    expect do
+      Lolita::Register.new
+    end.not_to raise_error
+  end
+
+  it "should set new key" do
+    register.set(:test, 1).should be_true
+  end
+
+  it "should get key" do
+    register.set(:test, 1)
+    register.get(:test).should == 1
+    register.get(:not_existing_key).should be_nil
+  end
+  
+  it "should get with options" do
+    register.set(:test, 1, :foo => :bar)
+    register.set(:test_without_options, 1)
+    register.get_with_options(:test).should have(2).items
+    register.get_with_options(:test_without_options).should have(1).item
+  end
+
+  it "should set key with options" do
+    register.set(:test, 1, :foo => :bar).should be_true
+  end
+  
+  context "filter" do
+    it "should accept only key" do
+      register.set(:test, 1, :foo => :bar)
+      register.filter(:test).should == [[1, {:foo=>:bar}]]
+    end
+
+    it "should accept key and options" do
+      register.set(:test, 1, :foo => :bar)
+      register.filter(:test, :foo => 0).should be_empty
+      register.filter(:test, :foo => :bar).should have(1).item
+    end
+
+    it "should accept only options" do
+      register.set(:test, 1, :foo => :bar)
+      register.filter(:foo => 0).should be_empty
+      register.filter(:foo => :bar).should have(1).item
+    end
+  end
+end

data/spec/search/simple_spec.rb

@@ -18,20 +18,20 @@ describe Lolita::Search::Simple do
 
     it "should run default search when no search method is provided" do
       pending "think that map_reduce should be fixed"
-      Factory.create(:post,:title => "moonwalker")
+      Fabricate(:post,:title => "moonwalker")
       search = Lolita::Search::Simple.new(dbi)
       search.run("moon").size.should == 1
     end
 
     it "should accept custom dbi for search" do
-      Factory.create(:category, :name => "special_text")
+      Fabricate(:category, :name => "special_text")
       search.run("special_text").should be_empty
       search.run("special_text",Object.new,Lolita::DBI::Base.create(Category)).should have(1).item
     end
 
     it "should run custom search when search method is provided" do
       search = Lolita::Search::Simple.new(dbi,:custom_search)
-      post = Factory.create(:post,:expire_date => 2.days.since)
+      post = Fabricate(:post,:expire_date => 2.days.since)
       results = search.run("")
       results.should have(1).item
       results.first.should == post
@@ -39,7 +39,7 @@ describe Lolita::Search::Simple do
 
     it "should use only given fields when they are presented" do
       search = Lolita::Search::Simple.new(dbi,:fields => [:body])
-      Factory.create(:post,:title => "only_in_title")
+      Fabricate(:post,:title => "only_in_title")
       search.run("only_in_title").should have(0).items
       search2 = Lolita::Search::Simple.new(dbi,:fields => [:title])
       search2.run("only_in_title").should have(1).item