diff --git a/spec/integration/indirector/direct_file_server_spec.rb b/spec/integration/indirector/direct_file_server_spec.rb
index 231a1a50b..de656a3e9 100755
--- a/spec/integration/indirector/direct_file_server_spec.rb
+++ b/spec/integration/indirector/direct_file_server_spec.rb
@@ -1,65 +1,69 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/indirector/file_content/file'
 
-describe Puppet::Indirector::DirectFileServer, " when interacting with the filesystem and the model", :fails_on_windows => true do
+describe Puppet::Indirector::DirectFileServer, " when interacting with the filesystem and the model" do
   include PuppetSpec::Files
 
   before do
     # We just test a subclass, since it's close enough.
     @terminus = Puppet::Indirector::FileContent::File.new
 
     @filepath = make_absolute("/path/to/my/file")
   end
 
   it "should return an instance of the model" do
-    FileTest.expects(:exists?).with(@filepath).returns(true)
+    pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+      FileTest.expects(:exists?).with(@filepath).returns(true)
 
-    @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}")).should be_instance_of(Puppet::FileServing::Content)
+      @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}")).should be_instance_of(Puppet::FileServing::Content)
+    end
   end
 
   it "should return an instance capable of returning its content" do
-    FileTest.expects(:exists?).with(@filepath).returns(true)
-    File.stubs(:lstat).with(@filepath).returns(stub("stat", :ftype => "file"))
-    IO.expects(:binread).with(@filepath).returns("my content")
+    pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+      FileTest.expects(:exists?).with(@filepath).returns(true)
+      File.stubs(:lstat).with(@filepath).returns(stub("stat", :ftype => "file"))
+      IO.expects(:binread).with(@filepath).returns("my content")
 
-    instance = @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}"))
+      instance = @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}"))
 
-    instance.content.should == "my content"
+      instance.content.should == "my content"
+    end
   end
 end
 
 describe Puppet::Indirector::DirectFileServer, " when interacting with FileServing::Fileset and the model" do
   include PuppetSpec::Files
 
   let(:path) { tmpdir('direct_file_server_testing') }
 
   before do
     @terminus = Puppet::Indirector::FileContent::File.new
 
     File.open(File.join(path, "one"), "w") { |f| f.print "one content" }
     File.open(File.join(path, "two"), "w") { |f| f.print "two content" }
 
     @request = @terminus.indirection.request(:search, "file:///#{path}", :recurse => true)
   end
 
   it "should return an instance for every file in the fileset" do
     result = @terminus.search(@request)
     result.should be_instance_of(Array)
     result.length.should == 3
     result.each { |r| r.should be_instance_of(Puppet::FileServing::Content) }
   end
 
   it "should return instances capable of returning their content" do
     @terminus.search(@request).each do |instance|
       case instance.full_path
       when /one/; instance.content.should == "one content"
       when /two/; instance.content.should == "two content"
       when path
       else
         raise "No valid key for #{instance.path.inspect}"
       end
     end
   end
 end
diff --git a/spec/integration/parser/compiler_spec.rb b/spec/integration/parser/compiler_spec.rb
index e7b56e353..0c817be80 100755
--- a/spec/integration/parser/compiler_spec.rb
+++ b/spec/integration/parser/compiler_spec.rb
@@ -1,281 +1,282 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Parser::Compiler do
   before :each do
     @node = Puppet::Node.new "testnode"
 
     @scope_resource = stub 'scope_resource', :builtin? => true, :finish => nil, :ref => 'Class[main]'
     @scope = stub 'scope', :resource => @scope_resource, :source => mock("source")
   end
 
   after do
     Puppet.settings.clear
   end
 
-  it "should be able to determine the configuration version from a local version control repository", :fails_on_windows => true do
-    # This should always work, because we should always be
-    # in the puppet repo when we run this.
-    version = %x{git rev-parse HEAD}.chomp
+  it "should be able to determine the configuration version from a local version control repository" do
+    pending("Bug #14071 about semantics of Puppet::Util::Execute on Windows", :if => Puppet.features.microsoft_windows?) do
+      # This should always work, because we should always be
+      # in the puppet repo when we run this.
+      version = %x{git rev-parse HEAD}.chomp
 
-    # REMIND: this fails on Windows due to #8410, re-enable the test when it is fixed
-    Puppet.settings[:config_version] = 'git rev-parse HEAD'
+      Puppet.settings[:config_version] = 'git rev-parse HEAD'
 
-    @parser = Puppet::Parser::Parser.new "development"
-    @compiler = Puppet::Parser::Compiler.new(@node)
+      @parser = Puppet::Parser::Parser.new "development"
+      @compiler = Puppet::Parser::Compiler.new(@node)
 
-    @compiler.catalog.version.should == version
+      @compiler.catalog.version.should == version
+    end
   end
 
   it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
     Puppet[:code] = <<-PP
       class foo
       {
         notify { foo_notify: }
         include bar
       }
       class bar
       {
         notify { bar_notify: }
       }
     PP
 
     @node.stubs(:classes).returns(['foo', 'bar'])
 
     catalog = Puppet::Parser::Compiler.compile(@node)
 
     catalog.resource("Notify[foo_notify]").should_not be_nil
     catalog.resource("Notify[bar_notify]").should_not be_nil
   end
 
   describe "when resolving class references" do
     it "should favor local scope, even if there's an included class in topscope" do
       Puppet[:code] = <<-PP
         class experiment {
           class baz {
           }
           notify {"x" : require => Class[Baz] }
         }
         class baz {
         }
         include baz
         include experiment
         include experiment::baz
       PP
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
       notify_resource = catalog.resource( "Notify[x]" )
 
       notify_resource[:require].title.should == "Experiment::Baz"
     end
 
     it "should favor local scope, even if there's an unincluded class in topscope" do
       Puppet[:code] = <<-PP
         class experiment {
           class baz {
           }
           notify {"x" : require => Class[Baz] }
         }
         class baz {
         }
         include experiment
         include experiment::baz
       PP
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
       notify_resource = catalog.resource( "Notify[x]" )
 
       notify_resource[:require].title.should == "Experiment::Baz"
     end
   end
 
   it "should recompute the version after input files are re-parsed" do
     Puppet[:code] = 'class foo { }'
     Time.stubs(:now).returns(1)
     node = Puppet::Node.new('mynode')
     Puppet::Parser::Compiler.compile(node).version.should == 1
     Time.stubs(:now).returns(2)
     Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
     Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
     Puppet::Parser::Compiler.compile(node).version.should == 2
   end
 
   ['class', 'define', 'node'].each do |thing|
     it "should not allow #{thing} inside evaluated conditional constructs" do
       Puppet[:code] = <<-PP
         if true {
           #{thing} foo {
           }
           notify { decoy: }
         }
       PP
 
       begin
         Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
         raise "compilation should have raised Puppet::Error"
       rescue Puppet::Error => e
         e.message.should =~ /at line 2/
       end
     end
   end
 
   it "should not allow classes inside unevaluated conditional constructs" do
     Puppet[:code] = <<-PP
       if false {
         class foo {
         }
       }
     PP
 
     lambda { Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode")) }.should raise_error(Puppet::Error)
   end
 
   describe "when defining relationships" do
     def extract_name(ref)
       ref.sub(/File\[(\w+)\]/, '\1')
     end
 
     let(:node) { Puppet::Node.new('mynode') }
     let(:code) do
       <<-MANIFEST
         file { [a,b,c]:
           mode => 0644,
         }
         file { [d,e]:
           mode => 0755,
         }
       MANIFEST
     end
     let(:expected_relationships) { [] }
     let(:expected_subscriptions) { [] }
 
     before :each do
       Puppet[:code] = code
     end
 
     after :each do
       catalog = described_class.compile(node)
 
       resources = catalog.resources.select { |res| res.type == 'File' }
 
       actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
         resources.map do |res|
           dependents = Array(res[relation])
           dependents.map { |ref| [res.title, extract_name(ref)] }
         end.inject(&:concat)
       end
 
       actual_relationships.should =~ expected_relationships
       actual_subscriptions.should =~ expected_subscriptions
     end
 
     it "should create a relationship" do
       code << "File[a] -> File[b]"
 
       expected_relationships << ['a','b']
     end
 
     it "should create a subscription" do
       code << "File[a] ~> File[b]"
 
       expected_subscriptions << ['a', 'b']
     end
 
     it "should create relationships using title arrays" do
       code << "File[a,b] -> File[c,d]"
 
       expected_relationships.concat [
         ['a', 'c'],
         ['b', 'c'],
         ['a', 'd'],
         ['b', 'd'],
       ]
     end
 
     it "should create relationships using collection expressions" do
       code << "File <| mode == 0644 |> -> File <| mode == 0755 |>"
 
       expected_relationships.concat [
         ['a', 'd'],
         ['b', 'd'],
         ['c', 'd'],
         ['a', 'e'],
         ['b', 'e'],
         ['c', 'e'],
       ]
     end
 
     it "should create relationships using resource names" do
       code << "'File[a]' -> 'File[b]'"
 
       expected_relationships << ['a', 'b']
     end
 
     it "should create relationships using variables" do
       code << <<-MANIFEST
         $var = File[a]
         $var -> File[b]
       MANIFEST
 
       expected_relationships << ['a', 'b']
     end
 
     it "should create relationships using case statements" do
       code << <<-MANIFEST
         $var = 10
         case $var {
           10: {
             file { s1: }
           }
           12: {
             file { s2: }
           }
         }
         ->
         case $var + 2 {
           10: {
             file { t1: }
           }
           12: {
             file { t2: }
           }
         }
       MANIFEST
 
       expected_relationships << ['s1', 't2']
     end
 
     it "should create relationships using array members" do
       code << <<-MANIFEST
         $var = [ [ [ File[a], File[b] ] ] ]
         $var[0][0][0] -> $var[0][0][1]
       MANIFEST
 
       expected_relationships << ['a', 'b']
     end
 
     it "should create relationships using hash members" do
       code << <<-MANIFEST
         $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
         $var[foo][bar][source] -> $var[foo][bar][target]
       MANIFEST
 
       expected_relationships << ['a', 'b']
     end
 
     it "should create relationships using resource declarations" do
       code << "file { l: } -> file { r: }"
 
       expected_relationships << ['l', 'r']
     end
 
     it "should chain relationships" do
       code << "File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]"
 
       expected_relationships << ['a', 'b'] << ['d', 'c']
       expected_subscriptions << ['b', 'c'] << ['e', 'd']
     end
   end
 end
diff --git a/spec/integration/provider/package_spec.rb b/spec/integration/provider/package_spec.rb
index 2c6a92d74..435a45d05 100755
--- a/spec/integration/provider/package_spec.rb
+++ b/spec/integration/provider/package_spec.rb
@@ -1,44 +1,44 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe "Package provider" do
   include PuppetSpec::Files
 
   Puppet::Type.type(:package).providers.each do |name|
     provider = Puppet::Type.type(:package).provider(name)
 
     describe name, :if => provider.suitable? do
       it "should fail when asked to install an invalid package" do
         pending("This test hangs forever with recent versions of RubyGems") if provider.name == :gem
 
         options = {:name => "nosuch#{provider.name}", :provider => provider.name}
         # The MSI provider requires that source be specified as it is
         # what actually determines if the package exists.
         if provider.name == :msi
           options[:source] = tmpfile("msi_package")
         end
 
         pkg = Puppet::Type.newpackage(options)
         lambda { pkg.provider.install }.should raise_error
       end
 
-      it "should be able to get a list of existing packages", :fails_on_windows => true do
+      it "should be able to get a list of existing packages" do
         if provider.name == :msi
           Puppet[:vardir] = tmpdir('msi_package_var_dir')
         end
 
         # the instances method requires root priviledges on gentoo
         # if the eix cache is outdated (to run eix-update) so make
         # sure we dont actually run eix-update
         if provider.name == :portage
           provider.stubs(:update_eix).returns('Database contains 15240 packages in 155 categories')
         end
 
         provider.instances.each do |package|
           package.should be_instance_of(provider)
           package.properties[:provider].should == provider.name
         end
       end
     end
   end
 end
diff --git a/spec/unit/face/module/list_spec.rb b/spec/unit/face/module/list_spec.rb
index fa1636a4b..21ce5b43e 100644
--- a/spec/unit/face/module/list_spec.rb
+++ b/spec/unit/face/module/list_spec.rb
@@ -1,182 +1,184 @@
 # encoding: UTF-8
 
 require 'spec_helper'
 require 'puppet/face'
 require 'puppet/module_tool'
 require 'puppet_spec/modules'
 
-describe "puppet module list", :fails_on_windows => true do
+describe "puppet module list" do
   include PuppetSpec::Files
 
   before do
     dir = tmpdir("deep_path")
 
     @modpath1 = File.join(dir, "modpath1")
     @modpath2 = File.join(dir, "modpath2")
     @modulepath = "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}"
     Puppet.settings[:modulepath] = @modulepath
 
     FileUtils.mkdir_p(@modpath1)
     FileUtils.mkdir_p(@modpath2)
   end
 
   it "should return an empty list per dir in path if there are no modules" do
     Puppet.settings[:modulepath] = @modulepath
     Puppet::Face[:module, :current].list.should == {
       @modpath1 => [],
       @modpath2 => []
     }
   end
 
   it "should include modules separated by the environment's modulepath" do
     foomod1 = PuppetSpec::Modules.create('foo', @modpath1)
     barmod1 = PuppetSpec::Modules.create('bar', @modpath1)
     foomod2 = PuppetSpec::Modules.create('foo', @modpath2)
 
     env = Puppet::Node::Environment.new
 
     Puppet::Face[:module, :current].list.should == {
       @modpath1 => [
         Puppet::Module.new('bar', :environment => env, :path => barmod1.path),
         Puppet::Module.new('foo', :environment => env, :path => foomod1.path)
       ],
       @modpath2 => [Puppet::Module.new('foo', :environment => env, :path => foomod2.path)]
     }
   end
 
   it "should use the specified environment" do
     PuppetSpec::Modules.create('foo', @modpath1)
     PuppetSpec::Modules.create('bar', @modpath1)
 
     usedenv = Puppet::Node::Environment.new('useme')
     usedenv.modulepath = [@modpath1, @modpath2]
 
     Puppet::Face[:module, :current].list(:environment => 'useme').should == {
       @modpath1 => [
         Puppet::Module.new('bar', :environment => usedenv),
         Puppet::Module.new('foo', :environment => usedenv)
       ],
       @modpath2 => []
     }
   end
 
   it "should use the specified modulepath" do
     PuppetSpec::Modules.create('foo', @modpath1)
     PuppetSpec::Modules.create('bar', @modpath2)
 
     Puppet::Face[:module, :current].list(:modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}").should == {
       @modpath1 => [ Puppet::Module.new('foo') ],
       @modpath2 => [ Puppet::Module.new('bar') ]
     }
   end
 
   it "should use the specified modulepath over the specified environment in place of the environment's default path" do
     foomod1 = PuppetSpec::Modules.create('foo', @modpath1)
     barmod2 = PuppetSpec::Modules.create('bar', @modpath2)
     env = Puppet::Node::Environment.new('myenv')
     env.modulepath = ['/tmp/notused']
 
     list = Puppet::Face[:module, :current].list(:environment => 'myenv', :modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}")
 
     # Changing Puppet[:modulepath] causes Puppet::Node::Environment.new('myenv')
     # to have a different object_id than the env above
     env = Puppet::Node::Environment.new('myenv')
     list.should == {
       @modpath1 => [ Puppet::Module.new('foo', :environment => env, :path => foomod1.path) ],
       @modpath2 => [ Puppet::Module.new('bar', :environment => env, :path => barmod2.path) ]
     }
   end
 
   describe "inline documentation" do
     subject { Puppet::Face[:module, :current].get_action :list }
 
     its(:summary)     { should =~ /list.*module/im }
     its(:description) { should =~ /list.*module/im }
     its(:returns)     { should =~ /hash of paths to module objects/i }
     its(:examples)    { should_not be_empty }
   end
 
   describe "when rendering" do
     it "should explicitly state when a modulepath is empty" do
       empty_modpath = tmpdir('empty')
       Puppet::Face[:module, :current].list_when_rendering_console(
         { empty_modpath => [] },
         {:modulepath => empty_modpath}
       ).should == <<-HEREDOC.gsub('        ', '')
         #{empty_modpath} (no modules installed)
       HEREDOC
     end
 
     it "should print both modules with and without metadata" do
