anima-core 0.3.0 → 1.0.0

data/skills/rspec/examples/mocks/any_instance.rb

@@ -0,0 +1,172 @@
+# RSpec Mocks: any_instance Examples
+# Source: rspec-mocks gem features/working_with_legacy_code/any_instance.feature
+
+# WARNING: any_instance is discouraged. It often indicates:
+# - Missing dependency injection
+# - Tight coupling in design
+# - Need for refactoring
+#
+# Prefer instance_double with explicit injection.
+# Use any_instance only for legacy code you can't easily refactor.
+
+# allow_any_instance_of - stub method on all instances
+RSpec.describe "allow_any_instance_of" do
+  describe "basic usage" do
+    it "stubs method on any instance" do
+      allow_any_instance_of(Widget).to receive(:name).and_return("Stubbed")
+
+      widget1 = Widget.new
+      widget2 = Widget.new
+
+      expect(widget1.name).to eq("Stubbed")
+      expect(widget2.name).to eq("Stubbed")
+    end
+  end
+
+  describe "with receive_messages" do
+    it "stubs multiple methods" do
+      allow_any_instance_of(Widget).to receive_messages(
+        name: "Stubbed",
+        price: 100
+      )
+
+      widget = Widget.new
+      expect(widget.name).to eq("Stubbed")
+      expect(widget.price).to eq(100)
+    end
+  end
+
+  describe "with arguments" do
+    it "matches specific arguments" do
+      allow_any_instance_of(Calculator).to receive(:add).with(1, 2).and_return(100)
+
+      calc = Calculator.new
+      expect(calc.add(1, 2)).to eq(100)
+    end
+  end
+
+  describe "block receives instance" do
+    it "passes instance as first argument to block" do
+      allow_any_instance_of(String).to receive(:slice) do |instance, start, length|
+        "Instance: #{instance[start, length]}"
+      end
+
+      expect("hello world".slice(0, 5)).to eq("Instance: hello")
+    end
+  end
+
+  describe "consecutive return values" do
+    it "applies per instance, not globally" do
+      allow_any_instance_of(Counter).to receive(:value).and_return(1, 2, 3)
+
+      first = Counter.new
+      second = Counter.new
+
+      # Each instance gets its own sequence
+      expect(first.value).to eq(1)
+      expect(first.value).to eq(2)
+      expect(second.value).to eq(1)  # New instance, new sequence
+      expect(first.value).to eq(3)
+    end
+  end
+end
+
+# expect_any_instance_of - expect at least one instance receives message
+RSpec.describe "expect_any_instance_of" do
+  describe "basic expectation" do
+    it "passes if any instance receives the message" do
+      expect_any_instance_of(Widget).to receive(:save)
+
+      widget = Widget.new
+      widget.save
+    end
+  end
+
+  describe "with return value" do
+    it "returns specified value and verifies call" do
+      expect_any_instance_of(Widget).to receive(:save).and_return(true)
+
+      widget = Widget.new
+      expect(widget.save).to be(true)
+    end
+  end
+end
+
+# Legacy code example - why any_instance exists
+RSpec.describe "legacy code scenario" do
+  # Imagine this service creates its own dependencies internally
+  # and we can't easily inject them
+  class LegacyOrderService
+    def process(order_id)
+      order = Order.find(order_id)  # Creates Order internally
+      order.process
+      order.save
+    end
+  end
+
+  describe LegacyOrderService do
+    subject(:service) { LegacyOrderService.new }
+
+    # Using any_instance because we can't inject Order
+    it "processes and saves the order" do
+      allow(Order).to receive(:find).and_return(build(:order))
+      expect_any_instance_of(Order).to receive(:process)
+      expect_any_instance_of(Order).to receive(:save)
+
+      service.process(1)
+    end
+  end
+
+  # BETTER: Refactor to use dependency injection
+  class RefactoredOrderService
+    def initialize(order_repository: Order)
+      @order_repository = order_repository
+    end
+
+    def process(order_id)
+      order = @order_repository.find(order_id)
+      order.process
+      order.save
+    end
+
+    private
+
+    attr_reader :order_repository
+  end
+
+  describe RefactoredOrderService do
+    subject(:service) { RefactoredOrderService.new(order_repository:) }
+
+    let(:order_repository) { class_double("Order") }
+    let(:order) { instance_double("Order") }
+
+    it "processes and saves the order" do
+      allow(order_repository).to receive(:find).and_return(order)
+      expect(order).to receive(:process)
+      expect(order).to receive(:save)
+
+      service.process(1)
+    end
+  end
+end
+
+# When any_instance might be acceptable
+RSpec.describe "acceptable any_instance usage" do
+  describe "testing framework extensions" do
+    # Testing behavior added to core classes
+    it "stubs String extension method" do
+      allow_any_instance_of(String).to receive(:custom_method).and_return("extended")
+
+      expect("test".custom_method).to eq("extended")
+    end
+  end
+
+  describe "testing monkey patches in legacy code" do
+    it "verifies behavior without refactoring" do
+      expect_any_instance_of(LegacyModel).to receive(:legacy_callback)
+
+      LegacyModel.create(name: "test")
+    end
+  end
+end
+

