Better test organization (#36)

Author: hopsoft

lib/universalid/extensions/active_record/base_unpacker.rb

@@ -45,14 +45,18 @@ def assign_descendants(record, attributes)
 
           new_models = models.select(&:new_record?)
           models -= new_models
+          association_collection = record.public_send(name)
 
           # restore persisted models
           # NOTE: ActiveRecord is smart enough to not re-create or re-add
           #       existing records for has_many associations
           record.public_send :"#{name}=", models if models.any?
 
           # restore new unsaved models
-          record.public_send(name).target.concat new_models if new_models.any?
+          association_collection.target.concat new_models if new_models.any?
+
+          # mark association relation as loaded
+          association_collection.proxy_association.instance_variable_set :@loaded, true
         end
       end
     end

lib/universalid/message_pack_types.rb

@@ -3,19 +3,19 @@
 # NOTE: MessagePack scans registered type in linear order and first match wins
 
 # scalars
-require_relative "message_pack_types/ruby/scalars/bigdecimal"
-require_relative "message_pack_types/ruby/scalars/complex"
-require_relative "message_pack_types/ruby/scalars/rational"
-require_relative "message_pack_types/ruby/scalars/date_time"
-require_relative "message_pack_types/ruby/scalars/date"
-require_relative "message_pack_types/ruby/scalars/range"
-require_relative "message_pack_types/ruby/scalars/regexp"
+require_relative "message_pack_types/scalars/bigdecimal"
+require_relative "message_pack_types/scalars/complex"
+require_relative "message_pack_types/scalars/rational"
+require_relative "message_pack_types/scalars/date_time"
+require_relative "message_pack_types/scalars/date"
+require_relative "message_pack_types/scalars/range"
+require_relative "message_pack_types/scalars/regexp"
 
 # composites
-require_relative "message_pack_types/ruby/composites/module"
-require_relative "message_pack_types/ruby/composites/open_struct"
-require_relative "message_pack_types/ruby/composites/struct"
-require_relative "message_pack_types/ruby/composites/set"
+require_relative "message_pack_types/composites/module"
+require_relative "message_pack_types/composites/open_struct"
+require_relative "message_pack_types/composites/struct"
+require_relative "message_pack_types/composites/set"
 
 # extensions
 Dir["#{__dir__}/extensions/**/*.rb"].sort.each { |f| require f }

lib/universalid/message_pack_types/ruby/composites/module.rb lib/universalid/message_pack_types/composites/module.rb

@@ -11,7 +11,8 @@
   unpacker: ->(unpacker) do
     class_name = unpacker.read
     hash = unpacker.read
-    klass = Object.const_get(class_name) if Object.const_defined?(class_name)
+    klass = Object.const_get(class_name) if class_name && Object.const_defined?(class_name)
+    klass ||= Struct.new(*hash.keys)
 
     if klass
       # shenanigans to support ::Ruby 3.0.X and 3.1.X

lib/universalid/message_pack_types/ruby/composites/open_struct.rb lib/universalid/message_pack_types/composites/open_struct.rb

@@ -9,6 +9,7 @@ def self.included(klass)
     klass.define_singleton_method(:foundry) { @foundry ||= ActiveRecordForge::Foundry.new(self) }
     klass.define_singleton_method(:forge) { |*args, **kwargs| foundry.forge(*args, **kwargs) }
     klass.define_singleton_method(:forge!) { |*args, **kwargs| foundry.forge!(*args, **kwargs) }
+    klass.define_singleton_method(:generate_attributes) { foundry.generate_attributes }
   end
 
   class Foundry
@@ -43,30 +44,6 @@ def forge!(...)
       forge(...).tap { |forged| forged.is_a?(Array) ? forged.each(&:save!) : forged.save! }
     end
 
-    private
-
-    def_delegators :klass, :columns, :column_names, :primary_key, :reflections, :reflect_on_all_associations
-
-    def association(name)
-      associations.find { |a| a.name.to_s == name.to_s }
-    end
-
-    def associations(macro: nil)
-      list = reflect_on_all_associations
-      list = list.select { |a| a.macro == macro.to_sym } if macro
-      list
-    end
-
-    def association_names(macro: nil)
-      associations(macro: macro).map { |a| a.name.to_s }
-    end
-
-    def foreign_key_column_names
-      reflections.each_with_object([]) do |(name, reflection), memo|
-        memo << reflection.foreign_key if reflection.macro == :belongs_to
-      end
-    end
-
     def generate_attributes
       attributes = {}
 
@@ -103,5 +80,29 @@ def generate_attributes
 
       attributes.with_indifferent_access
     end
+
+    private
+
+    def_delegators :klass, :columns, :column_names, :primary_key, :reflections, :reflect_on_all_associations
+
+    def association(name)
+      associations.find { |a| a.name.to_s == name.to_s }
+    end
+
+    def associations(macro: nil)
+      list = reflect_on_all_associations
+      list = list.select { |a| a.macro == macro.to_sym } if macro
+      list
+    end
+
+    def association_names(macro: nil)
+      associations(macro: macro).map { |a| a.name.to_s }
+    end
+
+    def foreign_key_column_names
+      reflections.each_with_object([]) do |(name, reflection), memo|
+        memo << reflection.foreign_key if reflection.macro == :belongs_to
+      end
+    end
   end
 end

lib/universalid/message_pack_types/ruby/composites/set.rb lib/universalid/message_pack_types/composites/set.rb

@@ -3,4 +3,8 @@
 class Campaign < ApplicationRecord
   has_many :emails, dependent: :destroy
   accepts_nested_attributes_for :emails
+
+  scope :email_subjects_like, ->(value) do
+    where id: Email.subject_like(value).select(:campaign_id)
+  end
 end

lib/universalid/message_pack_types/ruby/composites/struct.rb lib/universalid/message_pack_types/composites/struct.rb

@@ -4,4 +4,8 @@ class Email < ApplicationRecord
   belongs_to :campaign
   has_many :attachments, dependent: :destroy
   accepts_nested_attributes_for :attachments
+
+  scope :subject_like, ->(subject) do
+    where(arel_table[:subject].matches("%#{subject}%"))
+  end
 end

lib/universalid/message_pack_types/ruby/scalars/bigdecimal.rb lib/universalid/message_pack_types/scalars/bigdecimal.rb

@@ -48,4 +48,5 @@
 require_relative "models/attachment"
 
 # Seed some data
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
 Campaign.forge! 10, emails: 5, attachments: 3

lib/universalid/message_pack_types/ruby/scalars/complex.rb lib/universalid/message_pack_types/scalars/complex.rb

@@ -19,26 +19,30 @@
 Minitest.parallel_executor = Minitest::Parallel::Executor.new([Etc.nprocessors, 1].max) # thread count
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 
+# TODO: Get coverage working
 # Coverage setup
-SimpleCov.start do
-  project_name "UniversalID"
-  add_filter [
-    "lib/universalid/message_pack/types", # coverage doesn't work on these
-    "lib/universalid/message_pack_types", # coverage not needed
-    "lib/universalid/refinements", # coverage doesn't work on these
-    "test" # coverage not wanted
-  ]
-end
+# SimpleCov.start do
+#   project_name "UniversalID"
+#   add_filter [
+#     "lib/universalid/message_pack_types", # ....................coverage doesn't work on these
+#     "lib/universalid/extensions/**/*message_pack_type.rb", # ...coverage doesn't work on these
+#     "lib/universalid/refinements", # ...........................coverage doesn't work on these
+#     "test" # ...................................................coverage not wanted
+#   ]
+# end
 
 require "universalid"
 
 # Minimal subset of Rails tooling for testing purposes
 require_relative "rails_kit/setup"
 
+module UniversalID::MessagePack; end
+
 class Minitest::Test
   alias_method :original_run, :run
 
   def run
+    Campaign.destroy_all
     result = nil
     time = Benchmark.measure { result = original_run }
     time = time.real.round(5)
@@ -58,4 +62,100 @@ def run
 
     result
   end
+
+  def load_has_many(record, depth: 0)
+    count = 0
+    with_has_many record do |relation|
+      next unless count < depth
+      count += 1
+      relation.load
+      relation.each { |rec| load_has_many(rec, depth: depth - 1) }
+    end
+  end
+
+  def with_has_many(record)
+    record.class.reflect_on_all_associations.each do |association|
+      next unless association.is_a?(ActiveRecord::Reflection::HasManyReflection)
+      relation = record.public_send(association.name)
+      yield relation
+    end
+  end
+
+  def assert_has_many_loaded(record, depth: 1)
+    count = 0
+    with_has_many record do |relation|
+      next unless count <= depth
+      count += 1
+      assert relation.loaded?
+      relation.each { |rec| assert_has_many_loaded(rec, depth: depth - 1) }
+    end
+  end
+
+  def refute_has_many_loaded(record)
+    with_has_many record do |relation|
+      refute relation.loaded?
+    end
+  end
+
+  def assert_has_many(expected, actual)
+    assert_equal expected.size, actual.size
+    expected.each_with_index { |record, i| assert_record record, actual[i] }
+  end
+
+  def assert_record(expected, actual)
+    assert_equal expected.attributes, actual.attributes
+    assert_equal expected.persisted?, actual.persisted?
+    assert_equal expected.changed?, actual.changed?
+
+    with_has_many expected do |relation|
+      expected_relation = relation
+      actual_relation = actual.public_send(expected_relation.proxy_association.reflection.name)
+      assert_equal expected_relation.size, actual_relation.size
+      next unless expected_relation.loaded?
+      next unless actual_relation.loaded?
+
+      expected_relation.each_with_index do |record, i|
+        assert_record record, actual_relation[i]
+      end
+    end
+  end
+
+  def self.scalars
+    {
+      bigdecimal: BigDecimal("123.45"),
+      complex: Complex(1, 2),
+      date: Date.today,
+      datetime: DateTime.now,
+      false_class: false,
+      float: 123.45,
+      integer: 123,
+      nil_class: nil,
+      range: 1..100,
+      rational: Rational(3, 4),
+      regexp: /abc/,
+      string: "hello",
+      symbol: :symbol,
+      time: Time.now,
+      true_class: true
+    }
+  end
+
+  def scalars
+    self.class.scalars
+  end
+
+  def time_with_zones
+    month = ActiveSupport::TimeZone["UTC"].now.beginning_of_year
+
+    Timecop.freeze time do
+      11.times do |i|
+        ActiveSupport::TimeZone.all.each do |time_zone|
+          time = month.in_time_zone(time_zone).advance(days: rand(1..28), minutes: rand(1..59))
+          yield time
+        end
+
+        month.advance months: 1
+      end
+    end
+  end
 end