-      modpath = tmpdir('modpath')
-      Puppet.settings[:modulepath] = modpath
-      PuppetSpec::Modules.create('nometadata', modpath)
-      PuppetSpec::Modules.create('metadata', modpath, :metadata => {:author => 'metaman'})
+      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+        modpath = tmpdir('modpath')
+        Puppet.settings[:modulepath] = modpath
+        PuppetSpec::Modules.create('nometadata', modpath)
+        PuppetSpec::Modules.create('metadata', modpath, :metadata => {:author => 'metaman'})
 
-      dependency_tree = Puppet::Face[:module, :current].list
+        dependency_tree = Puppet::Face[:module, :current].list
 
-      output = Puppet::Face[:module, :current].list_when_rendering_console(
-        dependency_tree,
-        {}
-      )
+        output = Puppet::Face[:module, :current].
+          list_when_rendering_console(dependency_tree, {})
 
-      output.should == <<-HEREDOC.gsub('        ', '')
+        output.should == <<-HEREDOC.gsub('        ', '')
         #{modpath}
         ├── metaman-metadata (\e[0;36mv9.9.9\e[0m)
         └── nometadata (\e[0;36m???\e[0m)
-      HEREDOC
+        HEREDOC
+      end
     end
 
     it "should print the modulepaths in the order they are in the modulepath setting" do
       path1 = tmpdir('b')
       path2 = tmpdir('c')
       path3 = tmpdir('a')
 
       sep = File::PATH_SEPARATOR
       Puppet.settings[:modulepath] = "#{path1}#{sep}#{path2}#{sep}#{path3}"
 
       Puppet::Face[:module, :current].list_when_rendering_console(
         {
           path2 => [],
           path3 => [],
           path1 => [],
         },
         {}
       ).should == <<-HEREDOC.gsub('        ', '')
         #{path1} (no modules installed)
         #{path2} (no modules installed)
         #{path3} (no modules installed)
       HEREDOC
     end
 
     it "should print dependencies as a tree" do
-      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '0.0.5'})
-      PuppetSpec::Modules.create(
-        'other_mod',
-        @modpath1,
-        :metadata => {
-          :version => '1.0.0',
-          :dependencies => [{
-            "version_requirement" => ">= 0.0.5",
-            "name"                => "puppetlabs/dependable"
-          }]
-        }
-      )
-
-      dependency_tree = Puppet::Face[:module, :current].list
-
-      output = Puppet::Face[:module, :current].list_when_rendering_console(
-        dependency_tree,
-        {:tree => true}
-      )
-
-      output.should == <<-HEREDOC.gsub('        ', '')
+      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+        PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '0.0.5'})
+        PuppetSpec::Modules.create(
+          'other_mod',
+          @modpath1,
+          :metadata => {
+            :version => '1.0.0',
+            :dependencies => [{
+              "version_requirement" => ">= 0.0.5",
+              "name"                => "puppetlabs/dependable"
+            }]
+          }
+        )
+
+        dependency_tree = Puppet::Face[:module, :current].list
+
+        output = Puppet::Face[:module, :current].list_when_rendering_console(
+          dependency_tree,
+          {:tree => true}
+        )
+
+        output.should == <<-HEREDOC.gsub('        ', '')
         #{@modpath1}
         └─┬ puppetlabs-other_mod (\e[0;36mv1.0.0\e[0m)
           └── puppetlabs-dependable (\e[0;36mv0.0.5\e[0m)
         #{@modpath2} (no modules installed)
-      HEREDOC
+        HEREDOC
+      end
     end
   end
 
 end
diff --git a/spec/unit/face/module/search_spec.rb b/spec/unit/face/module/search_spec.rb
index 51f62bd1f..cd17eb25d 100644
--- a/spec/unit/face/module/search_spec.rb
+++ b/spec/unit/face/module/search_spec.rb
@@ -1,163 +1,163 @@
 require 'spec_helper'
 require 'puppet/face'
 require 'puppet/application/module'
 require 'puppet/module_tool'
 
-describe "puppet module search", :fails_on_windows => true do
+describe "puppet module search" do
   subject { Puppet::Face[:module, :current] }
 
   let(:options) do
     {}
   end
 
   describe Puppet::Application::Module do
     subject do
       app = Puppet::Application::Module.new
       app.stubs(:action).returns(Puppet::Face.find_action(:module, :search))
       app
     end
 
     before { subject.render_as = :console }
     before { Puppet::Util::Terminal.stubs(:width).returns(100) }
 
     it 'should output nothing when receiving an empty dataset' do
       subject.render([], ['apache', {}]).should == "No results found for 'apache'."
     end
 
     it 'should output a header when receiving a non-empty dataset' do
       results = [
         {'full_name' => '', 'author' => '', 'desc' => '', 'tag_list' => [] },
       ]
 
       subject.render(results, ['apache', {}]).should =~ /NAME/
       subject.render(results, ['apache', {}]).should =~ /DESCRIPTION/
       subject.render(results, ['apache', {}]).should =~ /AUTHOR/
       subject.render(results, ['apache', {}]).should =~ /KEYWORDS/
     end
 
     it 'should output the relevant fields when receiving a non-empty dataset' do
       results = [
         {'full_name' => 'Name', 'author' => 'Author', 'desc' => 'Summary', 'tag_list' => ['tag1', 'tag2'] },
       ]
 
       subject.render(results, ['apache', {}]).should =~ /Name/
       subject.render(results, ['apache', {}]).should =~ /Author/
       subject.render(results, ['apache', {}]).should =~ /Summary/
       subject.render(results, ['apache', {}]).should =~ /tag1/
       subject.render(results, ['apache', {}]).should =~ /tag2/
     end
 
     it 'should elide really long descriptions' do
       results = [
         {
           'full_name' => 'Name',
           'author' => 'Author',
           'desc' => 'This description is really too long to fit in a single data table, guys -- we should probably set about truncating it',
           'tag_list' => ['tag1', 'tag2'],
         },
       ]
 
       subject.render(results, ['apache', {}]).should =~ /\.{3}  @Author/
     end
 
     it 'should never truncate the module name' do
       results = [
         {
           'full_name' => 'This-module-has-a-really-really-long-name',
           'author' => 'Author',
           'desc' => 'Description',
           'tag_list' => ['tag1', 'tag2'],
         },
       ]
 
       subject.render(results, ['apache', {}]).should =~ /This-module-has-a-really-really-long-name/
     end
 
     it 'should never truncate the author name' do
       results = [
         {
           'full_name' => 'Name',
           'author' => 'This-author-has-a-really-really-long-name',
           'desc' => 'Description',
           'tag_list' => ['tag1', 'tag2'],
         },
       ]
 
       subject.render(results, ['apache', {}]).should =~ /@This-author-has-a-really-really-long-name/
     end
 
     it 'should never remove tags that match the search term' do
       results = [
         {
           'full_name' => 'Name',
           'author' => 'Author',
           'desc' => 'Description',
           'tag_list' => ['Supercalifragilisticexpialidocious'] + (1..100).map { |i| "tag#{i}" },
         },
       ]
 
       subject.render(results, ['Supercalifragilisticexpialidocious', {}]).should =~ /Supercalifragilisticexpialidocious/
       subject.render(results, ['Supercalifragilisticexpialidocious', {}]).should_not =~ /tag/
     end
 
     {
       100 => "NAME          DESCRIPTION                                     AUTHOR         KEYWORDS#{' '*15}\n"\
              "Name          This description is really too long to fit ...  @JohnnyApples  tag1 tag2 taggitty3#{' '*4}\n",
 
       70  => "NAME          DESCRIPTION                 AUTHOR         KEYWORDS#{' '*5}\n"\
              "Name          This description is rea...  @JohnnyApples  tag1 tag2#{' '*4}\n",
 
       80  => "NAME          DESCRIPTION                        AUTHOR         KEYWORDS#{' '*8}\n"\
              "Name          This description is really too...  @JohnnyApples  tag1 tag2#{' '*7}\n",
 
       200 => "NAME          DESCRIPTION                                                                                                        AUTHOR         KEYWORDS#{' '*48}\n"\
              "Name          This description is really too long to fit in a single data table, guys -- we should probably set about trunca...  @JohnnyApples  tag1 tag2 taggitty3#{' '*37}\n"
     }.each do |width, expectation|
       it "should resize the table to fit the screen, when #{width} columns" do
         results = [
           {
             'full_name' => 'Name',
             'author' => 'JohnnyApples',
             'desc' => 'This description is really too long to fit in a single data table, guys -- we should probably set about truncating it',
             'tag_list' => ['tag1', 'tag2', 'taggitty3'],
           },
         ]
 
         Puppet::Util::Terminal.expects(:width).returns(width)
         result = subject.render(results, ['apache', {}])
         result.lines.sort_by(&:length).last.chomp.length.should <= width
         result.should == expectation
       end
     end
   end
 
   describe "option validation" do
     context "without any options" do
       it "should require a search term" do
         pattern = /wrong number of arguments/
         expect { subject.search }.to raise_error ArgumentError, pattern
       end
     end
 
     it "should accept the --module-repository option" do
       options[:module_repository] = "http://forge.example.com"
       Puppet::Module::Tool::Applications::Searcher.expects(:run).with("puppetlabs-apache", options).once
       subject.search("puppetlabs-apache", options)
     end
   end
 
   describe "inline documentation" do
     subject { Puppet::Face[:module, :current].get_action :search }
 
     its(:summary)     { should =~ /search.*module/im }
     its(:description) { should =~ /search.*module/im }
     its(:returns)     { should =~ /array/i }
     its(:examples)    { should_not be_empty }
 
     %w{ license copyright summary description returns examples }.each do |doc|
       context "of the" do
         its(doc.to_sym) { should_not =~ /(FIXME|REVISIT|TODO)/ }
       end
     end
   end
 end
diff --git a/spec/unit/indirector/certificate_status/file_spec.rb b/spec/unit/indirector/certificate_status/file_spec.rb
index c5d4e283f..c26f6820f 100755
--- a/spec/unit/indirector/certificate_status/file_spec.rb
+++ b/spec/unit/indirector/certificate_status/file_spec.rb
@@ -1,191 +1,203 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/ssl/host'
 require 'puppet/indirector/certificate_status'
 require 'tempfile'
 
-describe "Puppet::Indirector::CertificateStatus::File", :fails_on_windows => true do
+describe "Puppet::Indirector::CertificateStatus::File" do
   include PuppetSpec::Files
 
   before :all do
     Puppet::SSL::Host.configure_indirection(:file)
   end
 
   before do
     Puppet::SSL::CertificateAuthority.stubs(:ca?).returns true
     @terminus = Puppet::SSL::Host.indirection.terminus(:file)
 
     @tmpdir = tmpdir("certificate_status_ca_testing")
     Puppet[:confdir] = @tmpdir
     Puppet[:vardir] = @tmpdir
 
     # localcacert is where each client stores the CA certificate
     # cacert is where the master stores the CA certificate
     # Since we need to play the role of both for testing we need them to be the same and exist
     Puppet[:cacert] = Puppet[:localcacert]
   end
 
   def generate_csr(host)
     host.generate_key
     csr = Puppet::SSL::CertificateRequest.new(host.name)
     csr.generate(host.key.content)
     Puppet::SSL::CertificateRequest.indirection.save(csr)
   end
 
   def sign_csr(host)
     host.desired_state = "signed"
     @terminus.save(Puppet::Indirector::Request.new(:certificate_status, :save, host.name, host))
   end
 
   def generate_signed_cert(host)
     generate_csr(host)
     sign_csr(host)
 
     @terminus.find(Puppet::Indirector::Request.new(:certificate_status, :find, host.name, host))
   end
 
   def generate_revoked_cert(host)
     generate_signed_cert(host)
 
     host.desired_state = "revoked"
 
     @terminus.save(Puppet::Indirector::Request.new(:certificate_status, :save, host.name, host))
   end
 
   it "should be a terminus on SSL::Host" do
     @terminus.should be_instance_of(Puppet::Indirector::CertificateStatus::File)
   end
 
   it "should create a CA instance if none is present" do
     @terminus.ca.should be_instance_of(Puppet::SSL::CertificateAuthority)
   end
 
   describe "when creating the CA" do
     it "should fail if it is not a valid CA" do
       Puppet::SSL::CertificateAuthority.expects(:ca?).returns false
       lambda { @terminus.ca }.should raise_error(ArgumentError, "This process is not configured as a certificate authority")
     end
   end
 
   it "should be indirected with the name 'certificate_status'" do
     Puppet::SSL::Host.indirection.name.should == :certificate_status
   end
 
   describe "when finding" do
     before do
       @host = Puppet::SSL::Host.new("foo")
       Puppet.settings.use(:main)
     end
 
     it "should return the Puppet::SSL::Host when a CSR exists for the host" do
-      generate_csr(@host)
-      request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
+      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+        generate_csr(@host)
+        request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
 
-      retrieved_host = @terminus.find(request)
+        retrieved_host = @terminus.find(request)
 
-      retrieved_host.name.should == @host.name
-      retrieved_host.certificate_request.content.to_s.chomp.should == @host.certificate_request.content.to_s.chomp
+        retrieved_host.name.should == @host.name
+        retrieved_host.certificate_request.content.to_s.chomp.should == @host.certificate_request.content.to_s.chomp
+      end
     end
 
     it "should return the Puppet::SSL::Host when a public key exist for the host" do
-      generate_signed_cert(@host)
-      request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
+      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+        generate_signed_cert(@host)
+        request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
 
-      retrieved_host = @terminus.find(request)
+        retrieved_host = @terminus.find(request)
 
-      retrieved_host.name.should == @host.name
-      retrieved_host.certificate.content.to_s.chomp.should == @host.certificate.content.to_s.chomp
+        retrieved_host.name.should == @host.name
+        retrieved_host.certificate.content.to_s.chomp.should == @host.certificate.content.to_s.chomp
+      end
     end
 
     it "should return nil when neither a CSR nor public key exist for the host" do
       request = Puppet::Indirector::Request.new(:certificate_status, :find, "foo", @host)
       @terminus.find(request).should == nil
     end
   end
 
   describe "when saving" do
     before do
       @host = Puppet::SSL::Host.new("foobar")
       Puppet.settings.use(:main)
     end
 
     describe "when signing a cert" do
       before do
         @host.desired_state = "signed"
         @request = Puppet::Indirector::Request.new(:certificate_status, :save, "foobar", @host)
       end
 
       it "should fail if no CSR is on disk" do
         lambda { @terminus.save(@request) }.should raise_error(Puppet::Error, /certificate request/)
       end
 
       it "should sign the on-disk CSR when it is present" do
-        signed_host = generate_signed_cert(@host)
+        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+          signed_host = generate_signed_cert(@host)
 
-        signed_host.state.should == "signed"
-        Puppet::SSL::Certificate.indirection.find("foobar").should be_instance_of(Puppet::SSL::Certificate)
+          signed_host.state.should == "signed"
+          Puppet::SSL::Certificate.indirection.find("foobar").should be_instance_of(Puppet::SSL::Certificate)
+        end
       end
     end
 
     describe "when revoking a cert" do
       before do
         @request = Puppet::Indirector::Request.new(:certificate_status, :save, "foobar", @host)
       end
 
       it "should fail if no certificate is on disk" do
         @host.desired_state = "revoked"
         lambda { @terminus.save(@request) }.should raise_error(Puppet::Error, /Cannot revoke/)
       end
 
       it "should revoke the certificate when it is present" do
-        generate_revoked_cert(@host)
+        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+          generate_revoked_cert(@host)
 
-        @host.state.should == 'revoked'
+          @host.state.should == 'revoked'
+        end
       end
     end
   end
 
   describe "when deleting" do
     before do
       Puppet.settings.use(:main)
     end
 
     it "should not delete anything if no certificate, request, or key is on disk" do
       host = Puppet::SSL::Host.new("clean_me")
       request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_me", host)
       @terminus.destroy(request).should == "Nothing was deleted"
     end
 
     it "should clean certs, cert requests, keys" do
-      signed_host = Puppet::SSL::Host.new("clean_signed_cert")
-      generate_signed_cert(signed_host)
-      signed_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_signed_cert", signed_host)
-      @terminus.destroy(signed_request).should == "Deleted for clean_signed_cert: Puppet::SSL::Certificate, Puppet::SSL::Key"
-
-      requested_host = Puppet::SSL::Host.new("clean_csr")
-      generate_csr(requested_host)
-      csr_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_csr", requested_host)
-      @terminus.destroy(csr_request).should == "Deleted for clean_csr: Puppet::SSL::CertificateRequest, Puppet::SSL::Key"
+      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+        signed_host = Puppet::SSL::Host.new("clean_signed_cert")
+        generate_signed_cert(signed_host)
+        signed_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_signed_cert", signed_host)
+        @terminus.destroy(signed_request).should == "Deleted for clean_signed_cert: Puppet::SSL::Certificate, Puppet::SSL::Key"
+
+        requested_host = Puppet::SSL::Host.new("clean_csr")
+        generate_csr(requested_host)
+        csr_request = Puppet::Indirector::Request.new(:certificate_status, :delete, "clean_csr", requested_host)
+        @terminus.destroy(csr_request).should == "Deleted for clean_csr: Puppet::SSL::CertificateRequest, Puppet::SSL::Key"
+      end
     end
   end
 
   describe "when searching" do
     it "should return a list of all hosts with certificate requests, signed certs, or revoked certs" do
-      Puppet.settings.use(:main)
+      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+        Puppet.settings.use(:main)
 
-      signed_host = Puppet::SSL::Host.new("signed_host")
-      generate_signed_cert(signed_host)
+        signed_host = Puppet::SSL::Host.new("signed_host")
+        generate_signed_cert(signed_host)
 
-      requested_host = Puppet::SSL::Host.new("requested_host")
-      generate_csr(requested_host)
+        requested_host = Puppet::SSL::Host.new("requested_host")
+        generate_csr(requested_host)
 
-      revoked_host = Puppet::SSL::Host.new("revoked_host")
-      generate_revoked_cert(revoked_host)
+        revoked_host = Puppet::SSL::Host.new("revoked_host")
+        generate_revoked_cert(revoked_host)
 
-      retrieved_hosts = @terminus.search(Puppet::Indirector::Request.new(:certificate_status, :search, "all", signed_host))
+        retrieved_hosts = @terminus.search(Puppet::Indirector::Request.new(:certificate_status, :search, "all", signed_host))
 
-      results = retrieved_hosts.map {|h| [h.name, h.state]}.sort{ |h,i| h[0] <=> i[0] }
-      results.should == [["ca","signed"],["requested_host","requested"],["revoked_host","revoked"],["signed_host","signed"]]
+        results = retrieved_hosts.map {|h| [h.name, h.state]}.sort{ |h,i| h[0] <=> i[0] }
+        results.should == [["ca","signed"],["requested_host","requested"],["revoked_host","revoked"],["signed_host","signed"]]
+      end
     end
   end
 end
diff --git a/spec/unit/module_spec.rb b/spec/unit/module_spec.rb
index bb32ccdde..15f7c5090 100755
--- a/spec/unit/module_spec.rb
+++ b/spec/unit/module_spec.rb
@@ -1,855 +1,857 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_spec/modules'
 require 'puppet/module_tool/checksums'
 
 describe Puppet::Module do
   include PuppetSpec::Files
 
   before do
     # This is necessary because of the extra checks we have for the deprecated
     # 'plugins' directory
     FileTest.stubs(:exist?).returns false
   end
 
   it "should have a class method that returns a named module from a given environment" do
     env = mock 'module'
     env.expects(:module).with("mymod").returns "yep"
     Puppet::Node::Environment.expects(:new).with("myenv").returns env
 
     Puppet::Module.find("mymod", "myenv").should == "yep"
   end
 
   it "should return nil if asked for a named module that doesn't exist" do
     env = mock 'module'
     env.expects(:module).with("mymod").returns nil
     Puppet::Node::Environment.expects(:new).with("myenv").returns env
 
     Puppet::Module.find("mymod", "myenv").should be_nil
   end
 
   it "should support a 'version' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.version = 1.09
     mod.version.should == 1.09
   end
 
   it "should support a 'source' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.source = "http://foo/bar"
     mod.source.should == "http://foo/bar"
   end
 
   it "should support a 'project_page' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.project_page = "http://foo/bar"
     mod.project_page.should == "http://foo/bar"
   end
 
   it "should support an 'author' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.author = "Luke Kanies <luke@madstop.com>"
     mod.author.should == "Luke Kanies <luke@madstop.com>"
   end
 
   it "should support a 'license' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.license = "GPL2"
     mod.license.should == "GPL2"
   end
 
   it "should support a 'summary' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.summary = "GPL2"
     mod.summary.should == "GPL2"
   end
 
   it "should support a 'description' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.description = "GPL2"
     mod.description.should == "GPL2"
   end
 
   it "should support specifying a compatible puppet version" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     mod.puppetversion.should == "0.25"
   end
 
   it "should validate that the puppet version is compatible" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     Puppet.expects(:version).returns "0.25"
     mod.validate_puppet_version
   end
 
   it "should fail if the specified puppet version is not compatible" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     Puppet.stubs(:version).returns "0.24"
     lambda { mod.validate_puppet_version }.should raise_error(Puppet::Module::IncompatibleModule)
   end
 
   describe "when finding unmet dependencies" do
     before do
       FileTest.unstub(:exist?)
       @modpath = tmpdir('modpath')
       Puppet.settings[:modulepath] = @modpath
     end
 
     it "should list modules that are missing" do
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
         :metadata => {
           :dependencies => [{
             "version_requirement" => ">= 2.2.0",
             "name" => "baz/foobar"
           }]
         }
       )
       mod.unmet_dependencies.should == [{
         :reason => :missing,
         :name   => "baz/foobar",
         :version_constraint => ">= 2.2.0",
         :parent => { :name => 'puppetlabs/needy', :version => 'v9.9.9' },
         :mod_details => { :installed_version => nil }
       }]
     end
 
     it "should list modules that are missing and have invalid names" do
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
         :metadata => {
           :dependencies => [{
             "version_requirement" => ">= 2.2.0",
             "name" => "baz/foobar=bar"
           }]
         }
       )
       mod.unmet_dependencies.should == [{
         :reason => :missing,
         :name   => "baz/foobar=bar",
         :version_constraint => ">= 2.2.0",
         :parent => { :name => 'puppetlabs/needy', :version => 'v9.9.9' },
         :mod_details => { :installed_version => nil }
       }]
     end
 
     it "should list modules with unmet version requirement" do
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :dependencies => [{
             "version_requirement" => ">= 2.2.0",
             "name" => "baz/foobar"
           }]
         }
       )
       mod2 = PuppetSpec::Modules.create(
         'foobaz',
         @modpath,
         :metadata => {
           :dependencies => [{
             "version_requirement" => "1.0.0",
             "name" => "baz/foobar"
           }]
         }
       )
 
       PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => { :version => '2.0.0', :author  => 'baz' }
       )
 
       mod.unmet_dependencies.should == [{
         :reason => :version_mismatch,
         :name   => "baz/foobar",
         :version_constraint => ">= 2.2.0",
         :parent => { :version => "v9.9.9", :name => "puppetlabs/foobar" },
         :mod_details => { :installed_version => "2.0.0" }
       }]
 
       mod2.unmet_dependencies.should == [{
         :reason => :version_mismatch,
         :name   => "baz/foobar",
         :version_constraint => "v1.0.0",
         :parent => { :version => "v9.9.9", :name => "puppetlabs/foobaz" },
         :mod_details => { :installed_version => "2.0.0" }
       }]
 
     end
 
     it "should consider a dependency without a version requirement to be satisfied" do
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :dependencies => [{
             "name" => "baz/foobar"
           }]
         }
       )
       PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :version => '2.0.0',
           :author  => 'baz'
         }
       )
 
       mod.unmet_dependencies.should be_empty
     end
 
     it "should consider a dependency without a semantic version to be unmet" do
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :dependencies => [{
             "name" => "baz/foobar"
           }]
         }
       )
       PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :version => '5.1',
           :author  => 'baz'
         }
       )
 
       mod.unmet_dependencies.should == [{
         :reason => :non_semantic_version,
         :parent => { :version => "v9.9.9", :name => "puppetlabs/foobar" },
         :mod_details => { :installed_version => "5.1" },
         :name => "baz/foobar",
         :version_constraint => ">= 0.0.0"
       }]
     end
 
     it "should have valid dependencies when no dependencies have been specified" do
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :dependencies => []
         }
       )
 
       mod.unmet_dependencies.should == []
     end
 
     it "should only list unmet dependencies" do
       mod = PuppetSpec::Modules.create(
         'mymod',
         @modpath,
         :metadata => {
           :dependencies => [
             {
               "version_requirement" => ">= 2.2.0",
               "name" => "baz/satisfied"
             },
             {
               "version_requirement" => ">= 2.2.0",
               "name" => "baz/notsatisfied"
             }
           ]
         }
       )
       PuppetSpec::Modules.create(
         'satisfied',
         @modpath,
         :metadata => {
           :version => '3.3.0',
           :author  => 'baz'
         }
       )
 
       mod.unmet_dependencies.should == [{
         :reason => :missing,
         :mod_details => { :installed_version => nil },
         :parent => { :version => "v9.9.9", :name => "puppetlabs/mymod" },
         :name => "baz/notsatisfied",
         :version_constraint => ">= 2.2.0"
       }]
     end
 
     it "should be empty when all dependencies are met" do
       mod = PuppetSpec::Modules.create(
         'mymod2',
         @modpath,
         :metadata => {
           :dependencies => [
             {
               "version_requirement" => ">= 2.2.0",
               "name" => "baz/satisfied"
             },
             {
               "version_requirement" => "< 2.2.0",
               "name" => "baz/alsosatisfied"
             }
           ]
         }
       )
       PuppetSpec::Modules.create(
         'satisfied',
         @modpath,
         :metadata => {
           :version => '3.3.0',
           :author  => 'baz'
         }
       )
       PuppetSpec::Modules.create(
         'alsosatisfied',
         @modpath,
         :metadata => {
           :version => '2.1.0',
           :author  => 'baz'
         }
       )
 
       mod.unmet_dependencies.should be_empty
     end
   end
 
   describe "when managing supported platforms" do
     it "should support specifying a supported platform" do
       mod = Puppet::Module.new("mymod")
       mod.supports "solaris"
     end
 
     it "should support specifying a supported platform and version" do
       mod = Puppet::Module.new("mymod")
       mod.supports "solaris", 1.0
     end
 
     it "should fail when not running on a supported platform" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
 
       mod.supports "hpux"
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::UnsupportedPlatform)
     end
 
     it "should fail when supported platforms are present but of the wrong version" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
       Facter.expects(:value).with("operatingsystemrelease").returns 2.0
 
       mod.supports "Solaris", 1.0
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::IncompatiblePlatform)
     end
 
     it "should be considered supported when no supported platforms have been specified" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       lambda { mod.validate_supported_platform }.should_not raise_error
     end
 
     it "should be considered supported when running on a supported platform" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
       Facter.expects(:value).with("operatingsystemrelease").returns 2.0
 
       mod.supports "Solaris", 1.0
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::IncompatiblePlatform)
     end
 
     it "should be considered supported when running on any of multiple supported platforms" do
       pending "Not sure how to send client platform to the module"
     end
 
     it "should validate its platform support on initialization" do
       pending "Not sure how to send client platform to the module"
     end
   end
 
   it "should return nil if asked for a module whose name is 'nil'" do
     Puppet::Module.find(nil, "myenv").should be_nil
   end
 
   it "should provide support for logging" do
     Puppet::Module.ancestors.should be_include(Puppet::Util::Logging)
   end
 
   it "should be able to be converted to a string" do
     Puppet::Module.new("foo").to_s.should == "Module foo"
   end
 
   it "should add the path to its string form if the module is found" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a"
     mod.to_s.should == "Module foo(/a)"
   end
 
   it "should fail if its name is not alphanumeric" do
     lambda { Puppet::Module.new(".something") }.should raise_error(Puppet::Module::InvalidName)
   end
 
   it "should require a name at initialization" do
     lambda { Puppet::Module.new }.should raise_error(ArgumentError)
   end
 
   it "should convert an environment name into an Environment instance" do
     Puppet::Module.new("foo", :environment => "prod").environment.should be_instance_of(Puppet::Node::Environment)
   end
 
   it "should accept an environment at initialization" do
     Puppet::Module.new("foo", :environment => :prod).environment.name.should == :prod
   end
 
   it "should use the default environment if none is provided" do
     env = Puppet::Node::Environment.new
     Puppet::Module.new("foo").environment.should equal(env)
   end
 
   it "should use any provided Environment instance" do
     env = Puppet::Node::Environment.new
     Puppet::Module.new("foo", :environment => env).environment.should equal(env)
   end
 
   describe ".path" do
     before do
       dir = tmpdir("deep_path")
 
       @first = File.join(dir, "first")
       @second = File.join(dir, "second")
       Puppet[:modulepath] = "#{@first}#{File::PATH_SEPARATOR}#{@second}"
 
       FileUtils.mkdir_p(@first)
       FileUtils.mkdir_p(@second)
     end
 
     it "should return the path to the first found instance in its environment's module paths as its path" do
       modpath = File.join(@first, "foo")
       FileUtils.mkdir_p(modpath)
 
       # Make a second one, which we shouldn't find
       FileUtils.mkdir_p(File.join(@second, "foo"))
 
       mod = Puppet::Module.new("foo")
       mod.path.should == modpath
     end
 
     it "should be able to find itself in a directory other than the first directory in the module path" do
       modpath = File.join(@second, "foo")
       FileUtils.mkdir_p(modpath)
 
       mod = Puppet::Module.new("foo")
       mod.should be_exist
       mod.path.should == modpath
     end
 
     it "should be able to find itself in a directory other than the first directory in the module path even when it exists in the first" do
       environment = Puppet::Node::Environment.new
 
       first_modpath = File.join(@first, "foo")
       FileUtils.mkdir_p(first_modpath)
       second_modpath = File.join(@second, "foo")
       FileUtils.mkdir_p(second_modpath)
 
       mod = Puppet::Module.new("foo", :environment => environment, :path => second_modpath)
       mod.path.should == File.join(@second, "foo")
       mod.environment.should == environment
     end
   end
 
   describe '#modulepath' do
     it "should return the directory the module is installed in, if a path exists" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       mod.modulepath.should == '/a'
     end
 
     it "should return nil if no path exists" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns nil
       mod.modulepath.should be_nil
     end
   end
 
   it "should be considered existent if it exists in at least one module path" do
     mod = Puppet::Module.new("foo")
     mod.expects(:path).returns "/a/foo"
     mod.should be_exist
   end
 
   it "should be considered nonexistent if it does not exist in any of the module paths" do
     mod = Puppet::Module.new("foo")
     mod.expects(:path).returns nil
     mod.should_not be_exist
   end
 
   [:plugins, :templates, :files, :manifests].each do |filetype|
     dirname = filetype == :plugins ? "lib" : filetype.to_s
     it "should be able to return individual #{filetype}" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname, "my/file")
       FileTest.expects(:exist?).with(path).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should == path
     end
 
     it "should consider #{filetype} to be present if their base directory exists" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(path).returns true
       mod.send(filetype.to_s + "?").should be_true
     end
 
     it "should consider #{filetype} to be absent if their base directory does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(path).returns false
       mod.send(filetype.to_s + "?").should be_false
     end
 
     it "should consider #{filetype} to be absent if the module base directory does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns nil
       mod.send(filetype.to_s + "?").should be_false
     end
 
     it "should return nil if asked to return individual #{filetype} that don't exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname, "my/file")
       FileTest.expects(:exist?).with(path).returns false
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
     end
 
     it "should return nil when asked for individual #{filetype} if the module does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns nil
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
     end
 
     it "should return the base directory if asked for a nil path" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       base = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(base).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), nil).should == base
     end
   end
 
   it "should return the path to the plugin directory" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a/foo"
 
     mod.plugin_directory.should == "/a/foo/lib"
   end
 
   it "should throw a warning if plugins are in a 'plugins' directory rather than a 'lib' directory" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a/foo"
     FileTest.expects(:exist?).with("/a/foo/plugins").returns true
     Puppet.expects(:deprecation_warning).with("using the deprecated 'plugins' directory for ruby extensions; please move to 'lib'")
 
     mod.plugin_directory.should == "/a/foo/plugins"
   end
 
   it "should default to 'lib' for the plugins directory" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a/foo"
     mod.plugin_directory.should == "/a/foo/lib"
   end
 end
 
 describe Puppet::Module, "when finding matching manifests" do
   before do
     @mod = Puppet::Module.new("mymod")
     @mod.stubs(:path).returns "/a"
     @pq_glob_with_extension = "yay/*.xx"
     @fq_glob_with_extension = "/a/manifests/#{@pq_glob_with_extension}"
   end
 
   it "should return all manifests matching the glob pattern" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
     FileTest.stubs(:directory?).returns false
 
     @mod.match_manifests(@pq_glob_with_extension).should == %w{foo bar}
   end
 
   it "should not return directories" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
 
     FileTest.expects(:directory?).with("foo").returns false
     FileTest.expects(:directory?).with("bar").returns true
     @mod.match_manifests(@pq_glob_with_extension).should == %w{foo}
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
     Dir.expects(:glob).with("/a/manifests/init.{pp,rb}").returns(%w{/a/manifests/init.pp})
 
     @mod.match_manifests(nil).should == %w{/a/manifests/init.pp}
   end
 
   it "should return all manifests matching the glob pattern in all existing paths" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{a b})
 
     @mod.match_manifests(@pq_glob_with_extension).should == %w{a b}
   end
 
   it "should match the glob pattern plus '.{pp,rb}' if no extention is specified" do
     Dir.expects(:glob).with("/a/manifests/yay/foo.{pp,rb}").returns(%w{yay})
 
     @mod.match_manifests("yay/foo").should == %w{yay}
   end
 
   it "should return an empty array if no manifests matched" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns([])
 
     @mod.match_manifests(@pq_glob_with_extension).should == []
   end
 end
 
 describe Puppet::Module do
   include PuppetSpec::Files
   before do
     @modpath = tmpdir('modpath')
     @module = PuppetSpec::Modules.create('mymod', @modpath)
   end
 
   it "should use 'License' in its current path as its metadata file" do
     @module.license_file.should == "#{@modpath}/mymod/License"
   end
 
   it "should return nil as its license file when the module has no path" do
     Puppet::Module.any_instance.stubs(:path).returns nil
     Puppet::Module.new("foo").license_file.should be_nil
   end
 
   it "should cache the license file" do
     @module.expects(:path).once.returns nil
     @module.license_file
     @module.license_file
   end
 
   it "should use 'metadata.json' in its current path as its metadata file" do
     @module.metadata_file.should == "#{@modpath}/mymod/metadata.json"
   end
 
   it "should return nil as its metadata file when the module has no path" do
     Puppet::Module.any_instance.stubs(:path).returns nil
     Puppet::Module.new("foo").metadata_file.should be_nil
   end
 
   it "should cache the metadata file" do
     Puppet::Module.any_instance.expects(:path).once.returns nil
     mod = Puppet::Module.new("foo")
     mod.metadata_file.should == mod.metadata_file
   end
 
   it "should have metadata if it has a metadata file and its data is not empty" do
     FileTest.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
 
     @module.should be_has_metadata
   end
 
   it "should have metadata if it has a metadata file and its data is not empty" do
     FileTest.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
 
     @module.should be_has_metadata
   end
 
   it "should not have metadata if has a metadata file and its data is empty" do
     FileTest.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "/*
 +-----------------------------------------------------------------------+
 |                                                                       |
 |                    ==> DO NOT EDIT THIS FILE! <==                     |
 |                                                                       |
 |   You should edit the `Modulefile` and run `puppet-module build`      |
 |   to generate the `metadata.json` file for your releases.             |
 |                                                                       |
 +-----------------------------------------------------------------------+
 */
 
 {}"
 
     @module.should_not be_has_metadata
   end
 
   it "should know if it is missing a metadata file" do
     FileTest.expects(:exist?).with(@module.metadata_file).returns false
 
     @module.should_not be_has_metadata
   end
 
   it "should be able to parse its metadata file" do
     @module.should respond_to(:load_metadata)
   end
 
   it "should parse its metadata file on initialization if it is present" do
     Puppet::Module.any_instance.expects(:has_metadata?).returns true
     Puppet::Module.any_instance.expects(:load_metadata)
 
     Puppet::Module.new("yay")
   end
 
   describe "when loading the metadata file", :if => Puppet.features.pson? do
     before do
       @data = {
         :license       => "GPL2",
         :author        => "luke",
         :version       => "1.0",
         :source        => "http://foo/",
         :puppetversion => "0.25",
         :dependencies  => []
       }
       @text = @data.to_pson
 
       @module = Puppet::Module.new("foo")
       @module.stubs(:metadata_file).returns "/my/file"
       File.stubs(:read).with("/my/file").returns @text
     end
 
     %w{source author version license}.each do |attr|
       it "should set #{attr} if present in the metadata file" do
         @module.load_metadata
         @module.send(attr).should == @data[attr.to_sym]
       end
 
       it "should fail if #{attr} is not present in the metadata file" do
         @data.delete(attr.to_sym)
         @text = @data.to_pson
         File.stubs(:read).with("/my/file").returns @text
         lambda { @module.load_metadata }.should raise_error(
           Puppet::Module::MissingMetadata,
           "No #{attr} module metadata provided for foo"
         )
       end
     end
 
     it "should set puppetversion if present in the metadata file" do
       @module.load_metadata
       @module.puppetversion.should == @data[:puppetversion]
     end
 
     context "when versionRequirement is used for dependency version info" do
       before do
         @data = {
           :license       => "GPL2",
           :author        => "luke",
           :version       => "1.0",
           :source        => "http://foo/",
           :puppetversion => "0.25",
           :dependencies  => [
             {
               "versionRequirement" => "0.0.1",
               "name" => "pmtacceptance/stdlib"
             },
             {
               "versionRequirement" => "0.1.0",
               "name" => "pmtacceptance/apache"
             }
           ]
         }
         @text = @data.to_pson
 
         @module = Puppet::Module.new("foo")
         @module.stubs(:metadata_file).returns "/my/file"
         File.stubs(:read).with("/my/file").returns @text
       end
 
       it "should set the dependency version_requirement key" do
         @module.load_metadata
         @module.dependencies[0]['version_requirement'].should == "0.0.1"
       end
 
       it "should set the version_requirement key for all dependencies" do
         @module.load_metadata
         @module.dependencies[0]['version_requirement'].should == "0.0.1"
         @module.dependencies[1]['version_requirement'].should == "0.1.0"
       end
     end
 
     it "should fail if the discovered name is different than the metadata name"
   end
 
