active_capture 1.1.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '03486bb96c7c947866d02dbd2a0d3427c81b8ccaea70440ce5ff4463a1905c43'
-  data.tar.gz: ba44f0ab8b7d31f34a9c2470031569514bc5346ad1acbd328a74d2f06ddb7b27
+  metadata.gz: 93b2a116c7a013ba34b42a5211179f14185d2e60d324ff74da5f4f23a8f30a7d
+  data.tar.gz: dd339d97072f5440c0ef2551c73aa6708bc9e22f894fda9e5641eb463d013399
 SHA512:
-  metadata.gz: e116aa0888362fd7f400bff904af9051a9aaaf60c941bd609008db77940c1007e5f20369ac5490cf918355cb3cfe693677074be0b98500e7346fd60f54fcccee
-  data.tar.gz: d3857c7bea275437fe8af8df3337c33da86bd2dfcc8738faea767c4081934381bfc14d3911c34a500f02d5bee0f219858f493af79b259e27fa2030e190578e6d
+  metadata.gz: 17dde4d63324dc3f3e8934e8e5310b3484be942e653068ff9e6d97474d52641571749a556f40985164b9067f3669ed1979f2ccf692479dd998e59c380c549ec9
+  data.tar.gz: 2f0111ff053df52edec0f1632716e45224f1447a811253543212766d685a9d881e7d2b0ec6841cee696bf99ff05c570beff835bfb4daf4674f1a5db3cd493fb5

data/lib/active_capture.rb

@@ -1,106 +1,147 @@
-require 'active_capture/version'
-require_relative 'active_capture/capture_storage'
+require 'support/version'
+require_relative 'support/capture_storage'
 require 'json'
 require 'active_record'
 
 module ActiveCapture
-  class Capture
-    def self.take(record, associations: [], name: nil)
-      raise ArgumentError, 'Record must be an ActiveRecord::Base instance' unless record.is_a?(ActiveRecord::Base)
-
-      capture_data = {
-        model: record.class.name,
-        record_id: record.id,
-        attributes: record.attributes,
-        associations: capture_associations(record, associations)
-      }
-
-      CaptureStorage.save_capture(record, capture_data, name)
+  def self.take(record, associations: [], name: nil)
+    validate_record(record)
+
+    capture_data = {
+      model: record.class.name,
+      record_id: record.id,
+      attributes: record.attributes,
+      associations: capture_associations(record, associations)
+    }
+
+    begin
+      Support::CaptureStorage.save_capture(record, capture_data, name)
+    rescue StandardError => e
+      raise "Failed to save capture: #{e.message}"
     end
+  end
 
-    def self.restore(record, capture_file, merge: false)
-      captured_records = CaptureStorage.load_capture(capture_file)
-
-      raise ArgumentError, 'capture file does not match the given record' unless captured_records['record_id'] == record.id
+  def self.restore(record, capture_file, merge: false)
+    captured_records = Support::CaptureStorage.load_capture(capture_file)
+    validate_capture(record, captured_records)
 
-      ActiveRecord::Base.transaction do
+    ActiveRecord::Base.transaction do
+      begin
         record.update!(captured_records['attributes'])
         restore_associations(record, captured_records['associations'], merge: merge)
+      rescue StandardError => e
+        raise "Failed to restore record: #{e.message}"
       end
     end
+  end
 
-    private
+  def self.flush(directory)
+    Support::CaptureStorage.flush(directory)
+  end
 
-    def self.capture_associations(record, associations)
-      association_data = {}
+  private
 
-      associations.each do |association|
-        nested_associations = []
+  def self.validate_record(record)
+    unless record.is_a?(ActiveRecord::Base)
+      raise ArgumentError, 'Record must be an ActiveRecord::Base instance'
+    end
+  end
 
-        if association.is_a?(Hash)
-          association_name = association.keys.first
-          nested_associations = association.values.flatten
-        else
-          association_name = association
-        end
+  def self.validate_capture(record, captured_records)
+    unless captured_records['record_id'] == record.id
+      raise ArgumentError, 'Capture file does not match the given record'
+    end
+  end
 
