attio-rails 0.1.1 → 0.2.0

data/lib/attio/rails/railtie.rb

@@ -1,15 +1,19 @@
+# frozen_string_literal: true
+
 module Attio
   module Rails
     class Railtie < ::Rails::Railtie
       initializer "attio.configure_rails_initialization" do
         ActiveSupport.on_load(:active_record) do
-          require 'attio/rails/concerns/syncable'
+          require "attio/rails/concerns/syncable"
         end
       end
 
+      # :nocov:
       generators do
-        require 'generators/attio/install/install_generator'
+        require "generators/attio/install/install_generator"
       end
+      # :nocov:
     end
   end
-end
+end

data/lib/attio/rails/rspec/helpers.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Attio
+  module Rails
+    module RSpec
+      # RSpec helper methods for testing Attio Rails integration
+      #
+      # @example Including in your specs
+      #   RSpec.configure do |config|
+      #     config.include Attio::Rails::RSpec::Helpers
+      #   end
+      #
+      # @example Basic usage
+      #   it 'syncs to Attio' do
+      #     stub_attio_client
+      #
+      #     user = User.create!(email: 'test@example.com')
+      #     expect(user.attio_record_id).to eq('attio-test-id')
+      #   end
+      #
+      # @example Testing with expectations
+      #   it 'sends correct attributes' do
+      #     expect_attio_sync(
+      #       object: 'people',
+      #       attributes: { email: 'test@example.com' }
+      #     ) do
+      #       User.create!(email: 'test@example.com')
+      #     end
+      #   end
+      module Helpers
+        # Stub the Attio client and records API
+        #
+        # @return [Hash{Symbol => RSpec::Mocks::Double}] Hash with :client and :records doubles
+        #
+        # @example
+        #   stubs = stub_attio_client
+        #   allow(stubs[:records]).to receive(:create).and_return(response)
+        def stub_attio_client
+          client = instance_double(Attio::Client)
+          records = instance_double(Attio::Resources::Records)
+
+          allow(Attio::Rails).to receive(:client).and_return(client)
+          allow(client).to receive(:records).and_return(records)
+
+          { client: client, records: records }
+        end
+
+        # Stub Attio create operations
+        #
+        # @param response [Hash] Custom response to return (default: { "data" => { "id" => "attio-test-id" } })
+        # @return [Hash{Symbol => RSpec::Mocks::Double}] Hash with :client and :records doubles
+        #
+        # @example
+        #   stub_attio_create
+        #   User.create!(email: 'test@example.com')
+        #
+        # @example With custom response
+        #   stub_attio_create('data' => { 'id' => 'custom-id' })
+        def stub_attio_create(response = { "data" => { "id" => "attio-test-id" } })
+          stubs = stub_attio_client
+          allow(stubs[:records]).to receive(:create).and_return(response)
+          stubs
+        end
+
+        # Stub Attio update operations
+        #
+        # @param response [Hash] Custom response to return
+        # @return [Hash{Symbol => RSpec::Mocks::Double}] Hash with :client and :records doubles
+        #
+        # @example
+        #   stub_attio_update
+        #   user.update!(name: 'New Name')
+        def stub_attio_update(response = { "data" => { "id" => "attio-test-id" } })
+          stubs = stub_attio_client
+          allow(stubs[:records]).to receive(:update).and_return(response)
+          stubs
+        end
+
+        # Stub Attio delete operations
+        #
+        # @param response [Hash] Custom response to return
+        # @return [Hash{Symbol => RSpec::Mocks::Double}] Hash with :client and :records doubles
+        #
+        # @example
+        #   stub_attio_delete
+        #   user.destroy!
+        def stub_attio_delete(response = { "data" => { "deleted" => true } })
+          stubs = stub_attio_client
+          allow(stubs[:records]).to receive(:delete).and_return(response)
+          stubs
+        end
+
+        # Expect a sync to Attio with specific parameters
+        #
+        # @param object [String] Expected Attio object type
+        # @param attributes [Hash, nil] Expected attributes (nil to match any)
+        # @yield Block to execute that should trigger the sync
+        # @return [Hash{Symbol => RSpec::Mocks::Double}] Hash with :client and :records doubles
+        #
+        # @example
+        #   expect_attio_sync(object: 'people', attributes: { email: 'test@example.com' }) do
+        #     User.create!(email: 'test@example.com')
+        #   end
+        def expect_attio_sync(object:, attributes: nil)
+          stubs = stub_attio_client
+
+          if attributes
+            expect(stubs[:records]).to receive(:create).with(
+              object: object,
+              data: { values: attributes }
+            ).and_return({ "data" => { "id" => "attio-test-id" } })
+          else
+            expect(stubs[:records]).to receive(:create).with(
+              hash_including(object: object)
+            ).and_return({ "data" => { "id" => "attio-test-id" } })
+          end
+
+          yield if block_given?
+
+          stubs
+        end
+
+        # Expect no sync to Attio
+        #
+        # @yield Block to execute that should not trigger any sync
+        # @return [Hash{Symbol => RSpec::Mocks::Double}] Hash with :client and :records doubles
+        #
+        # @example
+        #   expect_no_attio_sync do
+        #     with_attio_sync_disabled do
+        #       User.create!(email: 'test@example.com')
+        #     end
+        #   end
+        def expect_no_attio_sync
+          stubs = stub_attio_client
+
+          expect(stubs[:records]).not_to receive(:create)
+          expect(stubs[:records]).not_to receive(:update)
+
+          yield if block_given?
+
+          stubs
+        end
+
+        # Temporarily disable Attio syncing
+        #
+        # @yield Block to execute with syncing disabled
+        #
+        # @example
+        #   with_attio_sync_disabled do
+        #     User.create!(email: 'test@example.com') # Won't sync
+        #   end
+        def with_attio_sync_disabled
+          original_value = Attio::Rails.configuration.sync_enabled
+          Attio::Rails.configure { |c| c.sync_enabled = false }
+
+          yield
+        ensure
+          Attio::Rails.configure { |c| c.sync_enabled = original_value }
+        end
+
+        # Temporarily enable background sync
+        #
+        # @yield Block to execute with background sync enabled
+        #
+        # @example
+        #   with_attio_background_sync do
+        #     User.create!(email: 'test@example.com') # Will sync in background
+        #   end
+        #   expect(attio_sync_jobs.size).to eq(1)
+        def with_attio_background_sync
+          original_value = Attio::Rails.configuration.background_sync
+          Attio::Rails.configure { |c| c.background_sync = true }
+
+          yield
+        ensure
+          Attio::Rails.configure { |c| c.background_sync = original_value }
+        end
+
+        # Get all enqueued AttioSyncJob jobs
+        #
+        # @return [Array<Hash>] Array of enqueued job hashes
+        #
+        # @example
+        #   User.create!(email: 'test@example.com')
+        #   expect(attio_sync_jobs.size).to eq(1)
+        #   expect(attio_sync_jobs.first[:args]).to include('model_name' => 'User')
+        def attio_sync_jobs
+          ActiveJob::Base.queue_adapter.enqueued_jobs.select do |job|
+            job[:job] == AttioSyncJob
+          end
+        end
+
+        # Clear all enqueued AttioSyncJob jobs
+        #
+        # @return [Array<Hash>] The deleted jobs
+        #
+        # @example
+        #   clear_attio_sync_jobs
+        #   expect(attio_sync_jobs).to be_empty
+        def clear_attio_sync_jobs
+          ActiveJob::Base.queue_adapter.enqueued_jobs.delete_if do |job|
+            job[:job] == AttioSyncJob
+          end
+        end
+      end
+    end
+  end
+end

