chewy 0.8.4 → 7.3.4

data/spec/chewy/type/witchcraft_spec.rb

@@ -1,154 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type::Witchcraft do
-  def self.mapping(&block)
-    before do
-      stub_index(:products) do
-        define_type :product do
-          witchcraft!
-
-          instance_exec(&block)
-        end
-      end
-    end
-  end
-
-  describe '#cauldron' do
-    let(:type) { ProductsIndex::Product }
-    let(:object) { }
-
-    context 'empty mapping' do
-      mapping {}
-      specify { expect(type.cauldron.brew(object)).to eq({}) }
-    end
-
-    context do
-      mapping do
-        field :name
-        field :age
-        field :tags
-      end
-      let(:attributes) { { name: 'Name', age: 13, tags: %w[Ruby RoR] } }
-
-      context do
-        let(:object) { double(attributes) }
-        specify { expect(type.cauldron.brew(object)).to eq(attributes.as_json) }
-      end
-
-      context do
-        let(:object) { attributes }
-        specify { expect(type.cauldron.brew(object)).to eq(attributes.as_json) }
-      end
-    end
-
-    context 'simple lambdas' do
-      mapping do
-        field :name
-        field :age, value: -> (obj) {
-          obj.age if obj
-        }
-        field :tags, value: -> { tags.map(&:to_sym) }
-      end
-      let(:attributes) { { name: 'Name', age: 13, tags: %w[Ruby RoR] } }
-
-      context do
-        let(:object) { double(attributes) }
-        specify { expect(type.cauldron.brew(object)).to eq(attributes.merge(tags: [:Ruby, :RoR]).as_json) }
-      end
-    end
-
-    context 'crutches' do
-      mapping do
-        field :name, value: -> (o, c) { c.names[0] }
-      end
-      let(:attributes) { { name: 'Name' } }
-
-      context do
-        let(:object) { double(attributes) }
-        let(:crutches) { double(names: ['Other']) }
-        specify { expect(type.cauldron.brew(object, crutches)).to eq({name: 'Other'}.as_json) }
-      end
-    end
-
-    context 'nesting' do
-      context do
-        mapping do
-          field :queries do
-            field :title
-            field :body, value: -> { "This #{self[:body]}" }
-          end
-        end
-
-        let(:object) { double(queries: [
-          {title: 'Title1', body: 'Body1'},
-          {title: 'Title2', body: 'Body2'}
-        ]) }
-        specify { expect(type.cauldron.brew(object)).to eq({ queries: [
-          {title: 'Title1', body: 'This Body1'},
-          {title: 'Title2', body: 'This Body2'}
-        ] }.as_json) }
-      end
-
-      context do
-        mapping do
-          field :queries do
-            field :title
-            field :body, value: -> { "This #{body}" }
-          end
-        end
-
-        let(:object) { double(queries: [
-          double(title: 'Title1', body: 'Body1'),
-          double(title: 'Title2', body: 'Body2')
-        ]) }
-        specify { expect(type.cauldron.brew(object)).to eq({ queries: [
-          {title: 'Title1', body: 'This Body1'},
-          {title: 'Title2', body: 'This Body2'}
-        ] }.as_json) }
-      end
-
-      context do
-        mapping do
-          field :queries, value: -> { queries } do
-            field :title
-            field :body, value: -> { "This #{body}" }
-          end
-        end
-
-        let(:object) { double(queries: [
-          double(title: 'Title1', body: 'Body1'),
-          double(title: 'Title2', body: 'Body2')
-        ]) }
-        specify { expect(type.cauldron.brew(object)).to eq({ queries: [
-          {title: 'Title1', body: 'This Body1'},
-          {title: 'Title2', body: 'This Body2'}
-        ] }.as_json) }
-      end
-
-      context do
-        mapping do
-          field :queries do
-            field :fields, value: -> (o, q) { q.fields } do
-              field :first
-              field :second, value: -> (o, q, f, c) {
-                q.value + (f.respond_to?(:second) ? f.second : c.second)
-              }
-            end
-          end
-        end
-
-        let(:object) { double(queries: [
-          double(value: 'Value1', fields: [double(first: 'First1', second: 'Second1'), {first: 'First2'}]),
-          double(value: 'Value2', fields: double(first: 'First3', second: 'Second2', third: 'Third'))
-        ]) }
-        specify { expect(type.cauldron.brew(object, double(second: 'Crutch'))).to eq({queries: [
-          {fields: [
-            {first: 'First1', second: 'Value1Second1'},
-            {first: 'First2', second: 'Value1Crutch'}
-          ]},
-          {fields: {first: 'First3', second: 'Value2Second2'}}
-        ]}.as_json) }
-      end
-    end
-  end
-end

