dk-pkg 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA1: 
-  data.tar.gz: 938181da0a915713d54443c5597e23eaa6dee215
-  metadata.gz: bbd5ad3bb01f18268f93b23e972db8c93336fec5
+  metadata.gz: 11771e7a75edaca8db188e72bd1227074b519b40
+  data.tar.gz: bacebe6f8f0ef66f8338ac97326ea98e9df23b46
 SHA512: 
-  data.tar.gz: 408c329a61e4e081060345704ef97e76830179f27f20ce5ac6b72e30d2cd1966240ce236f7a558b5a5d28bd563a7865d117045ccf62f83629f383eb4ee2d43eb
-  metadata.gz: 758874d4b2719a306863b0d36f5782d6572fbcd00491c49e3774d5f8b542a00efa0eecb0f35188020adb5167ee6579b389c74c0163bc50ddd247596daf0f2f2e
+  metadata.gz: f00bd74d6913fc2511fd86c71599285b544ea1309f24e426d253b3f59890320f1a7e512d7502dcdadd1f484689d989772d2cc6ff2ab16f84d63851bb0d3c637a
+  data.tar.gz: 7144274536ee8403fc32138e20339881cdcefa82a65db83d3cc89d97cd17d6a955cdbc30c5c932d00bafb067292fe87edd527d52f5d196090c7e37848608dbc3

data/dk-pkg.gemspec

@@ -18,6 +18,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.16.1"])
+  gem.add_development_dependency("assert", ["~> 2.16.3"])
+
+  gem.add_dependency("dk",          ["~> 0.1.0"])
+  gem.add_dependency("much-plugin", ["~> 0.2.0"])
 
 end

data/lib/dk-pkg.rb

@@ -1,5 +1,6 @@
-require "dk-pkg/version"
+require 'dk-pkg/version'
+require 'dk-pkg/constants'
+require 'dk-pkg/install_pkg'
 
-module Dk; end
-module Dk::Pkg
-end
+# require the tasks for convenience
+require 'dk-pkg/validate'

data/lib/dk-pkg/constants.rb

@@ -0,0 +1,11 @@
+module Dk; end
+module Dk::Pkg
+
+  MANIFEST_PATH_PARAM_NAME  = 'dk_pkg_manifest_path'.freeze
+  MANIFEST_MODE_PARAM_NAME  = 'dk_pkg_manifest_mode'.freeze
+  MANIFEST_OWNER_PARAM_NAME = 'dk_pkg_manifest_owner'.freeze
+  INSTALLED_PKGS_PARAM_NAME = 'dk_pkg_installed_pkgs'.freeze
+
+  MANIFEST_SEPARATOR = "\n".freeze
+
+end

data/lib/dk-pkg/install_pkg.rb

@@ -0,0 +1,83 @@
+require 'dk/task'
+require 'much-plugin'
+require 'dk-pkg/constants'
+require 'dk-pkg/validate'
+
+module Dk::Pkg
+
+  module InstallPkg
+    include MuchPlugin
+
+    WRITE_MANIFEST_CMD_STR_PROC = proc{ |manifest_path| "tee #{manifest_path}" }
+
+    plugin_included do
+      include Dk::Task
+      include InstanceMethods
+
+      before Dk::Pkg::Validate
+
+    end
+
+    module InstanceMethods
+
+      private
+
+      def install_pkg(name)
+        raise(ArgumentError, "a pkg name must be provided") if name.to_s.empty?
+        raise(ArgumentError, "no block given") unless block_given?
+
+        if !params[INSTALLED_PKGS_PARAM_NAME].include?(name)
+          yield
+          dk_pkg_write_pkg_to_manifest(name)
+        else
+          log_info "#{name.inspect} has already been installed"
+        end
+      end
+
+      def dk_pkg_write_pkg_to_manifest(name)
+        pkgs = params[INSTALLED_PKGS_PARAM_NAME] + [name]
+        serialized_pkgs = Manifest.serialize(pkgs)
+        cmd!(
+          WRITE_MANIFEST_CMD_STR_PROC.call(params[MANIFEST_PATH_PARAM_NAME]),
+          serialized_pkgs
+        )
+        set_param INSTALLED_PKGS_PARAM_NAME, Manifest.deserialize(serialized_pkgs)
+      end
+
+    end
+
+    module TestHelpers
+      include MuchPlugin
+
+      plugin_included do
+        include Dk::Pkg::Validate::TestHelpers
+        include InstanceMethods
+
+      end
+
+      module InstanceMethods
+
+        def assert_dk_pkg_installed(test_runner, pkg_name)
+          assert_includes pkg_name, test_runner.params[INSTALLED_PKGS_PARAM_NAME]
+        end
+
+        def non_dk_install_pkg_runs(test_runner, test_runner_runs)
+          manifest_path          = test_runner.params[MANIFEST_PATH_PARAM_NAME]
+          write_manifest_cmd_str = WRITE_MANIFEST_CMD_STR_PROC.call(manifest_path)
+
+          test_runner_runs.reject do |run|
+            validate_task_run  = run.kind_of?(Dk::TaskRun) &&
+                                 run.task_class == Dk::Pkg::Validate
+            write_manifest_cmd = run.kind_of?(Dk::Local::CmdSpy) &&
+                                 run.cmd_str == write_manifest_cmd_str
+            validate_task_run || write_manifest_cmd
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/dk-pkg/manifest.rb

