mocktail 2.0.0 → 3.0.0

data/sub_projects/sorbet_user/sorbet/tapioca/config.yml

@@ -0,0 +1,13 @@
+gem:
+  # Add your `gem` command parameters here:
+  #
+  # exclude:
+  # - gem_name
+  # doc: true
+  # workers: 5
+dsl:
+  # Add your `dsl` command parameters here:
+  #
+  # exclude:
+  # - SomeGeneratorName
+  # workers: 5

data/sub_projects/sorbet_user/sorbet/tapioca/require.rb

@@ -0,0 +1,4 @@
+# typed: true
+# frozen_string_literal: true
+
+# Add your extra requires here (`bin/tapioca require` can be used to bootstrap this list)

data/sub_projects/sorbet_user/test/ensure_type_safety_test.rb

@@ -0,0 +1,21 @@
+# typed: false
+
+require "test_helper"
+
+class EnsureTypeSafetyTest < Minitest::Test
+  def test_basic_case
+    msg = assert_type_failure "\"foo\" + 1"
+
+    assert_includes msg, "Expected `String` but found `Integer(1)`"
+  end
+
+  def test_strict_case
+    msg = assert_strict_type_failure <<~RUBY
+      def foo
+        "no sig"
+      end
+    RUBY
+
+    assert_includes msg, "The method `foo` does not have a `sig`"
+  end
+end

data/sub_projects/sorbet_user/test/paint_by_number_test.rb

@@ -0,0 +1,113 @@
+# typed: strict
+
+require "test_helper"
+
+class Region < T::Struct
+  const :number, Integer
+  const :color, T.nilable(Symbol)
+end
+
+class Page < T::Struct
+  const :regions, T::Array[Region]
+end
+
+class BlankBook < T::Struct
+  const :pages, T::Array[Page], default: []
+  const :color_map, T::Hash[Integer, Symbol], default: {}
+end
+
+class PaintedBook < T::Struct
+  const :pages, T::Array[Page], default: []
+  const :author, String
+end
+
+class AssemblesBook
+  extend T::Sig
+
+  sig { params(blank_book: BlankBook, author: String, painted_regions: T::Array[Region]).returns(PaintedBook) }
+  def assemble(blank_book, author:, painted_regions:)
+    PaintedBook.new(pages: [], author: author)
+  end
+end
+
+class MatchesPaint
+  extend T::Sig
+
+  sig { params(number: Integer).returns(Symbol) }
+  def match(number)
+    :a_color
+  end
+end
+
+class PaintsRegion
+  extend T::Sig
+
+  sig { params(region: Region, color: Symbol).returns(Region) }
+  def paint(region, color)
+    Region.new(number: region.number, color: color)
+  end
+end
+
+class PaintsByNumber
+  extend T::Sig
+
+  sig { void }
+  def initialize
+    @matches_paint = T.let(MatchesPaint.new, MatchesPaint)
+    @paints_region = T.let(PaintsRegion.new, PaintsRegion)
+    @assembles_book = T.let(AssemblesBook.new, AssemblesBook)
+  end
+
+  sig { params(blank_book: BlankBook, author: String).returns(PaintedBook) }
+  def paint(blank_book, author:)
+    regions = blank_book.pages.flat_map { |page| page.regions }
+
+    colors = regions.map(&:number).uniq.map { |number|
+      [number, @matches_paint.match(number)]
+    }.to_h
+
+    painted_regions = regions.map { |region| @paints_region.paint(region, colors.fetch(region.number)) }
+
+    @assembles_book.assemble(blank_book, painted_regions: painted_regions, author: author)
+  end
+end
+
+class PaintByNumberTest < Minitest::Test
+  extend T::Sig
+
+  sig { params(name: String).void }
+  def initialize(name)
+    super
+    @matches_paint = T.let(Mocktail.of_next(MatchesPaint), MatchesPaint)
+    @paints_region = T.let(Mocktail.of_next(PaintsRegion), PaintsRegion)
+    @assembles_book = T.let(Mocktail.of_next(AssemblesBook), AssemblesBook)
+
+    @subject = T.let(PaintsByNumber.new, PaintsByNumber)
+  end
+
+  sig { void }
+  def test_paints_by_number
+    blank_book = BlankBook.new(pages: [
+      Page.new(regions: [
+        region_1 = Region.new(number: 1),
+        region_2 = Region.new(number: 2)
+      ]),
+      Page.new(regions: [region_3 = Region.new(number: 3)])
+    ])
+    region_1_painted = Region.new(number: 1)
+    region_2_painted = Region.new(number: 2)
+    region_3_painted = Region.new(number: 3)
+    stubs { @matches_paint.match(1) }.with { :orange }
+    stubs { @matches_paint.match(2) }.with { :green }
+    stubs { @matches_paint.match(3) }.with { :blue }
+    stubs { @paints_region.paint(region_1, :orange) }.with { region_1_painted }
+    stubs { @paints_region.paint(region_2, :green) }.with { region_2_painted }
+    stubs { @paints_region.paint(region_3, :blue) }.with { region_3_painted }
+    expected_painted_book = PaintedBook.new(pages: [], author: "Doesn't matter")
+    stubs { @assembles_book.assemble(blank_book, author: "Juice", painted_regions: [region_1_painted, region_2_painted, region_3_painted]) }.with { expected_painted_book }
+
+    result = @subject.paint(blank_book, author: "Juice")
+
+    assert_equal result, expected_painted_book
+  end
+end

