webhookdb 1.0.1 → 1.1.0

data/lib/webhookdb/replicator/front_marketplace_root_v1.rb

@@ -10,7 +10,7 @@ class Webhookdb::Replicator::FrontMarketplaceRootV1 < Webhookdb::Replicator::Bas
     return Webhookdb::Replicator::Descriptor.new(
       name: "front_marketplace_root_v1",
       ctor: self,
-      feature_roles: ["front"],
+      feature_roles: [],
       resource_name_singular: "Front Auth",
       resource_name_plural: "Front Auth",
       supports_webhooks: true,
@@ -47,9 +47,6 @@ class Webhookdb::Replicator::FrontMarketplaceRootV1 < Webhookdb::Replicator::Bas
   end
 
   def calculate_webhook_state_machine
-    step = Webhookdb::Replicator::StateMachineStep.new
-    step.output = "This integration cannot be modified through the command line."
-    step.completed
-    return step
+    return Webhookdb::Replicator::FrontV1Mixin.marketplace_only_state_machine
   end
 end

data/lib/webhookdb/replicator/front_message_v1.rb

@@ -11,7 +11,7 @@ class Webhookdb::Replicator::FrontMessageV1 < Webhookdb::Replicator::Base
     return Webhookdb::Replicator::Descriptor.new(
       name: "front_message_v1",
       ctor: self,
-      feature_roles: ["front"],
+      feature_roles: [],
       resource_name_singular: "Front Message",
       dependency_descriptor: Webhookdb::Replicator::FrontMarketplaceRootV1.descriptor,
       supports_webhooks: true,
@@ -42,4 +42,8 @@ class Webhookdb::Replicator::FrontMessageV1 < Webhookdb::Replicator::Base
   def _update_where_expr
     return self.qualified_table_sequel_identifier[:data] !~ Sequel[:excluded][:data]
   end
+
+  def calculate_webhook_state_machine
+    return Webhookdb::Replicator::FrontV1Mixin.marketplace_only_state_machine
+  end
 end

data/lib/webhookdb/replicator/front_signalwire_message_channel_app_v1.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require "jwt"
+
+require "webhookdb/replicator/front_v1_mixin"
+
+# Front has a system of 'channels' but it is a challenge to use.
+# This replicator leverages WebhookDB (and our existing Front app)
+# to integrate Front and SignalWire messages,
+# using a sort of two-way sync that implements the necessary Front channel contrWcts.
+#
+# Note: In the future, we can abstract this to support other channels, with minimal changes.
+#
+# We have the following concepts to keep in mind:
+#
+# - The front_message_v1 replicator stores ALL messages in Front (inbound and outbound).
+# - The signalwire_message_v1 replicator stores ALL messages in SignalWire (inbound and outbound).
+# - For two-way sync, we care that Outbound Front messages are turned into Outbound SignalWire messages,
+#   and Inbound SignalWire messages are turned into Inbound Front messages.
+# - This means that, for the purpose of a two-way sync, this replicator can 'enqueue' deliveries by storing
+#   a row with *either* a Front message id (query Front for all outbound messages),
+#   *or* SignalWire message id (query signalwire for all inbound messages). When a row has *both* ids,
+#   it means it has been "delivered", so to speak.
+# - We can ignore inbound Front messages and outbound SignalWire messages
+#   (stored in their respective replicators), since those are created by this replicator.
+#
+# This means that, rather than having to manage state between two event-based systems,
+# we can *converge* to a correct state based on a given state.
+# This is much easier (possible?) to reason about and test,
+# and makes it possible to reuse code,
+#
+# The order of operations is:
+# - The channel description instructs the user to go to /v1/install/front_signalwire/setup.
+# - This loads a terminal, showing instructions for how to set up
+#   (enabling the WebhookDB Front app, setting up SignalWire).
+# - The state machine also asks for the phone number to use to send messages.
+#   - The phone number used to send messages is stored in the api_url.
+# - The state machine prints out the API token to use in Front.
+#   - The api token is stored in the 'webhookdb_api_key' field, which is searchable.
+# - The user is directed to Front, to install the WebhookDB SignalWire channel.
+# - The user inputs their API token and connects the channel.
+# - Front makes an 'authorization' request to /v1/install/front_signalwire/authorization.
+#   - This uses the API key to find the right front_signalwire_message_channel_app_v1 integration
+#     via the webhookdb_api_key field.
+#   - This stores the channel_id on the integration as the api_url.
+# - Front makes 'message' requests to /v1/install/front_signalwire/message/<opaque id>.
+#   - This upserts a DB row into the front_message_v1 replicator.
+#   - It also enqueues a backfill of this replicator.
+# - Front can make a 'delete' request to /v1/install/front_signalwire/message/<opaque id>.
+#   - This deletes deletes this service integration.
+# - Because this replicator is a dependent of signalwire_message_v1 (see explanation below),
+#   whenever a signalwire row is updated, this replicator will be triggered and enqueue a backfill.
+# - When this replicator backfills, it will:
+#   - Look for inbound SMS, and upsert a row into this replication table.
+#   - Look for outbound Front messages, and upsert a row into this replication table.
+#   - Find replication table rows without a signalwire id, and send an SMS.
+#   - Find replication table rows without a Front message id, and create a Front message
+#     using https://dev.frontapp.com/reference/sync-inbound-message
+#
+class Webhookdb::Replicator::FrontSignalwireMessageChannelAppV1 < Webhookdb::Replicator::Base
+  include Webhookdb::DBAdapter::ColumnTypes
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "front_signalwire_message_channel_app_v1",
+      ctor: self,
+      feature_roles: [],
+      resource_name_singular: "Front/SignalWire Message",
+      dependency_descriptor: Webhookdb::Replicator::SignalwireMessageV1.descriptor,
+      supports_webhooks: true,
+      supports_backfill: true,
+      api_docs_url: "https://dev.frontapp.com/docs/getting-started-with-partner-channels",
+    )
+  end
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:external_id, TEXT)
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:signalwire_sid, TEXT, optional: true, index: true),
+      Webhookdb::Replicator::Column.new(:front_message_id, TEXT, optional: true, index: true),
+      Webhookdb::Replicator::Column.new(:external_conversation_id, TEXT, optional: true, index: true),
+      Webhookdb::Replicator::Column.new(:row_updated_at, TIMESTAMP, defaulter: :now, optional: true, index: true),
+      Webhookdb::Replicator::Column.new(:direction, TEXT),
+      Webhookdb::Replicator::Column.new(:body, TEXT),
+      Webhookdb::Replicator::Column.new(:sender, TEXT),
+      Webhookdb::Replicator::Column.new(:recipient, TEXT),
+    ]
+  end
+
+  def _timestamp_column_name
+    return :row_updated_at
+  end
+
+  def _update_where_expr
+    return (self.qualified_table_sequel_identifier[:signalwire_sid] =~ nil) |
+        (self.qualified_table_sequel_identifier[:front_message_id] =~ nil)
+  end
+
+  def format_phone(s) = Webhookdb::PhoneNumber.format_e164(s)
+  def support_phone = self.format_phone(self.service_integration.api_url)
+
+  def calculate_webhook_state_machine
+    if (step = self.calculate_dependency_state_machine_step(dependency_help: ""))
+      return step
+    end
+    step = Webhookdb::Replicator::StateMachineStep.new
+    if self.service_integration.api_url.blank?
+      step.output = %(This Front Channel will be linked to a specific number in SignalWire.
+Choose the phone number to connect to Front.)
+      return step.prompting("Phone number").api_url(self.service_integration)
+    end
+    self.service_integration.webhookdb_api_key ||= self.service_integration.new_api_key
+    self.service_integration.save_changes
+    step.output = %(Almost there! You can now finish installing the SignalWire Channel in Front.
+
+1. In Front, go to Settings -> Company -> Channels (in the left nav), Connect a Channel,
+   and choose the 'WebhookDB/SignalWire' channel.
+2. In the 'Token' field, enter this API Key: #{self.service_integration.webhookdb_api_key}
+
+If you need to find this key, you can run `webhookdb integrations info front_signalwire_message_channel_app_v1`.
+
+All of this information can be found in the WebhookDB docs, at https://docs.webhookdb.com/guides/front-channel-signalwire/)
+    return step.completed
+  end
+
+  def calculate_backfill_state_machine
+    # The backfills here are not normal backfills, requested by the customer.
+    # They are procedurally enqueued when we upsert data.
+    # So just reuse the webhook state machine.
+    return self.calculate_webhook_state_machine
+  end
+
+  def clear_webhook_information
+    # We say we support backfill, so this won't get cleared normally.
+    self._clear_backfill_information
+    super
+  end
+
+  def process_webhooks_synchronously? = true
+
+  def synchronous_processing_response_body(upserted:, request:)
+    case request.body["type"]
+      when "authorization"
+        self.front_channel_id = request.body.fetch("payload").fetch("channel_id")
+        self.service_integration.save_changes
+        return {type: "success", webhook_url: "#{Webhookdb.api_url}/v1/install/front_signalwire/channel"}.to_json
+      when "delete"
+        self.service_integration.destroy
+        return "{}"
+      when "message", "message_autoreply"
+        return {
+          type: "success",
+          external_id: upserted.fetch(:external_id),
+          external_conversation_id: upserted.fetch(:external_conversation_id),
+        }.to_json
+      else
+        return "{}"
+    end
+  end
+
+  def front_channel_id = self.service_integration.backfill_key
+
+  def front_channel_id=(c)
+    self.service_integration.backfill_key = c
+  end
+
+  def _webhook_response(request)
+    return Webhookdb::Front.webhook_response(request, Webhookdb::Front.signalwire_channel_app_secret)
+  end
+
+  def _resource_and_event(request)
+    type = request.body["type"]
+    is_signalwire = type.nil?
+    return request.body, nil if is_signalwire
+
+    # This ends up being called for 'authorization' and 'delete' messages too.
+    # Those are handled in the webhook response body.
+    is_message_type = ["message", "message_autoreply"].include?(type)
+    return nil, nil unless is_message_type
+
+    resource = request.body.dup
+    payload = resource.fetch("payload")
+    mid = if type == "message"
+            payload.fetch("id")
+      else
+        replied_to_id = payload["_links"]["related"]["message_replied_to"].split("/").last
+        "#{replied_to_id}_autoreply"
+    end
+    resource["front_message_id"] = mid
+    # Use the Front ID to identify this outbound message.
+    resource["external_id"] = mid
+    resource["direction"] = "outbound"
+    resource["body"] = payload.fetch("text")
+    resource["sender"] = self.support_phone
+    resource["recipient"] = self._front_recipient_phone(payload)
+    # All messages get the same conversation with SMS/chat, unlike email.
+    resource["external_conversation_id"] = resource["recipient"]
+    return resource, nil
+  end
+
+  def _front_recipient_phone(payload)
+    recipient = payload["recipients"].find { |r| r.fetch("role") == "to" }
+    raise Webhookdb::InvariantViolation, "no recipient found in #{payload}" if recipient.nil?
+    return self.format_phone(recipient.fetch("handle"))
+  end
+
+  def on_dependency_webhook_upsert(_replicator, payload, changed:)
+    return unless changed
+    return unless payload.fetch(:direction) == "inbound"
+    return unless payload.fetch(:to) == self.support_phone
+    body = JSON.parse(payload.fetch(:data))
+    body.merge!(
+      "external_id" => payload.fetch(:signalwire_id),
+      "signalwire_sid" => payload.fetch(:signalwire_id),
+      "direction" => "inbound",
+      "sender" => payload.fetch(:from),
+      "recipient" => self.support_phone,
+      "external_conversation_id" => payload.fetch(:from),
+    )
+    self.upsert_webhook_body(body)
+  end
+
+  def _notify_dependents(inserting, changed)
+    super
+    return unless changed
+    Webhookdb::BackfillJob.create_recursive(service_integration: self.service_integration, incremental: true).enqueue
+  end
+
+  def _backfillers = [Backfiller.new(self)]
+
+  class Backfiller < Webhookdb::Backfiller
+    def initialize(replicator)
+      super()
+      @replicator = replicator
+      @signalwire_sint = replicator.service_integration.depends_on
+    end
+
+    def handle_item(item)
+      front_id = item.fetch(:front_message_id)
+      sw_id = item.fetch(:signalwire_sid)
+      if (front_id && sw_id) || (!front_id && !sw_id)
+        msg = "row should have a front id OR signalwire id, should not have been inserted, or selected: #{item}"
+        raise Webhookdb::InvariantViolation, msg
+      end
+      sender = @replicator.format_phone(item.fetch(:sender))
+      recipient = @replicator.format_phone(item.fetch(:recipient))
+      body = item.fetch(:body)
+      idempotency_key = "fsmca-fims-#{item.fetch(:external_id)}"
+      idempotency = Webhookdb::Idempotency.once_ever.stored.using_seperate_connection.under_key(idempotency_key)
+      if front_id.nil?
+        texted_at = Time.parse(item.fetch(:data).fetch("date_created"))
+        if texted_at < Webhookdb::Front.channel_sync_refreshness_cutoff.seconds.ago
+          # Do not sync old rows, just mark them synced
+          item[:front_message_id] = "skipped_due_to_age"
+        else
+          # sync the message into Front
+          front_response_body = idempotency.execute do
+            self._sync_front_inbound(sender:, texted_at:, item:, body:)
+          end
+          item[:front_message_id] = front_response_body.fetch("message_uid")
+        end
+      else
+        messaged_at = Time.at(item.fetch(:data).fetch("created_at"))
+        if messaged_at < Webhookdb::Front.channel_sync_refreshness_cutoff.seconds.ago
+          # Do not sync old rows, just mark them synced
+          item[:signalwire_sid] = "skipped_due_to_age"
+        else
+          # send the SMS via signalwire
+          signalwire_resp = idempotency.execute do
+            Webhookdb::Signalwire.send_sms(
+              from: sender,
+              to: recipient,
+              body:,
+              space_url: @signalwire_sint.api_url,
+              project_id: @signalwire_sint.backfill_key,
+              api_key: @signalwire_sint.backfill_secret,
+              logger: @replicator.logger,
+            )
+          end
+          item[:signalwire_sid] = signalwire_resp.fetch("sid")
+        end
+      end
+      @replicator.upsert_webhook_body(item.deep_stringify_keys)
+    end
+
+    def _sync_front_inbound(sender:, texted_at:, item:, body:)
+      body = {
+        sender: {handle: sender},
+        body:,
+        delivered_at: texted_at.to_i,
+        metadata: {
+          external_id: item.fetch(:external_id),
+          external_conversation_id: item.fetch(:external_conversation_id),
+        },
+      }
+      token = JWT.encode(
+        {
+          iss: Webhookdb::Front.signalwire_channel_app_id,
+          jti: Webhookdb::Front.channel_jwt_jti,
+          sub: @replicator.front_channel_id,
+          exp: 10.seconds.from_now.to_i,
+        },
+        Webhookdb::Front.signalwire_channel_app_secret,
+      )
+      resp = Webhookdb::Http.post(
+        "https://api2.frontapp.com/channels/#{@replicator.front_channel_id}/inbound_messages",
+        body,
+        headers: {"Authorization" => "Bearer #{token}"},
+        timeout: Webhookdb::Front.http_timeout,
+        logger: @replicator.logger,
+      )
+      resp.parsed_response
+    end
+
+    def fetch_backfill_page(*)
+      rows = @replicator.admin_dataset do |ds|
+        ds.where(Sequel[signalwire_sid: nil] | Sequel[front_message_id: nil]).all
+      end
+      return rows, nil
+    end
+  end
+end

data/lib/webhookdb/replicator/front_v1_mixin.rb

@@ -13,10 +13,18 @@ module Webhookdb::Replicator::FrontV1Mixin
   end
 
   def _webhook_response(request)
-    return Webhookdb::Front.webhook_response(request)
+    return Webhookdb::Front.webhook_response(request, Webhookdb::Front.app_secret)
   end
 
   def on_dependency_webhook_upsert(_replicator, _payload, *)
     return
   end
+
+  def self.marketplace_only_state_machine
+    step = Webhookdb::Replicator::StateMachineStep.new
+    step.output = %(Front integrations can only be enabled through the Front App Store.
+Head over to https://app.frontapp.com/settings/apps/details/webhookdb/overview to set up WebhookDB replication.)
+    step.completed
+    return step
+  end
 end

data/lib/webhookdb/replicator/signalwire_message_v1.rb

@@ -43,6 +43,16 @@ class Webhookdb::Replicator::SignalwireMessageV1 < Webhookdb::Replicator::Base
     )
   end
 
+  def process_state_change(field, value, attr: nil)
+    if field == "api_url" && value.include?(".")
+      value = "https://" + value unless value.include?("://")
+      u = URI(value)
+      h = u.host.gsub(/\.signalwire\.com$/, "")
+      value = h
+    end
+    return super(field, value, attr:)
+  end
+
   def calculate_backfill_state_machine
     step = Webhookdb::Replicator::StateMachineStep.new
     unless self.service_integration.api_url.present?
@@ -67,8 +77,12 @@ Go to https://#{self.service_integration.api_url}.signalwire.com/credentials and
 
     unless self.service_integration.backfill_secret.present?
       step.needs_input = true
-      step.output = %(Let's create or reuse an API token. Press the 'New' button on your dashboard,
-name the token something like 'WebhookDB', and under Scopes, ensure the 'Messaging' checkbox is checked.
+      step.output = %(Let's create or reuse an API token.
+
+Go to https://#{self.service_integration.api_url}.signalwire.com/credentials
+and press the 'New' button.
+Name the token something like 'WebhookDB'.
+Under Scopes, ensure the 'Messaging' checkbox is checked.
 Then press 'Save'.
 
 Press 'Show' next to the newly-created API token, and copy it.)
@@ -139,22 +153,20 @@ Press 'Show' next to the newly-created API token, and copy it.)
   end
 
   def _fetch_backfill_page(pagination_token, last_backfilled:)
-    url = "https://#{self.service_integration.api_url}.signalwire.com"
+    urltail = pagination_token
     if pagination_token.blank?
       date_send_max = Date.tomorrow
-      url += "/2010-04-01/Accounts/#{self.service_integration.backfill_key}/Messages.json" \
-             "?PageSize=100&DateSend%3C=#{date_send_max}"
-    else
-      url += pagination_token
+      urltail = "/2010-04-01/Accounts/#{self.service_integration.backfill_key}/Messages.json" \
+                "?PageSize=100&DateSend%3C=#{date_send_max}"
     end
-    response = Webhookdb::Http.get(
-      url,
-      basic_auth: {username: self.service_integration.backfill_key,
-                   password: self.service_integration.backfill_secret,},
+    data = Webhookdb::Signalwire.http_request(
+      :get,
+      urltail,
+      space_url: self.service_integration.api_url,
+      project_id: self.service_integration.backfill_key,
+      api_key: self.service_integration.backfill_secret,
       logger: self.logger,
-      timeout: Webhookdb::Signalwire.http_timeout,
     )
-    data = response.parsed_response
     messages = data["messages"]
 
     if last_backfilled.present?

data/lib/webhookdb/service_integration.rb

@@ -9,8 +9,15 @@ class Webhookdb::ServiceIntegration < Webhookdb::Postgres::Model(:service_integr
   class TableRenameError < Webhookdb::InvalidInput; end
 
   # We limit the information that a user can access through the CLI to these fields.
-  # Blank string returns all info.
-  INTEGRATION_INFO_FIELDS = ["id", "service", "table", "url", "webhook_secret", ""].freeze
+  INTEGRATION_INFO_FIELDS = {
+    "id" => :opaque_id,
+    "service" => :service_name,
+    "table" => :table_name,
+    "url" => :unauthed_webhook_endpoint,
+    "webhook_secret" => :webhook_secret,
+    "webhookdb_api_key" => :webhookdb_api_key,
+    "api_url" => :api_url,
+  }.freeze
 
   plugin :timestamps
   plugin :column_encryption do |enc|
@@ -18,6 +25,7 @@ class Webhookdb::ServiceIntegration < Webhookdb::Postgres::Model(:service_integr
     enc.column :webhook_secret
     enc.column :backfill_key
     enc.column :backfill_secret
+    enc.column :webhookdb_api_key, searchable: true
   end
 
   many_to_one :organization, class: "Webhookdb::Organization"
@@ -64,11 +72,17 @@ class Webhookdb::ServiceIntegration < Webhookdb::Postgres::Model(:service_integr
   one_to_many :dependents, key: :depends_on_id, class: self
   one_to_many :sync_targets, class: "Webhookdb::SyncTarget"
 
+  # @return [Webhookdb::ServiceIntegration]
   def self.create_disambiguated(service_name, **kwargs)
     kwargs[:table_name] ||= "#{service_name}_#{SecureRandom.hex(2)}"
     return self.create(service_name:, **kwargs)
   end
 
+  # @return [Webhookdb::ServiceIntegration]
+  def self.for_api_key(key)
+    return self.with_encrypted_value(:webhookdb_api_key, key).first
+  end
+
   def can_be_modified_by?(customer)
     return customer.verified_member_of?(self.organization)
   end
@@ -254,12 +268,24 @@ class Webhookdb::ServiceIntegration < Webhookdb::Postgres::Model(:service_integr
     return self.db.select(Sequel.function(:nextval, self.sequence_name)).single_value
   end
 
+  def new_opaque_id = Webhookdb::Id.new_opaque_id("svi")
+
+  def ensure_opaque_id = self[:opaque_id] ||= self.new_opaque_id
+
+  def new_api_key
+    k = +"sk/"
+    k << self.ensure_opaque_id
+    k << "/"
+    k << Webhookdb::Id.rand_enc(24)
+    return k
+  end
+
   #
   # :Sequel Hooks:
   #
 
   def before_create
-    self[:opaque_id] ||= Webhookdb::Id.new_opaque_id("svi")
+    self.ensure_opaque_id
   end
 
   # @!attribute organization
@@ -286,6 +312,13 @@ class Webhookdb::ServiceIntegration < Webhookdb::Postgres::Model(:service_integr
   # @!attribute webhook_secret
   #   @return [String] Secret used to sign webhooks.
 
+  # @!attribute webhookdb_api_key
+  #   @return [String] API Key used in the Whdb-Api-Key header that can be used to identify
+  #     this service integration (where the opaque id cannot be used),
+  #     and is a secret so can be used for authentication.
+  #     Need for this should be rare- it's usually only used outside of the core webhookdb/backfill design
+  #     like for two-way sync (Front Channel/Signalwire integration, for example).
+
   # @!attribute depends_on
   #   @return [Webhookdb::ServiceIntegration]
 

data/lib/webhookdb/signalwire.rb

@@ -9,5 +9,45 @@ module Webhookdb::Signalwire
 
   configurable(:signalwire) do
     setting :http_timeout, 30
+    setting :sms_allowlist, [], convert: ->(s) { s.split }
+  end
+
+  def self.send_sms(from:, to:, body:, project_id:, **kw)
+    sms_allowed = self.sms_allowlist.any? { |pattern| File.fnmatch(pattern, to) }
+    unless sms_allowed
+      self.logger.warn("signalwire_sms_not_allowed", to:)
+      return {"sid" => "skipped"}
+    end
+    return self.http_request(
+      :post,
+      "/2010-04-01/Accounts/#{project_id}/Messages.json",
+      body: {
+        From: from,
+        To: to,
+        Body: body,
+      },
+      project_id:,
+      **kw,
+    )
+  end
+
+  def self.http_request(method, tail, space_url:, project_id:, api_key:, logger:, headers: {}, body: nil, **kw)
+    url = "https://#{space_url}.signalwire.com" + tail
+    headers["Content-Type"] = "application/x-www-form-urlencoded"
+    headers["Accept"] = "application/json"
+    kw[:body] = URI.encode_www_form(body) if body
+    resp = Webhookdb::Http.send(
+      method,
+      url,
+      basic_auth: {
+        username: project_id,
+        password: api_key,
+      },
+      logger:,
+      timeout: self.http_timeout,
+      headers:,
+      **kw,
+    )
+    return resp.parsed_response
   end
 end

data/lib/webhookdb/spec_helpers/citest.rb

@@ -4,10 +4,18 @@ require "webhookdb/slack"
 require "webhookdb/spec_helpers"
 
 module Webhookdb::SpecHelpers::Citest
-  def self.run_tests(folder)
+  INTEGRATION_TESTS_DIR = Pathname(__FILE__).dirname.parent.parent.parent + "integration"
+
+  # Run RSpec against the given folders, create a DatabaseDocument for the html results,
+  # and POST to Slack about it.
+  def self.run_tests(folders)
     out = StringIO.new
     err = StringIO.new
-    RSpec::Core::Runner.run([folder + "/", "--format", "html"], err, out)
+    folders = [folders] unless folders.respond_to?(:to_ary)
+    args = folders.map { |f| "#{f}/" }
+    args << "--format"
+    args << "html"
+    RSpec::Core::Runner.run(args, err, out)
 
     notifier = Webhookdb::Slack.new_notifier(
       force_channel: "#webhookdb-notifications",
@@ -17,13 +25,14 @@ module Webhookdb::SpecHelpers::Citest
     outstring = out.string
     result = Webhookdb::SpecHelpers::Citest.parse_rspec_html(outstring)
     unless result.ok?
-      msg = "Errored or unparseable output running #{folder} tests:\nerror: #{err.string}\nout: #{outstring}"
+      msg = "Errored or unparseable output running #{folders.join(', ')} tests:" \
+            "\nerror: #{err.string}\nout: #{outstring}"
       notifier.post text: msg
       return
     end
 
-    url = self.put_results(folder, result.html)
-    payload = self.result_to_payload(folder, result, url)
+    url = self.put_results(result.html)
+    payload = self.result_to_payload(result, url)
     notifier.post(payload)
   end
 
@@ -43,9 +52,9 @@ module Webhookdb::SpecHelpers::Citest
     return result
   end
 
-  def self.put_results(folder, html)
+  def self.put_results(html, key: "integration")
     now = Time.now
-    key = "test-results/#{folder}/#{now.year}/#{now.month}/#{now.in_time_zone('UTC').iso8601}.html"
+    key = "test-results/#{key}/#{now.year}/#{now.month}/#{now.in_time_zone('UTC').iso8601}.html"
     doc = Webhookdb::DatabaseDocument.create(
       key:,
       content: html,
@@ -55,13 +64,13 @@ module Webhookdb::SpecHelpers::Citest
     return url
   end
 
-  def self.result_to_payload(folder, result, html_url)
+  def self.result_to_payload(result, html_url, prefix: "Integration Tests")
     color = "good"
     color = "warning" if result.pending.nonzero?
     color = "danger" if result.failures.nonzero?
 
     return {
-      text: "Tests for #{folder}: #{result.examples} examples, #{result.failures} failures, #{result.pending} pending",
+      text: "#{prefix}: #{result.examples} examples, #{result.failures} failures, #{result.pending} pending",
       attachments: [
         {
           color:,

data/lib/webhookdb/spec_helpers/postgres.rb

@@ -31,6 +31,7 @@ module Webhookdb::SpecHelpers::Postgres
     context.around(:each) do |example|
       Webhookdb::Postgres.unsafe_skip_transaction_check = true if example.metadata[:no_transaction_check]
 
+      _truncate(example)
       setting = example.metadata[:db]
       if setting && setting != :no_transaction
         Webhookdb::SpecHelpers::Postgres.wrap_example_in_transactions(example)
@@ -44,11 +45,19 @@ module Webhookdb::SpecHelpers::Postgres
       Webhookdb::Postgres.unsafe_skip_transaction_check = false if example.metadata[:no_transaction_check]
 
       truncate_all if example.metadata[:db] == :no_transaction
+      _truncate(example)
     end
 
     super
   end
 
+  module_function def _truncate(example)
+    tr = example.metadata[:truncate]
+    return unless tr
+    tr = [tr] unless tr.respond_to?(:to_ary)
+    tr.each(&:truncate)
+  end
+
   ### Run the specified +example+ in the context of a transaction for each loaded
   ### model superclass. Raises if any of the loaded superclasses aren't
   ### configured.