mongoid 8.0.4 → 8.0.6

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 9ab3c68fb6c373b704eb2d459a98d7a4cb99d73b87e720eabb553fcd44928d17
4
- data.tar.gz: d0cd7fe683015dd257c48a7d0c301dd9c6972ea51be4b8199ae88b81dc45c8d6
3
+ metadata.gz: 51995917ca452899edfb1e432aecad879c476f89057c5377e55081a5c2a989ac
4
+ data.tar.gz: b01e8f7141b1f37d0ddfc51b5e4fa889f09b85988069af8cc8af7214a00a888c
5
5
  SHA512:
6
- metadata.gz: 247213c01b169b66f1441ccf892590c068b116e4a4998e15cb50c0cdf3b11648bc543a0c935165a7674a88e783734df36dfeed481079d759fcbf473c068686de
7
- data.tar.gz: fdf737044c01f8089e8bae7dbc14cce78e48e998ea810cd8e9a334f1bdc8c2b8e1ba6c885c8032c3b5da8b70d24b35b99dd90c260c87abea31a93edef15429cc
6
+ metadata.gz: 7a011a2367c77d3e7abdc57a3781f45c97c71451afcaae7a3358a3e0173e8d3bc4ef09ef92d32f8d72c14ca89b5d8f3d9fccdf8b0a7b84ccb9a874329413b561
7
+ data.tar.gz: a868fc0217fc98cccfa8b6c3f9c0dccb4425354ddb4f23a1819f52dc539e2754e8dd8a508a804e05bddeeb8be73fe09ff6f027d141a22d3f479c3adc63097fcb
checksums.yaml.gz.sig CHANGED
Binary file
data/Rakefile CHANGED
@@ -11,6 +11,15 @@ $: << File.join(ROOT, 'spec/shared/lib')
11
11
  require "rake"
12
12
  require "rspec/core/rake_task"
13
13
  require 'mrss/spec_organizer'
14
+ require 'rubygems/package'
15
+ require 'rubygems/security/policies'
16
+
17
+ def signed_gem?(path_to_gem)
18
+ Gem::Package.new(path_to_gem, Gem::Security::HighSecurity).verify
19
+ true
20
+ rescue Gem::Security::Exception => e
21
+ false
22
+ end
14
23
 
15
24
  $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
16
25
  require "mongoid/version"
@@ -103,3 +112,19 @@ namespace :release do
103
112
  end
104
113
  end
105
114
  end
115
+
116
+ desc 'Verifies that all built gems in pkg/ are valid'
117
+ task :verify do
118
+ gems = Dir['pkg/*.gem']
119
+ if gems.empty?
120
+ puts 'There are no gems in pkg/ to verify'
121
+ else
122
+ gems.each do |gem|
123
+ if signed_gem?(gem)
124
+ puts "#{gem} is signed"
125
+ else
126
+ abort "#{gem} is not signed"
127
+ end
128
+ end
129
+ end
130
+ end
@@ -35,10 +35,15 @@ module Mongoid
35
35
  # @api private
36
36
  class_attribute :aliased_associations
37
37
 
38
+ # @return [ Set<String> ] The set of associations that are configured
39
+ # with :store_as parameter.
40
+ class_attribute :stored_as_associations
41
+
38
42
  self.embedded = false
39
43
  self.embedded_relations = BSON::Document.new
40
44
  self.relations = BSON::Document.new
41
45
  self.aliased_associations = {}
46
+ self.stored_as_associations = Set.new
42
47
  end
43
48
 
44
49
  # This is convenience for libraries still on the old API.
@@ -219,6 +224,7 @@ module Mongoid
219
224
  self.relations = self.relations.merge(name => assoc)
220
225
  if assoc.embedded? && assoc.respond_to?(:store_as) && assoc.store_as != name
221
226
  self.aliased_associations[assoc.store_as] = name
227
+ self.stored_as_associations << assoc.store_as
222
228
  end
223
229
  end
224
230
  end
@@ -311,6 +311,13 @@ module Mongoid
311
311
 
312
312
  private
313
313
 
314
+ # Clears all pending atomic updates.
315
+ def reset_atomic_updates!
316
+ Atomic::UPDATES.each do |update|
317
+ send(update).clear
318
+ end
319
+ end
320
+
314
321
  # Generates the atomic updates in the correct order.
315
322
  #
316
323
  # @example Generate the updates.
@@ -43,22 +43,46 @@ module Mongoid
43
43
  # @return [ true | false ] True if pending, false if not.