-  it "should be able to tell if there are local changes", :fails_on_windows => true do
-    modpath = tmpdir('modpath')
-    foo_checksum = 'acbd18db4cc2f85cedef654fccc4a4d8'
-    checksummed_module = PuppetSpec::Modules.create(
-      'changed',
-      modpath,
-      :metadata => {
-        :checksums => {
-          "foo" => foo_checksum,
+  it "should be able to tell if there are local changes" do
+    pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+      modpath = tmpdir('modpath')
+      foo_checksum = 'acbd18db4cc2f85cedef654fccc4a4d8'
+      checksummed_module = PuppetSpec::Modules.create(
+        'changed',
+        modpath,
+        :metadata => {
+          :checksums => {
+            "foo" => foo_checksum,
+          }
         }
-      }
-    )
+      )
 
-    foo_path = Pathname.new(File.join(checksummed_module.path, 'foo'))
+      foo_path = Pathname.new(File.join(checksummed_module.path, 'foo'))
 
-    IO.binwrite(foo_path, 'notfoo')
-    Puppet::Module::Tool::Checksums.new(foo_path).checksum(foo_path).should_not == foo_checksum
-    checksummed_module.has_local_changes?.should be_true
+      IO.binwrite(foo_path, 'notfoo')
+      Puppet::Module::Tool::Checksums.new(foo_path).checksum(foo_path).should_not == foo_checksum
+      checksummed_module.has_local_changes?.should be_true
 
-    IO.binwrite(foo_path, 'foo')
+      IO.binwrite(foo_path, 'foo')
 
-    Puppet::Module::Tool::Checksums.new(foo_path).checksum(foo_path).should == foo_checksum
-    checksummed_module.has_local_changes?.should be_false
+      Puppet::Module::Tool::Checksums.new(foo_path).checksum(foo_path).should == foo_checksum
+      checksummed_module.has_local_changes?.should be_false
+    end
   end
 
   it "should know what other modules require it" do
     Puppet.settings[:modulepath] = @modpath
     dependable = PuppetSpec::Modules.create(
       'dependable',
       @modpath,
       :metadata => {:author => 'puppetlabs'}
     )
     PuppetSpec::Modules.create(
       'needy',
       @modpath,
       :metadata => {
         :author => 'beggar',
         :dependencies => [{
             "version_requirement" => ">= 2.2.0",
             "name" => "puppetlabs/dependable"
         }]
       }
     )
     PuppetSpec::Modules.create(
       'wantit',
       @modpath,
       :metadata => {
         :author => 'spoiled',
         :dependencies => [{
             "version_requirement" => "< 5.0.0",
             "name" => "puppetlabs/dependable"
         }]
       }
     )
     dependable.required_by.should =~ [
       {
         "name"    => "beggar/needy",
         "version" => "9.9.9",
         "version_requirement" => ">= 2.2.0"
       },
       {
         "name"    => "spoiled/wantit",
         "version" => "9.9.9",
         "version_requirement" => "< 5.0.0"
       }
     ]
   end
 end
diff --git a/spec/unit/module_tool/application_spec.rb b/spec/unit/module_tool/application_spec.rb
index a2ef184f7..a94dd003a 100644
--- a/spec/unit/module_tool/application_spec.rb
+++ b/spec/unit/module_tool/application_spec.rb
@@ -1,27 +1,27 @@
 require 'spec_helper'
 require 'puppet/module_tool'
 
-describe Puppet::Module::Tool::Applications::Application, :fails_on_windows => true do
+describe Puppet::Module::Tool::Applications::Application do
   describe 'app' do
 
     good_versions = %w{ 1.2.4 0.0.1 0.0.0 0.0.2-git-8-g3d316d1 0.0.3-b1 10.100.10000
                          0.1.2-rc1 0.1.2-dev-1 0.1.2-svn12345 0.1.2-3 }
     bad_versions = %w{ 0.1 0 0.1.2.3 dev 0.1.2beta }
 
-    before do
-      @app = Class.new(described_class).new
-    end
+    let :app do Class.new(described_class).new end
 
     good_versions.each do |ver|
       it "should accept version string #{ver}" do
-        @app.parse_filename("puppetlabs-ntp-#{ver}")
+        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+          app.parse_filename("puppetlabs-ntp-#{ver}")
+        end
       end
     end
 
     bad_versions.each do |ver|
       it "should not accept version string #{ver}" do
-        lambda { @app.parse_filename("puppetlabs-ntp-#{ver}") }.should raise_error
+        expect { app.parse_filename("puppetlabs-ntp-#{ver}") }.should raise_error
       end
     end
   end
 end
diff --git a/spec/unit/module_tool/applications/installer_spec.rb b/spec/unit/module_tool/applications/installer_spec.rb
index 1ad80ee60..b9675e7a7 100644
--- a/spec/unit/module_tool/applications/installer_spec.rb
+++ b/spec/unit/module_tool/applications/installer_spec.rb
@@ -1,205 +1,222 @@
 require 'spec_helper'
 require 'puppet/module_tool/applications'
 require 'puppet_spec/modules'
 require 'semver'
 
 describe Puppet::Module::Tool::Applications::Installer, :fails_on_windows => true do
   include PuppetSpec::Files
 
   before do
     FileUtils.mkdir_p(modpath1)
     fake_env.modulepath = [modpath1]
     FileUtils.touch(stdlib_pkg)
     Puppet.settings[:modulepath] = modpath1
     Puppet::Forge.stubs(:remote_dependency_info).returns(remote_dependency_info)
     Puppet::Forge.stubs(:repository).returns(repository)
   end
 
   let(:unpacker)        { stub(:run) }
   let(:installer_class) { Puppet::Module::Tool::Applications::Installer }
   let(:modpath1)        { File.join(tmpdir("installer"), "modpath1") }
   let(:stdlib_pkg)      { File.join(modpath1, "pmtacceptance-stdlib-0.0.1.tar.gz") }
   let(:fake_env)        { Puppet::Node::Environment.new('fake_env') }
   let(:options)         { Hash[:target_dir => modpath1] }
 
   let(:repository) do
     repository = mock()
     repository.stubs(:uri => 'forge-dev.puppetlabs.com')
 
     releases = remote_dependency_info.each_key do |mod|
       remote_dependency_info[mod].each do |release|
         repository.stubs(:retrieve).with(release['file'])\
                   .returns("/fake_cache#{release['file']}")
       end
     end
 
     repository
   end
 
   let(:remote_dependency_info) do
     {
       "pmtacceptance/stdlib" => [
         { "dependencies" => [],
           "version"      => "0.0.1",
           "file"         => "/pmtacceptance-stdlib-0.0.1.tar.gz" },
         { "dependencies" => [],
           "version"      => "0.0.2",
           "file"         => "/pmtacceptance-stdlib-0.0.2.tar.gz" },
         { "dependencies" => [],
           "version"      => "1.0.0",
           "file"         => "/pmtacceptance-stdlib-1.0.0.tar.gz" }
       ],
       "pmtacceptance/java" => [
         { "dependencies" => [["pmtacceptance/stdlib", ">= 0.0.1"]],
           "version"      => "1.7.0",
           "file"         => "/pmtacceptance-java-1.7.0.tar.gz" },
         { "dependencies" => [["pmtacceptance/stdlib", "1.0.0"]],
           "version"      => "1.7.1",
           "file"         => "/pmtacceptance-java-1.7.1.tar.gz" }
       ],
       "pmtacceptance/apollo" => [
         { "dependencies" => [
             ["pmtacceptance/java", "1.7.1"],
             ["pmtacceptance/stdlib", "0.0.1"]
           ],
           "version" => "0.0.1",
           "file"    => "/pmtacceptance-apollo-0.0.1.tar.gz" },
         { "dependencies" => [
             ["pmtacceptance/java", ">= 1.7.0"],
             ["pmtacceptance/stdlib", ">= 1.0.0"]
           ],
           "version" => "0.0.2",
           "file"    => "/pmtacceptance-apollo-0.0.2.tar.gz" }
       ]
     }
   end
 
   describe "the behavior of .is_module_package?" do
     it "should return true when file is a module package" do
-      installer = installer_class.new("foo", options)
-      installer.send(:is_module_package?, stdlib_pkg).should be_true
+      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+        installer = installer_class.new("foo", options)
+        installer.send(:is_module_package?, stdlib_pkg).should be_true
+      end
     end
 
     it "should return false when file is not a module package" do
-      installer = installer_class.new("foo", options)
-      installer.send(:is_module_package?, "pmtacceptance-apollo-0.0.2.tar").should be_false
+      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+        installer = installer_class.new("foo", options)
+        installer.send(:is_module_package?, "pmtacceptance-apollo-0.0.2.tar").
+          should be_false
+      end
     end
   end
 
   context "when the source is a repository" do
     it "should require a valid name" do
       lambda { installer_class.run('puppet', params) }.should
         raise_error(ArgumentError, "Could not install module with invalid name: puppet")
     end
 
     it "should install the requested module" do
-      Puppet::Module::Tool::Applications::Unpacker.expects(:new)\
-        .with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options)\
-        .returns(unpacker)
-      results = installer_class.run('pmtacceptance-stdlib', options)
-      results[:installed_modules].length == 1
-      results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
-      results[:installed_modules][0][:version][:vstring].should == "1.0.0"
+      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+        Puppet::Module::Tool::Applications::Unpacker.expects(:new).
+          with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
+          returns(unpacker)
+        results = installer_class.run('pmtacceptance-stdlib', options)
+        results[:installed_modules].length == 1
+        results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
+        results[:installed_modules][0][:version][:vstring].should == "1.0.0"
+      end
     end
 
     context "when the requested module has dependencies" do
       it "should install dependencies" do
