joblin 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e87b736e32f7b502592a72a08da939d0a2ef95302e96b491f8d258bcdafcfab1
-  data.tar.gz: 97df4d3166bb653f6362d11b600c91a805c4cdc368091690265ae2c686c136d2
+  metadata.gz: 2e541ee5d08b606fc0acf25a8e2aae3fb45a24d430befdfaadefd01b12e3c05c
+  data.tar.gz: 901c664b71c3f615d337f0c9a41f52d95153af1234632a4b9dd4d8d527c87afb
 SHA512:
-  metadata.gz: 352592cc3733c55879d51ac118c242184140d174f7873b632a6695a7536a641493a3515377a5b838bc1d27e22c9cb5092517b8d4096098b96cfc124561ea558e
-  data.tar.gz: a818e8053990c09106eb47a21ca8bd70aeea51a21a3d21f8a14de54bd6f03e7aa4931913d145b90db8a8c3907eb1bb78ae0dd4f25cc3e07450d120bead87cde8
+  metadata.gz: 9baf25436897e081d908f8f77873b9409b7b1fde6c47925a4b4309875ba9bbc1445ed3ec8ec2f3591a395c90c47f98854d84b5cf5ee2ce01ce519dd9aa16c43c
+  data.tar.gz: 8f0b5f1a644913410633f52227d26c2eabfb1770aaf3452b511be8409f0245c605bfa803093bef8783811e2b86d710d5b1fa3e097d7a1d323e94efd121050cc9

data/lib/joblin/batching/context_hash.rb

@@ -107,7 +107,7 @@ module Joblin::Batching
     private
 
     def get_parent_hash(bid)
-      resolve_hash(get_parent_bid(bid)).freeze
+      resolve_hash(get_parent_bid(bid))
     end
 
     def get_parent_bid(bid)
@@ -153,11 +153,27 @@ module Joblin::Batching
     end
 
     def load_all
-      resolve_hash(@bid_stack[0]).freeze
+      resolve_hash(@bid_stack[0])
       while @bid_stack[0].present?
         get_parent_hash(@bid_stack[0])
       end
+      freeze_inherited!
       @hash_map
     end
+
+    # Every hash but `local` is inherited: #[]=, #delete and #save! only ever touch `local`, so a
+    # write to any other hash would be silently dropped rather than persisted. Freeze those to
+    # surface the mistake.
+    #
+    # `local` itself is deliberately left as-is - `resolve_hash` has already frozen it unless the
+    # owning Batch set allow_context_changes, and re-freezing it here would break writes on an
+    # editable Batch as a side effect of merely _reading_ the context.
+    def freeze_inherited!
+      writable_bid = local_bid
+      @hash_map.each do |bid, hash|
+        next if hash.nil? || bid == writable_bid
+        hash.freeze
+      end
+    end
   end
 end

data/lib/joblin/version.rb

@@ -1,3 +1,3 @@
 module Joblin
-  VERSION = "0.2.0".freeze
+  VERSION = "0.2.1".freeze
 end

data/spec/batching/context_hash_spec.rb

@@ -40,6 +40,92 @@ RSpec.describe Joblin::Batching::ContextHash do
     Sidekiq::Worker.drain_all
   end
 
+  describe 'writability of a resolved context' do
+    # A Batch that both reads and writes its own context - the ReportSyncTask pattern. Reading the
+    # context as a Hash (present?, blank?, each, to_h, ... all route through #flatten) used to
+    # freeze the underlying hash and defeat allow_context_changes for the rest of the job.
+    def editable_batch(context)
+      Joblin::Batching::Batch.new.tap do |b|
+        b.allow_context_changes = true
+        b.context = context
+        b.jobs { }
+      end
+    end
+
+    it 'stays writable after the context is read as a Hash' do
+      batch = editable_batch(report_class: 'SomeReport')
+      ctx = Joblin::Batching::Batch.new(batch.bid).context
+
+      expect(ctx.present?).to eq(true)
+      expect { ctx[:report_attempt] = 1 }.not_to raise_error
+      expect(ctx[:report_attempt]).to eq(1)
+    end
+
+    it 'persists writes made after the context was read' do
+      batch = editable_batch(report_class: 'SomeReport')
+      loaded = Joblin::Batching::Batch.new(batch.bid)
+      loaded.context.to_h
+      loaded.context[:report_id] = 'some_report/1'
+      loaded.save_context_changes
+
+      expect(Joblin::Batching::Batch.new(batch.bid).context[:report_id]).to eq('some_report/1')
+    end
+
+    it 'leaves a non-editable context frozen' do
+      batch = Joblin::Batching::Batch.new
+      batch.context = { report_class: 'SomeReport' }
+      batch.jobs { }
+      ctx = Joblin::Batching::Batch.new(batch.bid).context
+      ctx.present?
+
+      expect { ctx[:report_attempt] = 1 }.to raise_error(FrozenError)
+    end
+
+    # `local` is "the nearest ancestor that actually has a context", so for a context-less Batch
+    # the writable hash belongs to an ancestor - #save! writes it back to that ancestor's key.
+    it 'stays writable when the context lives on an ancestor Batch' do
+      parent = editable_batch(sync_batch_id: 7)
+      child_bid = nil
+      parent.jobs do
+        child = Joblin::Batching::Batch.new
+        child.jobs { }
+        child_bid = child.bid
+      end
+
+      ctx = Joblin::Batching::Batch.new(child_bid).context
+      ctx.present?
+
+      expect(ctx.local_bid).to eq(parent.bid)
+      expect { ctx[:report_attempt] = 1 }.not_to raise_error
+      expect(ctx[:sync_batch_id]).to eq(7)
+    end
+
+    it 'freezes inherited contexts that writes would silently drop' do
+      grandparent = editable_batch(level: 'grandparent')
+      parent_bid = nil
+      child_bid = nil
+      grandparent.jobs do
+        parent = Joblin::Batching::Batch.new
+        parent.allow_context_changes = true
+        parent.context = { level: 'parent' }
+        parent.jobs do
+          child = Joblin::Batching::Batch.new
+          child.jobs { }
+          child_bid = child.bid
+        end
+        parent_bid = parent.bid
+      end
+
+      ctx = Joblin::Batching::Batch.new(child_bid).context
+      ctx.to_h
+      hash_map = ctx.send(:instance_variable_get, :@hash_map)
+
+      expect(ctx.local_bid).to eq(parent_bid)
+      expect(hash_map[parent_bid]).not_to be_frozen
+      expect(hash_map[grandparent.bid]).to be_frozen
+    end
+  end
+
   it 'works with a callback batch' do
     ActiveJob::Base.queue_adapter = :sidekiq
     b = Joblin::Batching::Batch.new