-        if record.respond_to?(association_name)
-          related_records = record.send(association_name)
-
-          if related_records.is_a?(ActiveRecord::Base)
-            association_data[association_name] = {
-              attributes: related_records.attributes,
-              associations: capture_associations(related_records, nested_associations)
-            }
-          elsif related_records.respond_to?(:map)
-            association_data[association_name] = related_records.map do |related_record|
-              {
-                attributes: related_record.attributes,
-                associations: capture_associations(related_record, nested_associations)
-              }
-            end
-          end
-        end
+  def self.capture_associations(record, associations)
+    associations.each_with_object({}) do |association, association_data|
+      association_name, nested_associations = parse_association(association)
+
+      next unless record.respond_to?(association_name)
+
+      begin
+        related_records = record.send(association_name)
+        association_data[association_name] = capture_related_records(related_records, nested_associations)
+      rescue StandardError => e
+        raise "Failed to capture association #{association_name}: #{e.message}"
       end
+    end
+  end
 
-      association_data
+  def self.capture_related_records(related_records, nested_associations)
+    if related_records.is_a?(ActiveRecord::Base)
+      {
+        attributes: related_records.attributes,
+        associations: capture_associations(related_records, nested_associations)
+      }
+    elsif related_records.respond_to?(:map)
+      related_records.map do |related_record|
+        {
+          attributes: related_record.attributes,
+          associations: capture_associations(related_record, nested_associations)
+        }
+      end
     end
+  end
 
-    def self.restore_associations(record, associations_data, merge: false)
-      associations_data.each do |association_name, related_data|
-        if related_data.is_a?(Array)
-          associated_class = record.class.reflect_on_association(association_name).klass
-          existing_records = record.send(association_name)
-
-          related_data.each do |related_record_data|
-            if related_record_data['attributes']['id'] && existing_record = existing_records.find_by(id: related_record_data['attributes']['id'])
-              existing_record.update!(related_record_data['attributes'])
-              restore_associations(existing_record, related_record_data['associations'], merge: merge)
-            else
-              new_record = associated_class.create!(related_record_data['attributes'])
-              restore_associations(new_record, related_record_data['associations'], merge: merge)
-            end
-          end
-        else
-          associated_class = record.class.reflect_on_association(association_name).klass
-          if merge && related_data['attributes']['id']
-            existing_record = record.send(association_name)
-
-            if existing_record && existing_record.id == related_data['attributes']['id']
-              existing_record.update!(related_data['attributes'])
-              restore_associations(existing_record, related_data['associations'], merge: merge)
-            else
-              new_record = associated_class.create!(related_data['attributes'])
-              record.update!(association_name => new_record)
-              restore_associations(new_record, related_data['associations'], merge: merge)
-            end
-          else
-            new_record = associated_class.create!(related_data['attributes'])
-            record.update!(association_name => new_record)
-            restore_associations(new_record, related_data['associations'], merge: merge)
-          end
+  def self.parse_association(association)
+    if association.is_a?(Hash)
+      [association.keys.first, association.values.flatten]
+    else
+      [association, []]
+    end
+  end
+
+  def self.restore_associations(record, associations_data, merge: false)
+    associations_data.each do |association_name, related_data|
+      if related_data.is_a?(Array)
+        restore_collection_association(record, association_name, related_data, merge)
+      else
+        restore_single_association(record, association_name, related_data, merge)
+      end
+    end
+  end
+
+  def self.restore_collection_association(record, association_name, related_data, merge)
+    associated_class = record.class.reflect_on_association(association_name).klass
+    existing_records = record.send(association_name)
+
+    related_data.each do |related_record_data|
+      if merge && related_record_data['attributes']['id']
+        existing_record = existing_records.find_by(id: related_record_data['attributes']['id'])
+        if existing_record
+          update_and_restore(existing_record, related_record_data, merge)
+          next
         end
       end
+      create_and_restore(associated_class, related_record_data, record, association_name)
+    end
+  end
+
+  def self.restore_single_association(record, association_name, related_data, merge)
+    associated_class = record.class.reflect_on_association(association_name).klass
+
+    if merge && related_data['attributes']['id']
+      existing_record = record.send(association_name)
+      if existing_record&.id == related_data['attributes']['id']
+        update_and_restore(existing_record, related_data, merge)
+        return
+      end
     end