44
44
  def pending_attribute?(key, value)
45
45
  name = key.to_s
46
-
47
46
  aliased = if aliased_associations.key?(name)
48
47
  aliased_associations[name]
49
48
  else
50
49
  name
51
50
  end
52
-
53
51
  if relations.has_key?(aliased)
54
- pending_relations[name] = value
52
+ set_pending_relation(name, aliased, value)
55
53
  return true
56
54
  end
57
55
  if nested_attributes.has_key?(aliased)
58
- pending_nested[name] = value
56
+ set_pending_nested(name, aliased, value)
59
57
  return true
60
58
  end
61
- return false
59
+ false
60
+ end
61
+
62
+ # Set value of the pending relation.
63
+ #
64
+ # @param [ Symbol ] name The name of the relation.
65
+ # @param [ Symbol ] aliased The aliased name of the relation.
66
+ # @param [ Object ] value The value of the relation.
67
+ def set_pending_relation(name, aliased, value)
68
+ if stored_as_associations.include?(name)
69
+ pending_relations[aliased] = value
70
+ else
71
+ pending_relations[name] = value
72
+ end
73
+ end
74
+
75
+ # Set value of the pending nested attribute.
76
+ #
77
+ # @param [ Symbol ] name The name of the nested attribute.
78
+ # @param [ Symbol ] aliased The aliased name of the nested attribute.
79
+ # @param [ Object ] value The value of the nested attribute.
80
+ def set_pending_nested(name, aliased, value)
81
+ if stored_as_associations.include?(name)
82
+ pending_nested[aliased] = value
83
+ else
84
+ pending_nested[name] = value
85
+ end
62
86
  end
63
87
 
64
88
  # Get all the pending associations that need to be set.
@@ -70,9 +70,7 @@ module Mongoid
70
70
  def move_changes
71
71
  @previous_changes = changes
72
72
  @previous_attributes = attributes.dup
73
- Atomic::UPDATES.each do |update|
74
- send(update).clear
75
- end
73
+ reset_atomic_updates!
76
74
  changed_attributes.clear
77
75
  end
78
76
 
@@ -25,6 +25,8 @@ module Mongoid
25
25
  # @param [ Hash ] options Extras for the option.
26
26
  #
27
27
  # @option options [ Object ] :default The default value.
28
+ # @option options [ Proc | nil ] :on_change The callback to invoke when the
29
+ # setter is invoked.
28
30
  def option(name, options = {})
29
31
  defaults[name] = settings[name] = options[:default]
30
32
 
@@ -38,6 +40,7 @@ module Mongoid
38
40
 
39
41
  define_method("#{name}=") do |value|
40
42
  settings[name] = value
43
+ options[:on_change]&.call(value)
41
44
  end
42
45
 
43
46
  define_method("#{name}?") do
@@ -125,6 +125,23 @@ module Mongoid
125
125
  # always return a Hash.
126
126
  option :legacy_attributes, default: false
127
127
 
128
+ # Allow BSON::Decimal128 to be parsed and returned directly in
129
+ # field values. When BSON 5 is present and the this option is set to false
130
+ # (the default), BSON::Decimal128 values in the database will be returned
131
+ # as BigDecimal.
132
+ #
133
+ # @note this option only has effect when BSON 5+ is present. Otherwise,
134
+ # the setting is ignored.
135
+ option :allow_bson5_decimal128, default: false, on_change: -> (allow) do
136
+ if BSON::VERSION >= '5.0.0'
137
+ if allow
138
+ BSON::Registry.register(BSON::Decimal128::BSON_TYPE, BSON::Decimal128)
139
+ else
140
+ BSON::Registry.register(BSON::Decimal128::BSON_TYPE, BigDecimal)
141
+ end
142
+ end
143
+ end
144
+
128
145
  # Has Mongoid been configured? This is checking that at least a valid
129
146
  # client config exists.
130
147
  #
@@ -20,7 +20,7 @@ module Mongoid
20
20
  other.each_pair do |key, value|
21
21
  if value.is_a?(Hash) && self[key.to_s].is_a?(Hash)
22
22
  value = self[key.to_s].merge(value) do |_key, old_val, new_val|
23
- case _key
23
+ case _key.to_s
24
24
  when '$in'
25
25
  new_val & old_val
26
26
  when '$nin'
@@ -47,7 +47,7 @@ module Mongoid
47
47
  if value.is_a?(Hash) && selector[field].is_a?(Hash) &&