-        Puppet::Module::Tool::Applications::Unpacker.expects(:new)\
-          .with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options)\
-        .returns(unpacker)
-        Puppet::Module::Tool::Applications::Unpacker.expects(:new)\
-          .with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options)\
-        .returns(unpacker)
-        Puppet::Module::Tool::Applications::Unpacker.expects(:new)\
-          .with('/fake_cache/pmtacceptance-java-1.7.1.tar.gz', options)\
-        .returns(unpacker)
-
-        results = installer_class.run('pmtacceptance-apollo', options)
-        installed_dependencies = results[:installed_modules][0][:dependencies]
-
-        dependencies = installed_dependencies.inject({}) do |result, dep|
-          result[dep[:module]] = dep[:version][:vstring]
-          result
+        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+          Puppet::Module::Tool::Applications::Unpacker.expects(:new).
+            with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
+            returns(unpacker)
+          Puppet::Module::Tool::Applications::Unpacker.expects(:new).
+            with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
+            returns(unpacker)
+          Puppet::Module::Tool::Applications::Unpacker.expects(:new).
+            with('/fake_cache/pmtacceptance-java-1.7.1.tar.gz', options).
+            returns(unpacker)
+
+          results = installer_class.run('pmtacceptance-apollo', options)
+          installed_dependencies = results[:installed_modules][0][:dependencies]
+
+          dependencies = installed_dependencies.inject({}) do |result, dep|
+            result[dep[:module]] = dep[:version][:vstring]
+            result
+          end
+
+          dependencies.length.should == 2
+          dependencies['pmtacceptance-java'].should   == '1.7.1'
+          dependencies['pmtacceptance-stdlib'].should == '1.0.0'
         end
