mailerlite-ruby 1.0.2

data/lib/mailerlite/fields/fields.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module MailerLite
+  # This is a class for manipulating the Fields from MailerLite API.
+  class Fields
+    attr_reader :client
+
+    # Inits the `Fields` class with the specified `client`.
+    #
+    # @param client [MailerLite::Client] the `Client` instance to use
+    def initialize(client: MailerLite::Client.new)
+      @client = client
+    end
+
+    # Returns a list of Fields that match the specified filter criteria.
+    #
+    # @param filter [:keyword, :type] Returns partial matches for fields
+    # @param limit [Integer] the maximum number of Fields to return
+    # @param page [Integer] the page number of the results to return
+    # @return [HTTP::Response] the response from the API
+    def get(limit: nil, page: nil, filter: {}, sort: nil)
+      params = {}
+      params['filter[keyword]'] = filter[:keyword] if filter.key?(:keyword)
+      params['filter[type]'] = filter[:type] if filter.key?(:type)
+      params['sort'] = sort if sort
+      params['limit'] = limit if limit
+      params['page'] = page if page
+      uri = URI("#{API_URL}/fields")
+      uri.query = URI.encode_www_form(params.compact)
+      client.http.get(uri)
+    end
+
+    # Update the specified Field
+    #
+    # @param name [String] the name of the field to create
+    # @param type [String] the type, can be text, number or date
+    # @return [HTTP::Response] the response from the API
+    def create(type:, name:)
+      params = { 'name' => name, 'type' => type }
+      client.http.post("#{API_URL}/fields", json: params.compact)
+    end
+
+    # Update the specified Field
+    #
+    # @param field_id [Integer] the field_id to update
+    # @param name [String] the name to update
+    # @return [HTTP::Response] the response from the API
+    def update(field_id:, name:)
+      params = { 'name' => name }
+      client.http.put("#{API_URL}/fields/#{field_id}", json: params.compact)
+    end
+
+    # Deletes the specified Field.
+    #
+    # @param field_id [String] the ID of the Field to delete
+    # @return [HTTP::Response] the response from the API
+    def delete(field_id)
+      client.http.delete("#{API_URL}/fields/#{field_id}")
+    end
+  end
+end

data/lib/mailerlite/forms/forms.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module MailerLite
+  # This is a class for manipulating the Forms from MailerLite API.
+  class Forms
+    attr_reader :client
+
+    # Inits the `Forms` class with the specified `client`.
+    #
+    # @param client [MailerLite::Client] the `Client` instance to use
+    def initialize(client: MailerLite::Client.new)
+      @client = client
+    end
+
+    # Returns a list of Forms that match the specified filter criteria.
+    #
+    # @param filter [#name] the name of the Forms to include in the results
+    # @param limit [Integer] the maximum number of Forms to return
+    # @param page [Integer] the page number of the results to return
+    # @return [HTTP::Response] the response from the API
+    def list(type:, filter: {}, limit: nil, sort: nil, page: nil)
+      params = {}
+      params['filter[name]'] = filter[:name] if filter.key?(:name)
+      params['limit'] = limit if limit
+      params['sort'] = sort if sort
+      params['page'] = page if page
+      uri = URI("#{API_URL}/forms/#{type}")
+      uri.query = URI.encode_www_form(params.compact)
+      client.http.get(uri)
+    end
+
+    # Returns the details of the specified Forms
+    #
+    # @param form_id [String] the ID of the forms to fetch
+    # @return [HTTP::Response] the response from the API
+    def fetch(form_id)
+      client.http.get("#{API_URL}/forms/#{form_id}")
+    end
+
+    # Returns the subscribers who signed up to a specific form
+    #
+    # @param form_id [String] the ID of the forms to fetch
+    # @return [HTTP::Response] the response from the API
+    def fetch_subscribers(form_id)
+      client.http.get("#{API_URL}/forms/#{form_id}/subscribers")
+    end
+
+    # Update the specified Forms
+    #
+    # @param form_id [String] the ID of the forms to fetch
+    # @param name [String] the name to update
+    # @return [HTTP::Response] the response from the API
+    def update(form_id:, name:)
+      params = { 'name' => name }
+      client.http.put("#{API_URL}/forms/#{form_id}", json: params.compact)
+    end
+
+    # Returns the total number of Forms in the MailerLite account.
+    #
+    # @return [HTTP::Response] the response from the API
+    def fetch_count
+      client.http.get("#{API_URL}/forms/?limit=0")
+    end
+
+    # Deletes the specified forms.
+    #
+    # @param form_id [String] the ID of the forms to delete
+    # @return [HTTP::Response] the response from the API
+    def delete(form_id)
+      client.http.delete("#{API_URL}/forms/#{form_id}")
+    end
+  end
+end