data/skills/rspec/examples/mocks/argument_matchers.rb

@@ -0,0 +1,206 @@
+# RSpec Mocks: Argument Matchers Examples
+# Source: rspec-mocks gem features/setting_constraints/matching_arguments.feature
+
+# Built-in argument matchers
+RSpec.describe "argument matchers" do
+  describe "anything" do
+    it "matches any single argument" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(anything)
+      dbl.foo("whatever")
+    end
+
+    it "matches at specific positions" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(1, anything, 3)
+      dbl.foo(1, "anything goes here", 3)
+    end
+  end
+
+  describe "any_args" do
+    it "matches any number of arguments" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(any_args)
+      dbl.foo(1, 2, 3, 4, 5)
+    end
+  end
+
+  describe "no_args" do
+    it "matches zero arguments" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(no_args)
+      dbl.foo
+    end
+  end
+
+  describe "type matchers" do
+    it "matches by kind_of" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(kind_of(Numeric))
+      dbl.foo(42)
+      # Also matches floats, BigDecimal, etc.
+    end
+
+    it "matches by instance_of (exact class)" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(instance_of(Integer))
+      dbl.foo(42)
+    end
+  end
+
+  describe "duck_type" do
+    it "matches by method presence" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(duck_type(:to_s, :length))
+
+      dbl.foo("a string")  # Has both methods
+    end
+  end
+
+  describe "boolean" do
+    it "matches true or false" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo).with(boolean)
+
+      dbl.foo(true)
+      dbl.foo(false)
+    end
+  end
+
+  describe "hash_including" do
+    it "matches partial hash" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(hash_including(a: 1))
+      dbl.foo(a: 1, b: 2, c: 3)
+    end
+
+    it "matches nested structure" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(
+        hash_including(user: hash_including(name: "Alice"))
+      )
+      dbl.foo(user: { name: "Alice", email: "alice@example.com" })
+    end
+  end
+
+  describe "hash_excluding" do
+    it "matches hash without specified keys" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(hash_excluding(:admin))
+      dbl.foo(name: "Alice", role: "user")
+    end
+  end
+
+  describe "array_including" do
+    it "matches array containing items" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(array_including(1, 2))
+      dbl.foo([1, 2, 3, 4])
+    end
+  end
+
+  describe "array_excluding" do
+    it "matches array without specified items" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(array_excluding(:admin))
+      dbl.foo([:user, :guest])
+    end
+  end
+
+  describe "regex matching" do
+    it "matches strings with regex" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(/bar/)
+      dbl.foo("foobar")
+    end
+  end
+
+  describe "RSpec matchers" do
+    it "uses collection matchers" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(a_collection_containing_exactly(1, 2, 3))
+      dbl.foo([3, 1, 2])
+    end
+
+    it "uses string matchers" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(a_string_starting_with("Hello"))
+      dbl.foo("Hello, World!")
+    end
+
+    it "uses comparison matchers" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(a_value > 10)
+      dbl.foo(15)
+    end
+  end
+
+  describe "satisfy" do
+    it "matches with custom predicate" do
+      dbl = double("collaborator")
+      expect(dbl).to receive(:foo).with(
+        satisfy { |x| x[:a][:b][:c] == 5 }
+      )
+      dbl.foo(a: { b: { c: 5 } })
+    end
+  end
+
+  describe "having_attributes" do
+    it "matches object with attributes" do
+      dbl = double("collaborator")
+      user = build(:user, name: "Alice", email: "alice@example.com")
+
+      expect(dbl).to receive(:process).with(
+        having_attributes(name: "Alice")
+      )
+      dbl.process(user)
+    end
+  end
+end
+
+# Argument-dependent responses
+RSpec.describe "conditional stubs" do
+  describe "different responses by argument" do
+    it "returns specific values for specific arguments" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo).and_return(:default)
+      allow(dbl).to receive(:foo).with(1).and_return(:one)
+      allow(dbl).to receive(:foo).with(2).and_return(:two)
+
+      expect(dbl.foo(0)).to eq(:default)
+      expect(dbl.foo(1)).to eq(:one)
+      expect(dbl.foo(2)).to eq(:two)
+      expect(dbl.foo(99)).to eq(:default)
+    end
+  end
+end
+
+# Practical example
+RSpec.describe UserRepository do
+  subject(:repository) { build(:user_repository, database:) }
+
+  let(:database) { instance_double("Database") }
+
+  describe "#find_by_attributes" do
+    before do
+      allow(database).to receive(:query)
+        .with(hash_including(active: true))
+        .and_return([build(:user, :active)])
+
+      allow(database).to receive(:query)
+        .with(hash_including(admin: true))
+        .and_return([build(:user, :admin)])
+    end
+
+    it "queries active users" do
+      result = repository.find_by_attributes(active: true, name: "Alice")
+      expect(result.first).to be_active
+    end
+
+    it "queries admin users" do
+      result = repository.find_by_attributes(admin: true, department: "IT")
+      expect(result.first).to be_admin
+    end
+  end
+end
+

