broadcast-ruby 0.1.4 → 0.3.0

data/lib/broadcast/resources/email_servers.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Broadcast
+  module Resources
+    class EmailServers < Base
+      # Fields the API returns redacted (bullet-masked). When updating, never
+      # round-trip these values back from a fetch — the gem strips them out
+      # of the payload (with a logger warning) to prevent corrupting credentials.
+      REDACTED_FIELDS = %i[
+        smtp_password
+        aws_access_key_id
+        aws_secret_access_key
+        outbound_aws_access_key_id
+        outbound_aws_secret_access_key
+        postmark_api_token
+        inboxroad_api_token
+        smtp_com_api_key
+      ].freeze
+
+      # Matches the API's redaction shape: 8 bullets, OR 4-char prefix + bullets + 4-char suffix.
+      REDACTED_PATTERN = /\A(?:•{8}|.{0,4}•+.{0,4})\z/
+
+      def list(limit: nil, offset: nil)
+        params = {}
+        params[:limit] = limit unless limit.nil?
+        params[:offset] = offset unless offset.nil?
+        get('/api/v1/email_servers', params)
+      end
+
+      def get_email_server(id)
+        get("/api/v1/email_servers/#{id}")
+      end
+
+      def create(**attrs)
+        post('/api/v1/email_servers', { email_server: attrs })
+      end
+
+      # Update an email server. Attrs are wrapped under `email_server:` on the wire.
+      #
+      # CAUTION: API responses redact credential fields (e.g. `smtp_password`)
+      # with bullet characters. Never echo a fetched response back into update —
+      # this method scrubs values that match the redaction pattern, but you
+      # should pass only the fields you actually want to change.
+      def update(id, **attrs)
+        scrubbed = scrub_redacted(attrs)
+        patch("/api/v1/email_servers/#{id}", { email_server: scrubbed })
+      end
+
+      def delete(id)
+        @client.request(:delete, "/api/v1/email_servers/#{id}")
+      end
+
+      def test_connection(id)
+        post("/api/v1/email_servers/#{id}/test_connection")
+      end
+
+      # Copy an email server to another channel. Requires an admin/system token.
+      # In SaaS mode, target_channel_id is scoped to the token creator's account.
+      def copy_to_channel(id, target_channel_id:)
+        post("/api/v1/email_servers/#{id}/copy_to_channel", { target_channel_id: target_channel_id })
+      end
+
+      private
+
+      def scrub_redacted(attrs)
+        scrubbed = {}
+        attrs.each do |key, value|
+          if REDACTED_FIELDS.include?(key.to_sym) && value.is_a?(String) && value.match?(REDACTED_PATTERN)
+            warn_redacted(key)
+            next
+          end
+          scrubbed[key] = value
+        end
+        scrubbed
+      end
+
+      def warn_redacted(field)
+        msg = "[broadcast-ruby] Dropped redacted #{field} from update payload — " \
+              'pass the real credential or omit the field'
+        if @client.config.logger
+          @client.config.logger.warn(msg)
+        else
+          Kernel.warn(msg)
+        end
+      end
+    end
+  end
+end