data/lib/mailerlite/groups/groups.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module MailerLite
+  # This is a class for manipulating the Groups from MailerLite API.
+  class Groups
+    attr_reader :client
+
+    # Inits the `Groups` class with the specified `client`.
+    #
+    # @param client [MailerLite::Client] the `Client` instance to use
+    def initialize(client: MailerLite::Client.new)
+      @client = client
+    end
+
+    # Returns a list of Groups that match the specified filter criteria.
+    #
+    # @param filter[:name] the name of the Groups to include in the results
+    # @param limit [Integer] the maximum number of Groups to return
+    # @param page [Integer] the page number of the results to return
+    # @return [HTTP::Response] the response from the API
+    def get(filter: {}, limit: nil, sort: nil, page: nil)
+      params = {}
+      params['filter[name]'] = filter[:name] if filter.key?(:name)
+      params['limit'] = limit if limit
+      params['sort'] = sort if sort
+      params['page'] = page if page
+      uri = URI("#{API_URL}/groups")
+      uri.query = URI.encode_www_form(params.compact)
+      client.http.get(uri)
+    end
+
+    # create a Group
+    #
+    # @param name [String] the name to update
+    # @return [HTTP::Response] the response from the API
+    def create(name:)
+      params = { 'name' => name }
+      client.http.post("#{API_URL}/groups", json: params.compact)
+    end
+
+    # Update the specified Group
+    #
+    # @param group_id [String] the ID of the Groups to update
+    # @param name [String] the name to update
+    # @return [HTTP::Response] the response from the API
+    def update(group_id:, name:)
+      params = { 'name' => name }
+      client.http.put("#{API_URL}/groups/#{group_id}", json: params.compact)
+    end
+
+    # Get Subscribers assigned to the specified group.
+    # @param group_id [Integer] The id of existing group belonging to the account
+    # @param filter[:status] [String] Must be one of the possible statuses: active, unsubscribed, unconfirmed, bounced or junk. Defaults to active.
+    # @param limit [Integer] the maximum number of subscribers to return
+    # @param page [Integer] the page number of the results to return
+    # @return [HTTP::Response] the response from the API
+    def get_subscribers(group_id:, filter: {}, limit: nil, page: nil, sort: nil)
+      params = {}
+      params['filter[status]'] = filter[:status] if filter.key?(:status)
+      params['limit'] = limit if limit
+      params['sort'] = sort if sort
+      params['page'] = page if page
+      client.http.get("#{API_URL}/groups/#{group_id}/subscribers", json: params.compact)
+    end
+
+    # Assign Subscriber to the specified group.
+    # @param group_id [Integer] The id of existing group belonging to the account
+    # @param subscriber [Integer] The id of existing subscriber belonging to the account
+    # @return [HTTP::Response] the response from the API
+    def assign_subscriber(group_id:, subscriber:)
+      client.http.post("#{API_URL}/subscribers/#{subscriber}/groups/#{group_id}")
+    end
+
+    # Unassign Subscriber to the specified group.
+    # @param group_id [Integer] The id of existing group belonging to the account
+    # @param subscriber [Integer] The id of existing subscriber belonging to the account
+    # @return [HTTP::Response] the response from the API
+    def unassign_subscriber(group_id:, subscriber:)
+      client.http.delete("#{API_URL}/subscribers/#{subscriber}/groups/#{group_id}")
+    end
+
+    # Deletes the specified Groups.
+    #
+    # @param group_id [String] the ID of the Groups to delete
+    # @return [HTTP::Response] the response from the API
+    def delete(group_id)
+      client.http.delete("#{API_URL}/groups/#{group_id}")
+    end
+  end
+end