data/sub_projects/sorbet_user/test/sorbet_test.rb

@@ -0,0 +1,289 @@
+# typed: strict
+
+require "test_helper"
+
+class SherbetTest < Minitest::Test
+  class Sherbet
+    extend T::Sig
+
+    sig { returns(Symbol) }
+    attr_reader :flavor
+
+    sig { params(size: T.nilable(Integer), sound: T.untyped).returns(Symbol) }
+    def lick(size: nil, sound: nil)
+      return :none if size.nil?
+      puts "Stop making this sound #{sound.inspect}"
+
+      if size > 10
+        :big
+      elsif size > 5
+        :medium
+      else
+        :small
+      end
+    end
+
+    sig { void }
+    def initialize
+      @flavor = T.let(:orange, Symbol)
+    end
+  end
+
+  include Mocktail::DSL
+  extend T::Sig
+
+  sig { void }
+  def test_stubbing
+    sherbet = Mocktail.of(Sherbet)
+    T.assert_type!(sherbet, Sherbet)
+
+    stubs { sherbet.flavor }.with { :strawberry }
+
+    assert_equal :strawberry, sherbet.flavor
+    T.assert_type!(sherbet.flavor, Symbol)
+  end
+
+  # This test makes sure the returns(T.anything) in
+  # lib/mocktail/handles_dry_call.rb doesn't cause issues for the test-scoped code
+  sig { void }
+  def test_stubbing_that_invokes_methods_on_return_value
+    sherbet = Mocktail.of(Sherbet)
+    T.assert_type!(sherbet, Sherbet)
+
+    stubs { sherbet.flavor }.with { :gooberry }
+
+    assert_equal :gooberry.to_s.to_sym, sherbet.flavor
+    T.assert_type!(sherbet.flavor, Symbol)
+  end
+
+  sig { void }
+  def test_stubbing_with_all_dem_options
+    sherbet = Mocktail.of(Sherbet)
+    T.assert_type!(sherbet, Sherbet)
+
+    Mocktail.stubs(
+      ignore_block: true,
+      ignore_extra_args: true,
+      ignore_arity: false,
+      times: 4
+    ) { sherbet.flavor }.with { :strawberry }
+
+    assert_equal :strawberry, sherbet.flavor
+    T.assert_type!(sherbet.flavor, Symbol)
+  end
+
+  sig { void }
+  def test_stubbing_with_matchers
+    sherbet = Mocktail.of(Sherbet)
+    T.assert_type!(sherbet, Sherbet)
+
+    stubs { |m|
+      T.assert_type!(m, Mocktail::MatcherPresentation)
+      sherbet.lick(size: m.is_a(Integer))
+    }.with { :tiny }
+    stubs { |m| sherbet.lick(size: 2, sound: m.any) }.with { :skosh }
+
+    T.assert_type!(sherbet.lick(size: 5), Symbol)
+    assert_equal :tiny, sherbet.lick(size: 1)
+    assert_nil sherbet.lick(size: T.unsafe(nil))
+
+    assert_equal :skosh, sherbet.lick(size: 2, sound: "yum")
+    assert_equal :skosh, sherbet.lick(size: 2, sound: nil)
+  end
+
+  class MatcherThing
+    extend T::Sig
+
+    sig { params(array: T::Array[Symbol]).void }
+    def takes_array(array)
+    end
+
+    sig { params(hash: T::Hash[Symbol, Integer]).void }
+    def takes_hash(hash)
+    end
+
+    sig { params(string: String).void }
+    def takes_string(string)
+    end
+
+    sig { params(integer: Integer).void }
+    def takes_integer(integer)
+    end
+  end
+
+  sig { void }
+  def test_matchers_more_precisely
+    thing = Mocktail.of(MatcherThing)
+
+    stubs { |m| thing.takes_array(m.includes(:ham)) }.with { nil }
+    stubs { |m| thing.takes_array(m.includes(:ham, :cheese)) }.with { nil }
+
+    stubs { |m| thing.takes_hash(m.includes_key(:ham)) }.with { nil }
+    stubs { |m| thing.takes_hash(m.includes_hash({cheese: 1}, {queso: 2})) }.with { nil }
+
+    stubs { |m| thing.takes_string(m.includes_string("s")) }.with { nil }
+    stubs { |m| thing.takes_string(m.includes_string("s", "t")) }.with { nil }
+
+    stubs { |m| thing.takes_string(m.matches("s")) }.with { nil }
+    stubs { |m| thing.takes_string(m.matches(/s/)) }.with { nil }
+
+    stubs { |m| thing.takes_integer(m.numeric) }.with { nil }
+
+    stubs { |m| thing.takes_integer(m.that { |i| i < 3 }) }.with { nil }
+
+    stubs { |m| thing.takes_integer(m.not(3)) }.with { nil }
+  end
+
+  class Is5Matcher < Mocktail::Matchers::Base
+    extend T::Sig
+
+    sig { returns(Symbol) }
+    def self.matcher_name
+      :is_5
+    end
+
+    sig { void }
+    def initialize
+      # Empty initialize is necessary b/c Base default expects an argument
+    end
+
+    sig { params(actual: T.untyped).returns(T::Boolean) }
+    def match?(actual)
+      actual == 5
+    end
+
+    sig { returns(String) }
+    def inspect
+      "is_5"
+    end
+  end
+  Mocktail.register_matcher(Is5Matcher)
+
+  sig { void }
+  def test_custom_matchers
+    thing = Mocktail.of(MatcherThing)
+
+    stubs { |m| thing.takes_integer(m.is_5) }.with { 8 }
+
+    assert_equal 8, thing.takes_integer(5)
+    assert_nil thing.takes_integer(9)
+  end
+
+  class Wastebin
+    extend T::Sig
+
+    sig {
+      params(thing: Sherbet).void
+    }
+    def dump(thing)
+    end
+  end
+  sig { void }
+  def test_verify
+    wastebin = Mocktail.of(Wastebin)
+    sherbet = Mocktail.of(Sherbet)
+
+    wastebin.dump(sherbet)
+
+    verify { wastebin.dump(sherbet) }
+    verify(
+      ignore_block: true,
+      ignore_extra_args: true,
+      ignore_arity: false,
+      times: 1
+    ) { wastebin.dump(sherbet) }
+    verify(
+      ignore_extra_args: true,
+      ignore_arity: true
+    ) { T.unsafe(wastebin).dump }
+  end
+
+  sig { void }
+  def test_captors
+    wastebin = Mocktail.of(Wastebin)
+    sherbet = Sherbet.new
+    captor = Mocktail.captor
+    T.assert_type!(captor, Mocktail::Matchers::Captor)
+
+    wastebin.dump(sherbet)
+
+    verify { wastebin.dump(captor.capture) }
+    assert_equal sherbet, captor.value
+  end
+
+  sig { void }
+  def test_of_next
+    sherbet = Mocktail.of_next(Sherbet, count: 1)
+    T.assert_type!(sherbet, Sherbet)
+
+    assert_equal sherbet, Sherbet.new
+  end
+
+  sig { void }
+  def test_of_next_with_count
+    sherbet = Mocktail.of_next_with_count(Sherbet, 2)
+    T.assert_type!(sherbet, T::Array[Sherbet])
+  end
+
+  sig { void }
+  def test_alias_of_next_with_count
+    sherbets = Mocktail.of_next_with_count(Sherbet, 2)
+
+    assert_equal 2, sherbets.size
+  end
+
+  module Button
+    extend T::Sig
+
+    sig { params(pressure: Integer, finger: T.any(String, Symbol)).void }
+    def self.push(pressure, finger:)
+    end
+  end
+
+  sig { void }
+  def test_replace
+    Mocktail.replace(Button)
+
+    Button.push(1, finger: :thumb)
+    Button.push(2, finger: :pinky)
+    Button.push(1, finger: "index finger")
+    assert_match(/redefines_singleton_methods/, Button.method(:push).source_location.first)
+
+    verify(times: 1) { |m| Button.push(1, finger: m.is_a(Symbol)) }
+    verify { |m| Button.push(1, finger: m.includes_string("index")) }
+  end
+
+  sig { void }
+  def test_explain
+    sherbet = Mocktail.of(Sherbet)
+
+    sherbet.flavor
+
+    explanation = Mocktail.explain(sherbet)
+
+    ref = explanation.reference
+    if !ref.is_a?(Sherbet)
+      assert_kind_of Mocktail::DoubleData, ref
+      T.assert_type!(ref.calls, T::Array[Mocktail::Call])
+      T.assert_type!(ref.stubbings, T::Array[Mocktail::Stubbing[T.untyped]])
+    end
+
+    explanation_2 = Mocktail.explain(sherbet.method(:flavor))
+    ref_2 = explanation_2.reference
+    if !ref_2.is_a?(Method)
+      assert_kind_of Mocktail::FakeMethodData, ref_2
+      T.assert_type!(ref_2.calls, T::Array[Mocktail::Call])
+      T.assert_type!(ref.stubbings, T::Array[Mocktail::Stubbing[T.untyped]])
+    end
+
+    Mocktail.replace(Button)
+
+    explanation_3 = Mocktail.explain(Button)
+    ref_3 = explanation_3.reference
+    if !ref_3.is_a?(Module)
+      assert_kind_of Mocktail::TypeReplacementData, ref_3
+      T.assert_type!(ref_3.calls, T::Array[Mocktail::Call])
+      T.assert_type!(ref.stubbings, T::Array[Mocktail::Stubbing[T.untyped]])
+    end
+  end
+end

