attr_masker 0.1.0 → 0.3.1

data/lib/attr_masker/performer.rb

@@ -1,67 +1,106 @@
 # (c) 2017 Ribose Inc.
 #
+
 module AttrMasker
   module Performer
-    class ActiveRecord
+    class Base
       def mask
-        unless defined? ::ActiveRecord
-          raise AttrMasker::Error, "ActiveRecord undefined. Nothing to do!"
-        end
-
         # Do not want production environment to be masked!
         #
         if Rails.env.production?
-          raise AttrMasker::Error, "Attempted to run in production environment."
+          unless ENV["FORCE_MASK"]
+            msg = "Attempted to run in production environment."
+            raise AttrMasker::Error, msg
+          end
         end
 
         all_models.each do |klass|
           next if klass.masker_attributes.empty?
+
           mask_class(klass)
         end
       end
 
       private
 
+      # Mask all objects of a class in batches to not run out of memory!
+      #--
+      # rubocop:todo Metrics/MethodLength
       def mask_class(klass)
         progressbar_for_model(klass) do |bar|
-          klass.all.each do |model|
-            mask_object model
-            bar.increment
+          if klass.all.unscoped.respond_to?(:find_each)
+            klass.all.unscoped.find_each(batch_size: 1000) do |model|
+              mask_object model
+              bar.increment
+            end
+          else
+            klass.all.unscoped.each do |model|
+              mask_object model
+              bar.increment
+            end
           end
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       # For each masker attribute, mask it, and save it!
       #
       def mask_object(instance)
         klass = instance.class
 
-        updates = klass.masker_attributes.reduce({}) do |acc, masker_attr|
-          attr_name = masker_attr[0]
-          column_name = masker_attr[1][:column_name] || attr_name
-          masker_value = instance.mask(attr_name)
-          acc.merge!(column_name => masker_value)
+        updates = klass.masker_attributes.values.reduce({}) do |acc, attribute|
+          next acc unless attribute.should_mask?(instance)
+
+          attribute.mask(instance)
+          acc.merge! attribute.masked_attributes_new_values(instance)
         end
 
-        klass.all.update(instance.id, updates)
+        make_update instance, updates unless updates.empty?
       end
 
       def progressbar_for_model(klass)
         bar = ProgressBar.create(
           title: klass.name,
-          total: klass.count,
+          total: klass.unscoped.count,
           throttle_rate: 0.1,
-          format: %q[%t %c/%C (%j%%) %B %E],
+          format: "%t %c/%C (%j%%) %B %E",
         )
 
         yield bar
       ensure
         bar.finish
       end
+    end
+
+    class ActiveRecord < Base
+      def dependencies_available?
+        defined? ::ActiveRecord
+      end
 
       def all_models
         ::ActiveRecord::Base.descendants.select(&:table_exists?)
       end
+
+      #--
+      # rubocop:disable Rails/SkipsModelValidations
+      def make_update(instance, updates)
+        instance.class.all.unscoped.where(id: instance.id).update_all(updates)
+      end
+      # rubocop:enable Rails/SkipsModelValidations
+    end
+
+    class Mongoid < Base
+      def dependencies_available?
+        defined? ::Mongoid
+      end
+
+      def all_models
+        ::Mongoid.models
+      end
+
+      def make_update(instance, updates)
+        instance.class.all.unscoped.where(id: instance.id).update(updates)
+      end
     end
   end
 end

data/lib/attr_masker/version.rb

@@ -2,20 +2,5 @@
 #
 
 module AttrMasker
-  # Contains information about this gem's version
-  module Version
-    MAJOR = 0
-    MINOR = 1
-    PATCH = 0
-
-    # 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.1".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"
@@ -16,6 +13,18 @@ namespace :db do
   # http://stackoverflow.com/questions/14163938/activerecordconnectionnotestablished-within-a-rake-task
   #
   task :mask => :environment do
-    AttrMasker::Performer::ActiveRecord.new.mask
+    Rails.application.eager_load!
+
+    config_file = Rails.root.join("config", "attr_masker.rb").to_s
+    require config_file if File.file?(config_file)
+
+    performers = AttrMasker::Performer::Base.descendants.map(&:new)
+    performers.select!(&:dependencies_available?)
+
+    if performers.empty?
+      raise AttrMasker::Error, "No supported database!"
+    end
+
+    performers.each(&:mask)
   end
 end

data/spec/dummy/app/models/non_persisted_model.rb

@@ -0,0 +1,2 @@
+class NonPersistedModel
+end

data/spec/dummy/config/attr_masker.rb

@@ -0,0 +1 @@
+$CONFIG_LOADED_AT = Time.now

data/spec/dummy/config/mongoid.yml