+
+    new_record = create_and_restore(associated_class, related_data)
+    record.update!(association_name => new_record)
+  end
+
+  def self.update_and_restore(record, related_data, merge)
+    record.update!(related_data['attributes'])
+    restore_associations(record, related_data['associations'], merge: merge)
+  end
+
+  def self.create_and_restore(associated_class, related_data, parent_record = nil, association_name = nil)
+    new_record = associated_class.create!(related_data['attributes'])
+    restore_associations(new_record, related_data['associations'], merge: false)
+    parent_record&.update!(association_name => new_record) if association_name
+    new_record
   end
 end

data/lib/support/capture_storage.rb

@@ -0,0 +1,211 @@
+# This module provides functionality for storing and retrieving JSON-based capture data
+# associated with specific records. It includes methods for saving captures, loading captures,
+# and flushing (deleting) files in a specific directory.
+
+require 'json'
+require 'fileutils'
+require 'pathname'
+
+module Support
+  class CaptureStorage
+    # Constants for directory and filename constraints
+    CAPTURE_DIR = 'captures'.freeze
+    MAX_FILENAME_LENGTH = 100
+    VALID_FILENAME_REGEX = /\A[a-zA-Z0-9\-_\.]+\z/
+
+    class << self
+      # Saves capture data to a JSON file in a structured directory.
+      # @param record [Object] The record object (must respond to :class and :id).
+      # @param capture_data [Hash] The data to be saved.
+      # @param name [String, nil] Optional custom filename.
+      # @return [Hash] Result of the operation with success status and file path or error message.
+      def save_capture(record, capture_data, name = nil)
+        validate_record(record) # Ensure the record is valid
+        validate_capture_data(capture_data) # Ensure the capture data is valid
+        
+        file_name = generate_filename(record, name) # Generate a valid filename
+        dir_path = create_capture_directory(record) # Create the directory for the capture
+        file_path = File.join(dir_path, file_name) # Full path to the capture file
+
+        write_capture_file(file_path, capture_data) # Write the capture data to the file
+        
+        { success: true, file_path: file_path }
+      rescue => e
+        { success: false, error: e.message }
+      end
+
+      # Loads capture data from a JSON file.
+      # @param capture_file [String] Path to the capture file.
+      # @return [Hash] Parsed JSON data from the file.
+      # @raise [StorageError] If the file cannot be loaded or parsed.
+      def load_capture(capture_file)
+        validate_file_path(capture_file) # Ensure the file path is valid
+        
+        file_content = read_file_safely(capture_file) # Read the file content
+        parsed_data = JSON.parse(file_content) # Parse the JSON content
+        
+        validate_parsed_data(parsed_data) # Ensure the parsed data is valid
+        
+        parsed_data
+      rescue => e
+        raise StorageError, "Failed to load capture: #{e.message}"
+      end
+
+      # Deletes all files in a specified directory under the capture directory.
+      # @param directory [String] Subdirectory name under the capture directory.
+      def flush(directory)
+        begin
+          dir_path = File.join(CAPTURE_DIR, directory) # Full path to the directory
+      
+          unless Dir.exist?(dir_path)
+            raise StandardError, "Directory '#{dir_path}' does not exist."
+          end
+      
+          files = Dir.glob("#{dir_path}/*") # Get all files in the directory
+          
+          if files.empty?
+            puts "No files found in #{dir_path} to delete."
+            return
+          end
+      
+          files.each do |file|
+            if File.file?(file)
+              begin
+                File.delete(file) # Delete each file
+              rescue Errno::EACCES
+                puts "Permission denied when deleting file: #{file}"
+              rescue StandardError => e
+                puts "Failed to delete file: #{file}. Error: #{e.message}"
+              end
+            end
+          end
+      
+          puts "Flushed all files in #{dir_path} successfully."
+      
+        rescue StandardError => e
+          puts "An error occurred during flush operation: #{e.message}"
+        end
+      end
+
+      private
+
+      # Validates that the record has the required attributes.
+      def validate_record(record)
+        unless record.respond_to?(:class) && record.respond_to?(:id)
+          raise ArgumentError, "Invalid record: must respond to :class and :id"
+        end
+
+        if record.id.nil?
+          raise ArgumentError, "Cannot capture unsaved record (ID is nil)"
+        end
+      end
+
+      # Validates the structure of the capture data.
+      def validate_capture_data(data)
+        unless data.is_a?(Hash)
+          raise ArgumentError, "Capture data must be a Hash"
+        end
+
+        required_keys = [:model, :record_id, :attributes]
+        missing_keys = required_keys.reject { |k| data.key?(k) }
+        unless missing_keys.empty?
+          raise ArgumentError, "Missing required keys in capture data: #{missing_keys.join(', ')}"
+        end
+      end
+
+      # Generates a valid filename for the capture file.
+      def generate_filename(record, custom_name)
+        model_name = record.class.name.downcase.gsub(/[^a-z0-9]/, '_')
+        record_id = record.id.to_s
+        timestamp = Time.now.strftime('%Y%m%d%H%M%S')
+
+        if custom_name
+          validate_filename(custom_name)
+          base_name = custom_name.gsub(/\s+/, '_')[0..MAX_FILENAME_LENGTH]
+          "#{base_name}.json"
+        else
+          "#{model_name}_#{record_id}_#{timestamp}.json"
+        end
+      end
+
+      # Validates the custom filename.
+      def validate_filename(name)
+        if name.empty?
+          raise ArgumentError, "Filename cannot be empty"
+        end
+
+        if name.length > MAX_FILENAME_LENGTH
+          raise ArgumentError, "Filename too long (max #{MAX_FILENAME_LENGTH} chars)"
+        end
+
+        unless name.match(VALID_FILENAME_REGEX)
+          raise ArgumentError, "Filename contains invalid characters"
+        end
+      end
+
+      # Creates the directory for storing capture files.
+      def create_capture_directory(record)
+        model_name = record.class.name.downcase.gsub(/[^a-z0-9]/, '_')
+        dir_path = File.join(CAPTURE_DIR, model_name)
+
+        begin
+          FileUtils.mkdir_p(dir_path) # Create the directory if it doesn't exist
+        rescue SystemCallError => e
+          raise StorageError, "Failed to create directory '#{dir_path}': #{e.message}"
+        end
+
+        dir_path
+      end
+
+      # Writes the capture data to a file safely.
+      def write_capture_file(file_path, data)
+        begin
+          temp_path = "#{file_path}.tmp"
+          File.write(temp_path, JSON.pretty_generate(data)) # Write to a temporary file
+          File.rename(temp_path, file_path) # Rename to the final file
+        rescue SystemCallError => e
+          File.delete(temp_path) if File.exist?(temp_path)
+          raise StorageError, "Failed to write capture file '#{file_path}': #{e.message}"
+        end
+      end
+
+      # Validates the file path for loading captures.
+      def validate_file_path(file_path)
+        unless File.exist?(file_path)
+          raise StorageError, "File does not exist: #{file_path}"
+        end
+
+        unless File.readable?(file_path)
+          raise StorageError, "No read permission for file: #{file_path}"
+        end
+
+        if File.directory?(file_path)
+          raise StorageError, "Path is a directory, not a file: #{file_path}"
+        end
+      end
+
+      # Reads the file content safely.
+      def read_file_safely(file_path)
+        File.read(file_path)
+      rescue SystemCallError => e
+        raise StorageError, "Failed to read file '#{file_path}': #{e.message}"
+      end
+
+      # Validates the parsed JSON data structure.
+      def validate_parsed_data(data)
+        unless data.is_a?(Hash)
+          raise StorageError, "Invalid capture format: expected JSON object"
+        end
+
+        required_keys = ['model', 'record_id', 'attributes']
+        missing_keys = required_keys.reject { |k| data.key?(k) }
+        unless missing_keys.empty?
+          raise StorageError, "Invalid capture data: missing keys #{missing_keys.join(', ')}"
+        end
+      end
+    end
+
+    # Custom error class for storage-related errors.
+    class StorageError < StandardError; end
+  end
+end