data/spec/chewy/type/wrapper_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type::Wrapper do
-  before do
-    stub_class(:city)
-    stub_index(:cities) do
-      define_type City
-    end
-  end
-
-  let(:city_type) { CitiesIndex::City }
-
-  subject(:city) { city_type.new(name: 'Martin', age: 42) }
-
-  it do
-    is_expected.to respond_to(:name)
-      .and respond_to(:age)
-      .and have_attributes(
-        name: 'Martin',
-        age: 42
-      )
-  end
-
-  it { expect { city.population }.to raise_error(NoMethodError) }
-
-  context 'highlight' do
-    subject(:city) do
-      city_type.new(name: 'Martin', age: 42)
-        .tap do |city|
-          city._data = {
-            'highlight' => { 'name' => ['<b>Mar</b>tin'] }
-          }
-        end
-    end
-
-    it do
-      is_expected.to respond_to(:name_highlight)
-        .and have_attributes(
-          name: 'Martin',
-          name_highlight: '<b>Mar</b>tin'
-        )
-    end
-  end
-
-  describe '#==' do
-    specify { expect(city_type.new(id: 42)).to eq(city_type.new(id: 42)) }
-    specify { expect(city_type.new(id: 42, age: 55)).to eq(city_type.new(id: 42, age: 54)) }
-    specify { expect(city_type.new(id: 42)).not_to eq(city_type.new(id: 43)) }
-    specify { expect(city_type.new(id: 42, age: 55)).not_to eq(city_type.new(id: 43, age: 55)) }
-    specify { expect(city_type.new(age: 55)).to eq(city_type.new(age: 55)) }
-    specify { expect(city_type.new(age: 55)).not_to eq(city_type.new(age: 54)) }
-
-    specify { expect(city_type.new(id: '42')).to eq(City.new.tap { |m| allow(m).to receive_messages(id: 42) }) }
-    specify { expect(city_type.new(id: 42)).not_to eq(City.new.tap { |m| allow(m).to receive_messages(id: 43) }) }
-
-    specify { expect(city_type.new(id: 42)).not_to eq(Class.new) }
-  end
-end

data/spec/chewy/type_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Type do
-  describe '.scopes' do
-    before do
-      stub_index(:places) do
-        def self.by_id
-        end
-
-        define_type :city do
-          def self.by_rating
-          end
-
-          def self.by_name
-          end
-        end
-      end
-    end
-
-    specify { expect(described_class.scopes).to eq([]) }
-    specify { expect(PlacesIndex::City.scopes).to match_array([:by_rating, :by_name]) }
-    specify { expect { PlacesIndex::City.non_existing_method_call }.to raise_error(NoMethodError) }
-
-    specify { expect(PlacesIndex::City._default_import_options).to eq({}) }
-    specify { expect { PlacesIndex::City.default_import_options(invalid_option: "Yeah!") }.to raise_error(ArgumentError) }
-
-    context 'default_import_options is set' do
-      before { PlacesIndex::City.default_import_options(batch_size: 500) }
-
-      specify { expect(PlacesIndex::City._default_import_options).to eq(batch_size: 500) }
-    end
-  end
-end