data/lib/mailerlite/segments/segments.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module MailerLite
+  # This is a class for manipulating the Segments from MailerLite API.
+  class Segments
+    attr_reader :client
+
+    # Inits the `Segments` class with the specified `client`.
+    #
+    # @param client [MailerLite::Client] the `Client` instance to use
+    def initialize(client: MailerLite::Client.new)
+      @client = client
+    end
+
+    # Returns a list of Segments that match the specified filter criteria.
+    #
+    # @param limit [Integer] the maximum number of Segments to return
+    # @param page [Integer] the page number of the results to return
+    # @return [HTTP::Response] the response from the API
+    def list(limit: nil, page: nil)
+      params = {}
+      params['limit'] = limit if limit
+      params['page'] = page if page
+
+      client.http.get("#{API_URL}/segments", json: params.compact)
+    end
+
+    # Update the specified Segment
+    #
+    # @param segment_id [String] the ID of the Segments to update
+    # @param name [String] the name to update
+    # @return [HTTP::Response] the response from the API
+    def update(segment_id:, name:)
+      params = { 'name' => name }
+      client.http.put("#{API_URL}/segments/#{segment_id}", json: params.compact)
+    end
+
+    # Get Subscribers assigned to the specified Segment.
+    # @param segment_id [Integer] The id of existing Segment belonging to the account
+    # @param filter[status] [String] Must be one of the possible statuses: active, unsubscribed, unconfirmed, bounced or junk. Defaults to active.
+    # @param limit [Integer] the maximum number of subscribers to return
+    # @param after [Integer] The last subscriber id, available in meta.last
+    # @return [HTTP::Response] the response from the API
+    def get_subscribers(segment_id:, filter: {}, limit: nil, after: nil)
+      params = {}
+      params['filter[status]'] = filter[:status] if filter.key?(:status)
+      params['limit'] = limit if limit
+      params['after'] = after if after
+      uri = URI("#{API_URL}/segments/#{segment_id}/subscribers")
+      uri.query = URI.encode_www_form(params.compact)
+      client.http.get(uri)
+    end
+
+    # Deletes the specified Segments.
+    #
+    # @param segment_id [String] the ID of the Segments to delete
+    # @return [HTTP::Response] the response from the API
+    def delete(segment_id)
+      client.http.delete("#{API_URL}/segments/#{segment_id}")
+    end
+  end
+end