data/lib/broadcast/resources/migration.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Broadcast
+  module Resources
+    # Read-only export endpoints under /api/migration/v1 — the surface behind
+    # backups and instance-to-instance migration.
+    #
+    # Two things differ from the v1 API:
+    #
+    # 1. **Admin tokens only.** Channel-scoped tokens are rejected outright;
+    #    the controller looks up AdminApiToken and nothing else.
+    # 2. **broadcast_channel_id is required on every call.** Set it once via
+    #    `Client.new(broadcast_channel_id:)` or `client.with_channel(id)` and
+    #    the gem attaches it automatically; otherwise pass it per call.
+    #
+    # Every list endpoint pages with `limit:` (1..250, default 250) and
+    # `offset:`, and returns `{"data" => [...], "pagination" => {...}}`.
+    class Migration < Base
+      # Endpoints that are a plain paginated list of the channel's records.
+      COLLECTIONS = %i[
+        channels subscribers templates segments sequences email_servers
+        opt_in_forms broadcasts outbound_receipts webhook_endpoints tokens
+        suppressions tags users link_redirects link_clicks subscriber_histories
+        file_assets
+      ].freeze
+
+      COLLECTIONS.each do |collection|
+        define_method(collection) do |**params|
+          get("/api/migration/v1/#{collection}", params)
+        end
+      end
+
+      # Export summary: format version, channel identity, per-resource counts,
+      # and recent-history totals. Call this first to size an export.
+      #
+      # @param days_history [Integer] window for the time-bounded counts
+      #   (broadcasts, receipts, histories). Server clamps to 1..365, default 90.
+      def manifest(**params)
+        get('/api/migration/v1/manifest', params)
+      end
+
+      # Binary contents of a stored file asset. Returns a String of bytes, not
+      # JSON — write it straight to disk.
+      def download_file_asset(id, **params)
+        @client.request(:get, "/api/migration/v1/file_assets/#{id}/download", params, raw: true)
+      end
+
+      # Pages through a collection, yielding each record.
+      #
+      #   client.migration.each_record(:subscribers) { |sub| csv << sub }
+      #
+      # Stops when the server reports `has_more: false`, so it stays correct if
+      # the page size is clamped server-side.
+      def each_record(collection, limit: 250, **params, &block)
+        return enum_for(:each_record, collection, limit: limit, **params) unless block_given?
+
+        offset = 0
+        loop do
+          page = public_send(collection, limit: limit, offset: offset, **params)
+          records = Array(page['data'])
+          records.each(&block)
+
+          pagination = page['pagination'] || {}
+          break unless pagination['has_more']
+
+          # Advance by what the server actually returned — it clamps `limit`.
+          advanced = pagination['limit'] || records.size
+          break if advanced.to_i.zero?
+
+          offset += advanced.to_i
+        end
+      end
+    end
+  end
+end

data/lib/broadcast/resources/opt_in_forms.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Broadcast
+  module Resources
+    class OptInForms < Base
+      # List opt-in forms.
+      #
+      # NOTE: returns up to 250 results per page along with `pagination`
+      # metadata. Variants are excluded (only main forms are returned).
+      # Pass `page:` to advance.
+      #
+      # Optional filters: filter: (label substring), widget_type:, enabled: 'true'
+      def list(**params)
+        get('/api/v1/opt_in_forms', params)
+      end
+
+      def get_opt_in_form(id)
+        get("/api/v1/opt_in_forms/#{id}")
+      end
+
+      # Create an opt-in form. Attrs are wrapped under `opt_in_form:` on the wire.
+      # Nested settings hashes (theme_settings, automation_settings, security_settings,
+      # trigger_settings, widget_settings) and arrays (opt_in_form_blocks_attributes,
+      # opt_in_post_submission_blocks_attributes) are passed through verbatim.
+      #
+      # Core:
+      #   label:, form_type:, widget_type:, enabled:, allowed_embedding_domains:
+      #
+      # Confirmation / welcome flow:
+      #   confirmation_email_template_id:            Template sent to confirm the address
+      #   welcome_email_template_id:                 Template sent after confirmation
+      #   confirmation_redirect_url:                 where to send the subscriber post-confirm
+      #   include_unsubscribe_link_in_confirmation:  boolean
+      #
+      # Custom fields declared in opt_in_form_blocks_attributes support a
+      # multi-line variant, which renders as a textarea on the hosted form.
+      def create(**attrs)
+        post('/api/v1/opt_in_forms', { opt_in_form: attrs })
+      end
+
+      def update(id, **attrs)
+        patch("/api/v1/opt_in_forms/#{id}", { opt_in_form: attrs })
+      end
+
+      def delete(id)
+        @client.request(:delete, "/api/v1/opt_in_forms/#{id}")
+      end
+
+      # Performance analytics for the form. start_date/end_date accept Date,
+      # Time, or ISO-8601 strings (default: last 30 days).
+      def analytics(id, start_date: nil, end_date: nil)
+        params = {}
+        params[:start_date] = coerce_date(start_date) if start_date
+        params[:end_date] = coerce_date(end_date) if end_date
+        get("/api/v1/opt_in_forms/#{id}/analytics", params)
+      end
+
+      def create_variant(id, name: nil, weight: nil)
+        body = {}
+        body[:name] = name unless name.nil?
+        body[:weight] = weight unless weight.nil?
+        post("/api/v1/opt_in_forms/#{id}/variants", body)
+      end
+
+      def duplicate(id, label: nil)
+        body = {}
+        body[:label] = label unless label.nil?
+        post("/api/v1/opt_in_forms/#{id}/duplicate", body)
+      end
+
+      private
+
+      def coerce_date(value)
+        case value
+        when Date, Time, DateTime then value.iso8601
+        else value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/broadcast/resources/subscribers.rb

