filter_factory 0.0.3 → 0.1.0

data/spec/filter_factory/field_spec.rb

@@ -1,60 +1,58 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe FilterFactory::Field do
-  describe "#initialize" do
-    it "should create field with name & condition specified" do
+RSpec.describe FilterFactory::Field do
+  describe '#initialize' do
+    it 'creates field with name & condition specified' do
       field = described_class.new(:name, :eq)
-      field.should be_instance_of(described_class)
-      field.alias.should == :name
-      field.name.should == :name
-      field.condition.should == :eq
+      expect([field.alias, field.name, field.condition]).to eq([:name, :name, :eq])
     end
 
-    it "should create field with name, condition & options specified" do
+    it 'creates field with name, condition & options specified' do
       field = described_class.new(:name, :eq, alias: :my_name)
-      field.should be_instance_of(described_class)
-      field.alias.should == :my_name
-      field.name.should == :name
-      field.condition.should == :eq
+      expect([field.alias, field.name, field.condition]).to eq([:my_name, :name, :eq])
     end
 
-    it "should raise error if name is not specified" do
-      expect{ described_class.new }.to raise_error(ArgumentError)
+    it 'raises error if name is not specified' do
+      expect { described_class.new }.to raise_error(ArgumentError)
     end
 
-    it "should raise error if condition is not specified" do
-      expect{ described_class.new(:name) }.to raise_error(ArgumentError)
+    it 'raises error if condition is not specified' do
+      expect { described_class.new(:name) }.to raise_error(ArgumentError)
     end
 
-    it "should raise error if wrong condition specified" do
-      expect{ described_class.new(:name, :my_eq) }.to raise_error(ArgumentError)
+    it 'raises error if wrong condition specified' do
+      expect { described_class.new(:name, :my_eq) }.to raise_error(ArgumentError)
     end
   end
 
-  describe "#==" do
-    it "should be equal to obj if it is an instance of Field & it has equal name, condition & alias" do
+  describe '#==' do
+    it 'equals to obj if it is an instance of Field & it has equal name, condition & alias' do
       f1 = described_class.new(:name, :eq)
       f2 = described_class.new(:name, :eq, alias: :name)
-      f1.should == f2
+      expect(f1 == f2).to eq(true)
     end
 
-    it "should not be equal to obj if it is not an instance of Field" do
+    it 'is not equal to obj if it is not an instance of Field' do
       f = described_class.new(:name, :eq)
-      f.should_not == []
-      f.should_not == {}
-      f.should_not == 0
+      expect([f == [], f == {}, f == 0]).to eq([false, false, false])
     end
 
-    it "should not be equal to obj if it is an instance of Field & it does not have equal name" do
-      described_class.new(:name, :eq).should_not == described_class.new(:my_name, :eq)
+    it 'is not equal to obj if it is an instance of Field & it does not have equal name' do
+      f1 = described_class.new(:name, :eq)
+      f2 = described_class.new(:my_name, :eq)
+      expect(f1 == f2).to eq(false)
     end
 
-    it "should not be equal to obj if it is an instance of Field & it does not have equal condition" do
-      described_class.new(:name, :eq).should_not == described_class.new(:name, :ne)
+    it 'is not equal to obj if it is an instance of Field & it does not have equal condition' do
+      f1 = described_class.new(:name, :eq)
+      f2 = described_class.new(:name, :ne)
+      expect(f1 == f2).to eq(false)
     end
 
-    it "should not be equal to obj if it is an instance of Field & it does not have equal alias" do
-      described_class.new(:name, :eq).should_not == described_class.new(:name, :eq, alias: :my_name)
+    it 'is not equal to obj if it is an instance of Field & it does not have equal alias' do
+      f1 = described_class.new(:name, :eq)
+      f2 = described_class.new(:name, :eq, alias: :my_name)
+      expect(f1 == f2).to eq(false)
     end
   end
-end
+end

data/spec/filter_factory/filter_spec.rb