data/lib/support/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Support
+  VERSION = "1.1.2"
+end

data/test/support/test_capture_storage.rb

@@ -0,0 +1,155 @@
+require 'test_helper'
+require 'minitest/autorun'
+require 'fileutils'
+
+# Define our test classes at the top level
+class TestModel; end
+class NewModel; end
+class ProtectedModel; end
+
+class CaptureStorageTest < Minitest::Test
+  # Simple test record class that mimics ActiveRecord::Base
+  class TestRecord
+    attr_reader :id
+
+    def initialize(id, class_name)
+      @id = id
+      @class_name = class_name
+    end
+
+    def class
+      @class_name.constantize
+    end
+  end
+
+  def setup
+    # Create test data directory
+    @test_dir = 'test_data'
+    FileUtils.mkdir_p(@test_dir)
+
+    # Create sample capture data
+    @sample_data = {
+      model: 'TestModel',
+      record_id: 1,
+      attributes: { name: 'Test', value: 42 },
+      associations: {
+        comments: [
+          { attributes: { id: 1, content: 'First comment' } },
+          { attributes: { id: 2, content: 'Second comment' } }
+        ]
+      }
+    }
+
+    # Create test files
+    @valid_file = "#{@test_dir}/valid.json"
+    File.write(@valid_file, JSON.generate(@sample_data))
+
+    @invalid_json_file = "#{@test_dir}/invalid.json"
+    File.write(@invalid_json_file, 'not valid json')
+
+    @empty_file = "#{@test_dir}/empty.json"
+    File.write(@empty_file, '')
+
+    # Clear captures directory before each test
+    FileUtils.rm_rf(Support::CaptureStorage::CAPTURE_DIR) if File.directory?(Support::CaptureStorage::CAPTURE_DIR)
+  end
+
+  def teardown
+    # Clean up test files
+    FileUtils.rm_rf(@test_dir)
+    FileUtils.rm_rf(Support::CaptureStorage::CAPTURE_DIR)
+  end
+
+  def test_save_capture_creates_valid_file
+    test_record = TestRecord.new(1, 'TestModel')
+    result = Support::CaptureStorage.save_capture(test_record, @sample_data)
+
+    assert result[:success], "Save should succeed: #{result[:error]}"
+    assert File.exist?(result[:file_path]), "File should exist at #{result[:file_path]}"
+
+    file_content = JSON.parse(File.read(result[:file_path]))
+    assert_equal 'TestModel', file_content['model']
+    assert_equal 1, file_content['record_id']
+  end
+
+  def test_save_capture_with_custom_name
+    test_record = TestRecord.new(1, 'TestModel')
+    custom_name = 'custom_capture'
+    result = Support::CaptureStorage.save_capture(test_record, @sample_data, custom_name)
+
+    assert result[:success], "Save should succeed: #{result[:error]}"
+    assert_match /#{custom_name}\.json/, result[:file_path]
+    assert File.exist?(result[:file_path]), "File should exist at #{result[:file_path]}"
+  end
+
+  def test_save_capture_invalid_filename
+    test_record = TestRecord.new(1, 'TestModel')
+    result = Support::CaptureStorage.save_capture(test_record, @sample_data, 'invalid/name')
+
+    refute result[:success], "Save should fail with invalid filename"
+    assert_match /Filename contains invalid characters/, result[:error], "Error should mention invalid filename"
+  end
+
+  def test_load_capture_valid_file
+    data = Support::CaptureStorage.load_capture(@valid_file)
+
+    assert_equal 'TestModel', data['model']
+    assert_equal 1, data['record_id']
+    assert_equal 2, data['associations']['comments'].size
+  end
+
+  def test_load_capture_nonexistent_file
+    assert_raises Support::CaptureStorage::StorageError do
+      Support::CaptureStorage.load_capture('nonexistent.json')
+    end
+  end
+
+  def test_load_capture_invalid_json
+    assert_raises Support::CaptureStorage::StorageError do
+      Support::CaptureStorage.load_capture(@invalid_json_file)
+    end
+  end
+
+  def test_load_capture_empty_file
+    assert_raises Support::CaptureStorage::StorageError do
+      Support::CaptureStorage.load_capture(@empty_file)
+    end
+  end
+
+  def test_load_capture_missing_required_keys
+    incomplete_data = { 'some_key' => 'some_value' }
+    incomplete_file = "#{@test_dir}/incomplete.json"
+    File.write(incomplete_file, JSON.generate(incomplete_data))
+
+    assert_raises Support::CaptureStorage::StorageError do
+      Support::CaptureStorage.load_capture(incomplete_file)
+    end
+  end
+
+  def test_atomic_write_handles_failure
+    # Create a directory we can't write to
+    protected_dir = "#{@test_dir}/protected"
+    FileUtils.mkdir_p(protected_dir)
+    FileUtils.chmod(0444, protected_dir) # read-only
+
+    test_record = TestRecord.new(1, 'ProtectedModel')
+    file_path = "#{protected_dir}/test.json"
+
+    assert_raises Support::CaptureStorage::StorageError do
+      Support::CaptureStorage.send(:write_capture_file, file_path, @sample_data)
+    end
+
+    # Verify no temp file remains
+    refute File.exist?("#{file_path}.tmp")
+  ensure
+    FileUtils.chmod(0755, protected_dir) if File.exist?(protected_dir)
+  end
+
+  def test_directory_creation
+    test_record = TestRecord.new(1, 'NewModel')
+    result = Support::CaptureStorage.save_capture(test_record, @sample_data)
+
+    assert result[:success], "Save should succeed: #{result[:error]}"
+    assert File.directory?('captures/newmodel'), "Directory should be created"
+  end
+end