@@ -3,6 +3,22 @@
 module Broadcast
   module Resources
     class Subscribers < Base
+      # List subscribers (250 per page, with `pagination` metadata; pass `page:`).
+      #
+      # Filters, all optional and combinable:
+      #   is_active:            true | false
+      #   source:               exact match on the source string
+      #   created_after:        ISO-8601 timestamp
+      #   created_before:       ISO-8601 timestamp
+      #   tags:                 array — AND logic, subscriber must have all of them
+      #   email:                partial (case-insensitive) match, not exact
+      #   confirmation_status:  'confirmed' | 'unconfirmed'
+      #   custom_data:          hash — JSONB containment, e.g. { plan: 'pro' }
+      #
+      # An unparseable created_after/created_before is *ignored* by the server
+      # rather than rejected; it comes back as a `parameter_ignored` warning on
+      # the response, so a bad timestamp silently widens the result set unless
+      # you check `result.warnings`.
       def list(**params)
         get('/api/v1/subscribers.json', params)
       end
@@ -11,8 +27,34 @@ module Broadcast
         get('/api/v1/subscribers/find.json', { email: email })
       end
 
+      # Create or upsert a subscriber.
+      #
+      # Subscriber attributes (wrapped under `subscriber:` on the wire):
+      #   email:, first_name:, last_name:, is_active:, source:,
+      #   subscribed_at:, ip_address:, tags: [...], custom_data: {...}
+      #
+      # Top-level options (NOT wrapped under `subscriber:`):
+      #   double_opt_in:               true | { reply_to:, confirmation_template_id:, include_unsubscribe_link: }
+      #                                When set, the subscriber is created in unconfirmed state
+      #                                and a confirmation email is queued.
+      #   confirmation_template_id:    custom confirmation template (used with double_opt_in: true)
+      #
+      # Admin tokens only:
+      #   confirmed_at:                backdate the confirmation timestamp on create.
+      #                                Intended for migrating an already-confirmed list off
+      #                                another provider. Ignored (with a warning) on update,
+      #                                and ignored entirely for channel-scoped tokens.
+      #
+      # Note `unsubscribed_at` is never settable here — use `unsubscribe(email)`.
       def create(**attrs)
-        post('/api/v1/subscribers.json', { subscriber: attrs })
+        double_opt_in = attrs.delete(:double_opt_in)
+        confirmation_template_id = attrs.delete(:confirmation_template_id)
+
+        payload = { subscriber: attrs }
+        payload[:double_opt_in] = double_opt_in unless double_opt_in.nil?
+        payload[:confirmation_template_id] = confirmation_template_id unless confirmation_template_id.nil?
+
+        post('/api/v1/subscribers.json', payload)
       end
 
       def update(email, **attrs)

data/lib/broadcast/resources/templates.rb

@@ -11,6 +11,23 @@ module Broadcast
         get("/api/v1/templates/#{id}")
       end
 
