vagrant-dsc 0.0.1 → 1.0.0

data/spec/base.rb

@@ -1,57 +1,54 @@
-require "tmpdir"
-require "rubygems"
-
-# Gems
-require "checkpoint"
-require "rspec/autorun"
-
-# Require Vagrant itself so we can reference the proper
-# classes to test.
-require "vagrant"
-require "vagrant/util/platform"
-
-# Add the test directory to the load path
-$:.unshift File.expand_path("../../", __FILE__)
-
-# Load in helpers
-require "vagrant/unit/support/dummy_communicator"
-require "vagrant/unit/support/dummy_provider"
-require "vagrant/unit/support/shared/base_context"
-require "vagrant/unit/support/shared/action_synced_folders_context"
-require "vagrant/unit/support/shared/capability_helpers_context"
-require "vagrant/unit/support/shared/plugin_command_context"
-require "vagrant/unit/support/shared/virtualbox_context"
-
-# Do not buffer output
-$stdout.sync = true
-$stderr.sync = true
-
-# Configure RSpec
-RSpec.configure do |c|
-  c.expect_with :rspec, :stdlib
-  c.treat_symbols_as_metadata_keys_with_true_values = true
-
-  if Vagrant::Util::Platform.windows?
-    c.filter_run_excluding :skip_windows
-  else
-    c.filter_run_excluding :windows
+shared_context "unit" do
+  before(:each) do
+    # State to store the list of registered plugins that we have to
+    # unregister later.
+    @_plugins = []
+
+    # Create a thing to store our temporary files so that they aren't
+    # unlinked right away.
+    @_temp_files = []
   end
-end
 
-# Configure VAGRANT_CWD so that the tests never find an actual
-# Vagrantfile anywhere, or at least this minimizes those chances.
-ENV["VAGRANT_CWD"] = Dir.mktmpdir("vagrant")
+  # This helper creates a temporary file and returns a Pathname
+  # object pointed to it.
+  #
+  # @return [Pathname]
+  def temporary_file(contents=nil)
+    f = Tempfile.new("vagrant-unit")
 
-# Set the dummy provider to the default for tests
-ENV["VAGRANT_DEFAULT_PROVIDER"] = "dummy"
+    if contents
+      f.write(contents)
+      f.flush
+    end
 
-# Unset all host plugins so that we aren't executing subprocess things
-# to detect a host for every test.
-Vagrant.plugin("2").manager.registered.dup.each do |plugin|
-  if plugin.components.hosts.to_hash.length > 0
-    Vagrant.plugin("2").manager.unregister(plugin)
+    # Store the tempfile in an instance variable so that it is not
+    # garbage collected, so that the tempfile is not unlinked.
+    @_temp_files << f
+
+    return Pathname.new(f.path)
+  end
+
+  # Asserts that the current (config) validation run should fail.
+  # Any error message is sufficient.
+  def assert_invalid
+    errors = subject.validate(machine)
+    if !errors.values.any? { |v| !v.empty? }
+      raise "No errors: #{errors.inspect}"
+    end
+  end
+
+  # Asserts that the current (config) validation should fail with a specific message.
+  def assert_error(error)
+    errors = subject.validate(machine)
+    raise "Error #{error} was not raised" if !errors["dsc provisioner"].include? error
+  end
+
+  # Asserts that no failures should occur in the current (config) validation run.
+  def assert_valid
+    errors = subject.validate(machine)
+    if !errors.values.all? { |v| v.empty? }
+      raise "Errors: #{errors.inspect}"
+    end
   end
-end
 
-# Disable checkpoint
-Checkpoint.disable!
+end

data/spec/provisioner/config_spec.rb

@@ -1,289 +1,147 @@
 require 'spec_helper'
 require 'vagrant-dsc/provisioner'
 require 'vagrant-dsc/config'
-require 'rspec/its'
+require 'base'
 
 describe VagrantPlugins::DSC::Config do
-  # include_context "unit"
+  include_context "unit"
   let(:instance) { described_class.new }
