sport_ngin_aws_auditor 0.2.0

data/lib/sport_ngin_aws_auditor/stack.rb

@@ -0,0 +1,63 @@
+require 'highline/import'
+
+module SportNginAwsAuditor
+  class Stack
+    extend OpsWorksWrapper
+    extend EC2Wrapper
+
+    class << self
+      attr_accessor :instances, :stacks
+    end
+
+    attr_accessor :id, :name, :instances
+    def initialize(aws_stack)
+      @id = aws_stack[:stack_id]
+      @name = aws_stack[:name]
+      @instances = get_instances.compact
+    end
+
+    def get_instances
+      return @instances if @instances
+      @instances = self.class.opsworks.describe_instances({stack_id: id})[:instances].map do |instance|
+        next unless instance[:status].to_s == 'online'
+        self.class.all_instances[instance[:ec2_instance_id]].stack_id = id
+        self.class.all_instances[instance[:ec2_instance_id]]
+      end
+    end
+
+    def print_instances
+      EC2Instance.instance_count_hash(self.instances).each do |key,value|
+        say "<%= color('#{key}: #{value}', :white) %>"
+      end
+    end
+
+    def pretty_print
+      puts "----------------------------------"
+      puts "#{@name}"
+      puts "----------------------------------"
+      print_instances
+      puts "\n"
+    end
+    
+    def self.all
+      return @stacks if @stacks 
+      @stacks = opsworks.describe_stacks.data[:stacks].map do |stack|
+        new(stack)
+      end.sort! { |a,b| a.name.downcase <=> b.name.downcase }
+    end
+
+    def self.all_instances
+      @all_instances ||= EC2Instance.instance_hash
+    end
+
+    def self.instances_without_stack 
+      all #simply getting all stacks to make sure instance stack_ids is set
+      all_instances.map do |id, instance|
+        next if instance.stack_id 
+        instance
+      end.compact
+    end
+
+  end
+end
+

data/lib/sport_ngin_aws_auditor/version.rb

@@ -0,0 +1,3 @@
+module SportNginAwsAuditor
+  VERSION = "0.2.0"
+end

data/lib/sport_ngin_aws_auditor.rb

@@ -0,0 +1,14 @@
+require_relative 'sport_ngin_aws_auditor/version'
+require_relative 'sport_ngin_aws_auditor/convenience_wrappers'
+require_relative 'sport_ngin_aws_auditor/ec2_instance'
+require_relative 'sport_ngin_aws_auditor/rds_instance'
+require_relative 'sport_ngin_aws_auditor/cache_instance'
+require_relative 'sport_ngin_aws_auditor/stack'
+require_relative 'sport_ngin_aws_auditor/google_sheet'
+require_relative 'sport_ngin_aws_auditor/output'
+require_relative 'sport_ngin_aws_auditor/config'
+require_relative 'sport_ngin_aws_auditor/notify_slack'
+
+module SportNginAwsAuditor
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+require 'aws-sdk'
+require 'slack-notifier'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+end

data/spec/sport_ngin_aws_auditor/aws_spec.rb