+      # Create a template. Attrs are wrapped under `template:` on the wire.
+      #
+      # Content:
+      #   label:, subject:, preheader:, body:, html_body:
+      #
+      # Confirmation templates (double opt-in):
+      #   template_purpose:          marks the template's role, e.g. 'confirmation'
+      #   confirmation_text:         copy shown in the confirmation email
+      #   default_confirmation:      make this the channel's default confirmation template
+      #   confirmation_page_settings: per-state page copy, keyed by state, each
+      #                              taking { heading:, body: } — e.g.
+      #                              { 'confirmed' => { heading: 'You're in',
+      #                                                 body: 'Thanks for confirming.' },
+      #                                'expired'   => { heading: 'Link expired', body: '...' } }
+      #
+      # Anything the server doesn't recognize comes back as an
+      # `unrecognized_parameter` warning on the response rather than an error.
       def create(**attrs)
         post('/api/v1/templates', { template: attrs })
       end

data/lib/broadcast/resources/transactionals.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Broadcast
+  module Resources
+    class Transactionals < Base
+      MAX_IDEMPOTENCY_KEY_LENGTH = 255
+
+      # Send a transactional email.
+      #
+      # Required:
+      #   to:      recipient email address
+      #
+      # One of subject/body or template_id is required (template_id resolves
+      # subject and body server-side; subject/body override the template).
+      #
+      # Optional:
+      #   subject:, body:, preheader:
+      #   reply_to:
+      #   template_id:                 resolve subject/body/preheader from a Template
+      #   include_unsubscribe_link:    boolean
+      #   double_opt_in:               true | { reply_to:, confirmation_template_id:, include_unsubscribe_link: }
+      #                                Holds the email until the recipient confirms.
+      #   confirmation_template_id:    custom confirmation template (used with double_opt_in: true)
+      #   subscriber:                  { first_name:, last_name: } — populates Subscriber on first send
+      #   idempotency_key:             see below
+      #
+      # Idempotency
+      # -----------
+      # Pass `idempotency_key:` to make a retry safe. The server stores the
+      # response for 24 hours keyed on (token, key) and replays it rather than
+      # sending a second email. Check `result.idempotent_replay?` to tell a
+      # replay from a fresh send.
+      #
+      #   client.transactionals.create(to: 'a@b.com', subject: 'Receipt',
+      #                                body: '<p>Thanks</p>',
+      #                                idempotency_key: "receipt-#{order.id}")
+      #
+      # The key is part of a fingerprint over method + full path + body:
+      #   - same key, same payload, still running   -> Broadcast::ConflictError (409)
+      #   - same key, *different* payload           -> Broadcast::ValidationError (422)
+      # That 422 means "this key was already used for something else", not that
+      # the email was invalid — don't retry it with the same key.
+      # rubocop:disable Metrics/ParameterLists -- mirrors the API's flat param surface
+      def create(to:, subject: nil, body: nil, reply_to: nil, preheader: nil,
+                 template_id: nil, include_unsubscribe_link: nil,
+                 double_opt_in: nil, confirmation_template_id: nil,
+                 subscriber: nil, idempotency_key: nil, **extra)
+        # rubocop:enable Metrics/ParameterLists
+        payload = { to: to }
+        payload[:subject] = subject unless subject.nil?
+        payload[:body] = body unless body.nil?
+        payload[:preheader] = preheader unless preheader.nil?
+        payload[:reply_to] = reply_to unless reply_to.nil?
+        payload[:template_id] = template_id unless template_id.nil?
+        payload[:include_unsubscribe_link] = include_unsubscribe_link unless include_unsubscribe_link.nil?
+        payload[:double_opt_in] = double_opt_in unless double_opt_in.nil?
+        payload[:confirmation_template_id] = confirmation_template_id unless confirmation_template_id.nil?
+        payload[:subscriber] = subscriber unless subscriber.nil?
+        payload.merge!(extra) unless extra.empty?
+
+        @client.request(:post, '/api/v1/transactionals.json', payload,
+                        headers: idempotency_headers(idempotency_key))
+      end
+
+      def get_transactional(id)
+        get("/api/v1/transactionals/#{id}.json")
+      end
+
+      private
+
+      def idempotency_headers(key)
+        return {} if key.nil?
+
+        key = key.to_s.strip
+        return {} if key.empty?
+
+        if key.length > MAX_IDEMPOTENCY_KEY_LENGTH
+          raise ArgumentError,
+                "idempotency_key must be #{MAX_IDEMPOTENCY_KEY_LENGTH} characters or fewer (got #{key.length})"
+        end
+
+        { 'Idempotency-Key' => key }
+      end
+    end
+  end
+end

