ree_lib 1.0.0

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+RSpec.describe ReeMapper::DateTime do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper_factory) {
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
+        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
+        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
+        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+      ]
+    )
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {
+      date_time :date_time
+    }
+  }
+
+  describe '#serialize' do
+    it {
+      expect(mapper.serialize({ date_time: DateTime.new(2020) })).to eq({ date_time: DateTime.new(2020) })
+    }
+
+    it {
+      expect { mapper.serialize({ date_time: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ date_time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ date_time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ date_time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ date_time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+
+  describe '#cast' do
+    it {
+      expect(mapper.cast({ 'date_time' => DateTime.new(2020) })).to eq({ date_time: DateTime.new(2020) })
+    }
+
+    it {
+      expect(mapper.cast({ 'date_time' => Time.new(2020) })).to eq({ date_time: Time.new(2020).to_datetime })
+    }
+
+    it {
+      expect(mapper.cast({ 'date_time' => DateTime.new(2020).to_s })).to eq({ date_time: DateTime.new(2020) })
+    }
+
+    it {
+      expect(mapper.cast({ 'date_time' => '2020-01-01' })).to eq({ date_time: DateTime.new(2020) })
+    }
+
+    it {
+      expect { mapper.cast({ 'date_time' => Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.cast({ 'date_time' => Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.cast({ 'date_time' => 'no date time' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+  end
+
+  describe '#db_dump' do
+    it {
+      expect(mapper.db_dump OpenStruct.new({ date_time: DateTime.new(2020) })).to eq({ date_time: DateTime.new(2020) })
+    }
+
+    it {
+      expect { mapper.db_dump OpenStruct.new({ date_time: Time.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump OpenStruct.new({ date_time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump OpenStruct.new({ date_time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump OpenStruct.new({ date_time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump OpenStruct.new({ date_time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+
+  describe '#db_load' do
+    it {
+      expect(mapper.db_load({ 'date_time' => DateTime.new(2020) })).to eq({ date_time: DateTime.new(2020) })
+    }
+
+    it {
+      expect(mapper.db_load({ 'date_time' => Time.new(2020) })).to eq({ date_time: Time.new(2020).to_datetime })
+    }
+
+    it {
+      expect(mapper.db_load({ 'date_time' => DateTime.new(2020).to_s })).to eq({ date_time: DateTime.new(2020) })
+    }
+
+    it {
+      expect(mapper.db_load({ 'date_time' => '2020-01-01' })).to eq({ date_time: DateTime.new(2020) })
+    }
+
+    it {
+      expect { mapper.db_load({ 'date_time' => Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_load({ 'date_time' => Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_load({ 'date_time' => 'no date time' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+RSpec.describe ReeMapper::Float do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper_factory) {
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
+        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
+        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
+        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+      ]
+    )
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {
+      float :float
+    }
+  }
+
+  describe '#cast' do
+    it {
+      expect(mapper.cast({ float: 1.1 })).to eq({ float: 1.1 })
+    }
+
+    it {
+      expect(mapper.cast({ float: '1.1' })).to eq({ float: 1.1 })
+    }
+
+    it {
+      expect { mapper.cast({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+
+    it {
+      expect { mapper.db_load({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+
+    it {
+      expect { mapper.cast({ float: Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+
+  describe '#serialize' do
+    it {
+      expect(mapper.serialize({ float: 1.1 })).to eq({ float: 1.1 })
+    }
+
+    it {
+      expect { mapper.serialize({ float: '1.1' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ float: nil }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ float: Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+
+  describe '#db_dump' do
+    it {
+      expect(mapper.db_dump({ float: 1.1 })).to eq({ float: 1.1 })
+    }
+
+    it {
+      expect { mapper.db_dump({ float: '1.1' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump({ float: nil }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump({ float: Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+
+  describe '#db_load' do
+    it {
+      expect(mapper.db_load({ float: 1.1 })).to eq({ float: 1.1 })
+    }
+
+    it {
+      expect(mapper.db_load({ float: '1.1' })).to eq({ float: 1.1 })
+    }
+
+    it {
+      expect { mapper.db_load({ float: 'a1.1' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+
+    it {
+      expect { mapper.db_load({ float: '1.1a' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+
+    it {
+      expect { mapper.db_load({ float: nil }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_load({ float: Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Mapper Hash' do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper_factory) {
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast, output: :symbol_key_hash)
+      ]
+    )
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:cast) {
+      hash :point do
+        integer :x
+        integer :y
+      end
+    }
+  }
+
+  describe '#cast' do
+    it {
+      expect(mapper.cast({ point: { x: 1, y: 1 } })).to eq({ point: { x: 1, y: 1 } })
+    }
+
+    it {
+      expect { mapper.cast({ point: 1 }) }.to raise_error(ReeMapper::TypeError, 'Missing required field `x`')
+    }
+  end
+
+  describe 'key: option' do
+    it {
+      expect(
+        mapper_factory.call.use(:cast) {
+          hash :point, key: :string do
+            integer :x
+            integer :y
+          end
+        }.cast({ point: { x: 1, y: 1 } })
+      ).to eq({ point: { 'x' => 1, 'y' => 1 } })
+    }
+
+    it {
+      expect(
+        mapper_factory.call.use(:cast) {
+          hash :point, key: :symbol do
+            integer :x
+            integer :y
+          end
+        }.cast({ point: { x: 1, y: 1 } })
+      ).to eq({ point: { x: 1, y: 1 } })
+    }
+
+    it {
+      expect {
+        mapper_factory.call.use(:cast) {
+          hash :point, key: :whatever do
+            integer :x
+            integer :y
+          end
+        }
+      }.to raise_error(ArgumentError)
+    }
+  end
+
+  describe 'parent strategy object output' do
+    let(:mapper_factory) {
+      build_mapper_factory(
+        strategies: [
+          build_mapper_strategy(method: :cast, output: :object)
+        ]
+      )
+    }
+
+    let(:mapper) {
+      mapper_factory.call.use(:cast, dto: dto) {
+        hash :point do
+          integer :x
+          integer :y
+        end
+      }
+    }
+
+    let(:dto) {
+      Class.new do
+        def ==(other)
+          instance_variables == other.instance_variables
+        end
+      end
+    }
+
+    it {
+      expect(mapper.cast({ point: { x: 1, y: 1 } })).to eq(Object.new.tap { _1.instance_exec { @point = { x: 1, y: 1 } } })
+    }
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+RSpec.describe ReeMapper::Integer do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper_factory) {
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
+        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
+        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
+        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+      ]
+    )
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {
+      integer :number
+    }
+  }
+
+  describe '#cast' do
+    it {
+      expect(mapper.cast({ number: 1 })).to eq({ number: 1 })
+    }
+
+    it {
+      expect(mapper.cast({ number: '1' })).to eq({ number: 1 })
+    }
+
+    it {
+      expect { mapper.cast({ number: 'b1' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+
+    it {
+      expect { mapper.cast({ number: '1b' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+
+    it {
+      expect { mapper.cast({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+
+  describe '#serialize' do
+    it {
+      expect(mapper.serialize({ number: 1 })).to eq({ number: 1 })
+    }
+
+    it {
+      expect { mapper.serialize({ number: '1' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ number: 'b1' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ number: '1b' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+
+  describe '#db_dump' do
+    it {
+      expect(mapper.db_dump({ number: 1 })).to eq({ number: 1 })
+    }
+
+    it {
+      expect { mapper.db_dump({ number: '1' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump({ number: 'b1' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump({ number: '1b' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+
+  describe '#db_load' do
+    it {
+      expect(mapper.db_load({ number: 1 })).to eq({ number: 1 })
+    }
+
+    it {
+      expect(mapper.db_load({ number: '1' })).to eq({ number: 1 })
+    }
+
+    it {
+      expect { mapper.db_load({ number: 'b1' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+
+    it {
+      expect { mapper.db_load({ number: '1b' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+
+    it {
+      expect { mapper.db_load({ number: 1.1 }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+RSpec.describe ReeMapper::String do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper_factory) {
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
+        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
+        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
+        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+      ]
+    )
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {
+      string :str
+    }
+  }
+
+  describe '#serialize' do
+    it { expect(mapper.serialize({ str: 'str' })).to eq({ str: 'str' }) }
+
+    it { expect { mapper.serialize({ str: nil }) }.to raise_error(ReeMapper::TypeError) }
+
+    it { expect { mapper.serialize({ str: :sym }) }.to raise_error(ReeMapper::TypeError) }
+
+    it { expect { mapper.serialize({ str: Object.new }) }.to raise_error(ReeMapper::TypeError) }
+  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) }
+
+    it { expect { mapper.cast({ str: :sym }) }.to raise_error(ReeMapper::TypeError) }
+
+    it { expect { mapper.cast({ str: Object.new }) }.to raise_error(ReeMapper::TypeError) }
+  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) }
+
+    it { expect { mapper.db_dump({ str: :sym }) }.to raise_error(ReeMapper::TypeError) }
+
+    it { expect { mapper.db_dump({ str: Object.new }) }.to raise_error(ReeMapper::TypeError) }
+  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) }
+
+    it { expect { mapper.db_load({ str: :sym }) }.to raise_error(ReeMapper::TypeError) }
+
+    it { expect { mapper.db_load({ str: Object.new }) }.to raise_error(ReeMapper::TypeError) }
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+RSpec.describe ReeMapper::Time do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper_factory) {
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast,      output: :symbol_key_hash),
+        build_mapper_strategy(method: :serialize, output: :symbol_key_hash),
+        build_mapper_strategy(method: :db_dump,   output: :symbol_key_hash),
+        build_mapper_strategy(method: :db_load,   output: :symbol_key_hash)
+      ]
+    )
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {
+      time :time
+    }
+  }
+
+  describe '#serialize' do
+    it {
+      expect(mapper.serialize({ time: Time.new(2020) })).to eq({ time: Time.new(2020) })
+    }
+
+    it {
+      expect { mapper.serialize({ time: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ time: DateTime.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.serialize({ time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+
+  describe '#cast' do
+    it {
+      expect(mapper.cast({ time: Time.new(2020) })).to eq({ time: Time.new(2020) })
+    }
+
+    it {
+      expect(mapper.cast({ time: DateTime.new(2020) })).to eq({ time: DateTime.new(2020).to_time })
+    }
+
+    it {
+      expect(mapper.cast({ time: Time.new(2020).to_s })).to eq({ time: Time.new(2020) })
+    }
+
+    it {
+      expect(mapper.cast({ time: '2020-01-01' })).to eq({ time: Time.new(2020) })
+    }
+
+    it {
+      expect { mapper.cast({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.cast({ time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.cast({ time: 'no date time' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+  end
+
+  describe '#db_dump' do
+    it {
+      expect(mapper.db_dump({ time: Time.new(2020) })).to eq({ time: Time.new(2020) })
+    }
+
+    it {
+      expect { mapper.serialize({ time: DateTime.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump({ time: Time.new(2020).to_s }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump({ time: '2020-01-01' }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_dump({ time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+  end
+
+  describe '#db_load' do
+    it {
+      expect(mapper.db_load({ time: Time.new(2020) })).to eq({ time: Time.new(2020) })
+    }
+
+    it {
+      expect(mapper.db_load({ time: DateTime.new(2020) })).to eq({ time: DateTime.new(2020).to_time })
+    }
+
+    it {
+      expect(mapper.db_load({ time: Time.new(2020).to_s })).to eq({ time: Time.new(2020) })
+    }
+
+    it {
+      expect(mapper.db_load({ time: '2020-01-01' })).to eq({ time: Time.new(2020) })
+    }
+
+    it {
+      expect { mapper.db_load({ time: Date.new(2020) }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_load({ time: Object.new }) }.to raise_error(ReeMapper::TypeError)
+    }
+
+    it {
+      expect { mapper.db_load({ time: 'no date time' }) }.to raise_error(ReeMapper::CoercionError)
+    }
+  end
+end