-
-        dependencies.length.should == 2
-        dependencies['pmtacceptance-java'].should   == '1.7.1'
-        dependencies['pmtacceptance-stdlib'].should == '1.0.0'
       end
 
       it "should install requested module if the '--force' flag is used" do
-        options = { :force => true, :target_dir => modpath1 }
-        Puppet::Module::Tool::Applications::Unpacker.expects(:new)\
-          .with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options)\
-        .returns(unpacker)
-        results = installer_class.run('pmtacceptance-apollo', options)
-        results[:installed_modules][0][:module].should == "pmtacceptance-apollo"
+        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+          options = { :force => true, :target_dir => modpath1 }
+          Puppet::Module::Tool::Applications::Unpacker.expects(:new).
+            with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
+            returns(unpacker)
+          results = installer_class.run('pmtacceptance-apollo', options)
+          results[:installed_modules][0][:module].should == "pmtacceptance-apollo"
+        end
       end
 
       it "should not install dependencies if the '--force' flag is used" do
-        options = { :force => true, :target_dir => modpath1 }
-        Puppet::Module::Tool::Applications::Unpacker.expects(:new)\
-          .with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options)\
-        .returns(unpacker)
-        results = installer_class.run('pmtacceptance-apollo', options)
-        dependencies = results[:installed_modules][0][:dependencies]
-        dependencies.should == []
+        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+          options = { :force => true, :target_dir => modpath1 }
+          Puppet::Module::Tool::Applications::Unpacker.expects(:new).
+            with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
+            returns(unpacker)
+          results = installer_class.run('pmtacceptance-apollo', options)
+          dependencies = results[:installed_modules][0][:dependencies]
+          dependencies.should == []
+        end
       end
 
       it "should not install dependencies if the '--ignore-dependencies' flag is used" do
-        options = { :ignore_dependencies => true, :target_dir => modpath1 }
-        Puppet::Module::Tool::Applications::Unpacker.expects(:new)\
-          .with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options)\
-        .returns(unpacker)
-        results = installer_class.run('pmtacceptance-apollo', options)
-        dependencies = results[:installed_modules][0][:dependencies]
-        dependencies.should == []
+        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+          options = { :ignore_dependencies => true, :target_dir => modpath1 }
+          Puppet::Module::Tool::Applications::Unpacker.expects(:new).
+            with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
+            returns(unpacker)
+          results = installer_class.run('pmtacceptance-apollo', options)
+          dependencies = results[:installed_modules][0][:dependencies]
+          dependencies.should == []
+        end
       end
 
       it "should set an error if dependencies can't be resolved" do
-        options = { :version => '0.0.1', :target_dir => modpath1 }
-        oneline = "'pmtacceptance-apollo' (v0.0.1) requested; Invalid dependency cycle"
-        multiline = <<-MSG.strip
+        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+          options = { :version => '0.0.1', :target_dir => modpath1 }
+          oneline = "'pmtacceptance-apollo' (v0.0.1) requested; Invalid dependency cycle"
+          multiline = <<-MSG.strip
 Could not install module 'pmtacceptance-apollo' (v0.0.1)
   No version of 'pmtacceptance-stdlib' will satisfy dependencies
     You specified 'pmtacceptance-apollo' (v0.0.1),
     which depends on 'pmtacceptance-java' (v1.7.1),
     which depends on 'pmtacceptance-stdlib' (v1.0.0)
     Use `puppet module install --force` to install this module anyway
 MSG
 
-        results = installer_class.run('pmtacceptance-apollo', options)
-        results[:result].should == :failure
-        results[:error][:oneline].should == oneline
-        results[:error][:multiline].should == multiline
+          results = installer_class.run('pmtacceptance-apollo', options)
+          results[:result].should == :failure
+          results[:error][:oneline].should == oneline
+          results[:error][:multiline].should == multiline
+        end
       end
     end
 
     context "when there are modules installed" do
       it "should use local version when already exists and satisfies constraints"
       it "should reinstall the local version if force is used"
       it "should upgrade local version when necessary to satisfy constraints"
       it "should error when a local version can't be upgraded to satisfy constraints"
     end
 
     context "when a local module needs upgrading to satisfy constraints but has changes" do
       it "should error"
       it "should warn and continue if force is used"
     end
 
     it "should error when a local version of a dependency has no version metadata"
     it "should error when a local version of a dependency has a non-semver version"
     it "should error when a local version of a dependency has a different forge name"
     it "should error when a local version of a dependency has no metadata"
   end
 
   context "when the source is a filesystem" do
     before do
       @sourcedir = tmpdir('sourcedir')
     end
 
     it "should error if it can't parse the name"
 
     it "should try to get_release_package_from_filesystem if it has a valid name"
   end
 end
diff --git a/spec/unit/module_tool/applications/uninstaller_spec.rb b/spec/unit/module_tool/applications/uninstaller_spec.rb
index e8a4b3f46..7929df3c0 100644
--- a/spec/unit/module_tool/applications/uninstaller_spec.rb
+++ b/spec/unit/module_tool/applications/uninstaller_spec.rb
@@ -1,206 +1,214 @@
 require 'spec_helper'
 require 'puppet/module_tool'
 require 'tmpdir'
 require 'puppet_spec/modules'
 
-describe Puppet::Module::Tool::Applications::Uninstaller, :fails_on_windows => true do
+describe Puppet::Module::Tool::Applications::Uninstaller do
   include PuppetSpec::Files
 
   def mkmod(name, path, metadata=nil)
     modpath = File.join(path, name)
     FileUtils.mkdir_p(modpath)
 
     if metadata
       File.open(File.join(modpath, 'metadata.json'), 'w') do |f|
         f.write(metadata.to_pson)
       end
     end
 
     modpath
   end
 
   describe "the behavior of the instances" do
 
     before do
       @uninstaller = Puppet::Module::Tool::Applications::Uninstaller
       FileUtils.mkdir_p(modpath1)
       FileUtils.mkdir_p(modpath2)
       fake_env.modulepath = [modpath1, modpath2]
     end
 
     let(:modpath1) { File.join(tmpdir("uninstaller"), "modpath1") }
     let(:modpath2) { File.join(tmpdir("uninstaller"), "modpath2") }
     let(:fake_env) { Puppet::Node::Environment.new('fake_env') }
     let(:options)  { {:environment => "fake_env"} }
 
     let(:foo_metadata) do
       {
         :author       => "puppetlabs",
         :name         => "puppetlabs/foo",
         :version      => "1.0.0",
         :source       => "http://dummyurl/foo",
         :license      => "Apache2",
         :dependencies => [],
       }
     end
 
     let(:bar_metadata) do
       {
         :author       => "puppetlabs",
         :name         => "puppetlabs/bar",
         :version      => "1.0.0",
         :source       => "http://dummyurl/bar",
         :license      => "Apache2",
         :dependencies => [],
       }
     end
 
     context "when the module is not installed" do
       it "should fail" do
         @uninstaller.new('fakemod_not_installed', options).run[:result].should == :failure
       end
     end
 
     context "when the module is installed" do
 
       it "should uninstall the module" do
