attr_masker 0.2.1 → 0.3.0

data/lib/attr_masker/version.rb

@@ -2,20 +2,5 @@
 #
 
 module AttrMasker
-  # Contains information about this gem's version
-  module Version
-    MAJOR = 0
-    MINOR = 2
-    PATCH = 1
-
-    # Returns a version string by joining <tt>MAJOR</tt>, <tt>MINOR</tt>, and
-    # <tt>PATCH</tt> with <tt>'.'</tt>
-    #
-    # Example
-    #
-    #   Version.string # '1.0.2'
-    def self.string
-      [MAJOR, MINOR, PATCH].join(".")
-    end
-  end
+  VERSION = "0.3.0".freeze
 end

data/lib/tasks/db.rake

@@ -1,9 +1,6 @@
 # (c) 2017 Ribose Inc.
 #
 
-# Hashrocket style looks better when describing task dependencies.
-# rubocop:disable Style/HashSyntax
-
 namespace :db do
   desc "Mask every DB record according to rules set up in the respective " \
   "ActiveRecord"

data/spec/dummy/config/routes.rb

@@ -1,3 +1,2 @@
 Rails.application.routes.draw do
-  #
 end

data/spec/features/active_record_spec.rb

@@ -1,28 +1,97 @@
 # (c) 2017 Ribose Inc.
 #
 
-# No point in using ApplicationRecord here.
-# rubocop:disable Rails/ApplicationRecord
-
 require_relative "shared_examples"
 
 RSpec.describe "Attr Masker gem", :suppress_progressbar do
   context "when used with ActiveRecord" do
     before do
-      if ENV["WITHOUT_ACTIVE_RECORD"]
+      if WITHOUT_ACTIVE_RECORD
         expect(defined?(::ActiveRecord)).to be(nil)
-        skip "Active Record specs disabled with WITHOUT_ACTIVE_RECORD shell " \
+        skip "Active Record specs disabled with WITHOUT=activerecord shell " \
           "variable"
       end
     end
 
-    before do
-      allow(ActiveRecord::Base).to receive(:descendants).
-        and_return([ActiveRecord::SchemaMigration, user_class_definition])
+    # For performance reasons, Rails features its own DescendantsTracker,
+    # which stores parent-child class relationships, and uses it to find
+    # subclasses instead of crawling the ObjectSpace.
+    #
+    # The drawback is that anonymous classes are never garbage collected,
+    # because there is always at least one reference, which is held by that
+    # tracker.  Therefore, the return value of ActiveRecord::Base.descendants
+    # method call is typically polluted by anonymous classes created by this
+    # test suite.  What is worse, that means that tests depend on each other.
+    #
+    # Till now, we used to stub ActiveRecord::Base.descendants method in specs
+    # where it matters, but that did not stop anonymous classes from being
+    # carried over to other examples, making the whole test suite quite
+    # fragile.  And indeed, issues have been observed with Rails 5.2.
+    #
+    # This commit introduces a very different approach.  Anonymous classes are
+    # removed from DescendantsTracker when respective test example is done.
+    # Nothing is carried over, no stubbing is necessary.  It must be noted
+    # though that the new approach relies on Rails private APIs.  But
+    # fortunately, DescendantsTracker is modified extremely rarely (no changes
+    # to AST since 2012), therefore  I expect that this new approach will
+    # require much less maintenance than stubbing we did.
+    #
+    # -----
+    # 2020-01
+    #
+    # From Rails 6.0, DescendantsTracker uses weak references, and no longer
+    # blocks garbage collection of anonymous classes.  See:
+    # https://github.com/rails/rails/pull/31442
+    #
+    # However, instances of these classes, which are bound to example life cycle
+    # via #let helpers, also hold the references, hence garbage collection must
+    # be postponed till example life cycle ends.
+    #
+    # Consequently, #after hooks cannot be used, as they are run too early for
+    # this purpose, but fortunately this can be worked around by
+    # before(:example) + after(:all) combo.
+    #
+    # -----
+    # 2020-01 part 2
+    #
+    # Not really.  Garbage Collector cannot be trusted.  It is not guaranteed
+    # to work consistently in different Ruby versions, and in fact is a cause
+    # of build failures in case of Rails 6.0 on Ruby 2.5.7 when run with
+    # WITHOUT=mongoid environment variable set.
+    #
+    # Therefore, manual sweep is still necessary in Ruby 6+.
+    after do
+      if defined?(::ActiveRecord::Base)
+        if ::ActiveSupport.gem_version < Gem::Version.new("6.0.0")
+          ::ActiveSupport::DescendantsTracker.
+            class_variable_get("@@direct_descendants")[::ActiveRecord::Base].
+            delete(user_class_definition)
+        else
+          ::ActiveSupport::DescendantsTracker.
+            class_variable_get("@@direct_descendants")[::ActiveRecord::Base].
+            instance_variable_get("@refs").
+            delete(user_class_definition)
+        end
+      end
+    end
+
+    # Rails 5.2 seems to reset connection shortly after Combustion gets its job,
+    # causing in-memory database to be dropped.  Hence, schema is loaded
+    # once again here.
+    before(:all) do
+      if defined?(::ActiveRecord::Base)
+        schema_path = File.expand_path("../dummy/db/schema.rb", __dir__)
+        load(schema_path)
+      end
     end
 
