tram-policy 0.0.1

data/lib/tram/policy/generator/policy_spec.erb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+RSpec.describe <%= klass %>, "#valid?" do
+  subject(:policy) { described_class[<%= policy_signature.join(", ") %>] }
+
+<% (parsed_params + parsed_options).each do |name| -%>
+  let(:<%= name %>) { FactoryGirl.build :<%= name %> }
+<% end -%>
+
+  it { is_expected.to be_valid }
+<% parsed_validators.each do |validator| %>
+  it "is invalid when not <%= validator %>" do
+    policy # modify it correspondingly
+    expect { policy }.to be_invalid_at # add tags to check
+  end
+<% end -%>
+end

data/lib/tram/policy/inflector.rb

@@ -0,0 +1,26 @@
+class Tram::Policy
+  if Object.const_defined? "ActiveSupport::Inflector"
+    Inflector = ActiveSupport::Inflector
+  elsif Object.const_defined? "Inflecto"
+    Inflector = ::Inflecto
+  else
+    module Inflector
+      def self.underscore(name)
+        name.dup.tap do |n|
+          n.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          n.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          n.gsub!("::", "/")
+          n.tr!("-", "_")
+          n.downcase!
+        end
+      end
+
+      def self.camelize(name)
+        name.dup.tap do |n|
+          n.gsub!(/(?:\A|_+)(.)/)    { $1.upcase }
+          n.gsub!(%r{(?:[/|-]+)(.)}) { "::#{$1.upcase}" }
+        end
+      end
+    end
+  end
+end

data/lib/tram/policy/matchers.rb

@@ -0,0 +1,112 @@
+require "rspec"
+
+# Checks that a block provides policy that has errors under given tags
+# It also check that selected messages has translations to all available locales
+#
+# @example
+#   subject(:policy) { UserPolicy[name: nil] }
+#   expect { policy }.to be_invalid_at field: "name", level: "error"
+#
+# You have to wrap expectation to a block called for available locales.
+#
+RSpec::Matchers.define :be_invalid_at do |**tags|
+  supports_block_expectations
+
+  # ****************************************************************************
+  # Result collectors for all available locations
+  # ****************************************************************************
+
+  attr_accessor :policy
+
+  def errors
+    @errors ||= {}
+  end
+
+  def tags
+    @tags ||= {}
+  end
+
+  def messages
+    @messages ||= {}
+  end
+
+  # ****************************************************************************
+  # Helpers to provide results for all locales
+  # ****************************************************************************
+
+  # Runs block in every available locale
+  def in_available_locales
+    Array(I18n.available_locales).flat_map do |locale|
+      I18n.with_locale(locale) { yield }
+    end
+  end
+
+  # Collects results for the current locale
+  def prepare_results(policy_block, tags, locale = I18n.locale)
+    localized_policy = policy_block.call
+    localized_errors = localized_policy&.errors || []
+    self.policy      = localized_policy.inspect
+    errors[locale]   = localized_errors.by_tags(tags)
+    messages[locale] = localized_errors.full_messages
+  end
+
+  # ****************************************************************************
+  # Checkers for collected results
+  # ****************************************************************************
+
+  # Checks if selected errors are present in all available locales
+  def errored?
+    errors.values.map(&:any?).reduce(true, &:&) == true
+  end
+
+  # Checks if selected errors are absent in all available locales
+  def not_errored?
+    errors.values.map(&:empty?).reduce(true, &:&) == true
+  end
+
+  # Checks if all collected errors are translated
+  def translated?
+    texts = errors.values.flatten.map(&:message)
+    texts.select { |text| text.start_with?("translation missing:") }.empty?
+  end
+
+  def report_errors
+    text = "Actual errors:\n"
+    messages.each do |locale, list|
+      text << "  #{locale}:\n"
+      list.each { |item| text << "  - #{item}\n" }
+    end
+    text
+  end
+
+  # ****************************************************************************
+  # Positive matcher
+  # ****************************************************************************
+
+  match do |policy_block|
+    in_available_locales { prepare_results(policy_block, tags) }
+    errored? && translated?
+  end
+
+  failure_message do |_|
+    text =  "#{policy} should have had errors with tags: #{tags}, "
+    text << "whose messages are translated in all available locales.\n"
+    text << report_errors
+    text
+  end
+
+  # ****************************************************************************
+  # Negative matcher
+  # ****************************************************************************
+
+  match_when_negated do |policy_block|
+    in_available_locales { prepare_results(policy_block, tags) }
+    not_errored?
+  end
+
+  failure_message_when_negated do |_|
+    text =  "#{policy} should not have had any error with tags: #{tags}.\n"
+    text << report_errors
+    text
+  end
+end