@@ -0,0 +1,48 @@
+require "sport_ngin_aws_auditor"
+
+module SportNginAwsAuditor
+  describe AWSSDK do
+    context 'without mfa' do
+      before :each do
+        mfa_devices = double('mfa_devices', mfa_devices: [])
+        iam_client = double('iam_client', list_mfa_devices: mfa_devices)
+        allow(Aws::IAM::Client).to receive(:new).and_return(iam_client)
+      end
+
+      it "should receive new Aws::SharedCredentials" do
+        expect(Aws::SharedCredentials).to receive(:new).with(profile_name: 'staging')
+        AWSSDK::authenticate('staging')
+      end
+
+      it "should update configs" do
+        coffee_types = {:coffee => "cappuccino", :beans => "arabica"}
+        allow(Aws::SharedCredentials).to receive(:new).and_return(coffee_types)
+        expect(Aws.config).to receive(:update).with({region: 'us-east-1', credentials: coffee_types})
+        AWSSDK::authenticate('staging')
+      end
+    end
+
+    context 'with mfa' do
+      it "should use MFA if it should" do
+        shared_credentials = double('shared_credentials', access_key_id: 'access_key_id',
+                                                          secret_access_key: 'secret_access_key')
+        shared_creds = double('shared_creds', credentials: shared_credentials)
+        cred_double = double('cred_hash', access_key_id: 'access_key_id',
+                                          secret_access_key: 'secret_access_key',
+                                          session_token: 'session_token')
+        new_creds = double('new_creds', credentials: cred_double)
+        sts = double('sts', get_session_token: new_creds)
+        allow(Output).to receive(:ask).and_return(123456)
+        allow(Aws::STS::Client).to receive(:new).and_return(sts)
+        device = double('mfa_device', serial_number: "arn:aws:iam::1234567890:mfa/test.user")
+        mfa_devices = double('mfa_devices', mfa_devices: [device])
+        iam_client = double('iam_client', list_mfa_devices: mfa_devices)
+        allow(Aws::IAM::Client).to receive(:new).and_return(iam_client)
+
+        expect(Aws::Credentials).to receive(:new).and_return(cred_double).at_least(:once)
+        expect(Aws::SharedCredentials).to receive(:new).and_return(shared_creds)
+        AWSSDK::authenticate('staging')
+      end
+    end
+  end
+end

data/spec/sport_ngin_aws_auditor/cache_instance_spec.rb