@@ -1,128 +1,128 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe FilterFactory::Filter do
-  it "should create filter and execute block" do
-    test_fields = [[:field1, :eq], [:field2, :eq], [:field3, :eq]]
+RSpec.describe FilterFactory::Filter do
+  describe '::create' do
+    it 'creates filter and execute block' do
+      test_fields = [[:field1, :eq], [:field2, :eq], [:field3, :eq]]
 
-    filter = described_class.create do
-      test_fields.each do |arr|
-        field *arr
+      filter = described_class.create do
+        test_fields.each do |arr|
+          field *arr
+        end
       end
-    end
 
-    filter.should be_a(described_class)
+      expect(filter.fields.map {|f| [f.name, f.condition]}).to eq(test_fields)
+    end
 
-    filter.fields.map{|f| [f.name, f.condition]}.should == test_fields
-  end
+    it 'defines singleton method for defined field by its name if no alias option specified' do
+      filter = described_class.create do
+        field :name, :eq
+      end
 
-  it "should define singleton method for defined field by its name if no alias option specified" do
-    filter = described_class.create do
-      field :name, :eq
+      expect(filter).to respond_to(:name, :'name=')
     end
 
-    filter.should respond_to(:name, :'name=')
-  end
+    it 'defines singleton method for defined field by its alias if alias option specified' do
+      filter = described_class.create do
+        field :name, :eq, alias: :my_name
+      end
 
-  it "should define singleton method for defined field by its alias if alias option specified" do
-    filter = described_class.create do
-      field :name, :eq, alias: :my_name
+      expect(filter).to respond_to(:my_name, :'my_name=')
     end
 
-    filter.should respond_to(:my_name, :'my_name=')
+    it 'raises error if duplicate field definition found' do
+      expect {
+        described_class.create do
+          field :name, :eq
+          field :surname, :regex, alias: :last_name
+          field :name, :eq, alias: :name
+        end
+      }.to raise_error(FilterFactory::Filter::DuplicateFieldError)
+    end
   end
 
-  it "should get field value" do
-    filter = described_class.create do
-      field :name, :eq
+  describe '#<field_name>, #<field_name>=' do
+    it 'gets field value' do
+      filter = described_class.create do
+        field :name, :eq
+      end
+
+      filter.fields.first.value = 'sample name'
+      expect(filter.name).to eq('sample name')
     end
 
-    filter.fields.first.value = "sample name"
-    filter.name.should == "sample name"
-  end
+    it 'sets field value' do
+      filter = described_class.create do
+        field :name, :eq
+      end
 
-  it "should set field value" do
-    filter = described_class.create do
-      field :name, :eq
+      filter.name = 'sample name'
+      expect(filter.fields.first.value).to eq('sample name')
     end
-
-    filter.name = "sample name"
-    filter.fields.first.value.should == "sample name"
   end
 
-  it "should respond_to attributes & attributes= methods" do
-    filter = described_class.create do
-      field :name, :eq
+  describe '#attributes, #attributes=' do
+    it 'respond_tos attributes & attributes= methods' do
+      filter = described_class.create do
+        field :name, :eq
+      end
+
+      expect(filter).to respond_to(:attributes, :attributes=)
     end
 
-    filter.should respond_to(:attributes, :attributes=)
-  end
+    it 'returns valid attributes' do
+      filter = described_class.create do
+        field :name, :eq
+        field :surname, :regex, alias: :last_name
+      end
+      filter.name = 'test name'
 
-  it "should return valid attributes" do
-    filter = described_class.create do
-      field :name, :eq
-      field :surname, :regex, alias: :last_name
+      expected_attributes = HashWithIndifferentAccess.new(name: 'test name', last_name: nil)
+
+      expect(filter.attributes).to eq(expected_attributes)
     end
-    filter.name = "test name"
 