data/lib/attio/rails/rspec/matchers.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Attio
+  module Rails
+    module RSpec
+      module Matchers
+        ::RSpec::Matchers.define :sync_to_attio do |expected|
+          match do |actual|
+            return false unless actual.class.respond_to?(:attio_object_type)
+
+            if expected
+              actual.class.attio_object_type == expected[:object] || expected[:object_type]
+            else
+              actual.class.attio_object_type.present?
+            end
+          end
+
+          failure_message do |actual|
+            if actual.class.respond_to?(:attio_object_type)
+              expected_obj = expected[:object] || expected[:object_type]
+              actual_obj = actual.class.attio_object_type
+              "expected #{actual.class} to sync to Attio object '#{expected_obj}' but syncs to '#{actual_obj}'"
+            else
+              "expected #{actual.class} to include Attio::Rails::Concerns::Syncable"
+            end
+          end
+
+          failure_message_when_negated do |actual|
+            "expected #{actual.class} not to sync to Attio"
+          end
+
+          description do
+            "sync to Attio"
+          end
+        end
+
+        ::RSpec::Matchers.define :have_attio_attribute do |attio_attr|
+          match do |actual|
+            return false unless actual.class.respond_to?(:attio_attribute_mapping)
+
+            mapping = actual.class.attio_attribute_mapping
+            if @mapped_to
+              mapping[attio_attr] == @mapped_to
+            else
+              mapping.key?(attio_attr)
+            end
+          end
+
+          chain :mapped_to do |local_attr|
+            @mapped_to = local_attr
+          end
+
+          failure_message do |actual|
+            if actual.class.respond_to?(:attio_attribute_mapping)
+              mapping = actual.class.attio_attribute_mapping
+              if @mapped_to
+                actual_mapping = mapping[attio_attr]
+                "expected #{actual.class} to map Attio attribute '#{attio_attr}' to '#{@mapped_to}' " \
+                  "but it maps to '#{actual_mapping}'"
+              else
+                available_attrs = mapping.keys.join(", ")
+                "expected #{actual.class} to have Attio attribute '#{attio_attr}' but has #{available_attrs}"
+              end
+            else
+              "expected #{actual.class} to include Attio::Rails::Concerns::Syncable"
+            end
+          end
+
+          description do
+            if @mapped_to
+              "have Attio attribute '#{attio_attr}' mapped to '#{@mapped_to}'"
+            else
+              "have Attio attribute '#{attio_attr}'"
+            end
+          end
+        end
+
+        ::RSpec::Matchers.define :enqueue_attio_sync_job do # rubocop:disable Metrics/BlockLength
+          supports_block_expectations
+
+          match do |block|
+            initial_jobs = attio_sync_jobs.dup
+            block.call
+            new_jobs = attio_sync_jobs - initial_jobs
+            @actual_count = new_jobs.size
+
+            if @expected_count
+              @actual_count == @expected_count
+            elsif @expected_action
+              new_jobs.any? { |job| job[:args].first["action"]["value"] == @expected_action.to_s }
+            else
+              @actual_count > 0
+            end
+          end
+
+          chain :with_action do |action|
+            @expected_action = action
+          end
+
+          chain :exactly do |count|
+            @expected_count = count
+          end
+
+          failure_message do
+            build_failure_message
+          end
+
+          failure_message_when_negated do
+            "expected not to enqueue AttioSyncJob but #{@actual_count} were enqueued"
+          end
+
+          description do
+            build_description
+          end
+
+          private def build_failure_message
+            if @expected_count
+              "expected to enqueue #{@expected_count} AttioSyncJob(s) but enqueued #{@actual_count}"
+            elsif @expected_action
+              "expected to enqueue AttioSyncJob with action '#{@expected_action}'"
+            else
+              "expected to enqueue AttioSyncJob but none were enqueued"
+            end
+          end
+
+          private def build_description
+            if @expected_count
+              "enqueue #{@expected_count} AttioSyncJob(s)"
+            elsif @expected_action
+              "enqueue AttioSyncJob with action '#{@expected_action}'"
+            else
+              "enqueue AttioSyncJob"
+            end
+          end
+
+          private def attio_sync_jobs
+            ActiveJob::Base.queue_adapter.enqueued_jobs.select do |job|
+              job[:job] == AttioSyncJob
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/attio/rails/rspec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "attio/rails/rspec/helpers"
+require "attio/rails/rspec/matchers"
+
+RSpec.configure do |config|
+  config.include Attio::Rails::RSpec::Helpers, type: :model
+  config.include Attio::Rails::RSpec::Matchers, type: :model
+end