@@ -0,0 +1,125 @@
+require "sport_ngin_aws_auditor"
+
+module SportNginAwsAuditor
+  describe CacheInstance do
+
+    before :each do
+      identity = double('identity', account: 123456789)
+      client = double('client', get_caller_identity: identity)
+      allow(Aws::STS::Client).to receive(:new).and_return(client)
+    end
+
+    after :each do
+      CacheInstance.instance_variable_set("@instances", nil)
+      CacheInstance.instance_variable_set("@reserved_instances", nil)
+    end
+
+    context "for normal cache_instances" do
+      before :each do
+        cache_instance1 = double('cache_instance', cache_cluster_id: "job-queue-cluster",
+                                                   cache_node_type: "cache.t2.small",
+                                                   engine: "redis",
+                                                   cache_cluster_status: "available",
+                                                   num_cache_nodes: 1,
+                                                   preferred_availability_zone: "us-east-1d",
+                                                   class: "Aws::ElastiCache::Types::CacheCluster")
+        cache_instance2 = double('cache_instance', cache_cluster_id: "job-queue-cluster",
+                                                   cache_node_type: "cache.t2.medium",
+                                                   engine: "mysql",
+                                                   cache_cluster_status: "available",
+                                                   num_cache_nodes: 1,
+                                                   preferred_availability_zone: "us-east-1d",
+                                                   class: "Aws::ElastiCache::Types::CacheCluster")
+        cache_clusters = double('cache_cluster', cache_clusters: [cache_instance1, cache_instance2])
+        tag1 = double('tag', key: "cookie", value: "chocolate chip")
+        tag2 = double('tag', key: "ice cream", value: "oreo")
+        tags = double('tags', tag_list: [tag1, tag2])
+        cache_client = double('cache_client', describe_cache_clusters: cache_clusters, list_tags_for_resource: tags)
+        allow(CacheInstance).to receive(:cache).and_return(cache_client)
+      end
+
+      it "should make a cache_instance for each instance" do
+        instances = CacheInstance::get_instances("tag_name")
+        expect(instances.first).to be_an_instance_of(CacheInstance)
+        expect(instances.last).to be_an_instance_of(CacheInstance)
+      end
+
+      it "should return an array of cache_instances" do
+        instances = CacheInstance::get_instances("tag_name")
+        expect(instances).not_to be_empty
+        expect(instances.length).to eq(2)
+      end
+
+      it "should have proper variables set" do
+        instances = CacheInstance::get_instances("tag_name")
+        instance = instances.first
+        expect(instance.id).to eq("job-queue-cluster")
+        expect(instance.name).to eq("job-queue-cluster")
+        expect(instance.instance_type).to eq("cache.t2.small")
+        expect(instance.engine).to eq("redis")
+      end
+    end
+
+    context "for reserved_cache_instances" do
+      before :each do
+        reserved_cache_instance1 = double('reserved_cache_instance', reserved_cache_node_id: "job-queue-cluster",
+                                                                     cache_node_type: "cache.t2.small",
+                                                                     product_description: "redis",
+                                                                     state: "active",
+                                                                     cache_node_count: 1,
+                                                                     class: "Aws::ElastiCache::Types::ReservedCacheNode")
+        reserved_cache_instance2 = double('reserved_cache_instance', reserved_cache_node_id: "job-queue-cluster",
+                                                                     cache_node_type: "cache.t2.medium",
+                                                                     product_description: "mysql",
+                                                                     state: "active",
+                                                                     cache_node_count: 1,
+                                                                     class: "Aws::ElastiCache::Types::ReservedCacheNode")
+        reserved_cache_nodes = double('cache_cluster', reserved_cache_nodes: [reserved_cache_instance1, reserved_cache_instance2])
+        cache_client = double('cache_client', describe_reserved_cache_nodes: reserved_cache_nodes)
+        allow(CacheInstance).to receive(:cache).and_return(cache_client)
+      end
+
+      it "should make a reserved_cache_instance for each instance" do
+        reserved_instances = CacheInstance::get_reserved_instances
+        expect(reserved_instances.first).to be_an_instance_of(CacheInstance)
+        expect(reserved_instances.last).to be_an_instance_of(CacheInstance)
+      end
+
+      it "should return an array of reserved_cache_instances" do
+        reserved_instances = CacheInstance::get_reserved_instances
+        expect(reserved_instances).not_to be_empty
+        expect(reserved_instances.length).to eq(2)
+      end
+
+      it "should have proper variables set" do
+        reserved_instances = CacheInstance::get_reserved_instances
+        reserved_instance = reserved_instances.first
+        expect(reserved_instance.id).to eq("job-queue-cluster")
+        expect(reserved_instance.name).to eq("job-queue-cluster")
+        expect(reserved_instance.instance_type).to eq("cache.t2.small")
+        expect(reserved_instance.engine).to eq("redis")
+      end
+    end
+
+    context "for returning pretty string formats" do
+      it "should return a string version of the name of the cache_instance" do
+        cache_instance = double('cache_instance', cache_cluster_id: "job-queue-cluster",
+                                                  cache_node_type: "cache.t2.small",
+                                                  engine: "redis",
+                                                  cache_cluster_status: "available",
+                                                  num_cache_nodes: 1,
+                                                  preferred_availability_zone: "us-east-1d",
+                                                  class: "Aws::ElastiCache::Types::CacheCluster")
+        cache_clusters = double('cache_cluster', cache_clusters: [cache_instance])
+        tag1 = double('tag', key: "cookie", value: "chocolate chip")
+        tag2 = double('tag', key: "ice cream", value: "oreo")
+        tags = double('tags', tag_list: [tag1, tag2])
+        cache_client = double('cache_client', describe_cache_clusters: cache_clusters, list_tags_for_resource: tags)
+        allow(CacheInstance).to receive(:cache).and_return(cache_client)
+        instances = CacheInstance::get_instances("tag_name")
+        instance = instances.first
+        expect(instance.to_s).to eq("redis cache.t2.small")
+      end
+    end
+  end
+end

