blood_contracts-ext 0.1.0

data/spec/blood_contracts/ext/map_value_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe BloodContracts::Core::MapValue do
+  before do
+    module Test
+      require "forwardable"
+
+      class JsonMapper
+        def self.call(**payload)
+          JSON.pretty_generate(payload)
+        end
+      end
+
+      class ContactType < ::BC::Ext::Refined
+        extend Forwardable
+        extract :name
+        extract :phone
+        extract :manager_id
+
+        def_delegators :@value, :name, :phone, :manager_id
+      end
+
+      ContactJsonType = ContactType.and_then(BC::MapValue.with(JsonMapper))
+      Contact = Struct.new(:name, :phone, :manager_id)
+    end
+  end
+
+  subject { Test::ContactJsonType.match(value) }
+
+  context "when value is a valid contact" do
+    let(:value) { Test::Contact.new("Nick Cage", "2-333-111-444", 4113) }
+    let(:valid_json) do
+      <<~JSON.strip
+        {
+          "name": "Nick Cage",
+          "phone": "2-333-111-444",
+          "manager_id": 4113
+        }
+      JSON
+    end
+
+    it do
+      is_expected.to be_valid
+      expect(subject.unpack).to eq(valid_json)
+    end
+  end
+
+  context "when value is an invalid contact" do
+    let(:value) { "Nick Cage, 2-333-111-444, 4113" }
+
+    it do
+      is_expected.to be_invalid
+      is_expected.to match(kind_of(::BC::ExceptionCaught))
+    end
+  end
+end

data/spec/blood_contracts/ext/policy_failure_spec.rb

@@ -0,0 +1,151 @@
+RSpec.describe BloodContracts::Core::PolicyFailure do
+  before do
+    module Test
+      class Phone < ::BC::Ext::Refined
+        REGEX = /\A(\+7|8)(9|8)\d{9}\z/i
+
+        def match
+          context[:phone_input] = value.to_s
+          clean_phone = context[:phone_input].gsub(/[\s\(\)-]/, "")
+          return failure(:invalid_phone) if clean_phone !~ REGEX
+          context[:clean_phone] = clean_phone
+
+          self
+        end
+
+        def mapped
+          context[:clean_phone]
+        end
+      end
+
+      class Email < ::BC::Ext::Refined
+        REGEX = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i
+        INVALID_EMAIL = define_error(:invalid_email)
+
+        def match
+          context[:email_input] = value.to_s
+          return failure(INVALID_EMAIL) if context[:email_input] !~ REGEX
+          context[:email] = context[:email_input]
+
+          self
+        end
+
+        def mapped
+          context[:email]
+        end
+      end
+
+      class Ascii < ::BC::Ext::Refined
+        REGEX = /^[[:ascii:]]+$/i
+
+        def match
+          context[:ascii_input] = value.to_s
+          return failure("Not ASCII") if context[:ascii_input] !~ REGEX
+          context[:ascii] = context[:ascii_input]
+
+          self
+        end
+
+        def mapped
+          context[:ascii]
+        end
+      end
+
+      Login = Email.or_a(Phone)
+    end
+  end
+
+  describe "Errors composition with Tram::Policy::Errors" do
+    context "when using `OR` composition" do
+      subject { Test::Login.match(value) }
+
+      context "when value is invalid" do
+        let(:value) { "tasf" }
+        let(:errors_list) do
+          [
+            { Test::Login => [kind_of(Tram::Policy::Errors)] },
+            { Test::Email => [kind_of(Tram::Policy::Errors)] },
+            { Test::Phone => [kind_of(Tram::Policy::Errors)] }
+          ]
+        end
+        let(:policy_errors) do
+          [
+            kind_of(Tram::Policy::Errors),
+            kind_of(Tram::Policy::Errors)
+          ]
+        end
+        let(:validation_context) { { phone_input: value, email_input: value } }
+        let(:messages) do
+          [
+            "Value `tasf` is not a valid phone",
+            "Given value is not a valid email"
+          ]
+        end
+
+        it do
+          is_expected.to be_invalid
+          expect { subject.unpack }.not_to raise_error
+          expect(subject.errors).to match_array(errors_list)
+          expect(subject.policy_errors).to match(policy_errors)
+          expect(subject.messages).to match_array(messages)
+          expect(subject.context).to include(validation_context)
+        end
+      end
+    end
+
+    context "when using `AND` composition" do
+      subject { Test::RegistrationInput.match(email, phone) }
+
+      before do
+        module Test
+          class RegistrationInput < ::BC::Ext::Tuple
+            attribute :login,    Login
+            attribute :password, Ascii
+          end
+        end
+      end
+
+      context "when input is invalid" do
+        let(:email) { "admin" }
+        let(:phone) { "not_a_phone" }
+        let(:login_error) { { Test::Login => [kind_of(Tram::Policy::Errors)] } }
+        let(:password) { "newP@ssw0rd" }
+        let(:attributes) do
+          attribute_errors.merge(password: kind_of(Test::Ascii))
+        end
+        let(:attribute_errors) do
+          {
+            login: kind_of(BC::PolicyFailure),
+            base: kind_of(BC::TuplePolicyFailure)
+          }
+        end
+        let(:errors) do
+          [
+            { Test::Email => [kind_of(Tram::Policy::Errors)] },
+            { Test::Phone => [kind_of(Tram::Policy::Errors)] },
+            { Test::Login => [kind_of(Tram::Policy::Errors)] },
+            { Test::RegistrationInput => [kind_of(Tram::Policy::Errors)] }
+          ]
+        end
+        let(:attribute_messages) do
+          {
+            login: [
+              "Given value is not a valid email",
+              "Value `admin` is not a valid phone"
+            ],
+            base: ["Data for registration is invalid"]
+          }
+        end
+
+        it do
+          expect(subject).to be_invalid
+          expect(subject.attributes).to match(attributes)
+          expect(subject.to_h).to match(hash_including(login: login_error))
+          expect(subject.errors).to match_array(errors)
+          expect(subject.attribute_errors).to match(attribute_errors)
+          expect(subject.attribute_messages).to match(attribute_messages)
+        end
+      end
+    end
+  end
+end