data/sub_projects/sorbet_user/test/test_helper.rb

@@ -0,0 +1,35 @@
+# typed: true
+
+require "mocktail/sorbet" # <-- the special sauce!
+require "minitest/autorun"
+
+require "tempfile"
+require "open3"
+module SorbetInsurance
+  include Kernel
+
+  def assert_type_failure(ruby_code, mode: "true")
+    Tempfile.create do |file|
+      file.write("# typed: strict\n\n" + ruby_code)
+      file.flush
+      stdout, stderr, status = Open3.capture3("bundle exec srb tc #{file.path}")
+      raise "Type passing succeeded but expected failure (stdout: #{stdout})" if status.success?
+      "#{stdout}\n#{stderr}"
+    end
+  end
+
+  def assert_strict_type_failure(ruby_code)
+    assert_type_failure(ruby_code, mode: "strict")
+  end
+end
+
+class Minitest::Test
+  include SorbetInsurance
+  include Mocktail::DSL
+
+  make_my_diffs_pretty!
+
+  def teardown
+    Mocktail.reset
+  end
+end

data/sub_projects/untyped_user/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem "mocktail", path: "../.."
+gem "minitest", "~> 5.26" # 6.0+ requires Ruby >= 3.2, dropping support for Ruby 3.1

data/sub_projects/untyped_user/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: ../..
+  specs:
+    mocktail (3.0.0)
+      sorbet-eraser (~> 0.3.1)
+      sorbet-runtime (~> 0.5.9204)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.27.0)
+    sorbet-eraser (0.3.1)
+    sorbet-runtime (0.5.11971)
+
+PLATFORMS
+  arm64-darwin-22
+  arm64-darwin-24
+  arm64-darwin-25
+
+DEPENDENCIES
+  minitest (~> 5.26)
+  mocktail!
+
+BUNDLED WITH
+   2.4.13