data/lib/tram/policy/validation_error.rb

@@ -0,0 +1,18 @@
+class Tram::Policy
+  # An exception to be risen by [Tram::Policy#validate!]
+  class ValidationError < RuntimeError
+    # Policy object whose validation has caused the exception
+    #
+    # @return [Tram::Policy]
+    #
+    attr_reader :policy
+
+    private
+
+    def initialize(policy, filter)
+      @policy  = policy
+      messages = policy.errors.reject(&filter).map(&:full_message)
+      super (["Validation failed with errors:"] + messages).join("\n- ")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+begin
+  require "pry"
+rescue
+  nil
+end
+require "bundler/setup"
+require "tram/policy"
+require "tram/policy/matchers"
+require "rspec/its"
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = ".rspec_status"
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.order = :random
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+
+  # Prepare the Test namespace for constants defined in specs
+  config.around(:each) do |example|
+    Test = Class.new(Module)
+    example.run
+    Object.send :remove_const, :Test
+  end
+end

data/spec/tram/policy/error_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe Tram::Policy::Error do
+  subject(:error) { described_class.new "Something bad happened", tags }
+
+  let(:tags) { { level: "warning" } }
+
+  describe "#message" do
+    subject { error.message }
+    it { is_expected.to eq "Something bad happened" }
+  end
+
+  describe "#full_message" do
+    subject { error.full_message }
+
+    context "with tags:" do
+      it { is_expected.to eq "Something bad happened {:level=>\"warning\"}" }
+    end
+
+    context "without tags:" do
+      let(:tags) { {} }
+      it { is_expected.to eq "Something bad happened" }
+    end
+  end
+
+  describe "#to_h" do
+    subject { error.to_h }
+    it { is_expected.to eq message: "Something bad happened", level: "warning" }
+  end
+
+  describe "#==" do
+    subject { error == other }
+
+    context "when other object has the same #to_h:" do
+      let(:other) { double to_h: error.to_h }
+      it { is_expected.to eq true }
+    end
+
+    context "when other object has different #to_h:" do
+      let(:other) { double to_h: error.to_h.merge(foo: :bar) }
+      it { is_expected.to eq false }
+    end
+
+    context "when other object not respond to #to_h:" do
+      let(:other) { double }
+      it { is_expected.to eq false }
+    end
+  end
+
+  describe "arbitrary tag" do
+    subject { error.send tag }
+
+    context "when tag is defined:" do
+      let(:tag) { "level" }
+      it { is_expected.to eq "warning" }
+    end
+
+    context "when tag not defined:" do
+      let(:tag) { :weight }
+      it { is_expected.to be_nil }
+    end
+  end
+end

data/spec/tram/policy/errors_spec.rb