@@ -0,0 +1,27 @@
+require 'dk-pkg/constants'
+
+module Dk::Pkg
+
+  module Manifest
+
+    def self.serialize(pkgs)
+      raise ArgumentError, "pkgs must be an array" if !pkgs.kind_of?(Array)
+      sanitize_array(pkgs).join(MANIFEST_SEPARATOR)
+    end
+
+    def self.deserialize(serialized_pkgs)
+      if !serialized_pkgs.kind_of?(String)
+        raise ArgumentError, "serialized pkgs must be a string"
+      end
+      sanitize_array(serialized_pkgs.split(MANIFEST_SEPARATOR))
+    end
+
+    private
+
+    def self.sanitize_array(array)
+      array.compact.uniq.map(&:to_s).reject(&:empty?).sort
+    end
+
+  end
+
+end

data/lib/dk-pkg/validate.rb

@@ -0,0 +1,55 @@
+require 'dk/task'
+require 'dk-pkg/constants'
+require 'dk-pkg/manifest'
+
+module Dk::Pkg
+
+  class Validate
+    include Dk::Task
+
+    desc "(dk-pkg) validate the required dk-pkg params"
+
+    run_only_once true
+
+    def run!
+      # validate that a manifest path has been set, so we can parse it
+      if params[MANIFEST_PATH_PARAM_NAME].to_s.empty?
+        raise ArgumentError, "no #{MANIFEST_PATH_PARAM_NAME.inspect} param set"
+      end
+
+      if !cmd("test -e #{params[MANIFEST_PATH_PARAM_NAME]}").success?
+        cmd! "touch #{params[MANIFEST_PATH_PARAM_NAME]}"
+        if param?(MANIFEST_MODE_PARAM_NAME)
+          cmd! "chmod #{params[MANIFEST_MODE_PARAM_NAME]} " \
+                     "#{params[MANIFEST_PATH_PARAM_NAME]}"
+        end
+        if param?(MANIFEST_OWNER_PARAM_NAME)
+          cmd! "chown #{params[MANIFEST_OWNER_PARAM_NAME]} " \
+                     "#{params[MANIFEST_PATH_PARAM_NAME]}"
+        end
+      end
+      serialized_pkgs = cmd!("cat #{params[MANIFEST_PATH_PARAM_NAME]}").stdout
+      set_param INSTALLED_PKGS_PARAM_NAME, Manifest.deserialize(serialized_pkgs)
+    end
+
+    module TestHelpers
+      include MuchPlugin
+
+      plugin_included do
+        include Dk::Task::TestHelpers
+
+        setup do
+          @dk_pkg_installed_pkgs ||= []
+
+          @params ||= {}
+          @params[MANIFEST_PATH_PARAM_NAME]  ||= Factory.file_path
+          @params[INSTALLED_PKGS_PARAM_NAME] ||= @dk_pkg_installed_pkgs
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/dk-pkg/version.rb

@@ -1,4 +1,4 @@
 module Dk; end
 module Dk::Pkg
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/test/support/factory.rb

@@ -1,6 +1,11 @@
 require 'assert/factory'
+require 'dk-pkg/manifest'
 
 module Factory
   extend Assert::Factory
 
+  def self.manifest_pkgs
+    Factory.integer(3).times.map{ Factory.string }.sort
+  end
+
 end

data/test/unit/dk-pkg_tests.rb

