slack_message 2.3.0 → 3.0.1

data/lib/slack_message/api.rb

@@ -10,6 +10,10 @@ module SlackMessage::Api
       raise ArgumentError, "Tried to find profile by invalid email address '#{email}'"
     end
 
+    if SlackMessage::Configuration.debugging?
+      warn [email, profile].inspect
+    end
+
     response = look_up_user_by_email(email, profile)
 
     if response.code != "200"
@@ -24,18 +28,11 @@ module SlackMessage::Api
       raise SlackMessage::ApiError, "Unable to parse JSON response from Slack API\n#{response.body}"
     end
 
-    if payload.include?("error") && payload["error"] == "invalid_auth"
-      raise SlackMessage::ApiError, "Received an error because your authentication token isn't properly configured."
-    elsif payload.include?("error") && payload["error"] == "users_not_found"
-      raise SlackMessage::ApiError, "Couldn't find a user with the email '#{email}'."
-    elsif payload.include?("error")
-      raise SlackMessage::ApiError, "Received error response from Slack during user lookup:\n#{response.body}"
-    end
-
+    SlackMessage::ErrorHandling.raise_user_lookup_errors(response, target, profile)
     payload["user"]["id"]
   end
 
-  def post(payload, target, profile)
+  def post(payload, target, profile, time)
     params  = {
       channel: target,
       username: payload.custom_bot_name || profile[:name],
@@ -56,25 +53,68 @@ module SlackMessage::Api
       raise ArgumentError, "Couldn't figure out icon '#{icon}'. Try :emoji: or a URL."
     end
 
+    if !time.nil?
+      params[:post_at] = time.to_i
+
+      if payload.custom_bot_name || payload.custom_bot_icon
+        raise ArgumentError, "Sorry, setting an image / emoji icon for scheduled messages isn't supported."
+      end
+    end
+
+    if SlackMessage::Configuration.debugging?
+      warn params.inspect
+    end
+
     response = post_message(profile, params)
+
+    SlackMessage::ErrorHandling.raise_post_response_errors(response, params, profile)
+    SlackMessage::Response.new(response, profile[:handle])
+  end
+
+  def update(payload, message, profile)
+    params  = {
+      channel: message.channel,
+      ts: message.timestamp,
+      blocks: payload.render,
+      text: payload.custom_notification
+    }
+
+    if params[:blocks].length == 0
+      raise ArgumentError, "Tried to send an entirely empty message."
+    end
+
+    if SlackMessage::Configuration.debugging?
+      warn params.inspect
+    end
+
+    response = update_message(profile, params)
     body  = JSON.parse(response.body)
     error = body.fetch("error", "")
 
-    # let's try to be helpful about error messages
-    if ["token_revoked", "token_expired", "invalid_auth", "not_authed"].include?(error)
-      raise SlackMessage::ApiError, "Couldn't send slack message because the API key for profile '#{profile[:handle]}' is wrong."
-    elsif ["no_permission", "ekm_access_denied"].include?(error)
-      raise SlackMessage::ApiError, "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 SlackMessage::ApiError, "Tried to send Slack message to non-existent channel or user '#{target}'"
-    elsif error == "invalid_arguments"
-      raise SlackMessage::ApiError, "Tried to send Slack message with invalid payload."
-    elsif response.code == "302"
-      raise SlackMessage::ApiError, "Got 302 response while posting to Slack. Check your API key for profile '#{profile[:handle]}'."
-    elsif response.code != "200"
-      raise SlackMessage::ApiError, "Got an error back from the Slack API (HTTP #{response.code}):\n#{response.body}"
+    SlackMessage::ErrorHandling.raise_post_response_errors(response, message, profile)
+    SlackMessage::Response.new(response, profile[:handle])
+  end
+
+  def delete(message, profile)
+    params = if message.scheduled?
+      {
+        channel: message.channel,
+        scheduled_message_id: message.scheduled_message_id,
+      }
+    else
+      {
+        channel: message.channel,
+        ts: message.timestamp,
+      }
     end
 
+    if SlackMessage::Configuration.debugging?
+      warn params.inspect
+    end
+
+    response = delete_message(profile, params)
+
+    SlackMessage::ErrorHandling.raise_delete_response_errors(response, message, profile)
     response
   end
 
@@ -84,6 +124,7 @@ module SlackMessage::Api
 
   def look_up_user_by_email(email, profile)
     uri = URI("https://slack.com/api/users.lookupByEmail?email=#{email}")
+
     request = Net::HTTP::Get.new(uri).tap do |req|
       req['Authorization']  = "Bearer #{profile[:api_token]}"
       req['Content-type']   = "application/json; charset=utf-8"
@@ -95,7 +136,44 @@ module SlackMessage::Api
   end
 
   def post_message(profile, params)
-    uri = URI("https://slack.com/api/chat.postMessage")
+    uri = if params.has_key?(:post_at)
+      URI("https://slack.com/api/chat.scheduleMessage")
+    else
+      URI("https://slack.com/api/chat.postMessage")
+    end
+
+    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
+
+  def update_message(profile, params)
+    uri = URI("https://slack.com/api/chat.update")
+
+    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
+
+  def delete_message(profile, params)
+    uri = if params.has_key?(:scheduled_message_id)
+      URI("https://slack.com/api/chat.deleteScheduledMessage")
+    else
+      URI("https://slack.com/api/chat.delete")
+    end
+
     request = Net::HTTP::Post.new(uri).tap do |req|
       req['Authorization']  = "Bearer #{profile[:api_token]}"
       req['Content-type']   = "application/json; charset=utf-8"

data/lib/slack_message/configuration.rb

@@ -1,8 +1,10 @@
 module SlackMessage::Configuration
   @@profiles = {}
+  @@debug = false
 
   def self.reset
-    @@profiles  = {}
+    @@profiles = {}
+    @@debug = false
   end
 
   def self.configure
@@ -36,4 +38,12 @@ module SlackMessage::Configuration
 
     @@profiles[handle]
   end
+
+  def self.debug
+    @@debug = true
+  end
+
+  def self.debugging?
+    @@debug
+  end
 end

data/lib/slack_message/dsl.rb

@@ -111,12 +111,14 @@ class SlackMessage::Dsl
   # replace emails w/ real user IDs
   def enrich_text(text_body)
     text_body.scan(SlackMessage::EMAIL_TAG_PATTERN).each do |email_tag|
-      raw_email = email_tag.gsub(/[><]/, '')
-      user_id   = SlackMessage::Api::user_id_for(raw_email, profile)
+      begin
+        raw_email = email_tag.gsub(/[><]/, '')
+        user_id   = SlackMessage::Api::user_id_for(raw_email, profile)
 
-      text_body.gsub!(email_tag, "<@#{user_id}>") if user_id
-    rescue SlackMessage::ApiError => e
-      # swallow errors for not-found users
+        text_body.gsub!(email_tag, "<@#{user_id}>") if user_id
+      rescue SlackMessage::ApiError => e
+        # swallow errors for not-found users
+      end
     end
 
     text_body

data/lib/slack_message/error_handling.rb

@@ -0,0 +1,124 @@
+class SlackMessage::ErrorHandling
+  PERMISSIONS_ERRORS = ["token_revoked", "token_expired", "invalid_auth", "not_authed",
+                        "team_access_not_granted", "no_permission", "missing_scope",
+                        "not_allowed_token_type", "ekm_access_denied"]
+
+  def self.raise_post_response_errors(response, params, profile)
+    body  = JSON.parse(response.body)
+    error = body.fetch("error", "")
+
+    if ["invalid_blocks", "invalid_blocks_format"].include?(error)
+      raise SlackMessage::ApiError, "Couldn't send Slack message because the serialized message had an invalid format"
+    elsif error == "channel_not_found"
+      raise SlackMessage::ApiError, "Tried to send Slack message to non-existent channel or user '#{params[:channel]}'"
+
+    # scheduling messages
+    elsif error == "invalid_time"
+      raise SlackMessage::ApiError, "Couldn't schedule Slack message because you requested an invalid time '#{params[:post_at]}'"
+    elsif error == "time_in_past"
+      raise SlackMessage::ApiError, "Couldn't schedule Slack message because you requested a time in the past (or too close to now) '#{params[:post_at]}'"
+    elsif error == "time_too_far"
+      raise SlackMessage::ApiError, "Couldn't schedule Slack message because you requested a time more than 120 days in the future '#{params[:post_at]}'"
+
+
+    elsif PERMISSIONS_ERRORS.include?(error)
+      raise SlackMessage::ApiError, "Couldn't send Slack message because the API key for profile '#{profile[:handle]}' is wrong, or the app has insufficient permissions (#{error})"
+    elsif error == "message_too_long"
+      raise SlackMessage::ApiError, "Tried to send Slack message, but the message was too long"
+    elsif error == "invalid_arguments"
+      raise SlackMessage::ApiError, "Tried to send Slack message with invalid payload"
+    elsif ["rate_limited", "ratelimited"].include?(error)
+      raise SlackMessage::ApiError, "Couldn't send Slack message because you've reached your rate limit"
+    elsif response.code == "302"
+      raise SlackMessage::ApiError, "Got 302 response while posting to Slack. Check your API key for profile '#{profile[:handle]}'"
+    elsif response.code != "200"
+      raise SlackMessage::ApiError, "Got an error back from the Slack API (HTTP #{response.code}):\n#{response.body}"
+    elsif !(error.nil? || error == "")
+      raise SlackMessage::ApiError, "Received error response from Slack during message posting:\n#{response.body}"
+    end
+  end
+
+  def self.raise_update_response_errors(response, message, profile)
+    body  = JSON.parse(response.body)
+    error = body.fetch("error", "")
+
+    if ["invalid_blocks", "invalid_blocks_format"].include?(error)
+      raise SlackMessage::ApiError, "Couldn't update Slack message because the serialized message had an invalid format"
+    elsif error == "channel_not_found"
+      raise SlackMessage::ApiError, "Tried to update Slack message to non-existent channel or user '#{message.channel}'"
+
+    elsif error == "message_not_found"
+      raise SlackMessage::ApiError, "Tried to update Slack message, but the message wasn't found (timestamp '#{message.timestamp}' for channel '#{message.channel}'"
+    elsif error == "cant_update_message"
+      raise SlackMessage::ApiError, "Couldn't update message because the message type isn't able to be updated, or #{profile[:handle]} isn't allowed to update it"
+    elsif error == "edit_window_closed"
+      raise SlackMessage::ApiError, "Couldn't update message because it's too old"
+
+
+    elsif PERMISSIONS_ERRORS.include?(error)
+      raise SlackMessage::ApiError, "Couldn't update Slack message because the API key for profile '#{profile[:handle]}' is wrong, or the app has insufficient permissions (#{error})"
+    elsif error == "message_too_long"
+      raise SlackMessage::ApiError, "Tried to update Slack message, but the message was too long"
+    elsif error == "invalid_arguments"
+      raise SlackMessage::ApiError, "Tried to update Slack message with invalid payload"
+    elsif ["rate_limited", "ratelimited"].include?(error)
+      raise SlackMessage::ApiError, "Couldn't update Slack message because you've reached your rate limit"
+    elsif response.code == "302"
+      raise SlackMessage::ApiError, "Got 302 response while updating a message. Check your API key for profile '#{profile[:handle]}'"
+    elsif response.code != "200"
+      raise SlackMessage::ApiError, "Got an error back from the Slack API (HTTP #{response.code}):\n#{response.body}"
+    elsif !(error.nil? || error == "")
+      raise SlackMessage::ApiError, "Received error response from Slack during message update:\n#{response.body}"
+    end
+  end
+
+  def self.raise_delete_response_errors(response, message, profile)
+    body  = JSON.parse(response.body)
+    error = body.fetch("error", "")
+
+    if error == "channel_not_found"
+      raise SlackMessage::ApiError, "Tried to delete Slack message in non-existent channel '#{message.channel}'"
+
+    elsif error == "invalid_scheduled_message_id"
+      raise SlackMessage::ApiError, "Can't delete message because the ID was invalid, or the message has already posted (#{message.scheduled_message_id})"
+    elsif error == "message_not_found"
+      raise SlackMessage::ApiError, "Tried to delete Slack message, but the message wasn't found (timestamp '#{message.timestamp}' for channel '#{message.channel}')"
+    elsif error == "cant_delete_message"
+      raise SlackMessage::ApiError, "Can't delete message because '#{profile[:handle]}' doesn't have permission to"
+    elsif error == "compliance_exports_prevent_deletion"
+      raise SlackMessage::ApiError, "Can't delete message because team compliance settings prevent it"
+
+
+    elsif PERMISSIONS_ERRORS.include?(error)
+      raise SlackMessage::ApiError, "Couldn't delete Slack message because the API key for profile '#{profile[:handle]}' is wrong, or the app has insufficient permissions (#{error})"
+    elsif ["rate_limited", "ratelimited"].include?(error)
+      raise SlackMessage::ApiError, "Couldn't delete Slack message because you've reached your rate limit"
+    elsif response.code == "302"
+      raise SlackMessage::ApiError, "Got 302 response while deleting a message. Check your API key for profile '#{profile[:handle]}'"
+    elsif response.code != "200"
+      raise SlackMessage::ApiError, "Got an error back from the Slack API (HTTP #{response.code}):\n#{response.body}"
+    elsif !(error.nil? || error == "")
+      raise SlackMessage::ApiError, "Received error response from Slack during message delete:\n#{response.body}"
+    end
+  end
+
+  def self.raise_user_lookup_response_errors(payload)
+    error = payload["error"]
+
+    if error == "users_not_found"
+      raise SlackMessage::ApiError, "Couldn't find a user with the email '#{email}'"
+
+
+    elsif PERMISSIONS_ERRORS.include?(error)
+      raise SlackMessage::ApiError, "Couldn't look up users because the API key for profile '#{profile[:handle]}' is wrong, or the app has insufficient permissions (#{error})"
+    elsif error
+      raise SlackMessage::ApiError, "Received error response from Slack during user lookup:\n#{response.body}"
+    elsif response.code == "302"
+      raise SlackMessage::ApiError, "Got 302 response during user lookup. Check your API key for profile '#{profile[:handle]}'"
+    elsif response.code != "200"
+      raise SlackMessage::ApiError, "Got an error back from the Slack API (HTTP #{response.code}):\n#{response.body}"
+    elsif !(error.nil? || error == "")
+      raise SlackMessage::ApiError, "Received error response from Slack during user lookup:\n#{response.body}"
+    end
+  end
+end

data/lib/slack_message/response.rb

@@ -0,0 +1,42 @@
+class SlackMessage::Response
+  attr_reader :channel, :timestamp, :profile_handle, :scheduled_message_id, :original_response
+
+  def initialize(api_response, profile_handle)
+    @original_response = JSON.parse(api_response.body)
+    @ok = @original_response["ok"]
+    @channel = @original_response["channel"]
+
+    @timestamp = @original_response["ts"]
+    @scheduled_message_id = @original_response["scheduled_message_id"]
+
+    @profile_handle = profile_handle
+  end
+
+  def marshal_dump
+    [ @profile_handle, @channel, @timestamp, @original_response, @ok, @original_response ]
+  end
+
+  def marshal_load(data)
+    @profile_handle, @channel, @timestamp, @original_response, @ok, @original_response = data
+  end
+
+  def sent_to_user?
+    channel =~ /^D.*/ # users are D for DM, channels start w/ C
+  end
+
+  def scheduled?
+    !!scheduled_message_id
+  end
+
+  def inspect
+    identifier = if scheduled?
+      "scheduled_message_id=#{scheduled_message_id}"
+    else
+      "timestamp=#{timestamp}"
+    end
+
+    ok_msg = @ok ? "ok" : "error"
+
+    "<SlackMessage::Response #{ok_msg} profile_handle=:#{profile_handle} channel=#{channel} #{identifier}>"
+  end
+end

data/lib/slack_message/rspec.rb

@@ -14,10 +14,15 @@ require 'rspec/mocks'
 # it can be cleaned up properly.
 #
 
+# TODO: test helpers for scheduled messages, editing and deleting, and
+# notification text. And realistically, overhaul all this.
+
 module SlackMessage::RSpec
   extend RSpec::Matchers::DSL
 
   @@listeners = []
+  @@custom_response = {}
+  @@response_code = '200'
 
   def self.register_expectation_listener(expectation_instance)
     @@listeners << expectation_instance
@@ -27,6 +32,11 @@ module SlackMessage::RSpec
     @@listeners.delete(expectation_instance)
   end
 
+  def self.reset_custom_responses
+    @@custom_response = {}
+    @@response_code = '200'
+  end
+
   FauxResponse = Struct.new(:code, :body)
 
   def self.included(_)
@@ -36,22 +46,24 @@ module SlackMessage::RSpec
         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)