data/spec/sport_ngin_aws_auditor/config_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'sport_ngin_aws_auditor'
+
+module SportNginAwsAuditor
+  describe Config do
+
+    context "config key methods" do
+      it "should return nil when not set" do
+        expect(SportNginAwsAuditor::Config.doesnt_exist).to eql(nil)
+        expect(SportNginAwsAuditor::Config.doesnt_exist?).to eql(false)
+      end
+      it "should return the config value when set" do
+        SportNginAwsAuditor::Config.new_value = "testing"
+        expect(SportNginAwsAuditor::Config.new_value).to eql("testing")
+      end
+    end
+
+    context "after loading a config file" do
+      before do
+        config_file = {"domain" => "example_domain",
+                       "slack" => {"slack_option" => true,
+                                   "username" => "Rspec Tester",
+                                   "icon_url" => "http://fake.url",
+                                   "channel" => "#test-channel",
+                                   "webhook" => "https://slack.web.hook"}}
+        allow(YAML).to receive(:load_file).and_return(config_file)
+        allow(File).to receive(:exist?).and_return(true)
+        SportNginAwsAuditor::Config.load("dummy/path")
+      end
+
+      it "calling a method corresponding to a key in the file should return the value" do
+        expect(SportNginAwsAuditor::Config.domain).to eql("example_domain")
+        expect(SportNginAwsAuditor::Config.slack).to be_kind_of(Hash)
+        expect(SportNginAwsAuditor::Config.slack[:slack_option]).to eql(true)
+      end
+
+      it "overwriting values should work" do
+        expect(SportNginAwsAuditor::Config.slack).to be_kind_of(Hash)
+        SportNginAwsAuditor::Config.slack = "this is a string now"
+        expect(SportNginAwsAuditor::Config.slack).to eql("this is a string now")
+      end
+    end
+  end
+end

data/spec/sport_ngin_aws_auditor/ec2_instance_spec.rb