@@ -0,0 +1,33 @@
+# Heavily based on Mongoid's test suite
+# https://github.com/mongodb/mongoid/blob/v6.2.0/spec/config/mongoid.yml
+test:
+  clients:
+    default:
+      database: attr_masker_test
+      hosts:
+        - <%=ENV["MONGOID_SPEC_HOST"]%>:<%=ENV["MONGOID_SPEC_PORT"]%>
+      options:
+        auth_source: "admin"
+        read:
+          mode: :primary_preferred
+          tag_sets:
+            - use: web
+        max_pool_size: 1
+    reports:
+      database: reports
+      hosts:
+        - <%=ENV["MONGOID_SPEC_HOST"]%>:<%=ENV["MONGOID_SPEC_PORT"]%>
+      options:
+        user: "mongoid-user"
+        password: "password"
+        auth_source: "admin"
+  options:
+    include_root_in_json: false
+    include_type_for_serialization: false
+    preload_models: false
+    scope_overwrite_exception: false
+    raise_not_found_error: true
+    use_activesupport_time_zone: true
+    use_utc: false
+    log_level: :warn
+    app_name: 'testing'

data/spec/dummy/config/routes.rb

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

data/spec/dummy/db/schema.rb

@@ -3,6 +3,7 @@ ActiveRecord::Schema.define do
     t.string :first_name
     t.string :last_name
     t.string :email
+    t.text :avatar
     t.timestamps null: false
   end
 end

data/spec/features/active_record_spec.rb

@@ -0,0 +1,97 @@
+# (c) 2017 Ribose Inc.
+#
+
+require_relative "shared_examples"
+
+RSpec.describe "Attr Masker gem", :suppress_progressbar do
+  context "when used with ActiveRecord" do
+    before do
+      if WITHOUT_ACTIVE_RECORD
+        expect(defined?(::ActiveRecord)).to be(nil)
+        skip "Active Record specs disabled with WITHOUT=activerecord shell " \
+          "variable"
+      end
+    end
+
+    # 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

@@ -0,0 +1,36 @@
+# (c) 2017 Ribose Inc.
+#
+
+require_relative "shared_examples"
+
+RSpec.describe "Attr Masker gem", :suppress_progressbar do
+  context "when used with Mongoid" do
+    before do
+      if WITHOUT_MONGOID
+        expect(defined?(::Mongoid)).to be(nil)
+        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) if defined?(::Mongoid)
+    end
+
+    let(:user_class_definition) do
+      Class.new do
+        include Mongoid::Document
+        include Mongoid::Timestamps
+
+        store_in collection: "users"
+
+        field :first_name
+        field :last_name
+        field :email
+        field :avatar
+      end
+    end
+
+    include_examples "Attr Masker gem feature specs"
+  end
+end

data/spec/features/shared_examples.rb

