mailersend-ruby 2.0.3 → 3.0.0

data/spec/sms_activity_rspec.rb

@@ -0,0 +1,26 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::SMSActivity do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:sms_activity) { Mailersend::SMSActivity.new(client) }
+
+  it 'returns a list of SMS activities' do
+    VCR.use_cassette('sms_activity/sms_activity_list') do
+      response = sms_activity.list(page: 1, limit: 10)
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+end

data/spec/sms_inbounds_rspec.rb

@@ -0,0 +1,77 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::SMSInbounds do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:sms_inbounds) { Mailersend::SMSInbounds.new(client) }
+
+  it 'returns a list of SMS inbounds' do
+    VCR.use_cassette('sms_inbounds/sms_inbounds_list_sms_inbounds') do
+      response = sms_inbounds.list(page: 1, limit: 10)
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns a single SMS inbound route' do
+    VCR.use_cassette('sms_inbounds/sms_inbounds_get_sms_inbound_route') do
+      response = sms_inbounds.get_sms_inbound_route(sms_inbound_id: '6vywj2lpml7oqzd1')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'adds a new SMS inbound route' do
+    VCR.use_cassette('sms_inbounds/sms_inbounds_add_sms_inbound_route') do
+      sms_inbounds.settings = {
+        'sms_number_id' => '0p7kx4xd7el9yjre',
+        'forward_url' => 'https://mailersend.com',
+        'name' => 'my-inbound-route',
+        'events' => ['sms.sent', 'sms.delivered']
+      }
+      response = sms_inbounds.add_sms_inbound_route
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(201)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'updates an SMS inbound route' do
+    VCR.use_cassette('sms_inbounds/sms_inbounds_update_sms_inbound_route') do
+      sms_inbounds.settings = {
+        'sms_number_id' => '0p7kx4xd7el9yjre',
+        'forward_url' => 'https://mailersend.com',
+        'name' => 'my-inbound-route',
+        'events' => ['sms.sent', 'sms.delivered']
+
+      }
+      response = sms_inbounds.update_sms_inbound_route(sms_inbound_id: '0p7kx4xw0eg9yjre')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'deletes an SMS inbound route' do
+    VCR.use_cassette('sms_inbounds/sms_inbounds_delete_sms_inbound_route') do
+      response = sms_inbounds.delete_sms_inbound_route(sms_inbound_id: '0p7kx4xw0eg9yjre')
+
+      expect(response.status).to eq(204)
+    end
+  end
+end

data/spec/sms_messages_rspec.rb

@@ -0,0 +1,26 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::SMSMessages do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:sms_messages) { Mailersend::SMSMessages.new(client) }
+
+  it 'returns a list of SMS messages' do
+    VCR.use_cassette('sms_messages/sms_messages_list_sms_messages') do
+      response = sms_messages.list(page: 1, limit: 10)
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+end

data/spec/sms_number_rspec.rb

@@ -0,0 +1,54 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::SMSNumber do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:sms_number) { Mailersend::SMSNumber.new(client) }
+
+  it 'returns a list of SMS numbers' do
+    VCR.use_cassette('sms_number/sms_number_list') do
+      response = sms_number.list(page: 1, limit: 10)
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns a single SMS number' do
+    VCR.use_cassette('sms_number/sms_number_get') do
+      response = sms_number.get(sms_number_id: '0p7kx4xd7el9yjre')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'updates an SMS number' do
+    VCR.use_cassette('sms_number/sms_number_update') do
+      response = sms_number.update(sms_number_id: '0p7kx4xd7el9yjre', paused: true)
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'deletes an SMS number' do
+    VCR.use_cassette('sms_number/sms_number_delete') do
+      response = sms_number.delete(sms_number_id: 'example_sms_number_id')
+
+      expect(response.status).to eq(204)
+    end
+  end
+end

data/spec/sms_recipient_rspec.rb

@@ -0,0 +1,46 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::SMSRecipient do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:sms_recipient) { Mailersend::SMSRecipient.new(client) }
+
+  it 'returns a list of SMS recipients' do
+    VCR.use_cassette('sms_recipient/sms_recipient_list') do
+      response = sms_recipient.list(page: 1, limit: 10)
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns a single SMS recipient' do
+    VCR.use_cassette('sms_recipient/sms_recipient_get') do
+      response = sms_recipient.get(sms_recipient_id: '627e7503d30078fb2208cc83')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'updates an SMS recipient' do
+    VCR.use_cassette('sms_recipient/sms_recipient_update') do
+      response = sms_recipient.update(sms_recipient_id: '627e7503d30078fb2208cc83', status: 'active')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+end

data/spec/sms_webhooks_rspec.rb

