puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/interface_spec.rb

@@ -101,10 +101,10 @@ describe Puppet::Interface do
         to raise_error ArgumentError
     end
 
-    it "should instance-eval any provided block", :'fails_on_ruby_1.9.2' => true do
+    it "should instance-eval any provided block" do
       face = subject.new(:face_test_block, '0.0.1') do
         action(:something) do
-          when_invoked { "foo" }
+          when_invoked {|_| "foo" }
         end
       end
 
@@ -137,13 +137,51 @@ describe Puppet::Interface do
     end
   end
 
-  describe "with face-level options", :'fails_on_ruby_1.9.2' => true do
+  describe "with face-level display_global_options" do
+    it "should not return any action level display_global_options" do
+      face = subject.new(:with_display_global_options, '0.0.1') do
+        display_global_options "environment"
+        action :baz do
+          when_invoked {|_| true }
+          display_global_options "modulepath"
+        end
+      end
+      face.display_global_options =~ ["environment"]
+    end
+
+    it "should not fail when a face d_g_o duplicates an action d_g_o" do
+      expect {
+        subject.new(:action_level_display_global_options, '0.0.1') do
+          action :bar do
+            when_invoked {|_| true }
+            display_global_options "environment"
+          end
+          display_global_options "environment"
+        end
+      }.to_not raise_error
+    end
+
+    it "should work when two actions have the same d_g_o" do
+      face = subject.new(:with_display_global_options, '0.0.1') do
+        action :foo do when_invoked {|_| true} ; display_global_options "environment" end
+        action :bar do when_invoked {|_| true} ; display_global_options "environment" end
+      end
+      face.get_action(:foo).display_global_options =~ ["environment"]
+      face.get_action(:bar).display_global_options =~ ["environment"]
+    end
+      
+  end
+  
+  describe "with inherited display_global_options" do
+  end
+
+  describe "with face-level options" do
     it "should not return any action-level options" do
       face = subject.new(:with_options, '0.0.1') do
         option "--foo"
         option "--bar"
         action :baz do
-          when_invoked { true }
+          when_invoked {|_| true }
           option "--quux"
         end
       end