+    # No point in using ApplicationRecord here.
+    # rubocop:disable Rails/ApplicationRecord
+
     let(:user_class_definition) { Class.new(ActiveRecord::Base) }
 
+    # rubocop:enable Rails/ApplicationRecord
+
     include_examples "Attr Masker gem feature specs"
   end
 end

data/spec/features/mongoid_spec.rb

@@ -6,15 +6,15 @@ require_relative "shared_examples"
 RSpec.describe "Attr Masker gem", :suppress_progressbar do
   context "when used with Mongoid" do
     before do
-      if ENV["WITHOUT_MONGOID"]
+      if WITHOUT_MONGOID
         expect(defined?(::Mongoid)).to be(nil)
-        skip "Mongoid specs disabled with WITHOUT_MONGOID shell variable"
+        skip "Mongoid specs disabled with WITHOUT=mongoid shell variable"
       end
     end
 
     after do
       # Remove the example-specific model from Mongoid.models
-      ::Mongoid.models.delete(user_class_definition)
+      ::Mongoid.models.delete(user_class_definition) if defined?(::Mongoid)
     end
 
     let(:user_class_definition) do

data/spec/features/shared_examples.rb

@@ -176,6 +176,63 @@ RSpec.shared_examples "Attr Masker gem feature specs" do
     )
   end
 
+  example "Using a custom masker with model" do
+    first_name_masker = ->(value:, model:, **_) do
+      value.reverse + model.email
+    end
+
+    last_name_masker = ->(value:, model:, **_) do
+      model.email + value.upcase
+    end
+
+    User.class_eval do
+      attr_masker :first_name, masker: first_name_masker
+      attr_masker :last_name, masker: last_name_masker
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      change { han.first_name }.to("naHhan@example.test") &
+      change { han.last_name }.to("han@example.testSOLO") &
+      preserve { han.email }
+    )
+
+    expect { luke.reload }.to(
+      change { luke.first_name }.to("ekuLluke@jedi.example.test") &
+      change { luke.last_name }.to("luke@jedi.example.testSKYWALKER") &
+      preserve { luke.email }
+    )
+  end
+
+  example "Masked value is assigned via attribute writer" do
+    User.class_eval do
+      attr_masker :first_name, :last_name
+
+      def first_name=(value)
+        self[:first_name] = "#{value} with side effects"
+      end
+
+      def last_name=(value)
+        self[:last_name] = value
+      end
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      change { han.first_name }.to("(redacted) with side effects") &
+      change { han.last_name }.to("(redacted)") &
+      preserve { han.email }
+    )
+
+    expect { luke.reload }.to(
+      change { luke.first_name }.to("(redacted) with side effects") &
+      change { luke.last_name }.to("(redacted)") &
+      preserve { luke.email }
+    )
+  end
+
   example "Masking a marshalled attribute" do
     User.class_eval do
       attr_masker :avatar, marshal: true
@@ -246,6 +303,40 @@ RSpec.shared_examples "Attr Masker gem feature specs" do
     expect(luke.avatar).to eq({ json: ["(redacted)"] }.to_json)
   end
 
