contracted_value 0.1.0.alpha.1

data/spec/contracted_value/value_spec.rb

@@ -0,0 +1,680 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+::RSpec.describe ::ContractedValue::Value do
+
+  shared_examples_for "attribute declaration" do
+    let(:value_class) do
+      raise "`value_class` absent"
+    end
+
+    example "does not raise error when NOT declaring any attribute" do
+      expect(->{ value_class }).to_not raise_error
+    end
+
+    example "does not raise error when declaring 1 attribute" do
+      expect(
+        ->{
+          value_class.class_eval do
+            attribute(:attribute_1)
+          end
+        },
+      ).to_not raise_error
+    end
+
+    example "does not raise error when declaring N attributes with different names" do
+      expect(
+        ->{
+          value_class.class_eval do
+            attribute(:attribute_1)
+            attribute(:attribute_2)
+          end
+        },
+      ).to_not raise_error
+    end
+
+    example "does raise error when declaring N attributes with the same name" do
+      expect(
+        ->{
+          value_class.class_eval do
+            attribute(:attribute_1)
+            attribute(:attribute_2)
+            attribute(:attribute_1)
+          end
+        },
+      ).to raise_error(::ContractedValue::Errors::DuplicateAttributeDeclaration)
+    end
+  end
+
+
+  describe "attribute declaration" do
+    it_behaves_like "attribute declaration" do
+      let(:value_class) do
+        Class.new(described_class)
+      end
+    end
+  end
+
+  describe "attribute assignment" do
+    context "on object initialization" do
+      context "with class with no attribute declared with contract" do
+        let(:value_class) do
+          Class.new(described_class) do
+            attribute(:attribute_1)
+            attribute(:attribute_2)
+          end
+        end
+
+        let(:default_inputs) do
+          {
+            attribute_1: 1,
+            attribute_2: 1,
+          }
+        end
+
+        let(:non_hash) do
+          []
+        end
+
+        it "does raise error when input is not a hash" do
+          aggregate_failures do
+            expect(
+              ->{
+                value_class.new(
+                  non_hash,
+                )
+              },
+            ).to raise_error(::ContractedValue::Errors::InvalidInputType)
+          end
+        end
+
+        it "does not raise error when input is a hash" do
+          aggregate_failures do
+            expect(
+              ->{
+                value_class.new(
+                  default_inputs,
+                )
+              },
+            ).to_not raise_error
+          end
+        end
+
+        it "does not raise error when input is a value" do
+          aggregate_failures do
+            expect(
+              ->{
+                value_class.new(
+                  value_class.new(
+                    default_inputs,
+                  ),
+                )
+              },
+            ).to_not raise_error
+          end
+        end
+
+        it "does raise error when value of any declared attribute missing from input" do
+          aggregate_failures do
+            [
+              :attribute_1,
+              :attribute_2,
+            ].each do |attr_name|
+              expect(
+                ->{
+                  value_class.new(
+                    default_inputs.dup.tap{|h| h.delete(attr_name)},
+                  )
+                },
+              ).to raise_error(::ContractedValue::Errors::MissingAttributeInput)
+            end
+          end
+        end
+
+        it "does not raise error when values of all declared attributes are present, even they are all nil" do
+          aggregate_failures do
+            [
+              :attribute_1,
+              :attribute_2,
+            ].each do |attr_name|
+              expect(
+                ->{
+                  value_class.new(
+                    default_inputs.each_with_object({}) do |(k, _v), h|
+                      h[k] = nil
+                    end
+                  )
+                },
+              ).to_not raise_error
+            end
+          end
+        end
+      end
+
+      context "with class with some attributes declared with contract" do
+        let(:value_class) do
+          Class.new(described_class) do
+            attribute(
+              :attribute_with_contract_1,
+              contract: ::Contracts::Builtin::And[::String, ::Contracts::Builtin::Not[::Contracts::Builtin::Send[:empty?]]],
+            )
+            attribute(
+              :attribute_with_contract_2,
+              contract: ::Contracts::Builtin::NatPos,
+            )
+          end
+        end
+
+        let(:default_inputs) do
+          {
+            attribute_with_contract_1: "yo",
+            attribute_with_contract_2: 1,
+          }
+        end
+
+
+        it "does not raise error when all values are valid according to contracts" do
+          expect(
+            ->{
+              value_class.new(
+                default_inputs
+              )
+            },
+          ).to_not raise_error
+        end
+
+        it "does raise error when any value is invalid according to contracts" do
+          aggregate_failures do
+            expect(
+              ->{
+                value_class.new(
+                  default_inputs.merge(
+                    attribute_with_contract_1: "",
+                  ),
+                )
+              },
+            ).to raise_error(::ContractedValue::Errors::InvalidAttributeValue)
+
+            expect(
+              ->{
+                value_class.new(
+                  default_inputs.merge(
+                    attribute_with_contract_2: 0,
+                  ),
+                )
+              },
+            ).to raise_error(::ContractedValue::Errors::InvalidAttributeValue)
+          end
+        end
+      end
+    end
+  end
+
+  describe "attribute input value freezing" do
+    let(:value_object) do
+      value_class.new(
+        a_hash: hash_as_input,
+      )
+    end
+
+    let(:hash_as_input) do
+      {
+        hash: hash_as_deep_nested_content,
+      }
+    end
+
+    let(:hash_as_deep_nested_content) do
+      ::Hash.new
+    end
+
+    shared_examples "attribute deeply frozen" do
+      it "does freeze the new object" do
+        expect(value_object).to be_frozen
+      end
+
+      it "does freeze the inputs" do
+        # Create it just before expectation
+        value_object
+
+        expect(
+          ->{
+            hash_as_input[:a] = nil
+          },
+        ).to raise_error(::RuntimeError, /can't modify frozen/)
+      end
+
+      it "does deeply freeze the inputs" do
+        # Create it just before expectation
+        value_object
+
+        expect(
+          ->{
+            hash_as_deep_nested_content[:a] = nil
+          },
+        ).to raise_error(::RuntimeError, /can't modify frozen/)
+      end
+    end
+
+    shared_examples "attribute shallowly frozen" do
+      it "does freeze the new object" do
+        expect(value_object).to be_frozen
+      end
+
+      it "does freeze the inputs" do
+        # Create it just before expectation
+        value_object
+
+        expect(
+          ->{
+            hash_as_input[:a] = nil
+          },
+        ).to raise_error(::RuntimeError, /can't modify frozen/)
+      end
+
+      it "does not deeply freeze the inputs" do
+        # Create it just before expectation
+        value_object
+
+        expect(
+          ->{
+            hash_as_deep_nested_content[:a] = nil
+          },
+        ).to_not raise_error
+      end
+    end
+
+    shared_examples "attribute not frozen" do
+      it "does freeze the new object" do
+        expect(value_object).to be_frozen
+      end
+
+      it "does not freeze the inputs" do
+        # Create it just before expectation
+        value_object
+
+        expect(
+          ->{
+            hash_as_input[:a] = nil
+          },
+        ).to_not raise_error
+      end
+
+      it "does not deeply freeze the inputs" do
+        # Create it just before expectation
+        value_object
+
+        expect(
+          ->{
+            hash_as_deep_nested_content[:a] = nil
+          },
+        ).to_not raise_error
+      end
+    end
+
+    context "when an attribute is declared without `refrigeration_mode` option" do
+      let(:value_class) do
+        Class.new(described_class) do
+          attribute(:a_hash)
+        end
+      end
+
+      it_behaves_like "attribute deeply frozen"
+    end
+
+    context "when an attribute is declared with `refrigeration_mode` option (:deep)" do
+      let(:value_class) do
+        Class.new(described_class) do
+          attribute(
+            :a_hash,
+            refrigeration_mode: :deep,
+          )
+        end
+      end
+
+      it_behaves_like "attribute deeply frozen"
+    end
+
+    context "when an attribute is declared with `refrigeration_mode` option (:shallow)" do
+      let(:value_class) do
+        Class.new(described_class) do
+          attribute(
+            :a_hash,
+            refrigeration_mode: :shallow,
+          )
+        end
+      end
+
+      it_behaves_like "attribute shallowly frozen"
+    end
+
+    context "when an attribute is declared with `refrigeration_mode` option (:none)" do
+      let(:value_class) do
+        Class.new(described_class) do
+          attribute(
+            :a_hash,
+            refrigeration_mode: :none,
+          )
+        end
+      end
+
+      it_behaves_like "attribute not frozen"
+    end
+
+    context "when an attribute is declared with invalid `refrigeration_mode` option" do
+      let(:value_class) do
+        Class.new(described_class) do
+          attribute(
+            :a_hash,
+            refrigeration_mode: :meow,
+          )
+        end
+      end
+
+      it "raises error on attribute declaration" do
+        expect do
+          value_class
+        end.to raise_error(::ContractedValue::Errors::InvalidRefrigerationMode)
+      end
+    end
+  end
+
+  describe "attribute default value" do
+    context "when with option :default_value" do
+      let(:value_class) do
+        # Workaround strange issue that
+        # `let` cannot be used in class block
+        default_val = default_value
+        attr_contract = attribute_contract
+
+        Class.new(described_class) do
+          attribute(
+            :attr_with_default,
+            default_value: default_val,
+            contract: attr_contract,
+          )
+        end
+      end
+
+      let(:default_value) do
+        1
+      end
+
+      let(:attribute_contract) do
+        ::Contracts::Builtin::Any
+      end
+
+      shared_examples "attribute with default value" do
+        it "returns default value when nothing provided" do
+          expect(
+            value_class.new.attr_with_default,
+          ).to eq(default_value)
+        end
+
+        it "returns provided value when something provided" do
+          [
+            nil,
+            :wut,
+            -> {  },
+          ].each do |provided_value|
+            aggregate_failures do
+              expect(
+                value_class.new(
+                  attr_with_default: provided_value,
+                ).attr_with_default,
+              ).to eq(provided_value)
+            end
+          end
+        end
+      end
+
+      context "and default value provided is `nil`" do
+        let(:default_value) do
+          nil
+        end
+
+        it_behaves_like "attribute with default value"
+
+        context "when default value violates contract" do
+          let(:attribute_contract) do
+            ::Contracts::Builtin::Not[nil]
+          end
+
+          it "does raise error on attribute declaration" do
+            expect do
+              value_class
+            end.to raise_error(::ContractedValue::Errors::InvalidAttributeDefaultValue)
+          end
+        end
+      end
+
+      context "and default value provided is not `nil`" do
+        let(:default_value) do
+          123
+        end
+
+        it_behaves_like "attribute with default value"
+
+        context "when default value violates contract" do
+          let(:attribute_contract) do
+            ::Symbol
+          end
+
+          it "does raise error on attribute declaration" do
+            expect do
+              value_class
+            end.to raise_error(::ContractedValue::Errors::InvalidAttributeDefaultValue)
+          end
+        end
+      end
+
+      context "and default value provided is mutable" do
+
+        context "as a string" do
+          let(:default_value) do
+            "PikaPika"
+          end
+
+          it_behaves_like "attribute with default value"
+
+          it "returns default value as frozen" do
+            expect(
+              value_class.new.attr_with_default,
+            ).to be_frozen
+          end
+        end
+
+        context "as a hash" do
+          let(:default_value) do
+            {a: {b: :c}}
+          end
+
+          it_behaves_like "attribute with default value"
+
+          it "returns default value as frozen" do
+            aggregate_failures do
+              val = value_class.new.attr_with_default.fetch(:a)
+
+              expect(val).to eq({b: :c})
+              expect(val).to be_frozen
+            end
+          end
+        end
+
+      end
+    end
+  end
+
+  describe "sub-classes of a value class" do
+
+    describe "attribute declaration" do
+      let(:parent_value_class) do
+        Class.new(described_class)
+      end
+
+      it_behaves_like "attribute declaration" do
+        let(:value_class) do
+          Class.new(parent_value_class)
+        end
+      end
+
+      describe "usage of parent class attribute" do
+
+        let(:parent_value_class) do
+          Class.new(described_class).tap do |klass|
+            klass.class_eval do
+              # Too lazy to include parent attributes in all examples
+              attribute(:attribute_1)
+            end
+          end
+        end
+        let(:child_value_class) do
+          Class.new(parent_value_class)
+        end
+
+        example "does not raise error" do
+          expect(
+            ->{
+              child_value_class.new(attribute_1: "wut")
+            },
+          ).to_not raise_error
+        end
+
+      end
+
+      describe "for new attributes absent in parent class" do
+
+        let(:parent_value_class) do
+          Class.new(described_class).tap do |klass|
+            klass.class_eval do
+              # Too lazy to include parent attributes in all examples
+              attribute(:attribute_1, default_value: nil)
+              attribute(:attribute_2, default_value: nil)
+            end
+          end
+        end
+
+        let(:child_value_class) do
+          Class.new(parent_value_class)
+        end
+
+        example "does not raise error when declaring 1 new attribute" do
+          expect(
+            ->{
+              child_value_class.class_eval do
+                attribute(:attribute_3)
+              end
+            },
+          ).to_not raise_error
+        end
+
+        example "does not raise error when declaring N attributes with different names" do
+          expect(
+            ->{
+              child_value_class.class_eval do
+                attribute(:attribute_3)
+                attribute(:attribute_4)
+              end
+            },
+          ).to_not raise_error
+        end
+
+        example "does raise error when declaring N attributes with the same name" do
+          expect(
+            ->{
+              child_value_class.class_eval do
+                attribute(:attribute_3)
+                attribute(:attribute_4)
+                attribute(:attribute_3)
+              end
+            },
+          ).to raise_error(::ContractedValue::Errors::DuplicateAttributeDeclaration)
+        end
+
+      end
+    end
+
+    describe "attribute redeclaration" do
+
+      let(:child_value_class) do
+        Class.new(parent_value_class)
+      end
+
+      describe "for existing attributes from parent class" do
+        let(:parent_value_class) do
+          Class.new(described_class).tap do |klass|
+            klass.class_eval do
+              attribute(:attribute_1)
+              attribute(:attribute_2)
+            end
+          end
+        end
+        it_behaves_like "attribute declaration" do
+          let(:value_class) do
+            child_value_class
+          end
+        end
+      end
+
+      describe "for existing attributes from parent class" do
+
+        let(:parent_value_class) do
+          Class.new(described_class).tap do |klass|
+            klass.class_eval do
+              attribute(
+                :attribute_1,
+                contract:           ::String,
+                refrigeration_mode: :deep,
+                # `default_value` not specified on purpose
+              )
+            end
+          end
+        end
+
+        example "does not raise error when declaring existing attribute with different contract" do
+          expect(
+            ->{
+              child_value_class.class_eval do
+                attribute(
+                  :attribute_1,
+                  contract: ::Contracts::Builtin::NatPos
+                )
+              end
+              child_value_class.new(attribute_1: "")
+            },
+          ).to raise_error(::ContractedValue::Errors::InvalidAttributeValue)
+        end
+
+        example "does not raise error when declaring existing attribute with different default_value" do
+          expect(
+            ->{
+              child_value_class.class_eval do
+                attribute(
+                  :attribute_1,
+                  default_value: nil,
+                )
+              end
+              child_value_class.new
+            },
+          ).to_not raise_error
+        end
+
+        example "does not raise error when declaring existing attribute with different refrigeration_mode" do
+          child_value_class.class_eval do
+            attribute(
+              :attribute_1,
+              refrigeration_mode: :none,
+            )
+          end
+          value_object = child_value_class.new(attribute_1: String.new)
+          expect(value_object).to be_frozen
+          expect(value_object.attribute_1).to_not be_frozen
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/contracted_value_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+::RSpec.describe ::ContractedValue do
+
+  it "has a version number" do
+    expect(described_class::VERSION).not_to eq(nil)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+require "contracted_value"
+
+if ENV["TRAVIS"]
+  require "simplecov"
+  SimpleCov.start
+
+  require "codecov"
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
+require "rspec"
+require "rspec/its"