terraspace 0.3.0 → 0.3.5

data/lib/terraspace/terraform/cloud/runs/lister.rb

@@ -1,5 +1,3 @@
-require 'cli-format'
-
 class Terraspace::Terraform::Cloud::Runs
   class Lister < Base
     def run

data/lib/terraspace/terraform/cloud/syncer.rb

@@ -12,8 +12,8 @@ module Terraspace::Terraform::Cloud
     end
 
     def mods
-      mod = @options[:mod]
-      mod ? [mod] : stack_names
+      stacks = @options[:stacks]
+      stacks.empty? ? stack_names : stacks
     end
 
     def run_sync(mod)

data/lib/terraspace/terraform/cloud/workspace.rb

@@ -20,15 +20,6 @@ module Terraspace::Terraform::Cloud
       logger.info names.join("\n")
     end
 
-    def setup
-      build
-      unless backend.dig('remote','workspaces') # in case called by terraspace down demo -y --destroy-workspace with a non-remote backend
-        logger.info "ERROR: Workspace not configured in backend.tf"
-        exit 1
-      end
-      init
-    end
-
     def init
       Terraspace::CLI::Init.new(@options.merge(calling_command: "cloud-setup")).run
     end

data/lib/terraspace/terraform/remote_state/fetcher.rb

@@ -1,29 +1,40 @@
 module Terraspace::Terraform::RemoteState
   class Fetcher
     extend Memoist
+    include Terraspace::Compiler::CommandsConcern
     include Terraspace::Util::Logging
 
     def initialize(parent, identifier, options={})
       @parent, @identifier, @options = parent, identifier, options
       child_name, @output_key = identifier.split('.')
       @child = Terraspace::Mod.new(child_name)
+      @child.resolved = @parent.resolved
     end
 
     def run
-      validate!
+      validate! # check child stack exists
       pull
       load
     end
 
+    # Returns OutputProxy
     def output
       run
       if pull_success?
-        value = output_value
-        error = output_error(:key_not_found) unless @outputs.key?(@output_key)
-        OutputProxy.new(value, @options.merge(error: error))
+        pull_success_output
       else
-        error = output_error(:state_not_found)
-        OutputProxy.new(nil, @options.merge(error: error))
+        @error_type ||= :state_not_found # could be set to :bucket_not_found by bucket_not_found_error
+        error = output_error(@error_type)
+        OutputProxy.new(@child, nil, @options.merge(error: error))
+      end
+    end
+
+    def pull_success_output
+      if @outputs.key?(@output_key)
+        OutputProxy.new(@child, output_value, @options)
+      else
+        error = output_error(:key_not_found)
+        OutputProxy.new(@child, nil, @options.merge(error: error))
       end
     end
 
@@ -39,6 +50,8 @@ module Terraspace::Terraform::RemoteState
         "Output #{@output_key} was not found for the #{@parent.name} tfvars file. Either #{@child.name} stack has not been deployed yet or it does not have this output: #{@output_key}"
       when :state_not_found
         "Output #{@output_key} could not be looked up for the #{@parent.name} tfvars file. #{@child.name} stack needs to be deployed"
+      when :bucket_not_found
+        "The bucket for the backend could not be found"
       end
       msg = "(#{msg})"
       log_message(msg)
@@ -52,7 +65,10 @@ module Terraspace::Terraform::RemoteState
       logger.info "Downloading tfstate files for dependencies defined in tfvars..." unless @@download_shown || @options[:quiet]
       @@download_shown = true
       logger.debug "Downloading tfstate for stack: #{@child.name}"
-      Terraspace::CLI::Init.new(mod: @child.name, calling_command: "apply", quiet: true).init # init not run, so only init
+
+      success = init # init not yet run. only run .init directly, not .run. init can completely error and early exit.
+      return unless success
+
       FileUtils.mkdir_p(File.dirname(state_path))
       command = "cd #{@child.cache_dir} && terraform state pull > #{state_path}"
       logger.debug "=> #{command}"
@@ -67,6 +83,20 @@ module Terraspace::Terraform::RemoteState
       @@pull_successes[cache_key] = success
     end
 
+    def init
+      Terraspace::CLI::Init.new(mod: @child.name, calling_command: "apply", quiet: true, suppress_error_color: true).init
+      true
+    rescue Terraspace::BucketNotFoundError # from Terraspace::Shell
+      bucket_not_found_error
+      false
+    end
+
+    # mimic pull error
+    def bucket_not_found_error
+      @@pull_successes[cache_key] = false
+      @error_type = :bucket_not_found
+    end
+
     def load
       return self unless pull_success?
 