data/skills/rspec/examples/mocks/constants.rb

@@ -0,0 +1,177 @@
+# RSpec Mocks: Constant Stubbing Examples
+# Source: rspec-mocks gem features/mutating_constants/*.feature
+
+# stub_const - temporarily replace constant values
+RSpec.describe "stub_const" do
+  describe "top-level constants" do
+    it "stubs constant for duration of example" do
+      stub_const("FOO", 5)
+      expect(FOO).to eq(5)
+    end
+
+    it "restores original value after example" do
+      original = FOO rescue nil
+      stub_const("FOO", 999)
+      # After this example, FOO returns to original
+    end
+  end
+
+  describe "nested constants" do
+    it "stubs nested class constants" do
+      stub_const("MyGem::SomeClass::PER_PAGE", 100)
+      expect(MyGem::SomeClass::PER_PAGE).to eq(100)
+    end
+
+    it "stubs module constants" do
+      stub_const("Rails::VERSION", "7.0.0")
+      expect(Rails::VERSION).to eq("7.0.0")
+    end
+  end
+
+  describe "replacing classes" do
+    it "stubs with fake class" do
+      fake_class = Class.new do
+        def self.perform
+          :fake_result
+        end
+      end
+
+      stub_const("HeavyWorker", fake_class)
+      expect(HeavyWorker.perform).to eq(:fake_result)
+    end
+  end
+
+  describe "transfer_nested_constants" do
+    it "transfers all nested constants" do
+      fake_deck = Class.new
+
+      stub_const("CardDeck", fake_deck, transfer_nested_constants: true)
+
+      # Original CardDeck::SUITS is now available on fake_deck
+      expect(CardDeck::SUITS).to eq(%w[hearts diamonds clubs spades])
+    end
+
+    it "transfers selected constants" do
+      fake_deck = Class.new
+
+      stub_const("CardDeck", fake_deck, transfer_nested_constants: [:SUITS])
+
+      expect(CardDeck::SUITS).to eq(%w[hearts diamonds clubs spades])
+      # Other constants like RANKS are not transferred
+    end
+  end
+
+  describe "undefined constants" do
+    it "can stub constants that don't exist yet" do
+      stub_const("FUTURE_FEATURE_FLAG", true)
+      expect(FUTURE_FEATURE_FLAG).to be(true)
+      # Constant is removed after example
+    end
+  end
+end
+
+# hide_const - temporarily make constant undefined
+RSpec.describe "hide_const" do
+  describe "hiding defined constants" do
+    it "makes constant undefined" do
+      hide_const("SomeClass")
+      expect { SomeClass }.to raise_error(NameError)
+    end
+
+    it "restores constant after example" do
+      hide_const("SomeClass")
+      # After this example, SomeClass is available again
+    end
+  end
+
+  describe "hiding nested constants" do
+    it "hides nested constant" do
+      hide_const("MyGem::SomeClass::TIMEOUT")
+      expect { MyGem::SomeClass::TIMEOUT }.to raise_error(NameError)
+    end
+  end
+
+  describe "hiding undefined constants" do
+    it "does nothing for undefined constants" do
+      # Safe to call - no error raised
+      hide_const("DEFINITELY_NOT_DEFINED")
+    end
+  end
+end
+
+# Practical examples
+RSpec.describe "configuration testing" do
+  describe FeatureToggle do
+    describe ".enabled?" do
+      context "when feature is enabled" do
+        before { stub_const("FeatureToggle::FEATURES", { dark_mode: true }) }
+
+        it "returns true" do
+          expect(FeatureToggle.enabled?(:dark_mode)).to be(true)
+        end
+      end
+
+      context "when feature is disabled" do
+        before { stub_const("FeatureToggle::FEATURES", { dark_mode: false }) }
+
+        it "returns false" do
+          expect(FeatureToggle.enabled?(:dark_mode)).to be(false)
+        end
+      end
+    end
+  end
+end
+
+RSpec.describe "environment-dependent code" do
+  describe ApiClient do
+    context "in production" do
+      before { stub_const("Rails.env", ActiveSupport::StringInquirer.new("production")) }
+
+      it "uses production URL" do
+        expect(ApiClient.base_url).to eq("https://api.example.com")
+      end
+    end
+
+    context "in development" do
+      before { stub_const("Rails.env", ActiveSupport::StringInquirer.new("development")) }
+
+      it "uses localhost URL" do
+        expect(ApiClient.base_url).to eq("http://localhost:3000")
+      end
+    end
+  end
+end
+
+RSpec.describe "testing error handling for missing dependencies" do
+  describe ExternalServiceClient do
+    context "when gem is not loaded" do
+      before { hide_const("ExternalGem") }
+
+      it "raises descriptive error" do
+        expect { ExternalServiceClient.connect }
+          .to raise_error("ExternalGem is required. Add it to your Gemfile.")
+      end
+    end
+  end
+end
+
+RSpec.describe "pagination configuration" do
+  describe UserListController do
+    subject(:controller) { build(:user_list_controller) }
+
+    context "with custom page size" do
+      before { stub_const("UserListController::DEFAULT_PAGE_SIZE", 50) }
+
+      it "uses custom page size" do
+        expect(controller.default_page_size).to eq(50)
+      end
+    end
+
+    context "with default page size" do
+      it "uses standard page size" do
+        expect(controller.default_page_size).to eq(25)
+      end
+    end
+  end
+end
+