+  example "Masking an attribute which spans on more than one table column \
+          (or document field)" do
+    User.class_eval do
+      attr_masker :full_name,
+                  column_names: %i[first_name last_name],
+                  masker: ->(**_) { "(first) (last)" }
+
+      def full_name
+        [first_name, last_name].join(" ")
+      end
+
+      def full_name=(value)
+        self.first_name = value.split(" ")[-2]
+        self.last_name = value.split(" ")[-1]
+      end
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      change { han.first_name }.to("(first)") &
+      change { han.last_name }.to("(last)") &
+      preserve { han.email } &
+      preserve { han.avatar }
+    )
+
+    expect { luke.reload }.to(
+      change { luke.first_name }.to("(first)") &
+      change { luke.last_name }.to("(last)") &
+      preserve { luke.email } &
+      preserve { luke.avatar }
+    )
+  end
+
   example "It is disabled in production environment" do
     allow(Rails).to receive(:env) { "production".inquiry }
 
@@ -267,7 +358,7 @@ RSpec.shared_examples "Attr Masker gem feature specs" do
     User.class_eval do
       attr_masker :last_name
 
-      default_scope ->() { where(last_name: "Solo") }
+      default_scope -> { where(last_name: "Solo") }
     end
 
     expect { run_rake_task }.not_to(change { User.unscoped.count })
@@ -283,3 +374,5 @@ RSpec.shared_examples "Attr Masker gem feature specs" do
     Rake::Task["db:mask"].execute
   end
 end
+
+# rubocop:enable Style/TrailingCommaInArguments

data/spec/spec_helper.rb

@@ -1,10 +1,35 @@
 # (c) 2017 Ribose Inc.
 #
 