data/lib/attio/rails/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Attio
   module Rails
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/lib/attio/rails.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require "attio"
 require "rails"
 require "active_support"
+require "logger"
 
 require "attio/rails/version"
 require "attio/rails/configuration"

data/lib/generators/attio/install/install_generator.rb

@@ -1,29 +1,31 @@
-require 'rails/generators/base'
+# frozen_string_literal: true
+
+require "rails/generators/base"
 
 module Attio
   module Generators
     class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path('templates', __dir__)
-      
+      source_root File.expand_path("templates", __dir__)
+
       class_option :skip_job, type: :boolean, default: false, desc: "Skip creating the sync job"
       class_option :skip_migration, type: :boolean, default: false, desc: "Skip creating the migration"
 
       def check_requirements
-        unless defined?(ActiveJob)
-          say "Warning: ActiveJob is not available. Skipping job creation.", :yellow
-          @skip_job = true
-        end
+        return if defined?(ActiveJob)
+
+        say "Warning: ActiveJob is not available. Skipping job creation.", :yellow
+        @skip_job = true
       end
 
       def create_initializer
-        template 'attio.rb', 'config/initializers/attio.rb'
+        template "attio.rb", "config/initializers/attio.rb"
       end
 
       def create_migration
         return if options[:skip_migration]
