chef-provisioning-aws 1.0.4 → 1.1.0

data/spec/aws_support/deep_matcher/fuzzy_match_objects.rb

@@ -0,0 +1,57 @@
+module AWSSupport
+  module DeepMatcher
+    #
+    # This gets mixed into RSpec::Support::FuzzyMatch, adding the ability to
+    # fuzzy match objects against hashes, a la:
+    #
+    # values_match({ a: 1, b: 2, 'c.d.e' => 3 },
+    #   <non-hash object with a, b and c methods>
+    # end
+    #
+    module FuzzyMatchObjects
+
+      require 'rspec/support/fuzzy_matcher'
+      require 'aws_support/deep_matcher/matchable_object'
+      require 'aws_support/deep_matcher/matchable_array'
+
+      def values_match?(expected, actual)
+        if Hash === expected
+          return hash_and_object_match?(expected, actual) if MatchableObject === actual
+        elsif Array === expected
+          return arrays_match?(expected, actual) if MatchableArray === actual
+        end
+
+        super
+      end
+
+      def hash_and_object_match?(expected, actual)
+        expected_hash.all? do |expected_key, expected_value|
+          # 'a.b.c'  => 1 -> { 'a' => { 'b' => { 'c' => 1 } } }
+          # :"a.b.c" => 1 -> { :a  => { :b  => { :c  => 1 } } }
+          names = expected_key.to_s.split('.')
+          if names.size > 1
+            expected_key = expected_key.is_a?(Symbol) ? names.shift.to_sym : names.shift
+            while !names.empty?
+              expected_value = { names.pop => expected_value }
+            end
+          end
+
+          # Grab the actual value from the object
+          begin
+            actual_value = actual_object.send(expected_key)
+          rescue NoMethodError
+            if !actual_value.respond_to?(expected_key)
+              return false
+            else
+              raise
+            end
+          end
+
+          return false if !values_match?(expected, actual)
+        end
+
+        true
+      end
+    end
+  end
+end

data/spec/aws_support/deep_matcher/match_values_failure_messages.rb

