neoid 0.1.2 → 0.2.0

data/spec/neoid/relationship_spec.rb

@@ -1,49 +1,50 @@
 require 'spec_helper'
 
 describe Neoid::Relationship do
-  let(:user) { User.create!(name: "Elad Ossadon", slug: "elado") }
-  let(:movie) { Movie.create!(name: "Memento", slug: "memento-1999", year: 1999) }
-  
-  it "should call neo_save after relationship model creation" do
-    Like.any_instance.should_receive(:neo_save)
+  let(:user) { User.create!(name: 'Elad Ossadon', slug: 'elado') }
+  let(:movie) { Movie.create!(name: 'Memento', slug: 'memento-1999', year: 1999) }
+
+  it 'should call neo_save after relationship model creation' do
+    expect_any_instance_of(Like).to receive(:neo_save)
     user.like! movie
   end
 
-  it "should create a neo_relationship for like" do
+  it 'should create a neo_relationship for like' do
     like = user.like! movie
     like = user.likes.last
 
-    like.neo_find_by_id.should_not be_nil
+    expect(like.neo_find_by_id).to_not be_nil
+
+    expect(like.neo_relationship).to_not be_nil
 
-    like.neo_relationship.should_not be_nil
-    
-    like.neo_relationship.start_node.should == user.neo_node
-    like.neo_relationship.end_node.should == movie.neo_node
-    like.neo_relationship.rel_type.should == 'likes'
+    expect(like.neo_relationship.start_node).to eq(user.neo_node)
+    expect(like.neo_relationship.end_node).to eq(movie.neo_node)
+    expect(like.neo_relationship.rel_type).to eq('likes')
   end
-  
-  it "should delete a relationship on deleting a record" do
+
+  it 'should delete a relationship on deleting a record' do
     user.like! movie
     like = user.likes.last
-    
+
     relationship_neo_id = like.neo_relationship.neo_id
 
-    Neography::Relationship.load(relationship_neo_id).should_not be_nil
-    
+    expect(Neography::Relationship.load(relationship_neo_id)).to_not be_nil
+
     user.unlike! movie
-    
+
     expect { Neography::Relationship.load(relationship_neo_id) }.to raise_error(Neography::RelationshipNotFoundException)
   end
 
-  it "should update neo4j on manual set of a collection" do
+  it 'should update neo4j on manual set of a collection' do
+    pending
     movies = [
-      Movie.create(name: "Memento"),
-      Movie.create(name: "The Prestige"),
-      Movie.create(name: "The Dark Knight"),
-      Movie.create(name: "Spiderman")
+      Movie.create(name: 'Memento'),
+      Movie.create(name: 'The Prestige'),
+      Movie.create(name: 'The Dark Knight'),
+      Movie.create(name: 'Spiderman')
     ]
 
-    user.neo_node.outgoing(:likes).length.should == 0
+    expect(user.neo_node.outgoing(:likes).length).to eq(0)
 
     expect {
       user.movies = movies
@@ -59,44 +60,45 @@ describe Neoid::Relationship do
     }.to change{ user.neo_node.outgoing(:likes).length }.to(0)
 
     expect {
-      user.movie_ids = movies[0...2].collect(&:id)
+      user.movie_ids = movies[0...2].map(&:id)
     }.to change{ user.neo_node.outgoing(:likes).length }.to(2)
   end
 
-  it "should update a relationship after relationship model update" do
+  it 'should update a relationship after relationship model update' do
     like = user.like! movie
 
-    like.neo_relationship.rate.should be_nil
+    expect(like.neo_relationship.rate).to be_nil
 
     like.rate = 10
     like.save!
 
-    like.neo_relationship.rate.should == 10
+    expect(like.neo_relationship.rate).to eq(10)
   end
 
-  context "polymorphic relationship" do
-    let(:user) { User.create(name: "Elad Ossadon", slug: "elado") }
+  context 'polymorphic relationship' do
+    let(:user) { User.create(name: 'Elad Ossadon', slug: 'elado') }
 
