vcr_stripe_webhook 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3a8235b3c64f4d6c484b72c9338943983f32edbef036d4490099792ebb5613ac
+  data.tar.gz: 6c772cedb526c96fd06a4eab52be8892d5a1884a33bddf9455537e998592eca4
+SHA512:
+  metadata.gz: ea08bd8d64a7c372365dc7a8b42903f82acda35a195b8e1df31025d68dedb4a7929883c723b0e38e26ccaf5cd32b25efe6fff450b4934a7344bb249387074ec2
+  data.tar.gz: 8cce67fa17d558e942a744c29f9201af74c6d3584688229205ecd6967284f9267d540fd22ef078036b5f3f6d9d57f3987b96e136e8e7b2b26c8ef94a655268d2

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,28 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+3.0.6

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+## [Unreleased]
+
+## [0.3.0] - 2024-12-01
+
+- Update gem dependencies
+- Fix typo
+
+## [0.2.0] - 2023-10-16
+
+- Add new methods
+  - `VcrStripeWebhook.receive_webhook_event`
+  - `VcrStripeWebhook.receive_webhook_events`
+
+### Breaking changes
+
+- Remove `VcrStripeWebhook.receive_webhook`
+
+## [0.1.0] - 2023-10-05
+
+- Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in vcr_stripe_webhook.gemspec
+gemspec
+
+gem "rake"
+gem "rspec"
+gem "rubocop"

data/Gemfile.lock

