slack_message 1.7.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3438c93abd1488bafc0ee9f33df94674290b68bd94110e8f2e601d95d3254bc
-  data.tar.gz: 5eee7e715e66042ab6c3ccbc47eedba3e2ddddacd327e1096e3a2d3476b076b0
+  metadata.gz: e92b2faa8e8b8118a0e168cef488d64b94255c841d774909647ede3d9a9faf6b
+  data.tar.gz: d494af801908aa9f5cf25141b012df26e23a69f8ef9389c3c8bb580c46641133
 SHA512:
-  metadata.gz: ddc5ace3b66e6977b164accfeec16c67450ed8fbd182939e85aa1d56c251319f203c4527d75d410c2858bbfa7540889a83ed08aed12890488944077edf1867ed
-  data.tar.gz: 16601f240ee826b8cadbd03429b5fd431ba21a5b159c1ca3c70932da362b54388c32115544bf782c45f9e2b1c603801d82e2fd6827e7020abfcaed18669601ee
+  metadata.gz: 6fceee6aeb36f7fc6b855c1ce90f647b67ce480c78e62ec2fe45bbfc347e6c9efa6ca910804c51b0edb12321953d96014ac137572d2140328109444f68512ca4
+  data.tar.gz: a9fe4697d85ac2f91197a39dacc46d1740c251f8472dcb91e8ba2132caac5c9f029cb5f88894f39542e1436ce554562d87108661863c2574655e64c866c5115e

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [2.1.0] - 2021-11-01
+- Change to use Slack Apps for all profiles. This should allow growth toward
+  updating messages, working with interactive messages etc.
+- As a result, allow custom icons per profile / message.
+- When sending a message, the first `text` block is used for the notification
+  content. Should resolve "this content cannot be displayed".
+- Significant restructuring of README.
+
+## [2.0.0] - 2021-11-01
+- Yeah that was all broken.
+
+## [1.9.0] - 2021-10-27
+- Add many validations so that trying to add e.g. empty text won't succeed.
+  Previously that would be accepted but return `invalid_blocks` from the API.
+
+## [1.8.1] - 2021-10-08
+- Cleaned that rspec code a bit, added more matchers for real world use.
+
+## [1.8.0] - 2021-10-07
+- Added the ability to test in RSpec.
+
 ## [1.7.1] - 2021-10-06
 - Fixed literally a syntax issue.
 - Fixed specs.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    slack_message (1.7.1)