-    it "should create relationships with polymorphic items" do
+    it 'should create relationships with polymorphic items' do
+      pending
       followed = [
-        User.create(name: "Some One", slug: "someone"),
-        Movie.create(name: "The Prestige"),
-        Movie.create(name: "The Dark Knight")
+        User.create(name: 'Some One', slug: 'someone'),
+        Movie.create(name: 'The Prestige'),
+        Movie.create(name: 'The Dark Knight')
       ]
 
       expect {
         followed.each do |item|
           user.user_follows.create!(item: item)
         end
-      }.to change{ user.neo_node.outgoing(:follows).length }.to(followed.length)
+      }.to change { user.neo_node.outgoing(:follows).length }.to(followed.length)
 
       expect {
         user.user_follows = user.user_follows[0...1]
-      }.to change{ user.neo_node.outgoing(:follows).length }.to(1)
+      }.to change { user.neo_node.outgoing(:follows).length }.to(1)
 
       expect {
         user.user_follows = []
-      }.to change{ user.neo_node.outgoing(:follows).length }.to(0)
+      }.to change { user.neo_node.outgoing(:follows).length }.to(0)
     end
   end
 end

data/spec/neoid/search_spec.rb

@@ -1,30 +1,30 @@
 require 'spec_helper'
 
 describe Neoid::ModelAdditions do
-  context "search" do
+  context 'search' do
     let(:index_name) { "articles_search_index_#{Time.now.to_f.to_s.gsub('.', '')}" }
-    
-    it "should index and find node in fulltext" do
-      Neoid.db.create_node_index(index_name, "fulltext", "lucene")
-      
-      n = Neography::Node.create(name: "test hello world", year: 2012)
-      Neoid.db.add_node_to_index(index_name, "name", n.name, n)
-      Neoid.db.add_node_to_index(index_name, "year", n.year, n)
-      
+
+    it 'should index and find node in fulltext' do
+      Neoid.db.create_node_index(index_name, 'fulltext', 'lucene')
+
+      n = Neography::Node.create(name: 'test hello world', year: 2012)
+      Neoid.db.add_node_to_index(index_name, 'name', n.name, n)
+      Neoid.db.add_node_to_index(index_name, 'year', n.year, n)
+
       [
-        "name:test",
-        "year:2012",
-        "name:test AND year:2012"
+        'name:test',
+        'year:2012',
+        'name:test AND year:2012'
       ].each { |q|
         results = Neoid.db.find_node_index(index_name, q)
-        results.length.should == 1
-        Neoid.db.send(:get_id, results).should == n.neo_id
+        expect(results.length).to eq(1)
+        expect(Neoid.db.send(:get_id, results)).to eq(n.neo_id)
       }
     end
-    
-    it "should index item on save" do
+
+    it 'should index item on save' do
       r = rand(1000000)
-      article = Article.create!(title: "Hello world #{r}", body: "Lorem ipsum dolor sit amet", year: r)
+      article = Article.create!(title: "Hello world #{r}", body: 'Lorem ipsum dolor sit amet', year: r)
 
       [
         "title:#{r}",
@@ -33,58 +33,83 @@ describe Neoid::ModelAdditions do
       ].each do |q|
         results = Neoid.db.find_node_index(Neoid::DEFAULT_FULLTEXT_SEARCH_INDEX_NAME, q)
 
-        results.should_not be_nil
-        results.length.should == 1
-        Neoid.db.send(:get_id, results).should == article.neo_node.neo_id
+        expect(results).to_not be_nil
+        expect(results.length).to eq(1)
+        expect(Neoid.db.send(:get_id, results)).to eq(article.neo_node.neo_id)
       end
     end
-    
-    context "search session" do
-      it "should return a search session" do
-        Article.neo_search("hello").should be_a(Neoid::SearchSession)
+
+    context 'search session' do
+      it 'should return a search session' do
+        expect(Article.neo_search('hello')).to be_a(Neoid::SearchSession)
       end
-      
-      it "should find hits" do
-        article = Article.create!(title: "Hello world", body: "Lorem ipsum dolor sit amet", year: 2012)
-        
-        Article.neo_search("hello").hits.should == [ article.neo_node ]
+
+      it 'should find hits' do
+        article = Article.create!(title: 'Hello world', body: 'Lorem ipsum dolor sit amet', year: 2012)
+
+        expect(Article.neo_search('hello').hits).to eq([article.neo_node])
       end
