module Thing
  def self.call
    Foo.call do
      Bar.call
    end
    yield
  end
end

RSpec.describe Thing do
  before do
    allow(Foo).to receive(:call).and_yield
    allow(Bar).to receive(:call)
  end

  describe '.call' do
    it 'calls Foo' do
      described_class.call
      expect(Foo).to have_received(:call)
    end

    it 'calls Bar' do
      described_class.call
      expect(Bar).to have_received(:call)
    end
  end
end

it 'yields control to a block' do
  expect do |b|
    described_class.call(&b)
  end.to yield_control
end

RSpec::Matchers.define :have_turbo_stream do |action:, target: nil, targets: nil, count: 1|
  match do |_actual|
    assert_turbo_stream(action:, target:, targets:, count:, &block_arg).present?
  end
end

it { is_expected.to have_turbo_stream(action: 'foo') { assert_select 'div.bar' } }

def call
  result = MyModel.with_advisory_lock_result('my_lock', timeout_seconds: 0) do
    # do things sensitive to competing consumers
  end
  raise MyError unless result.lock_was_acquired?
end

describe '#call' do
  it 'creates an advisory lock' do
    allow(MyModel).to receive(:with_advisory_lock_result).and_call_original
    described_class.new.call
    expect(MyModel).to have_received(:with_advisory_lock_result).with('my_lock', timeout_seconds: 0)
  end

  context 'when an advisory lock cannot be acquired' do
    it 'raises an error' do
      locking_thread = Thread.new do
        MyModel.with_advisory_lock('my_lock') do
          sleep 3 # retain lock for enough time to perform expection below
        end
      end
      sleep 0.5 # Allow time for the Thread to be created and lock acquired before the main thread does

      expect { described_class.call }.to raise_error(described_class::MyError)

      locking_thread.kill # Dispose of the thread after expectation (no need to wait any longer)
    end
  end
end

RSpec.describe Thing::Base do
  let(:dummy_thing) do
    Class.new(described_class)
  end

  before do
    stub_const('DummyThing', dummy_thing)
  end

  describe '#method_that_should_be_implemented' do
    subject do
      DummyThing.new.method_that_should_be_implemented
    end

    it { is_expected.to raise_error 'DummyThing must implement the method method_that_should_be_implemented'}
  end
end

RSpec.describe MyConcern do
  let(:model_class) do
    Class.new(ApplicationRecord) do
      self.table_name = 'mock_table'
      extend MyConcern
    end
  end

  before :all do
    ActiveRecord::Base.connection.execute(<<~SQL)
      CREATE TABLE mock_table (
        id serial PRIMARY KEY,
        label varchar
      );

      INSERT INTO mock_table (label)
      VALUES ('Foo'), ('Bar');
    SQL
  end

  after :all do
    ActiveRecord::Base.connection.drop_table :mock_types
  end

  # ... specs here

end

let(:io) { File.open Rails.root.join('spec/fixtures/files/image.png') }
let(:blob) { ActiveStorage::Blob.create_and_upload!(io:, filename: 'image.png') }

test:
  service: Disk
  root: <%= Rails.root.join("tmp/storage") %>

# spec/rails_helper.rb
config.after(:suite) do
  FileUtils.rm_rf(ActiveStorage::Blob.service.root)
end

RSpec.shared_context 'with disable consider all requests local' do
  before do
    method = Rails.application.method(:env_config)
    allow(Rails.application).to receive(:env_config).with(no_args) do
      method.call.merge(
        'action_dispatch.show_exceptions' => :all,
        'action_dispatch.show_detailed_exceptions' => false,
        'consider_all_requests_local' => false
      )
    end
  end
end

if ('clipboard' in navigator ) {
  // show the copy button
}

c.before(:example, type: :system) do
  page.driver.browser.evaluate_on_new_document(<<~JS)
    const clipboard = {
      writeText: text => new Promise(resolve => this.text = text),
      readText: () => new Promise(resolve => resolve(this.text))
    }
    Object.defineProperty(navigator, 'clipboard', { value: clipboard } )
  JS
end

text = page.driver.browser.evaluate_async(%(arguments[0](navigator.clipboard.readText())), 1) # this is some werid ass js syntax
expect(text).to eq 'foo'