@@ -0,0 +1,26 @@
+require 'assert'
+require 'dk-pkg'
+
+module Dk::Pkg
+
+  class UnitTests < Assert::Context
+    desc "Dk::Pkg"
+    setup do
+      @module = Dk::Pkg
+    end
+    subject{ @module }
+
+    should "know its param names" do
+      assert_equal 'dk_pkg_manifest_path',  MANIFEST_PATH_PARAM_NAME
+      assert_equal 'dk_pkg_manifest_mode',  MANIFEST_MODE_PARAM_NAME
+      assert_equal 'dk_pkg_manifest_owner', MANIFEST_OWNER_PARAM_NAME
+      assert_equal 'dk_pkg_installed_pkgs', INSTALLED_PKGS_PARAM_NAME
+    end
+
+    should "know its manifest separator" do
+      assert_equal "\n", MANIFEST_SEPARATOR
+    end
+
+  end
+
+end

data/test/unit/install_pkg_tests.rb

@@ -0,0 +1,162 @@
+require 'assert'
+require 'dk-pkg/install_pkg'
+
+require 'dk/task'
+require 'much-plugin'
+require 'dk-pkg/constants'
+require 'dk-pkg/validate'
+
+module Dk::Pkg::InstallPkg
+
+  class UnitTests < Assert::Context
+    include Dk::Pkg::Validate::TestHelpers
+
+    desc "Dk::Pkg::InstallPkg"
+    subject{ Dk::Pkg::InstallPkg }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    desc "mixin"
+    setup do
+      @task_class = Class.new{ include Dk::Pkg::InstallPkg }
+    end
+    subject{ @task_class }
+
+    should "be a Dk task" do
+      assert_includes Dk::Task, subject
+    end
+
+    should "run the Validate task as a before callback" do
+      assert_equal [Dk::Pkg::Validate], subject.before_callback_task_classes
+    end
+
+  end
+
+  class InitTests < MixinTests
+    desc "when init"
+    setup do
+      @task_class.class_eval do
+        def run!
+          install_pkg params['pkg-name'] do
+            set_param 'install-pkg-yielded', true
+          end
+        end
+      end
+      @params['pkg-name']            = Factory.string
+      @params['install-pkg-yielded'] = false
+
+      @runner = test_runner(@task_class, :params => @params)
+    end
+    subject{ @runner }
+
+    should "provide an install pkg helper" do
+      subject.run
+
+      assert_true subject.params['install-pkg-yielded']
+      # there will always be +1 because of the Validate task being run
+      assert_equal 2, subject.runs.size
+      tee_cmd = subject.runs.last
+      exp = "tee #{@params[Dk::Pkg::MANIFEST_PATH_PARAM_NAME]}"
+      assert_equal exp, tee_cmd.cmd_str
+
+      exp_pkgs = [@params['pkg-name']]
+      assert_equal Dk::Pkg::Manifest.serialize(exp_pkgs), tee_cmd.run_input
+
+      assert_equal exp_pkgs, subject.params[Dk::Pkg::INSTALLED_PKGS_PARAM_NAME]
+    end
+
+    should "not yield or run any commands if the pkg is already installed" do
+      @params[Dk::Pkg::INSTALLED_PKGS_PARAM_NAME] << @params['pkg-name']
+      runner = test_runner(@task_class, :params => @params)
+      runner.run
+
+      assert_false runner.params['install-pkg-yielded']
+      # there will always be +1 because of the Validate task being run
+      assert_equal 1, runner.runs.size
+    end
+
+    should "complain if passed invalid args" do
+      assert_raises(ArgumentError) do
+        subject.task.instance_eval{ install_pkg([nil, ''].sample){ } }
+      end
+      assert_raises(ArgumentError) do
+        subject.task.instance_eval{ install_pkg(Factory.string) }
+      end
+    end
+
+  end
+
+  class TestHelpersTests < UnitTests
+    desc "TestHelpers"
+    setup do
+      @task_class = Class.new do
+        include Dk::Pkg::InstallPkg
+
+        def run!
+          params['pkgs'].each do |(pkg_name, pkg_cmd)|
+            install_pkg(pkg_name){ cmd(pkg_cmd) }
+          end
+          run_task TestTask
+        end
+      end
+
+      # use an array of tuples so we don't have to worry about hash randomly
+      # ordering its key/values when testing
+      @params['pkgs'] = Factory.integer(3).times.map do
+        [Factory.string, Factory.string]
+      end
+      @runner = test_runner(@task_class, :params => @params)
+      @runner.run
+
+      @context_class = Class.new do
+        def self.setup(&block); end # needed for `Dk::Pkg::Validate::TestHelpers`
+        include Dk::Pkg::InstallPkg::TestHelpers
+
+        def initialize(assert_context)
+          @assert_context = assert_context
+        end
+
+        # needed to test `assert_dk_pkg_installed`
+        def assert_includes(*args)
+          @assert_context.assert_includes(*args)
+        end
+      end
+      @context = @context_class.new(self)
+    end
+    subject{ @context }
+
+    should have_imeths :assert_dk_pkg_installed, :non_dk_install_pkg_runs
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, Dk::Pkg::InstallPkg::TestHelpers
+    end
+
+    should "include dk-pkg Validate test helpers" do
+      assert_includes Dk::Pkg::Validate::TestHelpers, @context_class
+    end
+
+    should "provide a helper for asserting a pkg was installed" do
+      @params['pkgs'].each do |pkg_name, pkg_cmd|
+        subject.assert_dk_pkg_installed(@runner, pkg_name)
+      end
+    end
+
+    should "know how to select non dk-pkg install pkg runs" do
+      runs = subject.non_dk_install_pkg_runs(@runner, @runner.runs)
+      assert_not_equal runs, @runner.runs
+      assert_equal @params['pkgs'].size + 1, runs.size
+      cmd_runs = runs[0, @params['pkgs'].size]
+      assert_equal @params['pkgs'].map(&:last), cmd_runs.map(&:cmd_str)
+      assert_equal TestTask, runs.last.task_class
+    end
+
+  end
+
+  TestTask = Class.new{ include Dk::Task }
+
+end

