feat: write backup files when streaming

lib/unleash/backup_file_writer.rb

@@ -0,0 +1,21 @@
+require 'unleash/configuration'
+
+module Unleash
+  class BackupFileWriter
+    def self.save!(toggle_data)
+      Unleash.logger.debug "Will save toggles to disk now"
+
+      backup_file = Unleash.configuration.backup_file
+      backup_file_tmp = "#{backup_file}.tmp"
+
+      File.open(backup_file_tmp, "w") do |file|
+        file.write(toggle_data)
+      end
+      File.rename(backup_file_tmp, backup_file)
+    rescue StandardError => e
+      # This is not really the end of the world. Swallowing the exception.
+      Unleash.logger.error "Unable to save backup file. Exception thrown #{e.class}:'#{e}'"
+      Unleash.logger.error "stacktrace: #{e.backtrace}"
+    end
+  end
+end

lib/unleash/streaming_event_processor.rb

@@ -1,4 +1,5 @@
 require 'json'
+require 'unleash/backup_file_writer'
 
 module Unleash
   class StreamingEventProcessor
@@ -39,9 +40,10 @@ def handle_connected_event(event)
     end
 
     def handle_updated_event(event)
-      handle_delta_event(event.data)
+      # Save the updated state to backup file first, even if engine update fails
+      Unleash::BackupFileWriter.save!(event.data)
 
-      # TODO: update backup file
+      handle_delta_event(event.data)
     rescue JSON::ParserError => e
       Unleash.logger.error "Unable to parse JSON from streaming event data. Exception thrown #{e.class}: '#{e}'"
       Unleash.logger.debug "stacktrace: #{e.backtrace}"

lib/unleash/toggle_fetcher.rb

@@ -1,5 +1,6 @@
 require 'unleash/configuration'
 require 'unleash/bootstrap/handler'
+require 'unleash/backup_file_writer'
 require 'net/http'
 require 'json'
 require 'yggdrasil_engine'
@@ -54,25 +55,7 @@ def fetch
       # always synchronize with the local cache when fetching:
       update_engine_state!(response.body)
 
-      save! response.body
-    end
-
-    def save!(toggle_data)
-      Unleash.logger.debug "Will save toggles to disk now"
-
-      backup_file = Unleash.configuration.backup_file
-      backup_file_tmp = "#{backup_file}.tmp"
-
-      self.toggle_lock.synchronize do
-        File.open(backup_file_tmp, "w") do |file|
-          file.write(toggle_data)
-        end
-        File.rename(backup_file_tmp, backup_file)
-      end
-    rescue StandardError => e
-      # This is not really the end of the world. Swallowing the exception.
-      Unleash.logger.error "Unable to save backup file. Exception thrown #{e.class}:'#{e}'"
-      Unleash.logger.error "stacktrace: #{e.backtrace}"
+      Unleash::BackupFileWriter.save! response.body
     end
 
     private

spec/unleash/streaming_event_processor_spec.rb

@@ -0,0 +1,152 @@
+RSpec.describe Unleash::StreamingEventProcessor do
+  let(:engine) { YggdrasilEngine.new }
+  let(:processor) { Unleash::StreamingEventProcessor.new(engine) }
+
+  before do
+    Unleash.configure do |config|
+      config.url = 'http://streaming-test-url/'
+      config.app_name = 'streaming-my-test-app'
+    end
+
+    Unleash.logger = Unleash.configuration.logger
+  end
+
+  after do
+    WebMock.reset!
+    File.delete(Unleash.configuration.backup_file) if File.exist?(Unleash.configuration.backup_file)
+  end
+
+  describe '#process_event' do
+    let(:updated_event_data) do
+      {
+        "events": [
+          {
+            "type": "feature-updated",
+            "eventId": 2,
+            "feature": {
+              "name": "test-feature",
+              "enabled": true,
+              "strategies": [{"name": "default"}]
+            }
+          }
+        ]
+      }.to_json
+    end
+
+    let(:connected_event_data) do
+      {
+        "events": [
+          {
+            "type": "hydration",
+            "eventId": 1,
+            "features": [
+              {
+                "name": "test-feature",
+                "enabled": true,
+                "strategies": [{"name": "default"}]
+              }
+            ],
+            "segments": []
+          }
+        ]
+      }.to_json
+    end
+
+    class TestEvent
+      attr_reader :type, :data
+
+      def initialize(type, data)
+        @type = type
+        @data = data
+      end
+    end
+
+    context 'when processing unleash-updated event' do
+      let(:event) { TestEvent.new('unleash-updated', updated_event_data) }
+
+      it 'creates a backup file with toggle data' do
+        processor.process_event(event)
+
+        backup_file = Unleash.configuration.backup_file
+        expect(File.exist?(backup_file)).to eq(true)
+
+        content = File.read(backup_file)
+        expect(content).to eq(updated_event_data)
+
+        parsed = JSON.parse(content)
+        expect(parsed).to include('events')
+        expect(parsed['events'].first).to include('feature')
+        expect(parsed['events'].first['feature']['name']).to eq('test-feature')
+      end
+
+      it 'updates the engine state' do
+        processor.process_event(event)
+
+        expect(engine.enabled?('test-feature', {})).to eq(true)
+      end
+    end
+
+    context 'when processing unleash-connected event' do
+      let(:event) { TestEvent.new('unleash-connected', connected_event_data) }
+
+      it 'creates a backup file with toggle data' do
+        processor.process_event(event)
+
+        backup_file = Unleash.configuration.backup_file
+        expect(File.exist?(backup_file)).to eq(true)
+
+        content = File.read(backup_file)
+        expect(content).to eq(connected_event_data)
+
+        parsed = JSON.parse(content)
+        expect(parsed).to include('events')
+        expect(parsed['events'].first).to include('features')
+        expect(parsed['events'].first['features'].first['name']).to eq('test-feature')
+      end
+
+      it 'updates the engine state' do
+        processor.process_event(event)
+
+        expect(engine.enabled?('test-feature', {})).to eq(true)
+      end
+    end
+
+    context 'when processing unknown event type' do
+      let(:event) { TestEvent.new('unknown-event', updated_event_data) }
+
+      it 'does not create a backup file' do
+        processor.process_event(event)
+
+        backup_file = Unleash.configuration.backup_file
+        expect(File.exist?(backup_file)).to eq(false)
+      end
+
+      it 'does not update the engine state' do
+        initial_enabled = engine.enabled?('test-feature', {})
+
+        processor.process_event(event)
+
+        expect(engine.enabled?('test-feature', {})).to eq(initial_enabled)
+      end
+    end
+
+    context 'when processing event with invalid JSON' do
+      let(:invalid_data) { 'invalid json data that looks like real streaming data but is malformed' }
+      let(:event) { TestEvent.new('unleash-updated', invalid_data) }
+
+      it 'handles JSON parse errors gracefully' do
+        expect { processor.process_event(event) }.not_to raise_error
+      end
+
+      it 'still creates a backup file with the raw data' do
+        processor.process_event(event)
+
+        backup_file = Unleash.configuration.backup_file
+        expect(File.exist?(backup_file)).to eq(true)
+
+        content = File.read(backup_file)
+        expect(content).to eq(invalid_data)
+      end
+    end
+  end
+end