-        
+
         if defined?(ActiveRecord)
-          migration_template 'migration.rb', 'db/migrate/add_attio_record_id_to_tables.rb'
+          migration_template "migration.rb.erb", "db/migrate/add_attio_record_id_to_tables.rb"
         else
           say "ActiveRecord not detected. Skipping migration.", :yellow
         end
@@ -31,35 +33,35 @@ module Attio
 
       def create_sync_job
         return if options[:skip_job] || @skip_job
-        
-        template 'attio_sync_job.rb', 'app/jobs/attio_sync_job.rb'
+
+        template "attio_sync_job.rb", "app/jobs/attio_sync_job.rb"
       end
 
       def add_to_gemfile
+        return if gemfile_contains?("attio-rails")
+
         gem_group :production do
-          gem 'attio-rails'
-        end unless gemfile_contains?('attio-rails')
+          gem "attio-rails"
+        end
       end
 
       def display_readme
-        readme 'README.md'
+        readme "README.md"
       end
 
-      private
-
-      def gemfile_contains?(gem_name)
-        File.read('Gemfile').include?(gem_name)
-      rescue
+      private def gemfile_contains?(gem_name)
+        File.read("Gemfile").include?(gem_name)
+      rescue StandardError
         false
       end
 
-      def rails_version
+      private def rails_version
         Rails::VERSION::STRING
       end
 
-      def migration_version
+      private def migration_version
         "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
       end
     end
   end
-end
+end

data/lib/generators/attio/install/templates/attio.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 Attio::Rails.configure do |config|
   # Set your Attio API key
-  config.api_key = ENV['ATTIO_API_KEY']
-  
+  config.api_key = ENV.fetch("ATTIO_API_KEY", nil)
+
   # Optional: Set a default workspace ID
   # config.default_workspace_id = 'your-workspace-id'
-end
+end

data/lib/generators/attio/install/templates/attio_sync_job.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 class AttioSyncJob < ApplicationJob
   queue_as :low