48
48
  value.keys.all? { |key|
49
49
  key_s = key.to_s
50
- key_s.start_with?('$') && !selector[field].key?(key_s)
50
+ key_s.start_with?('$') && !selector[field].keys.map(&:to_s).include?(key_s)
51
51
  }
52
52
  then
53
53
  # Multiple operators can be combined on the same field by
@@ -38,8 +38,12 @@ module Mongoid
38
38
  consolidated = {}
39
39
  each_pair do |key, value|
40
40
  if key =~ /\$/
41
- value.each_pair do |_key, _value|
42
- value[_key] = (key == "$rename") ? _value.to_s : mongoize_for(key, klass, _key, _value)
41
+ value.keys.each do |key2|
42
+ value2 = value[key2]
43
+ real_key = klass.database_field_name(key2)
44
+
45
+ value.delete(key2) if real_key != key2
46
+ value[real_key] = (key == "$rename") ? value2.to_s : mongoize_for(key, klass, real_key, value2)
43
47
  end
44
48
  consolidated[key] ||= {}
45
49
  consolidated[key].update(value)
@@ -764,33 +764,60 @@ module Mongoid
764
764
 
765
765
  def field_for(name, options)
766
766
  opts = options.merge(klass: self)
767
- type_mapping = TYPE_MAPPINGS[options[:type]]
768
- opts[:type] = type_mapping || unmapped_type(options)
769
- if !opts[:type].is_a?(Class)
770
- raise Errors::InvalidFieldType.new(self, name, options[:type])
771
- else
772
- if INVALID_BSON_CLASSES.include?(opts[:type])
773
- warn_message = "Using #{opts[:type]} as the field type is not supported. "
774
- if opts[:type] == BSON::Decimal128
775
- warn_message += "In BSON <= 4, the BSON::Decimal128 type will work as expected for both storing and querying, but will return a BigDecimal on query in BSON 5+."
776
- else
777
- warn_message += "Saving values of this type to the database will work as expected, however, querying them will return a value of the native Ruby Integer type."
778
- end
779
- Mongoid.logger.warn(warn_message)
780
- end
781
- end
767
+ opts[:type] = retrieve_and_validate_type(name, options[:type])
782
768
  return Fields::Localized.new(name, opts) if options[:localize]
783
769
  return Fields::ForeignKey.new(name, opts) if options[:identity]
784
770
  Fields::Standard.new(name, opts)
785
771
  end
786
772
 
787
- def unmapped_type(options)
788
- if "Boolean" == options[:type].to_s
773
+ # Get the class for the given type.
774
+ #
775
+ # @param [ Symbol ] name The name of the field.
776
+ # @param [ Symbol | Class ] type The type of the field.
777
+ #
778
+ # @return [ Class ] The type of the field.
779
+ #
780
+ # @raises [ Mongoid::Errors::InvalidFieldType ] if given an invalid field
781
+ # type.
782
+ #
783
+ # @api private
784
+ def retrieve_and_validate_type(name, type)
785
+ result = TYPE_MAPPINGS[type] || unmapped_type(type)
786
+ raise Errors::InvalidFieldType.new(self, name, type) if !result.is_a?(Class)
787
+
788
+ if unsupported_type?(result)
789
+ warn_message = "Using #{result} as the field type is not supported. "
790
+ if result == BSON::Decimal128
791
+ warn_message += 'In BSON <= 4, the BSON::Decimal128 type will work as expected for both storing and querying, but will return a BigDecimal on query in BSON 5+. To use literal BSON::Decimal128 fields with BSON 5, set Mongoid.allow_bson5_decimal128 to true.'
792
+ else
793
+ warn_message += 'Saving values of this type to the database will work as expected, however, querying them will return a value of the native Ruby Integer type.'
794
+ end
795
+ Mongoid.logger.warn(warn_message)
796
+ end
797
+
798
+ result
799
+ end
800
+
801
+ def unmapped_type(type)
802
+ if "Boolean" == type.to_s
789
803
  Mongoid::Boolean
790
804
  else
791
- options[:type] || Object
805
+ type || Object
792
806
  end
793
807
  end
808
+
809
+ # Queries whether or not the given type is permitted as a declared field
810
+ # type.
811
+ #
812
+ # @param [ Class ] type The type to query
813
+ #
814
+ # @return [ true | false ] whether or not the type is supported
815
+ #
816
+ # @api private
817
+ def unsupported_type?(type)
818
+ return !Mongoid::Config.allow_bson5_decimal128? if type == BSON::Decimal128
819
+ INVALID_BSON_CLASSES.include?(type)
820
+ end
794
821
  end