data/test/unit/manifest_tests.rb

@@ -0,0 +1,63 @@
+require 'assert'
+require 'dk-pkg/manifest'
+
+require 'dk-pkg/constants'
+
+module Dk::Pkg::Manifest
+
+  class UnitTests < Assert::Context
+    desc "Dk::Pkg::Manifest"
+    setup do
+      @pkgs = Factory.manifest_pkgs
+    end
+    subject{ Dk::Pkg::Manifest }
+
+    should have_imeths :serialize, :deserialize
+
+    should "know how to serialize and deserialize" do
+      exp = @pkgs.join(Dk::Pkg::MANIFEST_SEPARATOR)
+      serialized_pkgs = subject.serialize(@pkgs)
+      assert_equal exp, serialized_pkgs
+      assert_equal @pkgs, subject.deserialize(serialized_pkgs)
+    end
+
+    should "clean pkg names using serialize/deserialize" do
+      valid_pkgs      = Factory.manifest_pkgs.shuffle # randomize their order
+      non_string_pkgs = [Factory.integer, Factory.boolean, Factory.float]
+      duplicate_pkg   = Factory.string
+      pkgs = valid_pkgs +
+             non_string_pkgs +                        # add non strings
+             ([duplicate_pkg] * Factory.integer(3)) + # add duplicates
+             ([nil] * Factory.integer(3)) +           # add `nil` packages
+             ([""] * Factory.integer(3))              # add empty string packages
+      serialized_pkgs = pkgs.shuffle.join(Dk::Pkg::MANIFEST_SEPARATOR)
+
+      exp_pkgs            = (valid_pkgs + non_string_pkgs + [duplicate_pkg]).map(&:to_s).sort
+      exp_serialized_pkgs = exp_pkgs.join(Dk::Pkg::MANIFEST_SEPARATOR)
+
+      assert_equal exp_serialized_pkgs, subject.serialize(pkgs)
+      assert_equal exp_pkgs,            subject.deserialize(serialized_pkgs)
+    end
+
+    should "handle special cases using serialize/deserialize" do
+      # a single item
+      pkg = Factory.string
+      assert_equal pkg,   subject.serialize([pkg])
+      assert_equal [pkg], subject.deserialize(pkg)
+
+      assert_equal "", subject.serialize([])
+      assert_equal [], subject.deserialize("")
+    end
+
+    should "complain if serialize/deserialize is passed invalid args" do
+      assert_raises(ArgumentError){ subject.serialize(nil) }
+      assert_raises(ArgumentError){ subject.serialize(Factory.string) }
+
+      assert_raises(ArgumentError){ subject.deserialize(nil) }
+      array = Factory.integer(3).times.map{ Factory.string }
+      assert_raises(ArgumentError){ subject.deserialize(array) }
+    end
+
+  end
+
+end

data/test/unit/validate_tests.rb

