puppet-armature 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0a8b80f2d44ce34400277ea4760820da4e6fd66
-  data.tar.gz: 2857d139910bfb9e29700ec61a318f5162ce64a5
+  metadata.gz: 20b1e802ab0134205a8fac195ba528a3664fd16f
+  data.tar.gz: c1a48279c939c21b4ae482ced27e44243c69c4fc
 SHA512:
-  metadata.gz: 00efc4bd4c00da1f8547a31be2c83db2bed1dc5dabb62ebbc5a5100808a7a87449e5a19c7b3b9b99b5b0499c27267d13b807cb9f4dcda278df3fc5cf815184bf
-  data.tar.gz: 4e4c492d820316e324c9cde18b37d7bbd76dce885df2231b6523e6405a3296e7c69b64542464d206bd1627b42ac879d529b1ed2c2f3354093d074ff90f64d883
+  metadata.gz: ee52d4da30d62132d98b0e0246c4ce6aeb5c99126e7ce9538fe7de28e72c7926f6d33edc377d403bb048d9b2e917ad1f4685b61703b32bf2d2435f85f019b1dc
+  data.tar.gz: 0da4f27f3df184cc48c1ae5d8383d7a62a874573a15fca64a3aff0cb54323144ef65da983a7c10c85d81c3977ce7e307abf1116ea5353fd8b7b32c28ce371a19

data/Gemfile.lock

@@ -13,13 +13,15 @@ GEM
     logging (2.0.0)
       little-plugger (~> 1.1)
       multi_json (~> 1.10)
