ree_lib 1.0.87 → 1.0.89

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/date_time_spec.rb

@@ -27,24 +27,24 @@ RSpec.describe 'ReeMapper::DateTime' do
     }
 
     it {
-      expect { mapper.serialize({ date_time: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `#{Time.new(2020).inspect}`")
+      expect { mapper.serialize({ date_time: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `#{Regexp.quote(Time.new(2020).inspect)}`/)
     }
 
     it {
-      expect { mapper.serialize({ date_time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `#{Date.new(2020).inspect}`")
+      expect { mapper.serialize({ date_time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `#{Regexp.quote(Date.new(2020).inspect)}`/)
     }
 
     it {
-      expect { mapper.serialize({ date_time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `\"#{DateTime.new(2020).to_s}\"`")
+      expect { mapper.serialize({ date_time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `\"#{Regexp.quote(DateTime.new(2020).to_s)}\"`/)
     }
 
     it {
-      expect { mapper.serialize({ date_time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `\"2020-01-01\"`")
+      expect { mapper.serialize({ date_time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `\"2020-01-01\"`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.serialize({ date_time: object }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `#{object.inspect}`")
+      expect { mapper.serialize({ date_time: object }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `#{object.inspect}`/)
     }
   end
 
@@ -66,16 +66,16 @@ RSpec.describe 'ReeMapper::DateTime' do
     }
 
     it {
-      expect { mapper.cast({ 'date_time' => Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `#{Date.new(2020).inspect}`")
+      expect { mapper.cast({ 'date_time' => Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `#{Regexp.quote(Date.new(2020).inspect)}`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.cast({ 'date_time' => object }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `#{object.inspect}`")
+      expect { mapper.cast({ 'date_time' => object }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `#{object.inspect}`/)
     }
 
     it {
-      expect { mapper.cast({ 'date_time' => 'no date time' }) }.to raise_error(ReeMapper::CoercionError, "`date_time` is invalid datetime, got `\"no date time\"`")
+      expect { mapper.cast({ 'date_time' => 'no date time' }) }.to raise_error(ReeMapper::CoercionError, /`date_time` is invalid datetime, got `\"no date time\"`/)
     }
   end
 
@@ -85,24 +85,24 @@ RSpec.describe 'ReeMapper::DateTime' do
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date_time: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `#{Time.new(2020).inspect}`")
+      expect { mapper.db_dump OpenStruct.new({ date_time: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `#{Regexp.quote(Time.new(2020).inspect)}`/)
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date_time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `#{Date.new(2020).inspect}`")
+      expect { mapper.db_dump OpenStruct.new({ date_time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `#{Regexp.quote(Date.new(2020).inspect)}`/)
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date_time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `\"#{DateTime.new(2020).to_s}\"`")
+      expect { mapper.db_dump OpenStruct.new({ date_time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `\"#{Regexp.quote(DateTime.new(2020).to_s)}\"`/)
     }
 
     it {
-      expect { mapper.db_dump OpenStruct.new({ date_time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `\"2020-01-01\"`")
+      expect { mapper.db_dump OpenStruct.new({ date_time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `\"2020-01-01\"`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.db_dump OpenStruct.new({ date_time: object }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `#{object.inspect}`")
+      expect { mapper.db_dump OpenStruct.new({ date_time: object }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `#{object.inspect}`/)
     }
   end
 
@@ -124,16 +124,16 @@ RSpec.describe 'ReeMapper::DateTime' do
     }
 
     it {
-      expect { mapper.db_load({ 'date_time' => Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `#{Date.new(2020).inspect}`")
+      expect { mapper.db_load({ 'date_time' => Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `#{Regexp.quote(Date.new(2020).inspect)}`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.db_load({ 'date_time' => object }) }.to raise_error(ReeMapper::TypeError, "`date_time` should be a datetime, got `#{object.inspect}`")
+      expect { mapper.db_load({ 'date_time' => object }) }.to raise_error(ReeMapper::TypeError, /`date_time` should be a datetime, got `#{object.inspect}`/)
     }
 
     it {
-      expect { mapper.db_load({ 'date_time' => 'no date time' }) }.to raise_error(ReeMapper::CoercionError, "`date_time` is invalid datetime, got `\"no date time\"`")
+      expect { mapper.db_load({ 'date_time' => 'no date time' }) }.to raise_error(ReeMapper::CoercionError, /`date_time` is invalid datetime, got `\"no date time\"`/)
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/float_spec.rb

@@ -40,16 +40,16 @@ RSpec.describe 'ReeMapper::Float' do
     }
 
     it {
-      expect { mapper.cast({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float, got `"a1.1"`')
+      expect { mapper.cast({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, /`float` is invalid float, got `"a1.1"`/)
     }
 
     it {
-      expect { mapper.cast({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float, got `"1.1a"`')
+      expect { mapper.cast({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError, /`float` is invalid float, got `"1.1a"`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.cast({ float: object }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float, got `#{object.inspect}`")
+      expect { mapper.cast({ float: object }) }.to raise_error(ReeMapper::TypeError, /`float` should be a float, got `#{object.inspect}`/)
     }
   end
 
@@ -59,16 +59,16 @@ RSpec.describe 'ReeMapper::Float' do
     }
 
     it {
-      expect { mapper.serialize({ float: '1.1' }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float, got `\"1.1\"`")
+      expect { mapper.serialize({ float: '1.1' }) }.to raise_error(ReeMapper::TypeError, /`float` should be a float, got `\"1.1\"`/)
     }
 
     it {
-      expect { mapper.serialize({ float: nil }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float, got `nil`")
+      expect { mapper.serialize({ float: nil }) }.to raise_error(ReeMapper::TypeError, /`float` should be a float, got `nil`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.serialize({ float: object }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float, got `#{object.inspect}`")
+      expect { mapper.serialize({ float: object }) }.to raise_error(ReeMapper::TypeError, /`float` should be a float, got `#{object.inspect}`/)
     }
   end
 
@@ -78,16 +78,16 @@ RSpec.describe 'ReeMapper::Float' do
     }
 
     it {
-      expect { mapper.db_dump({ float: '1.1' }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float, got `\"1.1\"`")
+      expect { mapper.db_dump({ float: '1.1' }) }.to raise_error(ReeMapper::TypeError, /`float` should be a float, got `\"1.1\"`/)
     }
 
     it {
-      expect { mapper.db_dump({ float: nil }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float, got `nil`")
+      expect { mapper.db_dump({ float: nil }) }.to raise_error(ReeMapper::TypeError, /`float` should be a float, got `nil`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.db_dump({ float: object }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float, got `#{object.inspect}`")
+      expect { mapper.db_dump({ float: object }) }.to raise_error(ReeMapper::TypeError, /`float` should be a float, got `#{object.inspect}`/)
     }
   end
 
@@ -109,20 +109,20 @@ RSpec.describe 'ReeMapper::Float' do
     }
 
     it {
-      expect { mapper.db_load({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float, got `"a1.1"`')
+      expect { mapper.db_load({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError, /`float` is invalid float, got `"a1.1"`/)
     }
 
     it {
-      expect { mapper.db_load({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError, '`float` is invalid float, got `"1.1a"`')
+      expect { mapper.db_load({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError, /`float` is invalid float, got `"1.1a"`/)
     }
 
     it {
-      expect { mapper.db_load({ float: nil }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float, got `nil`")
+      expect { mapper.db_load({ float: nil }) }.to raise_error(ReeMapper::TypeError, /`float` should be a float, got `nil`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.db_load({ float: object }) }.to raise_error(ReeMapper::TypeError, "`float` should be a float, got `#{object.inspect}`")
+      expect { mapper.db_load({ float: object }) }.to raise_error(ReeMapper::TypeError, /`float` should be a float, got `#{object.inspect}`/)
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/hash_spec.rb

@@ -27,11 +27,11 @@ RSpec.describe 'Mapper Hash' do
     }
 
     it {
-      expect { mapper.cast({ point: 1 }) }.to raise_error(ReeMapper::TypeError, 'Missing required field `x` for `point`')
+      expect { mapper.cast({ point: 1 }) }.to raise_error(ReeMapper::TypeError, /Missing required field `x` for `point`/)
     }
 
     it {
-      expect { mapper.cast({ point: { x: 1, y: 'not integer' } }) }.to raise_error(ReeMapper::CoercionError, '`point[y]` is invalid integer, got `"not integer"`')
+      expect { mapper.cast({ point: { x: 1, y: 'not integer' } }) }.to raise_error(ReeMapper::CoercionError, /`point\[y\]` is invalid integer, got `"not integer"`/)
     }
   end
 

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/integer_spec.rb

@@ -31,15 +31,15 @@ RSpec.describe 'ReeMapper::Integer' do
     }
 
     it {
-      expect { mapper.cast({ number: 'b1' }) }.to raise_error(ReeMapper::CoercionError, '`number` is invalid integer, got `"b1"`')
+      expect { mapper.cast({ number: 'b1' }) }.to raise_error(ReeMapper::CoercionError, /`number` is invalid integer, got `"b1"`/)
     }
 
     it {
-      expect { mapper.cast({ number: '1b' }) }.to raise_error(ReeMapper::CoercionError, '`number` is invalid integer, got `"1b"`')
+      expect { mapper.cast({ number: '1b' }) }.to raise_error(ReeMapper::CoercionError, /`number` is invalid integer, got `"1b"`/)
     }
 
     it {
-      expect { mapper.cast({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `1.1`')
+      expect { mapper.cast({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `1.1`/)
     }
   end
 
@@ -49,19 +49,19 @@ RSpec.describe 'ReeMapper::Integer' do
     }
 
     it {
-      expect { mapper.serialize({ number: '1' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `"1"`')
+      expect { mapper.serialize({ number: '1' }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `"1"`/)
     }
 
     it {
-      expect { mapper.serialize({ number: 'b1' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `"b1"`')
+      expect { mapper.serialize({ number: 'b1' }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `"b1"`/)
     }
 
     it {
-      expect { mapper.serialize({ number: '1b' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `"1b"`')
+      expect { mapper.serialize({ number: '1b' }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `"1b"`/)
     }
 
     it {
-      expect { mapper.serialize({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `1.1`')
+      expect { mapper.serialize({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `1.1`/)
     }
   end
 
@@ -71,19 +71,19 @@ RSpec.describe 'ReeMapper::Integer' do
     }
 
     it {
-      expect { mapper.db_dump({ number: '1' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `"1"`')
+      expect { mapper.db_dump({ number: '1' }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `"1"`/)
     }
 
     it {
-      expect { mapper.db_dump({ number: 'b1' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `"b1"`')
+      expect { mapper.db_dump({ number: 'b1' }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `"b1"`/)
     }
 
     it {
-      expect { mapper.db_dump({ number: '1b' }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `"1b"`')
+      expect { mapper.db_dump({ number: '1b' }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `"1b"`/)
     }
 
     it {
-      expect { mapper.db_dump({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `1.1`')
+      expect { mapper.db_dump({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `1.1`/)
     }
   end
 
@@ -97,15 +97,15 @@ RSpec.describe 'ReeMapper::Integer' do
     }
 
     it {
-      expect { mapper.db_load({ number: 'b1' }) }.to raise_error(ReeMapper::CoercionError, '`number` is invalid integer, got `"b1"`')
+      expect { mapper.db_load({ number: 'b1' }) }.to raise_error(ReeMapper::CoercionError, /`number` is invalid integer, got `"b1"`/)
     }
 
     it {
-      expect { mapper.db_load({ number: '1b' }) }.to raise_error(ReeMapper::CoercionError, '`number` is invalid integer, got `"1b"`')
+      expect { mapper.db_load({ number: '1b' }) }.to raise_error(ReeMapper::CoercionError, /`number` is invalid integer, got `"1b"`/)
     }
 
     it {
-      expect { mapper.db_load({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `1.1`')
+      expect { mapper.db_load({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `1.1`/)
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/rational_spec.rb

@@ -40,16 +40,16 @@ RSpec.describe 'ReeMapper::Rational' do
     }
 
     it {
-      expect { mapper.cast({ rational: 'a333' }) }.to raise_error(ReeMapper::CoercionError, '`rational` is invalid rational, got `"a333"`')
+      expect { mapper.cast({ rational: 'a333' }) }.to raise_error(ReeMapper::CoercionError, /`rational` is invalid rational, got `"a333"`/)
     }
 
     it {
-      expect { mapper.cast({ rational: '333a' }) }.to raise_error(ReeMapper::CoercionError, '`rational` is invalid rational, got `"333a"`')
+      expect { mapper.cast({ rational: '333a' }) }.to raise_error(ReeMapper::CoercionError, /`rational` is invalid rational, got `"333a"`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.cast({ rational: object }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational, got `#{object.inspect}`")
+      expect { mapper.cast({ rational: object }) }.to raise_error(ReeMapper::TypeError, /`rational` should be a rational, got `#{object.inspect}`/)
     }
   end
 
@@ -59,16 +59,16 @@ RSpec.describe 'ReeMapper::Rational' do
     }
 
     it {
-      expect { mapper.serialize({ rational: '1/3' }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational, got `\"1/3\"`")
+      expect { mapper.serialize({ rational: '1/3' }) }.to raise_error(ReeMapper::TypeError, /`rational` should be a rational, got `\"1\/3\"`/)
     }
 
     it {
-      expect { mapper.serialize({ rational: nil }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational, got `nil`")
+      expect { mapper.serialize({ rational: nil }) }.to raise_error(ReeMapper::TypeError, /`rational` should be a rational, got `nil`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.serialize({ rational: object }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational, got `#{object.inspect}`")
+      expect { mapper.serialize({ rational: object }) }.to raise_error(ReeMapper::TypeError, /`rational` should be a rational, got `#{object.inspect}`/)
     }
   end
 
@@ -78,16 +78,16 @@ RSpec.describe 'ReeMapper::Rational' do
     }
 
     it {
-      expect { mapper.db_dump({ rational: '1/3' }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational, got `\"1/3\"`")
+      expect { mapper.db_dump({ rational: '1/3' }) }.to raise_error(ReeMapper::TypeError, /`rational` should be a rational, got `\"1\/3\"`/)
     }
 
     it {
-      expect { mapper.db_dump({ rational: nil }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational, got `nil`")
+      expect { mapper.db_dump({ rational: nil }) }.to raise_error(ReeMapper::TypeError, /`rational` should be a rational, got `nil`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.db_dump({ rational: object }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational, got `#{object.inspect}`")
+      expect { mapper.db_dump({ rational: object }) }.to raise_error(ReeMapper::TypeError, /`rational` should be a rational, got `#{object.inspect}`/)
     }
   end
 
@@ -109,16 +109,16 @@ RSpec.describe 'ReeMapper::Rational' do
     }
 
     it {
-      expect { mapper.db_load({ rational: 'a333' }) }.to raise_error(ReeMapper::CoercionError, '`rational` is invalid rational, got `"a333"`')
+      expect { mapper.db_load({ rational: 'a333' }) }.to raise_error(ReeMapper::CoercionError, /`rational` is invalid rational, got `"a333"`/)
     }
 
     it {
-      expect { mapper.db_load({ rational: '333a' }) }.to raise_error(ReeMapper::CoercionError, '`rational` is invalid rational, got `"333a"`')
+      expect { mapper.db_load({ rational: '333a' }) }.to raise_error(ReeMapper::CoercionError, /`rational` is invalid rational, got `"333a"`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.db_load({ rational: object }) }.to raise_error(ReeMapper::TypeError, "`rational` should be a rational, got `#{object.inspect}`")
+      expect { mapper.db_load({ rational: object }) }.to raise_error(ReeMapper::TypeError, /`rational` should be a rational, got `#{object.inspect}`/)
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/string_spec.rb

@@ -24,52 +24,52 @@ RSpec.describe 'ReeMapper::String' do
   describe '#serialize' do
     it { expect(mapper.serialize({ str: 'str' })).to eq({ str: 'str' }) }
 
-    it { expect { mapper.serialize({ str: nil }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `nil`") }
+    it { expect { mapper.serialize({ str: nil }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `nil`/) }
 
-    it { expect { mapper.serialize({ str: :sym }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `:sym`") }
+    it { expect { mapper.serialize({ str: :sym }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `:sym`/) }
 
     it {
       object = Object.new
-      expect { mapper.serialize({ str: object }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `#{object.inspect}`")
+      expect { mapper.serialize({ str: object }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `#{object.inspect}`/)
     }
   end
 
   describe '#cast' do
     it { expect(mapper.cast({ str: 'str' })).to eq({ str: 'str' }) }
 
-    it { expect { mapper.cast({ str: nil }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `nil`") }
+    it { expect { mapper.cast({ str: nil }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `nil`/) }
 
-    it { expect { mapper.cast({ str: :sym }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `:sym`") }
+    it { expect { mapper.cast({ str: :sym }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `:sym`/) }
 
     it {
       object = Object.new
-      expect { mapper.cast({ str: object }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `#{object.inspect}`")
+      expect { mapper.cast({ str: object }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `#{object.inspect}`/)
     }
   end
 
   describe '#db_dump' do
     it { expect(mapper.db_dump({ str: 'str' })).to eq({ str: 'str' }) }
 
-    it { expect { mapper.db_dump({ str: nil }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `nil`") }
+    it { expect { mapper.db_dump({ str: nil }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `nil`/) }
 
-    it { expect { mapper.db_dump({ str: :sym }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `:sym`") }
+    it { expect { mapper.db_dump({ str: :sym }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `:sym`/) }
 
     it {
       object = Object.new
-      expect { mapper.db_dump({ str: object }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `#{object.inspect}`")
+      expect { mapper.db_dump({ str: object }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `#{object.inspect}`/)
     }
   end
 
   describe '#db_load' do
     it { expect(mapper.db_load({ str: 'str' })).to eq({ str: 'str' }) }
 
-    it { expect { mapper.db_load({ str: nil }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `nil`") }
+    it { expect { mapper.db_load({ str: nil }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `nil`/) }
 
-    it { expect { mapper.db_load({ str: :sym }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `:sym`") }
+    it { expect { mapper.db_load({ str: :sym }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `:sym`/) }
 
     it {
       object = Object.new
-      expect { mapper.db_load({ str: object }) }.to raise_error(ReeMapper::TypeError, "`str` should be a string, got `#{object.inspect}`")
+      expect { mapper.db_load({ str: object }) }.to raise_error(ReeMapper::TypeError, /`str` should be a string, got `#{object.inspect}`/)
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/time_spec.rb

@@ -27,24 +27,24 @@ RSpec.describe 'ReeMapper::Time' do
     }
 
     it {
-      expect { mapper.serialize({ time: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{DateTime.new(2020).inspect}`")
+      expect { mapper.serialize({ time: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{Regexp.quote(DateTime.new(2020).inspect)}`/)
     }
 
     it {
-      expect { mapper.serialize({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{Date.new(2020).inspect}`")
+      expect { mapper.serialize({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{Regexp.quote(Date.new(2020).inspect)}`/)
     }
 
     it {
-      expect { mapper.serialize({ time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `\"2020-01-01T00:00:00+00:00\"`")
+      expect { mapper.serialize({ time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `"2020-01-01T00:00:00\+00:00"`/)
     }
 
     it {
-      expect { mapper.serialize({ time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `\"2020-01-01\"`")
+      expect { mapper.serialize({ time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `\"2020-01-01\"`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.serialize({ time: object }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{object.inspect}`")
+      expect { mapper.serialize({ time: object }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{object.inspect}`/)
     }
   end
 
@@ -66,16 +66,16 @@ RSpec.describe 'ReeMapper::Time' do
     }
 
     it {
-      expect { mapper.cast({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{Date.new(2020).inspect}`")
+      expect { mapper.cast({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{Regexp.quote(Date.new(2020).inspect)}`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.cast({ time: object }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{object.inspect}`")
+      expect { mapper.cast({ time: object }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{object.inspect}`/)
     }
 
     it {
-      expect { mapper.cast({ time: 'no date time' }) }.to raise_error(ReeMapper::CoercionError, "`time` is invalid time, got `\"no date time\"`")
+      expect { mapper.cast({ time: 'no date time' }) }.to raise_error(ReeMapper::CoercionError, /`time` is invalid time, got `\"no date time\"`/)
     }
   end
 
@@ -85,25 +85,25 @@ RSpec.describe 'ReeMapper::Time' do
     }
 
     it {
-      expect { mapper.serialize({ time: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{DateTime.new(2020).inspect}`")
+      expect { mapper.serialize({ time: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{Regexp.quote(DateTime.new(2020).inspect)}`/)
     }
 
     it {
-      expect { mapper.db_dump({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{Date.new(2020).inspect}`")
+      expect { mapper.db_dump({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{Regexp.quote(Date.new(2020).inspect)}`/)
     }
 
     it {
       time = Time.new(2020).to_s
-      expect { mapper.db_dump({ time: time }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{time.inspect}`")
+      expect { mapper.db_dump({ time: time }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{Regexp.quote(time.inspect)}`/)
     }
 
     it {
-      expect { mapper.db_dump({ time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `\"2020-01-01\"`")
+      expect { mapper.db_dump({ time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `\"2020-01-01\"`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.db_dump({ time: object }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{object.inspect}`")
+      expect { mapper.db_dump({ time: object }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{object.inspect}`/)
     }
   end
 
@@ -125,16 +125,16 @@ RSpec.describe 'ReeMapper::Time' do
     }
 
     it {
-      expect { mapper.db_load({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{Date.new(2020).inspect}`")
+      expect { mapper.db_load({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{Regexp.quote(Date.new(2020).inspect)}`/)
     }
 
     it {
       object = Object.new
-      expect { mapper.db_load({ time: object }) }.to raise_error(ReeMapper::TypeError, "`time` should be a time, got `#{object.inspect}`")
+      expect { mapper.db_load({ time: object }) }.to raise_error(ReeMapper::TypeError, /`time` should be a time, got `#{object.inspect}`/)
     }
 
     it {
-      expect { mapper.db_load({ time: 'no date time' }) }.to raise_error(ReeMapper::CoercionError, "`time` is invalid time, got `\"no date time\"`")
+      expect { mapper.db_load({ time: 'no date time' }) }.to raise_error(ReeMapper::CoercionError, /`time` is invalid time, got `\"no date time\"`/)
     }
   end
 end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/type_options_spec.rb

@@ -193,7 +193,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
     }
 
     it {
-      expect { mapper.cast({}) }.to raise_error(ReeMapper::TypeError, "Missing required field `number` for `root`")
+      expect { mapper.cast({}) }.to raise_error(ReeMapper::TypeError, /Missing required field `number` for `root`/)
     }
 
     it {
@@ -226,7 +226,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
     }
 
     it {
-      expect { mapper.cast({ number: nil, number_or_nil: 1 }) }.to raise_error(ReeMapper::TypeError, "`number` should be an integer, got `nil`")
+      expect { mapper.cast({ number: nil, number_or_nil: 1 }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `nil`/)
     }
   end
 
@@ -306,7 +306,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
     }
 
     it {
-      expect { mapper.cast({ number: nil }) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `nil`')
+      expect { mapper.cast({ number: nil }) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `nil`/)
     }
 
     it {
@@ -319,7 +319,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
       let(:mapper) { mapper_factory.call.use(:cast) { integer? :number, default: :not_number } }
 
       it {
-        expect { mapper.cast({}) }.to raise_error(ReeMapper::TypeError, '`number` should be an integer, got `:not_number`')
+        expect { mapper.cast({}) }.to raise_error(ReeMapper::TypeError, /`number` should be an integer, got `:not_number`/)
       }
     end
   end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/wrappers/array_spec.rb

@@ -28,15 +28,15 @@ RSpec.describe 'ReeMapper::Array' do
     }
 
     it {
-      expect { mapper.serialize({ tags: 1 }) }.to raise_error(ReeMapper::TypeError, "`tags` should be an array, got `1`")
+      expect { mapper.serialize({ tags: 1 }) }.to raise_error(ReeMapper::TypeError, /`tags` should be an array, got `1`/)
     }
 
     it {
-      expect { mapper.serialize({tags: [1], ary_of_ary: ["1"] }) }.to raise_error(ReeMapper::TypeError, "`ary_of_ary[0]` should be an array, got `\"1\"`")
+      expect { mapper.serialize({tags: [1], ary_of_ary: ["1"] }) }.to raise_error(ReeMapper::TypeError, /`ary_of_ary\[0\]` should be an array, got `\"1\"`/)
     }
 
     it {
-      expect { mapper.serialize({tags: [1], ary_of_ary: [[1, "1"]] }) }.to raise_error(ReeMapper::TypeError, "`ary_of_ary[0][1]` should be an integer, got `\"1\"`")
+      expect { mapper.serialize({tags: [1], ary_of_ary: [[1, "1"]] }) }.to raise_error(ReeMapper::TypeError, /`ary_of_ary\[0\]\[1\]` should be an integer, got `\"1\"`/)
     }
   end
 
@@ -46,7 +46,7 @@ RSpec.describe 'ReeMapper::Array' do
     }
 
     it {
-      expect { mapper.cast({ 'tags' => 1 }) }.to raise_error(ReeMapper::TypeError, "`tags` should be an array, got `1`")
+      expect { mapper.cast({ 'tags' => 1 }) }.to raise_error(ReeMapper::TypeError, /`tags` should be an array, got `1`/)
     }
   end
 
@@ -56,7 +56,7 @@ RSpec.describe 'ReeMapper::Array' do
     }
 
     it {
-      expect { mapper.db_dump(OpenStruct.new({ tags: 1 })) }.to raise_error(ReeMapper::TypeError, "`tags` should be an array, got `1`")
+      expect { mapper.db_dump(OpenStruct.new({ tags: 1 })) }.to raise_error(ReeMapper::TypeError, /`tags` should be an array, got `1`/)
     }
   end
 
@@ -66,7 +66,7 @@ RSpec.describe 'ReeMapper::Array' do
     }
 
     it {
-      expect { mapper.db_load({ 'tags' => 1 }) }.to raise_error(ReeMapper::TypeError, "`tags` should be an array, got `1`")
+      expect { mapper.db_load({ 'tags' => 1 }) }.to raise_error(ReeMapper::TypeError, /`tags` should be an array, got `1`/)
     }
   end
 

data/lib/ree_lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReeLib
-  VERSION = "1.0.87"
+  VERSION = "1.0.89"
 end