data/lib/mailerlite/subscribers/subscribers.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module MailerLite
+  # This is a class for manipulating the subscribers from MailerLite API.
+  class Subscribers
+    attr_reader :client
+
+    # Inits the `Subscribers` class with the specified `client`.
+    #
+    # @param client [MailerLite::Client] the `Client` instance to use
+    def initialize(client: MailerLite::Client.new)
+      @client = client
+    end
+
+    # Returns a list of subscribers that match the specified filter criteria.
+    #
+    # @param filter[:status] [Array] the status of the subscribers to include in the results
+    # @param limit [Integer] the maximum number of subscribers to return
+    # @param page [Integer] the page number of the results to return
+    # @return [HTTP::Response] the response from the API
+    def fetch(filter:, limit: nil, page: nil)
+      params = { 'filter[status]' => filter[:status] }
+
+      params['limit'] = limit if limit
+      params['page'] = page if page
+      uri = URI("#{API_URL}/subscribers")
+      uri.query = URI.encode_www_form(params.compact)
+      client.http.get(uri)
+    end
+
+    # Creates a new subscriber with the specified details.
+    #
+    # @param email [String] the email address of the new subscriber
+    # @param fields [Hash] a hash of custom fields and their values for the subscriber
+    # @param groups [Array] an array of group IDs to add the subscriber to
+    # @param status [String] the status of the new subscriber
+    # @param subscribed_at [DateTime] the date and time when the subscriber was added
+    # @param ip_address [String] the IP address of the subscriber
+    # @param opted_in_at [DateTime] the date and time when the subscriber confirmed their subscription
+    # @param optin_ip [String] the IP address of the subscriber when they confirmed their subscription
+    # @param unsubscribed_at [DateTime] the date and time when the subscriber was unsubscribed
+    # @return [HTTP::Response] the response from the API
+    def create(email:, fields: nil, groups: nil, status: nil, subscribed_at: nil, ip_address: nil, opted_in_at: nil, optin_ip: nil, unsubscribed_at: nil)
+      params = { 'email' => email }
+
+      params['fields'] = fields if fields
+      params['groups'] = groups if groups
+      params['status'] = status if status
+      params['subscribed_at'] = subscribed_at if subscribed_at
+      params['ip_address'] = ip_address if ip_address
+      params['opted_in_at'] = opted_in_at if opted_in_at
+      params['optin_ip'] = optin_ip if optin_ip
+      params['unsubscribed_at'] = unsubscribed_at if unsubscribed_at
+
+      client.http.post("#{API_URL}/subscribers", json: params.compact)
+    end
+
+    # Creates a new subscriber with the specified details.
+    #
+    # @param email [String] the email address of the new subscriber
+    # @param fields [Hash] a hash of custom fields and their values for the subscriber
+    # @param groups [Array] an array of group IDs to add the subscriber to
+    # @param status [String] the status of the new subscriber
+    # @param subscribed_at [DateTime] the date and time when the subscriber was added
+    # @param ip_address [String] the IP address of the subscriber
+    # @param opted_in_at [DateTime] the date and time when the subscriber confirmed their subscription
+    # @param optin_ip [String] the IP address of the subscriber when they confirmed their subscription
+    # @param unsubscribed_at [DateTime] the date and time when the subscriber was unsubscribed
+    # @return [HTTP::Response] the response from the API
+    def update(email:, fields: nil, groups: nil, status: nil, subscribed_at: nil, ip_address: nil, opted_in_at: nil, optin_ip: nil, unsubscribed_at: nil)
+      params = { 'email' => email }
+
+      params['fields'] = fields if fields
+      params['groups'] = groups if groups
+      params['status'] = status if status
+      params['subscribed_at'] = subscribed_at if subscribed_at
+      params['ip_address'] = ip_address if ip_address
+      params['opted_in_at'] = opted_in_at if opted_in_at
+      params['optin_ip'] = optin_ip if optin_ip
+      params['unsubscribed_at'] = unsubscribed_at if unsubscribed_at
+
+      client.http.post("#{API_URL}/subscribers", json: params.compact)
+    end
+
+    # Returns the details of the specified subscribers
+    #
+    # @param subscriber_id [String] the ID of the subscriber to get
+    # @return [HTTP::Response] the response from the API
+    def get(subscriber_id)
+      client.http.get("#{API_URL}/subscribers/#{subscriber_id}")
+    end
+
+    # Returns the details of the specified subscribers
+    #
+    # @param import_id [String] the ID of the import to fetch report
+    # @return [HTTP::Response] the response from the API
+    def get_single_import(import_id)
+      client.http.get("#{API_URL}/subscribers/import/#{import_id}")
+    end
+
+    # Returns the total number of subscribers in the MailerLite account.
+    #
+    # @return [HTTP::Response] the response from the API
+    def fetch_count
+      client.http.get("#{API_URL}/subscribers/?limit=0")
+    end
+
+    # Deletes the specified subscriber.
+    #
+    # @param subscriber_id [String] the ID of the subscriber to delete
+    # @return [HTTP::Response] the response from the API
+    def delete(subscriber_id)
+      client.http.delete("#{API_URL}/subscribers/#{subscriber_id}")
+    end
+  end
+end