@@ -0,0 +1,74 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::SMSWebhooks do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:sms_webhooks) { Mailersend::SMSWebhooks.new(client) }
+
+  it 'returns a list of SMS webhooks' do
+    VCR.use_cassette('sms_webhooks/sms_webhooks_list_sms_webhooks') do
+      response = sms_webhooks.list(sms_number_id: '0p7kx4xd7el9yjre')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns a single SMS webhook route' do
+    VCR.use_cassette('sms_webhooks/sms_webhooks_get_sms_webhook_route') do
+      response = sms_webhooks.get_sms_webhook_route(sms_webhook_id: '0r83ql3pzvgzw1jm')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'adds a new SMS webhook route' do
+    VCR.use_cassette('sms_webhooks/sms_webhooks_add_sms_webhook_route') do
+      sms_webhooks.settings = {
+        'sms_number_id' => '0p7kx4xd7el9yjre',
+        'name' => 'good-webhook',
+        'url' => 'https://mailersend.net/webhook',
+        'events' => ['sms.sent', 'sms.delivered']
+      }
+      response = sms_webhooks.add_sms_webhook_route
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(201)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'updates an SMS webhook route' do
+    VCR.use_cassette('sms_webhooks/sms_webhooks_update_sms_webhook_route') do
+      sms_webhooks.settings = {
+        'url' => 'https://mailersend.net/updated_webhook',
+        'events' => ['sms.sent', 'sms.delivered']
+      }
+      response = sms_webhooks.update_sms_webhook_route(sms_webhook_id: '0r83ql3pzvgzw1jm')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'deletes an SMS webhook route' do
+    VCR.use_cassette('sms_webhooks/sms_webhooks_delete_sms_webhook_route') do
+      response = sms_webhooks.delete_sms_webhook_route(sms_webhook_id: '0r83ql3pzvgzw1jm')
+
+      expect(response.status).to eq(204)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,102 @@
+require 'simplecov'
+SimpleCov.start
+require 'mailersend'
+
+API_TOKEN = 'enter_your_api_token_here'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See https://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  #   # This allows you to limit a spec run to individual examples or groups
+  #   # you care about by tagging them with `:focus` metadata. When nothing
+  #   # is tagged with `:focus`, all examples get run. RSpec also provides
+  #   # aliases for `it`, `describe`, and `context` that include `:focus`
+  #   # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  #   config.filter_run_when_matching :focus
+  #
+  #   # Allows RSpec to persist some state between runs in order to support
+  #   # the `--only-failures` and `--next-failure` CLI options. We recommend
+  #   # you configure your source control system to ignore this file.
+  #   config.example_status_persistence_file_path = "spec/examples.txt"
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is
+  #   # recommended. For more details, see:
+  #   # https://rspec.info/features/3-12/rspec-core/configuration/zero-monkey-patching-mode/
+  #   config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  #   if config.files_to_run.one?
+  #     # Use the documentation formatter for detailed output,
+  #     # unless a formatter has already been configured
+  #     # (e.g. via a command-line flag).
+  #     config.default_formatter = "doc"
+  #   end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # Run specs in random order to surface order dependencies. If you find an
+  #   # order dependency and want to debug it, you can fix the order by providing
+  #   # the seed, which is printed after each run.
+  #   #     --seed 1234
+  #   config.order = :random
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  #   Kernel.srand config.seed
+end

data/spec/suppressions_rspec.rb

@@ -0,0 +1,124 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::Suppressions do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:suppressions) { Mailersend::Suppressions.new(client) }
+
+  it 'returns the blocklist' do
+    VCR.use_cassette('suppressions/suppressions_get_from_blocklist') do
+      response = suppressions.get_from_blocklist
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns hard bounces' do
+    VCR.use_cassette('suppressions/suppressions_get_hard_bounces') do
+      response = suppressions.get_hard_bounces
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns spam complaints' do
+    VCR.use_cassette('suppressions/suppressions_get_spam_complaints') do
+      response = suppressions.get_spam_complaints
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns unsubscribes' do
+    VCR.use_cassette('suppressions/suppressions_get_unsubscribes') do
+      response = suppressions.get_unsubscribes
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'adds to blocklist' do
+    VCR.use_cassette('suppressions/suppressions_add_to_blocklist') do
+      response = suppressions.add_to_blocklist(recipients: ['test@mailerlite.com'])
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(201)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'adds to hard bounces' do
+    VCR.use_cassette('suppressions/suppressions_add_to_hard_bounces') do
+      response = suppressions.add_to_hard_bounces(domain_id: 'jpzkmgq7e5vl059v', recipients: ['test@mailerlite.com'])
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(201)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'adds to spam complaints' do
+    VCR.use_cassette('suppressions/suppressions_add_to_spam_complaints') do
+      response = suppressions.add_to_spam_complaints(domain_id: 'jpzkmgq7e5vl059v', recipients: ['test@mailerlite.com'])
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(201)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'adds to unsubscribers' do
+    VCR.use_cassette('suppressions/suppressions_add_to_unsubscribers') do
+      response = suppressions.add_to_unsubscribers(domain_id: 'jpzkmgq7e5vl059v', recipients: ['test@mailerlite.com'])
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(201)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'deletes from blocklist' do
+    VCR.use_cassette('suppressions/suppressions_delete_from_blocklist') do
+      response = suppressions.delete_from_blocklist(domain_id: 'jpzkmgq7e5vl059v', ids: ['6764599b1cc3ea355ad717a0'])
+      expect(response.status).to eq(200)
+    end
+  end
+
+  it 'deletes from hard bounces' do
+    VCR.use_cassette('suppressions/suppressions_delete_from_hard_bounces') do
+      response = suppressions.delete_from_hard_bounces(domain_id: 'jpzkmgq7e5vl059v', ids: ['676457b042328d3c98db7600'])
+      expect(response.status).to eq(200)
+    end
+  end
+
+  it 'deletes from spam complaints' do
+    VCR.use_cassette('suppressions/suppressions_delete_from_spam_complaints') do
+      response = suppressions.delete_from_spam_complaints(domain_id: 'jpzkmgq7e5vl059v', ids: ['676457b1ee359d18093fcb99'])
+      expect(response.status).to eq(200)
+    end
+  end
+
+  it 'deletes from unsubscribers' do
+    VCR.use_cassette('suppressions/suppressions_delete_from_unsubscribers') do
+      response = suppressions.delete_from_unsubscribers(domain_id: 'jpzkmgq7e5vl059v', ids: ['676457b1252f59f004ea2bac'])
+      expect(response.status).to eq(200)
+    end
+  end
+end