+      response = {
+       "ok" => true,
+       "channel" => "C12345678",
+       "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}}
+                     ]
+       }
+      }.merge(@@custom_response).to_json
+
+      return FauxResponse.new(@@response_code, response)
     end
 
     SlackMessage::Api.undef_method(:look_up_user_by_email)
@@ -61,6 +73,18 @@ module SlackMessage::RSpec
     end
   end
 
+  def self.respond_with(response = {}, code: '200')
+    raise ArgumentError, "custom response must be a hash" unless response.is_a? Hash
+
+    @@custom_response = response
+    @@response_code = code
+  end
+
+  def self.reset_mock_response
+    @@custom_response = {}
+    @@response_code = '200'
+  end
+
   # w/ channel
   matcher :post_slack_message_to do |expected|
     match do |actual|
@@ -206,11 +230,11 @@ module SlackMessage::RSpec
       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 }
+        .select { |call| !@channel || call[:channel] == @channel }
+        .select { |call| !@profile || [call[:profile][:handle], call[:username]].include?(@profile) }
+        .select { |call| !@content || call.fetch(:blocks).to_s =~ @content }
+        .select { |call| !@icon || call.fetch(:icon_emoji, call.fetch(:icon_url, '')) == @icon }
+        .select { |call| !@icon_matching || call.fetch(:icon_emoji, call.fetch(:icon_url, '')) =~ @icon_matching }
         .any?
     end
 