795
822
  end
796
823
  end
@@ -16,16 +16,14 @@ module Mongoid
16
16
  #
17
17
  # @return [ Document ] The document, reloaded.
18
18
  def reload
19
- if @atomic_selector
20
- # Clear atomic_selector cache for sharded clusters. MONGOID-5076
21
- remove_instance_variable('@atomic_selector')
22
- end
23
-
24
19
  reloaded = _reload
25
20
  if Mongoid.raise_not_found_error && (reloaded.nil? || reloaded.empty?)
26
21
  shard_keys = atomic_selector.with_indifferent_access.slice(*shard_key_fields, :_id)
27
22
  raise Errors::DocumentNotFound.new(self.class, _id, shard_keys)
28
23
  end
24
+
25
+ reset_atomic_updates!
26
+
29
27
  @attributes = reloaded
30
28
  @attributes_before_type_cast = @attributes.dup
31
29
  @changed_attributes = {}
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module Mongoid
4
- VERSION = "8.0.4"
4
+ VERSION = "8.0.6"
5
5
  end
@@ -2711,4 +2711,31 @@ describe Mongoid::Attributes do
2711
2711
  catalog.set_field.should == Set.new([ 1, 2 ])
2712
2712
  end
2713
2713
  end
2714
+
2715
+ context 'when an embedded field has a capitalized store_as name' do
2716
+ let(:person) { Person.new(Purse: { brand: 'Gucci' }) }
2717
+
2718
+ it 'sets the value' do
2719
+ expect(person.purse.brand).to eq('Gucci')
2720
+ end
2721
+
2722
+ it 'saves successfully' do
2723
+ expect(person.save!).to eq(true)
2724
+ end
2725
+
2726
+ context 'when persisted' do
2727
+ before do
2728
+ person.save!
2729
+ person.reload
2730
+ end
2731
+
2732
+ it 'persists the value' do
2733
+ expect(person.reload.purse.brand).to eq('Gucci')
2734
+ end
2735
+
2736
+ it 'uses the correct key in the database' do
2737
+ expect(person.collection.find(_id: person.id).first['Purse']['_id']).to eq(person.purse.id)
2738
+ end
2739
+ end
2740
+ end
2714
2741
  end
@@ -272,6 +272,15 @@ describe Mongoid::Config do
272
272
  it_behaves_like "a config option"
273
273
  end
274
274
 
275
+ context 'when setting the allow_bson5_decimal128 option in the config' do
276
+ min_bson_version '5.0'
277
+
278
+ let(:option) { :allow_bson5_decimal128 }
279
+ let(:default) { false }
280
+
281
+ it_behaves_like "a config option"
282
+ end
283
+
275
284
  context 'when setting the broken_updates option in the config' do
276
285
  let(:option) { :broken_updates }
277
286
  let(:default) { false }
@@ -1179,33 +1179,49 @@ describe Mongoid::Contextual::Mongo do
1179
1179
  let!(:person2) { Person.create!(ssn: BSON::Decimal128.new("1")) }
1180
1180
  let(:tally) { Person.tally("ssn") }
1181
1181
 
1182
+ let(:tallied_classes) do
1183
+ tally.keys.map(&:class).sort do |a, b|
1184
+ a.to_s.casecmp(b.to_s)
1185
+ end
1186
+ end
1187
+
1182
1188
  context "< BSON 5" do
1183
1189
  max_bson_version '4.99.99'
1184
1190
 
1185
1191
  it "stores the correct types in the database" do
1186
- Person.find(person1.id).attributes["ssn"].should be_a BSON::Regexp::Raw
1187
- Person.find(person2.id).attributes["ssn"].should be_a BSON::Decimal128
1192
+ expect(Person.find(person1.id).attributes["ssn"]).to be_a BSON::Regexp::Raw
1193
+ expect(Person.find(person2.id).attributes["ssn"]).to be_a BSON::Decimal128
1194
+ end
1195
+
1196
+ it "tallies the correct type" do
1197
+ expect(tallied_classes).to be == [ BSON::Decimal128, BSON::Regexp::Raw ]
1198
+ end
1199
+ end
1200
+
1201
+ context '>= BSON 5' do
1202
+ min_bson_version "5.0"
1203
+
1204
+ it "stores the correct types in the database" do
1205
+ expect(Person.find(person1.id).ssn).to be_a BSON::Regexp::Raw
1206
+ expect(Person.find(person2.id).ssn).to be_a BigDecimal
1188
1207
  end
