rake-terraform 0.0.8 → 0.2.0

data/spec/unit/basetask_spec.rb

@@ -0,0 +1,10 @@
+require 'rake-terraform/basetask'
+
+module RakeTerraform
+  describe BaseTask do
+    it 'should raise an ArgumentError with no arguments' do
+      expect { RakeTerraform::BaseTask.new }
+        .to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/unit/envprocess_spec.rb

@@ -0,0 +1,263 @@
+require 'spec_helper'
+require 'rake-terraform/env_process'
+
+module RakeTerraform
+  # envprocess unit tests
+  module EnvProcess
+    describe 'EnvProcess' do
+      before(:all) do
+        Dotenv.overload(
+          'spec/fixtures/set_all_variables_nil.env'
+        )
+      end
+      # load the environment into instance variables
+      describe 'initialize' do
+        # wrapper class for envprocess methods
+        let(:test_class) do
+          Class.new do
+            include RakeTerraform::EnvProcess
+            def initialize
+              super
+            end
+          end
+        end
+        # instance of test class
+        let(:test_class_inst) { test_class.new }
+        context 'When an instance var is set through an environment var' do
+          it 'should not change if the environment variable changes' do
+            Dotenv.overload(
+              'spec/fixtures/envprocess_uniq_state_false_file_valid.env'
+            ) do
+              expect(test_class_inst.unique_state).to eq(false)
+            end
+            Dotenv.overload(
+              'spec/fixtures/envprocess_uniq_state_true_file_valid.env'
+            ) do
+              expect(test_class_inst.unique_state).to eq(false)
+            end
+          end
+        end
+        context 'When unique state and TERRAFORM_STATE_FILE are provided ' \
+         'and valid' do
+          let(:state_file_str) { '/tmp/some_state.tfstate' }
+          Dotenv.overload(
+            'spec/fixtures/envprocess_uniq_state_true_file_valid.env'
+          ) do
+            it 'should set state_file to the expected string' do
+              expect(test_class_inst.state_file).to eq(state_file_str)
+            end
+            it 'should set state_dir_var to nil' do
+              expect(test_class_inst.state_dir_var).to eq(nil)
+            end
+            it 'should set state_dir to nil' do
+              expect(test_class_inst.state_dir).to eq(nil)
+            end
+          end
+        end
+
+        context 'When unique state and TERRAFORM_STATE_DIR_VAR are provided ' \
+         'and valid' do
+          let(:tf_state_dir_value) { 'terraform/state/staging' }
+          let(:tf_state_dir_var) { 'SOMETHING' }
+          let(:tf_state_file_path) do
+            "#{PROJECT_ROOT}/terraform/#{tf_state_dir_value}/terraform.tfstate"
+          end
+          Dotenv.overload(
+            'spec/fixtures/envprocess_uniq_state_dir_var_valid.env'
+          ) do
+            it 'should set state_file to the expected string' do
+              expect(test_class_inst.state_file).to eq(tf_state_file_path)
+            end
+            it 'should set state_dir_var to "SOMETHING"' do
+              expect(test_class_inst.state_dir_var).to eq(tf_state_dir_var)
+            end
+            it 'should set state_dir to state/staging' do
+              expect(test_class_inst.state_dir).to eq(tf_state_dir_value)
+            end
+          end
+        end
+      end
+
+      # this parent method calls a bunch of the other ones - certain amount of
+      # coverage from those methods contained here
+      describe 'tf_unique_state' do
+        # wrapper class for envprocess methods
+        let(:test_class) { Class.new { include RakeTerraform::EnvProcess } }
+        # instance of test class
+        let(:test_class_inst) { test_class.new }
+        context 'when TERRAFORM_UNIQUE_STATE var is false' do
+          it 'should return false' do
+            Dotenv.overload('spec/fixtures/envprocess_uniq_state_false.env')
+            expect(test_class_inst.tf_unique_state).to eq(false)
+          end
+        end
+        context 'when TERRAFORM_UNIQUE_STATE is true but dependent ' \
+          'variables are missing' do
+          it 'should raise ArgumentError when no other variables are given' do
+            Dotenv.overload('spec/fixtures/envprocess_uniq_state_true.env')
+            expect { test_class_inst.tf_unique_state }
+              .to raise_error(
+                ArgumentError,
+                /^Both or neither of TERRAFORM_STATE_FILE/
+              )
+          end
+          it 'should return an ArgumentError where the target for ' \
+            'TERRAFORM_STATE_DIR_VAR is missing' do
+            Dotenv.overload(
+              'spec/fixtures/envprocess_uniq_state_missing_dir_var.env'
+            )
+            expect { test_class_inst.tf_unique_state }
+              .to raise_error(
+                ArgumentError,
+                /^Both or neither of TERRAFORM_STATE_FILE/
+              )
+          end
+        end
+        context 'when TERRAFORM_UNIQUE_STATE is true but more than one' \
+          'optional variable is given' do
+          it 'should return an ArgumentError' do
+            Dotenv.overload('spec/fixtures/envprocess_uniq_state_true_both.env')
+            expect { test_class_inst.tf_unique_state }
+              .to raise_error(
+                ArgumentError,
+                /^Both or neither of TERRAFORM_STATE_FILE/
+              )
+          end
+        end
+        context 'when TERRAFORM_UNIQUE_STATE is true but dependent ' \
+          'variables are missing' do
+          it 'should return an ArgumentError' do
+            Dotenv.load('spec/fixtures/envprocess_uniq_state_true.env')
+            expect { test_class_inst.tf_unique_state }
+              .to raise_error(
+                ArgumentError,
+                /^Both or neither of TERRAFORM_STATE_FILE/
+              )
+          end
+        end
+      end
+
+      describe 'tf_state_file' do
+        # wrapper class for envprocess methods
+        let(:test_class) { Class.new { include RakeTerraform::EnvProcess } }
+        # instance of test class
+        let(:test_class_inst) { test_class.new }
+        let(:state_file_str) { '/tmp/some_state.tfstate' }
+        context 'when TERRAFORM_UNIQUE_STATE var is false but ' \
+          'TERRAFORM_STATE_FILE is given' do
+          it 'should still return the content of a valid var' do
+            Dotenv.overload(
+              'spec/fixtures/envprocess_uniq_state_false_file_valid.env'
+            )
+            expect(test_class_inst.tf_unique_state).to eq(false)
+            expect(test_class_inst.tf_state_file).to eq(state_file_str)
+          end
+        end
+        context 'when TERRAFORM_UNIQUE_STATE var is true and ' \
+          'TERRAFORM_STATE_FILE is given' do
+          it 'should return the content of a valid var' do
+            Dotenv.overload(
+              'spec/fixtures/envprocess_uniq_state_true_file_valid.env'
+            )
+            expect(test_class_inst.tf_unique_state).to eq(true)
+            expect(test_class_inst.tf_state_file).to eq(state_file_str)
+          end
+        end
+        context 'when TERRAFORM_STATE_FILE is _not_ given but ' \
+          'TERRAFORM_STATE_DIR_VAR and target variable are valid' do
+          let(:tf_state_dir_value) { 'terraform/state/staging' }
+          let(:tf_state_file_path) do
+            "#{PROJECT_ROOT}/#{tf_state_dir_value}/terraform.tfstate"
+          end
+          it 'should return the full path to the calculated state file' do
+            Dotenv.overload(
+              'spec/fixtures/envprocess_uniq_state_dir_var_valid.env'
+            )
+            expect(test_class_inst.tf_state_file).to eq(tf_state_file_path)
+          end
+        end
+        context 'when TERRAFORM_STATE_FILE is an invalid string' do
+          it 'should raise an ArgumentError' do
+            Dotenv.overload(
+              'spec/fixtures/envprocess_uniq_state_invalid_state_file_str.env'
+            )
+            expect { test_class_inst.tf_state_file }
+              .to raise_error(
+                ArgumentError,
+                /^Argument for TERRAFORM_STATE_FILE is invalid/
+              )
+          end
+        end
+      end
+
+      # see also: tf_state_dir for the content of the target var
+      describe 'tf_state_dir_var' do
+        # wrapper class for envprocess methods
+        let(:test_class) { Class.new { include RakeTerraform::EnvProcess } }
+        # instance of test class
+        let(:test_class_inst) { test_class.new }
+        context 'when TERRAFORM_STATE_DIR_VAR is an invalid string' do
+          it 'should raise an ArgumentError' do
+            Dotenv.overload(
+              'spec/fixtures/envprocess_uniq_state_dir_var_invalid.env'
+            )
+            expect { test_class_inst.tf_state_dir_var }
+              .to raise_error(
+                ArgumentError,
+                /^Argument for TERRAFORM_STATE_DIR_VAR is invalid/
+              )
+          end
+        end
+      end
+
+      describe 'tf_state_dir' do
+        # wrapper class for envprocess methods
+        let(:test_class) { Class.new { include RakeTerraform::EnvProcess } }
+        # instance of test class
+        let(:test_class_inst) { test_class.new }
+        let(:tf_state_dir_value) { 'terraform/state/staging' }
+        context 'when TERRAFORM_STATE_DIR_VAR points to a valid value' do
+          it 'should return the value ' do
+            Dotenv.overload(
+              'spec/fixtures/envprocess_uniq_state_dir_var_valid.env'
+            )
+            expect(test_class_inst.tf_state_dir).to eq(tf_state_dir_value)
+          end
+        end
+      end
+
+      describe 'state_dir_full_path' do
+        # wrapper class for envprocess methods
+        let(:test_class) { Class.new { prepend RakeTerraform::EnvProcess } }
+        let(:test_class_inst) { test_class.new }
+        # instance of test class
+        let(:tf_environment) { 'terraform/eu-west-1' }
+        let(:tf_state_dir_value) { 'state/staging' }
+        let(:tf_state_file_path) do
+          "#{PROJECT_ROOT}/terraform/#{tf_state_dir_value}/terraform.tfstate"
+        end
+        context 'when tf_environment is "state/staging"' do
+          it 'should return the full path to the state file' do
+            Dotenv.overload(
+              'spec/fixtures/envprocess_uniq_state_dir_var_valid.env'
+            )
+            expect(test_class_inst.state_dir_full_path)
+              .to eq(tf_state_file_path)
+          end
+        end
+      end
+
+      describe 'default_state_file_name' do
+        # wrapper class for envprocess methods
+        let(:test_class) { Class.new { include RakeTerraform::EnvProcess } }
+        # instance of test class
+        let(:test_class_inst) { test_class.new }
+        let(:default_state_file_name) { 'terraform.tfstate' }
+        it 'should return the value of the default state file name' do
+          expect(test_class_inst.default_state_file_name)
+            .to eq(default_state_file_name)
+        end
+      end
+    end
+  end
+end