-        PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
-        results = @uninstaller.new("puppetlabs-foo", options).run
-        results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+          results = @uninstaller.new("puppetlabs-foo", options).run
+          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+        end
       end
 
       it "should only uninstall the requested module" do
-        PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
-        PuppetSpec::Modules.create('bar', modpath1, :metadata => bar_metadata)
+        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+          PuppetSpec::Modules.create('bar', modpath1, :metadata => bar_metadata)
 
-        results = @uninstaller.new("puppetlabs-foo", options).run
-        results[:affected_modules].length == 1
-        results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+          results = @uninstaller.new("puppetlabs-foo", options).run
+          results[:affected_modules].length == 1
+          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+        end
       end
 
       it "should uninstall fail if a module exists twice in the modpath" do
         PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
         PuppetSpec::Modules.create('foo', modpath2, :metadata => foo_metadata)
 
         @uninstaller.new('puppetlabs-foo', options).run[:result].should == :failure
       end
 
       context "when options[:version] is specified" do
 
         it "should uninstall the module if the version matches" do
-          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+          pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+            PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
-          options[:version] = "1.0.0"
+            options[:version] = "1.0.0"
 
-          results = @uninstaller.new("puppetlabs-foo", options).run
-          results[:affected_modules].length.should == 1
-          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
-          results[:affected_modules].first.version.should == "1.0.0"
+            results = @uninstaller.new("puppetlabs-foo", options).run
+            results[:affected_modules].length.should == 1
+            results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+            results[:affected_modules].first.version.should == "1.0.0"
+          end
         end
 
         it "should not uninstall the module if the version does not match" do
           PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
           options[:version] = "2.0.0"
 
           @uninstaller.new("puppetlabs-foo", options).run[:result].should == :failure
         end
       end
 
       context "when the module metadata is missing" do
 
         it "should not uninstall the module" do
           PuppetSpec::Modules.create('foo', modpath1)
 
           @uninstaller.new("puppetlabs-foo", options).run[:result].should == :failure
         end
       end
 
       context "when the module has local changes" do
 
         it "should not uninstall the module" do
           PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
           Puppet::Module.any_instance.stubs(:has_local_changes?).returns(true)
 
           @uninstaller.new("puppetlabs-foo", options).run[:result].should == :failure
         end
 
       end
 
       context "when the module does not have local changes" do
 
         it "should uninstall the module" do
-          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+          pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
+            PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
-          results = @uninstaller.new("puppetlabs-foo", options).run
-          results[:affected_modules].length.should == 1
-          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+            results = @uninstaller.new("puppetlabs-foo", options).run
+            results[:affected_modules].length.should == 1
+            results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+          end
         end
       end
 
       context "when uninstalling the module will cause broken dependencies" do
         it "should not uninstall the module" do
           Puppet.settings[:modulepath] = modpath1
           PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
           PuppetSpec::Modules.create(
             'needy',
             modpath1,
             :metadata => {
               :author => 'beggar',
               :dependencies => [{
                   "version_requirement" => ">= 1.0.0",
                   "name" => "puppetlabs/foo"
               }]
             }
           )
 
           @uninstaller.new("puppetlabs-foo", options).run[:result].should == :failure
         end
       end
 
       context "when using the --force flag" do
 
         let(:fakemod) do
           stub(
             :forge_name => 'puppetlabs/fakemod',
             :version    => '0.0.1',
             :has_local_changes? => true
           )
         end
 
         it "should ignore local changes" do
           foo = mkmod("foo", modpath1, foo_metadata)
           options[:force] = true
 
           results = @uninstaller.new("puppetlabs-foo", options).run
           results[:affected_modules].length.should == 1
           results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
         end
 
         it "should ignore broken dependencies" do
           Puppet.settings[:modulepath] = modpath1
           PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
           PuppetSpec::Modules.create(
             'needy',
             modpath1,
             :metadata => {
               :author => 'beggar',
               :dependencies => [{
                   "version_requirement" => ">= 1.0.0",
                   "name" => "puppetlabs/foo"
               }]
             }
           )
           options[:force] = true
 
           results = @uninstaller.new("puppetlabs-foo", options).run
           results[:affected_modules].length.should == 1
           results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
         end
       end
     end
   end
 end
diff --git a/spec/unit/module_tool/applications/upgrader_spec.rb b/spec/unit/module_tool/applications/upgrader_spec.rb
index 542e00b7a..14f94f657 100644
--- a/spec/unit/module_tool/applications/upgrader_spec.rb
+++ b/spec/unit/module_tool/applications/upgrader_spec.rb
@@ -1,37 +1,37 @@
 require 'spec_helper'
 require 'puppet/module_tool/applications'
 require 'puppet_spec/modules'
 require 'semver'
 
-describe Puppet::Module::Tool::Applications::Upgrader, :fails_on_windows => true do
+describe Puppet::Module::Tool::Applications::Upgrader do
   include PuppetSpec::Files
 
   before do
   end
 
   it "should update the requested module"
   it "should not update dependencies"
   it "should fail when updating a dependency to an unsupported version"
   it "should fail when updating a module that is not installed"
   it "should warn when the latest version is already installed"
   it "should warn when the best version is already installed"
 
   context "when using the '--version' option" do
     it "should update an installed module to the requested version"
   end
 
   context "when using the '--force' flag" do
     it "should ignore missing dependencies"
     it "should ignore version constraints"
     it "should not update a module that is not installed"
   end
 
   context "when using the '--env' option" do
     it "should use the correct environment"
   end
 
   context "when there are missing dependencies" do
     it "should fail to upgrade the original module"
     it "should raise an error"
   end
 end
diff --git a/spec/unit/module_tool_spec.rb b/spec/unit/module_tool_spec.rb
index 1517f30f5..52f710ce1 100644
--- a/spec/unit/module_tool_spec.rb
+++ b/spec/unit/module_tool_spec.rb
@@ -1,113 +1,113 @@
 # encoding: UTF-8
 
 require 'spec_helper'
 require 'puppet/module_tool'
 
-describe Puppet::Module::Tool, :fails_on_windows => true do
+describe Puppet::Module::Tool do
   describe '.format_tree' do
     it 'should return an empty tree when given an empty list' do
       subject.format_tree([]).should == ''
     end
 
     it 'should return a shallow when given a list without dependencies' do
       list = [ { :text => 'first' }, { :text => 'second' }, { :text => 'third' } ]
       subject.format_tree(list).should == <<-TREE
 ├── first
 ├── second
 └── third
 TREE
     end
 
     it 'should return a deeply nested tree when given a list with deep dependencies' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             }
           ]
         },
       ]
       subject.format_tree(list).should == <<-TREE
 └─┬ first
   └─┬ second
     └── third
 TREE
     end
 
     it 'should show connectors when deep dependencies are not on the last node of the top level' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             }
           ]
         },
         { :text => 'fourth' }
       ]
       subject.format_tree(list).should == <<-TREE
 ├─┬ first
 │ └─┬ second
 │   └── third
 └── fourth
 TREE
     end
 
     it 'should show connectors when deep dependencies are not on the last node of any level' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             },
             { :text => 'fourth' }
           ]
         }
       ]
       subject.format_tree(list).should == <<-TREE
 └─┬ first
   ├─┬ second
   │ └── third
   └── fourth
 TREE
     end
 
     it 'should show connectors in every case when deep dependencies are not on the last node' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             },
             { :text => 'fourth' }
           ]
         },
         { :text => 'fifth' }
       ]
       subject.format_tree(list).should == <<-TREE
 ├─┬ first
 │ ├─┬ second
 │ │ └── third
 │ └── fourth
 └── fifth
 TREE
     end
   end
 end