data/lib/mailerlite/timezones/timezones.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module MailerLite
+  # This is a class for manipulating the Timezones from MailerLite API.
+  class Timezones
+    attr_reader :client
+
+    # Inits the `Timezones` class with the specified `client`.
+    #
+    # @param client [MailerLite::Client] the `Client` instance to use
+    def initialize(client: MailerLite::Client.new)
+      @client = client
+    end
+
+    # Returns a list of Timezones
+    #
+    # @return [HTTP::Response] the response from the API
+    def list
+      client.http.get("#{API_URL}/timezones")
+    end
+  end
+end

data/lib/mailerlite/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MailerLite
+  VERSION = '1.0.2'
+end

data/lib/mailerlite/webhooks/webhooks.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module MailerLite
+  # This is a class for manipulating the Webhooks from MailerLite API.
+  class Webhooks
+    attr_reader :client
+
+    # Inits the `Webhooks` class with the specified `client`.
+    #
+    # @param client [MailerLite::Client] the `Client` instance to use
+    def initialize(client: MailerLite::Client.new)
+      @client = client
+    end
+
+    # Returns a list of Webhooks
+    #
+    # @return [HTTP::Response] the response from the API
+    def list
+      client.http.get("#{API_URL}/webhooks")
+    end
+
+    # Returns the details of the specified webhooks
+    #
+    # @param webhook_id [String] the ID of the webhooks to fetch
+    # @return [HTTP::Response] the response from the API
+    def get(webhook_id)
+      client.http.get("#{API_URL}/webhooks/#{webhook_id}")
+    end
+
+    # Create a Webhook
+    #
+    # @param name [String] the name of the Webhook to create
+    # @param events [Array] the events, must one from the list of supported events
+    # @param url [String] the events, can be text, number or date
+    # @return [HTTP::Response] the response from the API
+    def create(events:, url:, name: nil)
+      params = { 'events' => events, 'url' => url }
+      params['name'] = name if name
+      client.http.post("#{API_URL}/webhooks", json: params.compact)
+    end
+
+    # Update the specified Webhook
+    #
+    # @param webhook_id [String] the ID of the Webhook to update
+    # @param name [String] the name to update
+    # @param events [Array] the events to update
+    # @param url [String] the url to update
+    # @param enabled [Boolean] the enabled to update
+    # @return [HTTP::Response] the response from the API
+    def update(webhook_id:, events: nil, name: nil, url: nil, enabled: nil)
+      params = {}
+      params['events'] = events if events
+      params['name'] = name if name
+      params['url'] = url if url
+      params['enabled'] = enabled if enabled
+      client.http.put("#{API_URL}/webhooks/#{webhook_id}", json: params.compact)
+    end
+
+    # Deletes the specified Webhook.
+    #
+    # @param webhook_id [String] the ID of the Webhook to delete
+    # @return [HTTP::Response] the response from the API
+    def delete(webhook_id)
+      client.http.delete("#{API_URL}/webhooks/#{webhook_id}")
+    end
+  end
+end

data/lib/mailerlite-ruby.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'mailerlite'

data/lib/mailerlite.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'mailerlite/client'
+require_relative 'mailerlite/subscribers/subscribers'
+require_relative 'mailerlite/campaigns/campaigns'
+require_relative 'mailerlite/forms/forms'
+require_relative 'mailerlite/groups/groups'
+require_relative 'mailerlite/segments/segments'
+require_relative 'mailerlite/fields/fields'
+require_relative 'mailerlite/automations/automations'
+require_relative 'mailerlite/webhooks/webhooks'
+require_relative 'mailerlite/batch/batch'
+require_relative 'mailerlite/timezones/timezones'