data/lib/slack_message.rb

@@ -1,5 +1,7 @@
 module SlackMessage
+  require 'slack_message/response'
   require 'slack_message/dsl'
+  require 'slack_message/error_handling'
   require 'slack_message/api'
   require 'slack_message/configuration'
 
@@ -21,7 +23,7 @@ module SlackMessage
     Api.user_id_for(email, profile)
   end
 
-  def self.post_to(target, as: :default, &block)
+  def self.post_to(target, as: :default, at: nil, &block)
     profile = Configuration.profile(as)
 
     payload = Dsl.new(block, profile).tap do |instance|
@@ -30,23 +32,53 @@ module SlackMessage
 
     target  = Api::user_id_for(target, profile) if target =~ EMAIL_PATTERN
 
-    Api.post(payload, target, profile)
+    Api.post(payload, target, profile, at)
   end
 
-  def self.post_as(profile_name, &block)
+  def self.post_as(profile_name, at: nil, &block)
     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]
     payload = Dsl.new(block, profile).tap do |instance|
       instance.instance_eval(&block)
     end
 
-    target  = profile[:default_channel]
     target  = Api::user_id_for(target, profile) if target =~ EMAIL_PATTERN
 
-    Api.post(payload, target, profile)
+    Api.post(payload, target, profile, at)
+  end
+
+  def self.update(message, &block)
+    unless message.is_a?(SlackMessage::Response)
+      raise ArgumentError, "You must pass in a SlackMessage::Response to update a message"
+    end
+
+    if message.scheduled?
+      raise ArgumentError, "Sorry, scheduled messages cannot be updated. You will need to delete the message and schedule a new one."
+    end
+
+    profile = Configuration.profile(message.profile_handle)
+    payload = Dsl.new(block, profile).tap do |instance|
+      instance.instance_eval(&block)
+    end
+
+    Api.update(payload, message, profile)
+  end
+
+  def self.delete(message)
+    unless message.is_a?(SlackMessage::Response)
+      raise ArgumentError, "You must pass in a SlackMessage::Response to delete a message"
+    end
+
+    if message.sent_to_user?
+      raise ArgumentError, "It's not possible to delete messages sent directly to users."
+    end
+
+    profile = Configuration.profile(message.profile_handle)
+    Api.delete(message, profile)
   end
 
   def self.build(profile_name = :default, &block)