diff --git a/spec/unit/ssl/inventory_spec.rb b/spec/unit/ssl/inventory_spec.rb
index 000f0a253..fac601d42 100755
--- a/spec/unit/ssl/inventory_spec.rb
+++ b/spec/unit/ssl/inventory_spec.rb
@@ -1,179 +1,179 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/ssl/inventory'
 
 describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? do
   before do
     @class = Puppet::SSL::Inventory
   end
 
   it "should use the :certinventory setting for the path to the inventory file" do
     Puppet.settings.expects(:value).with(:cert_inventory).returns "/inven/tory"
 
     @class.any_instance.stubs(:rebuild)
 
     @class.new.path.should == "/inven/tory"
   end
 
   describe "when initializing" do
     it "should set its path to the inventory file" do
       Puppet.settings.stubs(:value).with(:cert_inventory).returns "/inven/tory"
       @class.new.path.should == "/inven/tory"
     end
   end
 
   describe "when managing an inventory" do
     before do
       Puppet.settings.stubs(:value).with(:cert_inventory).returns "/inven/tory"
 
       FileTest.stubs(:exist?).with("/inven/tory").returns true
 
       @inventory = @class.new
 
       @cert = mock 'cert'
     end
 
     describe "and creating the inventory file" do
       before do
         Puppet.settings.stubs(:write)
         FileTest.stubs(:exist?).with("/inven/tory").returns false
 
         Puppet::SSL::Certificate.indirection.stubs(:search).returns []
       end
 
       it "should log that it is building a new inventory file" do
         Puppet.expects(:notice)
 
         @inventory.rebuild
       end
 
       it "should use the Settings to write to the file" do
         Puppet.settings.expects(:write).with(:cert_inventory)
 
         @inventory.rebuild
       end
 
       it "should add a header to the file" do
         fh = mock 'filehandle'
         Puppet.settings.stubs(:write).yields fh
         fh.expects(:print).with { |str| str =~ /^#/ }
 
         @inventory.rebuild
       end
 
       it "should add formatted information on all existing certificates" do
         cert1 = mock 'cert1'
         cert2 = mock 'cert2'
 
         Puppet::SSL::Certificate.indirection.expects(:search).with("*").returns [cert1, cert2]
 
         @class.any_instance.expects(:add).with(cert1)
         @class.any_instance.expects(:add).with(cert2)
 
         @inventory.rebuild
       end
     end
 
     describe "and adding a certificate" do
       it "should build the inventory file if one does not exist" do
         Puppet.settings.stubs(:value).with(:cert_inventory).returns "/inven/tory"
         Puppet.settings.stubs(:write)
 
         FileTest.expects(:exist?).with("/inven/tory").returns false
 
         @inventory.expects(:rebuild)
 
         @inventory.add(@cert)
       end
 
       it "should use the Settings to write to the file" do
         Puppet.settings.expects(:write).with(:cert_inventory, "a")
 
         @inventory.add(@cert)
       end
 
       it "should use the actual certificate if it was passed a Puppet certificate" do
         cert = Puppet::SSL::Certificate.new("mycert")
         cert.content = @cert
 
         fh = stub 'filehandle', :print => nil
         Puppet.settings.stubs(:write).yields fh
 
         @inventory.expects(:format).with(@cert)
 
         @inventory.add(@cert)
       end
 
       it "should add formatted certificate information to the end of the file" do
         fh = mock 'filehandle'
 
         Puppet.settings.stubs(:write).yields fh
 
         @inventory.expects(:format).with(@cert).returns "myformat"
 
         fh.expects(:print).with("myformat")
 
         @inventory.add(@cert)
       end
     end
 
-    describe "and formatting a certificate", :fails_on_windows => true do
+    describe "and formatting a certificate" do
       before do
         @cert = stub 'cert', :not_before => Time.now, :not_after => Time.now, :subject => "mycert", :serial => 15
       end
 
       it "should print the serial number as a 4 digit hex number in the first field" do
         @inventory.format(@cert).split[0].should == "0x000f" # 15 in hex
       end
 
       it "should print the not_before date in '%Y-%m-%dT%H:%M:%S%Z' format in the second field" do
         @cert.not_before.expects(:strftime).with('%Y-%m-%dT%H:%M:%S%Z').returns "before_time"
 
         @inventory.format(@cert).split[1].should == "before_time"
       end
 
       it "should print the not_after date in '%Y-%m-%dT%H:%M:%S%Z' format in the third field" do
         @cert.not_after.expects(:strftime).with('%Y-%m-%dT%H:%M:%S%Z').returns "after_time"
 
         @inventory.format(@cert).split[2].should == "after_time"
       end
 
       it "should print the subject in the fourth field" do
         @inventory.format(@cert).split[3].should == "mycert"
       end
 
       it "should add a carriage return" do
         @inventory.format(@cert).should =~ /\n$/
       end
 
       it "should produce a line consisting of the serial number, start date, expiration date, and subject" do
         # Just make sure our serial and subject bracket the lines.
         @inventory.format(@cert).should =~ /^0x.+mycert$/
       end
     end
 
     it "should be able to find a given host's serial number" do
       @inventory.should respond_to(:serial)
     end
 
     describe "and finding a serial number" do
       it "should return nil if the inventory file is missing" do
         FileTest.expects(:exist?).with("/inven/tory").returns false
         @inventory.serial(:whatever).should be_nil
       end
 
       it "should return the serial number from the line matching the provided name" do
         File.expects(:readlines).with("/inven/tory").returns ["0x00f blah blah /CN=me\n", "0x001 blah blah /CN=you\n"]
 
         @inventory.serial("me").should == 15
       end
 
       it "should return the number as an integer" do
         File.expects(:readlines).with("/inven/tory").returns ["0x00f blah blah /CN=me\n", "0x001 blah blah /CN=you\n"]
 
         @inventory.serial("me").should == 15
       end
     end
   end
 end
diff --git a/spec/unit/type_spec.rb b/spec/unit/type_spec.rb
index 49fd2938e..8f743b1da 100755
--- a/spec/unit/type_spec.rb
+++ b/spec/unit/type_spec.rb
@@ -1,961 +1,961 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe Puppet::Type, :fails_on_windows => true do
+describe Puppet::Type do
   include PuppetSpec::Files
 
   it "should be Comparable" do
     a = Puppet::Type.type(:notify).new(:name => "a")
     b = Puppet::Type.type(:notify).new(:name => "b")
     c = Puppet::Type.type(:notify).new(:name => "c")
 
     [[a, b, c], [a, c, b], [b, a, c], [b, c, a], [c, a, b], [c, b, a]].each do |this|
       this.sort.should == [a, b, c]
     end
 
     a.should be < b
     a.should be < c
     b.should be > a
     b.should be < c
     c.should be > a
     c.should be > b
 
     [a, b, c].each {|x| a.should be <= x }
     [a, b, c].each {|x| c.should be >= x }
 
     b.should be_between(a, c)
   end
 
   it "should consider a parameter to be valid if it is a valid parameter" do
     Puppet::Type.type(:mount).should be_valid_parameter(:path)
   end
 
   it "should consider a parameter to be valid if it is a valid property" do
     Puppet::Type.type(:mount).should be_valid_parameter(:fstype)
   end
 
   it "should consider a parameter to be valid if it is a valid metaparam" do
     Puppet::Type.type(:mount).should be_valid_parameter(:noop)
   end
 
   it "should be able to retrieve a property by name" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
     resource.property(:fstype).must be_instance_of(Puppet::Type.type(:mount).attrclass(:fstype))
   end
 
   it "should be able to retrieve a parameter by name" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
     resource.parameter(:name).must be_instance_of(Puppet::Type.type(:mount).attrclass(:name))
   end
 
   it "should be able to retrieve a property by name using the :parameter method" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
     resource.parameter(:fstype).must be_instance_of(Puppet::Type.type(:mount).attrclass(:fstype))
   end
 
   it "should be able to retrieve all set properties" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
     props = resource.properties
     props.should_not be_include(nil)
     [:fstype, :ensure, :pass].each do |name|
       props.should be_include(resource.parameter(name))
     end
   end
 
   it "should have a method for setting default values for resources" do
     Puppet::Type.type(:mount).new(:name => "foo").should respond_to(:set_default)
   end
 
   it "should do nothing for attributes that have no defaults and no specified value" do
     Puppet::Type.type(:mount).new(:name => "foo").parameter(:noop).should be_nil
   end
 
   it "should have a method for adding tags" do
     Puppet::Type.type(:mount).new(:name => "foo").should respond_to(:tags)
   end
 
   it "should use the tagging module" do
     Puppet::Type.type(:mount).ancestors.should be_include(Puppet::Util::Tagging)
   end
 
   it "should delegate to the tagging module when tags are added" do
     resource = Puppet::Type.type(:mount).new(:name => "foo")
     resource.stubs(:tag).with(:mount)
 
     resource.expects(:tag).with(:tag1, :tag2)
 
     resource.tags = [:tag1,:tag2]
   end
 
   it "should add the current type as tag" do
     resource = Puppet::Type.type(:mount).new(:name => "foo")
     resource.stubs(:tag)
 
     resource.expects(:tag).with(:mount)
 
     resource.tags = [:tag1,:tag2]
   end
 
   it "should have a method to know if the resource is exported" do
     Puppet::Type.type(:mount).new(:name => "foo").should respond_to(:exported?)
   end
 
   it "should have a method to know if the resource is virtual" do
     Puppet::Type.type(:mount).new(:name => "foo").should respond_to(:virtual?)
   end
 
   it "should consider its version to be its catalog version" do
     resource = Puppet::Type.type(:mount).new(:name => "foo")
     catalog = Puppet::Resource::Catalog.new
     catalog.version = 50
     catalog.add_resource resource
 
     resource.version.should == 50
   end
 
   it "should consider its version to be zero if it has no catalog" do
     Puppet::Type.type(:mount).new(:name => "foo").version.should == 0
   end
 
   it "should provide source_descriptors" do
     resource = Puppet::Type.type(:mount).new(:name => "foo")
     catalog = Puppet::Resource::Catalog.new
     catalog.version = 50
     catalog.add_resource resource
 
     resource.source_descriptors.should == {:tags=>["mount", "foo"], :path=>"/Mount[foo]"}
   end
 
   it "should consider its type to be the name of its class" do
     Puppet::Type.type(:mount).new(:name => "foo").type.should == :mount
   end
 
   it "should use any provided noop value" do
     Puppet::Type.type(:mount).new(:name => "foo", :noop => true).must be_noop
   end
 
   it "should use the global noop value if none is provided" do
     Puppet[:noop] = true
     Puppet::Type.type(:mount).new(:name => "foo").must be_noop
   end
 
   it "should not be noop if in a non-host_config catalog" do
     resource = Puppet::Type.type(:mount).new(:name => "foo")
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource resource
     resource.should_not be_noop
   end
 
   describe "when creating an event" do
     before do
       @resource = Puppet::Type.type(:mount).new :name => "foo"
     end
 
     it "should have the resource's reference as the resource" do
       @resource.event.resource.should == "Mount[foo]"
     end
 
     it "should have the resource's log level as the default log level" do
       @resource[:loglevel] = :warning
       @resource.event.default_log_level.should == :warning
     end
 
     {:file => "/my/file", :line => 50, :tags => %{foo bar}}.each do |attr, value|
       it "should set the #{attr}" do
         @resource.stubs(attr).returns value
         @resource.event.send(attr).should == value
       end
     end
 
     it "should allow specification of event attributes" do
       @resource.event(:status => "noop").status.should == "noop"
     end
   end
 
   describe "when creating a provider" do
     before :each do
       @type = Puppet::Type.newtype(:provider_test_type) do
         newparam(:name) { isnamevar }
         newparam(:foo)
         newproperty(:bar)
       end
     end
 
     after :each do
       @type.provider_hash.clear
     end
 
     describe "when determining if instances of the type are managed" do
       it "should not consider audit only resources to be managed" do
         @type.new(:name => "foo", :audit => 'all').managed?.should be_false
       end
 
       it "should not consider resources with only parameters to be managed" do
         @type.new(:name => "foo", :foo => 'did someone say food?').managed?.should be_false
       end
 
       it "should consider resources with any properties set to be managed" do
         @type.new(:name => "foo", :bar => 'Let us all go there').managed?.should be_true
       end
     end
 
     it "should have documentation for the 'provider' parameter if there are providers" do
       @type.provide(:test_provider)
       @type.paramdoc(:provider).should =~ /`provider_test_type`[\s\r]+resource/
     end
 
     it "should not have documentation for the 'provider' parameter if there are no providers" do
       expect { @type.paramdoc(:provider) }.to raise_error(NoMethodError)
     end
 
     it "should create a subclass of Puppet::Provider for the provider" do
       provider = @type.provide(:test_provider)
 
       provider.ancestors.should include(Puppet::Provider)
     end
 
     it "should use a parent class if specified" do
       parent_provider = @type.provide(:parent_provider)
       child_provider  = @type.provide(:child_provider, :parent => parent_provider)
 
       child_provider.ancestors.should include(parent_provider)
     end
 
     it "should use a parent class if specified by name" do
       parent_provider = @type.provide(:parent_provider)
       child_provider  = @type.provide(:child_provider, :parent => :parent_provider)
 
       child_provider.ancestors.should include(parent_provider)
     end
 
     it "should raise an error when the parent class can't be found" do
       expect {
         @type.provide(:child_provider, :parent => :parent_provider)
       }.to raise_error(Puppet::DevError, /Could not find parent provider.+parent_provider/)
     end
 
     it "should ensure its type has a 'provider' parameter" do
       @type.provide(:test_provider)
 
       @type.parameters.should include(:provider)
     end
 
     it "should remove a previously registered provider with the same name" do
       old_provider = @type.provide(:test_provider)
       new_provider = @type.provide(:test_provider)
 
       old_provider.should_not equal(new_provider)
     end
 
     it "should register itself as a provider for the type" do
       provider = @type.provide(:test_provider)
 
       provider.should == @type.provider(:test_provider)
     end
 
     it "should create a provider when a provider with the same name previously failed" do
       @type.provide(:test_provider) do
         raise "failed to create this provider"
       end rescue nil
 
       provider = @type.provide(:test_provider)
 
       provider.ancestors.should include(Puppet::Provider)
       provider.should == @type.provider(:test_provider)
     end
   end
 
   describe "when choosing a default provider" do
     it "should choose the provider with the highest specificity" do
       # Make a fake type
       type = Puppet::Type.newtype(:defaultprovidertest) do
         newparam(:name) do end
       end
 
       basic = type.provide(:basic) {}
       greater = type.provide(:greater) {}
 
       basic.stubs(:specificity).returns 1
       greater.stubs(:specificity).returns 2
 
       type.defaultprovider.should equal(greater)
     end
   end
 
   describe "when initializing" do
     describe "and passed a Puppet::Resource instance" do
       it "should set its title to the title of the resource if the resource type is equal to the current type" do
         resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:name => "/other"})
         Puppet::Type.type(:mount).new(resource).title.should == "/foo"
       end
 
       it "should set its title to the resource reference if the resource type is not equal to the current type" do
         resource = Puppet::Resource.new(:user, "foo")
         Puppet::Type.type(:mount).new(resource).title.should == "User[foo]"
       end
 
       [:line, :file, :catalog, :exported, :virtual].each do |param|
         it "should copy '#{param}' from the resource if present" do
           resource = Puppet::Resource.new(:mount, "/foo")
           resource.send(param.to_s + "=", "foo")
           resource.send(param.to_s + "=", "foo")
           Puppet::Type.type(:mount).new(resource).send(param).should == "foo"
         end
       end
 
       it "should copy any tags from the resource" do
         resource = Puppet::Resource.new(:mount, "/foo")
         resource.tag "one", "two"
         tags = Puppet::Type.type(:mount).new(resource).tags
         tags.should be_include("one")
         tags.should be_include("two")
       end
 
       it "should copy the resource's parameters as its own" do
         resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:atboot => true, :fstype => "boo"})
         params = Puppet::Type.type(:mount).new(resource).to_hash
         params[:fstype].should == "boo"
         params[:atboot].should == true
       end
     end
 
     describe "and passed a Hash" do
       it "should extract the title from the hash" do
         Puppet::Type.type(:mount).new(:title => "/yay").title.should == "/yay"
       end
 
       it "should work when hash keys are provided as strings" do
         Puppet::Type.type(:mount).new("title" => "/yay").title.should == "/yay"
       end
 
       it "should work when hash keys are provided as symbols" do
         Puppet::Type.type(:mount).new(:title => "/yay").title.should == "/yay"
       end
 
       it "should use the name from the hash as the title if no explicit title is provided" do
         Puppet::Type.type(:mount).new(:name => "/yay").title.should == "/yay"
       end
 
       it "should use the Resource Type's namevar to determine how to find the name in the hash" do
         yay = make_absolute('/yay')
         Puppet::Type.type(:file).new(:path => yay).title.should == yay
       end
 
       [:catalog].each do |param|
         it "should extract '#{param}' from the hash if present" do
           Puppet::Type.type(:mount).new(:name => "/yay", param => "foo").send(param).should == "foo"
         end
       end
 
       it "should use any remaining hash keys as its parameters" do
         resource = Puppet::Type.type(:mount).new(:title => "/foo", :catalog => "foo", :atboot => true, :fstype => "boo")
         resource[:fstype].must == "boo"
         resource[:atboot].must == true
       end
     end
 
     it "should fail if any invalid attributes have been provided" do
       lambda { Puppet::Type.type(:mount).new(:title => "/foo", :nosuchattr => "whatever") }.should raise_error(Puppet::Error)
     end
 
     it "should set its name to the resource's title if the resource does not have a :name or namevar parameter set" do
       resource = Puppet::Resource.new(:mount, "/foo")
 
       Puppet::Type.type(:mount).new(resource).name.should == "/foo"
     end
 
     it "should fail if no title, name, or namevar are provided" do
       lambda { Puppet::Type.type(:file).new(:atboot => true) }.should raise_error(Puppet::Error)
     end
 
     it "should set the attributes in the order returned by the class's :allattrs method" do
       Puppet::Type.type(:mount).stubs(:allattrs).returns([:name, :atboot, :noop])
       resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:name => "myname", :atboot => "myboot", :noop => "whatever"})
 
       set = []
 
       Puppet::Type.type(:mount).any_instance.stubs(:newattr).with do |param, hash|
         set << param
         true
       end.returns(stub_everything("a property"))
 
       Puppet::Type.type(:mount).new(resource)
 
       set[-1].should == :noop
       set[-2].should == :atboot
     end
 
     it "should always set the name and then default provider before anything else" do
       Puppet::Type.type(:mount).stubs(:allattrs).returns([:provider, :name, :atboot])
       resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:name => "myname", :atboot => "myboot"})
 
       set = []
 
       Puppet::Type.type(:mount).any_instance.stubs(:newattr).with do |param, hash|
         set << param
         true
       end.returns(stub_everything("a property"))
 
       Puppet::Type.type(:mount).new(resource)
       set[0].should == :name
       set[1].should == :provider
     end
 
     # This one is really hard to test :/
     it "should set each default immediately if no value is provided" do
       defaults = []
       Puppet::Type.type(:service).any_instance.stubs(:set_default).with { |value| defaults << value; true }
 
       Puppet::Type.type(:service).new :name => "whatever"
 
       defaults[0].should == :provider
     end
 
     it "should retain a copy of the originally provided parameters" do
       Puppet::Type.type(:mount).new(:name => "foo", :atboot => true, :noop => false).original_parameters.should == {:atboot => true, :noop => false}
     end
 
     it "should delete the name via the namevar from the originally provided parameters" do
       Puppet::Type.type(:file).new(:name => make_absolute('/foo')).original_parameters[:path].should be_nil
     end
   end
 
   it "should have a class method for converting a hash into a Puppet::Resource instance" do
     Puppet::Type.type(:mount).must respond_to(:hash2resource)
   end
 
   describe "when converting a hash to a Puppet::Resource instance" do
     before do
       @type = Puppet::Type.type(:mount)
     end
 
     it "should treat a :title key as the title of the resource" do
       @type.hash2resource(:name => "/foo", :title => "foo").title.should == "foo"
     end
 
     it "should use the name from the hash as the title if no explicit title is provided" do
       @type.hash2resource(:name => "foo").title.should == "foo"
     end
 
     it "should use the Resource Type's namevar to determine how to find the name in the hash" do
       @type.stubs(:key_attributes).returns([ :myname ])
 
       @type.hash2resource(:myname => "foo").title.should == "foo"
     end
 
     [:catalog].each do |attr|
       it "should use any provided #{attr}" do
         @type.hash2resource(:name => "foo", attr => "eh").send(attr).should == "eh"
       end
     end
 
     it "should set all provided parameters on the resource" do
       @type.hash2resource(:name => "foo", :fstype => "boo", :boot => "fee").to_hash.should == {:name => "foo", :fstype => "boo", :boot => "fee"}
     end
 
     it "should not set the title as a parameter on the resource" do
       @type.hash2resource(:name => "foo", :title => "eh")[:title].should be_nil
     end
 
     it "should not set the catalog as a parameter on the resource" do
       @type.hash2resource(:name => "foo", :catalog => "eh")[:catalog].should be_nil
     end
 
     it "should treat hash keys equivalently whether provided as strings or symbols" do
       resource = @type.hash2resource("name" => "foo", "title" => "eh", "fstype" => "boo")
       resource.title.should == "eh"
       resource[:name].should == "foo"
       resource[:fstype].should == "boo"
     end
   end
 
   describe "when retrieving current property values" do
     before do
       @resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
       @resource.property(:ensure).stubs(:retrieve).returns :absent
     end
 
     it "should fail if its provider is unsuitable" do
       @resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
       @resource.provider.class.expects(:suitable?).returns false
       lambda { @resource.retrieve_resource }.should raise_error(Puppet::Error)
     end
 
     it "should return a Puppet::Resource instance with its type and title set appropriately" do
       result = @resource.retrieve_resource
       result.should be_instance_of(Puppet::Resource)
       result.type.should == "Mount"
       result.title.should == "foo"
     end
 
     it "should set the name of the returned resource if its own name and title differ" do
       @resource[:name] = "my name"
       @resource.title = "other name"
       @resource.retrieve_resource[:name].should == "my name"
     end
 
     it "should provide a value for all set properties" do
       values = @resource.retrieve_resource
       [:ensure, :fstype, :pass].each { |property| values[property].should_not be_nil }
     end
 
     it "should provide a value for 'ensure' even if no desired value is provided" do
       @resource = Puppet::Type.type(:file).new(:path => make_absolute("/my/file/that/can't/exist"))
     end
 
     it "should not call retrieve on non-ensure properties if the resource is absent and should consider the property absent" do
       @resource.property(:ensure).expects(:retrieve).returns :absent
       @resource.property(:fstype).expects(:retrieve).never
       @resource.retrieve_resource[:fstype].should == :absent
     end
 
     it "should include the result of retrieving each property's current value if the resource is present" do
       @resource.property(:ensure).expects(:retrieve).returns :present
       @resource.property(:fstype).expects(:retrieve).returns 15
       @resource.retrieve_resource[:fstype] == 15
     end
   end
 
   describe "#to_resource" do
     it "should return a Puppet::Resource that includes properties, parameters and tags" do
       type_resource = Puppet::Type.type(:mount).new(
         :ensure   => :present,
         :name     => "foo",
         :fstype   => "bar",
         :remounts => true
       )
       type_resource.tags = %w{bar baz}
 
       # If it's not a property it's a parameter
       type_resource.parameters[:remounts].should_not be_a(Puppet::Property)
       type_resource.parameters[:fstype].is_a?(Puppet::Property).should be_true
 
       type_resource.property(:ensure).expects(:retrieve).returns :present
       type_resource.property(:fstype).expects(:retrieve).returns 15
 
       resource = type_resource.to_resource
 
       resource.should be_a Puppet::Resource
       resource[:fstype].should   == 15
       resource[:remounts].should == :true
       resource.tags.should       =~ %w{foo bar baz mount}
     end
   end
 
   describe ".title_patterns" do
     describe "when there's one namevar" do
       before do
         @type_class = Puppet::Type.type(:notify)
         @type_class.stubs(:key_attributes).returns([:one])
       end
 
       it "should have a default pattern for when there's one namevar" do
         patterns = @type_class.title_patterns
         patterns.length.should == 1
         patterns[0].length.should == 2
       end
 
       it "should have a regexp that captures the entire string" do
         patterns = @type_class.title_patterns
         string = "abc\n\tdef"
         patterns[0][0] =~ string
         $1.should == "abc\n\tdef"
       end
     end
   end
 
   describe "when in a catalog" do
     before do
       @catalog = Puppet::Resource::Catalog.new
       @container = Puppet::Type.type(:component).new(:name => "container")
       @one = Puppet::Type.type(:file).new(:path => make_absolute("/file/one"))
       @two = Puppet::Type.type(:file).new(:path => make_absolute("/file/two"))
 
       @catalog.add_resource @container
       @catalog.add_resource @one
       @catalog.add_resource @two
       @catalog.add_edge @container, @one
       @catalog.add_edge @container, @two
     end
 
     it "should have no parent if there is no in edge" do
       @container.parent.should be_nil
     end
 
     it "should set its parent to its in edge" do
       @one.parent.ref.should == @container.ref
     end
 
     after do
       @catalog.clear(true)
     end
   end
 
   it "should have a 'stage' metaparam" do
     Puppet::Type.metaparamclass(:stage).should be_instance_of(Class)
   end
 
   describe "#suitable?" do
     let(:type) { Puppet::Type.type(:file) }
     let(:resource) { type.new :path => tmpfile('suitable') }
     let(:provider) { resource.provider }
 
     it "should be suitable if its type doesn't use providers" do
       type.stubs(:paramclass).with(:provider).returns nil
 
       resource.should be_suitable
     end
 
     it "should be suitable if it has a provider which is suitable" do
       resource.should be_suitable
     end
 
     it "should not be suitable if it has a provider which is not suitable" do
       provider.class.stubs(:suitable?).returns false
 
       resource.should_not be_suitable
     end
 
     it "should be suitable if it does not have a provider and there is a default provider" do
       resource.stubs(:provider).returns nil
 
       resource.should be_suitable
     end
 
     it "should not be suitable if it doesn't have a provider and there is not default provider" do
       resource.stubs(:provider).returns nil
       type.stubs(:defaultprovider).returns nil
 
       resource.should_not be_suitable
     end
   end
 
   describe "::instances" do
     after :each do Puppet::Type.rmtype(:type_spec_fake_type) end
     let :type do
       Puppet::Type.newtype(:type_spec_fake_type) do
         newparam(:name) do
           isnamevar
         end
 
         newproperty(:prop1) {}
       end
 
       Puppet::Type.type(:type_spec_fake_type)
     end
 
     it "should not fail if no suitable providers are found" do
       type.provide(:fake1) do
         confine :exists => '/no/such/file'
         mk_resource_methods
       end
 
       expect { type.instances.should == [] }.should_not raise_error
     end
 
     context "with a default provider" do
       before :each do
         type.provide(:default) do
           defaultfor :operatingsystem => Facter.value(:operatingsystem)
           mk_resource_methods
           class << self
             attr_accessor :names
           end
           def self.instance(name)
             new(:name => name, :ensure => :present)
           end
           def self.instances
             @instances ||= names.collect { |name| instance(name.to_s) }
           end
 
           @names = [:one, :two]
         end
       end
 
       it "should return only instances of the type" do
         type.instances.should be_all {|x| x.is_a? type }
       end
 
       it "should return instances from the default provider" do
         type.instances.map(&:name).should == ["one", "two"]
       end
 
       it "should return instances from all providers" do
         type.provide(:fake1, :parent => :default) { @names = [:three, :four] }
         type.instances.map(&:name).should == ["one", "two", "three", "four"]
       end
 
       it "should not return instances from unsuitable providers" do
         type.provide(:fake1, :parent => :default) do
           @names = [:three, :four]
           confine :exists => "/no/such/file"
         end
 
         type.instances.map(&:name).should == ["one", "two"]
       end
     end
   end
 
 
   describe "::ensurable?" do
     before :each do
       class TestEnsurableType < Puppet::Type
         def exists?; end
         def create; end
         def destroy; end
       end
     end
 
     it "is true if the class has exists?, create, and destroy methods defined" do
       TestEnsurableType.should be_ensurable
     end
 
     it "is false if exists? is not defined" do
       TestEnsurableType.class_eval { remove_method(:exists?) }
       TestEnsurableType.should_not be_ensurable
     end
 
     it "is false if create is not defined" do
       TestEnsurableType.class_eval { remove_method(:create) }
       TestEnsurableType.should_not be_ensurable
     end
 
     it "is false if destroy is not defined" do
       TestEnsurableType.class_eval { remove_method(:destroy) }
       TestEnsurableType.should_not be_ensurable
     end
   end
 end
 
 describe Puppet::Type::RelationshipMetaparam do
   include PuppetSpec::Files
 
   it "should be a subclass of Puppet::Parameter" do
     Puppet::Type::RelationshipMetaparam.superclass.should equal(Puppet::Parameter)
   end
 
   it "should be able to produce a list of subclasses" do
     Puppet::Type::RelationshipMetaparam.should respond_to(:subclasses)
   end
 