data/test/test_active_capture.rb

@@ -2,6 +2,7 @@ require 'test_helper'
 require 'minitest/autorun'
 
 class ActiveCaptureTest < Minitest::Test
+  # Setup method to initialize test data before each test
   def setup
     @user = User.create!(name: "John Doe", email: "john@example.com")
     @post = @user.posts.create!(title: "First Post", content: "This is my first post.")
@@ -9,29 +10,50 @@ class ActiveCaptureTest < Minitest::Test
     @comment2 = @post.comments.create!(content: "Thanks for sharing.")
   end
 
+  # Teardown method to clean up after each test
+  def teardown
+    FileUtils.rm_rf('captures/')
+  end
+
+  # Test capturing a user with associated posts and comments
   def test_capture_with_associations
-    ActiveCapture::Capture.take(@user, associations: [:posts, { posts: :comments }])
+    # Take a capture of the user and their associations
+    ActiveCapture.take(@user, associations: [:posts, { posts: :comments }])
 
+    # Verify that capture files are created
     capture_files = Dir["captures/user/*.json"]
     assert !capture_files.empty?, "capture file should be created"
 
+    # Verify the content of the capture file
     capture_content = JSON.parse(File.read(capture_files.last))
     assert_equal 1, capture_content["associations"]["posts"].size
     assert_equal 2, capture_content["associations"]["posts"].first["associations"]["comments"].size
   end
 
