terrafile 0.1.1

data/lib/terrafile/errors.rb

@@ -0,0 +1,3 @@
+module Terrafile
+  class Error < RuntimeError; end
+end

data/lib/terrafile/helper.rb

@@ -0,0 +1,50 @@
+module Terrafile
+  module Helper
+    def self.run!(command)
+      begin
+        _stdout, stderr, status = Open3.capture3(command)
+      rescue Errno::ENOENT => error
+        raise Error, "'#{command}' failed (#{error})"
+      end
+
+      unless status.success?
+        raise Error, "'#{command}' failed with exit code #{status.exitstatus} " \
+                        "(#{stderr.chomp})"
+      end
+
+      true
+    end
+
+    def self.run_with_output(command)
+      begin
+        stdout, _stderr, _status = Open3.capture3(command)
+      rescue Errno::ENOENT => error
+        raise Error, "'#{command}' failed (#{error})"
+      end
+
+      stdout.chomp
+    end
+
+    def self.clone(source, destination)
+      run!("git clone --depth 1 #{source} #{destination} &> /dev/null")
+    end
+
+    def self.dir_exists?(path)
+      Dir.exist?(path)
+    end
+
+    def self.file_exists?(path)
+      File.exist?(path)
+    end
+
+    def self.repo_up_to_date?(version)
+      current_tag = run_with_output('git describe --tags').tr("\n", '')
+      current_hash = run_with_output('git rev-parse HEAD').tr("\n", '')
+      [current_tag, current_hash].include? version
+    end
+
+    def self.pull_repo
+      run!('git pull &> /dev/null')
+    end
+  end
+end

data/lib/terrafile/installer.rb

@@ -0,0 +1,47 @@
+module Terrafile
+  class Installer
+    MODULES_PATH = 'vendor/terraform_modules'.freeze
+
+    def initialize
+      @dependencies = read_terrafile
+    end
+
+    def call
+      create_modules_directory_if_needed
+      checkout_modules
+    end
+
+    private
+
+    attr_reader :dependencies
+
+    def read_terrafile
+      return built_dependencies if Helper.file_exists?(TERRAFILE_PATH)
+
+      Kernel.puts '[*] Terrafile does not exist'
+      Kernel.exit 1
+    end
+
+    def built_dependencies
+      Dependency.build_from_terrafile
+    end
+
+    def checkout_modules
+      Dir.chdir(Installer::MODULES_PATH) do
+        dependencies.each do |dependency|
+          msg = "Checking out #{dependency.version} from #{dependency.source}"
+          Kernel.puts msg
+          dependency.fetch
+          dependency.checkout
+        end
+      end
+    end
+
+    def create_modules_directory_if_needed
+      return if Helper.dir_exists?(MODULES_PATH)
+
+      Kernel.puts "[*] Creating Terraform modules directory at '#{MODULES_PATH}'"
+      FileUtils.makedirs MODULES_PATH
+    end
+  end
+end

data/lib/terrafile/version.rb

@@ -0,0 +1,3 @@
+module Terrafile
+  VERSION = '0.1.1'.freeze
+end

