pose 1.3.4 → 2.0.0

data/spec/pose_api_spec.rb

@@ -2,280 +2,282 @@
 
 require "spec_helper"
 
-describe Pose do
-  subject { PosableOne.new }
-
-  describe 'associations' do
-    it 'allows to access the associated words of a posable object directly' do
-      subject.should have(0).pose_words
-      subject.pose_words << PoseWord.new(text: 'one')
-      subject.should have_pose_words 'one'
+module Pose
+  describe Pose do
+    subject { PosableOne.new }
+
+    describe 'associations' do
+      it 'allows to access the associated words of a posable object directly' do
+        expect(subject).to have(0).pose_words
+        subject.pose_words << Word.new(text: 'one')
+        expect(subject).to have_pose_words 'one'
+      end
     end
-  end
 
 
-  describe '#update_pose_index' do
+    describe '#update_pose_index' do
 
-    before :each do
-      Pose::CONFIGURATION[:perform_search] = perform_search
-    end
+      before :each do
+        Pose::CONFIGURATION[:perform_search] = perform_search
+      end
 
-    after :each do
-      Pose::CONFIGURATION.delete :perform_search
-    end
+      after :each do
+        Pose::CONFIGURATION.delete :perform_search
+      end
 
-    context "search_in_tests flag is not enabled" do
-      let(:perform_search) { false }
+      context "search_in_tests flag is not enabled" do
+        let(:perform_search) { false }
 
-      it "doesn't call update_pose_words" do
-        subject.should_not_receive :update_pose_words
-        subject.update_pose_index
+        it "doesn't call update_pose_words" do
+          subject.should_not_receive :update_pose_words
+          subject.update_pose_index
+        end
       end
-    end
 
-    context "search_in_tests flag is enabled" do
-      let(:perform_search) { true }
+      context "search_in_tests flag is enabled" do
+        let(:perform_search) { true }
 
-      it "calls update_pose_words" do
-        subject.should_receive :update_pose_words
-        subject.update_pose_index
+        it "calls update_pose_words" do
+          subject.should_receive :update_pose_words
+          subject.update_pose_index
+        end
       end
     end
-  end
 
 
-  describe '#update_pose_words' do
+    describe '#update_pose_words' do
 
-    it 'saves the words for search' do
-      subject.text = 'foo bar'
-      subject.update_pose_words
-      subject.should have_pose_words 'foo', 'bar'
-    end
+      it 'saves the words for search' do
+        subject.text = 'foo bar'
+        subject.update_pose_words
+        expect(subject).to have_pose_words 'foo', 'bar'
+      end
 
-    it 'updates the search index when the text is changed' do
-      subject.text = 'foo'
-      subject.save!
+      it 'updates the search index when the text is changed' do
+        subject.text = 'foo'
+        subject.save!
 
-      subject.text = 'other text'
-      subject.update_pose_words
+        subject.text = 'other text'
+        subject.update_pose_words
 
-      subject.should have_pose_words 'other', 'text'
-    end
+        expect(subject).to have_pose_words 'other', 'text'
+      end
 
-    it "doesn't create duplicate words" do
-      subject.text = 'foo foo'
-      subject.save!
-      subject.should have(1).pose_words
+      it "doesn't create duplicate words" do
+        subject.text = 'foo foo'
+        subject.save!
+        expect(subject).to have(1).pose_words
+      end
     end
-  end
 
 
-  describe 'search' do
+    describe 'search' do
 
-    it 'works' do
-      pos = PosableOne.create text: 'foo'
-      result = Pose.search 'foo', PosableOne
-      result.should == { PosableOne => [pos] }
-    end
+      it 'works' do
+        pos = PosableOne.create text: 'foo'
+        result = Pose.search 'foo', PosableOne
+        expect(result).to eq({ PosableOne => [pos] })
+      end
 
-    describe 'classes parameter' do
+      describe 'classes parameter' do
 
-      before :each do
-        @pos1 = PosableOne.create text: 'foo'
-        @pos2 = PosableTwo.create text: 'foo'
-      end
+        before :each do
+          @pos1 = PosableOne.create text: 'foo'
+          @pos2 = PosableTwo.create text: 'foo'
+        end
 
-      it 'returns all requested classes' do
-        result = Pose.search 'foo', [PosableOne, PosableTwo]
+        it 'returns all requested classes' do
+          result = Pose.search 'foo', [PosableOne, PosableTwo]
 
-        result.keys.should have(2).items
-        result.keys.should include PosableOne
-        result.keys.should include PosableTwo
-      end
+          expect(result.keys).to have(2).items
+          expect(result.keys).to include PosableOne
+          expect(result.keys).to include PosableTwo
+        end
 
-      it 'returns all matching instances of each requested class' do
-        result = Pose.search 'foo', [PosableOne, PosableTwo]
+        it 'returns all matching instances of each requested class' do
+          result = Pose.search 'foo', [PosableOne, PosableTwo]
 
