anima-core 0.2.1 → 1.0.0

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

@@ -0,0 +1,223 @@
+# RSpec Mocks: Configuring Responses Examples
+# Source: rspec-mocks gem features/configuring_responses/*.feature
+
+# and_return - return specified values
+RSpec.describe "and_return" do
+  describe "single value" do
+    it "returns the value on every call" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo).and_return(14)
+
+      expect(dbl.foo).to eq(14)
+      expect(dbl.foo).to eq(14)
+    end
+  end
+
+  describe "consecutive values" do
+    it "returns values in sequence" do
+      die = double("die")
+      allow(die).to receive(:roll).and_return(1, 2, 3)
+
+      expect(die.roll).to eq(1)
+      expect(die.roll).to eq(2)
+      expect(die.roll).to eq(3)
+      expect(die.roll).to eq(3)  # Repeats last value
+    end
+  end
+end
+
+# and_raise - raise exceptions
+RSpec.describe "and_raise" do
+  describe "various forms" do
+    it "raises with string message" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo).and_raise("boom")
+
+      expect { dbl.foo }.to raise_error("boom")
+    end
+
+    it "raises specified error class" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo).and_raise(ArgumentError)
+
+      expect { dbl.foo }.to raise_error(ArgumentError)
+    end
+
+    it "raises error class with message" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo).and_raise(ArgumentError, "invalid")
+
+      expect { dbl.foo }.to raise_error(ArgumentError, "invalid")
+    end
+
+    it "raises error instance" do
+      dbl = double("collaborator")
+      error = StandardError.new("specific error")
+      allow(dbl).to receive(:foo).and_raise(error)
+
+      expect { dbl.foo }.to raise_error(error)
+    end
+  end
+end
+
+# and_yield - yield to blocks
+RSpec.describe "and_yield" do
+  describe "yielding arguments" do
+    it "yields specified values to block" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo).and_yield(2, 3)
+
+      x = y = nil
+      dbl.foo { |a, b| x, y = a, b }
+
+      expect(x).to eq(2)
+      expect(y).to eq(3)
+    end
+  end
+
+  describe "multiple yields" do
+    it "yields multiple times" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:each)
+        .and_yield(1)
+        .and_yield(2)
+        .and_yield(3)
+
+      yielded = []
+      dbl.each { |x| yielded << x }
+
+      expect(yielded).to eq([1, 2, 3])
+    end
+  end
+end
+
+# and_call_original - call real implementation
+RSpec.describe "and_call_original" do
+  describe "partial double with original" do
+    it "calls through to real method" do
+      expect(Calculator).to receive(:add).and_call_original
+      expect(Calculator.add(2, 3)).to eq(5)
+    end
+
+    it "combines with specific stubs" do
+      allow(Calculator).to receive(:add).and_call_original
+      allow(Calculator).to receive(:add).with(2, 3).and_return(-5)
+
+      expect(Calculator.add(2, 2)).to eq(4)   # Calls original
+      expect(Calculator.add(2, 3)).to eq(-5)  # Uses stub
+    end
+  end
+end
+
+# Block implementation - dynamic behavior
+RSpec.describe "block implementation" do
+  describe "simple block" do
+    it "returns block result" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo) { 14 }
+
+      expect(dbl.foo).to eq(14)
+    end
+  end
+
+  describe "block with arguments" do
+    it "receives call arguments" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:greet) { |name| "Hello, #{name}!" }
+
+      expect(dbl.greet("Alice")).to eq("Hello, Alice!")
+    end
+  end
+
+  describe "calculations" do
+    it "performs dynamic calculations" do
+      loan = double("loan", amount: 1000)
+      allow(loan).to receive(:payment_for_rate) { |rate| loan.amount * rate }
+
+      expect(loan.payment_for_rate(0.05)).to eq(50)
+      expect(loan.payment_for_rate(0.10)).to eq(100)
+    end
+  end
+
+  describe "yielding to caller's block" do
+    it "invokes caller's block from implementation" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:process) { |&block| block.call(14) }
+
+      result = nil
+      dbl.process { |x| result = x * 2 }
+
+      expect(result).to eq(28)
+    end
+  end
+
+  describe "simulating failures" do
+    it "simulates transient errors" do
+      client = double("client")
+      call_count = 0
+
+      allow(client).to receive(:fetch_data) do
+        call_count += 1
+        call_count.odd? ? raise("timeout") : { count: 15 }
+      end
+
+      expect { client.fetch_data }.to raise_error("timeout")
+      expect(client.fetch_data).to eq(count: 15)
+      expect { client.fetch_data }.to raise_error("timeout")
+    end
+  end
+end
+
+# and_throw - throw symbols
+RSpec.describe "and_throw" do
+  it "throws specified symbol" do
+    dbl = double("collaborator")
+    allow(dbl).to receive(:halt).and_throw(:abort)
+
+    expect { dbl.halt }.to throw_symbol(:abort)
+  end
+
+  it "throws symbol with value" do
+    dbl = double("collaborator")
+    allow(dbl).to receive(:halt).and_throw(:result, 42)
+
+    expect { dbl.halt }.to throw_symbol(:result, 42)
+  end
+end
+
+# and_invoke - mixed responses per call
+RSpec.describe "and_invoke" do
+  it "executes different lambdas per call" do
+    dbl = double("collaborator")
+    allow(dbl).to receive(:foo).and_invoke(
+      -> { raise "first call fails" },
+      -> { "second call succeeds" }
+    )
+
+    expect { dbl.foo }.to raise_error("first call fails")
+    expect(dbl.foo).to eq("second call succeeds")
+  end
+end
+
+# Practical example: API client with retry
+RSpec.describe ApiClient do
+  subject(:client) { build(:api_client, http:) }
+
+  let(:http) { instance_double("Net::HTTP") }
+
+  describe "#fetch_with_retry" do
+    context "when first request times out" do
+      before do
+        allow(http).to receive(:get).and_invoke(
+          -> { raise Timeout::Error },
+          -> { { data: "success" } }
+        )
+      end
+
+      it "retries and succeeds" do
+        expect(client.fetch_with_retry("/api")).to eq(data: "success")
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,149 @@
+# RSpec Mocks: Spies Examples
+# Source: rspec-mocks gem features/basics/spies.feature,
+#         null_object_doubles.feature
+
+# spy - null object double for arrange-act-assert pattern
+RSpec.describe "spy" do
+  describe "basic usage" do
+    it "allows any message without raising" do
+      invitation = spy("invitation")
+      invitation.deliver  # doesn't raise
+      invitation.foo.bar.baz  # also doesn't raise
+    end
+
+    it "verifies messages after the fact" do
+      invitation = spy("invitation")
+      invitation.deliver("user@example.com")
+
+      expect(invitation).to have_received(:deliver).with("user@example.com")
+    end
+  end
+
+  describe "verifying doubles as spies" do
+    it "can create instance spy" do
+      user = instance_spy("User")
+      user.save
+      expect(user).to have_received(:save)
+    end
+
+    it "can create class spy" do
+      notifier = class_spy("UserMailer")
+      notifier.send_welcome("email@example.com")
+      expect(notifier).to have_received(:send_welcome)
+    end
+
+    it "can create object spy" do
+      real_user = User.new
+      user = object_spy(real_user)
+      user.save
+      expect(user).to have_received(:save)
+    end
+  end
+
+  describe "spy constraints" do
+    it "verifies call count" do
+      invitation = spy("invitation")
+      invitation.deliver
+      invitation.deliver
+
+      expect(invitation).to have_received(:deliver).twice
+    end
+
+    it "verifies message order" do
+      invitation = spy("invitation")
+      invitation.prepare
+      invitation.deliver
+
+      expect(invitation).to have_received(:prepare).ordered
+      expect(invitation).to have_received(:deliver).ordered
+    end
+
+    it "verifies arguments" do
+      invitation = spy("invitation")
+      invitation.deliver("foo@example.com")
+      invitation.deliver("bar@example.com")
+
+      expect(invitation).to have_received(:deliver).with("foo@example.com")
+      expect(invitation).to have_received(:deliver).with("bar@example.com")
+    end
+  end
+end
+
+# Practical example: arrange-act-assert with spies
+RSpec.describe InvitationService do
+  subject(:service) { build(:invitation_service, mailer:) }
+
+  let(:mailer) { spy("mailer") }
+  let(:user) { build(:user, email: "test@example.com") }
+
+  describe "#send_invitation" do
+    it "sends email to the user" do
+      # Arrange (done in let blocks)
+
+      # Act
+      service.send_invitation(user)
+
+      # Assert
+      expect(mailer).to have_received(:deliver).with(user.email)
+    end
+
+    it "sends invitation with correct template" do
+      service.send_invitation(user)
+
+      expect(mailer).to have_received(:deliver)
+        .with(user.email)
+        .once
+    end
+  end
+end
+
+# null object double
+RSpec.describe "null object double" do
+  describe "as_null_object" do
+    it "returns itself for any message" do
+      dbl = double("collaborator").as_null_object
+      expect(dbl.foo.bar.baz).to be(dbl)
+    end
+
+    it "can have specific stubs" do
+      dbl = double("collaborator", foo: 3).as_null_object
+      allow(dbl).to receive(:bar).and_return(4)
+
+      expect(dbl.foo).to eq(3)
+      expect(dbl.bar).to eq(4)
+      expect(dbl.undefined_method).to be(dbl)
+    end
+  end
+end
+
+# Practical use: chained methods without full stubbing
+RSpec.describe QueryBuilder do
+  subject(:builder) { build(:query_builder) }
+
+  let(:query) { instance_spy("ActiveRecord::Relation").as_null_object }
+
+  describe "#build" do
+    before { allow(User).to receive(:where).and_return(query) }
+
+    it "chains query methods" do
+      builder.build(status: :active, role: :admin)
+
+      expect(query).to have_received(:where).with(status: :active)
+      expect(query).to have_received(:where).with(role: :admin)
+    end
+  end
+end
+
+# Partial doubles with spies
+RSpec.describe "partial double spy pattern" do
+  describe "spying on real objects" do
+    it "allows spying on class methods" do
+      allow(Invitation).to receive(:deliver)
+
+      Invitation.deliver("test@example.com")
+
+      expect(Invitation).to have_received(:deliver).with("test@example.com")
+    end
+  end
+end
+

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