-    filter.attributes.should == HashWithIndifferentAccess.new({name: "test name", last_name: nil})
+    it 'fills filter values from hash' do
+      filter = described_class.create do
+        field :name, :eq
+        field :surname, :regex, alias: :last_name
+      end
+
+      attributes = { name: 'my test name', last_name: 'surname here' }
+      filter.attributes = attributes
+      expect(filter.attributes).to eq(HashWithIndifferentAccess.new(attributes))
+    end
   end
 
-  it "should raise error if duplicate field definition found" do
-    expect do
-      described_class.create do
+  describe '#get_field' do
+    it 'responds to #get_field method' do
+      expect(subject).to respond_to(:get_field)
+    end
+
+    it 'returns valid field by calling #get_field' do
+      filter = described_class.create do
         field :name, :eq
         field :surname, :regex, alias: :last_name
-        field :name, :eq, alias: :name
       end
-    end.to raise_error(FilterFactory::Filter::DuplicateFieldError)
-  end
 
-  it "should respond to #get_field method" do
-    should respond_to(:get_field)
-  end
+      field_name = filter.get_field(:name)
+      expect([field_name.class, field_name.condition]).to eq([FilterFactory::Field, :eq])
 
-  it "should return valid field by calling #get_field" do
-    filter = described_class.create do
-      field :name, :eq
-      field :surname, :regex, alias: :last_name
+      field_surname = filter.get_field(:surname)
+      expect([field_surname.class, field_surname.condition]).to eq([FilterFactory::Field, :regex])
+
+      expect(filter.get_field(:my_name)).to be_nil
     end
-    filter.get_field(:name).should be_instance_of(FilterFactory::Field)
-    filter.get_field(:name).condition.should == :eq
-    filter.get_field(:surname).should be_instance_of(FilterFactory::Field)
-    filter.get_field(:surname).condition.should == :regex
-    filter.get_field(:my_name).should be_nil
   end
 
   described_class::CONDITIONS.each do |condition|
-    it "should respond to #{condition} method" do
-      should respond_to(condition)
+    it 'responds to #{condition} method' do
+      expect(subject).to respond_to(condition)
     end
 
-    it "should define field with '#{condition}' condition" do
+    it "defines field with '#{condition}' condition" do
       filter = described_class.create{ public_send(condition, :name) }
-      filter.get_field(:name).condition.should == condition
+      expect(filter.get_field(:name).condition).to eq(condition)
     end
   end
-
-  it "should fill filter values from hash" do
-    filter = described_class.create do
-      field :name, :eq
-      field :surname, :regex, alias: :last_name
-    end
-
-    attributes = {name: "my test name", last_name: "surname here"}
-    filter.attributes = attributes
-    filter.attributes.should == HashWithIndifferentAccess.new(attributes)
-  end
-
-  #describe "#conditions" do
-  #  it "should return result of query method for each of the condition as a Method object" do
-  #    filter = described_class.create do
-  #      field :name, :eq
-  #    end
-  #
-  #    filter.name = "sample name"
-  #    filter.conditions.first.should be_a(Method)
-  #  end
-  #end
-end
+end

data/spec/filter_factory/mongoid/model_spec.rb

@@ -1,152 +1,138 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe MPost do
-  before(:each) do
-    @posts = FactoryGirl.create_list(:mongoid_post, 10)
-  end
+RSpec.describe MPost do
+  let!(:posts) { FactoryGirl.create_list(:mongoid_post, 5) }
 
-  it "should respond to ::filter method" do
-    described_class.should respond_to(:filter)
+  it 'responds to ::filter method' do
+    expect(described_class).to respond_to(:filter)
   end
 
-  it "should execute filter methods chain" do
-    sample = @posts.sample
+  it 'executes filter methods chain' do
+    sample = posts.sample
 
     filter = FilterFactory.create do
-      field :title,  :eq
-      field :author, :eq, alias: :user
-      field :views,  :gte
+      eq :title
+      eq :author, alias: :user
+      gte :views
     end
 
     filter.title = sample.title
     filter.user = sample.author
 