-
-  before { subject.finalize! }
-
-  def assert_invalid
-    errors = subject.validate(machine)
-    if !errors.values.any? { |v| !v.empty? }
-      raise "No errors: #{errors.inspect}"
-    end
-  end
-
-  def assert_valid
-    errors = subject.validate(machine)
-    if !errors.values.all? { |v| v.empty? }
-      raise "Errors: #{errors.inspect}"
-    end
-  end
+  let(:machine) { double("machine") }
 
   def valid_defaults
-    subject.image = "foo"
+    # subject.prop = value
   end
 
-
   describe "defaults" do
 
+    before do
+      env = double("environment", root_path: "/tmp/vagrant-dsc-path")
+      config = double("config")
+      machine.stub(config: config, env: env)
+
+      allow(machine).to receive(:root_path).and_return("/c/foo")
+    end
+
     # before do
     #   # By default lets be Linux for validations
     #   Vagrant::Util::Platform.stub(linux: true)
     # end
 
-    subject do
-      instance.tap do |o|
-        o.finalize!
-      end
-    end
-
-    its("manifest_file")      { expect = "default.ps1" }
-    its("manifests_path")     { expect = "." }
-    its("configuration_name") { expect = "default" }
-    its("mof_file")           { expect be_nil }
-    its("module_path")        { expect be_nil }
-    its("options")            { expect = [] }
-    its("facter")             { expect = {} }
-    its("synced_folder_type") { expect be_nil }
-    its("temp_dir")           { expect match /^\/tmp\/vagrant-dsc-*/ }
-    its("working_directory")  { expect be_nil }
+    before { subject.finalize! }
+
+    its("configuration_file")   { expect = "default.ps1" }
+    its("manifests_path")       { expect = "." }
+    its("configuration_name")   { expect = "default" }
+    its("mof_path")             { expect be_nil }
+    its("module_path")          { expect be_nil }
+    its("options")              { expect = [] }
+    its("configuration_params") { expect = {} }
+    its("synced_folder_type")   { expect be_nil }
+    its("temp_dir")             { expect match /^\/tmp\/vagrant-dsc-*/ }
+    its("working_directory")    { expect be_nil }
   end
-end
-
-
-# require_relative "../base"
-
-# require "vagrant/util/platform"
-
-# require Vagrant.source_root.join("plugins/providers/docker/config")
-
-# describe VagrantPlugins::DockerProvider::Config do
-#   include_context "unit"
-
-#   let(:machine) { double("machine") }
-
-#   let(:build_dir) do
-#     temporary_dir.tap do |dir|
-#       dir.join("Dockerfile").open("w") do |f|
-#         f.write("Hello")
-#       end
-#     end
-#   end
-
-#   def assert_invalid
-#     errors = subject.validate(machine)
-#     if !errors.values.any? { |v| !v.empty? }
-#       raise "No errors: #{errors.inspect}"
-#     end
-#   end
-
-#   def assert_valid
-#     errors = subject.validate(machine)
-#     if !errors.values.all? { |v| v.empty? }
-#       raise "Errors: #{errors.inspect}"
-#     end
-#   end
-
-#   def valid_defaults
-#     subject.image = "foo"
-#   end
-
-#   describe "defaults" do
-#     before { subject.finalize! }
-
-#     its(:build_dir) { should be_nil }
-#     its(:expose) { should eq([]) }
-#     its(:cmd) { should eq([]) }
-#     its(:env) { should eq({}) }
-#     its(:force_host_vm) { should be_false }
-#     its(:host_vm_build_dir_options) { should be_nil }
-#     its(:image) { should be_nil }
-#     its(:name) { should be_nil }
-#     its(:privileged) { should be_false }
-#     its(:vagrant_machine) { should be_nil }
-#     its(:vagrant_vagrantfile) { should be_nil }
-#   end
-
-#   before do
-#     # By default lets be Linux for validations
-#     Vagrant::Util::Platform.stub(linux: true)
-#   end
-
-#   it "should be invalid if both build dir and image are set" do
-#     subject.build_dir = build_dir
-#     subject.image = "foo"
-#     subject.finalize!
-#     assert_invalid
-#   end
-
-#   describe "#build_dir" do
-#     it "should be valid if not set with image" do
-#       subject.build_dir = nil
-#       subject.image = "foo"
-#       subject.finalize!
-#       assert_valid
-#     end
 