@@ -0,0 +1,133 @@
+# RSpec Mocks: Stubbing (allow) Examples
+# Source: rspec-mocks gem features/basics/allowing_messages.feature,
+#         partial_test_doubles.feature
+
+# Basic allow syntax
+RSpec.describe "allow (stubbing)" do
+  describe "basic stubs" do
+    it "returns nil by default" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo)
+
+      expect(dbl.foo).to be_nil
+    end
+
+    it "returns specified value with and_return" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo).and_return("bar")
+
+      expect(dbl.foo).to eq("bar")
+    end
+
+    it "returns value with block syntax" do
+      dbl = double("collaborator")
+      allow(dbl).to receive(:foo) { "bar" }
+
+      expect(dbl.foo).to eq("bar")
+    end
+  end
+
+  describe "multiple stubs" do
+    it "stubs multiple methods with receive_messages" do
+      dbl = double("collaborator")
+      allow(dbl).to receive_messages(
+        title: "The RSpec Book",
+        subtitle: "BDD with RSpec"
+      )
+
+      expect(dbl.title).to eq("The RSpec Book")
+      expect(dbl.subtitle).to eq("BDD with RSpec")
+    end
+  end
+end
+
+# Partial doubles - stubbing methods on real objects
+RSpec.describe "partial doubles" do
+  describe "stubbing real objects" do
+    it "stubs specific methods while preserving others" do
+      string = "a string"
+      allow(string).to receive(:length).and_return(500)
+
+      expect(string.length).to eq(500)
+      expect(string.reverse).to eq("gnirts a")  # Still works
+    end
+
+    it "stubs class methods" do
+      allow(User).to receive(:find).and_return(build(:user, name: "Stubbed"))
+
+      expect(User.find(1).name).to eq("Stubbed")
+    end
+  end
+
+  describe "stub restoration" do
+    # Stubs are automatically restored after each example
+    it "first example stubs User.count" do
+      allow(User).to receive(:count).and_return(100)
+      expect(User.count).to eq(100)
+    end
+
+    it "next example has original behavior" do
+      # User.count works normally again
+      expect(User.count).to be_a(Integer)
+    end
+  end
+end
+
+# Practical example: stubbing external services
+RSpec.describe WeatherService do
+  subject(:service) { build(:weather_service, client:) }
+
+  let(:client) { instance_double("HTTPClient") }
+
+  describe "#temperature" do
+    context "when API returns data" do
+      before do
+        allow(client).to receive(:get)
+          .with("/weather", hash_including(zip: "12345"))
+          .and_return(temp: 72, humidity: 45)
+      end
+
+      it "extracts temperature from response" do
+        expect(service.temperature("12345")).to eq(72)
+      end
+    end
+
+    context "when API returns nil" do
+      before do
+        allow(client).to receive(:get).and_return(nil)
+      end
+
+      it "returns default value" do
+        expect(service.temperature("12345")).to eq(0)
+      end
+    end
+  end
+end
+
+# Practical example: isolating database calls
+RSpec.describe ReportGenerator do
+  subject(:generator) { build(:report_generator) }
+
+  describe "#monthly_summary" do
+    let(:orders) { build_list(:order, 3, total: 100) }
+
+    before do
+      allow(Order).to receive(:where).and_return(orders)
+      allow(orders).to receive(:sum).with(:total).and_return(300)
+    end
+
+    it "calculates total from orders" do
+      summary = generator.monthly_summary(Date.current)
+      expect(summary[:total]).to eq(300)
+    end
+
+    it "queries orders for the month" do
+      generator.monthly_summary(Date.new(2024, 1, 15))
+
+      expect(Order).to have_received(:where).with(
+        created_at: Date.new(2024, 1, 1)..Date.new(2024, 1, 31)
+      )
+    end
+  end
+end
+