+    minitest (5.10.1)
     multi_json (1.12.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  minitest (~> 5.9)
   puppet-armature!
 
 BUNDLED WITH
-   1.10.4
+   1.14.6

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems/package_task'
+require 'rake/testtask'
+
+# Build packages from all .gemspec files
+FileList['*.gemspec'].each do |path|
+  Gem::PackageTask.new(eval(File.read(path))) { |pkg| }
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "lib" << "test"
+  t.test_files = FileList['test/*_test.rb']
+end

data/lib/armature/cache.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'logging'
 require 'pathname'
 require 'set'
 
@@ -6,17 +7,25 @@ module Armature
   class Cache
     def initialize(path)
       FileUtils.mkdir_p(path)
+      @lock_file = nil
       @path = File.realpath(path)
       @repos = {}
       @process_prefix = "#{Time.now.to_i}.#{Process.pid}"
       @sequence = 0
       @logger = Logging.logger[self]
 
-      %w{repo mutable immutable object tmp}.each do |subdir|
+      %w{repo ref/mutable ref/immutable ref/identity object tmp}.each do |subdir|
         FileUtils.mkdir_p("#{@path}/#{subdir}")
       end
     end
 
+    def flush_memory!
+      @logger.debug("Flushing in-memory caches for all repos")
+      @repos.each do |name, repo|
+        repo.freshen!
+      end
+    end
+
     # Get GitRepo object for a local clone of a remote repo at a URL
     #
     # This will clone the repo if it doesn't already exist.
@@ -47,56 +56,38 @@ module Armature
     end
 
     # Check out a ref from a repo and return the path
-    def checkout(repo, ref, options={})
-      options = Armature::Util.process_options(options,
-        { :name=>nil }, { :refresh=>false })
-
-      safe_ref = fs_sanitize(ref)
-
-      if options[:refresh]
+    def checkout(repo, ref, refresh=false, options={})
+      if refresh
         # Don't check the cache; refresh it from source.
         repo.freshen()
+        ref = repo.canonical_ref(ref)
       else
-        # Check cache first
-        ["immutable", "mutable"].each do |type|
-          ref_path = "#{@path}/#{type}/#{repo.name}/#{safe_ref}"
-          if Dir.exist? ref_path
-            return ref_path
-          end
+        # This will raise a RefError if the ref doesn't exist
+        begin
+          ref = repo.canonical_ref(ref)
+        rescue RefError
+          repo.freshen()
+          ref = repo.canonical_ref(ref)
         end
+      end
 
-        # Special case, since branches may be refered to by name
-        safe_branch = fs_sanitize("refs/heads/#{ref}")
-        ref_path = "#{@path}/mutable/#{repo.name}/#{safe_branch}"
-        if Dir.exist? ref_path
-          return ref_path
-        end
+      type = repo.ref_type(ref)
+      safe_ref = fs_sanitize(ref)
+      repo_path = "#{@path}/ref/#{type}/#{repo.name}"
+      ref_path = "#{repo_path}/#{safe_ref}"
 
-        # Special case, since tags may be refered to by name
-        safe_tag = fs_sanitize("refs/tags/#{ref}")
-        ref_path = "#{@path}/immutable/#{repo.name}/#{safe_tag}"
+      if ! refresh
+        # Check cache first
         if Dir.exist? ref_path
           return ref_path
         end
       end
 
-      # This will raise if the ref doesn't exist
-      begin
-        type, sha, real_ref = repo.ref_info(ref)
-      rescue
-        repo.freshen()
-        type, sha, real_ref = repo.ref_info(ref)
-      end
-
-      repo_dir = "#{@path}/#{type}/#{repo.name}"
-      if ! Dir.exist? repo_dir
-        Dir.mkdir(repo_dir)
-      end
+      FileUtils.mkdir_p(repo_path)
 
-      ref_path = "#{repo_dir}/#{safe_ref}"
-      sha_path = checkout_sha(repo, sha, options[:name])
-      if sha_path != ref_path
-        atomic_symlink(sha_path, ref_path)
+      identity_path = checkout_identity(repo, repo.ref_identity(ref))
+      if identity_path != ref_path
+        atomic_symlink(identity_path, ref_path)
       end
 
       ref_path
@@ -129,9 +120,8 @@ module Armature
     end
 
     def update_branches()
-      Dir.glob("#{@path}/mutable/*/*") do |path|
-        ref = File.basename(path)
-        ### FIXME decode
+      Dir.glob("#{@path}/ref/mutable/*/*") do |path|
+        ref = fs_unsanitize(File.basename(path))
         repo = get_repo_by_name(File.basename(File.dirname(path)))
         @logger.info("Updating #{ref} ref from #{repo.url}")
 
@@ -198,34 +188,38 @@ module Armature
       ref.sub(/\A\./, "\\.").gsub(/[\\|]/, '\\\0').gsub(/\//, '|')
     end
 
-    # Assumes sha exists. Use checkout() if it might not.
-    def checkout_sha(repo, sha, name=nil)
-      safe_sha = fs_sanitize(sha)
+    def fs_unsanitize(name)
+      name.gsub(/\|/, '/').gsub(/\\([\\|])/, '\0').sub(/^\\\./, '.')
+    end
+
+    # Assumes identity exists. Use checkout() if it might not.
+    def checkout_identity(repo, identity)
+      safe_identity = fs_sanitize(identity)
 
-      repo_path = "#{@path}/immutable/#{repo.name}"
-      sha_path = "#{repo_path}/#{safe_sha}"
-      if Dir.exist? sha_path
-        return sha_path
+      repo_path = "#{@path}/identity/#{repo.name}"
+      identity_path = "#{repo_path}/#{safe_identity}"
+      if Dir.exist? identity_path
+        return identity_path
       end
 
       FileUtils.mkdir_p(repo_path)
 
-      Armature::Util::lock sha_path, File::LOCK_EX, "checkout" do
+      Armature::Util::lock identity_path, File::LOCK_EX, "checkout" do
         # Another process may have created the object before we got the lock
-        if Dir.exist? sha_path
-          return sha_path
+        if Dir.exist? identity_path
+          return identity_path
         end
 
-        object_path = new_object_path(name)
+        object_path = new_object_path(identity)
         FileUtils.mkdir_p object_path
 
         @logger.debug(
-          "Checking out '#{sha}' from '#{repo.url}' into '#{object_path}'")
-        repo.git "reset", "--hard", sha, :work_dir=>object_path
-        atomic_symlink(object_path, sha_path)
+          "Checking out '#{identity}' from '#{repo.url}' into '#{object_path}'")
+        repo.git "reset", "--hard", identity, :work_dir=>object_path
+        atomic_symlink(object_path, identity_path)
       end
 
-      sha_path
+      identity_path
     end
 
     # Put a directory into a trash directory for off-line deletion
@@ -318,7 +312,7 @@ module Armature
     def garbage_collect_refs(referenced_paths)
       # Must be run from garbage_collect, since that handles the lock as well
       # as emptying the trash
-      all_references = Set.new(Dir.glob("#{@path}/{im,}mutable/*/*"))
+      all_references = Set.new(Dir.glob("#{@path}/ref/*/*/*"))
       difference = all_references - referenced_paths
       @logger.info(
         "Deleting #{difference.size} of #{all_references.size} references")
@@ -348,7 +342,7 @@ module Armature
       all_repos = Set.new(all_repos.map { |path| File.basename(path) })
       used_repos = Set.new()
 
-      referenced_repos = Dir.glob("#{@path}/{im,}mutable/*")
+      referenced_repos = Dir.glob("#{@path}/ref/*/*")
       referenced_repos.each do |path|
         # No refs within the repo in use (for this ref type)
         if Dir.glob("#{path}/*").empty?

data/lib/armature/environments.rb

@@ -39,7 +39,7 @@ module Armature
           " environment '#{name}'"
 
         begin
-          ref_path = @cache.checkout(repo, ref, :name=>ref, :refresh=>true)
+          ref_path = @cache.checkout(repo, ref, true)
         rescue RefError
           @logger.info "Ref '#{ref}' does not exist; ensuring environment" \
             " '#{name}' is gone"
@@ -50,9 +50,7 @@ module Armature
         puppetfile_path = "#{ref_path}/Puppetfile"
         if File.exist?(puppetfile_path)
           @logger.debug "Found Puppetfile in environment '#{name}'"
-          puppetfile = Armature::Puppetfile.new()
-          puppetfile.include(puppetfile_path)
-          module_refs = puppetfile.results
+          module_refs = Armature::Puppetfile.new().include(puppetfile_path)
           @logger.debug "Loaded Puppetfile in environment '#{name}' with" \
             " #{module_refs.length} modules"
         else
@@ -84,10 +82,7 @@ module Armature
           raise "Module name may not contain /: '#{name}'"
         end
 
-        ref_path = @cache.checkout(
-          @cache.get_repo(info[:git]),
-          info[:ref],
-          :name=>"#{name}.#{info[:ref]}")
+        ref_path = @cache.checkout(@cache.get_repo(info[:git]), info[:ref])
 
         @cache.atomic_symlink(ref_path, "#{modules_path}/#{name}")
       end

data/lib/armature/gitrepo.rb

@@ -19,17 +19,22 @@ module Armature
 
     def freshen
       if ! @fetched
-        @logger.info("Fetching from #{url}")
-        Armature::Util::lock @git_dir, File::LOCK_EX, "fetch" do
-          git "remote", "update", "--prune"
-        end
-        @fetched = true
+        freshen!
         true
       else
         false
       end
     end
 
+    def freshen!
+      @logger.info("Fetching from #{url}")
+      Armature::Util::lock @git_dir, File::LOCK_EX, "fetch" do
+        git "remote", "update", "--prune"
+      end
+      @ref_cache = {}
+      @fetched = true
+    end
+
     def git(*arguments)
       # This accepts a hash of options as the last argument
       options = if arguments.last.is_a? Hash then arguments.pop else {} end
@@ -57,43 +62,78 @@ module Armature
 
       lines.map do |line|
         sha, ref = line.split(' ', 2)
-        @ref_cache[ref] = [:mutable, sha, ref]
-        # Strip refs/heads/ from the beginning of each ref
-        ref["refs/heads/".length .. -1]
+        name = ref.sub("refs/heads/", "")
+        @ref_cache[ref] = [:mutable, sha, ref, "branch", name]
+        name
       end
     end
 
-    # Get the type of a ref (:branch, :tag, or :sha) and its sha as [type, sha]
+    def ref_type(ref)
+      ref_info(ref)[0]
+    end
+
+    def ref_identity(ref)
+      ref_info(ref)[1]
+    end
+
+    def canonical_ref(ref)
+      ref_info(ref)[2]
+    end
+
+    def ref_human_name(ref)
+      info = ref_info(ref)
+
+      "#{info[3]} '#{info[4]}'"
+    end
+
+  private
+
+    # Get information about ref, checking the cache first
     def ref_info(ref)
-      if result = check_cache(ref)
-        result
+      if ! @ref_cache[ref]
+        freshen_ref_cache(ref)
+      end
+
+      @ref_cache[ref]
+    end
+
+    # Get information about a ref and put it in the cache
+    def freshen_ref_cache(ref)
+      if ref.start_with? "refs/heads/"
+        @ref_cache[ref] = [:mutable, rev_parse!(ref), ref, "branch", ref.sub("refs/heads/", "")]
+      elsif ref.start_with? "refs/tags/"
+        @ref_cache[ref] = [:immutable, rev_parse!(ref), ref, "tag", ref.sub("refs/tags/", "")]
+      elsif ref.start_with? "refs/"
+        @ref_cache[ref] = [:mutable, rev_parse!(ref), ref, "ref", ref]
       elsif sha = rev_parse("refs/heads/#{ref}")
-        @ref_cache["refs/heads/#{ref}"] = [:mutable, sha, "refs/heads/#{ref}"]
+        @ref_cache["refs/heads/#{ref}"] = [:mutable, sha, "refs/heads/#{ref}", "branch", ref]
+        @ref_cache[ref] = @ref_cache["refs/heads/#{ref}"]
       elsif sha = rev_parse("refs/tags/#{ref}")
-        @ref_cache["refs/tags/#{ref}"] = [:immutable, sha, "refs/tags/#{ref}"]
+        @ref_cache["refs/tags/#{ref}"] = [:immutable, sha, "refs/tags/#{ref}", "tag", ref]
+        @ref_cache[ref] = @ref_cache["refs/tags/#{ref}"]
       elsif sha = rev_parse(ref)
         if sha == ref
-          @ref_cache[ref] = [:immutable, sha, ref]
+          @ref_cache[ref] = [:identity, sha, ref, "revision", ref]
         else
-          @ref_cache[ref] = [:mutable, sha, ref]
+          @ref_cache[ref] = [:mutable, sha, ref, "ref", ref]
         end
       else
         raise RefError.new("no such ref '#{ref}' in repo '#{url}'")
       end
     end
 
-  private
-    def check_cache(ref)
-      @ref_cache[ref] \
-      || @ref_cache["refs/heads/#{ref}"] \
-      || @ref_cache["refs/tags/#{ref}"]
-    end
-
     # Get the sha for a ref, or nil if it doesn't exist
     def rev_parse(ref)
+      rev_parse!(ref)
+    rescue RefError
+      nil
+    end
+
+    # Get the sha for a ref, or raise if it doesn't exist
+    def rev_parse!(ref)
       git("rev-parse", "--verify", "#{ref}^{commit}").chomp
     rescue Armature::Run::CommandFailureError
-      nil
+      raise RefError.new("no such ref '#{ref}' in repo '#{url}'")
     end
   end
 end

data/lib/armature/puppetfile.rb

@@ -8,6 +8,7 @@ module Armature
 
     def include(path)
       instance_eval(IO.read(path), path)
+      @results
     end
 
     def mod(name, options={})
@@ -21,10 +22,50 @@ module Armature
         raise "Module #{name} declared twice"
       end
 
-      @results[name] = Armature::Util.process_options(options, {}, {
+      options = Armature::Util.process_options(options, {
+        :commit => nil,
+        :tag => nil,
+        :branch => nil,
+        :ref => nil,
+      }, {
         :git => nil,
-        :ref => "master",
       })
+
+      ref = nil
+
+      if options[:commit]
+        if ref
+          raise "Module #{name} has more than one of :commit, :tag, :branch, or :ref"
+        end
+        ref = options[:commit]
+      end
+
+      if options[:tag]
+        if ref
+          raise "Module #{name} has more than one of :commit, :tag, :branch, or :ref"
+        end
+        ref = "refs/tags/#{options[:tag]}"
+      end
+
+      if options[:branch]
+        if ref
+          raise "Module #{name} has more than one of :commit, :tag, :branch, or :ref"
+        end
+        ref = "refs/heads/#{options[:branch]}"
+      end
+
+      if options[:ref]
+        if ref
+          raise "Module #{name} has more than one of :commit, :tag, :branch, or :ref"
+        end
+        ref = options[:ref]
+      end
+
+      if ! ref
+        ref = "refs/heads/master"
+      end
+
+      @results[name] = { :name => name, :ref => ref, :git => options[:git] }
     end
 
     def forge(*arguments)

data/lib/armature/run.rb

@@ -26,11 +26,11 @@ module Armature::Run
     command.shelljoin
   end
 
-  def command(*command)
+  def command(environment={}, *command)
     logger = Logging.logger[self]
 
     logger.debug(command_to_string(*command))
-    out, status = Open3.capture2e(*command)
+    out, status = Open3.capture2e(environment, *command)
     logger.debug(command_to_string(command.first) + ": #{status}")
 
     if ! status.success?
@@ -39,4 +39,15 @@ module Armature::Run
 
     out
   end
+
+  def clean_git(*command)
+    # Disable general configuration files
+    environment = {
+      "HOME" => "",
+      "XDG_CONFIG_HOME" => "",
+      "GIT_CONFIG_NOSYSTEM" => "1",
+    }
+
+    command(environment, "git", *command)
+  end
 end

data/lib/armature/version.rb

@@ -1,3 +1,3 @@
 module Armature
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
 end

data/puppet-armature.gemspec

@@ -17,4 +17,5 @@ spec = Gem::Specification.new do |s|
   s.executables << 'armature'
   s.add_runtime_dependency('gli','2.14.0')
   s.add_runtime_dependency('logging','~> 2')
+  s.add_development_dependency('minitest','~> 5.9')
 end

data/test/deploy_test.rb

@@ -0,0 +1,306 @@
+require 'minitest/autorun'
+require 'helpers'
+
+class DeployTest < Minitest::Test
+  include ArmatureTestHelpers
+
+  def test_deploy_just_master_branch
+    with_context do
+      repo = @cache.get_repo(repo_path("control"))
+      branches = Set.new(repo.get_branches())
+
+      assert_equal(Set.new(['master']), branches,
+        "Branches before test incorrect")
+      assert_equal([], @environments.names(),
+        "Environments before test incorrect")
+
+      @environments.checkout_ref(repo, "master")
+
+      assert_equal(["master"], @environments.names(),
+        "Environments after test incorrect")
+      assert_equal([".", "..", "master"], Dir.entries(@environments.path),
+        "Environments directory after test incorrect")
+    end
+  end
+
+  ### FIXME: should this generate an error?
+  def test_deploy_nonexistant_branch
+    with_context do
+      repo = @cache.get_repo(repo_path("control"))
+      branches = Set.new(repo.get_branches())
+
+      assert_equal(Set.new(['master']), branches,
+        "Branches before test incorrect")
+
+      @environments.checkout_ref(repo, "foo")
+
+      assert_equal([], @environments.names(),
+        "Environments after test incorrect")
+    end
+  end
+
+  def test_deploy_all_branches
+    with_context do
+      repo = @cache.get_repo(repo_path("control"))
+      branches = Set.new(repo.get_branches())
+
+      Dir.mkdir(@context_path + "/foo")
+      File.symlink(@context_path + "/foo", @environments.path + "/foo")
+
+      assert_equal(["foo"], @environments.names(),
+        "Environments before test incorrect")
+
+      (Set.new(@environments.names()) - branches).each do |name|
+        @environments.remove(name)
+      end
+
+      branches.each do |branch|
+        @environments.checkout_ref(repo, branch)
+      end
+
+      assert_equal(["master"], @environments.names(),
+        "Environments after test incorrect")
+    end
+  end
+
+  def test_deploy_one_module
+    with_context do
+      repo = @cache.get_repo(repo_path("control"))
+      @environments.checkout_ref(repo, "master")
+
+      assert_equal(
+        [".", "..", "module1"],
+        Dir.entries(@environments.path + "/master/modules"),
+        "Modules installed after test incorrect")
+    end
+  end
+
+  def test_adding_module_and_redeploying
+    with_context do
+      repo = @cache.get_repo(repo_path("control"))
+      @environments.checkout_ref(repo, "master")
+
+      repo_init("module-2")
+      repo_commit("control", "Add module-2") do
+        File.write("Puppetfile", <<-PUPPETFILE)
+          forge "https://forge.puppet.com"
+
+          mod "module1", :git=>"#{repo_path('module-1')}"
+          mod "module2", :git=>"#{repo_path('module-2')}"
+        PUPPETFILE
+      end
+
+      @cache.flush_memory!
+      @environments.checkout_ref(repo, "master")
+      assert_equal(
+        [".", "..", "module1", "module2"],
+        Dir.entries(@environments.path + "/master/modules"),
+        "Modules installed after test incorrect")
+      assert_environment_file_contains(
+        "master/modules/module1/README.md",
+        "# Armature test repo: module-1")
+      assert_environment_file_contains(
+        "master/modules/module2/README.md",
+        "# Armature test repo: module-2")
+    end
+  end
+
+  def test_removing_module_and_redeploying
+    with_context do
+      repo = @cache.get_repo(repo_path("control"))
+      @environments.checkout_ref(repo, "master")
+
+      repo_commit("control", "Remove module-1") do
+        File.write("Puppetfile", <<-PUPPETFILE)
+          forge "https://forge.puppet.com"
+        PUPPETFILE
+      end
+
+      @cache.flush_memory!
+      @environments.checkout_ref(repo, "master")
+      assert_equal(
+        [".", ".."],
+        Dir.entries(@environments.path + "/master/modules"),
+        "Modules installed after test incorrect")
+    end
+  end
+
+  def test_module_with_bad_ref
+    with_context do
+      repo = @cache.get_repo(repo_path("control"))
+      repo_commit("control", "Set module-1 to bad ref") do
+        File.write("Puppetfile", <<-PUPPETFILE)
+          forge "https://forge.puppet.com"
+
+          mod "module1", :git=>"#{repo_path('module-1')}", :ref=>"bad"
+        PUPPETFILE
+      end
+
+      assert_raises(Armature::RefError) do
+        @environments.checkout_ref(repo, "master")
+      end
+
+      ### FIXME state of repo after an error is undefined, but this behavior
+      ### seems reasonable.
+      assert_equal(
+        [".", ".."],
+        Dir.entries(@environments.path),
+        "Modules installed after test incorrect")
+    end
+  end
+
+  def test_redeploying_module_with_bad_ref
+    with_context do
+      repo = @cache.get_repo(repo_path("control"))
+      @environments.checkout_ref(repo, "master")
+
+      repo_commit("control", "Set module-1 to bad ref") do
+        File.write("Puppetfile", <<-PUPPETFILE)
+          forge "https://forge.puppet.com"
+
+          mod "module1", :git=>"#{repo_path('module-1')}", :ref=>"bad"
+        PUPPETFILE
+      end
+
+      @cache.flush_memory!
+      assert_raises(Armature::RefError) do
+        @environments.checkout_ref(repo, "master")
+      end
+
+      ### FIXME state of repo after an error is undefined
+      ### What happens if other modules already exist?
+      skip("state of repo after an error is undefined")
+      assert_equal(
+        [".", "..", "module1"],
+        Dir.entries(@environments.path + "/master/modules"),
+        "Modules installed after test incorrect")
+    end
+  end
+
+  def test_redeploying_module_with_ref_tag
+    with_context do
+      set_up_interesting_module("interesting")
+      redeploy_module_with_ref_of_type("ref", "tag_one") do
+        assert_module_manifests("interesting", ["one.pp"],
+          "Incorrect module version after redeploy")
+      end
+    end
+  end
+
+  def test_redeploying_module_with_ref_branch
+    with_context do
+      set_up_interesting_module("interesting")
+      redeploy_module_with_ref_of_type("ref", "branch_two") do
+        assert_module_manifests("interesting", ["one.pp", "two.pp", "two_a.pp"],
+          "Incorrect module version after redeploy")
+      end
+    end
+  end
+
+  def test_redeploying_module_with_ref_commit
+    with_context do
+      set_up_interesting_module("interesting")
+      sha = repo_git("interesting", "rev-parse", "branch_two^").chomp
+      redeploy_module_with_ref_of_type("ref", sha) do
+        assert_module_manifests("interesting", ["one.pp", "two.pp"],
+          "Incorrect module version after redeploy")
+      end
+    end
+  end
+
+  def test_redeploying_module_with_tag
+    with_context do
+      set_up_interesting_module("interesting")
+      redeploy_module_with_ref_of_type("tag", "tag_one") do
+        assert_module_manifests("interesting", ["one.pp"],
+          "Incorrect module version after redeploy")
+      end
+    end
+  end
+
+  def test_redeploying_module_with_branch
+    with_context do
+      set_up_interesting_module("interesting")
+      redeploy_module_with_ref_of_type("branch", "branch_two") do
+        assert_module_manifests("interesting", ["one.pp", "two.pp", "two_a.pp"],
+          "Incorrect module version after redeploy")
+      end
+    end
+  end
+
+  def test_redeploying_module_with_commit
+    with_context do
+      set_up_interesting_module("interesting")
+      sha = repo_git("interesting", "rev-parse", "branch_two^").chomp
+      redeploy_module_with_ref_of_type("commit", sha) do
+        assert_module_manifests("interesting", ["one.pp", "two.pp"],
+          "Incorrect module version after redeploy")
+      end
+    end
+  end
+
+  def test_redeploying_module_with_updated_branch
+    with_context do
+      set_up_interesting_module("interesting")
+      redeploy_module_with_ref_of_type("ref", "branch_two") do
+        repo_git("interesting", "checkout", "branch_two")
+        add_module_class("interesting", "two_b")
+
+        @cache.flush_memory!
+        @environments.checkout_ref(@cache.get_repo(repo_path("control")), "master")
+
+        skip("checkout_ref doesn't update branches at the moment")
+        assert_module_manifests("interesting",
+          ["one.pp", "two.pp", "two_a.pp", "two_b.pp"],
+          "Incorrect module version after redeploy")
+      end
+    end
+  end
+
+  def test_updating_branches_on_module_with_updated_branch
+    with_context do
+      set_up_interesting_module("interesting")
+      redeploy_module_with_ref_of_type("ref", "branch_two") do
+        repo_git("interesting", "checkout", "branch_two")
+        add_module_class("interesting", "two_b")
+
+        @cache.flush_memory!
+        @cache.update_branches()
+
+        assert_module_manifests("interesting",
+          ["one.pp", "two.pp", "two_a.pp", "two_b.pp"],
+          "Incorrect module version after redeploy")
+      end
+    end
+  end
+
+private
+
+  # The "interesting" repo must be created first so it can be queried for shas
+  def redeploy_module_with_ref_of_type(ref_type, ref)
+    repo = @cache.get_repo(repo_path("control"))
+
+    repo_puppetfile_update("control", <<-MODULES)
+      mod "interesting", :git=>"#{repo_path('interesting')}"
+    MODULES
+
+    @environments.checkout_ref(repo, "master")
+
+    assert_module_manifests("interesting", ["one.pp", "two.pp", "three.pp"],
+      "Incorrect module version after initial deploy")
+
+    repo_commit("control", "Add interesting module") do
+      File.write("Puppetfile", <<-PUPPETFILE)
+        forge "https://forge.puppet.com"
+
+        mod "interesting", :git=>"#{repo_path('interesting')}",
+          :#{ref_type}=>"#{ref}"
+      PUPPETFILE
+    end
+
+    @cache.flush_memory!
+    @environments.checkout_ref(repo, "master")
+
+    yield
+  end
+end

data/test/helpers.rb

@@ -0,0 +1,130 @@
+require 'armature'
+require 'fileutils'
+require 'tmpdir'
+
+module ArmatureTestHelpers
+  def repo_path(name)
+    @context_path + "/repos/" + name
+  end
+
+  def repo_init(name)
+    Armature::Run.clean_git("init", repo_path(name))
+    repo_commit(name, "Initial revision of #{name}") do
+      File.write("README.md", <<-README)
+        # Armature test repo: #{name}
+
+        Located at #{repo_path(name)}
+      README
+
+      Dir.mkdir("manifests")
+      File.write("manifests/.keep", "")
+
+      if block_given?
+        yield
+      end
+    end
+  end
+
+  def repo_commit(name, message)
+    Dir.chdir(repo_path(name)) do
+      yield
+      Armature::Run.clean_git("add", ".")
+      Armature::Run.clean_git("commit", "-m", message)
+    end
+  end
+
+  def repo_git(name, *command)
+    Dir.chdir(repo_path(name)) do
+      Armature::Run.clean_git(*command)
+    end
+  end
+
+  def repo_puppetfile_update(name, modules)
+    repo_commit(name, "Update Puppetfile") do
+      File.write("Puppetfile", <<-PUPPETFILE)
+        forge "https://forge.puppet.com"
+
+        #{modules}
+      PUPPETFILE
+    end
+  end
+
+  def add_module_class(module_name, class_name)
+    repo_commit(module_name, "Add #{class_name}.pp") do
+      File.write("manifests/#{class_name}.pp", <<-MANIFEST)
+        class module1::#{class_name} {
+          notify { "in #{module_name}::#{class_name}": }
+        }
+      MANIFEST
+    end
+  end
+
+  def set_up_interesting_module(module_name)
+    repo_init(module_name)
+
+    add_module_class(module_name, "one")
+    repo_git(module_name, "tag", "tag_one")
+    add_module_class(module_name, "two")
+    repo_git(module_name, "checkout", "-b", "branch_two")
+    add_module_class(module_name, "two_a")
+    repo_git(module_name, "checkout", "master")
+    add_module_class(module_name, "three")
+  end
+
+  def set_up_context
+    @context_path = Dir.mktmpdir("armature.test_context.")
+    @cache = Armature::Cache.new(@context_path + "/cache")
+
+    Dir.mkdir(@context_path + "/environments")
+    @environments = Armature::Environments.new(@context_path + "/environments", @cache)
+
+    repo_init("module-1")
+
+    repo_init("control") do
+      File.write("Puppetfile", <<-PUPPETFILE)
+        forge "https://forge.puppet.com"
+
+        mod "module1", :git=>"#{repo_path('module-1')}"
+      PUPPETFILE
+    end
+  end
+
+  def tear_down_context
+    FileUtils.rm_rf(@context_path)
+
+    # Ensure that code trying to use these after this point fails in a
+    # predictable way.
+    @context_path = nil
+    @cache = nil
+    @environments = nil
+  end
+
+  def with_context
+    set_up_context
+    yield
+    tear_down_context
+  end
+
+  def environment_file_contains?(path, search)
+    File.foreach(@environments.path + "/" + path).any? do
+      |line| line.include? search
+    end
+  end
+
+  def assert_environment_file_contains(path, search, message=nil)
+    if ! message
+      message = "#{path} does not contain '#{search}'"
+    end
+
+    assert(environment_file_contains?(path, search), message)
+  end
+
+  def assert_module_manifests(module_name, manifest_names=["init.pp"],
+      message="Incorrect manifests in module '#{module_name}'",
+      environment="master")
+    assert_equal(
+      ([".", "..", ".keep"] + manifest_names).sort(),
+      Dir.entries(@environments.path + "/#{environment}/modules/#{module_name}/manifests"),
+      message)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet-armature
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Parks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-31 00:00:00.000000000 Z
+date: 2017-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gli
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
 description: Armature sets up Puppet environments for each branch in your control
   repo and installs modules as specified by the Puppetfile for each environment. It
   is designed as a replacement for r10k.
@@ -51,6 +65,7 @@ files:
 - Gemfile.lock
 - LICENSE
 - README.md
+- Rakefile
 - TODO.md
 - bin/armature
 - docs/puppetfile-syntax.md
@@ -63,6 +78,8 @@ files:
 - lib/armature/util.rb
 - lib/armature/version.rb
 - puppet-armature.gemspec
+- test/deploy_test.rb
+- test/helpers.rb
 homepage: https://github.com/danielparks/armature
 licenses:
 - BSD-2-Clause
@@ -89,4 +106,3 @@ signing_key:
 specification_version: 4
 summary: Deploy Puppet environments and manage modules
 test_files: []
-has_rdoc: false