kitchen-terraform 0.5.1 → 0.6.0

data/lib/terraform/client.rb

@@ -14,78 +14,83 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative 'apply_command'
-require_relative 'command_executor'
-require_relative 'get_command'
-require_relative 'output_command'
-require_relative 'plan_command'
-require_relative 'show_command'
-require_relative 'validate_command'
-require_relative 'version_command'
+require 'terraform/command_factory'
+require 'terraform/no_output_parser'
+require 'terraform/output_parser'
+require 'terraform/shell_out'
+require 'terraform/version'
 
 module Terraform
-  # Behaviour for implementing the workflow
-  module Client
-    include CommandExecutor
-
-    def apply_execution_plan
-      execute command: ApplyCommand.new(
-        color: provisioner[:color], parallelism: provisioner[:parallelism],
-        state: provisioner[:state], target: provisioner[:plan]
-      ), timeout: provisioner[:apply_timeout]
+  # Client to execute commands
+  class Client
+    def apply_constructively
+      apply plan_command: factory.plan_command
     end
 
-    def current_state
-      execute(
-        command: ShowCommand
-          .new(color: provisioner[:color], target: provisioner[:state])
-      ) { |value| return value.gsub(/(\e\[\d+m|\n)/, '') }
+    def apply_destructively
+      apply plan_command: factory.destructive_plan_command
     end
 
-    def download_modules
-      execute command: GetCommand.new(target: provisioner[:directory])
+    def each_output_name(&block)
+      output_parser(name: '').each_name(&block)
     end
 
-    def output_value(list: false, name:, &block)
-      execute(
-        command: OutputCommand.new(
-          list: list, state: provisioner[:state], target: name, version: version
-        )
-      ) { |value| list ? value.each(&block) : (return value) }
+    def iterate_output(name:, &block)
+      output_parser(name: name).iterate_parsed_output(&block)
     end
 
-    def each_output_name(&block)
-      execute(
-        command: OutputCommand.new(
-          list: false, state: provisioner[:state], version: version,
-          return_raw: true
-        )
-      ) { |output| JSON.parse(output).each_key(&block) }
-    end
-
-    def plan_execution(destroy:)
-      execute command: plan_command(destroy: destroy)
+    def load_state(&block)
+      execute(command: factory.show_command) do |state|
+        /\w+/.match state, &block
+      end
     end
 
-    def validate_configuration_files
-      execute command: ValidateCommand.new(target: provisioner[:directory])
+    def output(name:)
+      output_parser(name: name).parsed_output
     end
 
     def version
-      execute command: VersionCommand.new do |value|
-        return value.slice(/v\d+\.\d+\.\d+/)
+      execute command: factory.version_command do |value|
+        return ::Terraform::Version.create value: value
       end
     end
 
     private
 
-    def plan_command(destroy:)
-      PlanCommand
-        .new color: provisioner[:color], destroy: destroy,
-             out: provisioner[:plan], parallelism: provisioner[:parallelism],
-             state: provisioner[:state], target: provisioner[:directory],
-             variables: provisioner[:variables],
-             variable_files: provisioner[:variable_files]
+    attr_accessor :apply_timeout, :cli, :factory, :logger
+
+    def apply(plan_command:)
+      execute command: factory.validate_command
+      execute command: factory.get_command
+      execute command: plan_command
+      ::Terraform::ShellOut.new(
+        cli: cli, command: factory.apply_command, logger: logger,
+        timeout: apply_timeout
+      ).execute
+    end
+
+    def execute(command:, &block)
+      ::Terraform::ShellOut
+        .new(cli: cli, command: command, logger: logger).execute(&block)
+    end
+
+    def initialize(config: {}, logger:)
+      self.apply_timeout = config[:apply_timeout]
+      self.cli = config[:cli]
+      self.factory = ::Terraform::CommandFactory.new config: config
+      self.logger = logger
+    end
+
+    def output_parser(name:)
+      execute(
+        command: factory.output_command(target: name, version: version)
+      ) do |value|
+        return ::Terraform::OutputParser.create output: value, version: version
+      end
+    rescue ::Kitchen::StandardError => exception
+      raise exception unless exception.message =~ /no outputs/
+
+      ::Terraform::NoOutputParser.new
     end
   end
 end

data/lib/terraform/color_coercer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Copyright 2016 New Context Services, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Terraform
+  # A coercer for the [:color] value
+  class ColorCoercer
+    def coerce(attr:, value:)
+      configurable[attr] = [true, false].find(
+        proc { configurable.config_error attr: attr, expected: 'a boolean' },
+        &value.method(:==)
+      )
+    end
+
+    private
+
+    attr_accessor :configurable
+
+    def initialize(configurable:)
+      self.configurable = configurable
+    end
+  end
+end

data/lib/terraform/color_config.rb

@@ -14,21 +14,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require_relative 'color_coercer'
+require_relative 'simple_config'
+
 module Terraform
   # Behaviour for the [:color] config option
   module ColorConfig
-    def self.included(configurable_class)
-      configurable_class.required_config :color do |_, value, configurable|
-        configurable.coerce_color value: value
-      end
-      configurable_class.default_config :color, true
-    end
+    include ::Terraform::SimpleConfig
 
-    def coerce_color(value:)
-      raise TypeError unless [TrueClass, FalseClass].include? value.class
-      config[:color] = value
-    rescue TypeError
-      config_error attribute: 'color', expected: 'a boolean'
+    def self.extended(configurable_class)
+      configurable_class
+        .configure_required attr: :color,
+                            coercer_class: ::Terraform::ColorCoercer,
+                            default_value: true
     end
   end
 end

data/lib/terraform/command.rb

@@ -14,54 +14,40 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mixlib/shellout'
+require 'terraform/command_options'
 
 module Terraform
   # Terraform command to be executed
   class Command
-    def name
-      ''
-    end
+    attr_reader :options, :target
 
-    def options
-      '--help'
-    end
+    def name
+      /(\w+)Command/.match(self.class.to_s) { |match| return match[1].downcase }
 
-    def output
-      processed_output raw_output: shell_out.stdout
+      'help'
     end
 
-    def run(logger:, timeout:)
-      shell_out.live_stream = logger
-      shell_out.timeout = timeout
-      shell_out.run_command
-      shell_out.error!
-    rescue => exception
-      handle_error exception: exception
+    def prepare
+      preparations.each(&:execute)
     end
 
     def to_s
-      shell_out.command
+      "#{name} #{options} #{target}".strip
     end
 
     private
 
-    attr_accessor :shell_out
+    attr_accessor :preparations
 
-    def handle_error(exception:)
-      raise exception
-    end
-
-    def initialize(target: '', **keyword_arguments)
-      initialize_attributes(**keyword_arguments)
-      self.shell_out = Mixlib::ShellOut
-                       .new "terraform #{name} #{options} #{target}", returns: 0
-    end
+    attr_writer :options, :target
 
-    def initialize_attributes(**_keyword_arguments) end
+    def initialize(target: '', &block)
+      block ||= proc {}
 
-    def processed_output(raw_output:)
-      raw_output
+      self.options = ::Terraform::CommandOptions.new
+      self.preparations = []
+      self.target = target
+      block.call options
     end
   end
 end

data/lib/terraform/command_factory.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# Copyright 2016 New Context Services, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'terraform/apply_command'
+require 'terraform/destructive_plan_command'
+require 'terraform/get_command'
+require 'terraform/output_command'
+require 'terraform/plan_command'
+require 'terraform/show_command'
+require 'terraform/validate_command'
+require 'terraform/version_command'
+
+module Terraform
+  # A factory to create commands
+  class CommandFactory
+    def apply_command
+      ::Terraform::ApplyCommand.new target: config[:plan] do |options|
+        options.color = config[:color]
+        options.input = false
+        options.parallelism = config[:parallelism]
+        options.state = config[:state]
+      end
+    end
+
+    def destructive_plan_command
+      ::Terraform::DestructivePlanCommand
+        .new target: config[:directory] do |options|
+          configure_plan options: options
+          options.destroy = true
+          options.state = config[:state]
+        end
+    end
+
+    def get_command
+      ::Terraform::GetCommand.new target: config[:directory] do |options|
+        options.update = true
+      end
+    end
+
+    def output_command(target:, version:)
+      version
+        .if_json_not_supported { return base_output_command target: target }
+
+      json_output_command target: target
+    end
+
+    def plan_command
+      ::Terraform::PlanCommand.new target: config[:directory] do |options|
+        configure_plan options: options
+      end
+    end
+
+    def show_command
+      ::Terraform::ShowCommand.new target: config[:state] do |options|
+        options.color = config[:color]
+      end
+    end
+
+    def validate_command
+      ::Terraform::ValidateCommand.new target: config[:directory]
+    end
+
+    def version_command
+      ::Terraform::VersionCommand.new
+    end
+
+    private
+
+    attr_accessor :config
+
+    def base_output_command(target:, &block)
+      block ||= proc {}
+
+      ::Terraform::OutputCommand.new target: target do |options|
+        options.color = config[:color]
+        options.state = config[:state]
+        block.call options
+      end
+    end
+
+    def configure_plan(options:)
+      options.color = config[:color]
+      options.input = false
+      options.out = config[:plan]
+      options.parallelism = config[:parallelism]
+      options.var = config[:variables]
+      options.var_file = config[:variable_files]
+    end
+
+    def initialize(config:)
+      self.config = config
+    end
+
+    def json_output_command(target:)
+      base_output_command(target: target) { |options| options.json = true }
+    end
+  end
+end

data/lib/terraform/command_option.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Copyright 2016 New Context Services, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Terraform
+  # An option for a command
+  class CommandOption
+    attr_reader :key, :value
+
+    def ==(other)
+      tuple == other.tuple
+    end
+
+    alias eql? ==
+
+    def hash
+      stripped_key.hash & stripped_value.hash
+    end
+
+    def to_s
+      "#{formatted_key}#{formatted_value}"
+    end
+
+    def tuple
+      [stripped_key, stripped_value]
+    end
+
+    private
+
+    attr_accessor :stripped_key, :stripped_value
+
+    attr_writer :key, :value
+
+    def initialize(key:, value: '')
+      self.key = key
+      self.stripped_key = stripped_string config_string: key
+      self.stripped_value = stripped_string config_string: value
+      self.value = value
+    end
+
+    def formatted_key
+      "-#{stripped_key}"
+    end
+
+    def formatted_value
+      stripped_value.sub(/(\S)/, '=\1')
+    end
+
+    def stripped_string(config_string:)
+      String(config_string).gsub(/\s/, '')
+    end
+  end
+end