+    slack_message (2.1.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -3,8 +3,7 @@ SlackMessage: a Friendly DSL for Slack
 
 SlackMessage is a wrapper over the [Block Kit
 API](https://app.slack.com/block-kit-builder/) to make it easy to read and
-write messages to slack in your ruby application. It has zero dependencies and
-is built to be opinionated to keep your configuration needs low.
+write messages to slack in your ruby application.
 
 Posting a message to Slack should be this easy:
 
@@ -16,80 +15,105 @@ end
 
 To install, just add `slack_message` to your bundle and you're ready to go.
 
+Opinionated Stances
+------------
+
+Slack's API has a lot of options available to you! But this gem takes some
+opinionated stances on how to make use of that API. For instance:
+
+* No dependencies. Your lockfile is enough of a mess already.
+* Webhooks are passé. Only Slack Apps are supported now.
+* Unless you request otherwise, text is always rendered using `mrkdwn`. If you
+  want plaintext, you'll need to ask for it. Same for the `emoji` flag.
+* As many API semantics as possible are hidden. For instance, if you post to
+  something that looks like an email address, `slack_message` is going to try to
+  look it up as an email address.
+* A few little hacks on the block syntax, such as adding a `blank_line` (which
+  doesn't exist in the API), or leading spaces.
+* Configuration should be as simple as possible. But as much work as possible
+  should be moved from callers into configuration.
 
 Usage
 ------------
 
 ### Configuration
 
-To get started, you'll need to configure at least one profile to use to post
-to slack. Get a [Webhook URL](https://slack.com/help/articles/115005265063-Incoming-webhooks-for-Slack)
-from Slack and configure it like this:
+To get started, you'll need to create a Slack App with some appropriate
+permissions.  It used to be possible to use the Webhook API, but that's long
+since been deprecated, and apps are pretty [straightforward to
+create](https://api.slack.com/tutorials/tracks/getting-a-token).
+
+Generally, make sure your token has permissions for `users:read` and `chat:write`.
 
 ```ruby
 SlackMessage.configure do |config|
-  webhook_url = 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'
+  api_token = 'xoxb-11111111111-2222222222-33333333333333333'
 
-  config.add_profile(name: 'Slack Notifier', url: webhook_url)
+  config.add_profile(api_token: api_token)
 end
 ```
 
-You should probably keep that webhook in a safe place like `ENV`. If using this
-gem with Rails, place this code in somewhere like
-`config/initializers/slack_message.rb`.
+You should keep your token in a safe place like `ENV`. If using this gem with
+Rails, place this code in somewhere like `config/initializers/slack_message.rb`.
 
 #### Additional Profiles
 
-If you want to post to multiple different webhook addresses (say, if you have
-several different bots that post to different channels as different identities),
-you can configure those profiles as well, by giving each of them a name:
+If your app uses slack messages for several different purposes, it's common to
+want to post to different channels as different names / icons / etc. To do that
+more easily and consistently, you can specify multiple profiles:
 
 ```ruby
 SlackMessage.configure do |config|
+  api_token = 'xoxb-11111111111-2222222222-33333333333333333'
+
   # default profile
-  config.add_profile(name: 'Slack Notifier', url: ENV['SLACK_WEBHOOK_URL'])
+  config.add_profile(api_token: api_token, name: 'Slack Notifier')
 
   # additional profiles (see below for usage)
-  config.add_profile(:prod_alert_bot, name: 'Prod Alert Bot', url: ENV['SLACK_PROD_ALERT_WEBHOOK_URL'])
-  config.add_profile(:sidekiq_bot, name: 'Sidekiq Bot', url: ENV['SLACK_SIDEKIQ_WEBHOOK_URL'])
+  config.add_profile(:prod_alert_bot,
+    name: 'Prod Alert Bot'
+    icon: ':mooseandsquirrel:'
+  )
+  config.add_profile(:sidekiq_bot,
+    api_token: ENV.fetch('SIDEKIQ_SLACK_APP_API_TOKEN'),
+    name: 'Sidekiq Bot',
+  )
 end
 ```
 
-If you frequently ping the same channel with the same bot, and don't want to
-continually specify the channel name, you can specify a default channel and
-post using the `post_as` method. It is otherwise identical to `post_to`, but
-allows you to omit the channel argument:
+A number of parameters are available to make it simpler to use a profile without
+specifying repetitive information. Most all have corresponding options when
+composing a message:
+
+| Config          | Default         | Value                                                           |
+|-----------------|-----------------|-----------------------------------------------------------------|
+| api_token       | None            | Your Slack App API Key.                                         |
+| name            | From Slack App  | The bot name for your message.                                  |
+| icon            | From Slack App  | Profile icon for your message. Specify as :emoji: or image URL. |
+| default_channel | None (optional) | Channel / user to post to by default.                           |
+
+
+Setting a `default_channel` specifically will allow you to use `post_as`, which
+is a convenient shortcut for bots that repeatedly post to one channel as a
+consistent identity:
 
 ```ruby
 SlackMessage.configure do |config|
-  config.add_profile(:prod_alert_bot,
-    name: 'Prod Alert Bot',
-    url: ENV['SLACK_PROD_ALERT_WEBHOOK_URL'],
+  config.add_profile(:red_alert_bot,
+    api_token: ENV.fetch('SLACK_API_TOKEN'),
+    name: 'Red Alerts',
+    icon: ':klaxon:',
     default_channel: '#red_alerts'
   )
 end
 
-SlackMessage.post_as(:prod_alert_bot) do
+SlackMessage.post_as(:red_alert_bot) do
   text ":ambulance: weeooo weeooo something went wrong"
 end
 ```
 
-Note that `post_as` does not allow you to choose a channel (because that's just
-the same as using `post_to`), so you really do have to specify `default_channel`.
-
-#### Configuring User Search
-
-Slack's API no longer allows you to send DMs to users by username. You need to
-look up a user's internal ID and send to that ID. Thankfully, there is a lookup
-by email endpoint for this. If you'd like to post messages to users by their
-email address, you'll need a
-[separate API Token](https://api.slack.com/tutorials/tracks/getting-a-token):
-
-```ruby
-SlackMessage.configure do |config|
-  config.api_token = 'xoxb-11111111111-2222222222-33333333333333333'
-end
-```
+There's no reason you can't use the same API key for several profiles. Profiles
+are most useful to create consistent name / icon setups for apps with many bots.
 
 ### Posting Messages
 
@@ -104,14 +128,12 @@ end
 That's it! SlackMessage will automatically serialize for the API like this:
 
 ```json
-[{"type":"section","text":{"type":"mrkdwn","text":"We did it! :thumbsup:"}}]
+[{"type":"section","text":{"type":"mrkdwn","text":"We did it @here! :thumbsup:"}}]
 ```
 
 Details like remembering that Slack made a mystifying decision to force you to
 request "mrkdwn", or requiring your text to be wrapped into a section are handled
-for you.
-
-Building up messages is meant to be as user-friendly as possible:
+for you. Building up messages is meant to be as user-friendly as possible:
 
 ```ruby
 SlackMessage.build do
@@ -147,20 +169,21 @@ automatically:
 ]
 ```
 
-If you've configured an API key for user search (see above in configuration),
-it's just as easy to send messages directly to users:
+It's just as easy to send messages directly to users. SlackMessage will look for
+targets that are email-addressish, and look them up for you automatically:
 
 ```ruby
-SlackMessage.post_to('hello@joemastey.com') do
-  text "We did it! :thumbsup:"
+user_email = 'hello@joemastey.com'
+
+SlackMessage.post_to(user_email) do
+  text "You specifically did it! :thumbsup:"
 end
 ```
 
 SlackMessage is able to build all kinds of rich messages for you, and has been
 a real joy to use for the author at least. To understand a bit more about the
-possibilities of blocks, see Slack's [Block Kit
-Builder](https://app.slack.com/block-kit-builder/) to understand the structure
-better. There are lots of options:
+possibilities of blocks, you should play around with Slack's [Block Kit
+Builder](https://app.slack.com/block-kit-builder/). There are lots of options:
 
 ```ruby
 SlackMessage.post_to('#general') do
@@ -195,38 +218,75 @@ For now you'll need to read a bit of the source code to get the entire API. Sorr
 working on it.
 
 If you've defined multiple profiles in configuration, you can specify which to
-use for your message by specifying their name:
+use for your message by specifying its name:
 
 ```ruby
 SlackMessage.post_to('#general', as: :sidekiq_bot) do
   text ":octagonal_sign: A job has failed permanently and needs to be rescued."
-  link_button "Sidekiq Dashboard", "https://yoursite.com/sidekiq", style: :danger
+  link_button "Sidekiq Dashboard", sidekiq_dashboard_url, style: :danger
 end
 ```
 
-You can also use a custom name when sending a message:
+You can also override profile bot details when sending a message:
 
 ```ruby
 SlackMessage.post_to('#general') do
   bot_name "CoffeeBot"
+  bot_icon ":coffee:"
 
   text ":coffee::clock: Time to take a break!"
 end
 ```
 
-Opinionated Stances
-------------
+### Testing
 
-Slack's API has a lot of options available to you! But this gem takes some
-opinionated stances on how to make use of that API. For instance:
+You can do some basic testing against SlackMessage, at least if you use RSpec!
+You'll need to require and include the testing behavior like this, in your
+spec_helper file:
 
-* Unless you request otherwise, text is always rendered using `mrkdwn`. If you
-  want plaintext, you'll need to ask for it.
-* Generally, same goes for the `emoji` flag on almost every text element.
-* It's possible to ask for a `blank_line` in sections, even though that concept
-  isn't real. In this case, a text line containing only an emspace is rendered.
-* It's easy to configure a bot for consistent name / channel use. My previous
-  use of SlackNotifier led to frequently inconsistent names.
+```ruby
+require 'slack_message/rspec'
+
+RSpec.configure do |config|
+  include SlackMessage::RSpec
+
+  # your other config
+end
+```
+
+This will stop API calls for posting messages, and will allow you access to
+some custom matchers:
+
+```ruby
+expect {
+  SlackMessage.post_to('#general') { text "foo" }
+}.to post_slack_message_to('#general').with_content_matching(/foo/)
+
+expect {
+  SlackMessage.post_as(:schmoebot) { text "foo" }
+}.to post_slack_message_as(:schmoebot)
+
+expect {
+  SlackMessage.post_as(:schmoebot) { text "foo" }
+}.to post_slack_message_as('Schmoe Bot')
+
+expect {
+  SlackMessage.post_as(:schmoebot) { text "foo" }
+}.to post_slack_message_with_icon(':schmoebot:')
+
+expect {
+  SlackMessage.post_as(:schmoebot) { text "foo" }
+}.to post_slack_message_with_icon_matching(/gravatar/)
+ 
+expect {
+  SlackMessage.post_to('#general') { text "foo" }
+}.to post_to_slack
+```
+
+Be forewarned, I'm frankly not that great at more complicated RSpec matchers,
+so I'm guessing there are some bugs. Also, because the content of a message
+gets turned into a complex JSON object, matching against content isn't capable
+of very complicated regexes.
 
 What it Doesn't Do
 ------------
@@ -234,25 +294,25 @@ What it Doesn't Do
 This gem is intended to stay fairly simple. Other gems have lots of config
 options and abilities, which is wonderful, but overall complicates usage. If
 you want to add a feature, open an issue on Github first to see if it's likely
-to be merged.
-
-Since this gem was built out of an existing need that _didn't_ include most of
-the block API, I'd be inclined to merge features that sustainably expand the
-DSL to include more of the block API itself.
+to be merged. This gem was built out of an existing need that _didn't_ include
+most of the block API, but I'd be inclined to merge features that sustainably
+expand the DSL to include more useful features.
 
-Also, some behaviors that are still planned but not yet added:
+Some behaviors that are still planned but not yet added:
 
 * some API documentation amirite?
 * allow custom http_options in configuration
 * more of BlockKit's options
 * any interactive elements at all (I don't understand them yet)
-* more interesting return types for your message
-* richer text formatting (ul is currently a hack)
+* editing / updating messages
+* multiple recipients
+* more interesting return types for your message (probably related to the above)
+* richer text formatting (for instance, `ul` is currently a hack)
 
 Contributing
 ------------
 
-Contributions are very welcome. Fork, fix, submit pulls.
+Contributions are very welcome. Fork, fix, submit pull.
 
 Contribution is expected to conform to the [Contributor Covenant](https://github.com/jmmastey/slack_message/blob/master/CODE_OF_CONDUCT.md).
 

data/lib/slack_message/api.rb

@@ -3,13 +3,11 @@ require 'net/https'
 require 'json'
 
 class SlackMessage::Api
-  def self.user_id_for(email)
-    token = SlackMessage.configuration.api_token
-
+  def self.user_id_for(email, profile)
     uri = URI("https://slack.com/api/users.lookupByEmail?email=#{email}")
     request = Net::HTTP::Get.new(uri).tap do |req|
-      req['Authorization']  = "Bearer #{token}"
-      req['Content-type']   = "application/json"
+      req['Authorization']  = "Bearer #{profile[:api_token]}"
+      req['Content-type']   = "application/json; charset=utf-8"
     end
 
     response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
@@ -38,30 +36,57 @@ class SlackMessage::Api
   end
 
   def self.post(payload, target, profile)
-    profile[:url] = profile[:url]
-
-    uri     = URI.parse(profile[:url])
     params  = {
       channel: target,
-      username: profile[:name],
-      blocks: payload
-    }.to_json
+      username: payload.custom_bot_name || profile[:name],
+      blocks: payload.render,
+      text: payload.notification_text,
+    }
+
+    icon = payload.custom_bot_icon || profile[:icon]
+    if icon =~ /^:\w+:$/
+      params[:icon_emoji] = icon
+    elsif icon =~ /^(https?:\/\/)?[0-9a-z]+\.[-_0-9a-z]+/ # very naive regex, I know. it'll be fine.
+      params[:icon_url] = icon
+    elsif !(icon.nil? || icon == '')
+      raise ArgumentError, "Couldn't figure out icon '#{icon}'. Try :emoji: or a URL."
+    end
 
-    response = Net::HTTP.post_form uri, { payload: params }
+    response = post_message(profile, params)
+    body  = JSON.parse(response.body)
+    error = body.fetch("error", "")
 
     # let's try to be helpful about error messages
-    if response.body == "invalid_token"
-      raise "Couldn't send slack message because the URL for profile '#{profile[:handle]}' is wrong."
-    elsif response.body == "channel_not_found"
+    if ["token_revoked", "token_expired", "invalid_auth", "not_authed"].include?(error)
+      raise "Couldn't send slack message because the API key for profile '#{profile[:handle]}' is wrong."
+    elsif ["no_permission", "ekm_access_denied"].include?(error)
+      raise "Couldn't send slack message because the API key for profile '#{profile[:handle]}' isn't allowed to post messages."
+    elsif error == "channel_not_found"
       raise "Tried to send Slack message to non-existent channel or user '#{target}'"
-    elsif response.body == "missing_text_or_fallback_or_attachments"
+    elsif error == "invalid_arguments"
       raise "Tried to send Slack message with invalid payload."
     elsif response.code == "302"
-      raise "Got 302 response while posting to Slack. Check your webhook URL for '#{profile[:handle]}'."
+      raise "Got 302 response while posting to Slack. Check your API key for profile '#{profile[:handle]}'."
     elsif response.code != "200"
       raise "Got an error back from the Slack API (HTTP #{response.code}):\n#{response.body}"
     end
 
     response
   end
+
+  # mostly test harness
+  def self.post_message(profile, params)
+    uri = URI("https://slack.com/api/chat.postMessage")
+    request = Net::HTTP::Post.new(uri).tap do |req|
+      req['Authorization']  = "Bearer #{profile[:api_token]}"
+      req['Content-type']   = "application/json; charset=utf-8"
+      req.body = params.to_json
+    end
+
+    Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+      http.request(request)
+    end
+  end
+
+  private_class_method :post_message
 end

data/lib/slack_message/configuration.rb

@@ -1,9 +1,7 @@
 module SlackMessage::Configuration
-  @@api_token = nil
   @@profiles = {}
 
   def self.reset
-    @@api_token = nil
     @@profiles  = {}
   end
 
@@ -13,35 +11,29 @@ module SlackMessage::Configuration
 
   ###
 
-  def self.api_token=(token)
-    @@api_token = token
+  def self.clear_profiles! # test harness, mainly
+    @@profiles = {}
   end
 
-  def self.api_token
-    unless @@api_token.is_a? String
-      raise ArgumentError, "Please set an API token to use API features."
-    end
-
-    @@api_token
-  end
-
-  ###
-
-  def self.add_profile(handle = :default, name:, url:, default_channel: nil)
+  def self.add_profile(handle = :default, api_token:, name: nil, icon: nil, default_channel: nil)
     if @@profiles.include?(handle)
       warn "WARNING: Overriding profile '#{handle}' in SlackMessage config"
     end
 
-    @@profiles[handle] = { name: name, url: url, handle: handle, default_channel: default_channel }
+    @@profiles[handle] = {
+      handle: handle,
+      api_token: api_token,
+      name: name,
+      icon: icon,
+      default_channel: default_channel
+    }
   end
 
-  def self.profile(handle, custom_name: nil)
+  def self.profile(handle)
     unless @@profiles.include?(handle)
       raise ArgumentError, "Unknown SlackMessage profile '#{handle}'."
     end
 
-    @@profiles[handle].tap do |profile|
-      profile[:name] = custom_name if !custom_name.nil?
-    end
+    @@profiles[handle]
   end
 end

data/lib/slack_message/dsl.rb

@@ -1,5 +1,6 @@
 class SlackMessage::Dsl
-  attr_reader :body, :default_section, :custom_bot_name
+  attr_reader :body, :default_section, :custom_bot_name, :custom_bot_icon
+  attr_accessor :notification_text
 
   EMSPACE = " " # unicode emspace
 
@@ -9,8 +10,10 @@ class SlackMessage::Dsl
     @caller_self = eval("self", block.binding)
 
     @body = []
-    @default_section = Section.new
+    @default_section = Section.new(self)
     @custom_bot_name = nil
+    @custom_bot_icon = nil
+    @notification_text = nil
   end
 
   # allowable top-level entities within a block
@@ -18,7 +21,7 @@ class SlackMessage::Dsl
   def section(&block)
     finalize_default_section
 
-    section = Section.new.tap do |s|
+    section = Section.new(self).tap do |s|
       s.instance_eval(&block)
     end
 
@@ -52,6 +55,10 @@ class SlackMessage::Dsl
   def context(text)
     finalize_default_section
 
+    if text == "" || text.nil?
+      raise ArgumentError, "tried to create a context block without a value"
+    end
+
     @body.push({ type: "context", elements: [{
       type: "mrkdwn", text: text
     }]})
@@ -78,6 +85,10 @@ class SlackMessage::Dsl
     @custom_bot_name = name
   end
 
+  def bot_icon(icon)
+    @custom_bot_icon = icon
+  end
+
   # end bot name
 
   def render
@@ -98,18 +109,23 @@ class SlackMessage::Dsl
       @body.push(default_section.render)
     end
 
-    @default_section = Section.new
+    @default_section = Section.new(self)
   end
 
   class Section
     attr_reader :body
 
-    def initialize
+    def initialize(parent)
+      @parent = parent
       @body = { type: "section" }
       @list = List.new
     end
 
     def text(msg)
+      if msg == "" || msg.nil?
+        raise ArgumentError, "tried to create text node without a value"
+      end
+
       if @body.include?(:text)
         @body[:text][:text] << "\n#{msg}"
 
@@ -119,14 +135,16 @@ class SlackMessage::Dsl
     end
 
     def ul(elements)
-      raise Arguments, "please pass an array" unless elements.respond_to?(:map)
+      raise ArgumentError, "please pass an array" unless elements.respond_to?(:map)
+
       text(
         elements.map { |text| "#{EMSPACE}• #{text}" }.join("\n")
       )
     end
 
     def ol(elements)
-      raise Arguments, "please pass an array" unless elements.respond_to?(:map)
+      raise ArgumentError, "please pass an array" unless elements.respond_to?(:map)
+
       text(
         elements.map.with_index(1) { |text, idx| "#{EMSPACE}#{idx}. #{text}" }.join("\n")
       )
@@ -186,6 +204,10 @@ class SlackMessage::Dsl
     end
 
     def list_item(title, value)
+      if value == "" || value.nil?
+        raise ArgumentError, "can't create a list item for '#{title}' without a value"
+      end
+
       @list.add(title, value)
     end
 
@@ -199,6 +221,11 @@ class SlackMessage::Dsl
 
     def render
       body[:fields] = @list.render if @list.any?
+
+      if body[:text] && body[:text][:text] && !@parent.notification_text
+        @parent.notification_text = body[:text][:text]
+      end
+
       body
     end
   end

data/lib/slack_message/rspec.rb

@@ -0,0 +1,241 @@
+require 'rspec/expectations'
+require 'rspec/mocks'
+
+# Honestly, this code is what happens when you do not understand the RSpec
+# custom expectation API really at all, but you really want to create your
+# matcher. This code is soo baaad.
+#
+# We override API calls by entirely replacing the low-level API method. Then we
+# use our overridden version to capture and record calls. When someone creates
+# a new expectation, an object is created, so we allow that object to register
+# itself to receive notification when a slack message _would have_ been posted.
+#
+# Then once the expectation is fulfilled, that class unregisters itself so that
+# it can be cleaned up properly.
+#
+
+module SlackMessage::RSpec
+  extend RSpec::Matchers::DSL
+
+  @@listeners = []
+
+  def self.register_expectation_listener(expectation_instance)
+    @@listeners << expectation_instance
+  end
+
+  def self.unregister_expectation_listener(expectation_instance)
+    @@listeners.delete(expectation_instance)
+  end
+
+  FauxResponse = Struct.new(:code, :body)
+
+  def self.included(_)
+    SlackMessage::Api.singleton_class.undef_method(:post_message)
+    SlackMessage::Api.define_singleton_method(:post_message) do |profile, params|
+      @@listeners.each do |listener|
+        listener.record_call(params.merge(profile: profile))
+      end
+
+      response = {"ok"=>true,
+       "channel"=>"D12345678",
+       "ts"=>"1635863996.002300",
+       "message"=>
+        {"type"=>"message", "subtype"=>"bot_message",
+        "text"=>"foo",
+        "ts"=>"1635863996.002300",
+        "username"=>"SlackMessage",
+        "icons"=>{"emoji"=>":successkid:"},
+        "bot_id"=>"B1234567890",
+        "blocks"=>
+        [{"type"=>"section",
+          "block_id"=>"hAh7",
+          "text"=>{"type"=>"mrkdwn", "text"=>"foo", "verbatim"=>false}}]}}
+
+      return FauxResponse.new('200', response.to_json)
+    end
+  end
+
+  # w/ channel
+  matcher :post_slack_message_to do |expected|
+    match do |actual|
+      @instance ||= PostTo.new
+      @instance.with_channel(expected)
+
+      actual.call
+      @instance.enforce_expectations
+    end
+
+    chain :with_content_matching do |content|
+      @instance ||= PostTo.new
+      @instance.with_content_matching(content)
+    end
+
+    failure_message { @instance.failure_message }
+    failure_message_when_negated { @instance.failure_message_when_negated }
+
+    supports_block_expectations
+  end
+
+  # no channel
+  matcher :post_to_slack do |expected|
+    match do |actual|
+      @instance ||= PostTo.new
+
+      actual.call
+      @instance.enforce_expectations
+    end
+
+    chain :with_content_matching do |content|
+      @instance ||= PostTo.new
+      @instance.with_content_matching(content)
+    end
+
+    failure_message { @instance.failure_message }
+    failure_message_when_negated { @instance.failure_message_when_negated }
+
+    supports_block_expectations
+  end
+
+  # name / profile matcher
+  matcher :post_slack_message_as do |expected|
+     match do |actual|
+      @instance ||= PostTo.new
+      @instance.with_profile(expected)
+
+      actual.call
+      @instance.enforce_expectations
+    end
+
+    chain :with_content_matching do |content|
+      @instance ||= PostTo.new
+      @instance.with_content_matching(content)
+    end
+
+    failure_message { @instance.failure_message }
+    failure_message_when_negated { @instance.failure_message_when_negated }
+
+    supports_block_expectations
+  end
+
+  # icon matcher
+  matcher :post_slack_message_with_icon do |expected|
+     match do |actual|
+      @instance ||= PostTo.new
+      @instance.with_icon(expected)
+
+      actual.call
+      @instance.enforce_expectations
+    end
+
+    chain :with_content_matching do |content|
+      @instance ||= PostTo.new
+      @instance.with_content_matching(content)
+    end
+
+    failure_message { @instance.failure_message }
+    failure_message_when_negated { @instance.failure_message_when_negated }
+
+    supports_block_expectations
+  end
+
+  matcher :post_slack_message_with_icon_matching do |expected|
+     match do |actual|
+      @instance ||= PostTo.new
+      @instance.with_icon_matching(expected)
+
+      actual.call
+      @instance.enforce_expectations
+    end
+
+    chain :with_content_matching do |content|
+      @instance ||= PostTo.new
+      @instance.with_content_matching(content)
+    end
+
+    failure_message { @instance.failure_message }
+    failure_message_when_negated { @instance.failure_message_when_negated }
+
+    supports_block_expectations
+  end
+
+  class PostTo
+    def initialize
+      @captured_calls = []
+      @content = nil
+      @channel = nil
+      @profile = nil
+      @icon = nil
+      @icon_matching = nil
+
+      SlackMessage::RSpec.register_expectation_listener(self)
+    end
+
+    def record_call(deets)
+      @captured_calls.push(deets)
+    end
+
+    def with_channel(channel)
+      @channel = channel
+    end
+
+    def with_icon(icon)
+      @icon = icon
+    end
+
+    def with_icon_matching(icon)
+      raise ArgumentError unless icon.is_a? Regexp
+      @icon_matching = icon
+    end
+
+    def with_content_matching(content)
+      raise ArgumentError unless content.is_a? Regexp
+      @content = content
+    end
+
+    def with_profile(profile)
+      @profile = profile
+    end
+
+    def enforce_expectations
+      SlackMessage::RSpec.unregister_expectation_listener(self)
+
+      @captured_calls
+        .filter { |call| !@channel || call[:channel] == @channel }
+        .filter { |call| !@profile || [call[:profile][:handle], call[:username]].include?(@profile) }
+        .filter { |call| !@content || call.fetch(:blocks).to_s =~ @content }
+        .filter { |call| !@icon || call.fetch(:icon_emoji, call.fetch(:icon_url, '')) == @icon }
+        .filter { |call| !@icon_matching || call.fetch(:icon_emoji, call.fetch(:icon_url, '')) =~ @icon_matching }
+        .any?
+    end
+
+    def failure_message
+      "expected block to #{failure_expression}"
+    end
+
+    def failure_message_when_negated
+      "expected block not to #{failure_expression}"
+    end
+
+    def failure_expression
+      concat = []
+
+      if @channel
+        concat << "post a slack message to '#{@channel}'"
+      elsif @profile
+        concat << "post a slack message as '#{@profile}'"
+      elsif @icon
+        concat << "post a slack message with icon '#{@icon}'"
+      elsif @icon_matching
+        concat << "post a slack message with icon matching '#{@icon_matching.inspect}'"
+      else
+        concat << "post a slack message"
+      end
+
+      if @content
+        concat << "with content matching #{@content.inspect}"
+      end
+
+      concat.join " "
+    end
+  end
+end

data/lib/slack_message.rb

@@ -11,19 +11,15 @@ module SlackMessage
     configuration.configure(&block)
   end
 
-  def self.user_id_for(email) # spooky undocumented public method 👻
-    Api::user_id_for(email)
-  end
-
   def self.post_to(target, as: :default, &block)
     payload = Dsl.new(block).tap do |instance|
       instance.instance_eval(&block)
     end
 
-    profile = Configuration.profile(as, custom_name: payload.custom_bot_name)
-    target  = user_id_for(target) if target =~ /^\S{1,}@\S{2,}\.\S{2,}$/
+    profile = Configuration.profile(as)
+    target  = Api::user_id_for(target, profile) if target =~ /^\S{1,}@\S{2,}\.\S{2,}$/
 
-    Api.post(payload.render, target, profile)
+    Api.post(payload, target, profile)
   end
 
   def self.post_as(profile_name, &block)
@@ -31,15 +27,15 @@ module SlackMessage
       instance.instance_eval(&block)
     end
 
-    profile = Configuration.profile(profile_name, custom_name: payload.custom_bot_name)
+    profile = Configuration.profile(profile_name)
     if profile[:default_channel].nil?
       raise ArgumentError, "Sorry, you need to specify a default_channel for profile #{profile_name} to use post_as"
     end
 
     target  = profile[:default_channel]
-    target  = user_id_for(target) if target =~ /^\S{1,}@\S{2,}\.\S{2,}$/
+    target  = Api::user_id_for(target, profile) if target =~ /^\S{1,}@\S{2,}\.\S{2,}$/
 
-    Api.post(payload.render, target, profile)
+    Api.post(payload, target, profile)
   end
 
   def self.build(&block)

data/slack_message.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name        = 'slack_message'
-  gem.version     = "1.7.1"
+  gem.version     = "2.1.0"
   gem.summary     = "A nice DSL for composing rich messages in Slack"
   gem.authors     = ["Joe Mastey"]
   gem.email       = 'hello@joemastey.com'

data/spec/slack_message_spec.rb

@@ -1,18 +1,24 @@
 require 'spec_helper'
 
 RSpec.describe SlackMessage do
-  it "includes a bunch of stuff" do
-    expect(SlackMessage).to respond_to(:post_to)
-  end
-
   describe "API convenience" do
+    before do
+      SlackMessage.configure do |config|
+        config.add_profile(name: 'default profile', api_token: 'abc123')
+      end
+    end
+
+    after do
+      SlackMessage.configuration.reset
+    end
+
     it "can grab user IDs" do
-      SlackMessage.configure { |c| c.api_token = "asdf" }
+      profile = SlackMessage::Configuration.profile(:default)
       allow(Net::HTTP).to receive(:start).and_return(
         double(code: "200", body: '{ "user": { "id": "ABC123" }}')
       )
 
-      result = SlackMessage.user_id_for("hello@joemastey.com")
+      result = SlackMessage::Api.user_id_for("hello@joemastey.com", profile)
       expect(result).to eq("ABC123")
     end
   end
@@ -40,36 +46,99 @@ RSpec.describe SlackMessage do
       SlackMessage.configuration.reset
     end
 
-    it "allows you to set an API key" do
+    it "lets you add and fetch profiles" do
       SlackMessage.configure do |config|
-        config.api_token = "abc123"
+        config.add_profile(name: 'default profile', api_token: 'abc123')
+        config.add_profile(:nonstandard, name: 'another profile', api_token: 'abc123')
       end
 
-      expect(SlackMessage.configuration.api_token).to eq("abc123")
+      expect(SlackMessage.configuration.profile(:default)[:name]).to eq('default profile')
+      expect(SlackMessage.configuration.profile(:nonstandard)[:name]).to eq('another profile')
+
+      expect {
+        SlackMessage.configuration.profile(:missing)
+      }.to raise_error(ArgumentError)
     end
+  end
 
-    it "raises errors for missing configuration" do
+  describe "custom expectations" do
+    before do
       SlackMessage.configure do |config|
-        #config.api_token = "abc123"
+        config.clear_profiles!
+        config.add_profile(name: 'default profile', api_token: 'abc123')
       end
+    end
 
+    it "can assert expectations against posts" do
       expect {
-        SlackMessage.configuration.api_token
-      }.to raise_error(ArgumentError)
+        SlackMessage.post_to('#lieutenant') { text "foo" }
+      }.not_to post_slack_message_to('#general')
+
+      expect {
+        SlackMessage.post_to('#general') { text "foo" }
+      }.to post_slack_message_to('#general').with_content_matching(/foo/)
     end
 
-    it "lets you add and fetch profiles" do
+    it "resets state properly" do
+      expect {
+        SlackMessage.post_to('#general') { text "foo" }
+      }.to post_slack_message_to('#general')
+
+      expect { }.not_to post_slack_message_to('#general')
+    end
+
+    it "lets you assert by profile name" do
       SlackMessage.configure do |config|
-        config.add_profile(name: 'default profile', url: 'http://hooks.slack.com/1234/')
-        config.add_profile(:nonstandard, name: 'another profile', url: 'http://hooks.slack.com/1234/')
+        config.clear_profiles!
+        config.add_profile(:schmoebot, name: 'Schmoe', api_token: 'abc123', icon: ':schmoebot:', default_channel: '#schmoes')
       end
 
-      expect(SlackMessage.configuration.profile(:default)[:name]).to eq('default profile')
-      expect(SlackMessage.configuration.profile(:nonstandard)[:name]).to eq('another profile')
+      expect {
+        SlackMessage.post_as(:schmoebot) { text "foo" }
+      }.to post_slack_message_to('#schmoes')
 
       expect {
-        SlackMessage.configuration.profile(:missing)
-      }.to raise_error(ArgumentError)
+        SlackMessage.post_as(:schmoebot) { text "foo" }
+      }.to post_slack_message_as(:schmoebot)
+
+      expect {
+        SlackMessage.post_as(:schmoebot) { text "foo" }
+      }.to post_slack_message_as('Schmoe').with_content_matching(/foo/)
+    end
+
+    it "lets you assert by profile image" do
+      SlackMessage.configure do |config|
+        config.clear_profiles!
+        config.add_profile(:schmoebot, name: 'Schmoe', api_token: 'abc123', icon: ':schmoebot:', default_channel: '#schmoes')
+      end
+
+      expect {
+        SlackMessage.post_as(:schmoebot) { text "foo" }
+      }.to post_slack_message_with_icon(':schmoebot:')
+
+      expect {
+        SlackMessage.post_as(:schmoebot) do
+          bot_icon ':schmalternate:'
+          text "foo"
+        end
+      }.to post_slack_message_with_icon(':schmalternate:')
+
+      expect {
+        SlackMessage.post_as(:schmoebot) do
+          bot_icon 'https://thispersondoesnotexist.com/image'
+          text "foo"
+        end
+      }.to post_slack_message_with_icon_matching(/thisperson/)
+    end
+
+    it "lets you assert notification text" do
+      # TODO :|
+    end
+
+    it "can assert more generally too tbh" do
+      expect {
+        SlackMessage.post_to('#general') { text "foo" }
+      }.to post_to_slack.with_content_matching(/foo/)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 require_relative '../lib/slack_message'
+require_relative '../lib/slack_message/rspec'
 
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
@@ -49,4 +50,6 @@ RSpec.configure do |config|
   # test failures related to randomization by passing the same `--seed` value
   # as the one that triggered the failure.
   Kernel.srand config.seed
+
+  include SlackMessage::RSpec
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slack_message
 version: !ruby/object:Gem::Version
-  version: 1.7.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Joe Mastey
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-06 00:00:00.000000000 Z
+date: 2021-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -70,6 +70,7 @@ files:
 - lib/slack_message/api.rb
 - lib/slack_message/configuration.rb
 - lib/slack_message/dsl.rb
+- lib/slack_message/rspec.rb
 - slack_message.gemspec
 - spec/slack_message_spec.rb
 - spec/spec_helper.rb