+  # Test restoring a user with merge functionality
   def test_restore_with_merge
-    ActiveCapture::Capture.take(@user, associations: [:posts, { posts: :comments }])
+    # Take a capture of the user and their associations
+    ActiveCapture.take(@user, associations: [:posts, { posts: :comments }])
     capture_file = Dir["captures/user/*.json"].last
+
+    # Modify the post and add a new comment
     @post.update(title: "updated title")
     new_comment = @post.comments.create!(content: "Another comment")
-    ActiveCapture::Capture.restore(@user, capture_file, merge: true)
 
+    # Restore the user from the capture file with merge enabled
+    ActiveCapture.restore(@user, capture_file, merge: true)
+
+    # Reload the user and post to verify changes
     @user.reload
     @post.reload
 
+    # Verify that the user's name is restored
     assert_equal "John Doe", @user.name
+
+    # Verify that the post's title is restored
     assert_equal "First Post", @post.title
+
+    # Verify that the new comment still exists after the merge
     assert_equal 3, @post.comments.count
     assert @post.comments.exists?(new_comment.id), "New comment should still exist after merge"
   end

data/test/test_active_capture_flush.rb

@@ -0,0 +1,90 @@
+require 'minitest/autorun'
+require 'fileutils'
+require_relative '../lib/active_capture'
+
+# Test suite for the ActiveCapture.flush method
+class ActiveCaptureFlushTest < Minitest::Test
+  # Directory where test captures will be stored
+  CAPTURES_DIR = 'captures'.freeze
+
+  # Setup method to prepare the test environment
+  def setup
+    # Create the captures directory
+    FileUtils.mkdir_p(CAPTURES_DIR)
+    # Create a user subdirectory
+    @user_dir = File.join(CAPTURES_DIR, 'user')
+    FileUtils.mkdir_p(@user_dir)
+    # Add test files to the user directory
+    File.write(File.join(@user_dir, 'test1.json'), '{}')
+    File.write(File.join(@user_dir, 'test2.json'), '{}')
+  end
+
+  # Teardown method to clean up after tests
+  def teardown
+    # Remove the captures directory and its contents
+    FileUtils.rm_rf(CAPTURES_DIR)
+  end
+
+  # Test flushing a valid directory with files
+  def test_flush_valid_directory
+    # Ensure the user directory exists and contains files
+    assert Dir.exist?(@user_dir)
+    assert_equal 2, Dir.glob(File.join(@user_dir, '*')).size
+
+    # Call the flush method
+    ActiveCapture.flush('user')
+
+    # Verify the directory is empty after flushing
+    assert_empty Dir.glob(File.join(@user_dir, '*'))
+    puts "test_flush_valid_directory passed"
+  end
+
+  # Test flushing a non-existent directory
+  def test_flush_non_existent_directory
+    # Capture the output of the flush method
+    output = capture_io do
+      ActiveCapture.flush('non_existent_dir')
+    end
+    # Verify the appropriate error message is displayed
+    assert_match /Directory 'captures\/non_existent_dir' does not exist./, output[0]
+    puts "test_flush_non_existent_directory passed"
+  end
+
+  # Test flushing an empty directory
+  def test_flush_empty_directory
+    # Remove and recreate the user directory to ensure it's empty
+    FileUtils.rm_rf(@user_dir)
+    FileUtils.mkdir_p(@user_dir)
+    assert_empty Dir.glob(File.join(@user_dir, '*'))
+
+    # Capture the output of the flush method
+    output = capture_io do
+      ActiveCapture.flush('user')
+    end
+    # Verify the appropriate message is displayed for an empty directory
+    assert_match /No files found in captures\/user to delete./, output[0]
+    puts "test_flush_empty_directory passed"
+  end
+
+  # Test flushing a directory with a file that has restricted permissions
+  def test_flush_with_permission_error
+    # Skip this test unless run with restricted permissions
+    skip "Run this test with restricted permissions to verify behavior."
+
+    # Create a protected file with no permissions
+    protected_file = File.join(@user_dir, 'protected.json')
+    File.write(protected_file, '{}')
+    FileUtils.chmod(0o000, protected_file)
+
+    # Capture the output of the flush method
+    output = capture_io do
+      ActiveCapture.flush('user')
+    end
+    # Verify the appropriate error message is displayed for permission issues
+    assert_match /Permission denied when deleting file: captures\/user\/protected.json/, output[0]
+
+    # Reset permissions for cleanup
+    FileUtils.chmod(0o644, protected_file)
+    puts "test_flush_with_permission_error passed"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_capture
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.2
 platform: ruby
 authors:
 - Tanmay Bhawsar