-        result[PosableOne].should == [@pos1]
-        result[PosableTwo].should == [@pos2]
-      end
+          expect(result[PosableOne]).to eq [@pos1]
+          expect(result[PosableTwo]).to eq [@pos2]
+        end
 
-      it 'returns only instances of the given classes' do
-        result = Pose.search 'foo', PosableOne
-        result.keys.should include PosableOne
-        result.keys.should_not include PosableTwo
+        it 'returns only instances of the given classes' do
+          result = Pose.search 'foo', PosableOne
+          expect(result.keys).to include PosableOne
+          result.keys.should_not include PosableTwo
+        end
       end
-    end
 
-    describe 'query parameter' do
+      describe 'query parameter' do
 
-      it 'returns an empty array if nothing matches' do
-        pos1 = PosableOne.create text: 'one'
-        result = Pose.search 'two', PosableOne
-        result[PosableOne].should be_empty
-      end
+        it 'returns an empty array if nothing matches' do
+          pos1 = PosableOne.create text: 'one'
+          result = Pose.search 'two', PosableOne
+          expect(result[PosableOne]).to be_empty
+        end
 
-      it 'returns only objects that match all given query words' do
-        pos1 = PosableOne.create text: 'one two'
-        pos2 = PosableOne.create text: 'one three'
-        pos3 = PosableOne.create text: 'two three'
+        it 'returns only objects that match all given query words' do
+          pos1 = PosableOne.create text: 'one two'
+          pos2 = PosableOne.create text: 'one three'
+          pos3 = PosableOne.create text: 'two three'
 
-        result = Pose.search 'two one', PosableOne
+          result = Pose.search 'two one', PosableOne
 
-        result[PosableOne].should == [pos1]
-      end
+          expect(result[PosableOne]).to eq [pos1]
+        end
 
-      it 'returns nothing if searching for a non-existing word' do
-        pos1 = PosableOne.create text: 'one two'
-        result = Pose.search 'one zonk', PosableOne
-        result[PosableOne].should be_empty
-      end
+        it 'returns nothing if searching for a non-existing word' do
+          pos1 = PosableOne.create text: 'one two'
+          result = Pose.search 'one zonk', PosableOne
+          expect(result[PosableOne]).to be_empty
+        end
 
-      it 'works if the query is given in uppercase' do
-        pos1 = PosableOne.create text: 'one two'
-        result = Pose.search 'OnE TwO', PosableOne
-        result[PosableOne].should == [pos1]
+        it 'works if the query is given in uppercase' do
+          pos1 = PosableOne.create text: 'one two'
+          result = Pose.search 'OnE TwO', PosableOne
+          expect(result[PosableOne]).to eq [pos1]
+        end
       end
-    end
 
 
-    describe "'limit' parameter" do
+      describe "'limit' parameter" do
 
-      before :each do
-        @pos1 = FactoryGirl.create :posable_one, text: 'foo', private: true
-        @pos2 = FactoryGirl.create :posable_one, text: 'foo', private: true
-        @pos3 = FactoryGirl.create :posable_one, text: 'foo', private: false
-      end
+        before :each do
+          @pos1 = FactoryGirl.create :posable_one, text: 'foo', private: true
+          @pos2 = FactoryGirl.create :posable_one, text: 'foo', private: true
+          @pos3 = FactoryGirl.create :posable_one, text: 'foo', private: false
+        end
 
-      context 'with ids and no scope' do
-        it 'limits the result set to the given number' do
-          result = Pose.search 'foo', PosableOne, result_type: :ids, limit: 1
-          result[PosableOne].should have(1).item
+        context 'with ids and no scope' do
+          it 'limits the result set to the given number' do
+            result = Pose.search 'foo', PosableOne, result_type: :ids, limit: 1
+            expect(result[PosableOne]).to have(1).item
+          end
         end
-      end
 
-      context 'with ids and scope' do
-        it 'limits the result set to the given number' do
-          result = Pose.search 'foo', PosableOne, result_type: :ids, limit: 1, where: [private: false]
-          result[PosableOne].should have(1).item
+        context 'with ids and scope' do
+          it 'limits the result set to the given number' do
+            result = Pose.search 'foo', PosableOne, result_type: :ids, limit: 1, where: [private: false]
+            expect(result[PosableOne]).to have(1).item
+          end
         end
-      end
 
-      context 'with classes and no scope' do
-        it 'limits the result set to the given number' do
-          result = Pose.search 'foo', PosableOne, limit: 1
-          result[PosableOne].should have(1).item
+        context 'with classes and no scope' do
+          it 'limits the result set to the given number' do
+            result = Pose.search 'foo', PosableOne, limit: 1
+            expect(result[PosableOne]).to have(1).item
+          end
         end