+# Warnings gem must be added to Gemfile or otherwise loaded in order to have
+# the following configuration in effect.
+#
+# TODO: Add Warning to gemspec or Gemfile after dropping support for Ruby 2.3.
+begin
+  require "warning"
+
+  # Deduplicate warnings
+  Warning.dedup
+
+  # Ignore all warnings in Gem dependencies
+  Gem.path.each do |path|
+    Warning.ignore(//, path)
+  end
+rescue LoadError
+end
+
+require "simplecov"
+SimpleCov.start
+
+if ENV.key?("CI")
+  require "codecov"
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
 require "bundler"
 Bundler.require :default, :development
 
-Dir[File.expand_path "../support/**/*.rb", __FILE__].sort.each { |f| require f }
+Dir[File.expand_path "support/**/*.rb", __dir__].sort.each { |f| require f }
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure

data/spec/support/00_control_constants.rb

@@ -0,0 +1,2 @@
+WITHOUT_ACTIVE_RECORD = ENV.fetch("WITHOUT", "") =~ /\bactiverecord\b/
+WITHOUT_MONGOID = ENV.fetch("WITHOUT", "") =~ /\bmongoid\b/

data/spec/support/{00_mongoid_env.rb → 10_mongoid_env.rb}

@@ -6,4 +6,4 @@
 ENV["MONGOID_SPEC_HOST"] ||= "127.0.0.1"
 ENV["MONGOID_SPEC_PORT"] ||= "27017"
 
-require "mongoid" unless ENV["WITHOUT_MONGOID"]
+require "mongoid" unless WITHOUT_MONGOID

data/spec/support/20_combustion.rb

@@ -3,8 +3,8 @@
 
 Combustion.path = "spec/dummy"
 
-if ENV["WITHOUT_ACTIVE_RECORD"].nil?
-  Combustion.initialize! :active_record
-else
+if WITHOUT_ACTIVE_RECORD
   Combustion.initialize!
+else
+  Combustion.initialize! :active_record
 end

data/spec/support/db_cleaner.rb

@@ -2,14 +2,16 @@ require "database_cleaner"
 
 RSpec.configure do |config|
   config.before(:suite) do
-    unless ENV["WITHOUT_ACTIVE_RECORD"]
+    unless WITHOUT_ACTIVE_RECORD
+      require "database_cleaner-active_record"
       DatabaseCleaner[:active_record].strategy = :truncation
     end
 
     # Since models are defined dynamically in specs, Database Cleaner is unable
     # to list them and to determine collection names to be cleaned.
     # Therefore, they are specified explicitly here.
-    unless ENV["WITHOUT_MONGOID"]
+    unless WITHOUT_MONGOID
+      require "database_cleaner-mongoid"
       DatabaseCleaner[:mongoid].strategy = :truncation, { only: "users" }
     end
 

data/spec/support/rake.rb

@@ -3,4 +3,4 @@
 
 require "rake"
 Rails.application.load_tasks
-load File.expand_path("../../../lib/tasks/db.rake", __FILE__)
+load File.expand_path("../../lib/tasks/db.rake", __dir__)

data/spec/unit/attribute_spec.rb

@@ -16,17 +16,17 @@ RSpec.describe AttrMasker::Attribute do
     end
   end
 
-  describe "#column_name" do
-    subject { receiver.method :column_name }
+  describe "#column_names" do
+    subject { receiver.method :column_names }
     let(:receiver) { described_class.new :some_attr, :some_model, options }
     let(:options) { {} }
 
-    it "defaults to attribute name" do
-      expect(subject.call).to eq(:some_attr)
+    it "defaults to array containing attribute name only" do
+      expect(subject.call).to contain_exactly(:some_attr)
     end
 
-    it "can be overriden with :column_name option" do
-      options[:column_name] = :some_column
+    it "can be overriden with :column_names option" do
+      options[:column_names] = :some_column
       expect(subject.call).to eq(:some_column)
     end
   end
@@ -55,6 +55,88 @@ RSpec.describe AttrMasker::Attribute do
     end
   end
 
+  describe "mask" do
+    subject { described_class.instance_method :mask }
+    let(:receiver) { described_class.new :some_attr, :some_model, options }
+    let(:model_instance) { Struct.new(:some_attr).new("value") }
+    let(:options) { { masker: masker } }
+    let(:masker) { ->(**) { "masked_value" } }
+
+    it "takes the instance.options[:masker] and calls it" do
+      expect(masker).to receive(:call)
+      subject.bind(receiver).call(model_instance)
+    end
+
+    it "passes the unmarshalled attribute value to the masker" do
+      expect(receiver).to receive(:unmarshal_data).
+        with("value").and_return("unmarshalled_value")
+      expect(masker).to receive(:call).
+        with(hash_including(value: "unmarshalled_value"))
+      subject.bind(receiver).call(model_instance)
+    end
+
+    it "passes the model instance to the masker" do
+      expect(masker).to receive(:call).
+        with(hash_including(model: model_instance))
+      subject.bind(receiver).call(model_instance)
+    end
+
+    it "passes the attribute name to the masker" do
+      expect(masker).to receive(:call).
+        with(hash_including(attribute_name: :some_attr))
+      subject.bind(receiver).call(model_instance)
+    end
+
+    it "passes the masking options to the masker" do
+      expect(masker).to receive(:call).
+        with(hash_including(masking_options: options))
+      subject.bind(receiver).call(model_instance)
+    end
+
+    it "marshals the masked value, and assigns it to the attribute" do
+      expect(receiver).to receive(:marshal_data).
+        with("masked_value").and_return("marshalled_masked_value")
+      subject.bind(receiver).call(model_instance)
+      expect(model_instance.some_attr).to eq("marshalled_masked_value")
+    end
+  end
+
+  describe "#masked_attributes_new_values" do
+    subject { receiver.method :masked_attributes_new_values }
+    let(:receiver) { described_class.new :some_attr, :some_model, options }
+    let(:options) { {} }
+    let(:model_instance) { double } # Struct.new(:some_attr, :other_attr) }
+    let(:changes) { { some_attr: [nil, "new"], other_attr: [nil, "other"] } }
+
+    before { allow(model_instance).to receive(:changes).and_return(changes) }
+
+    # rubocop:disable Style/BracesAroundHashParameters
+    # We are comparing hashes here, and we want hash literals
+    it "returns a hash of required database updates which include masked field \
+        change, but ignores other attribute changes" do
+      expect(subject.(model_instance)).to eq({ some_attr: "new" })
+    end
+
+    it "returns an emtpy hash for an unchanged object" do
+      changes.clear
+      expect(subject.(model_instance)).to eq({})
+    end
+
+    it "allows overriding column/field name to be updated with column_name \
+      option" do
+      options[:column_names] = %i[other_attr]
+      expect(subject.(model_instance)).to eq({ other_attr: "other" })
+    end
+
+    it "allows specifying more than one column/field name to be updated \
+      with column_name option" do
+      options[:column_names] = %i[some_attr other_attr]
+      expect(subject.(model_instance)).
+        to eq({ some_attr: "new", other_attr: "other" })
+    end
+    # rubocop:enable Style/BracesAroundHashParameters
+  end
+
   describe "#evaluate_option" do
     subject { receiver.method :evaluate_option }
     let(:receiver) { described_class.new :some_attr, model_instance, options }