data/spec/blood_contracts/ext/policy_spec.rb

@@ -0,0 +1,138 @@
+RSpec.describe "BC::Ext::Refined validation delegated to Tram::Policy" do
+  before do
+    module Test
+      class AddressPolicy < Tram::Policy
+        option :country_code
+        option :city
+        option :street
+
+        validate :city_correctness
+        validate :country_code_correctness
+        validate :street_correctness
+
+        def country_code_correctness
+          return if country_code.to_s.size == 2
+          errors.add :invalid_country_code, value: country_code
+        end
+
+        def city_correctness
+          return if (2..30).cover?(city.to_s.size)
+          errors.add :invalid_city_name, value: city
+        end
+
+        def street_correctness
+          return if (5..75).cover?(street.to_s.size)
+          errors.add :invalid_street, value: street
+        end
+      end
+
+      class AddressType < BC::Ext::Refined
+        self.policy = AddressPolicy
+
+        extract :city
+        extract :country_code, method_name: :country
+        extract :street
+
+        def city
+          return value.city if value.respond_to?(:city)
+          stringify_hash_keys(value.to_h)
+            .values_at("city", "City")
+            .compact
+            .first
+        end
+
+        def country
+          return value.country if value.respond_to?(:country)
+          stringify_hash_keys(value.to_h)
+            .values_at("country", "country_code", "CountryCode")
+            .compact
+            .first
+        end
+
+        def street
+          return value.street if value.respond_to?(:street)
+          stringify_hash_keys(value.to_h)
+            .values_at("street", "street_line", "StreetLine")
+            .compact
+            .first
+        end
+
+        private def stringify_hash_keys(hash)
+          hash.reduce({}) { |a, (k, v)| a.merge!(k.to_s => v) }
+        end
+
+      end
+
+      Address = Struct.new(:country, :city, :street)
+    end
+  end
+
+  subject { Test::AddressType.match(value) }
+
+  context "when input is valid address" do
+    let(:mapped_data) do
+      { city: "Moscow", country_code: "RU", street: "ul. Novoslobodskaya" }
+    end
+
+    context "when value is an Test::Address" do
+      let(:value) do
+        Test::Address.new("RU", "Moscow", "ul. Novoslobodskaya")
+      end
+
+      it do
+        expect(subject).to be_valid
+        expect(subject).to be_kind_of(Test::AddressType)
+        expect(subject.unpack).to match(mapped_data)
+      end
+    end
+
+    context "when value is a parsed json" do
+      let(:json) do
+        '{"CountryCode": "RU", '\
+        '"City": "Moscow", '\
+        '"StreetLine": "ul. Novoslobodskaya"}'
+      end
+      let(:value) { JSON.parse(json) }
+
+      it do
+        expect(subject).to be_valid
+        expect(subject).to be_kind_of(Test::AddressType)
+        expect(subject.unpack).to match(mapped_data)
+      end
+    end
+  end
+
+  context "when input is invalid address" do
+    let(:mapped_data) do
+      { Test::AddressType => [kind_of(Tram::Policy::Errors)] }
+    end
+    let(:error_messages) do
+      ["The value `M` is not a valid city name",
+       "The value `RUS` is not a valid ISO country code",
+       "The value `ul` is not a valid street"]
+    end
+
+    context "when value is an Test::Address" do
+      let(:value) { Test::Address.new("RUS", "M", "ul") }
+
+      it do
+        expect(subject).to be_invalid
+        expect(subject).to be_kind_of(BC::PolicyFailure)
+        expect(subject.unpack).to match(mapped_data)
+        expect(subject.messages).to match(error_messages)
+      end
+    end
+
+    context "when value is a parsed json" do
+      let(:json) { '{"country": "RUS", "city": "M", "street": "ul"}' }
+      let(:value) { JSON.parse(json) }
+
+      it do
+        expect(subject).to be_invalid
+        expect(subject).to be_kind_of(BC::PolicyFailure)
+        expect(subject.unpack).to match(mapped_data)
+        expect(subject.messages).to match(error_messages)
+      end
+    end
+  end
+end