@@ -0,0 +1,83 @@
+PATH
+  remote: .
+  specs:
+    vcr_stripe_webhook (0.3.0)
+      stripe (>= 9.0)
+      vcr (~> 6.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
+    ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.8)
+    crack (1.0.0)
+      bigdecimal
+      rexml
+    diff-lcs (1.5.1)
+    dotenv (3.1.4)
+    hashdiff (1.1.2)
+    json (2.8.2)
+    language_server-protocol (3.17.0.3)
+    parallel (1.26.3)
+    parser (3.3.6.0)
+      ast (~> 2.4.1)
+      racc
+    public_suffix (6.0.1)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.2.1)
+    regexp_parser (2.9.3)
+    rexml (3.3.9)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.2)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+    rubocop (1.69.0)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.4, < 3.0)
+      rubocop-ast (>= 1.36.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.36.2)
+      parser (>= 3.3.1.0)
+    ruby-progressbar (1.13.0)
+    stripe (13.2.0)
+    unicode-display_width (3.1.2)
+      unicode-emoji (~> 4.0, >= 4.0.4)
+    unicode-emoji (4.0.4)
+    vcr (6.3.1)
+      base64
+    webmock (3.24.0)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  dotenv (~> 3.0)
+  rake
+  rspec
+  rubocop
+  vcr_stripe_webhook!
+  webmock (~> 3.0)
+
+BUNDLED WITH
+   2.4.20

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Shunichi Ikegami
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+# VcrStripeWebhook
+
+Record and replay Stripe webhooks during integration test.
+
+## Requirements
+
+- [vcr gem](https://github.com/vcr/vcr)
+- [Stripe CLI](https://stripe.com/docs/stripe-cli)
+
+## Installation
+
+Add this gem to Gemfile.
+
+```
+gem 'vcr_stripe_webhook', github: 'shunichi/vcr_stripe_webhook'
+```
+
+## Usage
+
+```ruby
+# Set Stripe API key for test mode
+Stripe.api_key = 'sk_test_...'
+```
+
+Use `VcrStripeWebhook.use_cassette` instead of `VCR.use_cassette`.
+
+```ruby
+# This method wraps VCR.use_cassette
+VcrStripeWebhook.use_cassette('create_customer') do |vcr_cassette|
+  stripe_customer = nil
+
+  # Get webhook payload from Stripe server or current cassette
+  webhook_event = VcrStripeWebhook.receive_webhook_event('customer.created') do
+    customer_params = {
+      email: 'test-user@example.com',
+      name: 'test-user',
+    }
+    stripe_customer = Stripe::Customer.create(customer_params)
+  end
+
+  # Call your webhook manually
+  post your_stripe_webhook_path, params: webhook_event.as_json,
+    headers: { 'Content-Type: application/json' }
+
+  # Insert assertion here
+ensure
+  stripe_customer&.delete
+end
+```
+
+On the first run, this code records HTTP requests/responses with VCR gem and additionally records received webhooks with vcr_stripe_webhook gem.
+On the second run or later, it replays the recorded requests, responses and webhooks.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/shunichi/vcr_stripe_webhook.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/vcr_stripe_webhook/configuration.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module VcrStripeWebhook
+  class Configuration
+    DEFAULT_TIMEOUT_SEC = 5
+
+    attr_writer :timeout, :cassette_library_dir, :stripe_api_key
+
+    def timeout
+      @timeout ||= DEFAULT_TIMEOUT_SEC
+    end
+
+    def cassette_library_dir
+      @cassette_library_dir ||=
+        File.join(VCR.configuration.cassette_library_dir, "stripe_webhooks")
+    end
+
+    def stripe_api_key
+      @stripe_api_key ||= Stripe.api_key
+    end
+  end
+end

data/lib/vcr_stripe_webhook/error.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module VcrStripeWebhook
+  class Error < StandardError
+  end
+
+  class EventWaitTimeout < Error
+  end
+
+  class CassetteDataError < Error
+  end
+end

data/lib/vcr_stripe_webhook/event.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module VcrStripeWebhook
+  class Event
+    attr_reader :type
+
+    def initialize(type, event_hash)
+      @type = type
+      @event_hash = event_hash
+    end
+
+    def to_h
+      {
+        "type" => type,
+        "value" => as_hash
+      }
+    end
+
+    def as_hash
+      @event_hash
+    end
+
+    def as_json
+      @json = JSON.generate(@event_hash)
+    end
+
+    class << self
+      def from_hash(hash)
+        Event.new(hash["type"], hash["value"])
+      end
+    end
+  end
+end

data/lib/vcr_stripe_webhook/event_cassette.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require_relative "event"
+require_relative "error"
+
+module VcrStripeWebhook
+  class EventCassette
+    attr_reader :name, :vcr_cassette
+
+    def initialize(name, vcr_cassette, recording)
+      @mutex = Mutex.new
+      @name = name
+      @vcr_cassette = vcr_cassette
+      @recording = recording
+      if recording
+        @data = Data.new
+      else
+        @data = Data.deserialize(path)
+        @wait_counter = 0
+      end
+    end
+
+    def path
+      dir = VcrStripeWebhook.configuration.cassette_library_dir
+      File.join(dir, "#{name}.stripe_webhooks.yml")
+    end
+
+    def recording?
+      @recording
+    end
+
+    def wait_for_events(waiter, timeout:, &block)
+      if recording?
+        record_and_wait_for_events(waiter, timeout: timeout, &block)
+      else
+        replay_and_wait_for_events(waiter, &block)
+      end
+    end
+
+    def receive_event_payload(event)
+      @mutex.synchronize do
+        @data.events.push(event)
+      end
+    end
+
+    def serialize
+      @data.serialize(path)
+    end
+
+    private
+
+    def record_and_wait_for_events(waiter, timeout:)
+      wait_start = @data.events.size
+
+      yield
+
+      start_time = Time.now
+      loop do
+        finished = false
+        target_events = nil
+        @mutex.synchronize do
+          wait_end = @data.events.size
+          target_events = @data.events[wait_start...wait_end]
+          finished = waiter.call(target_events)
+          @data.waits.push(Wait.new(wait_start, wait_end)) if finished
+        end
+
+        return target_events if finished
+
+        if Time.now - start_time > timeout
+          message = waiter.timeout_message(target_events, recording: true)
+          raise EventWaitTimeout, message
+        end
+
+        sleep 0.5
+      end
+    end
+
+    def replay_and_wait_for_events(waiter)
+      wait = @data.waits[@wait_counter]
+      if wait.nil?
+        raise CassetteDataError, <<~ERROR_MESSAGE
+          receive_webhook_event(s) calls is more than the calls in the recorded data.
+          If you modify test code after recording, record real webhooks again.
+        ERROR_MESSAGE
+      end
+
+      yield
+
+      target_events = @data.events[wait.start...wait.end]
+      finished = waiter.call(target_events)
+      unless finished
+        message = waiter.timeout_message(target_events, recording: false)
+        raise raise CassetteDataError, message
+      end
+
+      @wait_counter += 1
+      target_events
+    end
+
+    def logger
+      VcrStripeWebhook.logger
+    end
+
+    class Wait
+      attr_reader :start, :end
+
+      def initialize(wait_start, wait_end)
+        @start = wait_start
+        @end = wait_end
+      end
+
+      def to_h
+        {
+          "start" => start,
+          "end" => self.end
+        }
+      end
+
+      class << self
+        def from_hash(hash)
+          Wait.new(hash["start"], hash["end"])
+        end
+      end
+    end
+
+    class Data
+      attr_reader :events, :waits
+
+      def initialize(events: [], waits: [])
+        @events = events
+        @waits = waits
+      end
+
+      def serialize(path)
+        yaml = YAML.dump({
+                           "events" => @events.map(&:to_h),
+                           "waits" => @waits.map(&:to_h)
+                         })
+        FileUtils.mkdir_p File.dirname(path)
+        File.write(path, yaml)
+      end
+
+      class << self
+        def deserialize(path)
+          yaml = YAML.safe_load_file(path, permitted_classes: [])
+          events = yaml["events"].map { |event_hash| Event.from_hash(event_hash) }
+          waits = yaml["waits"].map { |hash| Wait.from_hash(hash) }
+          Data.new(events: events, waits: waits)
+        end
+      end
+    end
+  end
+end

data/lib/vcr_stripe_webhook/event_receiver.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "server"
+require_relative "stripe_cli"
+
+module VcrStripeWebhook
+  class EventReceiver
+    class << self
+      def instance
+        @instance ||= EventReceiver.new
+      end
+
+      def terminate
+        return unless @instance
+
+        @instance.stop
+        @instance = nil
+      end
+    end
+
+    def initialize
+      @started = false
+    end
+
+    def start
+      return if @started
+
+      api_key = VcrStripeWebhook.configuration.stripe_api_key
+
+      @fence_mutex = Mutex.new
+      @fence_cond_var = ConditionVariable.new
+      @fence_test_clock_id = nil
+      @fence_signaled = false
+      @last_fence_event_created = nil
+
+      @cassette = nil
+      @server = VcrStripeWebhook::Server.new do |payload|
+        receive_webhook(payload)
+      end
+      @cli = VcrStripeWebhook::StripeCLI.new(@server.port, api_key)
+      @started = true
+    end
+
+    def stop
+      @cli.terminate
+      @server.close
+      @started = false
+    end
+
+    def use_cassette(cassette)
+      if cassette.recording?
+        start
+        logger.info "Using cassette: #{cassette.name}"
+        @cassette = cassette
+        yield cassette.vcr_cassette
+        logger.info "Eject cassette: #{cassette.name}"
+        @cassette = nil
+        wait_for_rest_webhooks
+      else
+        yield cassette.vcr_cassette
+      end
+    end
+
+    # Create and delete dummy test clock to wait for the rest webhooks to be received.
+    # Stripe doesn’t guarantee delivery of events in the order in which they’re generated.
+    # But waiting dummy test clock event lower the probability of webhook ordering problem.
+    def wait_for_rest_webhooks
+      time = Time.now
+      name = "vcr_sw_fence_#{time.to_i}_#{SecureRandom.alphanumeric}"
+      test_clock = nil
+      @fence_mutex.synchronize do
+        raise "Fence already used!" if @fence_test_clock_id
+
+        @fence_signaled = false
+        test_clock = Stripe::TestHelpers::TestClock.create(frozen_time: time.to_i, name: name)
+        @fence_test_clock_id = test_clock.id
+      end
+      test_clock.delete
+      @fence_mutex.synchronize do
+        loop do
+          break if @fence_signaled
+
+          @fence_cond_var.wait(@fence_mutex, VcrStripeWebhook.configuration.timeout)
+        end
+        @fence_test_clock_id = nil
+      end
+    end
+
+    private
+
+    def receive_webhook(payload)
+      event_hash = JSON.parse(payload)
+      if @last_fence_event_created && event_hash["created"] < @last_fence_event_created
+        logger.info "Ignore old event: #{event_hash["type"]}"
+        return
+      end
+
+      logger.info "Server received event: #{event_hash["type"]} (cassette=#{@cassette&.name})"
+      @cassette&.receive_event_payload(Event.new(event_hash["type"], event_hash))
+
+      @fence_mutex.synchronize do
+        if @fence_test_clock_id && event_hash["type"] == "test_helpers.test_clock.deleted" && event_hash.dig(
+          "data", "object", "id"
+        ) == @fence_test_clock_id
+          @last_fence_event_created = event_hash["created"]
+          @fence_signaled = true
+          @fence_cond_var.signal
+        end
+      end
+    end
+
+    def logger
+      VcrStripeWebhook.logger
+    end
+  end
+end

data/lib/vcr_stripe_webhook/server.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module VcrStripeWebhook
+  # Tiny web server for stripe webhook
+  class Server
+    attr_reader :tcp_server, :port
+
+    def initialize(port = 0, &block)
+      run(port, &block)
+    end
+
+    def close
+      logger.info "Closing Server"
+      tcp_server.close
+    end
+
+    def wait_event(event_type)
+      @event_waiter.wait(event_type)
+    end
+
+    def join
+      @accept_thread.join
+    end
+
+    private
+
+    def run(port, &block)
+      @tcp_server = TCPServer.open(port)
+      _family, port, host, _ip = tcp_server.addr
+      @port = port
+      logger.info "Server is on #{[host, port].join(":")}"
+
+      @block = block
+      @accept_thread = Thread.start do
+        run_thread
+      end
+    end
+
+    def run_thread
+      loop do
+        socket = tcp_server.accept
+        Thread.start(socket) do |s|
+          request = RequestParser.new(s)
+
+          if request.json?
+            @block&.call(request.body)
+            s.write("HTTP/1.1 204\r\n\r\n")
+          else
+            s.write("HTTP/1.1 400\r\n\r\n")
+          end
+        ensure
+          s.close
+        end
+      end
+    rescue IOError
+      # Closed in another thread
+    end
+
+    def logger
+      VcrStripeWebhook.logger
+    end
+
+    class RequestParser
+      MAX_HEADER_LENGTH = 16 * 1024
+
+      attr_reader :method, :path, :headers, :body
+
+      def initialize(socket)
+        @method, @path = read_start_line(socket)
+        @headers = read_headers(socket)
+        return unless content_length
+
+        @body = socket.read(content_length)
+      end
+
+      def content_length
+        @content_length ||= headers["content-length"]&.to_i
+      end
+
+      def content_type
+        return @content_type if defined?(@content_type)
+
+        if headers["content-type"]
+          @content_type, _attributes = headers["content-type"].split(/;\s+/, 2)
+        else
+          @content_type = nil
+        end
+        @content_type
+      end
+
+      def json?
+        content_type == "application/json"
+      end
+
+      def json_value
+        return @json_value if defined?(@json_value)
+
+        @json_value =
+          if json?
+            begin
+              JSON.parse(@body)
+            rescue StandardError
+              nil
+            end
+          end
+      end
+
+      private
+
+      def read_start_line(socket)
+        line = socket.gets("\n")
+        method, path, _http_version = line.split(" ", 3)
+        [method, path]
+      end
+
+      def read_headers(socket)
+        headers = {}
+        loop do
+          line = socket.gets("\n", MAX_HEADER_LENGTH, chomp: true)
+          break if line.nil? || line.empty?
+
+          key, value = line.split(/:\s+/, 2).map(&:strip)
+          headers[key.downcase] = value
+        end
+        headers
+      end
+
+      def logger
+        VcrStripeWebhook.logger
+      end
+    end
+  end
+end

data/lib/vcr_stripe_webhook/stripe_cli.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module VcrStripeWebhook
+  class StripeCLI
+    def initialize(server_port, api_key)
+      @server_port = server_port
+      @api_key = api_key
+      run
+    end
+
+    def terminate
+      @stdout.close
+      @read_out_thread.join
+      @stderr.close
+      @read_err_thread.join
+      Process.kill(:TERM, @pid)
+      Process.waitpid(@pid)
+    end
+
+    private
+
+    def run
+      spawn_process
+
+      @ready_waiter = ReadyWaiter.new
+
+      @read_out_thread = Thread.new do
+        read_thread("OUT", @stdout)
+      end
+      @read_err_thread = Thread.new do
+        read_thread("ERR", @stderr, ready_check: true)
+      end
+
+      logger.info "Waiting for Stripe CLI to be ready..."
+      @ready_waiter.wait_ready
+      self
+    end
+
+    def spawn_process
+      env = { "STRIPE_API_KEY" => @api_key }
+      r_out, w_out = IO.pipe
+      r_err, w_err = IO.pipe
+      command_and_args = ["stripe", "listen", "--forward-to", "localhost:#{@server_port}/"]
+      logger.info "Spawning Stripe CLI: #{command_and_args.join(" ")}"
+      @pid = spawn(env, *command_and_args, { out: w_out, err: w_err })
+      w_out.close
+      w_err.close
+      @stdout = r_out
+      @stderr = r_err
+      logger.info "Stripe CLI PID=#{@pid}"
+    rescue Errno::ENOENT
+      raise "Could not spawn Stripe CLI"
+    end
+
+    def read_thread(prefix, io, ready_check: false)
+      loop do
+        line = io.gets(chomp: true)
+        return if line.nil?
+
+        @ready_waiter.signal_ready if ready_check && line.start_with?("Ready!")
+        logger.info "Stripe CLI: #{prefix}: #{line}"
+      rescue IOError
+        # Closed in another thread
+        break
+      end
+    end
+
+    def logger
+      VcrStripeWebhook.logger
+    end
+
+    class ReadyWaiter
+      def initialize
+        @ready = false
+        @ready_mutex = Mutex.new
+        @ready_cond_var = ConditionVariable.new
+      end
+
+      def wait_ready
+        @ready_mutex.synchronize do
+          loop do
+            break if @ready
+
+            @ready_cond_var.wait(@ready_mutex)
+          end
+        end
+      end
+
+      def signal_ready
+        @ready_mutex.synchronize do
+          @ready = true
+          @ready_cond_var.signal
+        end
+      end
+    end
+  end
+end

data/lib/vcr_stripe_webhook/version.rb

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

data/lib/vcr_stripe_webhook/waiter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module VcrStripeWebhook
+  class ProcWaiter
+    def initialize(_proc)
+      @proc
+    end
+
+    def call(events)
+      @proc.call(events)
+    end
+
+    def timeout_message(_events, recording:)
+      events_words = recording ? "received events" : "the recorded events"
+      "wait_until proc does not return true with #{events_words}."
+    end
+  end
+
+  class EventTypeWaiter
+    attr_reader :event_types
+
+    def initialize(event_types)
+      @event_types = event_types
+    end
+
+    def call(events)
+      type_set = events.map(&:type).to_set
+      event_types.all? { |type| type_set.member?(type) }
+    end
+
+    def timeout_message(events, recording:)
+      type_set = events.map(&:type).to_set
+      missing_event_types = event_types.reject { |type| type_set.member?(type) }
+      events_words = recording ? "Received events" : "The recorded events"
+      types_words = missing_event_types.map { |type| "'#{type}'" }.join(", ")
+      "#{events_words} don't contain #{types_words}."
+    end
+  end
+end

data/lib/vcr_stripe_webhook.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "logger"
+require "set"
+require_relative "vcr_stripe_webhook/version"
+require_relative "vcr_stripe_webhook/configuration"
+require_relative "vcr_stripe_webhook/event_receiver"
+require_relative "vcr_stripe_webhook/event_cassette"
+require_relative "vcr_stripe_webhook/waiter"
+
+module VcrStripeWebhook
+  class << self
+    attr_reader :server, :current_event_cassette
+    attr_writer :logger
+
+    def stop
+      EventReceiver.terminate
+    end
+
+    def configuration
+      @configuration ||= VcrStripeWebhook::Configuration.new
+    end
+
+    def logger
+      @logger ||= Logger.new("log/vcr_stripe_webhook.log")
+    end
+
+    def use_cassette(name, options = {}, &block)
+      VCR.use_cassette(name, options) do |vcr_cassette|
+        @current_event_cassette = EventCassette.new(name, vcr_cassette, vcr_cassette.recording?)
+        EventReceiver.instance.use_cassette(@current_event_cassette, &block)
+        @current_event_cassette.serialize if @current_event_cassette.recording?
+      ensure
+        @current_event_cassette = nil
+      end
+    end
+
+    def receive_webhook_events(event_types: nil, wait_until: nil, timeout: configuration.timeout, &block)
+      raise "No event cassette inserted." if current_event_cassette.nil?
+      raise "event_types or wait_until must be passed as an argument." if event_types.nil? && wait_until.nil?
+
+      waiter =
+        if event_types
+          EventTypeWaiter.new(event_types)
+        else
+          ProcWaiter.new(wait_until)
+        end
+      current_event_cassette.wait_for_events(waiter, timeout: timeout, &block)
+    end
+
+    def receive_webhook_event(event_type, timeout: configuration.timeout, &block)
+      events = receive_webhook_events(event_types: [event_type], timeout: timeout, &block)
+      events.find { |event| event.type == event_type }
+    end
+  end
+end

data/sig/vcr_stripe_webhook.rbs

@@ -0,0 +1,4 @@
+module VcrStripeWebhook
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: vcr_stripe_webhook
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Shunichi Ikegami
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-12-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: stripe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Record and replay Stripe webhooks during test
+email:
+- sike.tm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/vcr_stripe_webhook.rb
+- lib/vcr_stripe_webhook/configuration.rb
+- lib/vcr_stripe_webhook/error.rb
+- lib/vcr_stripe_webhook/event.rb
+- lib/vcr_stripe_webhook/event_cassette.rb
+- lib/vcr_stripe_webhook/event_receiver.rb
+- lib/vcr_stripe_webhook/server.rb
+- lib/vcr_stripe_webhook/stripe_cli.rb
+- lib/vcr_stripe_webhook/version.rb
+- lib/vcr_stripe_webhook/waiter.rb
+- sig/vcr_stripe_webhook.rbs
+homepage: https://github.com/shunichi/vcr_stripe_webhook
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/shunichi/vcr_stripe_webhook
+  source_code_uri: https://github.com/shunichi/vcr_stripe_webhook
+  changelog_uri: https://github.com/shunichi/vcr_stripe_webhook/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Record and replay Stripe webhooks during test
+test_files: []