@@ -32,9 +32,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/active_capture.rb
-- lib/active_capture/capture_storage.rb
-- lib/active_capture/version.rb
+- lib/support/capture_storage.rb
+- lib/support/version.rb
+- test/support/test_capture_storage.rb
 - test/test_active_capture.rb
+- test/test_active_capture_flush.rb
 - test/test_helper.rb
 homepage: https://github.com/bhawsartanmay/active_capture
 licenses:

data/lib/active_capture/capture_storage.rb

@@ -1,29 +0,0 @@
-require 'json'
-require 'fileutils'
-
-module ActiveCapture
-  class CaptureStorage
-    CAPTURE_DIR = 'captures'
-
-    def self.save_capture(record, capture_data, name = nil)
-      model_name = record.class.name.downcase
-      record_id = record.id
-      timestamp = Time.now.strftime('%Y%m%d%H%M%S')
-      file_name = name ? "#{name}.json" : "#{record_id}_#{timestamp}.json"
-
-      dir_path = File.join(CAPTURE_DIR, model_name)
-      FileUtils.mkdir_p(dir_path)
-
-      file_path = File.join(dir_path, file_name)
-      File.write(file_path, JSON.pretty_generate(capture_data))
-
-      puts "Capture saved to #{file_path}"
-    end
-
-    def self.load_capture(capture_file)
-      raise ArgumentError, "Capture file does not exist #{capture_file}" unless File.exist?(capture_file)
-
-      JSON.parse(File.read(capture_file))
-    end
-  end
-end

data/lib/active_capture/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveCapture
-  VERSION = "1.1.0"
-end