-      
-      it "should find results with a search string" do
-        article = Article.create!(title: "Hello world", body: "Lorem ipsum dolor sit amet", year: 2012)
 
-        Article.neo_search("hello").results.should == [ article ]
+      it 'should find results with a search string' do
+        article = Article.create!(title: 'Hello world', body: 'Lorem ipsum dolor sit amet', year: 2012)
+
+        expect(Article.neo_search('hello').results).to eq([article])
       end
-      
-      it "should find results with a hash" do
+
+      it 'should find results with a hash' do
         articles = [
-          Article.create!(title: "How to draw manga", body: "Lorem ipsum dolor sit amet", year: 2012),
-          Article.create!(title: "Manga x", body: "Lorem ipsum dolor sit amet", year: 2013)
+          Article.create!(title: 'How to draw manga', body: 'Lorem ipsum dolor sit amet', year: 2012),
+          Article.create!(title: 'Manga x', body: 'Lorem ipsum dolor sit amet', year: 2013)
         ]
 
 
-        Article.neo_search(year: 2012).results.should == [ articles[0] ]
+        expect(Article.neo_search(year: 2012).results).to eq([articles[0]])
       end
     end
 
-    context "search in multiple types" do
+    context 'in multiple types' do
       before :each do
         @articles = [
-          Article.create!(title: "How to draw manga", body: "Lorem ipsum dolor sit amet", year: 2012),
-          Article.create!(title: "Manga x", body: "Lorem ipsum dolor sit amet", year: 2012)
+          Article.create!(title: 'How to draw manga', body: 'Lorem ipsum dolor sit amet', year: 2012),
+          Article.create!(title: 'Manga x', body: 'Lorem ipsum dolor sit amet', year: 2012)
         ]
 
         @movies = [
-          Movie.create!(name: "Anime is not Manga", slug: "anime")
+          Movie.create!(name: 'Anime is not Manga', slug: 'anime')
         ]
       end
 
-      it "should search in multiple types" do
-        Neoid.search([Article, Movie], "manga").results.should =~ @articles + @movies
+      it 'should search in multiple types' do
+        expect(Neoid.search([Article, Movie], 'manga').results).to match_array(@articles + @movies)
+      end
+
+      it 'should search in single type when specified' do
+        expect(Neoid.search([Article], 'manga').results).to match_array(@articles)
+      end
+    end
+
+    context 'matching types' do
+      before :each do
+        Article.create!(title: 'Comics: How to draw manga', body: 'Lorem ipsum dolor sit amet', year: 2012)
+        Article.create!(title: 'Manga x', body: 'Lorem ipsum dolor sit amet', year: 2012)
+        Article.create!(title: 'hidden secrets of comics masters', body: 'Lorem ipsum dolor sit amet', year: 2012)
+        Article.create!(title: 'hidden secrets of manga comics artists', body: 'Lorem ipsum dolor sit amet', year: 2012)
+      end
+
+      it 'will match by keyword' do
+        expect(Neoid.search([Article], 'manga comics').results.size).to eq(1)
+      end
+
+      it 'will match with AND' do
+        expect(Neoid.search([Article], 'manga comics', match_type: 'AND').results.size).to eq(1)
+      end
+
+      it 'will match with OR' do
+        expect(Neoid.search([Article], 'manga comics', match_type: 'OR').results.size).to eq(4)
       end
 
-      it "should search in single type when specified" do
-        Neoid.search([Article], "manga").results.should =~ @articles
+      it 'will fail with wrong match_type' do
+        expect { Neoid.search([Article], 'manga comics', match_type: 'MAYBE') }.to raise_error('Invalid match_type option. Valid values are AND,OR')
       end
     end
   end

data/spec/neoid_spec.rb

@@ -1,11 +1,18 @@
 require 'spec_helper'
 
 describe Neoid do
-  context "subrefs" do
-    it "should create all subrefs on initialization" do
+  context 'subrefs' do
+    before(:each) do
+      # first we have to enable subrefs
+      Neoid.config.enable_subrefs = true
+      # now that its enabled, we re-initialize the module
+      Neoid.initialize_all
+    end
+
+    it 'should create all subrefs on initialization' do
       Neoid.node_models.each do |klass|