data/mailerlite-ruby.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mailerlite/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mailerlite-ruby'
+  spec.version       = MailerLite::VERSION
+  spec.authors       = ['Nikola Milojević', 'Ahsan Gondal']
+  spec.email         = ['info@mailerlite.com']
+
+  spec.summary       = "MailerLite's official Ruby SDK"
+  spec.description   = "MailerLite's official Ruby SDK. Interacts with all endpoints at MailerLite API."
+  spec.homepage      = 'https://www.MailerLite.com'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 2.5.0'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/mailerlite/mailerlite-ruby'
+  spec.metadata['changelog_uri'] = 'https://github.com/mailerlite/mailerlite-ruby/blob/main/CHANGELOG.md'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.4.7'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rubocop', '~> 1.7'
+  spec.add_dependency 'dotenv', '~> 2.7'
+  spec.add_dependency 'http', '~> 5.0'
+  spec.add_dependency 'json', '~> 2.5'
+  spec.add_dependency 'uri', '~> 0.12.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'vcr'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'yard'
+end

data/renovate.json

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "config:base"
+  ]
+}

data/spec/automations_rspec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Import the RSpec and VCR gems
+require 'spec_helper'
+require 'vcr'
+require 'json'
+
+# require "webmock/rspec"
+# Import the `Automations` class
+
+# Configure VCR to save and replay HTTP requests
+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
+
+# Set up the test for the `Automations` class
+RSpec.describe MailerLite::Automations do
+  let(:client) { MailerLite::Client.new }
+  let(:automations) { described_class.new(client: client) }
+
+  describe '#get' do
+    # Use VCR to record and replay the HTTP request
+    it 'gets all automation' do
+      VCR.use_cassette('automations/get') do
+        response = automations.get
+        body = JSON.parse(response.body)
+        expect(response.status).to eq 200
+        expect(body['data']).to be_an Array
+      end
+    end
+  end
+
+  describe '#fetch' do
+    # Use VCR to record and replay the HTTP request
+    it 'fetchs all automation' do
+      VCR.use_cassette('automations/fetch') do
+        response = automations.fetch(75_040_845_299_975_641)
+        body = JSON.parse(response.body)
+        expect(response.status).to eq 200
+        expect(Integer(body['data']['id'])).to be_an Integer
+      end
+    end
+  end
+
+  describe '#get_subscriber_activity' do
+    # Use VCR to record and replay the HTTP request
+    it 'get_subscriber_activitys all automation' do
+      VCR.use_cassette('automations/get_subscriber_activity') do
+        response = automations.get_subscriber_activity(
+          automation_id: '75040845299975641',
+          filter: { status: 'completed' }
+        )
+        # body = JSON.parse(response.body)
+        expect(response.status).to eq 200
+        # expect(Integer(body['data']['id'])).to be_an Integer
+      end
+    end
+  end
+end

data/spec/batches_rspec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Import the RSpec and VCR gems
+require 'spec_helper'
+require 'vcr'
+require 'json'
+
+# require "webmock/rspec"
+# Import the `Batch` class
+
+# Configure VCR to save and replay HTTP requests
+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
+
+# Set up the test for the `Batch` class
+RSpec.describe MailerLite::Batch do
+  let(:client) { MailerLite::Client.new }
+  let(:batch) { described_class.new(client: client) }
+
+  describe '#request' do
+    # Use VCR to record and replay the HTTP request
+    it 'executes a batch request' do
+      VCR.use_cassette('batch/request') do
+        response = batch.request(
+          requests: [
+            { method: 'GET', path: 'api/subscribers/list' },
+            { method: 'GET', path: 'api/campaigns/list' }
+          ]
+        )
+        body = JSON.parse(response.body)
+        expect(response.status).to eq 200
+        expect(body['responses']).to be_an Array
+      end
+    end
+  end
+end