diff --git a/lib/puppet/feature/base.rb b/lib/puppet/feature/base.rb
index 5f3f0023f..56782b3b6 100644
--- a/lib/puppet/feature/base.rb
+++ b/lib/puppet/feature/base.rb
@@ -1,59 +1,60 @@
 require 'puppet/util/feature'
 
 # Add the simple features, all in one file.
 
 # We've got LDAP available.
 Puppet.features.add(:ldap, :libs => ["ldap"])
 
 # We have the Rdoc::Usage library.
 Puppet.features.add(:usage, :libs => %w{rdoc/ri/ri_paths rdoc/usage})
 
 # We have libshadow, useful for managing passwords.
 Puppet.features.add(:libshadow, :libs => ["shadow"])
 
 # We're running as root.
 Puppet.features.add(:root) { require 'puppet/util/suidmanager'; Puppet::Util::SUIDManager.root? }
 
 # We've got mongrel available
 Puppet.features.add(:mongrel, :libs => %w{rubygems mongrel puppet/network/http_server/mongrel})
 
 # We have lcs diff
 Puppet.features.add :diff, :libs => %w{diff/lcs diff/lcs/hunk}
 
 # We have augeas
 Puppet.features.add(:augeas, :libs => ["augeas"])
 
 # We have RRD available
 Puppet.features.add(:rrd_legacy, :libs => ["RRDtool"])
 Puppet.features.add(:rrd, :libs => ["RRD"])
 
 # We have OpenSSL
 Puppet.features.add(:openssl, :libs => ["openssl"])
 
 # We have a syslog implementation
 Puppet.features.add(:syslog, :libs => ["syslog"])
 
 # We can use POSIX user functions
 Puppet.features.add(:posix) do
   require 'etc'
   Etc.getpwuid(0) != nil && Puppet.features.syslog?
 end
 
 # We can use Microsoft Windows functions
 Puppet.features.add(:microsoft_windows) do
   begin
     require 'sys/admin'
     require 'win32/process'
     require 'win32/dir'
+    require 'win32/service'
   rescue LoadError => err
-    warn "Cannot run on Microsoft Windows without the sys-admin, win32-process & win32-dir gems: #{err}" unless Puppet.features.posix?
+    warn "Cannot run on Microsoft Windows without the sys-admin, win32-process, win32-dir & win32-service gems: #{err}" unless Puppet.features.posix?
   end
 end
 
 raise Puppet::Error,"Cannot determine basic system flavour" unless Puppet.features.posix? or Puppet.features.microsoft_windows?
 
 # We have CouchDB
 Puppet.features.add(:couchdb, :libs => ["couchrest"])
 
 # We have sqlite
 Puppet.features.add(:sqlite, :libs => ["sqlite3"])