-#     it "should be valid with a valid directory" do
-#       subject.build_dir = build_dir
-#       subject.finalize!
-#       assert_valid
-#     end
+  describe "derived settings" do
 
-#     it "should be invalid with a directory that doesn't have a Dockerfile" do
-#       subject.build_dir = temporary_dir.to_s
-#       subject.finalize!
-#       assert_invalid
-#     end
-#   end
-
-#   describe "#expose" do
-#     before do
-#       valid_defaults
-#     end
-
-#     it "uniqs the ports" do
-#       subject.expose = [1, 1, 4, 5]
-#       subject.finalize!
-#       assert_valid
-
-#       expect(subject.expose).to eq([1, 4, 5])
-#     end
-#   end
-
-#   describe "#image" do
-#     it "should be valid if set" do
-#       subject.image = "foo"
-#       subject.finalize!
-#       assert_valid
-#     end
-
-#     it "should be invalid if not set" do
-#       subject.image = nil
-#       subject.finalize!
-#       assert_invalid
-#     end
-#   end
-
-#   describe "#link" do
-#     before do
-#       valid_defaults
-#     end
-
-#     it "should be valid with good links" do
-#       subject.link "foo:bar"
-#       subject.link "db:blah"
-#       subject.finalize!
-#       assert_valid
-#     end
-
-#     it "should be invalid if not name:alias" do
-#       subject.link "foo"
-#       subject.finalize!
-#       assert_invalid
-#     end
+    it "should derive 'configuration_name' from 'configuration_file' automatically" do
+      subject.configuration_file = "manifests/MyWebsite.ps1"
+      subject.finalize!
+      expect(subject.configuration_name).to eq("MyWebsite")
+    end
 
-#     it "should be invalid if too many colons" do
-#       subject.link "foo:bar:baz"
-#       subject.finalize!
-#       assert_invalid
-#     end
-#   end
+    it "should derive 'configuration_name' from 'configuration_file' automatically, when given multi-level file path" do
+      subject.configuration_file = "manifests/foo/MyWebsite.ps1"
+      subject.finalize!
+      expect(subject.configuration_name).to eq("MyWebsite")
+    end
 
-#   describe "#merge" do
-#     let(:one) { described_class.new }
-#     let(:two) { described_class.new }
+    it "should derive 'configuration_name' from 'configuration_file' automatically, when given no multi-level file path" do
+      subject.configuration_file = "MyWebsite.ps1"
+      subject.finalize!
+      expect(subject.configuration_name).to eq("MyWebsite")
+    end
 
-#     subject { one.merge(two) }
+    it "should detect the fully qualified path to the manifest automatically" do
+      env = double("environment", root_path: "")
+      config = double("config")
+      machine.stub(config: config, env: env)
+      allow(machine).to receive(:root_path).and_return(".")
 
-#     context "#build_dir and #image" do
-#       it "overrides image if build_dir is set previously" do
-#         one.build_dir = "foo"
-#         two.image = "bar"
+      subject.configuration_file = "manifests/MyWebsite.ps1"
 
-#         expect(subject.build_dir).to be_nil
-#         expect(subject.image).to eq("bar")
-#       end
+      subject.finalize!
+      subject.validate(machine)
 
-#       it "overrides image if build_dir is set previously" do
-#         one.image = "foo"
-#         two.build_dir = "bar"
+      basePath = File.absolute_path(File.join(File.dirname(__FILE__), '../../'))
+      expect(subject.expanded_configuration_file.to_s).to eq("#{basePath}/manifests/MyWebsite.ps1")
+    end
+  end
 
-#         expect(subject.image).to be_nil
-#         expect(subject.build_dir).to eq("bar")
-#       end
+  describe "validate" do
+    before { subject.finalize! }
 
-#       it "preserves if both set" do
-#         one.image = "foo"
-#         two.image = "baz"
-#         two.build_dir = "bar"
+    before do
+      env = double("environment", root_path: "")
+      config = double("config")
+      machine.stub(config: config, env: env)
 