-      end
 
-      context 'with classes and scope' do
-        it 'limits the result set to the given number' do
-          result = Pose.search 'foo', PosableOne, limit: 1, where: [private: false]
-          result[PosableOne].should have(1).item
+        context 'with classes and scope' do
+          it 'limits the result set to the given number' do
+            result = Pose.search 'foo', PosableOne, limit: 1, where: [private: false]
+            expect(result[PosableOne]).to have(1).item
+          end
         end
       end
-    end
 
 
-    describe "'result_type' parameter" do
-
-      before :each do
-        @foo_one = FactoryGirl.create :posable_one, text: 'foo one'
-      end
+      describe "'result_type' parameter" do
 
-      describe 'default behavior' do
-        it 'returns full objects' do
-          result = Pose.search 'foo', PosableOne
-          result[PosableOne].first.should == @foo_one
+        before :each do
+          @foo_one = FactoryGirl.create :posable_one, text: 'foo one'
         end
-      end
 
-      context ':ids given' do
-        it 'returns ids instead of objects' do
-          result = Pose.search 'foo', PosableOne, result_type: :ids
-          result[PosableOne].first.should == @foo_one.id
+        describe 'default behavior' do
+          it 'returns full objects' do
+            result = Pose.search 'foo', PosableOne
+            expect(result[PosableOne].first).to eq @foo_one
+          end
         end
-      end
-    end
-
-
-    describe "'where' parameter" do
 
-      before :each do
-        @one = FactoryGirl.create :posable_one, text: 'foo one', private: true
-        @bar = FactoryGirl.create :posable_one, text: 'bar one', private: true
-        @two = FactoryGirl.create :posable_one, text: 'foo two', private: false
+        context ':ids given' do
+          it 'returns ids instead of objects' do
+            result = Pose.search 'foo', PosableOne, result_type: :ids
+            expect(result[PosableOne].first).to eq @foo_one.id
+          end
+        end
       end
 
-      context 'with result type :classes' do
 
-        it 'limits the result set by the given conditions' do
-          result = Pose.search 'foo', PosableOne, where: [ private: true ]
-          result[PosableOne].should have(1).item
-          result[PosableOne].should include @one
-        end
-
-        it 'allows to use the hash syntax for queries' do
-          result = Pose.search 'foo', PosableOne, where: [ private: true ]
-          result[PosableOne].should have(1).item
-          result[PosableOne].should include @one
-        end
+      describe "'where' parameter" do
 
-        it 'allows to use the string syntax for queries' do
-          result = Pose.search 'foo', PosableOne, where: [ ['private = ?', true] ]
-          result[PosableOne].should have(1).item
-          result[PosableOne].should include @one
+        before :each do
+          @one = FactoryGirl.create :posable_one, text: 'foo one', private: true
+          @bar = FactoryGirl.create :posable_one, text: 'bar one', private: true
+          @two = FactoryGirl.create :posable_one, text: 'foo two', private: false
         end
 
-        it 'allows to combine several conditions' do
-          three = FactoryGirl.create :posable_one, text: 'foo two', private: true
-          result = Pose.search 'foo', PosableOne, where: [ {private: true}, ['text = ?', 'foo two'] ]
-          result[PosableOne].should have(1).item
-          result[PosableOne].should include three
+        context 'with result type :classes' do
+
+          it 'limits the result set by the given conditions' do
+            result = Pose.search 'foo', PosableOne, where: [ private: true ]
+            expect(result[PosableOne]).to have(1).item
+            expect(result[PosableOne]).to include @one
+          end
+
+          it 'allows to use the hash syntax for queries' do
+            result = Pose.search 'foo', PosableOne, where: [ private: true ]
+            expect(result[PosableOne]).to have(1).item
+            expect(result[PosableOne]).to include @one
+          end
+
+          it 'allows to use the string syntax for queries' do
+            result = Pose.search 'foo', PosableOne, where: [ ['private = ?', true] ]
+            expect(result[PosableOne]).to have(1).item
+            expect(result[PosableOne]).to include @one
+          end
+
+          it 'allows to combine several conditions' do
+            three = FactoryGirl.create :posable_one, text: 'foo two', private: true
+            result = Pose.search 'foo', PosableOne, where: [ {private: true}, ['text = ?', 'foo two'] ]
+            expect(result[PosableOne]).to have(1).item
+            expect(result[PosableOne]).to include three
+          end
         end
-      end
 
-      context 'with result type :ids' do
+        context 'with result type :ids' do
 
-        it 'limits the result set by the given condition' do
-          result = Pose.search 'foo', PosableOne, result_type: :ids, where: [ private: true ]
-          result[PosableOne].should have(1).item
-          result[PosableOne].should include @one.id
+          it 'limits the result set by the given condition' do
+            result = Pose.search 'foo', PosableOne, result_type: :ids, where: [ private: true ]
+            expect(result[PosableOne]).to have(1).item
+            expect(result[PosableOne]).to include @one.id
+          end
         end
       end
     end