data/lib/terraspace/terraform/remote_state/marker/output.rb

@@ -8,6 +8,7 @@ module Terraspace::Terraform::RemoteState::Marker
       @child_name, @output_key = @identifier.split('.')
     end
 
+    # Returns OutputProxy
     def build
       if valid?
         Terraspace::Dependency::Registry.register(@parent_name, @child_name)
@@ -16,7 +17,7 @@ module Terraspace::Terraform::RemoteState::Marker
       end
       # MARKER for debugging. Only appears on 1st pass. Will not see unless changing Terraspace code for debugging.
       marker = "MARKER:terraform_output('#{@identifier}')"
-      Terraspace::Terraform::RemoteState::OutputProxy.new(marker, @options)
+      Terraspace::Terraform::RemoteState::OutputProxy.new(@mod, marker, @options)
     end
 
     def valid?
@@ -26,6 +27,7 @@ module Terraspace::Terraform::RemoteState::Marker
     def warning
       logger.warn "WARN: The #{@child_name} stack does not exist".color(:yellow)
       caller_line = caller.find { |l| l.include?('.tfvars') }
+      return unless caller_line # specs dont have a tfvars file
       source_code = PrettyTracer.new(caller_line).source_code
       logger.info source_code
     end

data/lib/terraspace/terraform/remote_state/null_object.rb

@@ -0,0 +1,40 @@
+module Terraspace::Terraform::RemoteState
+  class NullObject
+    def to_a
+      []
+    end
+
+    def to_ary
+      []
+    end
+
+    def to_s
+      "(unresolved)" # always returned as part of first unresolved processing pass
+    end
+    alias_method :to_str, :to_s # ERB requires to_str
+
+    def to_f
+      0.0
+    end
+
+    def to_i
+      0
+    end
+
+    def nil?
+      true
+    end
+
+    def inspect
+      format("#<%s:0x%x>", self.class, object_id)
+    end
+
+    def method_missing(*_args, &_block)
+      self
+    end
+
+    def respond_to?(_message, _include_private = false)
+      true
+    end
+  end
+end

data/lib/terraspace/terraform/remote_state/output_proxy.rb

@@ -1,29 +1,33 @@
 module Terraspace::Terraform::RemoteState
   class OutputProxy
     # raw: can be anything: String, Array, Hash, etc
-    # options: original options passed by user with terraform_output
+    # options: original options passed by user from the output helper in tfvars
     attr_reader :raw, :options
-    def initialize(raw, options={})
-      @raw, @options = raw, options
+    def initialize(mod, raw, options={})
+      @mod, @raw, @options = mod, raw, options
       @format = @options[:format]
     end
 
     # Should always return a String
     def to_s
-      case @format
-      when "string"
-        content.to_s
-      else # "json"
-        content.to_json
+      if @mod.resolved
+        # Dont use NullObject wrapper because Integer get changed to Strings.
+        # Want raw value to be used for the to_json call
+        value = @raw.nil? ? mock_or_error : @raw
+        value.to_json
+      else
+        NullObject.new # to_s => (unresolved)
       end
     end
 
-    def content
-      if @raw.nil?
-        @options[:mock] || @options[:error]
-      else
-        @raw
-      end
+    def to_ruby
+      data = @raw.nil? ? mock_or_error : @raw
+      @mod.resolved ? data : NullObject.new
+    end
+
+  private
+    def mock_or_error
+      @options[:mock] || @options[:error]
     end
   end
 end

data/lib/terraspace/version.rb

@@ -1,3 +1,3 @@
 module Terraspace
-  VERSION = "0.3.0"
+  VERSION = "0.3.5"
 end

data/spec/fixtures/dependencies/app/stacks/a1/tfvars/dev.tfvars

@@ -0,0 +1 @@
+length = <%= output('b1.length') %>

data/spec/fixtures/fetcher/c1.json

@@ -8,6 +8,10 @@
       "value": 1,
       "type": "number"
     },