@@ -154,7 +192,7 @@ describe Puppet::Interface do
       expect {
         subject.new(:action_level_options, '0.0.1') do
           action :bar do
-            when_invoked { true }
+            when_invoked {|_| true }
             option "--foo"
           end
           option "--foo"
@@ -164,8 +202,8 @@ describe Puppet::Interface do
 
     it "should work when two actions have the same option" do
       face = subject.new(:with_options, '0.0.1') do
-        action :foo do when_invoked { true } ; option "--quux" end
-        action :bar do when_invoked { true } ; option "--quux" end
+        action :foo do when_invoked {|_| true } ; option "--quux" end
+        action :bar do when_invoked {|_| true } ; option "--quux" end
       end
 
       face.get_action(:foo).options.should =~ [:quux]
@@ -185,18 +223,18 @@ describe Puppet::Interface do
     let :parent do
       parent = Class.new(subject)
       parent.option("--inherited")
-      parent.action(:parent_action) do when_invoked { true } end
+      parent.action(:parent_action) do when_invoked {|_| true } end
       parent
     end
 
     let :face do
       face = parent.new(:example, '0.2.1')
       face.option("--local")
-      face.action(:face_action) do when_invoked { true } end
+      face.action(:face_action) do when_invoked {|_| true } end
       face
     end
 
-    describe "#options", :'fails_on_ruby_1.9.2' => true do
+    describe "#options" do
       it "should list inherited options" do
         face.options.should =~ [:inherited, :local]
       end
@@ -218,7 +256,7 @@ describe Puppet::Interface do
       end
     end
 
-    describe "#get_option", :'fails_on_ruby_1.9.2' => true do
+    describe "#get_option" do
       it "should return an inherited option object" do
         face.get_option(:inherited).should be_an_instance_of subject::Option
       end

data/spec/unit/module_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_spec/modules'
@@ -7,6 +7,11 @@ require 'puppet/module_tool/checksums'
 describe Puppet::Module do
   include PuppetSpec::Files
 
+  let(:env) { mock("environment") }
+  let(:path) { "path" }
+  let(:name) { "mymod" }
+  let(:mod) { Puppet::Module.new(name, path, env) }
+
   before do
     # This is necessary because of the extra checks we have for the deprecated
     # 'plugins' directory
@@ -15,77 +20,69 @@ describe Puppet::Module do
 
   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"
+    env.expects(:module).with(name).returns "yep"
     Puppet::Node::Environment.expects(:new).with("myenv").returns env
 
-    Puppet::Module.find("mymod", "myenv").should == "yep"
+    Puppet::Module.find(name, "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
+    env.expects(:module).with(name).returns nil
     Puppet::Node::Environment.expects(:new).with("myenv").returns env
 
-    Puppet::Module.find("mymod", "myenv").should be_nil
+    Puppet::Module.find(name, "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
+  describe "attributes" do
+    it "should support a 'version' attribute" do
+      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 'source' attribute" do
+      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 a 'project_page' attribute" do
+      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 an 'author' attribute" do
+      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 'license' attribute" do
+      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 'summary' attribute" do
+      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 a 'description' attribute" do
+      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"
+    it "should support specifying a compatible puppet version" do
+      mod.puppetversion = "0.25"
+      mod.puppetversion.should == "0.25"
+    end
   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)
@@ -248,7 +245,7 @@ describe Puppet::Module do
 
     it "should only list unmet dependencies" do
       mod = PuppetSpec::Modules.create(
-        'mymod',
+        name,
         @modpath,
         :metadata => {
           :dependencies => [
@@ -275,7 +272,7 @@ describe Puppet::Module do
       mod.unmet_dependencies.should == [{
         :reason => :missing,
         :mod_details => { :installed_version => nil },
-        :parent => { :version => "v9.9.9", :name => "puppetlabs/mymod" },
+        :parent => { :version => "v9.9.9", :name => "puppetlabs/#{name}" },
         :name => "baz/notsatisfied",
         :version_constraint => ">= 2.2.0"
       }]
@@ -321,60 +318,12 @@ describe Puppet::Module do
 
   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
@@ -386,204 +335,69 @@ describe Puppet::Module do
   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)"
+    mod.to_s.should == "Module #{name}(#{path})"
   end
 
   it "should fail if its name is not alphanumeric" do
-    lambda { Puppet::Module.new(".something") }.should raise_error(Puppet::Module::InvalidName)
+    lambda { Puppet::Module.new(".something", "path", env) }.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
+    Puppet::Module.new("foo", "path", env).environment.should == env
   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 = Puppet::Module.new("foo", "/a/foo", env)
       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
+      module_file = File.join(path, dirname, "my/file")
+      FileTest.expects(:exist?).with(module_file).returns true
+      mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should == module_file
     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
+      module_file = File.join(path, dirname)
+      FileTest.expects(:exist?).with(module_file).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
+      module_file = File.join(path, dirname)
+      FileTest.expects(:exist?).with(module_file).returns false
       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
+      module_file = File.join(path, dirname, "my/file")
+      FileTest.expects(:exist?).with(module_file).returns false
       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)
+      base = File.join(path, dirname)
       FileTest.expects(:exist?).with(base).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), nil).should == base
     end
   end
 
-  %w{plugins files}.each do |filetype|
-    short = filetype.sub(/s$/, '')
-    dirname = filetype == "plugins" ? "lib" : filetype.to_s
-    it "should be able to return the #{short} directory" do
-      Puppet::Module.new("foo").should respond_to(short + "_directory")
-    end
-
-    it "should return the path to the #{short} directory" do
-      mod = Puppet::Module.new("foo")
-      mod.stubs(:path).returns "/a/foo"
-
-      mod.send(short + "_directory").should == "/a/foo/#{dirname}"
-    end
-  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
-
-    mod.plugin_directory.should == "/a/foo/plugins"
-    @logs.first.message.should == "using the deprecated 'plugins' directory for ruby extensions; please move to 'lib'"
-    @logs.first.level.should == :warning
-  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"
+  it "should return the path to the plugin directory" do
+    mod.plugin_directory.should == File.join(path, "lib")
   end
 end
 
 describe Puppet::Module, "when finding matching manifests" do
   before do
-    @mod = Puppet::Module.new("mymod")
-    @mod.stubs(:path).returns "/a"
+    @mod = Puppet::Module.new("mymod", "/a", mock("environment"))
     @pq_glob_with_extension = "yay/*.xx"
     @fq_glob_with_extension = "/a/manifests/#{@pq_glob_with_extension}"
   end
@@ -604,8 +418,7 @@ describe Puppet::Module, "when finding matching manifests" do
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
-    FileTest.expects(:exist?).with("/a/manifests/init.pp").returns(true)
-    FileTest.expects(:exist?).with("/a/manifests/init.rb").returns(false)
+    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
@@ -627,12 +440,6 @@ describe Puppet::Module, "when finding matching manifests" do
 
     @mod.match_manifests(@pq_glob_with_extension).should == []
   end
-
-  it "should raise an error if the pattern tries to leave the manifest directory" do
-    expect do
-      @mod.match_manifests("something/../../*")
-    end.to raise_error(Puppet::Module::InvalidFilePattern, /The pattern "something\/\.\.\/\.\.\/\*" to find manifests in the module "mymod" is invalid and potentially unsafe./)
-  end
 end
 
 describe Puppet::Module do
@@ -646,11 +453,6 @@ describe Puppet::Module 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
@@ -661,17 +463,6 @@ describe Puppet::Module 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\"}"
@@ -718,7 +509,16 @@ describe Puppet::Module do
     Puppet::Module.any_instance.expects(:has_metadata?).returns true
     Puppet::Module.any_instance.expects(:load_metadata)
 
-    Puppet::Module.new("yay")
+    Puppet::Module.new("yay", "path", mock("env"))
+  end
+
+  def a_module_with_metadata(data)
+    text = data.to_pson
+
+    mod = Puppet::Module.new("foo", "path", mock("env"))
+    mod.stubs(:metadata_file).returns "/my/file"
+    File.stubs(:read).with("/my/file").returns text
+    mod
   end
 
   describe "when loading the metadata file", :if => Puppet.features.pson? do
@@ -731,11 +531,7 @@ describe Puppet::Module do
         :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
+      @module = a_module_with_metadata(@data)
     end
 
     %w{source author version license}.each do |attr|
@@ -779,11 +575,7 @@ describe Puppet::Module do
             }
           ]
         }
-        @text = @data.to_pson
-
-        @module = Puppet::Module.new("foo")
-        @module.stubs(:metadata_file).returns "/my/file"
-        File.stubs(:read).with("/my/file").returns @text
+        @module = a_module_with_metadata(@data)
       end
 
       it "should set the dependency version_requirement key" do
@@ -797,33 +589,33 @@ describe Puppet::Module do
         @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::ModuleTool::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::ModuleTool::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::ModuleTool::Checksums.new(foo_path).checksum(foo_path).should == foo_checksum
-    checksummed_module.has_local_changes?.should be_false
+      Puppet::ModuleTool::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