data/spec/integration/runs_terrafile_executable_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../spec_helper'
+
+module Terrafile
+  RSpec.describe 'CLI runs terrafile executable', type: :aruba do
+    context 'when no Terrafile is found' do
+      let(:file)    { 'Bananafile' }
+      let(:content) { 'Something else entirely' }
+      let(:output)  { 'Terrafile does not exist' }
+
+      before(:each) { write_file file, content }
+      before(:each) { run('terrafile') }
+
+      it 'prints out an error message' do
+        expect(last_command_started).to have_output(/#{output}/)
+      end
+
+      it 'exits non-zero' do
+        expect(last_command_started).not_to have_exit_status(0)
+      end
+    end
+
+    context 'when a Terrafile IS found' do
+      let(:file)    { 'Terrafile' }
+      let(:content) do
+        <<~YML
+          terraform-aws-module1:
+            source: "git@github.com:org1/repo1.git"
+            version: "0.8.0"
+
+          terraform-aws-module2:
+            source: "git@github.com:org2/repo2.git"
+            version: "004e5791c2ef816578420fb6695e4009a838c863"
+        YML
+      end
+      let(:notice)  { 'Creating Terraform modules directory' }
+
+      before(:each) { write_file file, content }
+      before(:each) { run('terrafile') }
+
+      context 'and the modules directory does not yet exist' do
+        it 'prints out its intention to create that directory' do
+          expect(last_command_started).to have_output(/#{notice}/)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'simplecov'
+SimpleCov.start do
+  minimum_coverage 100
+end
+require 'bundler/setup'
+require 'aruba/rspec'
+require 'terrafile'
+# require 'pry'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/terrafile_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe Terrafile do
+  it 'has a version number' do
+    expect(Terrafile::VERSION).not_to be nil
+  end
+end

data/spec/unit/dependency_spec.rb

@@ -0,0 +1,152 @@
+require_relative '../spec_helper'
+
+module Terrafile
+  RSpec.describe Dependency do
+    describe 'class methods' do
+      describe '::build_from_terrafile' do
+        before do
+          modules = {
+            'terraform-aws-name1' => {
+              'source' => 'git@github.com:org1/repo1',
+              'version' => '0.8.0',
+            },
+            'terraform-aws-name2' => {
+              'source' => 'git@github.com:org2/repo2',
+              'version' => '004e5791',
+            },
+          }
+          allow(File).to receive(:read).and_return(double)
+          allow(YAML).to receive(:safe_load).and_return(modules)
+        end
+
+        it 'instantiates a dependency for each module listed in the Terrafile' do
+          allow(Dependency).to receive(:new)
+
+          Dependency.build_from_terrafile
+
+          expect(Dependency).to have_received(:new).with(
+            name: 'terraform-aws-name1',
+            source: 'git@github.com:org1/repo1',
+            version: '0.8.0'
+          )
+
+          expect(Dependency).to have_received(:new).with(
+            name: 'terraform-aws-name2',
+            source: 'git@github.com:org2/repo2',
+            version: '004e5791'
+          )
+        end
+
+        it 'returns a list of dependencies' do
+          expect(Dependency.build_from_terrafile.size).to eq(2)
+        end
+      end
+    end
+
+    describe 'instance methods' do
+      describe '#fetch' do
+        let(:dependency) do
+          Dependency.new(
+            name:    'terraform-of-mine',
+            version: '1.2.3',
+            source:  'git@github.com:org1/repo1'
+          )
+        end
+
+        before do
+          allow(Dir).to receive(:chdir).and_yield
+          allow(Helper).to receive(:clone)
+          allow(Helper).to receive(:repo_up_to_date?)
+          allow(Helper).to receive(:pull_repo)
+        end
+
+        context 'if a sub-directory named for the dependency already exists' do
+          before do
+            allow(Helper).to receive(:dir_exists?)
+              .with('terraform-of-mine').and_return(true)
+          end
+
+          it 'does not re-clone the module' do
+            dependency.fetch
+
+            expect(Helper).not_to have_received(:clone)
+              .with('git@github.com:org1/repo1', 'terraform-aws-name1')
+          end
+
+          it 'changes into the sub-directory for that dependency' do
+            dependency.fetch
+
+            expect(Dir).to have_received(:chdir).with('terraform-of-mine')
+          end
+
+          it 'tests whether the repo is out of date' do
+            dependency.fetch
+
+            expect(Helper).to have_received(:repo_up_to_date?).with('1.2.3')
+          end
+
+          context 'if the module needs to be updated' do
+            before do
+              allow(Helper).to receive(:repo_up_to_date?).and_return(false)
+            end
+
+            it 'pulls the latest revision down' do
+              dependency.fetch
+
+              expect(Helper).to have_received(:pull_repo)
+            end
+          end
+
+          context 'if the module is up-to-date' do
+            before do
+              allow(Helper).to receive(:repo_up_to_date?).and_return(true)
+            end
+
+            it 'does not attempt to pull fresh revisions' do
+              dependency.fetch
+
+              expect(Helper).not_to have_received(:pull_repo)
+            end
+          end
+        end
+
+        context 'if a sub-directory named for the dependency DOES NOT already exists' do
+          before do
+            allow(Helper).to receive(:dir_exists?)
+              .with('terraform-of-mine').and_return(false)
+          end
+
+          it 'does clone the module' do
+            dependency.fetch
+
+            expect(Helper).to have_received(:clone)
+              .with('git@github.com:org1/repo1', 'terraform-of-mine')
+          end
+        end
+      end
+
+      describe '#checkout' do
+        let(:dependency) do
+          Dependency.new(name: 'terraform-of-mine', version: '1.2.3', source: double)
+        end
+
+        before do
+          allow(Dir).to receive(:chdir).and_yield
+          allow(Helper).to receive(:run!)
+        end
+
+        it 'changes to the given dependency\'s directory' do
+          dependency.checkout
+
+          expect(Dir).to have_received(:chdir).with('terraform-of-mine')
+        end
+
+        it 'checks out the right version of that dependency, suppressing output' do
+          dependency.checkout
+
+          expect(Helper).to have_received(:run!).with('git checkout 1.2.3 &> /dev/null')
+        end
+      end
+    end
+  end
+end

data/spec/unit/helper_spec.rb

@@ -0,0 +1,182 @@
+require_relative '../spec_helper'
+
+module Terrafile
+  RSpec.describe Helper do
+    describe '::run!' do
+      it 'passes given cmd to Open3.capture3' do
+        stdout = double
+        stderr = double
+        status = double(success?: true)
+        allow(Open3).to receive(:capture3).and_return([stdout, stderr, status])
+
+        Helper.run!('git clone foo')
+
+        expect(Open3).to have_received(:capture3).with('git clone foo')
+      end
+
+      context 'when the system call return a zero exit status' do
+        let(:zero_result) do
+          stdout = "45bca5861c0c7e4defe0702e8f4d3e1f255fe96b\n"
+          stderr = ''
+          status = double(exitstatus: 1, success?: true)
+          [stdout, stderr, status]
+        end
+
+        it 'returns true' do
+          allow(Open3).to receive(:capture3).and_return(zero_result)
+
+          expect(Helper.run!('git rev-parse HEAD')).to be true
+        end
+      end
+
+      context 'when the system call returns a non-zero exit status' do
+        let(:non_zero_result) do
+          stdout = ''
+          stderr = "fatal: repository 'bar' does not exist\n"
+          status = double(exitstatus: 128, success?: false)
+          [stdout, stderr, status]
+        end
+
+        it 'raises a helpful Terrafile::Error' do
+          allow(Open3).to receive(:capture3).and_return(non_zero_result)
+          msg = "'git clone bar' failed with exit code 128 " \
+                  "(fatal: repository 'bar' does not exist)"
+
+          expect { Helper.run!('git clone bar') }
+            .to raise_error(Terrafile::Error, msg)
+        end
+      end
+
+      context 'when the system call raises an ENOENT error' do
+        it 'catches this and raises a helpful Terrafile::Error' do
+          allow(Open3).to receive(:capture3).and_raise(Errno::ENOENT, 'rubbish')
+
+          msg = "'rubbish' failed (No such file or directory - rubbish)"
+
+          expect { Helper.run!('rubbish') }.to raise_error(Terrafile::Error, msg)
+        end
+      end
+    end
+
+    describe '::run_with_output(cmd)' do
+      it 'passes given cmd to Open3.capture3' do
+        stdout = double(chomp: '')
+        stderr = double
+        status = double(success?: true)
+        allow(Open3).to receive(:capture3).and_return([stdout, stderr, status])
+
+        Helper.run_with_output('git describe --tags')
+
+        expect(Open3).to have_received(:capture3).with('git describe --tags')
+      end
+
+      context 'when the system call returns a zero exit status' do
+        let(:zero_result) do
+          stdout = "1.1.2\n"
+          stderr = ''
+          status = double(exitstatus: 1, success?: true)
+          [stdout, stderr, status]
+        end
+
+        it 'returns the systems output to STDOUT' do
+          allow(Open3).to receive(:capture3).and_return(zero_result)
+
+          expect(Helper.run_with_output('git describe --tags')).to eq('1.1.2')
+        end
+      end
+
+      context 'when the system call returns a non-zero exit status' do
+        let(:non_zero_result) do
+          stdout = ''
+          stderr = "fatal: No names found, cannot describe anything.\n"
+          status = double(exitstatus: 128, success?: false)
+          [stdout, stderr, status]
+        end
+
+        it 'also returns STDOUT ignoring the exit code and STDERR' do
+          allow(Open3).to receive(:capture3).and_return(non_zero_result)
+
+          expect(Helper.run_with_output('git describe --tags')).to eq('')
+        end
+      end
+
+      context 'when the system call raises an ENOENT error' do
+        it 'catches this and raises a helpful Terrafile::Error' do
+          allow(Open3).to receive(:capture3).and_raise(Errno::ENOENT, 'rubbish')
+
+          msg = "'rubbish' failed (No such file or directory - rubbish)"
+
+          expect { Helper.run_with_output('rubbish') }.to raise_error(Terrafile::Error, msg)
+        end
+      end
+    end
+
+    describe '::clone(source, destination)' do
+      it 'checks out the given revision using run!' do
+        allow(Helper).to receive(:run!)
+        source = 'git@github.com:org1/repo1'
+        destination = 'terraform-aws-name1'
+
+        Helper.clone(source, destination)
+
+        expect(Helper).to have_received(:run!)
+          .with("git clone --depth 1 #{source} #{destination} &> /dev/null")
+      end
+    end
+
+    describe '::repo_up_to_date?(version)' do
+      before { allow(Helper).to receive(:run_with_output).and_return('') }
+
+      it 'gets a list of any tags at the current revision' do
+        Helper.repo_up_to_date?(double)
+
+        expect(Helper).to have_received(:run_with_output)
+          .with('git describe --tags')
+      end
+
+      it 'gets the SHA of the current revision' do
+        Helper.repo_up_to_date?(double)
+
+        expect(Helper).to have_received(:run_with_output)
+          .with('git rev-parse HEAD')
+      end
+
+      describe 'determining if the repo is up to date' do
+        it 'returns true if the given version matches a tag' do
+          allow(Helper).to receive(:run_with_output)
+            .with('git describe --tags').and_return('0.1.0')
+
+          expect(Helper.repo_up_to_date?('0.1.0')).to be true
+          expect(Helper.repo_up_to_date?('0.1.1')).to be false
+        end
+
+        it 'returns true if the given version matches the SHA' do
+          allow(Helper).to receive(:run_with_output)
+            .with('git rev-parse HEAD').and_return('abc123')
+
+          expect(Helper.repo_up_to_date?('abc123')).to be true
+          expect(Helper.repo_up_to_date?('bcd321')).to be false
+        end
+
+        it 'returns false if the given version matches neither a tag nor the SHA' do
+          allow(Helper).to receive(:run_with_output)
+            .with('git describe --tags').and_return('0.1.0')
+          allow(Helper).to receive(:run_with_output)
+            .with('git rev-parse HEAD').and_return('abc123')
+
+          expect(Helper.repo_up_to_date?('bananas')).to be false
+        end
+      end
+    end
+
+    describe '::pull_repo' do
+      it 'pulls the latest code without generating any output' do
+        allow(Helper).to receive(:run!)
+
+        Helper.pull_repo
+
+        expect(Helper).to have_received(:run!).with('git pull &> /dev/null')
+      end
+    end
+  end
+end