capistrano-template 0.0.1

data/lib/capistrano/template/tasks/template_defaults.cap

@@ -0,0 +1,13 @@
+namespace :load do
+  task :defaults do
+    set :templating_digster, ->{ ->(data){ Digest::MD5.hexdigest(data)} }
+    set :templating_digest_cmd, %Q{test "Z$(openssl md5 %<path>s| sed "s/^.*= *//")" = "Z%<digest>s" } # alternative %Q{echo "%<digest>s %<path>s" | md5sum -c --status }  should return true when the file content is the same
+    set :templating_mode_test_cmd, %Q{ [ "Z$(printf "%%.4o" 0$(stat -c "%%a" %<path>s 2>/dev/null ||  stat -f "%%A" %<path>s))" != "Z%<mode>s" ] } # mac uses different mode formatter
+    set :templating_paths , ->{ ["config/deploy/templates/#{fetch(:stage)}/%<host>s",
+                                 "config/deploy/templates/#{fetch(:stage)}",
+                                 "config/deploy/templates/shared/%<host>s",
+                                 "config/deploy/templates/shared"].map {|partial_path| (partial_path)} }
+  end
+end
+
+

data/lib/capistrano/template/version.rb

@@ -0,0 +1,5 @@
+module Capistrano
+  module Template
+    VERSION = '0.0.1'
+  end
+end

data/spec/integration/capistrano/template/helpers/dsl_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+module Capistrano
+  module Template
+    module Helpers
+      module Integration # prodect from other dummy classes
+        module DSLSpec
+          class Dummy
+            include DSL
+            attr_accessor :data, :release_path
+
+            def initialize
+              self.data = {
+                templating_digster: ->(data) { Digest::MD5.hexdigest(data) },
+                templating_digest_cmd: %Q(echo "%<digest>s %<path>s" | md5sum -c --status ),
+                templating_mode_test_cmd: %Q{ [ "Z$(printf "%%.4o" 0$(stat -c "%%a" %<path>s 2>/dev/null ||  stat -f "%%A" %<path>s))" != "Z%<mode>s" ] }
+              }
+            end
+
+            # custom methods
+            def var1
+              'my'
+            end
+
+            def var2
+              'content'
+            end
+
+            # capistrano method
+            def fetch(*args)
+              data.fetch(*args)
+            end
+
+            # sshkit metthods
+
+            def host
+              'localhost'
+            end
+
+            def test(*args)
+              execute(*args)
+            end
+
+            def execute(*args)
+              system(*args)
+            end
+
+            def upload!(io, filename)
+              File.write(filename, io.read, mode: 'w')
+            end
+
+            def capture(cmd)
+              `#{cmd}`
+            end
+
+            def info(*)
+            end
+
+            def error(*)
+            end
+          end
+        end
+      end
+
+      describe DSL do
+        subject do
+          Integration::DSLSpec::Dummy.new.tap do |d|
+            d.data[:templating_paths] = [tmp_folder]
+            d.release_path = tmp_folder
+          end
+        end
+
+        let(:template_name) { 'my_template.erb' }
+
+        let(:tmp_folder) { File.join(__dir__, '..', '..', '..', 'tmp') }
+
+        let(:template_content) { '<%=var1%> -- <%=var2%>' }
+        let(:expected_content) { 'my -- content' }
+
+        let(:template_name) { 'my_template.erb' }
+        let(:template_fullname) { File.join(tmp_folder, template_name) }
+        let(:remote_filename) { File.join(tmp_folder, 'my_template') }
+
+        let(:digest_algo) { ->(data) { Digest::MD5.hexdigest(data) } }
+        let(:digest_cmd) { %Q{test "Z$(openssl md5 %<path>s| sed "s/^.*= *//")" = "Z%<digest>s" } }
+
+        let(:mode_test_cmd) do
+          %Q{ [ "Z$(printf "%%.4o" 0$(stat -c "%%a" %<path>s 2>/dev/null ||  stat -f "%%A" %<path>s))" != "Z%<mode>s" ] }
+        end
+
+        before :each do
+          Dir.mkdir(tmp_folder) unless Dir.exist? tmp_folder
+          File.write(template_fullname, template_content, mode: 'w')
+        end
+
+        after :each do
+          [
+            template_fullname,
+            remote_filename
+          ].each do |f|
+            system('rm', '-f', f) if File.exist? f
+          end
+        end
+
+        describe '#template' do
+
+          it 'create the result file' do
+            subject.template(template_name)
+
+            expect(File.read(remote_filename)).to eq(expected_content)
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/integration/capistrano/template/helpers/paths_lookup_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Capistrano
+  module Template
+    module Helpers
+      describe PathsLookup do
+        subject do
+          PathsLookup.new(lookup_paths, context)
+        end
+
+        let(:tmp_folder) { File.join(__dir__, '..', '..', '..', 'tmp') }
+
+        let(:lookup_paths) { ["#{tmp_folder}/%<host>s", "#{tmp_folder}"] }
+        let(:context) { OpenStruct.new(host: 'localhost') }
+
+        let(:template_content) { '<%=var1%> -- <%=var2%>' }
+        let(:template_name) { 'my_template.erb' }
+        let(:template_fullname) { File.join(tmp_folder, template_name) }
+
+        before :each do
+          Dir.mkdir(tmp_folder) unless Dir.exist? tmp_folder
+          File.write(template_fullname, template_content, mode: 'w')
+        end
+
+        after :each do
+          if File.exist? template_fullname
+            system('rm', '-f', File.join(tmp_folder, template_fullname))
+          end
+        end
+
+        describe '#template_exists?' do
+
+          it 'returns true when a template file exists' do
+            expect(subject.template_exists?(template_name)).to be_truthy
+          end
+
+          it 'returns false when a template does not file exists' do
+            expect(subject.template_exists?("#{template_name}.not_exists")).to be_falsy
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/spec/integration/capistrano/template/helpers/uploader_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module Capistrano
+  module Template
+    module Helpers
+      describe Uploader do
+
+        before :each do
+          Dir.mkdir(tmp_folder) unless Dir.exist? tmp_folder
+        end
+
+        after :each do
+          system('rm', '-f', remote_filename) if File.exist? remote_filename
+        end
+
+        subject do
+          Uploader.new(
+              remote_filename,
+              context,
+              mode: 0640,
+              mode_test_cmd: mode_test_cmd,
+              digest: digest,
+              digest_cmd: digest_cmd,
+              io: as_io
+          )
+        end
+
+        let(:context) do
+          Struct.new(:host).new.tap do |cont|
+            cont.host = 'localhost'
+
+            allow(cont).to receive(:info)
+            allow(cont).to receive(:error)
+
+            def cont.test(*args)
+              system(*args)
+            end
+
+            def cont.execute(*args)
+              system(*args)
+            end
+
+            def cont.upload!(io, filename)
+              File.write(filename, io.read, mode: 'w')
+            end
+
+          end
+
+        end
+
+        let(:tmp_folder) { File.join(__dir__, '..', '..', '..', 'tmp') }
+
+        let(:rendered_template_content) { 'my -- content' }
+        let(:as_io) { StringIO.new(rendered_template_content) }
+
+        let(:remote_filename) { File.join(tmp_folder, 'my_template') }
+
+        let(:digest) { Digest::MD5.hexdigest(rendered_template_content) }
+        let(:digest_cmd) { %Q{test "Z$(openssl md5 %<path>s| sed "s/^.*= *//")" = "Z%<digest>s" } }
+
+        let(:mode_test_cmd) do
+          %Q{ [ "Z$(printf "%%.4o" 0$(stat -c "%%a" %<path>s 2>/dev/null ||  stat -f "%%A" %<path>s))" != "Z%<mode>s" ] }
+        end
+
+        describe '#call' do
+
+          it 'uploads a template when content has changed' do
+            subject.call
+            expect(File.exist?(remote_filename)).to be_truthy
+          end
+
+          it 'does not upload a template when content is equal' do
+            File.write(remote_filename, rendered_template_content, mode: 'w')
+
+            expect(context).not_to receive(:upload!)
+            subject.call
+          end
+
+          it 'evals the erb' do
+            subject.call
+            expect(File.read(remote_filename)).to eq(rendered_template_content)
+          end
+
+          it 'sets permissions' do
+            File.write(remote_filename, rendered_template_content, mode: 'w')
+            File.chmod(0400, remote_filename)
+
+            subject.call
+
+            mode = File.stat(remote_filename).mode & 0xFFF
+
+            expect(mode).to eq(0640)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'bundler/setup'
+Bundler.require(:development)
+
+require 'coveralls'
+Coveralls.wear! unless ENV['SIMPLE_COVERAGE']
+
+begin
+  if ENV['SIMPLE_COVERAGE']
+    require 'simplecov'
+    SimpleCov.start do
+      add_group 'Lib', 'lib'
+
+      add_filter '/spec/'
+    end
+  end
+rescue LoadError
+  warn '=' * 80
+  warn 'simplecov not installed. No coverage report'
+  warn '=' * 80
+end
+
+require 'capistrano/template'
+
+Dir[File.join(File.expand_path(__dir__), 'support/**/*.rb')].each { |f| require f }
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/unit/capistrano/template/helpers/dsl_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module Capistrano
+  module Template
+    module Helpers
+      module Unit # prodect from other dummy classes
+        module DSLSpec
+          class Dummy
+            include DSL
+            attr_accessor :data, :file_exists
+
+            def initialize
+              self.file_exists = true
+              self.data = {
+                templating_paths: ['/tmp'],
+              }
+            end
+
+            def host
+              'localhost'
+            end
+
+            def release_path
+              '/var/www/app/releases/20140510'
+            end
+
+            def fetch(*args)
+              data.fetch(*args)
+            end
+
+            def _paths_factory
+              lambda do |*args|
+                PathsLookup.new(*args).tap do |pl|
+                  def pl.existence_check(*)
+                    file_exists
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      describe DSL do
+        subject do
+          Unit::DSLSpec::Dummy.new
+        end
+
+        let(:template_name) { 'my_template.erb' }
+
+        describe '#template' do
+          it 'raises an exception when template does not exists' do
+            subject.file_exists = false
+            expect { subject.template(template_name) }.to raise_error(ArgumentError, /template #{template_name} not found Paths/)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/capistrano/template/helpers/paths_lookup_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module Capistrano
+  module Template
+    module Helpers
+      describe PathsLookup do
+        subject do
+          PathsLookup.new(lookup_paths, context)
+        end
+
+        let(:lookup_paths) { ['path1/%<host>s', 'path2'] }
+        let(:context) { OpenStruct.new(host: 'localhost') }
+        let(:template_name) { 'my_template' }
+
+        describe '#template_exists?' do
+
+          it 'returns true when a template file exists' do
+            subject.stub(existence_check: true)
+            expect(subject.template_exists?(template_name)).to be_truthy
+          end
+
+          it 'returns false when a template does not file exists' do
+            subject.stub(existence_check: false)
+            expect(subject.template_exists?(template_name)).to be_falsy
+          end
+
+          it 'checks for every possible path existence' do
+            expect(subject).to receive(:existence_check).exactly(lookup_paths.count * 2).times
+            subject.template_exists?(template_name)
+          end
+
+          it 'stops search for first hit' do
+            expect(subject).to receive(:existence_check).exactly(2).times.and_return(false, true)
+            subject.template_exists?(template_name)
+          end
+
+        end
+
+        describe '#template_file' do
+          it 'returns the first found filename' do
+            allow(subject).to receive(:existence_check).and_return(false, false, true)
+            expect(subject.template_file(template_name)).to eq('path2/my_template.erb')
+          end
+
+          it 'expends the host' do
+            allow(subject).to receive(:existence_check).and_return(true)
+            expect(subject.template_file(template_name)).to eq('path1/localhost/my_template.erb')
+          end
+        end
+
+      end
+    end
+  end
+end