-#         expect(subject.image).to eq("baz")
-#         expect(subject.build_dir).to eq("bar")
-#       end
-#     end
+      allow(machine).to receive(:root_path).and_return("/path/to/vagrant")
+    end
 
-#     context "env vars" do
-#       it "should merge the values" do
-#         one.env["foo"] = "bar"
-#         two.env["bar"] = "baz"
+    # before do
+    #   # By default lets be Linux for validations
+    #   Vagrant::Util::Platform.stub(linux: true)
+    # end
 
-#         expect(subject.env).to eq({
-#           "foo" => "bar",
-#           "bar" => "baz",
-#         })
-#       end
-#     end
+    # it "should disallow absolute module paths" do
+    # end
 
-#     context "exposed ports" do
-#       it "merges the exposed ports" do
-#         one.expose << 1234
-#         two.expose = [42, 54]
+    it "should generate a module path on the host machine relative to the Vagrantfile" do
+      subject.module_path = "foo/modules"
+      expect(subject.expanded_module_paths('/path/to/vagrant/')).to eq(["/path/to/vagrant/foo/modules"])
+    end
 
-#         expect(subject.expose).to eq([
-#           1234, 42, 54])
-#       end
-#     end
+    it "should generate module paths on the host machine relative to the Vagrantfile" do
+      subject.module_path = ["dont/exist", "also/dont/exist"]
+      expect(subject.expanded_module_paths('/path/to/vagrant/')).to eq(["/path/to/vagrant/dont/exist", "/path/to/vagrant/also/dont/exist"])
+    end
 
-#     context "links" do
-#       it "should merge the links" do
-#         one.link "foo"
-#         two.link "bar"
+    it "should be invalid if 'manifests_path' is not a real directory" do
+      subject.manifests_path = "/i/do/not/exist"
+      assert_invalid
+      assert_error("\"Path to DSC Manifest folder does not exist: /i/do/not/exist\"")
+    end
 
-#         expect(subject._links).to eq([
-#           "foo", "bar"])
-#       end
-#     end
-#   end
+    it "should be invalid if 'configuration_file' is not a real file" do
+      subject.manifests_path = "/"
+      subject.configuration_file = "notexist.pp"
+      assert_invalid
+      assert_error("\"Path to DSC Manifest does not exist: /notexist.pp\"")
+    end
 
-#   describe "#vagrant_machine" do
-#     before { valid_defaults }
+    it "should be invalid if 'module_path' is not a real directory" do
+      subject.module_path = "/i/dont/exist"
+      assert_invalid
+      assert_error("\"Path to DSC Modules does not exist: /i/dont/exist\"")
+    end
 
-#     it "should convert to a symbol" do
-#       subject.vagrant_machine = "foo"
-#       subject.finalize!
-#       assert_valid
-#       expect(subject.vagrant_machine).to eq(:foo)
-#     end
-#   end
+    it "should be invalid if 'configuration_file' and 'mof_path' provided" do
+      mof = File.new(temporary_file)
+      man = File.new(temporary_file)
 
-#   describe "#vagrant_vagrantfile" do
-#     before { valid_defaults }
+      subject.configuration_file = File.basename(man)
+      subject.mof_path = File.basename(mof)
+      expect { subject.finalize! }.to raise_error("\"Cannot provide configuration_file and mof_path at the same time. Please provide only one of the two.\"")
+      # assert_error("\"Cannot provide configuration_file and mof_path at the same time. Please provide only one of the two.\"")
+    end
 
-#     it "should be valid if set to a file" do
-#       subject.vagrant_vagrantfile = temporary_file.to_s
-#       subject.finalize!
-#       assert_valid
-#     end
+    it "should be valid if 'configuration_file' is a real file" do
+      file = File.new(temporary_file)
 
-#     it "should not be valid if set to a non-existent place" do
-#       subject.vagrant_vagrantfile = "/i/shouldnt/exist"
-#       subject.finalize!
-#       assert_invalid
-#     end
-#   end
-# end
+      subject.configuration_file = File.basename(file)
+      subject.manifests_path = File.dirname(file)
+      subject.module_path = File.dirname(file)
+      assert_valid
+    end
+  end
+end