+    "complex": {
+      "value": ["a","b"],
+      "type": "list"
+    },
     "random_pet_id": {
       "value": "valued-buzzard",
       "type": "string"

data/spec/terraspace/all/summary_spec.rb

@@ -68,7 +68,7 @@ describe Terraspace::All::Summary do
     let(:log_path) { "spec/fixtures/summary/output.log" }
     it "run" do
       summary.run
-      expect(@io.string).to include "=> terraform output"
+      expect(@io.string).to include "pet1 = krill"
     end
   end
 

data/spec/terraspace/compiler/erb/render_spec.rb

@@ -0,0 +1,15 @@
+describe Terraspace::Compiler::Erb::Render do
+  let(:render) { described_class.new(mod, src_path) }
+  let(:mod)    { Terraspace::Mod.new("a1") }
+
+  # Only testing mod unresolved as a sanity check and its worth the ROI.
+  # The resolved would the Fetcher. We have unit tests to cover those other changes.
+  context "a1" do
+    let(:src_path) { fixture("dependencies/app/stacks/a1/tfvars/dev.tfvars") }
+    it "build" do
+      allow(Terraspace::Terraform::RemoteState::Marker::Output).to receive(:stack_names).and_return("b1")
+      result = render.build
+      expect(result).to eq "length = (unresolved)"
+    end
+  end
+end

data/spec/terraspace/dependency/helper/depends_on_spec.rb

@@ -0,0 +1,27 @@
+describe Terraspace::Dependency::Helper::DependsOn do
+  let(:depends_on) do
+    described_class.new(mod, identifier, options)
+  end
+  let (:mod) { Terraspace::Mod.new("a1") }
+  # follow args dont matter for spec
+  let (:identifier) { "b1" }
+  let (:options) { {} }
+
+  context "unresolved" do
+    before(:each) { mod.resolved = false }
+    it "result calls Marker::Output" do
+      allow(Terraspace::Terraform::RemoteState::Marker::Output).to receive(:new).and_return(double(:marker_output).as_null_object)
+      result = depends_on.result
+      expect(result).to be_a(RSpec::Mocks::Double)
+      expect(result.instance_variable_get(:@name)).to eq :marker_output
+    end
+  end
+
+  context "resolved" do
+    before(:each) { mod.resolved = true }
+    it "return an raw String" do
+      result = depends_on.result
+      expect(result).to eq "# a1 depends on b1"
+    end
+  end
+end

data/spec/terraspace/dependency/helper/output_spec.rb

@@ -0,0 +1,29 @@
+describe Terraspace::Dependency::Helper::Output do
+  let(:output) do
+    described_class.new(mod, identifier, options)
+  end
+  let (:mod) { Terraspace::Mod.new("foo") }
+  # doesnt matter for spec
+  let (:identifier) { nil }
+  let (:options) { nil }
+
+  context "unresolved" do
+    before(:each) { mod.resolved = false }
+    it "result calls Marker::Output" do
+      allow(Terraspace::Terraform::RemoteState::Marker::Output).to receive(:new).and_return(double(:marker_output).as_null_object)
+      result = output.result
+      expect(result).to be_a(RSpec::Mocks::Double)
+      expect(result.instance_variable_get(:@name)).to eq :marker_output
+    end
+  end
+
+  context "resolved" do
+    before(:each) { mod.resolved = true }
+    it "result calls Fetcher" do
+      allow(Terraspace::Terraform::RemoteState::Fetcher).to receive(:new).and_return(double(:fetcher_output).as_null_object)
+      result = output.result
+      expect(result).to be_a(RSpec::Mocks::Double)
+      expect(result.instance_variable_get(:@name)).to eq :fetcher_output
+    end
+  end
+end

data/spec/terraspace/terraform/remote_state/fetcher_spec.rb

@@ -11,41 +11,122 @@ describe Terraspace::Terraform::RemoteState::Fetcher do
     double("c1").as_null_object
   end
 
-  context "pull success" do
-    let(:state_path)   { "spec/fixtures/fetcher/c1.json" }
-    let(:pull_success) { true }
+  context "to_s uses to_json by default" do
+    context "pull success" do
+      let(:state_path)   { "spec/fixtures/fetcher/c1.json" }
+      let(:pull_success) { true }
 
-    context "c1.length" do
-      let(:identifier) { "c1.length" }
-      it "fetched found attribute" do
-        expect(fetcher.output.raw).to eq 1 # matches spec/fixtures/fetcher/c1.json outputs.length.value
+      context "c1.length" do
+        let(:identifier) { "c1.length" }
+        it "fetched found attribute" do
+          expect(fetcher.output.to_s).to eq '1' # Integer as json matches spec/fixtures/fetcher/c1.json outputs.length.value
+        end
+      end
+
+      context "c1.complex" do
+        let(:identifier) { "c1.complex" }
+        it "fetched found attribute" do
+          expect(fetcher.output.to_s).to eq ["a","b"].to_json # matches spec/fixtures/fetcher/c1.json outputs.complex.value
+        end
+      end
+
+      context "c1.does-not-exist" do
+        let(:identifier) { "c1.does-not-exist" }
+        it "fetched missing output" do
+          output_proxy = fetcher.output
+          expect(output_proxy.raw).to be nil
+          value = output_proxy.to_s
+          # (Output length9 was not found for the b1 tfvars file. Either c1 stack has not been deployed yet or it does not have this output: length9)
+          expect(value).to include "not found"
+        end
       end
     end
 
-    context "c1.does-not-exist" do
-      let(:identifier) { "c1.does-not-exist" }
-      it "fetched missing output" do
-        output_proxy = fetcher.output
-        expect(output_proxy.raw).to be nil
-        # (Output length9 was not found for the b1 tfvars file. Either c1 stack has not been deployed yet or it does not have this output: length9)
-        error = output_proxy.options[:error]
-        expect(error).to include "not found"
+    context "pull fail" do
+      let(:state_path)   { nil }
+      let(:pull_success) { false }
+
+      context "stack needs to be deployed" do
+        let(:identifier) { "c1.length" }
+        it "fetched" do
+          output_proxy = fetcher.output
+          expect(output_proxy.raw).to be nil
+          # (Output length could not be looked up for the b1 tfvars file. c1 stack needs to be deployed)
+          value = output_proxy.to_s
+          expect(value).to include "stack needs to be deployed"
+        end
+      end
+
+      context "bucket does not exist" do
+        let(:identifier) { "c1.length" }
+        it "fetched" do
+          fetcher.bucket_not_found_error # fake it!
+          output_proxy = fetcher.output
+          expect(output_proxy.raw).to be nil
+          # (Output length could not be looked up for the b1 tfvars file. c1 stack needs to be deployed)
+          value = output_proxy.to_s
+          expect(value).to include "bucket for the backend could not be found"
+        end
       end
     end
   end
 
-  context "pull fail" do
-    let(:state_path)   { nil }
-    let(:pull_success) { false }
-
-    context "c1.length" do
-      let(:identifier) { "c1.length" }
-      it "fetched" do
-        output_proxy = fetcher.output
-        expect(output_proxy.raw).to be nil
-        # (Output length could not be looked up for the b1 tfvars file. c1 stack needs to be deployed)
-        error = output_proxy.options[:error]
-        expect(error).to include "stack needs to be deployed"
+  context "to_ruby" do
+    context "pull success" do
+      let(:state_path)   { "spec/fixtures/fetcher/c1.json" }
+      let(:pull_success) { true }
+
+      context "c1.length" do
+        let(:identifier) { "c1.length" }
+        it "fetched found attribute" do
+          expect(fetcher.output.to_ruby).to eq 1 # raw Integer
+        end
+      end
+
+      context "c1.complex" do
+        let(:identifier) { "c1.complex" }
+        it "fetched found attribute" do
+          expect(fetcher.output.to_ruby).to eq ["a","b"] # raw Array
+        end
+      end
+
+      context "c1.does-not-exist" do
+        let(:identifier) { "c1.does-not-exist" }
+        it "fetched missing output" do
+          output_proxy = fetcher.output
+          expect(output_proxy.raw).to be nil
+          value = output_proxy.to_ruby
+          # (Output length9 was not found for the b1 tfvars file. Either c1 stack has not been deployed yet or it does not have this output: length9)
+          expect(value).to include "not found"
+        end
+      end
+    end
+
+    context "pull fail" do
+      let(:state_path)   { nil }
+      let(:pull_success) { false }
+
+      context "stack needs to be deployed" do
+        let(:identifier) { "c1.length" }
+        it "fetched" do
+          output_proxy = fetcher.output
+          expect(output_proxy.raw).to be nil
+          # (Output length could not be looked up for the b1 tfvars file. c1 stack needs to be deployed)
+          value = output_proxy.to_s
+          expect(value).to include "stack needs to be deployed"
+        end
+      end
+
+      context "bucket does not exist" do
+        let(:identifier) { "c1.length" }
+        it "fetched" do
+          fetcher.bucket_not_found_error # fake it!
+          output_proxy = fetcher.output
+          expect(output_proxy.raw).to be nil
+          # (Output length could not be looked up for the b1 tfvars file. c1 stack needs to be deployed)
+          value = output_proxy.to_s
+          expect(value).to include "bucket for the backend could not be found"
+        end
       end
     end
   end