@@ -0,0 +1,145 @@
+module AWSSupport
+  module DeepMatcher
+    module MatchValuesFailureMessages
+
+      require 'rspec/matchers'
+      require 'rspec/matchers/composable'
+      require 'aws_support/deep_matcher'
+      require 'aws_support/deep_matcher/matchable_object'
+      require 'aws_support/deep_matcher/matchable_array'
+
+      protected
+
+      def match_values_failure_messages(expected, actual, identifier=nil)
+        if DeepMatcher === expected
+          return expected.match_failure_messages(actual, identifier)
+        elsif RSpec::Matchers::Composable === expected
+          if !expected.matches?(actual)
+            return [ expected.failure_message ]
+          else
+            return []
+          end
+        elsif Hash === expected
+          return match_hashes_failure_messages(expected, actual, identifier) if Hash === actual
+          return match_hash_and_object_failure_messages(expected, actual, identifier) if MatchableObject === actual
+        elsif Array === expected
+          return match_arrays_failure_messages(expected, actual, identifier) if MatchableArray === actual
+        end
+
+        if values_match?(expected, actual)
+          []
+        elsif expected.respond_to?(:failure_message)
+          [ "#{identifier ? "#{identifier}: " : ""}#{expected.failure_message}" ]
+        else
+          [ "#{identifier ? "#{identifier}: " : ""}expected #{description_of(expected)}, but actual value was #{actual.inspect}" ]
+        end
+      end
+
+      def match_hashes_failure_messages(expected_hash, actual_hash, identifier)
+        result = []
+
+        expected_hash.all? do |expected_key, expected_value|
+          missing_value = false
+          actual_value = actual_hash.fetch(expected_key) do
+            result << "expected #{identifier || "hash"}.fetch(#{expected_key.inspect}) to #{description_of(expected_value)}, but it was missing entirely from the hash"
+            missing_value = true
+          end
+          unless missing_value
+            result += match_values_failure_messages(expected_value, actual_value, "#{identifier}[#{expected_key.inspect}]")
+          end
+        end
+
+        result
+      end
+
+      #
+      # Match arrays using Diff::LCS to determine which elements correspond to
+      # which.
+      #
+      def match_arrays_failure_messages(expected_list, actual_list, identifier)
+        result = [ "#{identifier || "value"} is different from expected!  Differences:" ]
+
+        different = false
+
+        expected_list = expected_list.map { |v| ExpectedValue.new(v) }
+        Diff::LCS.sdiff(expected_list, actual_list) do |change|
+          case change.action
+          when '='
+            messages = [ change.new_element.inspect ]
+          when '+'
+            messages = [ change.new_element.inspect ]
+            different = true
+          when '-'
+            messages = [ change.old_element.value.inspect ]
+            different = true
+          when '!'
+            messages = change.old_element.failure_messages(change.new_element)
+            different = true
+          else
+            raise "Unknown operator returned from sdiff: #{op}"
+          end
+          op = change.action
+          op = ' ' if op == '='
+          result += messages.flat_map { |m| m.split("\n") }.map { |m| "#{op} #{m}" }
+        end
+        different ? result : []
+      end
+
+      def match_hash_and_object_failure_messages(expected_hash, actual_object, identifier)
+        result = []
+
+        expected_hash.all? do |expected_key, expected_value|
+          # 'a.b.c' => 1 -> { a: { b: { c: 1 }}}
+          names = expected_key.to_s.split('.')
+          if names.size > 1
+            expected_key = names.shift
+            while !names.empty?
+              expected_value = { names.pop => expected_value }
+            end
+          end
+
+          # Grab the actual value from the object
+          begin
+            actual_value = actual_object.send(expected_key)
+          rescue NoMethodError
+            if !actual_value.respond_to?(expected_key)
+              result << "#{identifier || "object"}.send(#{expected_key.inspect}) is missing, expected value #{description_of(expected_value)}"
+              next
+            else
+              raise
+            end
+          end
+
+          # Check if the values are different
+          result += match_values_failure_messages(expected_value, actual_value, "#{identifier}.#{expected_key}")
+        end
+
+        result
+      end
+
+      #
+      # Handles == by calling match (used for Diff::LCS to do its magic and still
+      # work with rspec)
+      #
+      class ExpectedValue
+        include RSpec::Matchers::Composable
+        include MatchValuesFailureMessages
+
+        def initialize(value)
+          @value = value
+        end
+        attr_reader :value
+
+        def failure_messages(actual)
+          @failure_messages[actual]
+        end
+
+        def ==(actual)
+          @failure_messages ||= {}
+          @failure_messages[actual] ||= match_values_failure_messages(value, actual)
+          @failure_messages[actual].empty?
+        end
+      end
+    end
+  end
+end

data/spec/aws_support/deep_matcher/matchable_array.rb

@@ -0,0 +1,24 @@
+module AWSSupport
+  module DeepMatcher
+    #
+    # If a module implements this, it signifies that
+    #
+    module MatchableArray
+
+      #
+      # TODO allow the user to return a new object that actually implements the
+      # enumerable, in case the class in question is non-standard.
+      #
+
+      def self.matchable_classes
+        @matchable_classes ||= []
+      end
+
+      def self.===(other)
+        return true if matchable_classes.any? { |c| c === other }
+        return true if Enumerable === other && !(Struct === other)
+        super
+      end
+    end
+  end
+end

data/spec/aws_support/deep_matcher/matchable_object.rb

@@ -0,0 +1,25 @@
+module AWSSupport
+  module DeepMatcher
+    #
+    # If a module implements this, or is added to `matchable_classes`,
+    # RSpec's `match` will match its attributes up to hashes a la:
+    #
+    # ```ruby
+    # expect(my_object).to match({ a: 1, b: 2 })
+    # ```
+    #
+    # Which will compare my_object.a to 1 and my_object.b to 2.
+    #
+    module MatchableObject
+
+      def self.matchable_classes
+        @matchable_classes ||= []
+      end
+
+      def self.===(other)
+        return true if matchable_classes.any? { |c| c === other}
+        super
+      end
+    end
+  end
+end

data/spec/aws_support/deep_matcher/rspec_monkeypatches.rb

@@ -0,0 +1,25 @@
+# FIRST thing we do in a desperate attempt to get our module in before RSpec loads
+
+module AWSSupport
+  module DeepMatcher
+    module MatchValuesFailureMessages
+    end
+  end
+end
+
+module RSpec
+  module Matchers
+    module Composable
+      include AWSSupport::DeepMatcher::MatchValuesFailureMessages
+    end
+  end
+end
+
+require 'aws_support/deep_matcher/match_values_failure_messages'
+require 'rspec/matchers/composable'
+require 'rspec/support/fuzzy_matcher'
+require 'aws_support/deep_matcher/fuzzy_match_objects'
+
+module RSpec::Support::FuzzyMatcher
+  prepend AWSSupport::DeepMatcher::FuzzyMatchObjects
+end

data/spec/aws_support/delayed_stream.rb

@@ -0,0 +1,41 @@
+require 'timeout'
+
+module AWSSupport
+  class DelayedStream
+    def initialize(delay_before_streaming, *streams)
+      @streams = streams.flatten.select { |s| !s.nil? }
+      if delay_before_streaming > 0
+        @buffer = StringIO.new
+        @thread = Thread.new do
+          sleep delay_before_streaming
+          start_streaming
+        end
+      end
+    end
+
+    attr_reader :streams
+    attr_reader :buffer
+
+    def start_streaming
+      if @buffer
+        buffer = @buffer
+        @buffer = nil
+        streams.each { |s| s.write(buffer.string) }
+      end
+    end
+
+    def write(*args, &block)
+      if buffer.nil?
+        streams.each { |s| s.write(*args, &block) }
+      else
+        buffer.write(*args, &block)
+      end
+    end
+
+    def close
+      @streams = []
+      @thread.kill if @thread
+      @thread = nil
+    end
+  end
+end

data/spec/aws_support/matchers/create_an_aws_object.rb

@@ -0,0 +1,60 @@
+require 'rspec/matchers'
+require 'chef/provisioning'
+require 'aws_support/deep_matcher'
+
+module AWSSupport
+  module Matchers
+    class CreateAnAWSObject
+      include RSpec::Matchers::Composable
+      include AWSSupport::DeepMatcher
+
+      def initialize(example, resource_class, name, expected_values)
+        @example = example
+        @resource_class = resource_class
+        @name = name
+        @expected_values = expected_values
+      end
+
+      attr_reader :example
+      attr_reader :resource_class
+      attr_reader :name
+      attr_reader :expected_values
+      def resource_name
+        @resource_class.resource_name
+      end
+
+      def match_failure_messages(recipe)
+        differences = []
+
+        # We want to record that it was created BEFORE the converge, so that
+        # even if it fails, we destroy it.
+        example.created_during_test << [ resource_name, name ]
+
+        # Converge
+        begin
+          recipe.converge
+        rescue
+          differences += [ "error trying to create #{resource_name}[#{name}]!\n#{($!.backtrace.map { |line| "- #{line}\n" } + [ recipe.output_for_failure_message ]).join("")}" ]
+        end
+
+        # Check whether the recipe caused an update or not
+        differences += match_values_failure_messages(example.be_updated, recipe, "recipe")
+
+        # Check for object existence and properties
+        resource = resource_class.new(name, nil)
+        resource.driver example.driver
+        resource.managed_entry_store Chef::Provisioning.chef_managed_entry_store
+        aws_object = resource.aws_object
+
+        # Check existence
+        if aws_object.nil?
+          differences << "#{resource_name}[#{name}] was not created!"
+        else
+          differences += match_values_failure_messages(expected_values, aws_object, "#{resource_name}[#{name}]")
+        end
+
+        differences
+      end
+    end
+  end
+end

data/spec/aws_support/matchers/update_an_aws_object.rb

@@ -0,0 +1,66 @@
+require 'rspec/matchers'
+require 'aws_support/deep_matcher'
+
+module AWSSupport
+  module Matchers
+    class UpdateAnAWSObject
+
+      include RSpec::Matchers::Composable
+      include AWSSupport::DeepMatcher
+
+      require 'chef/provisioning'
+
+      def initialize(example, resource_class, name, expected_updates)
+        @example = example
+        @resource_class = resource_class
+        @name = name
+        @expected_updates = expected_updates
+
+        # Grab the "before" value
+        resource = resource_class.new(name, nil)
+        resource.driver example.driver
+        resource.managed_entry_store Chef::Provisioning.chef_managed_entry_store
+        @had_initial_value = !resource.aws_object.nil?
+      end
+
+      attr_reader :example
+      attr_reader :resource_class
+      attr_reader :name
+      attr_reader :expected_updates
+      def resource_name
+        @resource_class.resource_name
+      end
+      attr_reader :had_initial_value
+
+      def match_failure_messages(recipe)
+        differences = []
+
+        if !had_initial_value
+          differences << "expected recipe to update #{resource_name}[#{name}], but the AWS object did not exist before recipe ran!"
+          return differences
+        end
+
+        # Converge
+        begin
+          recipe.converge
+        rescue
+          differences += [ "error trying to update #{resource_name}[#{name}]!\n#{($!.backtrace.map { |line| "- #{line}\n" } + [ recipe.output_for_failure_message ]).join("")}" ]
+        end
+
+        # Check if the recipe actually caused an update
+        differences += match_values_failure_messages(example.be_updated, recipe, "recipe")
+
+        # Check if any properties that should have been updated, weren't
+        resource = resource_class.new(name, nil)
+        resource.driver example.driver
+        resource.managed_entry_store Chef::Provisioning.chef_managed_entry_store
+        aws_object = resource.aws_object
+
+        # Check to see if properties have the expected values
+        differences += match_values_failure_messages(expected_updates, aws_object, "#{resource_name}[#{name}]")
+
+        differences
+      end
+    end
+  end
+end