1189
1208
 
1190
1209
  it "tallies the correct type" do
1191
- tally.keys.map(&:class).sort do |a,b|
1192
- a.to_s <=> b.to_s
1193
- end.should == [BSON::Decimal128, BSON::Regexp::Raw]
1210
+ expect(tallied_classes).to be == [ BigDecimal, BSON::Regexp::Raw ]
1194
1211
  end
1195
1212
  end
1196
1213
 
1197
- context ">= BSON 5" do
1214
+ context '>= BSON 5 with decimal128 allowed' do
1198
1215
  min_bson_version "5.0"
1216
+ config_override :allow_bson5_decimal128, true
1199
1217
 
1200
1218
  it "stores the correct types in the database" do
1201
- Person.find(person1.id).ssn.should be_a BSON::Regexp::Raw
1202
- Person.find(person2.id).ssn.should be_a BigDeimal
1219
+ expect(Person.find(person1.id).ssn).to be_a BSON::Regexp::Raw
1220
+ expect(Person.find(person2.id).ssn).to be_a BSON::Decimal128
1203
1221
  end
1204
1222
 
1205
1223
  it "tallies the correct type" do
1206
- tally.keys.map(&:class).sort do |a,b|
1207
- a.to_s <=> b.to_s
1208
- end.should == [BigDecimal, BSON::Regexp::Raw]
1224
+ expect(tallied_classes).to be == [ BSON::Decimal128, BSON::Regexp::Raw ]
1209
1225
  end
1210
1226
  end
1211
1227
  end
@@ -3560,6 +3576,20 @@ describe Mongoid::Contextual::Mongo do
3560
3576
  end
3561
3577
  end
3562
3578
 
3579
+ context 'when using aliased field names' do
3580
+ before do
3581
+ context.update_all('$set' => { years: 100 })
3582
+ end
3583
+
3584
+ it "updates the first matching document" do
3585
+ expect(depeche_mode.reload.years).to eq(100)
3586
+ end
3587
+
3588
+ it "updates the last matching document" do
3589
+ expect(new_order.reload.years).to eq(100)
3590
+ end
3591
+ end
3592
+
3563
3593
  context "when the attributes must be mongoized" do
3564
3594
 
3565
3595
  before do
@@ -44,7 +44,7 @@ describe Mongoid::Criteria::Queryable::Selector do
44
44
  end
45
45
  end
46
46
 
47
- context "when selector contains a $nin" do
47
+ context "when selector contains a $nin string" do
48
48
 
49
49
  let(:initial) do
50
50
  { "$nin" => ["foo"] }
@@ -72,7 +72,35 @@ describe Mongoid::Criteria::Queryable::Selector do
72
72
  end
73
73
  end
74
74
 
75
- context "when selector contains a $in" do
75
+ context "when selector contains a $nin symbol" do
76
+
77
+ let(:initial) do
78
+ { :$nin => ["foo"] }
79
+ end
80
+
81
+ before do
82
+ selector["field"] = initial
83
+ end
84
+
85
+ context "when merging in a new $nin" do
86
+
87
+ let(:other) do
88
+ { "field" => { :$nin => ["bar"] } }
89
+ end
90
+
91
+ before do
92
+ selector.merge!(other)
93
+ end
94
+
95
+ it "combines the two $nin queries into one" do
96
+ expect(selector).to eq({
97
+ "field" => { :$nin => ["foo", "bar"] }
98
+ })
99
+ end
100
+ end
101
+ end
102
+
103
+ context "when selector contains a $in string" do
76
104
 
77
105
  let(:initial) do
78
106
  { "$in" => [1, 2] }
@@ -117,6 +145,51 @@ describe Mongoid::Criteria::Queryable::Selector do
117
145
  end
118
146
  end
119
147
 
148
+ context "when selector contains a $in symbol" do
149
+
150
+ let(:initial) do
151
+ { :$in => [1, 2] }
152
+ end
153
+
154
+ before do
155
+ selector["field"] = initial
156
+ end
157
+
158
+ context "when merging in a new $in with an intersecting value" do
159
+
160
+ let(:other) do
161
+ { "field" => { :$in => [1] } }
162
+ end
163
+
164
+ before do
165
+ selector.merge!(other)
166
+ end
167
+
168
+ it "intersects the $in values" do
169
+ expect(selector).to eq({
170
+ "field" => { :$in => [1] }
171
+ })
172
+ end
173
+ end
174
+
175
+ context "when merging in a new $in with no intersecting values" do
176
+
177
+ let(:other) do
178
+ { "field" => { :$in => [3] } }
179
+ end
180
+
181
+ before do
182
+ selector.merge!(other)
183
+ end
184
+
185
+ it "intersects the $in values" do
186
+ expect(selector).to eq({
187
+ "field" => { :$in => [] }
188
+ })
189
+ end
190
+ end
191
+ end
192
+
120
193
  context "when selector is not nested" do