-    described_class.filter(filter).to_a.should == [sample]
+    expect(described_class.filter(filter).to_a).to eq([sample])
   end
 
-  it "should return records with column' values equal to specified value" do
-    sample = @posts.sample
+  it 'returns records with column values equal to specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :id,  :eq
-    end
+    filter = FilterFactory.create { eq :id }
     filter.id = sample.id
 
-    described_class.filter(filter).to_a.should == [sample]
+    expect(described_class.filter(filter).to_a).to eq([sample])
   end
 
-  it "should return records with column' values not equal specified value" do
-    sample = @posts.sample
+  it 'returns records with column values not equal specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :id,  :ne
-    end
+    filter = FilterFactory.create { ne :id }
     filter.id = sample.id
 
-    described_class.filter(filter).to_a.sort.should == @posts.reject{|p| p.id == sample.id}
+    expected_result = posts.reject { |p| p.id == sample.id }
+    expect(described_class.filter(filter).to_a.sort).to eq(expected_result)
   end
 
-  it "should return records with column' values less than specified value" do
-    sample = @posts.sample
+  it 'returns records with column values less than specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :views,  :lt
-    end
+    filter = FilterFactory.create { lt :views }
     filter.views = sample.views
 
-    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views < sample.views}.map(&:id).sort
+    expected_result = posts.select { |p| p.views < sample.views }.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values less than or equal to specified value" do
-    sample = @posts.sample
+  it 'returns records with column values less than or equal to specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :views,  :lte
-    end
+    filter = FilterFactory.create { lte :views }
     filter.views = sample.views
 
-    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views <= sample.views}.map(&:id).sort
+    expected_result = posts.select { |p| p.views <= sample.views }.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values greater than specified value" do
-    sample = @posts.sample
+  it 'returns records with column values greater than specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :views,  :gt
-    end
+    filter = FilterFactory.create { gt :views }
     filter.views = sample.views
 
-    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views > sample.views}.map(&:id).sort
+    expected_result = posts.select { |p| p.views > sample.views }.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values greater than or equal to specified value" do
-    sample = @posts.sample
+  it 'returns records with column values greater than or equal to specified value' do
+    sample = posts.sample
 
-    filter = FilterFactory.create do
-      field :views,  :gte
-    end
+    filter = FilterFactory.create { gte :views }
     filter.views = sample.views
 
-    described_class.filter(filter).map(&:id).sort.should == @posts.select{|p| p.views >= sample.views}.map(&:id).sort
+    expected_result = posts.select { |p| p.views >= sample.views }.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values all equal to specified value" do
-    sample = @posts.sample(2)
-    sample.each{|r| r.update_attribute(:opts, [1, 2, 3, 4])}
+  it 'returns records with column values all equal to specified value' do
+    sample = posts.sample(2)
+    sample.each { |r| r.update_attribute(:opts, [1, 2, 3, 4]) }
 
-    filter = FilterFactory.create do
-      field :opts,  :all
-    end
+    filter = FilterFactory.create { all :opts }
     filter.opts = [1, 2, 3, 4]
 
-    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+    expected_result = sample.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values in specified values" do
-    sample = @posts.sample(3)
+  it 'returns records with column values in specified values' do
+    sample = posts.sample(3)
 
     filter = FilterFactory.create do
-      field :id,  :in
+      field :id, :in
     end
     filter.id = sample.map(&:id)
 
-    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+    expected_result = sample.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values not in specified values" do
-    sample = @posts.sample(3)
+  it 'returns records with column values not in specified values' do
+    sample = posts.sample(3)
 
-    filter = FilterFactory.create do
-      field :id,  :nin
-    end
+    filter = FilterFactory.create { nin :id }
     filter.id = sample.map(&:id)
 