data/slack_message.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name        = 'slack_message'
-  gem.version     = "2.3.0"
+  gem.version     = "3.0.1"
   gem.summary     = "A nice DSL for composing rich messages in Slack"
   gem.authors     = ["Joe Mastey"]
   gem.email       = 'hello@joemastey.com'
@@ -18,7 +18,7 @@ Gem::Specification.new do |gem|
     "source_code_uri" => "http://github.com/jmmastey/slack_message",
   }
 
-  gem.required_ruby_version = '>= 2.6.0'
+  gem.required_ruby_version = '>= 2.5.0'
 
   gem.add_development_dependency "rspec", "3.10.0"
   gem.add_development_dependency "pry", "0.14.1"

data/spec/slack_message_spec.rb

@@ -111,10 +111,6 @@ RSpec.describe SlackMessage do
       }.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" }
@@ -123,8 +119,6 @@ RSpec.describe SlackMessage do
   end
 
   describe "API convenience" do
-    let(:profile) { SlackMessage::Configuration.profile(:default) }
-
     before do
       SlackMessage.configure do |config|
         config.clear_profiles!
@@ -142,13 +136,73 @@ RSpec.describe SlackMessage do
       expect {
         SlackMessage.post_to('#general') { text("Not Tagged: hello@joemastey.com ") }
       }.to post_to_slack.with_content_matching(/hello@joemastey.com/)