121
194
 
122
195
  before do
@@ -210,7 +210,79 @@ describe Mongoid::Criteria::Queryable::Storable do
210
210
  }
211
211
  end
212
212
  end
213
+
214
+ context 'when value is a hash combine values with different operator keys' do
215
+ let(:base) do
216
+ query.add_field_expression('foo', {'$in' => ['bar']})
217
+ end
218
+
219
+ let(:modified) do
220
+ base.add_field_expression('foo', {'$nin' => ['zoom']})
221
+ end
222
+
223
+ it 'combines the conditions using $and' do
224
+ modified.selector.should == {
225
+ 'foo' => {
226
+ '$in' => ['bar'],
227
+ '$nin' => ['zoom']
228
+ }
229
+ }
230
+ end
231
+ end
232
+
233
+ context 'when value is a hash with symbol operator key combine values with different operator keys' do
234
+ let(:base) do
235
+ query.add_field_expression('foo', {:$in => ['bar']})
236
+ end
237
+
238
+ let(:modified) do
239
+ base.add_field_expression('foo', {:$nin => ['zoom']})
240
+ end
241
+
242
+ it 'combines the conditions using $and' do
243
+ modified.selector.should == {
244
+ 'foo' => {
245
+ :$in => ['bar'],
246
+ :$nin => ['zoom']
247
+ }
248
+ }
249
+ end
250
+ end
251
+
252
+ context 'when value is a hash add values with same operator keys using $and' do
253
+ let(:base) do
254
+ query.add_field_expression('foo', {'$in' => ['bar']})
255
+ end
256
+
257
+ let(:modified) do
258
+ base.add_field_expression('foo', {'$in' => ['zoom']})
259
+ end
260
+
261
+ it 'adds the new condition using $and' do
262
+ modified.selector.should == {
263
+ 'foo' => {'$in' => ['bar']},
264
+ '$and' => ['foo' => {'$in' => ['zoom']}]
265
+ }
266
+ end
267
+ end
268
+
269
+ context 'when value is a hash with symbol operator key add values with same operator keys using $and' do
270
+ let(:base) do
271
+ query.add_field_expression('foo', {:$in => ['bar']})
272
+ end
273
+
274
+ let(:modified) do
275
+ base.add_field_expression('foo', {:$in => ['zoom']})
276
+ end
277
+
278
+ it 'adds the new condition using $and' do
279
+ modified.selector.should == {
280
+ 'foo' => {:$in => ['bar']},
281
+ '$and' => ['foo' => {:$in => ['zoom']}]
282
+ }
283
+ end
213
284
  end
285
+ end
214
286
 
215
287
  describe '#add_operator_expression' do
216
288
  let(:query_method) { :add_operator_expression }
@@ -178,7 +178,7 @@ describe Mongoid::Extensions::Hash do
178
178
 
179
179
  it "moves the non hash values under the provided key" do
180
180
  expect(consolidated).to eq({
181
- "$set" => { name: "Tool", likes: 10 }, "$inc" => { plays: 1 }
181
+ "$set" => { 'name' => "Tool", likes: 10 }, "$inc" => { 'plays' => 1 }
182
182
  })
183
183
  end
184
184
  end
@@ -195,7 +195,7 @@ describe Mongoid::Extensions::Hash do
195
195
 
196
196
  it "moves the non hash values under the provided key" do
197
197
  expect(consolidated).to eq({
198
- "$set" => { likes: 10, name: "Tool" }, "$inc" => { plays: 1 }
198
+ "$set" => { likes: 10, 'name' => "Tool" }, "$inc" => { 'plays' => 1 }
199
199
  })
200
200
  end
201
201
  end
@@ -213,7 +213,7 @@ describe Mongoid::Extensions::Hash do
213
213
 
214
214
  it "moves the non hash values under the provided key" do
215
215
  expect(consolidated).to eq({
216
- "$set" => { likes: 10, name: "Tool" }, "$inc" => { plays: 1 }
216
+ "$set" => { likes: 10, name: "Tool" }, "$inc" => { 'plays' => 1 }
217
217
  })
218
218
  end
219
219
  end