-  
+
   retry_on Attio::RateLimitError, wait: 1.minute, attempts: 3
   retry_on Attio::ServerError, wait: :exponentially_longer, attempts: 5
   discard_on ActiveJob::DeserializationError
 
   def perform(model_name:, model_id:, action:, attio_record_id: nil)
     return unless Attio::Rails.sync_enabled?
-    
+
     model_class = model_name.constantize
-    
+
     case action
     when :sync
       sync_record(model_class, model_id)
@@ -30,19 +32,17 @@ class AttioSyncJob < ApplicationJob
     raise e
   end
 
-  private
-
-  def sync_record(model_class, model_id)
+  private def sync_record(model_class, model_id)
     model = model_class.find_by(id: model_id)
     return unless model
-    
+
     # Check if model should still be synced
     return unless model.should_sync_to_attio?
-    
+
     model.sync_to_attio_now
   end
 
-  def delete_record(model_class, model_id, attio_record_id)
+  private def delete_record(model_class, model_id, attio_record_id)
     return unless attio_record_id.present?
 
     # Model might already be deleted, so we work with the class
@@ -54,10 +54,10 @@ class AttioSyncJob < ApplicationJob
       object: object_type,
       id: attio_record_id
     )
-    
+
     Attio::Rails.logger.info "Deleted Attio record #{attio_record_id} for #{model_class.name}##{model_id}"
   rescue Attio::NotFoundError
     # Record already deleted in Attio, nothing to do
     Attio::Rails.logger.info "Attio record #{attio_record_id} already deleted"
   end
-end
+end

data/lib/generators/attio/install/templates/{migration.rb → migration.rb.erb}

@@ -1,4 +1,4 @@
-class AddAttioRecordIdToTables < ActiveRecord::Migration<%= migration_version %>
+class AddAttioRecordIdToTables < ActiveRecord::Migration<%= migration_version %> # rubocop:disable Rails/Migration
   def change
     # Add attio_record_id to each table that needs to sync with Attio
     # Example:

data/test_basic.rb

@@ -1,26 +1,27 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 # Test without loading external dependencies
-$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
-$LOAD_PATH.unshift(File.expand_path('../../attio/lib', __FILE__))
+$LOAD_PATH.unshift(File.expand_path("lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../attio/lib", __dir__))
 
 puts "Testing Attio Rails gem structure..."
 
 # Test version file
-require 'attio/rails/version'
+require "attio/rails/version"
 puts "✓ Version loaded: #{Attio::Rails::VERSION}"
 
 # Test that all files exist
 files_to_check = [
-  'lib/attio/rails.rb',
-  'lib/attio/rails/configuration.rb',
-  'lib/attio/rails/concerns/syncable.rb',
-  'lib/attio/rails/railtie.rb',
-  'lib/generators/attio/install/install_generator.rb',
-  'lib/generators/attio/install/templates/attio.rb',
-  'lib/generators/attio/install/templates/attio_sync_job.rb',
-  'lib/generators/attio/install/templates/migration.rb',
-  'lib/generators/attio/install/templates/README.md'
+  "lib/attio/rails.rb",
+  "lib/attio/rails/configuration.rb",
+  "lib/attio/rails/concerns/syncable.rb",
+  "lib/attio/rails/railtie.rb",
+  "lib/generators/attio/install/install_generator.rb",
+  "lib/generators/attio/install/templates/attio.rb",
+  "lib/generators/attio/install/templates/attio_sync_job.rb",
+  "lib/generators/attio/install/templates/migration.rb",
+  "lib/generators/attio/install/templates/README.md",
 ]
 
 files_to_check.each do |file|
@@ -32,8 +33,8 @@ files_to_check.each do |file|
 end
 
 # Test spec files exist
-spec_files = Dir.glob('spec/**/*_spec.rb')
+spec_files = Dir.glob("spec/**/*_spec.rb")
 puts "\nFound #{spec_files.length} spec files:"
 spec_files.each { |f| puts "  - #{f}" }
 
-puts "\nBasic structure test completed!"
+puts "\nBasic structure test completed!"