+    end
 
-
-      allow(SlackMessage::Api).to receive(:user_id_for).and_raise(SlackMessage::ApiError)
+    it "is graceful about those failures" do
+      allow(SlackMessage::Api).to receive(:user_id_for).with('nuffin@nuffin.nuffin', any_args).and_raise(SlackMessage::ApiError)
+      allow(SlackMessage::Api).to receive(:user_id_for).with('hello@joemastey.com', any_args).and_return('ABC123')
 
       expect {
         SlackMessage.post_to('#general') { text("Not User: <nuffin@nuffin.nuffin>") }
       }.to post_to_slack.with_content_matching(/\<nuffin@nuffin.nuffin\>/)
+
+      expect {
+        SlackMessage.post_to('#general') { text("Not User: <nuffin@nuffin.nuffin>, User: <hello@joemastey.com>") }
+      }.to post_to_slack.with_content_matching(/ABC123/)
+    end
+  end
+
+  describe "error handling" do
+    before do
+      SlackMessage.configure do |config|
+        config.clear_profiles!
+        config.add_profile(name: 'default profile', api_token: 'abc123')
+        config.add_profile(:schmoebot, name: 'Schmoe', api_token: 'abc123', icon: ':schmoebot:', default_channel: '#schmoes')
+      end
+    end
+
+    after do
+      SlackMessage::RSpec.reset_mock_response
+    end
+
+    it "raises nice error messages when API methods return errors" do
+      SlackMessage::RSpec.respond_with('error' => 'nuffin')
+
+      expect {
+        SlackMessage.post_to('#general') { text 'nuh uh' }
+      }.to raise_error(SlackMessage::ApiError)
+
+      expect {
+        SlackMessage.post_as(:schmoebot) { text 'nuh uh' }
+      }.to raise_error(SlackMessage::ApiError)
+    end
+
+    it "raises for redirects" do
+      SlackMessage::RSpec.respond_with(code: '302')
+
+      expect {
+        SlackMessage.post_to('#general') { text 'nuh uh' }
+      }.to raise_error(SlackMessage::ApiError)
+    end
+
+    it "raises errors w/ updates too" do
+      message = SlackMessage.post_to('#general') { text 'nuh uh' }
+
+      SlackMessage::RSpec.respond_with('error' => 'bad choice')
+
+      expect {
+        SlackMessage.update(message) { text 'nuh uh' }
+      }.to raise_error(SlackMessage::ApiError)
+    end
+
+    it "even raises errors during deletes" do
+      message = SlackMessage.post_to('#general') { text 'nuh uh' }
+
+      SlackMessage::RSpec.respond_with('error' => 'bad choice')
+
+      expect {
+        SlackMessage.delete(message) { text 'nuh uh' }
+      }.to raise_error(SlackMessage::ApiError)
     end
   end
 end