data/spec/fixtures/en.yml

@@ -0,0 +1,19 @@
+---
+en:
+  bad: Something bad has happened
+  contracts:
+    test/email:
+      invalid_email: Given value is not a valid email
+    test/phone:
+      invalid_phone: Value `%{phone_input}` is not a valid phone
+    test/login:
+      no_matches: Data for login is invalid
+    test/registration_input:
+      invalid_tuple: Data for registration is invalid
+    test/plain_text_error:
+      message: "Service responded with a message: `%{plain_text}`"
+  tram-policy:
+    test/address_policy:
+      invalid_city_name: The value `%{value}` is not a valid city name
+      invalid_country_code: The value `%{value}` is not a valid ISO country code
+      invalid_street: The value `%{value}` is not a valid street

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require "bundler/setup"
+require "blood_contracts/ext"
+
+require_relative "support/fixtures_helper.rb"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.around do |example|
+    I18n.available_locales = %w[en]
+    I18n.backend.store_translations :en, yaml_fixture_file("en.yml")["en"]
+    module Test; end
+    example.run
+    Object.send(:remove_const, :Test)
+  end
+end

data/spec/support/fixtures_helper.rb

@@ -0,0 +1,11 @@
+def fixture_file_path(filename)
+  File.expand_path "spec/fixtures/#{filename}"
+end
+
+def yaml_fixture_file(filename)
+  YAML.load_file(fixture_file_path(filename))
+end
+
+def load_fixture(filename)
+  load fixture_file_path(filename)
+end

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: blood_contracts-ext
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sergey Dolganov (sclinede)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: blood_contracts-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: tram-policy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+description: Extra helpers for BloodContracts::Core
+email:
+- sclinede@evilmartians.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CODE_OF_CONDUCT.md
+- README.md
+- LICENSE
+- CHANGELOG.md
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- blood_contracts-ext.gemspec
+- lib/blood_contracts/core/defineable_error.rb
+- lib/blood_contracts/core/exception_caught.rb
+- lib/blood_contracts/core/exception_handling.rb
+- lib/blood_contracts/core/expected_error.rb
+- lib/blood_contracts/core/extractable.rb
+- lib/blood_contracts/core/map_value.rb
+- lib/blood_contracts/core/policy_failure.rb
+- lib/blood_contracts/core/sum_policy_failure.rb
+- lib/blood_contracts/core/tuple_policy_failure.rb
+- lib/blood_contracts/ext.rb
+- lib/blood_contracts/ext/pipe.rb
+- lib/blood_contracts/ext/refined.rb
+- lib/blood_contracts/ext/sum.rb
+- lib/blood_contracts/ext/tuple.rb
+- spec/blood_contracts/ext/exception_caught_spec.rb
+- spec/blood_contracts/ext/expected_error_spec.rb
+- spec/blood_contracts/ext/map_value_spec.rb
+- spec/blood_contracts/ext/policy_failure_spec.rb
+- spec/blood_contracts/ext/policy_spec.rb
+- spec/fixtures/en.yml
+- spec/spec_helper.rb
+- spec/support/fixtures_helper.rb
+homepage: https://github.com/sclinede/blood_contracts-ext
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Extra helpers for BloodContracts::Core
+test_files:
+- spec/blood_contracts/ext/exception_caught_spec.rb
+- spec/blood_contracts/ext/expected_error_spec.rb
+- spec/blood_contracts/ext/map_value_spec.rb
+- spec/blood_contracts/ext/policy_failure_spec.rb
+- spec/blood_contracts/ext/policy_spec.rb
+- spec/fixtures/en.yml
+- spec/spec_helper.rb
+- spec/support/fixtures_helper.rb