diff --git a/lib/puppet/provider/service/windows.rb b/lib/puppet/provider/service/windows.rb
new file mode 100644
index 000000000..09754ffda
--- /dev/null
+++ b/lib/puppet/provider/service/windows.rb
@@ -0,0 +1,101 @@
+# Windows Service Control Manager (SCM) provider
+
+require 'win32/service' if Puppet.features.microsoft_windows?
+
+Puppet::Type.type(:service).provide :windows do
+
+  desc "Support for Windows Service Control Manager (SCM).
+
+  Services are controlled according to win32-service gem.
+
+  * All SCM operations (start/stop/enable/disable/query) are supported.
+
+  * Control of service groups (dependencies) is not yet supported."
+
+  defaultfor :operatingsystem => :windows
+  confine :operatingsystem => :windows
+
+  has_feature :refreshable
+
+  def enable
+    w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_AUTO_START )
+    raise Puppet::Error.new("Win32 service enable of #{@resource[:name]} failed" ) if( w32ss.nil? )
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot enable #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  def disable
+    w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DISABLED )
+    raise Puppet::Error.new("Win32 service disable of #{@resource[:name]} failed" ) if( w32ss.nil? )
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot disable #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  def manual_start
+    w32ss = Win32::Service.configure( 'service_name' => @resource[:name], 'start_type' => Win32::Service::SERVICE_DEMAND_START )
+    raise Puppet::Error.new("Win32 service manual enable of #{@resource[:name]} failed" ) if( w32ss.nil? )
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot enable #{@resource[:name]} for manual start, error was: #{detail}" )
+  end
+
+  def enabled?
+    w32ss = Win32::Service.config_info( @resource[:name] )
+    raise Puppet::Error.new("Win32 service query of #{@resource[:name]} failed" ) unless( !w32ss.nil? && w32ss.instance_of?( Struct::ServiceConfigInfo ) )
+    Puppet.debug("Service #{@resource[:name]} start type is #{w32ss.start_type}")
+    case w32ss.start_type
+      when Win32::Service.get_start_type(Win32::Service::SERVICE_AUTO_START),
+           Win32::Service.get_start_type(Win32::Service::SERVICE_BOOT_START),
+           Win32::Service.get_start_type(Win32::Service::SERVICE_SYSTEM_START)
+        true
+      when Win32::Service.get_start_type(Win32::Service::SERVICE_DEMAND_START)
+        :manual
+      when Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
+        false
+      else
+        raise Puppet::Error.new("Unknown start type: #{w32ss.start_type}")
+    end
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot get start type for #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  def start
+    Win32::Service.start( @resource[:name] )
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot start #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  def stop
+    Win32::Service.stop( @resource[:name] )
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot start #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  def restart
+    self.stop
+    self.start
+  end
+
+  def status
+    w32ss = Win32::Service.status( @resource[:name] )
+    raise Puppet::Error.new("Win32 service query of #{@resource[:name]} failed" ) unless( !w32ss.nil? && w32ss.instance_of?( Struct::ServiceStatus ) )
+    state = case w32ss.current_state
+      when "stopped", "pause pending", "stop pending", "paused" then :stopped
+      when "running", "continue pending", "start pending"       then :running
+      else
+        raise Puppet::Error.new("Unknown service state '#{w32ss.current_state}' for service '#{@resource[:name]}'")
+    end
+    Puppet.debug("Service #{@resource[:name]} is #{w32ss.current_state}")
+    return state
+  rescue Win32::Service::Error => detail
+    raise Puppet::Error.new("Cannot get status of #{@resource[:name]}, error was: #{detail}" )
+  end
+
+  # returns all providers for all existing services and startup state
+  def self.instances
+    srvcs = []
+    Win32::Service.services.collect{ |s|
+      srvcs << new(:name => s.service_name)
+    }
+    srvcs
+  end
+end
diff --git a/lib/puppet/type/service.rb b/lib/puppet/type/service.rb
index 3116f5f8e..eaf2b8ee1 100644
--- a/lib/puppet/type/service.rb
+++ b/lib/puppet/type/service.rb
@@ -1,197 +1,207 @@
 # This is our main way of managing processes right now.
 #
 # a service is distinct from a process in that services
 # can only be managed through the interface of an init script
 # which is why they have a search path for initscripts and such
 
 module Puppet
 
   newtype(:service) do
     @doc = "Manage running services.  Service support unfortunately varies
       widely by platform --- some platforms have very little if any concept of a
       running service, and some have a very codified and powerful concept.
       Puppet's service support is usually capable of doing the right thing, but
       the more information you can provide, the better behaviour you will get.
 
       Puppet 2.7 and newer expect init scripts to have a working status command.
       If this isn't the case for any of your services' init scripts, you will
       need to set `hasstatus` to false and possibly specify a custom status
       command in the `status` attribute.
 
       Note that if a `service` receives an event from another resource,
       the service will get restarted. The actual command to restart the
       service depends on the platform. You can provide an explicit command
       for restarting with the `restart` attribute, or use the init script's
       restart command with the `hasrestart` attribute; if you do neither,
       the service's stop and start commands will be used."
 
     feature :refreshable, "The provider can restart the service.",
       :methods => [:restart]
 
     feature :enableable, "The provider can enable and disable the service",
       :methods => [:disable, :enable, :enabled?]
 
     feature :controllable, "The provider uses a control variable."
 
     newproperty(:enable, :required_features => :enableable) do
       desc "Whether a service should be enabled to start at boot.
         This property behaves quite differently depending on the platform;
         wherever possible, it relies on local tools to enable or disable
         a given service."
 
       newvalue(:true, :event => :service_enabled) do
         provider.enable
       end
 
       newvalue(:false, :event => :service_disabled) do
         provider.disable
       end
 