@@ -0,0 +1,382 @@
+# (c) 2017 Ribose Inc.
+#
+
+# No point in ensuring a trailing comma in multiline argument lists here.
+# rubocop:disable Style/TrailingCommaInArguments
+
+require "spec_helper"
+
+RSpec.shared_examples "Attr Masker gem feature specs" do
+  before do
+    stub_const "User", user_class_definition
+
+    User.class_eval do
+      def jedi?
+        email.ends_with? "@jedi.example.test"
+      end
+    end
+  end
+
+  let!(:han) do
+    User.create!(
+      first_name: "Han",
+      last_name: "Solo",
+      email: "han@example.test",
+      avatar: Marshal.dump("Millenium Falcon photo"),
+    )
+  end
+
+  let!(:luke) do
+    User.create!(
+      first_name: "Luke",
+      last_name: "Skywalker",
+      email: "luke@jedi.example.test",
+      avatar: Marshal.dump("photo with a light saber"),
+    )
+  end
+
+  example "Masking a single text attribute with default options" do
+    User.class_eval do
+      attr_masker :last_name
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    [han, luke].each do |record|
+      expect { record.reload }.to(
+        change { record.last_name }.to("(redacted)") &
+        preserve { record.first_name } &
+        preserve { record.email }
+      )
+    end
+  end
+
+  example "Specifying multiple attributes in an attr_masker declaration" do
+    User.class_eval do
+      attr_masker :first_name, :last_name
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    [han, luke].each do |record|
+      expect { record.reload }.to(
+        change { record.first_name }.to("(redacted)") &
+        change { record.last_name }.to("(redacted)") &
+        preserve { record.email }
+      )
+    end
+  end
+
+  example "Skipping some records when a symbol is passed to :if option" do
+    User.class_eval do
+      attr_masker :first_name, :last_name, if: :jedi?
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      preserve { han.first_name } &
+      preserve { han.last_name } &
+      preserve { han.email }
+    )
+
+    expect { luke.reload }.to(
+      change { luke.first_name }.to("(redacted)") &
+      change { luke.last_name }.to("(redacted)") &
+      preserve { luke.email }
+    )
+  end
+
+  example "Skipping some records when a lambda is passed to :if option" do
+    User.class_eval do
+      attr_masker :first_name, :last_name, if: ->(r) { r.jedi? }
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      preserve { han.first_name } &
+      preserve { han.last_name } &
+      preserve { han.email }
+    )
+
+    expect { luke.reload }.to(
+      change { luke.first_name }.to("(redacted)") &
+      change { luke.last_name }.to("(redacted)") &
+      preserve { luke.email }
+    )
+  end
+
+  example "Skipping some records when a symbol is passed to :unless option" do
+    User.class_eval do
+      attr_masker :first_name, :last_name, unless: :jedi?
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      change { han.first_name }.to("(redacted)") &
+      change { han.last_name }.to("(redacted)") &
+      preserve { han.email }
+    )
+
+    expect { luke.reload }.to(
+      preserve { luke.first_name } &
+      preserve { luke.last_name } &
+      preserve { luke.email }
+    )
+  end
+
+  example "Skipping some records when a lambda is passed to :unless option" do
+    User.class_eval do
+      attr_masker :first_name, :last_name, unless: ->(r) { r.jedi? }
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      change { han.first_name }.to("(redacted)") &
+      change { han.last_name }.to("(redacted)") &
+      preserve { han.email }
+    )
+
+    expect { luke.reload }.to(
+      preserve { luke.first_name } &
+      preserve { luke.last_name } &
+      preserve { luke.email }
+    )
+  end
+
+  example "Using a custom masker" do
+    reverse_masker = ->(value:, **_) do
+      value.reverse
+    end
+
+    upcase_masker = ->(value:, **_) do
+      value.upcase
+    end
+
+    User.class_eval do
+      attr_masker :first_name, masker: reverse_masker
+      attr_masker :last_name, masker: upcase_masker
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      change { han.first_name }.to("naH") &
+      change { han.last_name }.to("SOLO") &
+      preserve { han.email }
+    )
+
+    expect { luke.reload }.to(
+      change { luke.first_name }.to("ekuL") &
+      change { luke.last_name }.to("SKYWALKER") &
+      preserve { luke.email }
+    )
+  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
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      preserve { han.first_name } &
+      preserve { han.last_name } &
+      preserve { han.email } &
+      change { han.avatar }
+    )
+
+    expect(han.avatar).to eq(Marshal.dump("(redacted)"))
+
+    expect { luke.reload }.to(
+      preserve { luke.first_name } &
+      preserve { luke.last_name } &
+      preserve { luke.email } &
+      change { luke.avatar }
+    )
+
+    expect(luke.avatar).to eq(Marshal.dump("(redacted)"))
+  end
+
+  example "Masking a marshalled attribute with a custom marshaller" do
+    module CustomMarshal
+      module_function
+
+      def load_marshalled(*args)
+        Marshal.load(*args) # rubocop:disable Security/MarshalLoad
+      end
+
+      def dump_json(*args)
+        JSON.dump(json: args)
+      end
+    end
+
+    User.class_eval do
+      attr_masker(
+        :avatar,
+        marshal: true,
+        marshaler: CustomMarshal,
+        load_method: :load_marshalled,
+        dump_method: :dump_json,
+      )
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      preserve { han.first_name } &
+      preserve { han.last_name } &
+      preserve { han.email } &
+      change { han.avatar }
+    )
+
+    expect(han.avatar).to eq({ json: ["(redacted)"] }.to_json)
+
+    expect { luke.reload }.to(
+      preserve { luke.first_name } &
+      preserve { luke.last_name } &
+      preserve { luke.email } &
+      change { luke.avatar }
+    )
+
+    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 }
+
+    User.class_eval do
+      attr_masker :last_name
+    end
+
+    expect { run_rake_task }.to(
+      preserve { User.count } &
+      raise_exception(AttrMasker::Error)
+    )
+
+    [han, luke].each do |record|
+      expect { record.reload }.not_to(change { record })
+    end
+  end
+
+  example "It masks records disregarding default scope" do
+    User.class_eval do
+      attr_masker :last_name
+
+      default_scope -> { where(last_name: "Solo") }
+    end
+
+    expect { run_rake_task }.not_to(change { User.unscoped.count })
+
+    [han, luke].each do |record|
+      expect { record.reload }.to(
+        change { record.last_name }.to("(redacted)")
+      )
+    end
+  end
+
+  example "It loads configuration file", :force_config_file_reload do
+    expect { run_rake_task }.to change { $CONFIG_LOADED_AT }
+  end
+
+  def run_rake_task
+    Rake::Task["db:mask"].execute
+  end
+end
+
+# rubocop:enable Style/TrailingCommaInArguments