data/spec/unit/plantask_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'rake-terraform/plantask'
+
+module RakeTerraform
+  module PlanTask
+    describe Config do
+      before(:all) do
+        Dotenv.overload(
+          'spec/fixtures/set_all_variables_nil.env'
+        )
+      end
+      let(:non_existent_input_dir) { "#{PROJECT_ROOT}/non/existent/input/dir" }
+      let(:non_existent_output_file) do
+        "#{PROJECT_ROOT}/non/existent/output/file.tf"
+      end
+      let(:default_input_dir_str) { "#{PROJECT_ROOT}/terraform" }
+      let(:default_aws_project_str) { 'default' }
+      let(:default_output_file_str) do
+        "#{PROJECT_ROOT}/output/terraform/plan.tf"
+      end
+      let(:default_credentials_str) { File.expand_path('~/.aws/credentials') }
+      let(:default_opts_hash) do
+        {
+          input_dir: default_input_dir_str,
+          output_file: default_output_file_str,
+          credentials: default_credentials_str,
+          aws_project: default_aws_project_str,
+          unique_state: false,
+          state_file: nil
+        }
+      end
+
+      before(:each) do
+        # reset default config object before each test
+        @default_config = RakeTerraform::PlanTask::Config.new
+      end
+
+      it 'should initialize successfully with no arguments' do
+        expect { RakeTerraform::PlanTask::Config.new }.to_not raise_error
+      end
+
+      describe 'opts' do
+        Dotenv.overload(
+          'spec/fixtures/set_all_variables_nil.env'
+        ) do
+          context 'with a default config object' do
+            it 'should return the expected default keys and values' do
+              default_opts_hash.keys.each do |key|
+                expect(@default_config.opts).to have_key(key)
+                expect(@default_config.opts[key]).to eq(default_opts_hash[key])
+              end
+            end
+
+            it 'should reflect new values when the config object is updated' do
+              @default_config.input_dir = non_existent_input_dir
+              @default_config.output_file = non_existent_output_file
+              expect(@default_config.opts[:input_dir])
+                .to eq(non_existent_input_dir)
+              expect(@default_config.opts[:output_file])
+                .to eq(non_existent_output_file)
+            end
+          end
+        end
+      end
+
+      describe 'input_dir' do
+        after(:all) do
+          Dotenv.overload(
+            'spec/fixtures/set_all_variables_nil.env'
+          )
+        end
+        let(:tf_environment) { 'terraform/eu-west-1' }
+        let(:tf_state_dir_value) { "#{tf_environment}/state/staging" }
+        let(:tf_state_file_path) do
+          "#{PROJECT_ROOT}/#{tf_state_dir_value}/terraform.tfstate"
+        end
+        context 'with a default config object' do
+          it 'should set the input_dir to PROJECT_ROOT/terraform' do
+            expect(@default_config.input_dir).to eq(default_input_dir_str)
+            expect(@default_config.tf_environment).to eq(nil)
+            expect(@default_config.state_file).to eq(nil)
+          end
+        end
+        context 'when I set the input_dir to something else and state_dir ' \
+          'is true' do
+          Dotenv.overload(
+            'spec/fixtures/envprocess_uniq_state_dir_var_valid.env'
+          ) do
+            it 'should update input_dir, tf_environment and state_file' do
+              @default_config.input_dir = tf_environment
+              expect(@default_config.tf_environment).to eq(tf_environment)
+              expect(@default_config.state_file).to eq(tf_state_file_path)
+            end
+          end
+        end
+        context 'when I set the input_dir to something else and state_dir ' \
+          'is false' do
+          Dotenv.overload(
+            'spec/fixtures/envprocess_uniq_state_true_file_valid.env'
+          ) do
+            it 'should update input_dir, tf_environment but _not_ state_file' do
+              @default_config.input_dir = tf_environment
+              expect(@default_config.tf_environment).to eq(tf_environment)
+              expect(@default_config.state_file).to eq(nil)
+            end
+          end
+        end
+      end
+    end
+
+    describe Task do
+      it 'should raise an ArgumentError with no arguments' do
+        expect { RakeTerraform::PlanTask::Task.new }
+          .to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/unit/terraformcmd_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+require 'rake-terraform/terraformcmd'
+
+module RakeTerraform
+  # mock kernel calls to terraform binary
+  module TerraformCmd
+    describe 'TerraformCmd' do
+      # wrapper class for terraformcmd methods
+      let(:test_class) { Class.new { include RakeTerraform::TerraformCmd } }
+      # instance of test class
+      let(:test_class_inst) { test_class.new }
+      before(:all) do
+        Dotenv.overload(
+          'spec/fixtures/set_all_variables_nil.env'
+        )
+      end
+
+      describe 'tf_get' do
+        let(:get_cmd) { 'terraform get' }
+        let(:get_up_cmd) { 'terraform get -update' }
+        context 'with no arguments' do
+          it 'should call terraform get' do
+            expect(test_class_inst).to receive(:system)
+              .with(get_cmd)
+            test_class_inst.tf_get
+          end
+        end
+        context 'with update=true' do
+          it 'should call terraform get -update' do
+            expect(test_class_inst).to receive(:system)
+              .with(get_up_cmd)
+            test_class_inst.tf_get(true)
+          end
+        end
+      end
+
+      describe 'tf_plan' do
+        let(:default_plan_cmd) { 'terraform plan -module-depth 2' }
+        let(:default_output_file) { "#{PROJECT_ROOT}/output/terraform/plan.tf" }
+        let(:cred_plan_cmd) do
+          "terraform plan -module-depth 2 -var access_key=\"#{access_key}\"" \
+            " -var secret_key=\"#{secret_key}\""
+        end
+        let(:output_plan_cmd) do
+          "terraform plan -module-depth 2 -out #{default_output_file}"
+        end
+        let(:module_arg_cmd) { 'terraform plan -module-depth 56' }
+        let(:module_arg) { 56 }
+        let(:access_key) { 'BISFITPONHYWERBENTEIN' }
+        let(:secret_key) { 'trujRepGidjurivGomAyctyeOpVuWiuvafeeshjuo' }
+        let(:state_file) do
+          "#{PROJECT_ROOT}/terraform/test_env/state_1.tfstate"
+        end
+        let(:state_file_cmd) do
+          "terraform plan -module-depth 2 -state #{state_file}"
+        end
+        context 'with no arguments' do
+          it 'should call terraform plan' do
+            expect(test_class_inst).to receive(:system)
+              .with(default_plan_cmd)
+            test_class_inst.tf_plan
+          end
+        end
+        context 'with just an access_key' do
+          it 'should raise an ArgumentError' do
+            expect { test_class_inst.tf_plan(access_key) }
+              .to raise_error(ArgumentError,
+                              'Only one of access_key or secret_key given')
+          end
+        end
+        context 'with just a secret_key' do
+          it 'should raise an ArgumentError' do
+            expect { test_class_inst.tf_plan(nil, secret_key) }
+              .to raise_error(ArgumentError,
+                              'Only one of access_key or secret_key given')
+          end
+        end
+        context 'with both an access_key and a secret_key' do
+          it 'should call terraform plan with those vars configured' do
+            expect(test_class_inst).to receive(:system)
+              .with(cred_plan_cmd)
+            test_class_inst.tf_plan(access_key, secret_key)
+          end
+        end
+        context 'with an output file' do
+          it 'should call terraform plan with an output file' do
+            expect(test_class_inst).to receive(:system)
+              .with(output_plan_cmd)
+            test_class_inst.tf_plan(nil, nil, default_output_file)
+          end
+        end
+        context 'with an state file' do
+          it 'should call terraform plan with a state file' do
+            expect(test_class_inst).to receive(:system)
+              .with(state_file_cmd)
+            test_class_inst.tf_plan(nil, nil, nil, state_file)
+          end
+        end
+        context 'where module_depth is given as an argument' do
+          it 'should call terraform plan with updated module-depth argument' do
+            expect(test_class_inst).to receive(:system)
+              .with(module_arg_cmd)
+            test_class_inst.tf_plan(nil, nil, nil, nil, module_arg)
+          end
+        end
+      end
+
+      describe 'tf_show' do
+        let(:default_plan_file) { "#{PROJECT_ROOT}/output/terraform/plan.tf" }
+        let(:default_show_cmd) do
+          "terraform show -module-depth 2 #{default_plan_file}"
+        end
+        let(:module_arg_cmd) do
+          "terraform show -module-depth 56 #{default_plan_file}"
+        end
+        let(:module_arg) { 56 }
+        context 'with no arguments' do
+          it 'should raise an ArgumentError' do
+            expect { test_class_inst.tf_show }
+              .to raise_error(ArgumentError)
+          end
+        end
+        context 'with a plan file argument' do
+          it 'should call terraform show with the plan file' do
+            expect(test_class_inst).to receive(:system)
+              .with(default_show_cmd)
+            test_class_inst.tf_show(default_plan_file)
+          end
+        end
+        context 'where module_depth is given as an argument' do
+          it 'should call terraform show with updated module-depth argument' do
+            expect(test_class_inst).to receive(:system)
+              .with(module_arg_cmd)
+            test_class_inst.tf_show(default_plan_file, module_arg)
+          end
+        end
+      end
+
+      describe 'tf_apply' do
+        let(:default_plan_file) { "#{PROJECT_ROOT}/output/terraform/plan.tf" }
+        let(:default_apply_cmd) do
+          "terraform apply #{default_plan_file}"
+        end
+        let(:state_file) do
+          "#{PROJECT_ROOT}/terraform/test_env/state_1.tfstate"
+        end
+        let(:state_file_cmd) do
+          'terraform apply -state ' \
+            "#{state_file} #{default_plan_file}"
+        end
+        context 'with no arguments' do
+          it 'should raise an ArgumentError' do
+            expect { test_class_inst.tf_apply }
+              .to raise_error(ArgumentError)
+          end
+        end
+        context 'with a plan file argument' do
+          it 'should call terraform apply with the plan file' do
+            expect(test_class_inst).to receive(:system)
+              .with(default_apply_cmd)
+            test_class_inst.tf_apply(default_plan_file)
+          end
+        end
+        context 'where state file is given as an argument' do
+          it 'should call terraform apply with a state file argument' do
+            expect(test_class_inst).to receive(:system)
+              .with(state_file_cmd)
+            test_class_inst.tf_apply(default_plan_file, state_file)
+          end
+        end
+      end
+    end
+  end
+end