+      newvalue(:manual, :event => :service_manual_start) do
+        provider.manual_start
+      end
+
       def retrieve
         provider.enabled?
       end
+
+      validate do |value|
+        if value == :manual and !Puppet.features.microsoft_windows?
+          raise Puppet::Error.new("Setting enable to manual is only supported on Microsoft Windows.")
+        end
+      end
     end
 
     # Handle whether the service should actually be running right now.
     newproperty(:ensure) do
       desc "Whether a service should be running."
 
       newvalue(:stopped, :event => :service_stopped) do
         provider.stop
       end
 
       newvalue(:running, :event => :service_started) do
         provider.start
       end
 
       aliasvalue(:false, :stopped)
       aliasvalue(:true, :running)
 
       def retrieve
         provider.status
       end
 
       def sync
         event = super()
 
         if property = @resource.property(:enable)
           val = property.retrieve
           property.sync unless property.safe_insync?(val)
         end
 
         event
       end
     end
 
     newparam(:binary) do
       desc "The path to the daemon.  This is only used for
         systems that do not support init scripts.  This binary will be
         used to start the service if no `start` parameter is
         provided."
     end
 
     newparam(:hasstatus) do
       desc "Declare whether the service's init script has a functional status
         command; defaults to `true`. This attribute's default value changed in
         Puppet 2.7.0.
 
         If a service's init script does not support any kind of status command,
         you should set `hasstatus` to false and either provide a specific
         command using the `status` attribute or expect that Puppet will look for
         the service name in the process table. Be aware that 'virtual' init
         scripts (like 'network' under Red Hat systems) will respond poorly to
         refresh events from other resources if you override the default behavior
         without providing a status command."
 
       newvalues(:true, :false)
 
       defaultto :true
     end
     newparam(:name) do
       desc "The name of the service to run.  This name is used to find
         the service in whatever service subsystem it is in."
       isnamevar
     end
 
     newparam(:path) do
       desc "The search path for finding init scripts.  Multiple values should
         be separated by colons or provided as an array."
 
       munge do |value|
         value = [value] unless value.is_a?(Array)
         # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
         # It affects stand-alone blocks, too.
         paths = value.flatten.collect { |p| x = p.split(":") }.flatten
       end
 
       defaultto { provider.class.defpath if provider.class.respond_to?(:defpath) }
     end
     newparam(:pattern) do
       desc "The pattern to search for in the process table.
         This is used for stopping services on platforms that do not
         support init scripts, and is also used for determining service
         status on those service whose init scripts do not include a status
         command.
 
         If this is left unspecified and is needed to check the status
         of a service, then the service name will be used instead.
 
         The pattern can be a simple string or any legal Ruby pattern."
 
       defaultto { @resource[:binary] || @resource[:name] }
     end
     newparam(:restart) do
       desc "Specify a *restart* command manually.  If left
         unspecified, the service will be stopped and then started."
     end
     newparam(:start) do
       desc "Specify a *start* command manually.  Most service subsystems
         support a `start` command, so this will not need to be
         specified."
     end
     newparam(:status) do
       desc "Specify a *status* command manually.  This command must
         return 0 if the service is running and a nonzero value otherwise.
         Ideally, these return codes should conform to
         [the LSB's specification for init script status actions](http://refspecs.freestandards.org/LSB_3.1.1/LSB-Core-generic/LSB-Core-generic/iniscrptact.html),
         but puppet only considers the difference between 0 and nonzero
         to be relevant.
 
         If left unspecified, the status method will be determined
         automatically, usually by looking for the service in the process
         table."
     end
 
     newparam(:stop) do
       desc "Specify a *stop* command manually."
     end
 
     newparam(:control) do
       desc "The control variable used to manage services (originally for HP-UX).
         Defaults to the upcased service name plus `START` replacing dots with
         underscores, for those providers that support the `controllable` feature."
       defaultto { resource.name.gsub(".","_").upcase + "_START" if resource.provider.controllable? }
     end
 
     newparam :hasrestart do
       desc "Specify that an init script has a `restart` option.  Otherwise,
         the init script's `stop` and `start` methods are used."
       newvalues(:true, :false)
     end
 
     newparam(:manifest) do
       desc "Specify a command to config a service, or a path to a manifest to do so."
     end
 
     # Basically just a synonym for restarting.  Used to respond
     # to events.
     def refresh
       # Only restart if we're actually running
       if (@parameters[:ensure] || newattr(:ensure)).retrieve == :running
         provider.restart
       else
         debug "Skipping restart; service is not running"
       end
     end
   end
 end
diff --git a/spec/unit/provider/service/windows_spec.rb b/spec/unit/provider/service/windows_spec.rb
new file mode 100755
index 000000000..be2f33c20
--- /dev/null
+++ b/spec/unit/provider/service/windows_spec.rb
@@ -0,0 +1,130 @@
+#!/usr/bin/env rspec
+#
+# Unit testing for the Windows service Provider
+#
+
+require 'spec_helper'
+
+require 'ostruct'
+require 'win32/service' if Puppet.features.microsoft_windows?
+
+provider_class = Puppet::Type.type(:service).provider(:windows)
+
+describe provider_class, :if => Puppet.features.microsoft_windows? do
+
+  before :each do
+    @provider = Puppet::Type.type(:service).provider(:windows)
+    Puppet::Type.type(:service).stubs(:provider).returns(@provider)
+  end
+
+  describe ".instances" do
+    it "should enumerate all services" do
+      list_of_services = ['snmptrap', 'svchost', 'sshd'].map {|s| OpenStruct.new(:service_name => s)}
+      Win32::Service.expects(:services).returns(list_of_services)
+
+      provider_class.instances.map {|provider| provider.name}.should =~ ['snmptrap', 'svchost', 'sshd']
+    end
+  end
+
+  describe "#start" do
+    it "should call out to the Win32::Service API to start the service" do
+      Win32::Service.expects(:start).with('snmptrap')
+
+      resource = Puppet::Type.type(:service).new(:name => 'snmptrap')
+      resource.provider.start
+    end
+
+    it "should handle when Win32::Service.start raises a Win32::Service::Error" do
+      Win32::Service.expects(:start).with('snmptrap').raises(
+        Win32::Service::Error.new("The service cannot be started, either because it is disabled or because it has no enabled devices associated with it.")
+      )
+
+      resource = Puppet::Type.type(:service).new(:name => 'snmptrap')
+      expect { resource.provider.start }.to raise_error(
+        Puppet::Error,
+        /Cannot start snmptrap, error was: The service cannot be started, either/
+      )
+    end
+  end
+
+  describe "#stop" do
+    it "should stop a running service"
+    it "should not try to stop an already stopped service"
+  end
+
+  describe "#status" do
+    ['stopped', 'paused', 'stop pending', 'pause pending'].each do |state|
+      it "should report a #{state} service as stopped" do
+        Win32::Service.expects(:status).with('snmptrap').returns(
+          stub(
+            'struct_service_status',
+            :instance_of?  => Struct::ServiceStatus,
+            :current_state => state
+          )
+        )
+        resource = Puppet::Type.type(:service).new(:name => 'snmptrap')
+
+        resource.provider.status.should == :stopped
+      end
+    end
+
+    ["running", "continue pending", "start pending" ].each do |state|
+      it "should report a #{state} service as running" do
+        Win32::Service.expects(:status).with('snmptrap').returns(
+          stub(
+            'struct_service_status',
+            :instance_of?  => Struct::ServiceStatus,
+            :current_state => state
+          )
+        )
+        resource = Puppet::Type.type(:service).new(:name => 'snmptrap')
+        resource.provider.status.should == :running
+      end
+    end
+  end
+
+  describe "#enabled?" do
+    it "should report a service with a startup type of manual as manual" do
+      Win32::Service.expects(:config_info).with('snmptrap').returns(
+        stub(
+          'struct_config_info',
+          :instance_of? => Struct::ServiceConfigInfo,
+          :start_type   => Win32::Service.get_start_type(Win32::Service::SERVICE_DEMAND_START)
+        )
+      )
+      resource = Puppet::Type.type(:service).new(:name => 'snmptrap')
+      resource.provider.enabled?.should == :manual
+    end
+
+    it "should report a service with a startup type of disabled as false" do
+      Win32::Service.expects(:config_info).with('snmptrap').returns(
+        stub(
+          'struct_config_info',
+          :instance_of? => Struct::ServiceConfigInfo,
+          :start_type   => Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
+        )
+      )
+      resource = Puppet::Type.type(:service).new(:name => 'snmptrap')
+      resource.provider.enabled?.should == false
+    end
+
+    # We need to guard this section explicitly since rspec will always
+    # construct all examples, even if it isn't going to run them.
+    if Puppet.features.microsoft_windows?
+      [Win32::Service::SERVICE_AUTO_START, Win32::Service::SERVICE_BOOT_START, Win32::Service::SERVICE_SYSTEM_START].each do |start_type_const|
+        start_type = Win32::Service.get_start_type(start_type_const)
+        it "should report a service with a startup type of '#{start_type}' as true" do
+          Win32::Service.expects(:config_info).with('snmptrap').returns(
+            stub(
+              'struct_config_info',
+              :instance_of? => Struct::ServiceConfigInfo,
+              :start_type   => start_type
+            )
+          )
+          resource = Puppet::Type.type(:service).new(:name => 'snmptrap')
+          resource.provider.enabled?.should == true
+        end
+      end
+    end
+  end
+end
diff --git a/spec/unit/type/service_spec.rb b/spec/unit/type/service_spec.rb
index 40270e7c8..ab006a4be 100755
--- a/spec/unit/type/service_spec.rb
+++ b/spec/unit/type/service_spec.rb
@@ -1,233 +1,248 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Type.type(:service) do
   it "should have an :enableable feature that requires the :enable, :disable, and :enabled? methods" do
     Puppet::Type.type(:service).provider_feature(:enableable).methods.should == [:disable, :enable, :enabled?]
   end
 
   it "should have a :refreshable feature that requires the :restart method" do
     Puppet::Type.type(:service).provider_feature(:refreshable).methods.should == [:restart]
   end
 end
 
 describe Puppet::Type.type(:service), "when validating attributes" do
   [:name, :binary, :hasstatus, :path, :pattern, :start, :restart, :stop, :status, :hasrestart, :control].each do |param|
     it "should have a #{param} parameter" do
       Puppet::Type.type(:service).attrtype(param).should == :param
     end
   end
 
   [:ensure, :enable].each do |param|
     it "should have an #{param} property" do
       Puppet::Type.type(:service).attrtype(param).should == :property
     end
   end
 end
 
 describe Puppet::Type.type(:service), "when validating attribute values" do
   before do
     @provider = stub 'provider', :class => Puppet::Type.type(:service).defaultprovider, :clear => nil, :controllable? => false
     Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(@provider)
   end
 
   it "should support :running as a value to :ensure" do
     Puppet::Type.type(:service).new(:name => "yay", :ensure => :running)
   end
 
   it "should support :stopped as a value to :ensure" do
     Puppet::Type.type(:service).new(:name => "yay", :ensure => :stopped)
   end
 
   it "should alias the value :true to :running in :ensure" do
     svc = Puppet::Type.type(:service).new(:name => "yay", :ensure => true)
     svc.should(:ensure).should == :running
   end
 
   it "should alias the value :false to :stopped in :ensure" do
     svc = Puppet::Type.type(:service).new(:name => "yay", :ensure => false)
     svc.should(:ensure).should == :stopped
   end
 
   it "should support :true as a value to :enable" do
     Puppet::Type.type(:service).new(:name => "yay", :enable => :true)
   end
 
   it "should support :false as a value to :enable" do
     Puppet::Type.type(:service).new(:name => "yay", :enable => :false)
   end
 
+  it "should support :manual as a value to :enable on Windows" do
+    Puppet.features.stubs(:microsoft_windows?).returns true
+
+    Puppet::Type.type(:service).new(:name => "yay", :enable => :manual)
+  end
+
+  it "should not support :manual as a value to :enable when not on Windows" do
+    Puppet.features.stubs(:microsoft_windows?).returns false
+
+    expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :manual) }.to raise_error(
+      Puppet::Error,
+      /Setting enable to manual is only supported on Microsoft Windows\./
+    )
+  end
+
   it "should support :true as a value to :hasstatus" do
     Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :true)
   end
 
   it "should support :false as a value to :hasstatus" do
     Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :false)
   end
 
   it "should specify :true as the default value of hasstatus" do
     Puppet::Type.type(:service).new(:name => "yay")[:hasstatus].should == :true
   end
 
   it "should support :true as a value to :hasrestart" do
     Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :true)
   end
 
   it "should support :false as a value to :hasrestart" do
     Puppet::Type.type(:service).new(:name => "yay", :hasrestart => :false)
   end
 
   it "should allow setting the :enable parameter if the provider has the :enableable feature" do
     Puppet::Type.type(:service).defaultprovider.stubs(:supports_parameter?).returns(true)
     Puppet::Type.type(:service).defaultprovider.expects(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).returns(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
     svc.should(:enable).should == :true
   end
 
   it "should not allow setting the :enable parameter if the provider is missing the :enableable feature" do
     Puppet::Type.type(:service).defaultprovider.stubs(:supports_parameter?).returns(true)
     Puppet::Type.type(:service).defaultprovider.expects(:supports_parameter?).with(Puppet::Type.type(:service).attrclass(:enable)).returns(false)
     svc = Puppet::Type.type(:service).new(:name => "yay", :enable => true)
     svc.should(:enable).should be_nil
   end
 
   it "should split paths on ':'" do
     FileTest.stubs(:exist?).returns(true)
     FileTest.stubs(:directory?).returns(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two:/three/four")
     svc[:path].should == %w{/one/two /three/four}
   end
 
   it "should accept arrays of paths joined by ':'" do
     FileTest.stubs(:exist?).returns(true)
     FileTest.stubs(:directory?).returns(true)
     svc = Puppet::Type.type(:service).new(:name => "yay", :path => ["/one:/two", "/three:/four"])
     svc[:path].should == %w{/one /two /three /four}
   end
 end
 
 describe Puppet::Type.type(:service), "when setting default attribute values" do
   it "should default to the provider's default path if one is available" do
     FileTest.stubs(:directory?).returns(true)
     FileTest.stubs(:exist?).returns(true)
 
     Puppet::Type.type(:service).defaultprovider.stubs(:respond_to?).returns(true)
     Puppet::Type.type(:service).defaultprovider.stubs(:defpath).returns("testing")
     svc = Puppet::Type.type(:service).new(:name => "other")
     svc[:path].should == ["testing"]
   end
 
   it "should default 'pattern' to the binary if one is provided" do
     svc = Puppet::Type.type(:service).new(:name => "other", :binary => "/some/binary")
     svc[:pattern].should == "/some/binary"
   end
 
   it "should default 'pattern' to the name if no pattern is provided" do
     svc = Puppet::Type.type(:service).new(:name => "other")
     svc[:pattern].should == "other"
   end
 
   it "should default 'control' to the upcased service name with periods replaced by underscores if the provider supports the 'controllable' feature" do
     provider = stub 'provider', :controllable? => true, :class => Puppet::Type.type(:service).defaultprovider, :clear => nil
     Puppet::Type.type(:service).defaultprovider.stubs(:new).returns(provider)
     svc = Puppet::Type.type(:service).new(:name => "nfs.client")
     svc[:control].should == "NFS_CLIENT_START"
   end
 end
 
 describe Puppet::Type.type(:service), "when retrieving the host's current state" do
   before do
     @service = Puppet::Type.type(:service).new(:name => "yay")
   end
 
   it "should use the provider's status to determine whether the service is running" do
     @service.provider.expects(:status).returns(:yepper)
     @service[:ensure] = :running
     @service.property(:ensure).retrieve.should == :yepper
   end
 
   it "should ask the provider whether it is enabled" do
     @service.provider.class.stubs(:supports_parameter?).returns(true)
     @service.provider.expects(:enabled?).returns(:yepper)
     @service[:enable] = true
     @service.property(:enable).retrieve.should == :yepper
   end
 end
 
 describe Puppet::Type.type(:service), "when changing the host" do
   before do
     @service = Puppet::Type.type(:service).new(:name => "yay")
   end
 
   it "should start the service if it is supposed to be running" do
     @service[:ensure] = :running
     @service.provider.expects(:start)
     @service.property(:ensure).sync
   end
 
   it "should stop the service if it is supposed to be stopped" do
     @service[:ensure] = :stopped
     @service.provider.expects(:stop)
     @service.property(:ensure).sync
   end
 
   it "should enable the service if it is supposed to be enabled" do
     @service.provider.class.stubs(:supports_parameter?).returns(true)
     @service[:enable] = true
     @service.provider.expects(:enable)
     @service.property(:enable).sync
   end
 
   it "should disable the service if it is supposed to be disabled" do
     @service.provider.class.stubs(:supports_parameter?).returns(true)
     @service[:enable] = false
     @service.provider.expects(:disable)
     @service.property(:enable).sync
   end
 
   it "should sync the service's enable state when changing the state of :ensure if :enable is being managed" do
     @service.provider.class.stubs(:supports_parameter?).returns(true)
     @service[:enable] = false
     @service[:ensure] = :stopped
 
     @service.property(:enable).expects(:retrieve).returns("whatever")
     @service.property(:enable).expects(:insync?).returns(false)
     @service.property(:enable).expects(:sync)
 
     @service.provider.stubs(:stop)
 
     @service.property(:ensure).sync
   end
 end
 
 describe Puppet::Type.type(:service), "when refreshing the service" do
   before do
     @service = Puppet::Type.type(:service).new(:name => "yay")
   end
 
   it "should restart the service if it is running" do
     @service[:ensure] = :running
     @service.provider.expects(:status).returns(:running)
     @service.provider.expects(:restart)
     @service.refresh
   end
 
   it "should restart the service if it is running, even if it is supposed to stopped" do
     @service[:ensure] = :stopped
     @service.provider.expects(:status).returns(:running)
     @service.provider.expects(:restart)
     @service.refresh
   end
 
   it "should not restart the service if it is not running" do
     @service[:ensure] = :running
     @service.provider.expects(:status).returns(:stopped)
     @service.refresh
   end
 
   it "should add :ensure as a property if it is not being managed" do
     @service.provider.expects(:status).returns(:running)
     @service.provider.expects(:restart)
     @service.refresh
   end
 end