data/sub_projects/untyped_user/antitype_test.rb

@@ -0,0 +1,54 @@
+require "minitest/autorun"
+require "mocktail"
+
+class AntitypeTest < Minitest::Test
+  include Mocktail::DSL
+
+  module Stuff
+    def things(pants, shirts, sandals:)
+    end
+  end
+
+  def test_mocking_modules
+    stuff = Mocktail.of(Stuff)
+
+    stubs(ignore_arity: true, ignore_extra_args: true) { stuff.things }.with { "things" }
+
+    assert_equal "things", stuff.things(1, 2, sandals: 3)
+  end
+
+  class Stuffing
+    include Stuff
+  end
+
+  def test_matchers
+    stuff = Mocktail.of(Stuff)
+
+    stubs { stuff.things(:zubon, :shatsu, sandals: false) }.with { "things" }
+    stubs { |m| stuff.things(m.numeric, m.is_a(Stuff), sandals: m.includes(true)) }.with { "crap" }
+
+    assert_equal "things", stuff.things(:zubon, :shatsu, sandals: false)
+    assert_equal "crap", stuff.things(42, Stuffing.new, sandals: [true, false])
+    assert_nil stuff.things(42, Stuffing.new, sandals: ["true"])
+    assert_nil stuff.things("42", Stuffing.new, sandals: [true])
+    assert_nil stuff.things(42, Stuffing, sandals: [true])
+
+    stuff.things(:a, :b, sandals: :c)
+    stuff.things(:c, :d, sandals: :e)
+    stuff.things(:f, :g, sandals: :h)
+
+    captor = Mocktail.captor
+    verify { stuff.things(:c, captor.capture, sandals: :e) }
+    assert_equal captor.value, :d
+  end
+
+  def test_sorbet_runtime_is_not_loaded
+    refute $LOADED_FEATURES.any? { |feature|
+      feature.include?("sorbet-runtime")
+    }, "sorbet-runtime was required by something in mocktail. Features:\n\n#{$LOADED_FEATURES.join("\n")}"
+  end
+
+  def teardown
+    Mocktail.reset
+  end
+end

data/sub_projects/untyped_user/script/test

@@ -0,0 +1,5 @@
+#/usr/bin/env bash
+
+set -xeuo pipefail
+
+bundle exec ruby antitype_test.rb