-  end
 
 
-  describe 'autocomplete_words' do
+    describe 'autocomplete_words' do
 
-    it 'returns words that start with the given phrase' do
-      PosableOne.create text: 'great green pine tree'
+      it 'returns words that start with the given phrase' do
+        PosableOne.create text: 'great green pine tree'
 
-      result = Pose.autocomplete_words 'gr'
+        result = Pose.autocomplete_words 'gr'
 
-      result.should have(2).words
-      result.should include 'great'
-      result.should include 'green'
-    end
+        expect(result).to have(2).words
+        expect(result).to include 'great'
+        expect(result).to include 'green'
+      end
 
-    it 'returns words that match the given phrase exactly' do
-      PoseWord.create text: 'cat'
-      result = Pose.autocomplete_words 'cat'
-      result.should == ['cat']
-    end
+      it 'returns words that match the given phrase exactly' do
+        Word.create text: 'cat'
+        result = Pose.autocomplete_words 'cat'
+        expect(result).to eq ['cat']
+      end
 
-    it 'stems the search query' do
-      PosableOne.create text: 'car'
-      result = Pose.autocomplete_words 'cars'
-      result.should have(1).words
-      result[0].should == 'car'
-    end
+      it 'stems the search query' do
+        PosableOne.create text: 'car'
+        result = Pose.autocomplete_words 'cars'
+        expect(result).to have(1).words
+        expect(result[0]).to eq 'car'
+      end
 
-    it 'returns nothing if the search query is empty' do
-      PosableOne.create text: 'foo bar'
-      result = Pose.autocomplete_words ''
-      result.should be_empty
+      it 'returns nothing if the search query is empty' do
+        PosableOne.create text: 'foo bar'
+        result = Pose.autocomplete_words ''
+        expect(result).to be_empty
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,95 +1,39 @@
-#require "rails/test_help"
-#require 'rspec/rails'
-require 'rubygems'
-require 'bundler/setup'
-require 'hashie'
-require 'active_record'
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/string'
-require 'pose'
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require 'rspec/rails'
+require 'rspec/autorun'
+require 'factory_girl_rails'
 require 'faker'
-require 'factory_girl'
-require 'database_cleaner'
-
-FactoryGirl.find_definitions
-
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
-Rails = Hashie::Mash.new({env: 'test'})
-
-# We have no Railtie in these tests --> load Pose manually.
-ActiveRecord::Base.send :extend, Pose::ActiveRecordBaseAdditions
-
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir["#{File.dirname __FILE__}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
-  # == Mock Framework
+  # ## Mock Framework
   #
   # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
   #
   # config.mock_with :mocha
   # config.mock_with :flexmock
   # config.mock_with :rr
-  config.mock_with :rspec
 
   # If you're not using ActiveRecord, or you'd prefer not to run each of your
   # examples within a transaction, remove the following line or assign false
   # instead of true.
-  # config.use_transactional_fixtures = true
-
-  config.before :suite do
-    setup_db
-    DatabaseCleaner.strategy = :deletion
-  end
-
-  config.before :each do
-    DatabaseCleaner.start
-  end
-
-  config.after :each do
-    DatabaseCleaner.clean
-  end
-end
-
-
-#####################
-# DATABASE SETUP
-#
-
-def setup_db
-  ActiveRecord::Base.establish_connection adapter:      'postgresql',
-                                          database:     'pose_test',
-                                          min_messages: 'INFO'
-
-  ActiveRecord::Schema.define(version: 1) do
-    unless table_exists? 'posable_ones'
-      create_table 'posable_ones' do |t|
-        t.string 'text'
-        t.boolean 'private'
-      end
-    end
+  config.use_transactional_fixtures = true
 
-    unless table_exists? 'posable_twos'
-      create_table 'posable_twos' do |t|
-        t.string 'text'
-        t.boolean 'private'
-      end
-    end
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = false
 
-    unless table_exists? 'pose_assignments'
-      create_table "pose_assignments" do |t|
-        t.integer "pose_word_id",            null: false
-        t.integer "posable_id",              null: false
-        t.string  "posable_type", limit: 20, null: false
-      end
-    end
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
 
-    unless table_exists? 'pose_words'
-      create_table "pose_words" do |t|
-        t.string "text", limit: 80, null: false
-      end
-    end
-  end
+  config.include FactoryGirl::Syntax::Methods
 end

data/spec/support/matchers.rb

@@ -10,4 +10,3 @@ RSpec::Matchers.define :have_pose_words do |*expected|
     "expected that subject would have pose words [#{expected.join ', '}], but it has [#{texts.join ', '}]"
   end
 end
-