data/lib/broadcast/response.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Broadcast
+  # A single entry from the API's `warnings` array (docs: api-response-warnings).
+  # The API raises these on successful 2xx responses when it accepted the request
+  # but ignored part of it — an unrecognized parameter, a parameter that only
+  # applies in another mode, a value the server overrode.
+  #
+  # `param` is a dot-path to the offending parameter (e.g. "subscriber.foo").
+  # The API never includes submitted values, so a warning is safe to log.
+  Warning = Struct.new(:code, :param, :message) do
+    def to_s
+      param ? "[#{code}] #{param}: #{message}" : "[#{code}] #{message}"
+    end
+  end
+
+  # Parsed X-RateLimit-* response headers. `reset` is the time the current
+  # window rolls over, not a duration.
+  RateLimit = Struct.new(:limit, :remaining, :reset)
+
+  # The value returned by every JSON API call.
+  #
+  # Response subclasses Hash rather than wrapping it, so everything that worked
+  # against the raw parsed body still works — `result['id']`, `result.is_a?(Hash)`,
+  # `result.dig(...)`, equality against a plain Hash. The response metadata the
+  # API sends alongside the body is exposed as extra readers.
+  #
+  #   result = client.subscribers.create(email: 'user@example.com', foo: 'bar')
+  #   result['id']                  # => 42        (unchanged from v0.2)
+  #   result.warnings               # => [#<Warning code="unrecognized_parameter" ...>]
+  #   result.rate_limit.remaining   # => 118
+  #   result.status                 # => 201
+  #
+  # Non-Hash JSON bodies (a bare array) are returned as-is and carry no metadata.
+  class Response < Hash
+    attr_reader :status, :headers
+
+    class << self
+      # Wraps a parsed JSON body when it is a Hash; passes anything else through.
+      def build(parsed, status:, headers: {})
+        return parsed unless parsed.is_a?(::Hash)
+
+        response = new
+        response.replace(parsed)
+        response.attach_metadata(status: status, headers: headers)
+        response
+      end
+    end
+
+    # @api private — set once by .build immediately after construction
+    def attach_metadata(status:, headers:)
+      @status = status
+      @headers = headers
+      self
+    end
+
+    def warnings
+      @warnings ||= Array(self['warnings']).filter_map do |entry|
+        next unless entry.is_a?(::Hash)
+
+        Warning.new(code: entry['code'], param: entry['param'], message: entry['message'])
+      end
+    end
+
+    def warnings?
+      !warnings.empty?
+    end
+
+    def rate_limit
+      return @rate_limit if defined?(@rate_limit)
+
+      limit = header('x-ratelimit-limit')
+      @rate_limit = if limit.nil?
+                      nil
+                    else
+                      RateLimit.new(
+                        limit: limit.to_i,
+                        remaining: header('x-ratelimit-remaining')&.to_i,
+                        reset: parse_time(header('x-ratelimit-reset'))
+                      )
+                    end
+    end
+
+    # True when the API replayed a stored response for a repeated
+    # Idempotency-Key rather than performing the write again.
+    def idempotent_replay?
+      header('idempotency-replayed') == 'true'
+    end
+
+    private
+
+    def header(name)
+      (@headers || {})[name]
+    end
+
+    def parse_time(value)
+      value && Time.iso8601(value)
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/broadcast/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Broadcast
-  VERSION = '0.1.4'
+  VERSION = '0.3.0'
 end

data/lib/broadcast/webhook.rb

@@ -7,6 +7,40 @@ module Broadcast
   module Webhook
     TIMESTAMP_TOLERANCE = 300 # 5 minutes
 