data/spec/support/mongoid.rb

@@ -1,81 +0,0 @@
-require 'database_cleaner'
-
-CONFIG = {
-  sessions: {
-    default: {
-      uri: 'mongodb://127.0.0.1:27017/chewy_mongoid_test'
-    }
-  },
-  clients: {
-    default: {
-      uri: 'mongodb://127.0.0.1:27017/chewy_mongoid_test'
-    }
-  }
-}
-
-Mongoid.configure do |config|
-  config.load_configuration(CONFIG)
-end
-
-Mongoid.logger = Logger.new('/dev/null')
-
-module MongoidClassHelpers
-  extend ActiveSupport::Concern
-
-  module Country
-    extend ActiveSupport::Concern
-
-    included do
-      include Mongoid::Document
-
-      field :name, type: String
-      field :country_code, type: String
-      field :rating, type: Integer
-    end
-  end
-
-  module City
-    extend ActiveSupport::Concern
-
-    included do
-      include Mongoid::Document
-
-      field :name, type: String
-      field :rating, type: Integer
-    end
-  end
-
-  def adapter
-    :mongoid
-  end
-
-  def stub_model name, superclass = nil, &block
-    mixin = "MongoidClassHelpers::#{name.to_s.camelize}".safe_constantize || Mongoid::Document
-    superclass ||= Class.new do
-      include mixin
-      store_in collection: name.to_s.tableize
-    end
-
-    stub_class(name, superclass, &block)
-  end
-end
-
-RSpec.configure do |config|
-  config.include MongoidClassHelpers
-
-  config.filter_run_excluding :active_record
-  config.filter_run_excluding :sequel
-
-  config.before(:suite) do
-    DatabaseCleaner.clean_with :truncation
-    DatabaseCleaner.strategy = :truncation
-  end
-
-  config.before do
-    DatabaseCleaner.start
-  end
-
-  config.after do
-    DatabaseCleaner.clean
-  end
-end

data/spec/support/sequel.rb

@@ -1,75 +0,0 @@
-require 'database_cleaner'
-
-DB = Sequel.sqlite# logger: Logger.new(STDOUT)
-
-DB.create_table :countries do
-  primary_key :id
-  column :name, :string
-  column :country_code, :string
-  column :rating, :integer
-end
-
-DB.create_table :cities do
-  primary_key :id
-  column :country_id, :integer
-  column :name, :string
-  column :rating, :integer
-end
-
-DB.create_table :rating_cities do
-  primary_key :rating
-  column :country_id, :integer
-  column :name, :string
-end
-
-Sequel::Model.plugin :chewy_observe
-
-module SequelClassHelpers
-  extend ActiveSupport::Concern
-
-  class AdaptedSequelModel < Sequel::Model
-    # Allow to set primary key using mass assignment.
-    unrestrict_primary_key
-
-    # Aliases for compatibility with specs that were written with ActiveRecord in mind...
-    alias_method :save!, :save
-    alias_method :update_attributes, :update
-    alias_method :update_attributes!, :update
-
-    class << self
-      alias_method :create!, :create
-    end
-  end
-
-  def adapter
-    :sequel
-  end
-
-  def stub_model(name, &block)
-    stub_class(name, AdaptedSequelModel, &block).tap do |klass|
-      # Sequel doesn't work well with dynamically created classes,
-      # so we must set the dataset (table) name manually.
-      klass.dataset = name.to_s.pluralize.to_sym
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include SequelClassHelpers
-
-  config.filter_run_excluding :active_record
-  config.filter_run_excluding :mongoid
-
-  config.before(:suite) do
-    DatabaseCleaner.clean_with :truncation
-    DatabaseCleaner.strategy = :truncation
-  end
-
-  config.before do
-    DatabaseCleaner.start
-  end
-
-  config.after do
-    DatabaseCleaner.clean
-  end
-end