@@ -0,0 +1,181 @@
+require "sport_ngin_aws_auditor"
+
+module SportNginAwsAuditor
+  describe EC2Instance do
+
+    after :each do
+      EC2Instance.instance_variable_set("@instances", nil)
+      EC2Instance.instance_variable_set("@reserved_instances", nil)
+    end
+
+    context "for normal ec2_instances" do
+      before :each do
+        state = double('state', name: 'running')
+        placement = double('placement', availability_zone: "us-east-1d")
+        tag1 = double('tag', key: "cookie", value: "chocolate chip")
+        tag2 = double('tag', key: "ice cream", value: "oreo")
+        instance_tags = [tag1, tag2]
+        ec2_instance1 = double('ec2_instance', instance_id: "i-thisisfake",
+                                               instance_type: "t2.large",
+                                               vpc_id: "vpc-alsofake",
+                                               platform: nil,
+                                               state: state,
+                                               placement: placement,
+                                               tags: instance_tags,
+                                               class: "Aws::EC2::Types::Instance")
+        ec2_instance2 = double('ec2_instance', instance_id: "i-thisisfake",
+                                               instance_type: "t2.large",
+                                               vpc_id: "vpc-alsofake",
+                                               platform: nil,
+                                               state: state,
+                                               placement: placement,
+                                               tags: instance_tags,
+                                               class: "Aws::EC2::Types::Instance")
+        ec2_reservations = double('ec2_reservations', instances: [ec2_instance1, ec2_instance2])
+        ec2_instances = double('ec2_instances', reservations: [ec2_reservations])
+        name_tag = { key: "Name", value: "our-app-instance-100" }
+        stack_tag = { key: "opsworks:stack", value: "our_app_service_2" }
+        client_tags = double('tags', tags: [name_tag, stack_tag])
+        ec2_client = double('rds_client', describe_instances: ec2_instances, describe_tags: client_tags)
+        allow(EC2Instance).to receive(:ec2).and_return(ec2_client)
+      end
+
+      it "should make an ec2_instance for each instance" do
+        instances = EC2Instance::get_instances("tag_name")
+        expect(instances.first).to be_an_instance_of(EC2Instance)
+        expect(instances.last).to be_an_instance_of(EC2Instance)
+      end
+
+      it "should return an array of ec2_instances" do
+        instances = EC2Instance::get_instances("tag_name")
+        expect(instances).not_to be_empty
+        expect(instances.length).to eq(2)
+      end
+
+      it "should have proper variables set" do
+        instances = EC2Instance::get_instances("tag_name")
+        instance = instances.first
+        expect(instance.stack_name).to eq("our_app_service_2")
+        expect(instance.name).to eq("our-app-instance-100")
+        expect(instance.id).to eq("i-thisisfake")
+        expect(instance.availability_zone).to eq("us-east-1d")
+        expect(instance.instance_type).to eq("t2.large")
+        expect(instance.platform).to eq("VPC")
+      end
+    end
+
+    context "for reserved_ec2_instances" do
+      before :each do
+        reserved_ec2_instance1 = double('reserved_ec2_instance', reserved_instances_id: "12345-dfas-1234-asdf-thisisfake!!",
+                                                                 instance_type: "t2.medium",
+                                                                 product_description: "Linux/UNIX (Amazon VPC)",
+                                                                 state: "active",
+                                                                 availability_zone: "us-east-1b",
+                                                                 instance_count: 4,
+                                                                 class: "Aws::EC2::Types::ReservedInstances")
+        reserved_ec2_instance2 = double('reserved_ec2_instance', reserved_instances_id: "12345-dfas-1234-asdf-thisisalsofake",
+                                                                 instance_type: "t2.small",
+                                                                 product_description: "Linux/UNIX (Amazon VPC)",
+                                                                 state: "active",
+                                                                 availability_zone: "us-east-1b",
+                                                                 instance_count: 2,
+                                                                 class: "Aws::EC2::Types::ReservedInstances")
+        reserved_ec2_instances = double('reserved_ec2_instances', reserved_instances: [reserved_ec2_instance1, reserved_ec2_instance2])
+        ec2_client = double('rds_client', describe_reserved_instances: reserved_ec2_instances)
+        allow(EC2Instance).to receive(:ec2).and_return(ec2_client)
+      end
+
+      it "should make a reserved_ec2_instance for each instance" do
+        reserved_instances = EC2Instance::get_reserved_instances
+        expect(reserved_instances.first).to be_an_instance_of(EC2Instance)
+        expect(reserved_instances.last).to be_an_instance_of(EC2Instance)
+      end
+
+      it "should return an array of reserved_ec2_instances" do
+        reserved_instances = EC2Instance::get_reserved_instances
+        expect(reserved_instances).not_to be_empty
+        expect(reserved_instances.length).to eq(2)
+      end
+
+      it "should have proper variables set" do
+        reserved_instances = EC2Instance::get_reserved_instances
+        reserved_instance = reserved_instances.first
+        expect(reserved_instance.id).to eq("12345-dfas-1234-asdf-thisisfake!!")
+        expect(reserved_instance.platform).to eq("VPC")
+        expect(reserved_instance.availability_zone).to eq("us-east-1b")
+        expect(reserved_instance.instance_type).to eq("t2.medium")
+        expect(reserved_instance.count).to eq(4)
+      end
+    end
+
+    context "for returning pretty string formats" do
+      it "should return a string version of the name of the reserved_rds_instance" do
+        state = double('state', name: 'running')
+        placement = double('placement', availability_zone: "us-east-1d")
+        tag1 = double('tag', key: "cookie", value: "chocolate chip")
+        tag2 = double('tag', key: "ice cream", value: "oreo")
+        instance_tags = [tag1, tag2]
+        ec2_instance = double('ec2_instance', instance_id: "i-thisisfake",
+                                              instance_type: "t2.large",
+                                              vpc_id: "vpc-alsofake",
+                                              platform: nil,
+                                              state: state,
+                                              placement: placement,
+                                              tags: instance_tags,
+                                              class: "Aws::EC2::Types::Instance")
+        ec2_reservations = double('ec2_reservations', instances: [ec2_instance])
+        ec2_instances = double('ec2_instances', reservations: [ec2_reservations])
+        name_tag = { key: "Name", value: "our-app-instance-100" }
+        stack_tag = { key: "opsworks:stack", value: "our_app_service_2" }
+        tags = double('tags', tags: [name_tag, stack_tag])
+        ec2_client = double('rds_client', describe_instances: ec2_instances, describe_tags: tags)
+        allow(EC2Instance).to receive(:ec2).and_return(ec2_client)
+        instances = EC2Instance::get_instances("tag_name")
+        instance = instances.first
+        expect(instance.to_s).to eq("VPC us-east-1d t2.large")
+      end
+    end
+
+    context "when bucketizing" do
+      before :each do
+        state = double('state', name: 'running')
+        placement = double('placement', availability_zone: "us-east-1d")
+        ec2_instance1 = double('ec2_instance', instance_id: "i-thisisfake",
+                                               instance_type: "t2.large",
+                                               vpc_id: "vpc-alsofake",
+                                               platform: nil,
+                                               state: state,
+                                               placement: placement,
+                                               class: "Aws::EC2::Types::Instance")
+        ec2_instance2 = double('ec2_instance', instance_id: "i-alsofake",
+                                               instance_type: "t2.small",
+                                               vpc_id: "vpc-alsofake",
+                                               platform: nil,
+                                               state: state,
+                                               placement: placement,
+                                               class: "Aws::EC2::Types::Instance")
+        ec2_reservations = double('ec2_reservations', instances: [ec2_instance1, ec2_instance2])
+        ec2_instances = double('ec2_instances', reservations: [ec2_reservations])
+        name_tag = { key: "Name", value: "our-app-instance-100" }
+        stack_tag = { key: "opsworks:stack", value: "our_app_service_2" }
+        tags = double('tags', tags: [name_tag, stack_tag])
+        ec2_client = double('rds_client', describe_instances: ec2_instances, describe_tags: tags)
+        allow(EC2Instance).to receive(:ec2).and_return(ec2_client)
+      end
+
+      it "should return a hash where the first element's key is the opsworks:stack name of the instances" do
+        instances = EC2Instance::get_instances
+        buckets = EC2Instance::bucketize
+        expect(buckets.first.first).to eq("our_app_service_2")
+      end
+
+      it "should return a hash where each element is a list of ec2_instances" do
+        instances = EC2Instance::get_instances
+        buckets = EC2Instance::bucketize
+        expect(buckets).not_to be_empty
+        expect(buckets.length).to eq(1)
+        expect(buckets.first.length).to eq(2)
+      end
+    end
+  end
+end