-  describe "when munging relationships", :fails_on_windows => true do
+  describe "when munging relationships" do
     before do
       @path = make_absolute('/foo')
       @resource = Puppet::Type.type(:mount).new :name => @path
       @metaparam = Puppet::Type.metaparamclass(:require).new :resource => @resource
     end
 
     it "should accept Puppet::Resource instances" do
       ref = Puppet::Resource.new(:file, @path)
       @metaparam.munge(ref)[0].should equal(ref)
     end
 
     it "should turn any string into a Puppet::Resource" do
       @metaparam.munge("File[/ref]")[0].should be_instance_of(Puppet::Resource)
     end
   end
 
   it "should be able to validate relationships" do
     Puppet::Type.metaparamclass(:require).new(:resource => mock("resource")).should respond_to(:validate_relationship)
   end
 
   it "should fail if any specified resource is not found in the catalog" do
     catalog = mock 'catalog'
     resource = stub 'resource', :catalog => catalog, :ref => "resource"
 
     param = Puppet::Type.metaparamclass(:require).new(:resource => resource, :value => %w{Foo[bar] Class[test]})
 
     catalog.expects(:resource).with("Foo[bar]").returns "something"
     catalog.expects(:resource).with("Class[Test]").returns nil
 
     param.expects(:fail).with { |string| string.include?("Class[Test]") }
 
     param.validate_relationship
   end
 end
 
 describe Puppet::Type.metaparamclass(:check) do
   include PuppetSpec::Files
 
   it "should warn and create an instance of ':audit'" do
     file = Puppet::Type.type(:file).new :path => make_absolute('/foo')
     file.expects(:warning)
     file[:check] = :mode
     file[:audit].should == [:mode]
   end
 end
 
 describe Puppet::Type.metaparamclass(:audit) do
   include PuppetSpec::Files
 
   before do
     @resource = Puppet::Type.type(:file).new :path => make_absolute('/foo')
   end
 
   it "should default to being nil" do
     @resource[:audit].should be_nil
   end
 
   it "should specify all possible properties when asked to audit all properties" do
     @resource[:audit] = :all
 
     list = @resource.class.properties.collect { |p| p.name }
     @resource[:audit].should == list
   end
 
   it "should accept the string 'all' to specify auditing all possible properties" do
     @resource[:audit] = 'all'
 
     list = @resource.class.properties.collect { |p| p.name }
     @resource[:audit].should == list
   end
 
   it "should fail if asked to audit an invalid property" do
     lambda { @resource[:audit] = :foobar }.should raise_error(Puppet::Error)
   end
 
   it "should create an attribute instance for each auditable property" do
     @resource[:audit] = :mode
     @resource.parameter(:mode).should_not be_nil
   end
 
   it "should accept properties specified as a string" do
     @resource[:audit] = "mode"
     @resource.parameter(:mode).should_not be_nil
   end
 
   it "should not create attribute instances for parameters, only properties" do
     @resource[:audit] = :noop
     @resource.parameter(:noop).should be_nil
   end
 
   describe "when generating the uniqueness key" do
     it "should include all of the key_attributes in alphabetical order by attribute name" do
       Puppet::Type.type(:file).stubs(:key_attributes).returns [:path, :mode, :owner]
       Puppet::Type.type(:file).stubs(:title_patterns).returns(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
       myfile = make_absolute('/my/file')
       res = Puppet::Type.type(:file).new( :title => myfile, :path => myfile, :owner => 'root', :content => 'hello' )
       res.uniqueness_key.should == [ nil, 'root', myfile]
     end
   end
 
   context "type attribute bracket methods" do
     after :each do Puppet::Type.rmtype(:attributes)     end
     let   :type do
       Puppet::Type.newtype(:attributes) do
         newparam(:name) {}
       end
     end
 
     it "should work with parameters" do
       type.newparam(:param) {}
       instance = type.new(:name => 'test')
 
       expect { instance[:param] = true }.should_not raise_error
       expect { instance["param"] = true }.should_not raise_error
       instance[:param].should == true
       instance["param"].should == true
     end
 
     it "should work with meta-parameters" do
       instance = type.new(:name => 'test')
 
       expect { instance[:noop] = true }.should_not raise_error
       expect { instance["noop"] = true }.should_not raise_error
       instance[:noop].should == true
       instance["noop"].should == true
     end
 
     it "should work with properties" do
       type.newproperty(:property) {}
       instance = type.new(:name => 'test')
 
       expect { instance[:property] = true }.should_not raise_error
       expect { instance["property"] = true }.should_not raise_error
       instance.property(:property).must be
       instance.should(:property).must be_true
     end
 
     it "should handle proprieties correctly" do
       # Order of assignment is significant in this test.
       props = {}
       [:one, :two, :three].each {|prop| type.newproperty(prop) {} }
       instance = type.new(:name => "test")
 
       instance[:one] = "boo"
       one = instance.property(:one)
       instance.properties.must == [one]
 
       instance[:three] = "rah"
       three = instance.property(:three)
       instance.properties.must == [one, three]
 
       instance[:two] = "whee"
       two = instance.property(:two)
       instance.properties.must == [one, two, three]
     end
 
     it "should handle parameter aliases correctly" do
       type.newparam(:one) {}
       type.newproperty(:two) {}
 
       type.set_attr_alias :three => :one
       type.attr_alias(:three).must == :one
 
       type.set_attr_alias :four => :two
       type.attr_alias(:four).must == :two
 
       type.attr_alias(:name).must_not be
 
       instance = type.new(:name => "my name")
       instance.must be
 
       instance[:three]       = "value three"
       instance.value(:three).must == "value three"
       instance.value(:one).must   == "value three"
 
       instance[:four]              = "value four"
       instance.should(:four).must == "value four"
       instance.value(:four).must  == "value four"
       instance.value(:two).must   == "value four"
     end
 
     it "newattr should handle required features correctly" do
       Puppet::Util::Log.level = :debug
 
       type.feature :feature1, "one"
       type.feature :feature2, "two"
 
       none = type.newproperty(:none) {}
       one  = type.newproperty(:one, :required_features => :feature1) {}
       two  = type.newproperty(:two, :required_features => [:feature1, :feature2]) {}
 
       nope  = type.provide(:nope)  {}
       maybe = type.provide(:maybe) { has_features :feature1 }
       yep   = type.provide(:yep)   { has_features :feature1, :feature2 }
 
       [nope, maybe, yep].each_with_index do |provider, i|
         rsrc = type.new(:provider => provider.name, :name => "test#{i}",
                         :none => "a", :one => "b", :two => "c")
 
         rsrc.should(:none).must be
 
         if provider.declared_feature? :feature1
           rsrc.should(:one).must be
         else
           rsrc.should(:one).must_not be
           @logs.find {|l| l.message =~ /not managing attribute one/ }.should be
         end
 
         if provider.declared_feature? :feature2
           rsrc.should(:two).must be
         else
           rsrc.should(:two).must_not be
           @logs.find {|l| l.message =~ /not managing attribute two/ }.should be
         end
       end
     end
   end
 end