+    # Every event type a webhook endpoint can subscribe to, mirroring
+    # WebhookEndpoint::AVAILABLE_EVENT_TYPES server-side. Use these when
+    # creating an endpoint — an unknown event type is dropped silently.
+    EMAIL_EVENTS = %w[
+      email.sent email.delivered email.delivery_delayed email.complained
+      email.bounced email.opened email.clicked email.failed
+    ].freeze
+
+    SUBSCRIBER_EVENTS = %w[
+      subscriber.created subscriber.updated subscriber.deleted
+      subscriber.subscribed subscriber.unsubscribed subscriber.bounced
+      subscriber.complained
+    ].freeze
+
+    BROADCAST_EVENTS = %w[
+      broadcast.scheduled broadcast.queueing broadcast.sending broadcast.sent
+      broadcast.failed broadcast.partial_failure broadcast.aborted
+      broadcast.paused
+    ].freeze
+
+    SEQUENCE_EVENTS = %w[
+      sequence.subscriber_added sequence.subscriber_completed
+      sequence.subscriber_moved sequence.subscriber_removed
+      sequence.subscriber_paused sequence.subscriber_resumed
+      sequence.subscriber_error
+    ].freeze
+
+    # Delivery-machinery events, not content events.
+    SYSTEM_EVENTS = %w[message.attempt.exhausted test.webhook].freeze
+
+    EVENT_TYPES = (
+      EMAIL_EVENTS + SUBSCRIBER_EVENTS + BROADCAST_EVENTS + SEQUENCE_EVENTS + SYSTEM_EVENTS
+    ).freeze
+
     module_function
 
     def verify(payload, signature_header, timestamp_header, secret:, now: nil)

data/lib/broadcast.rb

@@ -2,7 +2,10 @@
 
 require_relative 'broadcast/version'
 require_relative 'broadcast/errors'
+require_relative 'broadcast/response'
 require_relative 'broadcast/configuration'
+require_relative 'broadcast/debug_logger'
+require_relative 'broadcast/connection'
 require_relative 'broadcast/client'
 require_relative 'broadcast/webhook'
 require_relative 'broadcast/resources/base'
@@ -12,6 +15,12 @@ require_relative 'broadcast/resources/broadcasts'
 require_relative 'broadcast/resources/segments'
 require_relative 'broadcast/resources/templates'
 require_relative 'broadcast/resources/webhook_endpoints'
+require_relative 'broadcast/resources/transactionals'
+require_relative 'broadcast/resources/opt_in_forms'
+require_relative 'broadcast/resources/email_servers'
+require_relative 'broadcast/resources/autopilots'
+require_relative 'broadcast/resources/discovery'
+require_relative 'broadcast/resources/migration'
 
 # ActionMailer integration — only loaded when Rails is present
 if defined?(Rails::Railtie)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: broadcast-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Simon Chiu
@@ -31,27 +31,36 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
+- SDK-COVERAGE.md
 - lib/broadcast-ruby.rb
 - lib/broadcast.rb
 - lib/broadcast/client.rb
 - lib/broadcast/configuration.rb
+- lib/broadcast/connection.rb
+- lib/broadcast/debug_logger.rb
 - lib/broadcast/delivery_method.rb
 - lib/broadcast/errors.rb
 - lib/broadcast/railtie.rb
+- lib/broadcast/resources/autopilots.rb
 - lib/broadcast/resources/base.rb
 - lib/broadcast/resources/broadcasts.rb
+- lib/broadcast/resources/discovery.rb
+- lib/broadcast/resources/email_servers.rb
+- lib/broadcast/resources/migration.rb
+- lib/broadcast/resources/opt_in_forms.rb
 - lib/broadcast/resources/segments.rb
 - lib/broadcast/resources/sequences.rb
 - lib/broadcast/resources/subscribers.rb
 - lib/broadcast/resources/templates.rb
+- lib/broadcast/resources/transactionals.rb
 - lib/broadcast/resources/webhook_endpoints.rb
+- lib/broadcast/response.rb
 - lib/broadcast/version.rb
 - lib/broadcast/webhook.rb
 homepage: https://github.com/send-broadcast/broadcast-ruby
@@ -77,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Ruby client for the Broadcast email platform
 test_files: []