-    described_class.filter(filter).map(&:id).sort.should == (@posts.map(&:id) - sample.map(&:id)).sort
+    expected_result = (posts.map(&:id) - sample.map(&:id)).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with column' values which match the specified regexp" do
-    sample = @posts.sample(3)
-    sample.each_with_index{|r,i| r.update_attribute(:title, "my_title_#{i}")}
-
-    filter = FilterFactory.create do
-      field :title,  :regex
-    end
+  it 'returns records with column values which match the specified regexp' do
+    sample = posts.sample(3)
+    sample.each_with_index { |r, i| r.update_attribute(:title, "my_title_#{i}") }
 
+    filter = FilterFactory.create { regex :title }
     filter.title = '_title_'
 
-    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+    expected_result = sample.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
 
-  it "should return records with existing column' values" do
-    sample = @posts.sample(3)
-    sample.each{|r| r.update_attribute(:not_exists, rand(0..25))}
-
-    filter = FilterFactory.create do
-      field :not_exists, :exists
-    end
+  it 'returns records with existing column values' do
+    sample = posts.sample(3)
+    sample.each { |r| r.update_attribute(:not_exists, rand(0..25)) }
 
+    filter = FilterFactory.create { exists :not_exists }
     filter.not_exists = true
 
-    described_class.filter(filter).map(&:id).sort.should == sample.map(&:id).sort
+    expected_result = sample.map(&:id).sort
+    expect(described_class.filter(filter).map(&:id).sort).to eq(expected_result)
   end
-end
+end

data/spec/models/ar_post.rb

@@ -1,2 +1,2 @@
 class ARPost < ActiveRecord::Base
-end
+end

data/spec/spec_helper.rb

@@ -2,56 +2,48 @@ MODELS = File.join(File.dirname(__FILE__), 'models')
 
 require 'rubygems'
 
+require 'mysql2'
 require 'mongoid'
 require 'active_record'
-require 'database_cleaner'
 require 'factory_girl'
 
 require 'filter_factory'
 
-Dir["#{MODELS}/*.rb"].each { |f| require f }
+require 'models/ar_post'
+require 'models/m_post'
 
 Mongoid.configure do |config|
   config.connect_to 'mongoid_filter_factory_test'
 end
-#Mongoid.logger = Logger.new($stdout)
-#Moped.logger = Logger.new($stdout)
+Mongoid.logger.level = Logger::ERROR
+Mongo::Logger.logger.level = Logger::ERROR
+
+# create mysql database
+client = Mysql2::Client.new(host: '127.0.0.1', username: 'root', password: nil)
+client.query('CREATE DATABASE IF NOT EXISTS active_record_filter_factory_test')
+client.close
 
 ActiveRecord::Base.establish_connection(
-  adapter: "mysql2",
-  database: "active_record_filter_factory_test"
+  adapter: 'mysql2',
+  database: 'active_record_filter_factory_test'
 )
-ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS ar_posts")
+
+# create mysql table if not exists
+ActiveRecord::Base.connection.execute('DROP TABLE IF EXISTS ar_posts')
 ActiveRecord::Base.connection.create_table(:ar_posts) do |t|
   t.string :title
   t.string :author
   t.integer :views
 end
-#ActiveRecord::Base.logger = Logger.new($stdout)
-#ActiveRecord::Base.logger.level = Logger::DEBUG
 
 FactoryGirl.definition_file_paths = [File.join(File.dirname(__FILE__), 'factories')]
 FactoryGirl.find_definitions
 
 RSpec.configure do |config|
   config.mock_with :rspec
-  config.color_enabled = true
-
-  config.before(:suite) do
-    mongoid = DatabaseCleaner[:mongoid]
-    mongoid.strategy = :truncation
-    mongoid.clean_with(:truncation)
-
-    active_record = DatabaseCleaner[:active_record]
-    active_record.strategy = :truncation
-    active_record.clean_with(:truncation)
-  end
-
-  config.before(:each) do
-    DatabaseCleaner.start
-  end
 
   config.after(:each) do
-    DatabaseCleaner.clean
+    ARPost.delete_all
+    MPost.delete_all
   end
-end
+end