data/spec/templates_rspec.rb

@@ -0,0 +1,44 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::Templates do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:templates) { Mailersend::Templates.new(client) }
+
+  it 'returns a list of templates' do
+    VCR.use_cassette('templates/templates_list') do
+      response = templates.list(domain_id: 'zkq340ezdqkgd796', page: 1, limit: 10)
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns a single template' do
+    VCR.use_cassette('templates/templates_single') do
+      response = templates.single(template_id: 'pq3enl6v607g2vwr')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'deletes a template' do
+    VCR.use_cassette('templates/templates_delete') do
+      response = templates.delete(template_id: 'z3m5jgrow5zgdpyo')
+
+      expect(response.status).to eq(200)
+    end
+  end
+end

data/spec/tokens_rspec.rb

@@ -0,0 +1,44 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::Tokens do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:tokens) { Mailersend::Tokens.new(client) }
+
+  it 'creates a new token' do
+    VCR.use_cassette('tokens/tokens_create') do
+      response = tokens.create(name: 'Test Token', scopes: ['email_full'], domain_id: 'example_domain_id')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Hash)
+    end
+  end
+
+  it 'updates a token status' do
+    VCR.use_cassette('tokens/tokens_update') do
+      response = tokens.update(token_id: '1dd8e323b92f9953069f9647ca5929a24674e2f972d85734b27de16cd06360256054a070b783c272', status: 'pause')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response).to be_a(Hash)
+    end
+  end
+
+  it 'deletes a token' do
+    VCR.use_cassette('tokens/tokens_delete') do
+      response = tokens.delete(token_id: '1dd8e323b92f9953069f9647ca5929a24674e2f972d85734b27de16cd06360256054a070b783c272')
+
+      expect(response.status).to eq(200)
+    end
+  end
+end

data/spec/webhooks_rspec.rb

@@ -0,0 +1,60 @@
+require 'rspec'
+require 'vcr'
+require 'json'
+
+VCR.configure do |config|
+  config.cassette_library_dir = './fixtures'
+  config.hook_into :webmock
+  config.filter_sensitive_data('<AUTH>') do |interaction|
+    interaction.request.headers['Authorization'][0]
+  end
+end
+
+RSpec.describe Mailersend::Webhooks do
+  let(:client) { Mailersend::Client.new(API_TOKEN) }
+  let(:webhooks) { Mailersend::Webhooks.new(client) }
+
+  it 'returns a list of webhooks' do
+    VCR.use_cassette('webhooks/webhooks_list') do
+      response = webhooks.list(domain_id: 'jpzkmgq7e5vl059v')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_an(Array)
+    end
+  end
+
+  it 'returns a single webhook' do
+    VCR.use_cassette('webhooks/webhooks_single') do
+      response = webhooks.single(webhook_id: '3vz9dlej514kj50y')
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(200)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'creates a new webhook' do
+    VCR.use_cassette('webhooks/webhooks_create') do
+      response = webhooks.create(
+        url: 'https://example.com/webhook',
+        name: 'Test Webhook',
+        events: ['activity.sent', 'activity.delivered'],
+        domain_id: 'jpzkmgq7e5vl059v',
+        enabled: true
+      )
+      parsed_response = JSON.parse(response.body)
+
+      expect(response.status).to eq(201)
+      expect(parsed_response['data']).to be_a(Hash)
+    end
+  end
+
+  it 'deletes a webhook' do
+    VCR.use_cassette('webhooks/webhooks_delete') do
+      response = webhooks.delete(webhook_id: '3vz9dlej514kj50y')
+
+      expect(response.status).to eq(204)
+    end
+  end
+end