@@ -0,0 +1,197 @@
+require 'assert'
+require 'dk-pkg/validate'
+
+require 'dk/task'
+require 'dk-pkg/constants'
+require 'dk-pkg/manifest'
+
+class Dk::Pkg::Validate
+
+  class UnitTests < Assert::Context
+    desc "Dk::Pkg::Validate"
+    setup do
+      @task_class = Dk::Pkg::Validate
+    end
+    subject{ @task_class }
+
+    should "be a Dk task" do
+      assert_includes Dk::Task, subject
+    end
+
+    should "know its description" do
+      exp = "(dk-pkg) validate the required dk-pkg params"
+      assert_equal exp, subject.description
+    end
+
+    should "only run once" do
+      assert_true subject.run_only_once
+    end
+
+  end
+
+  class RunSetupTests < UnitTests
+    include Dk::Task::TestHelpers
+
+    desc "when run"
+    setup do
+      @manifest_path  = Factory.file_path
+      @manifest_mode  = Factory.string
+      @manifest_owner = Factory.string
+      @installed_pkgs = Factory.manifest_pkgs
+
+      @exp_test_cmd = "test -e #{@manifest_path}"
+      @exp_cat_cmd  = "cat #{@manifest_path}"
+
+      @params = {
+        Dk::Pkg::MANIFEST_PATH_PARAM_NAME  => @manifest_path,
+        Dk::Pkg::MANIFEST_MODE_PARAM_NAME  => @manifest_mode,
+        Dk::Pkg::MANIFEST_OWNER_PARAM_NAME => @manifest_owner
+      }
+    end
+    subject{ @runner }
+
+    private
+
+    def stub_test_manifest_file_exists_cmd(runner, success)
+      @runner.stub_cmd(@exp_test_cmd){ |s| s.exitstatus = success ? 0 : 1 }
+    end
+
+    def stub_cat_manifest_file_cmd(runner, manifest = nil)
+      manifest ||= Dk::Pkg::Manifest.serialize(@installed_pkgs)
+      runner.stub_cmd(@exp_cat_cmd){ |s| s.stdout = manifest }
+    end
+
+  end
+
+  class RunTests < RunSetupTests
+    setup do
+      @runner = test_runner(@task_class, :params => @params)
+      stub_test_manifest_file_exists_cmd(@runner, false)
+      stub_cat_manifest_file_cmd(@runner)
+      @runner.run
+    end
+
+    should "parse the manifest file and set the installed pkgs param" do
+      assert_equal 5, subject.runs.size
+
+      test_cmd, touch_cmd, chmod_cmd, chown_cmd, cat_cmd = subject.runs
+      assert_equal @exp_test_cmd,                                test_cmd.cmd_str
+      assert_equal "touch #{@manifest_path}",                    touch_cmd.cmd_str
+      assert_equal "chmod #{@manifest_mode} #{@manifest_path}",  chmod_cmd.cmd_str
+      assert_equal "chown #{@manifest_owner} #{@manifest_path}", chown_cmd.cmd_str
+      assert_equal @exp_cat_cmd,                                 cat_cmd.cmd_str
+
+      exp = @installed_pkgs
+      assert_equal exp, subject.params[Dk::Pkg::INSTALLED_PKGS_PARAM_NAME]
+    end
+
+  end
+
+  class RunWithEmptyManifestTests < RunSetupTests
+    desc "and the manifest is empty"
+    setup do
+      @runner = test_runner(@task_class, :params => @params)
+      stub_test_manifest_file_exists_cmd(@runner, Factory.boolean)
+      stub_cat_manifest_file_cmd(@runner, "")
+      @runner.run
+    end
+
+    should "parse the manifest file and set the installed pkgs param" do
+      assert_equal [], subject.params[Dk::Pkg::INSTALLED_PKGS_PARAM_NAME]
+    end
+
+  end
+
+  class RunWithExistingManifestTests < RunSetupTests
+    desc "and the manifest already exists"
+    setup do
+      @runner = test_runner(@task_class, :params => @params)
+      stub_test_manifest_file_exists_cmd(@runner, true)
+      stub_cat_manifest_file_cmd(@runner)
+      @runner.run
+    end
+
+    should "not create the manifest file but still parse it" do
+      assert_equal 2, subject.runs.size
+
+      test_cmd, cat_cmd = subject.runs
+      assert_equal @exp_test_cmd, test_cmd.cmd_str
+      assert_equal @exp_cat_cmd,  cat_cmd.cmd_str
+
+      exp = @installed_pkgs
+      assert_equal exp, subject.params[Dk::Pkg::INSTALLED_PKGS_PARAM_NAME]
+    end
+
+  end
+
+  class RunOnNewWithoutModeOrOwnerParamsTests < RunSetupTests
+    desc "with a new manifest but no mode/owner params set"
+    setup do
+      @params.delete(Dk::Pkg::MANIFEST_MODE_PARAM_NAME)
+      @params.delete(Dk::Pkg::MANIFEST_OWNER_PARAM_NAME)
+
+      @runner = test_runner(@task_class, :params => @params)
+      stub_test_manifest_file_exists_cmd(@runner, false)
+      stub_cat_manifest_file_cmd(@runner)
+      @runner.run
+    end
+
+    should "create the manifest file but not change its mode/owner" do
+      assert_equal 3, subject.runs.size
+
+      test_cmd, touch_cmd, cat_cmd = subject.runs
+      assert_equal @exp_test_cmd,             test_cmd.cmd_str
+      assert_equal "touch #{@manifest_path}", touch_cmd.cmd_str
+      assert_equal @exp_cat_cmd,              cat_cmd.cmd_str
+
+      exp = @installed_pkgs
+      assert_equal exp, subject.params[Dk::Pkg::INSTALLED_PKGS_PARAM_NAME]
+    end
+
+  end
+
+  class RunWithoutManifestPathTests < RunSetupTests
+    desc "and the manifest path param isn't set"
+    setup do
+      @params[Dk::Pkg::MANIFEST_PATH_PARAM_NAME] = [nil, ''].sample
+    end
+
+    should "complain about the param not being set" do
+      runner = test_runner(@task_class, :params => @params)
+      assert_raises(ArgumentError){ runner.run }
+    end
+
+  end
+
+  class TestHelpersTests < UnitTests
+    desc "TestHelpers"
+    setup do
+      @context_class = Class.new do
+        def self.setup_blocks; @setup_blocks ||= []; end
+        def self.setup(&block)
+          self.setup_blocks << block
+        end
+        include Dk::Pkg::Validate::TestHelpers
+        attr_reader :dk_pkg_installed_pkgs, :params
+        def initialize
+          self.class.setup_blocks.each{ |b| self.instance_eval(&b) }
+        end
+      end
+      @context = @context_class.new
+    end
+    subject{ @context }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, Dk::Pkg::Validate::TestHelpers
+    end
+
+    should "setup the ivars and params the validate task needs" do
+      assert_not_nil subject.params[Dk::Pkg::MANIFEST_PATH_PARAM_NAME]
+
+      exp = subject.dk_pkg_installed_pkgs
+      assert_equal exp, subject.params[Dk::Pkg::INSTALLED_PKGS_PARAM_NAME]
+    end
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dk-pkg
-version: !ruby/object:Gem::Version 
-  version: 0.0.1
+version: &id002 !ruby/object:Gem::Version 
+  version: 0.1.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2016-08-11 00:00:00 Z
+date: 2016-08-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: assert
@@ -19,9 +19,28 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 2.16.1
+        version: 2.16.3
   type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: dk
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - *id002
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: much-plugin
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id004
 description: Dk logic for installing pkgs
 email: 
 - kelly@kellyredding.com
@@ -39,10 +58,18 @@ files:
 - README.md
 - dk-pkg.gemspec
 - lib/dk-pkg.rb
+- lib/dk-pkg/constants.rb
+- lib/dk-pkg/install_pkg.rb
+- lib/dk-pkg/manifest.rb
+- lib/dk-pkg/validate.rb
 - lib/dk-pkg/version.rb
 - log/.gitkeep
 - test/helper.rb
 - test/support/factory.rb
+- test/unit/dk-pkg_tests.rb
+- test/unit/install_pkg_tests.rb
+- test/unit/manifest_tests.rb
+- test/unit/validate_tests.rb
 - tmp/.gitkeep
 homepage: https://github.com/redding/dk-pkg
 licenses: 
@@ -56,13 +83,13 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - &id002 
+  - &id005 
     - ">="
     - !ruby/object:Gem::Version 
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - *id002
+  - *id005
 requirements: []
 
 rubyforge_project: 
@@ -73,3 +100,7 @@ summary: Dk logic for installing pkgs
 test_files: 
 - test/helper.rb
 - test/support/factory.rb
+- test/unit/dk-pkg_tests.rb
+- test/unit/install_pkg_tests.rb
+- test/unit/manifest_tests.rb
+- test/unit/validate_tests.rb