data/spec/sport_ngin_aws_auditor/notify_slack_spec.rb

@@ -0,0 +1,33 @@
+require "sport_ngin_aws_auditor"
+
+module SportNginAwsAuditor
+  describe NotifySlack do
+    before :each do
+      config_file = {"slack" => {"channel" => "#random-test-channel",
+                                 "username" => "Random User",
+                                 "webhook" => "https://hooks.slack.com/services/totallyrandom/fakewebhookurl",
+                                 "icon_url" => "http://random-picture.jpg"}
+                    }
+      expect(YAML).to receive(:load_file).and_return(config_file)
+      expect(File).to receive(:exist?).and_return(true)
+      SportNginAwsAuditor::Config.load("dummy/path")
+    end
+
+    it 'should ping Slack Notifier' do
+      notifier = double('notifier', ping: true)
+      allow(Slack::Notifier).to receive(:new).and_return(notifier)
+      expect(notifier).to receive(:ping).and_return(true)
+      message = NotifySlack.new("Test message")
+      message.perform
+    end
+
+     it 'should define certain values' do
+      message = NotifySlack.new("Test message")
+      expect(message.text).to eq("Test message")
+      expect(message.channel).to eq("#random-test-channel")
+      expect(message.username).to eq("Random User")
+      expect(message.webhook).to eq("https://hooks.slack.com/services/totallyrandom/fakewebhookurl")
+      expect(message.icon_url).to eq("http://random-picture.jpg")
+    end
+  end
+end