-        klass.instance_variable_get(:@neo_subref_node).should_not be_nil
+        expect(klass.instance_variable_get(:@neo_subref_node)).to_not be_nil
       end
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -2,10 +2,23 @@ require 'neoid'
 require 'active_record'
 require 'neography'
 require 'rest-client'
+require 'codeclimate-test-reporter'
+require 'factory_girl'
+require 'rspec/its'
 
-# ENV['NEOID_LOG'] = 'true'
+CodeClimate::TestReporter.start if ENV['CODECLIMATE_REPO_TOKEN']
 
-uri = URI.parse(ENV["NEO4J_URL"] ? ENV["NEO4J_URL"] : ENV['TRAVIS'] ? "http://localhost:7474" : "http://localhost:7574")
+require 'simplecov'
+
+require "factories.rb"
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+]
+
+SimpleCov.start
+
+uri = URI.parse('http://localhost:7474')
 $neo = Neography::Rest.new(uri.to_s)
 
 Neography.configure do |c|
@@ -21,9 +34,13 @@ end
 
 Neoid.db = $neo
 
+Neoid.configure do |config|
+  config.enable_subrefs = false
+end
+
 logger, ActiveRecord::Base.logger = ActiveRecord::Base.logger, Logger.new('/dev/null')
 ActiveRecord::Base.configurations = YAML::load(IO.read(File.join(File.dirname(__FILE__), 'support/database.yml')))
-ActiveRecord::Base.establish_connection('sqlite3')
+ActiveRecord::Base.establish_connection(:sqlite3)
 
 require 'support/schema'
 require 'support/models'
@@ -31,11 +48,13 @@ require 'support/models'
 ActiveRecord::Base.logger = logger
 
 RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+
   config.mock_with :rspec
 
   config.before(:all) do
   end
-  
+
   config.before(:each) do
     Neoid.node_models.each(&:destroy_all)
     Neoid.clean_db(:yes_i_am_sure)

data/spec/support/database.yml

@@ -3,4 +3,4 @@ sqlite3:
   database: ":memory:"
   encoding: utf8
   charset: utf8
-  timeout: 5000
+  timeout: 5000

data/spec/support/models.rb

@@ -1,26 +1,26 @@
 class User < ActiveRecord::Base
   include ActiveModel::Validations::Callbacks
-  
+
   has_many :likes
   has_many :movies, through: :likes
 
   has_many :user_follows
-  
+
   def likes?(movie)
     likes.where(movie_id: movie.id).exists?
   end
-  
+
   def like!(movie)
     movies << movie unless likes?(movie)
     likes.where(movie_id: movie.id).first
   end
-  
+
   def unlike!(movie)
-    likes.where(movie_id: movie.id, user_id: self.id).destroy_all
+    likes.where(movie_id: movie.id, user_id: id).destroy_all
   end
-  
+
   include Neoid::Node
-  
+
   neoidable do |c|
     c.field :name
     c.field :slug
@@ -29,12 +29,12 @@ end
 
 class Movie < ActiveRecord::Base
   include ActiveModel::Validations::Callbacks
-  
+
   has_many :likes
   has_many :users, through: :likes
-  
+
   include Neoid::Node
-  
+
   neoidable do |c|
     c.field :name
     c.field :slug
@@ -55,9 +55,9 @@ class UserFollow < ActiveRecord::Base
 
   belongs_to :user
   belongs_to :item, polymorphic: true
-  
+
   include Neoid::Relationship
-  
+
   neoidable do |c|
     c.relationship start_node: :user, end_node: :item, type: :follows
   end
@@ -65,12 +65,12 @@ end
 
 class Like < ActiveRecord::Base
   include ActiveModel::Validations::Callbacks
-  
+
   belongs_to :user
   belongs_to :movie
-  
+
   include Neoid::Relationship
-  
+
   neoidable do |c|
     c.relationship start_node: :user, end_node: :movie, type: :likes
     c.field :rate
@@ -84,7 +84,7 @@ class Article < ActiveRecord::Base
     c.field :title
     c.field :year
     c.field :title_length do
-      self.title ? self.title.length : 0
+      title ? title.length : 0
     end
 
     c.search do |s|