data/skills/rspec/examples/mocks/doubles.rb

@@ -0,0 +1,139 @@
+# RSpec Mocks: Test Doubles Examples
+# Source: rspec-mocks gem features/basics/test_doubles.feature,
+#         verifying_doubles/*.feature
+
+# Basic double - strict, raises on unexpected messages
+RSpec.describe "basic double" do
+  it "raises on unexpected messages" do
+    dbl = double("collaborator")
+    expect { dbl.foo }.to raise_error(RSpec::Mocks::MockExpectationError)
+  end
+
+  it "can be created with predefined stubs" do
+    dbl = double("collaborator", foo: 3, bar: 4)
+    expect(dbl.foo).to eq(3)
+    expect(dbl.bar).to eq(4)
+  end
+
+  it "can be anonymous with stubs" do
+    dbl = double(foo: "bar", baz: "qux")
+    expect(dbl.foo).to eq("bar")
+    expect(dbl.baz).to eq("qux")
+  end
+end
+
+# instance_double - verifies against instance methods
+RSpec.describe "instance_double" do
+  describe "verification" do
+    it "allows stubbing existing methods" do
+      notifier = instance_double("ConsoleNotifier", notify: true)
+      expect(notifier.notify).to be(true)
+    end
+
+    it "raises if stubbing non-existent method" do
+      notifier = instance_double("ConsoleNotifier")
+      expect {
+        allow(notifier).to receive(:non_existent_method)
+      }.to raise_error(RSpec::Mocks::MockExpectationError, /does not implement/)
+    end
+
+    it "verifies argument arity" do
+      calculator = instance_double("Calculator")
+      expect {
+        allow(calculator).to receive(:add).with(1, 2, 3, 4, 5)
+      }.to raise_error(RSpec::Mocks::MockExpectationError, /wrong number of arguments/)
+    end
+  end
+end
+
+# Practical example with instance_double
+RSpec.describe UserNotificationService do
+  subject(:service) { build(:user_notification_service, notifier:) }
+
+  let(:notifier) { instance_double("ConsoleNotifier") }
+  let(:user) { build(:user) }
+
+  describe "#notify" do
+    it "delegates to the notifier" do
+      expect(notifier).to receive(:notify).with(user.email, "Welcome!")
+      service.notify(user, "Welcome!")
+    end
+  end
+end
+
+# class_double - verifies against class methods
+RSpec.describe "class_double" do
+  describe "replacing constants" do
+    it "can replace the class constant with as_stubbed_const" do
+      fake_mailer = class_double("UserMailer").as_stubbed_const
+      allow(fake_mailer).to receive(:send_welcome)
+
+      # Now UserMailer refers to fake_mailer within this example
+      UserMailer.send_welcome
+      expect(fake_mailer).to have_received(:send_welcome)
+    end
+
+    it "transfers nested constants when requested" do
+      fake_class = class_double("CardDeck").as_stubbed_const(
+        transfer_nested_constants: true
+      )
+      # CardDeck::SUITS and other constants are now available
+      expect(CardDeck::SUITS).to eq(%w[hearts diamonds clubs spades])
+    end
+
+    it "can selectively transfer constants" do
+      fake_class = class_double("CardDeck").as_stubbed_const(
+        transfer_nested_constants: [:SUITS]
+      )
+      # Only SUITS is transferred
+      expect(CardDeck::SUITS).to eq(%w[hearts diamonds clubs spades])
+    end
+  end
+end
+
+# Practical example with class_double
+RSpec.describe OrderProcessor do
+  subject(:processor) { build(:order_processor) }
+
+  let(:payment_gateway) { class_double("PaymentGateway").as_stubbed_const }
+
+  describe "#process" do
+    let(:order) { build(:order, amount: 100) }
+
+    it "charges the payment gateway" do
+      expect(payment_gateway).to receive(:charge).with(100).and_return(true)
+      processor.process(order)
+    end
+  end
+end
+
+# object_double - doubles an existing object instance
+RSpec.describe "object_double" do
+  describe "doubling real objects" do
+    it "avoids side effects while verifying methods" do
+      real_user = User.new
+      user_double = object_double(real_user, save: true)
+
+      expect(user_double.save).to be(true)
+    end
+
+    it "verifies methods exist on the real object" do
+      real_user = User.new
+      user_double = object_double(real_user)
+
+      expect {
+        allow(user_double).to receive(:non_existent)
+      }.to raise_error(RSpec::Mocks::MockExpectationError)
+    end
+  end
+
+  describe "doubling constant objects" do
+    it "can replace global logger" do
+      logger = object_double("MyApp::LOGGER", info: nil, error: nil).as_stubbed_const
+
+      MyApp::LOGGER.info("test message")
+      expect(logger).to have_received(:info).with("test message")
+    end
+  end
+end
+