@@ -0,0 +1,112 @@
+RSpec.describe Tram::Policy::Errors do
+  let(:policy) { double :policy, t: "OMG!" }
+  let(:errors) { described_class.new(policy) }
+
+  describe ".new" do
+    subject { errors }
+
+    it { is_expected.to be_kind_of Enumerable }
+    it { is_expected.to respond_to :empty? }
+    it { is_expected.to be_empty }
+    its(:policy) { is_expected.to eql policy }
+  end
+
+  describe "#add" do
+    subject     { errors.add :omg, level: "info", field: "name" }
+    let(:error) { errors.to_a.last }
+
+    it "adds an error to the collection:" do
+      expect { 2.times { subject } }.to change { errors.count }.by 1
+
+      expect(error).to be_kind_of Tram::Policy::Error
+      expect(error).to eq message: "OMG!", level: "info", field: "name"
+    end
+  end
+
+  describe "#merge" do
+    let(:other) { described_class.new(policy) }
+
+    before do
+      errors.add "D'OH!", level: "disaster"
+      other.add  "OUCH!", level: "error"
+    end
+
+    context "without a block:" do
+      subject { errors.merge(other) }
+
+      it "merges other collection as is" do
+        expect(subject).to be_a Tram::Policy::Errors
+        expect(subject.map(&:to_h)).to match_array [
+          { message: "OMG!", level: "disaster" },
+          { message: "OMG!", level: "error" }
+        ]
+      end
+    end
+
+    context "with a block:" do
+      subject { errors.merge(other) { |err| err.merge(source: "Homer") } }
+
+      it "merges filtered collection as is" do
+        expect(subject).to be_a Tram::Policy::Errors
+        expect(subject.map(&:to_h)).to match_array [
+          { message: "OMG!", level: "disaster" },
+          { message: "OMG!", level: "error", source: "Homer" }
+        ]
+      end
+    end
+
+    context "not errors:" do
+      subject { errors.merge 1 }
+      it { is_expected.to eql errors }
+    end
+  end
+
+  describe "#messages" do
+    subject { errors.messages }
+
+    it { is_expected.to eq [] }
+
+    context "with errors added:" do
+      before  { errors.add "OMG!", level: "info", field: "name" }
+      it { is_expected.to eq %w[OMG!] }
+    end
+  end
+
+  describe "#full_messages" do
+    subject { errors.full_messages }
+
+    it { is_expected.to eq [] }
+
+    context "with errors added:" do
+      before  { errors.add "OMG!", level: "info", field: "name" }
+      it { is_expected.to eq ["OMG! {:level=>\"info\", :field=>\"name\"}"] }
+    end
+  end
+
+  describe "#by_tags" do
+    before do
+      errors.add :foo, field: "name",  level: "error"
+      errors.add :foo, field: "email", level: "info"
+      errors.add :foo, field: "email", level: "error"
+    end
+
+    context "with filter" do
+      subject { errors.by_tags level: "error" }
+
+      it "returns selected errors only" do
+        expect(subject.map(&:to_h)).to match_array [
+          { message: "OMG!", field: "name",  level: "error" },
+          { message: "OMG!", field: "email", level: "error" }
+        ]
+      end
+    end
+
+    context "without a filter" do
+      subject { errors.by_tags }
+
+      it "returns selected all errors" do
+        expect(subject.map(&:to_h)).to match_array errors.to_a
+      end
+    end
+  end
+end

data/spec/tram/policy/inflector_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe Tram::Policy::Inflector do
+  let(:snake) { "test/admin2_user_new_policy" }
+  let(:camel) { "Test::Admin2UserNewPolicy" }
+
+  describe "#underscore" do
+    subject { described_class.underscore "Test::Admin2USERNew-Policy" }
+    it { is_expected.to eq snake }
+  end
+
+  describe "#camelize" do
+    subject { described_class.camelize snake }
+    it { is_expected.to eq camel }
+  end
+end

data/spec/tram/policy/matchers_spec.rb

@@ -0,0 +1,70 @@
+RSpec.describe "RSpec matchers:" do
+  subject { Test::UserPolicy[name: nil] }
+
+  before do
+    I18n.available_locales = %i[en]
+    I18n.backend.store_translations \
+      :en, { "test/user_policy" => { "name_presence" => "Name is absent" } }
+
+    class Test::UserPolicy < Tram::Policy
+      option :name
+
+      validate :name_presence
+
+      private
+
+      def name_presence
+        return if name
+        errors.add :name_presence, field: "name"
+      end
+    end
+  end
+
+  describe "to be_invalid_at" do
+    it "passes when some translated error present w/o tags constraint" do
+      expect do
+        expect { subject }.to be_invalid_at
+      end.not_to raise_error
+    end
+
+    it "passes when some translated error present under given tags" do
+      expect do
+        expect { subject }.to be_invalid_at field: "name"
+      end.not_to raise_error
+    end
+
+    it "fails when no errors present under given tags" do
+      expect do
+        expect { subject }.to be_invalid_at field: "email"
+      end.to raise_error RSpec::Expectations::ExpectationNotMetError
+    end
+
+    it "fails when some translations are absent" do
+      I18n.available_locales = %i[ru en]
+
+      expect do
+        expect { subject }.to be_invalid_at field: "name"
+      end.to raise_error RSpec::Expectations::ExpectationNotMetError
+    end
+  end
+
+  describe "not_to be_invalid_at" do
+    it "passes when no errors present under given tags" do
+      expect do
+        expect { subject }.not_to be_invalid_at field: "email"
+      end.not_to raise_error
+    end
+
+    it "fails when some error present under given tags" do
+      expect do
+        expect { subject }.not_to be_invalid_at field: "name"
+      end.to raise_error RSpec::Expectations::ExpectationNotMetError
+    end
+
+    it "fails when some error present w/o tags constraint" do
+      expect do
+        expect { subject }.not_to be_invalid_at
+      end.to raise_error RSpec::Expectations::ExpectationNotMetError
+    end
+  end
+end