Initial cron import from puppet 7a4c5f07bdf61a7bc7aa32a50e99489a604eac52

32 files changed, 3140 insertions, 0 deletions

diff --git a/lib/puppet/provider/cron/crontab.rb b/lib/puppet/provider/cron/crontab.rb
new file mode 100644
index 0000000..b24ed14
--- /dev/null
+++ b/lib/puppet/provider/cron/crontab.rb
@@ -0,0 +1,297 @@
+require 'puppet/provider/parsedfile'
+
+Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFile, :default_target => ENV["USER"] || "root") do
+  commands :crontab => "crontab"
+
+  text_line :comment, :match => %r{^\s*#}, :post_parse => proc { |record|
+    record[:name] = $1 if record[:line] =~ /Puppet Name: (.+)\s*$/
+  }
+
+  text_line :blank, :match => %r{^\s*$}
+
+  text_line :environment, :match => %r{^\s*\w+\s*=}
+
+  def self.filetype
+  tabname = case Facter.value(:osfamily)
+            when "Solaris"
+              :suntab
+            when "AIX"
+              :aixtab
+            else
+              :crontab
+            end
+
+    Puppet::Util::FileType.filetype(tabname)
+  end
+
+  self::TIME_FIELDS = [:minute, :hour, :monthday, :month, :weekday]
+
+  record_line :crontab,
+    :fields     => %w{time command},
+    :match      => %r{^\s*(@\w+|\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.+)$},
+    :absent     => '*',
+    :block_eval => :instance do
+
+    def post_parse(record)
+      time = record.delete(:time)
+      if match = /@(\S+)/.match(time)
+        # is there another way to access the constant?
+        Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.each { |f| record[f] = :absent }
+        record[:special] = match.captures[0]
+      elsif match = /(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/.match(time)
+        record[:special] = :absent
+        Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.zip(match.captures).each do |field,value|
+          if value == self.absent
+            record[field] = :absent
+          else
+            record[field] = value.split(",")
+          end
+        end
+      else
+        raise Puppet::Error, _("Line got parsed as a crontab entry but cannot be handled. Please file a bug with the contents of your crontab")
+      end
+      record
+    end
+
+    def pre_gen(record)
+      if record[:special] and record[:special] != :absent
+        record[:special] = "@#{record[:special]}"
+      end
+
+      Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.each do |field|
+        if vals = record[field] and vals.is_a?(Array)
+          record[field] = vals.join(",")
+        end
+      end
+      record
+    end
+
+    def to_line(record)
+      str = ""
+      record[:name] = nil if record[:unmanaged]
+      str = "# Puppet Name: #{record[:name]}\n" if record[:name]
+      if record[:environment] and record[:environment] != :absent
+        str += record[:environment].map {|line| "#{line}\n"}.join('')
+      end
+      if record[:special] and record[:special] != :absent
+        fields = [:special, :command]
+      else
+        fields = Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS + [:command]
+      end
+      str += record.values_at(*fields).map do |field|
+        if field.nil? or field == :absent
+          self.absent
+        else
+          field
+        end
+      end.join(self.joiner)
+      str
+    end
+  end
+
+  def create
+    if resource.should(:command) then
+      super
+    else
+      resource.err _("no command specified, cannot create")
+    end
+  end
+
+  # Look up a resource with a given name whose user matches a record target
+  #
+  # @api private
+  #
+  # @note This overrides the ParsedFile method for finding resources by name,
+  #   so that only records for a given user are matched to resources of the
+  #   same user so that orphaned records in other crontabs don't get falsely
+  #   matched (#2251)
+  #
+  # @param [Hash<Symbol, Object>] record
+  # @param [Array<Puppet::Resource>] resources
+  #
+  # @return [Puppet::Resource, nil] The resource if found, else nil
+  def self.resource_for_record(record, resources)
+    resource = super
+
+    if resource
+      target = resource[:target] || resource[:user]
+      if record[:target] == target
+        resource
+      end
+    end
+  end
+
+  # Return the header placed at the top of each generated file, warning
+  # users that modifying this file manually is probably a bad idea.
+  def self.header
+%{# HEADER: This file was autogenerated at #{Time.now} by puppet.
+# HEADER: While it can still be managed manually, it is definitely not recommended.
+# HEADER: Note particularly that the comments starting with 'Puppet Name' should
+# HEADER: not be deleted, as doing so could cause duplicate cron jobs.\n}
+  end
+
+  # Regex for finding one vixie cron header.
+  def self.native_header_regex
+    /# DO NOT EDIT THIS FILE.*?Cron version.*?vixie.*?\n/m
+  end
+
+  # If a vixie cron header is found, it should be dropped, cron will insert
+  # a new one in any case, so we need to avoid duplicates.
+  def self.drop_native_header
+    true
+  end
+
+  # See if we can match the record against an existing cron job.
+  def self.match(record, resources)
+    # if the record is named, do not even bother (#19876)
+    # except the resource name was implicitly generated (#3220)
+    return false if record[:name] and !record[:unmanaged]
+    resources.each do |name, resource|
+      # Match the command first, since it's the most important one.
+      next unless record[:target] == resource[:target]
+      next unless record[:command] == resource.value(:command)
+
+      # Now check the time fields
+      compare_fields = self::TIME_FIELDS + [:special]
+
+      matched = true
+      compare_fields.each do |field|
+        # If the resource does not manage a property (say monthday) it should
+        # always match. If it is the other way around (e.g. resource defines
+        # a should value for :special but the record does not have it, we do
+        # not match
+        next unless resource[field]
+        unless record.include?(field)
+          matched = false
+          break
+        end
+
+        if record_value = record[field] and resource_value = resource.value(field)
+          # The record translates '*' into absent in the post_parse hook and
+          # the resource type does exactly the opposite (alias :absent to *)
+          next if resource_value == '*' and record_value == :absent
+          next if resource_value == record_value
+        end
+        matched =false
+        break
+      end
+      return resource if matched
+    end
+    false
+  end
+
+  @name_index = 0
+
+  # Collapse name and env records.
+  def self.prefetch_hook(records)
+    name = nil
+    envs = nil
+    result = records.each { |record|
+      case record[:record_type]
+      when :comment
+        if record[:name]
+          name = record[:name]
+          record[:skip] = true
+
+          # Start collecting env values
+          envs = []
+        end
+      when :environment
+        # If we're collecting env values (meaning we're in a named cronjob),
+        # store the line and skip the record.
+        if envs
+          envs << record[:line]
+          record[:skip] = true
+        end
+      when :blank
+        # nothing
+      else
+        if name
+          record[:name] = name
+          name = nil
+        else
+          cmd_string = record[:command].gsub(/\s+/, "_")
+          index = ( @name_index += 1 )
+          record[:name] = "unmanaged:#{cmd_string}-#{ index.to_s }"
+          record[:unmanaged] = true
+        end
+        if envs.nil? or envs.empty?
+          record[:environment] = :absent
+        else
+          # Collect all of the environment lines, and mark the records to be skipped,
+          # since their data is included in our crontab record.
+          record[:environment] = envs
+
+          # And turn off env collection again
+          envs = nil
+        end
+      end
+    }.reject { |record| record[:skip] }
+    result
+  end
+
+  def self.to_file(records)
+    text = super
+    # Apparently Freebsd will "helpfully" add a new TZ line to every
+    # single cron line, but not in all cases (e.g., it doesn't do it
+    # on my machine).  This is my attempt to fix it so the TZ lines don't
+    # multiply.
+    if text =~ /(^TZ=.+\n)/
+      tz = $1
+      text.sub!(tz, '')
+      text = tz + text
+    end
+    text
+  end
+
+  def user=(user)
+    # we have to mark the target as modified first, to make sure that if
+    # we move a cronjob from userA to userB, userA's crontab will also
+    # be rewritten
+    mark_target_modified
+    @property_hash[:user] = user
+    @property_hash[:target] = user
+  end
+
+  def user
+    @property_hash[:user] || @property_hash[:target]
+  end
+
+  CRONTAB_DIR = case Facter.value("osfamily")
+  when "Debian", "HP-UX"
+    "/var/spool/cron/crontabs"
+  when /BSD/
+    "/var/cron/tabs"
+  when "Darwin"
+    "/usr/lib/cron/tabs/"
+  else
+    "/var/spool/cron"
+  end
+
+  # Yield the names of all crontab files stored on the local system.
+  #
+  # @note Ignores files that are not writable for the puppet process.
+  #
+  # @api private
+  def self.enumerate_crontabs
+    Puppet.debug "looking for crontabs in #{CRONTAB_DIR}"
+    return unless File.readable?(CRONTAB_DIR)
+    Dir.foreach(CRONTAB_DIR) do |file|
+      path = "#{CRONTAB_DIR}/#{file}"
+      yield(file) if File.file?(path) and File.writable?(path)
+    end
+  end
+
+
+  # Include all plausible crontab files on the system
+  # in the list of targets (#11383 / PUP-1381)
+  def self.targets(resources = nil)
+    targets = super(resources)
+    enumerate_crontabs do |target|
+      targets << target
+    end
+    targets.uniq
+  end
+
+end
+
diff --git a/lib/puppet/type/cron.rb b/lib/puppet/type/cron.rb
new file mode 100644
index 0000000..a4f1f91
--- /dev/null
+++ b/lib/puppet/type/cron.rb
@@ -0,0 +1,480 @@
+require 'etc'
+require 'facter'
+require 'puppet/util/filetype'
+
+Puppet::Type.newtype(:cron) do
+  @doc = <<-'EOT'
+    Installs and manages cron jobs.  Every cron resource created by Puppet
+    requires a command and at least one periodic attribute (hour, minute,
+    month, monthday, weekday, or special).  While the name of the cron job is
+    not part of the actual job, the name is stored in a comment beginning with
+    `# Puppet Name: `. These comments are used to match crontab entries created
+    by Puppet with cron resources.
+
+    If an existing crontab entry happens to match the scheduling and command of a
+    cron resource that has never been synced, Puppet will defer to the existing
+    crontab entry and will not create a new entry tagged with the `# Puppet Name: `
+    comment.
+
+    Example:
+
+        cron { 'logrotate':
+          command => '/usr/sbin/logrotate',
+          user    => 'root',
+          hour    => 2,
+          minute  => 0,
+        }
+
+    Note that all periodic attributes can be specified as an array of values:
+
+        cron { 'logrotate':
+          command => '/usr/sbin/logrotate',
+          user    => 'root',
+          hour    => [2, 4],
+        }
+
+    ...or using ranges or the step syntax `*/2` (although there's no guarantee
+    that your `cron` daemon supports these):
+
+        cron { 'logrotate':
+          command => '/usr/sbin/logrotate',
+          user    => 'root',
+          hour    => ['2-4'],
+          minute  => '*/10',
+        }
+
+    An important note: _the Cron type will not reset parameters that are
+    removed from a manifest_. For example, removing a `minute => 10` parameter
+    will not reset the minute component of the associated cronjob to `*`.
+    These changes must be expressed by setting the parameter to
+    `minute => absent` because Puppet only manages parameters that are out of
+    sync with manifest entries.
+
+    **Autorequires:** If Puppet is managing the user account specified by the
+    `user` property of a cron resource, then the cron resource will autorequire
+    that user.
+  EOT
+  ensurable
+
+  # A base class for all of the Cron parameters, since they all have
+  # similar argument checking going on.
+  class CronParam < Puppet::Property
+    class << self
+      attr_accessor :boundaries, :default
+    end
+
+    # We have to override the parent method, because we consume the entire
+    # "should" array
+    def insync?(is)
+      self.is_to_s(is) == self.should_to_s
+    end
+
+    # A method used to do parameter input handling.  Converts integers
+    # in string form to actual integers, and returns the value if it's
+    # an integer or false if it's just a normal string.
+    def numfix(num)
+      if num =~ /^\d+$/
+        return num.to_i
+      elsif num.is_a?(Integer)
+        return num
+      else
+        return false
+      end
+    end
+
+    # Verify that a number is within the specified limits.  Return the
+    # number if it is, or false if it is not.
+    def limitcheck(num, lower, upper)
+      (num >= lower and num <= upper) && num
+    end
+
+    # Verify that a value falls within the specified array.  Does case
+    # insensitive matching, and supports matching either the entire word
+    # or the first three letters of the word.
+    def alphacheck(value, ary)
+      tmp = value.downcase
+
+      # If they specified a shortened version of the name, then see
+      # if we can lengthen it (e.g., mon => monday).
+      if tmp.length == 3
+        ary.each_with_index { |name, index|
+          if tmp.upcase == name[0..2].upcase
+            return index
+          end
+        }
+      else
+        return ary.index(tmp) if ary.include?(tmp)
+      end
+
+      false
+    end
+
+    def should_to_s(value = @should)
+      if value
+        if value.is_a?(Array) && (name == :command || value[0].is_a?(Symbol))
+          value = value[0]
+        end
+        super(value)
+      else
+        nil
+      end
+    end
+
+    def is_to_s(value = @is)
+      if value
+        if value.is_a?(Array) && (name == :command || value[0].is_a?(Symbol))
+          value = value[0]
+        end
+        super(value)
+      else
+        nil
+      end
+    end
+
+    def should
+      if @should and @should[0] == :absent
+        :absent
+      else
+        @should
+      end
+    end
+
+    def should=(ary)
+      super
+      @should.flatten!
+    end
+
+    # The method that does all of the actual parameter value
+    # checking; called by all of the +param<name>=+ methods.
+    # Requires the value, type, and bounds, and optionally supports
+    # a boolean of whether to do alpha checking, and if so requires
+    # the ary against which to do the checking.
+    munge do |value|
+      # Support 'absent' as a value, so that they can remove
+      # a value
+      if value == "absent" or value == :absent
+        return :absent
+      end
+
+      # Allow the */2 syntax
+      if value =~ /^\*\/[0-9]+$/
+        return value
+      end
+
+      # Allow ranges
+      if value =~ /^[0-9]+-[0-9]+$/
+        return value
+      end
+
+      # Allow ranges + */2
+      if value =~ /^[0-9]+-[0-9]+\/[0-9]+$/
+        return value
+      end
+
+      if value == "*"
+        return :absent
+      end
+
+      return value unless self.class.boundaries
+      lower, upper = self.class.boundaries
+      retval = nil
+      if num = numfix(value)
+        retval = limitcheck(num, lower, upper)
+      elsif respond_to?(:alpha)
+        # If it has an alpha method defined, then we check
+        # to see if our value is in that list and if so we turn
+        # it into a number
+        retval = alphacheck(value, alpha)
+      end
+
+      if retval
+        return retval.to_s
+      else
+        self.fail _("%{value} is not a valid %{name}") % { value: value, name: self.class.name }
+      end
+    end
+  end
+
+  # Somewhat uniquely, this property does not actually change anything -- it
+  # just calls +@resource.sync+, which writes out the whole cron tab for
+  # the user in question.  There is no real way to change individual cron
+  # jobs without rewriting the entire cron file.
+  #
+  # Note that this means that managing many cron jobs for a given user
+  # could currently result in multiple write sessions for that user.
+  newproperty(:command, :parent => CronParam) do
+    desc "The command to execute in the cron job.  The environment
+      provided to the command varies by local system rules, and it is
+      best to always provide a fully qualified command.  The user's
+      profile is not sourced when the command is run, so if the
+      user's environment is desired it should be sourced manually.
+
+      All cron parameters support `absent` as a value; this will
+      remove any existing values for that field."
+
+    def retrieve
+      return_value = super
+      return_value = return_value[0] if return_value && return_value.is_a?(Array)
+
+      return_value
+    end
+
+    def should
+      if @should
+        if @should.is_a? Array
+          @should[0]
+        else
+          devfail "command is not an array"
+        end
+      else
+        nil
+      end
+    end
+
+    def munge(value)
+      value.strip
+    end
+  end
+
+  newproperty(:special) do
+    desc "A special value such as 'reboot' or 'annually'.
+       Only available on supported systems such as Vixie Cron.
+       Overrides more specific time of day/week settings.
+       Set to 'absent' to make puppet revert to a plain numeric schedule."
+
+    def specials
+      %w{reboot yearly annually monthly weekly daily midnight hourly absent} +
+        [ :absent ]
+    end
+
+    validate do |value|
+      raise ArgumentError, _("Invalid special schedule %{value}") % { value: value.inspect } unless specials.include?(value)
+    end
+
+    def munge(value)
+      # Support value absent so that a schedule can be
+      # forced to change to numeric.
+      if value == "absent" or value == :absent
+        return :absent
+      end
+      value
+    end
+  end
+
+  newproperty(:minute, :parent => CronParam) do
+    self.boundaries = [0, 59]
+    desc "The minute at which to run the cron job.
+      Optional; if specified, must be between 0 and 59, inclusive."
+  end
+
+  newproperty(:hour, :parent => CronParam) do
+    self.boundaries = [0, 23]
+    desc "The hour at which to run the cron job. Optional;
+      if specified, must be between 0 and 23, inclusive."
+  end
+
+  newproperty(:weekday, :parent => CronParam) do
+    def alpha
+      %w{sunday monday tuesday wednesday thursday friday saturday}
+    end
+    self.boundaries = [0, 7]
+    desc "The weekday on which to run the command. Optional; if specified,
+      must be either:
+
+      -   A number between 0 and 7, inclusive, with 0 or 7 being Sunday
+      -   The name of the day, such as 'Tuesday'."
+  end
+
+  newproperty(:month, :parent => CronParam) do
+    def alpha
+      # The ___placeholder accounts for the fact that month is unique among
+      # "nameable" crontab entries in that it does not use 0-based indexing.
+      # Padding the array with a placeholder introduces the appropriate shift
+      # in indices.
+      %w{___placeholder january february march april may june july
+        august september october november december}
+    end
+    self.boundaries = [1, 12]
+    desc "The month of the year. Optional; if specified,
+      must be either:
+
+      -   A number between 1 and 12, inclusive, with 1 being January
+      -   The name of the month, such as 'December'."
+  end
+
+  newproperty(:monthday, :parent => CronParam) do
+    self.boundaries = [1, 31]
+    desc "The day of the month on which to run the
+      command.  Optional; if specified, must be between 1 and 31."
+  end
+
+  newproperty(:environment) do
+    desc "Any environment settings associated with this cron job.  They
+      will be stored between the header and the job in the crontab.  There
+      can be no guarantees that other, earlier settings will not also
+      affect a given cron job.
+
+
+      Also, Puppet cannot automatically determine whether an existing,
+      unmanaged environment setting is associated with a given cron
+      job.  If you already have cron jobs with environment settings,
+      then Puppet will keep those settings in the same place in the file,
+      but will not associate them with a specific job.
+
+      Settings should be specified exactly as they should appear in
+      the crontab, like `PATH=/bin:/usr/bin:/usr/sbin`."
+
+    validate do |value|
+      unless value =~ /^\s*(\w+)\s*=\s*(.*)\s*$/ or value == :absent or value == "absent"
+        raise ArgumentError, _("Invalid environment setting %{value}") % { value: value.inspect }
+      end
+    end
+
+    def insync?(is)
+      if is.is_a? Array
+        return is.sort == @should.sort
+      else
+        return is == @should
+      end
+    end
+
+    def should
+      @should
+    end
+
+    def should_to_s(newvalue = @should)
+      if newvalue
+        newvalue.join(",")
+      else
+        nil
+      end
+    end
+  end
+
+  newparam(:name) do
+    desc "The symbolic name of the cron job.  This name
+      is used for human reference only and is generated automatically
+      for cron jobs found on the system.  This generally won't
+      matter, as Puppet will do its best to match existing cron jobs
+      against specified jobs (and Puppet adds a comment to cron jobs it adds),
+      but it is at least possible that converting from unmanaged jobs to
+      managed jobs might require manual intervention."
+
+    isnamevar
+  end
+
+  newproperty(:user) do
+    desc "The user who owns the cron job.  This user must
+      be allowed to run cron jobs, which is not currently checked by
+      Puppet.
+
+      This property defaults to the user running Puppet or `root`.
+
+      The default crontab provider executes the system `crontab` using
+      the user account specified by this property."
+
+    defaultto {
+      if not provider.is_a?(@resource.class.provider(:crontab))
+        struct = Etc.getpwuid(Process.uid)
+        struct.respond_to?(:name) && struct.name or 'root'
+      end
+    }
+  end
+
+  # Autorequire the owner of the crontab entry.
+  autorequire(:user) do
+    self[:user]
+  end
+
+  newproperty(:target) do
+    desc "The name of the crontab file in which the cron job should be stored.
+
+      This property defaults to the value of the `user` property if set, the
+      user running Puppet or `root`.
+
+      For the default crontab provider, this property is functionally
+      equivalent to the `user` property and should be avoided. In particular,
+      setting both `user` and `target` to different values will result in
+      undefined behavior."
+
+    defaultto {
+      if provider.is_a?(@resource.class.provider(:crontab))
+        if val = @resource.should(:user)
+          val
+        else
+          struct = Etc.getpwuid(Process.uid)
+          struct.respond_to?(:name) && struct.name or 'root'
+        end
+      elsif provider.class.ancestors.include?(Puppet::Provider::ParsedFile)
+        provider.class.default_target
+      else
+        nil
+      end
+    }
+  end
+
+  validate do
+    return true unless self[:special]
+    return true if self[:special] == :absent
+    # there is a special schedule in @should, so we don't want to see
+    # any numeric should values
+    [ :minute, :hour, :weekday, :monthday, :month ].each do |field|
+      next unless self[field]
+      next if self[field] == :absent
+      raise ArgumentError, _("%{cron} cannot specify both a special schedule and a value for %{field}") % { cron: self.ref, field: field }
+    end
+  end
+
+  # We have to reorder things so that :provide is before :target
+
+  attr_accessor :uid
+
+  # Marks the resource as "being purged".
+  #
+  # @api public
+  #
+  # @note This overrides the Puppet::Type method in order to handle
+  #   an edge case that has so far been observed during testing only.
+  #   Without forcing the should-value for the user property to be
+  #   identical to the original cron file, purging from a fixture
+  #   will not work, because the user property defaults to the user
+  #   running the test. It is not clear whether this scenario can apply
+  #   during normal operation.
+  #
+  # @note Also, when not forcing the should-value for the target
+  #   property, unpurged file content (such as comments) can end up
+  #   being written to the default target (i.e. the current login name).
+  def purging
+    self[:target] = provider.target
+    self[:user] = provider.target
+    super
+  end
+
+  def value(name)
+    name = name.intern
+    ret = nil
+    if obj = @parameters[name]
+      ret = obj.should
+
+      ret ||= obj.retrieve
+
+      if ret == :absent
+        ret = nil
+      end
+    end
+
+    unless ret
+      case name
+      when :command
+      when :special
+        # nothing
+      else
+        #ret = (self.class.validproperty?(name).default || "*").to_s
+        ret = "*"
+      end
+    end
+
+    ret
+  end
+end
+
diff --git a/spec/acceptance/tests/resource/cron/should_allow_changing_parameters.rb b/spec/acceptance/tests/resource/cron/should_allow_changing_parameters.rb
new file mode 100644
index 0000000..4a14371
--- /dev/null
+++ b/spec/acceptance/tests/resource/cron/should_allow_changing_parameters.rb
@@ -0,0 +1,74 @@
+test_name "Cron: should allow changing parameters after creation"
+confine :except, :platform => 'windows'
+confine :except, :platform => /^eos-/ # See PUP-5500
+confine :except, :platform => /^fedora-28/
+tag 'audit:medium',
+    'audit:refactor',  # Use block style `test_name`
+    'audit:acceptance' # Could be done at the integration (or unit) layer though
+                       # actual changing of resources could irreparably damage a
+                       # host running this, or require special permissions.
+
+require 'puppet/acceptance/common_utils'
+extend Puppet::Acceptance::CronUtils
+
+teardown do
+  step "Cron: cleanup"
+  agents.each do |agent|
+    clean agent
+  end
+end
+
+
+agents.each do |agent|
+  step "ensure the user exist via puppet"
+  setup agent
+
+  step "Cron: basic - verify that it can be created"
+  apply_manifest_on(agent, 'cron { "myjob": command => "/bin/false", user    => "tstuser", hour    => "*", minute  => [1], ensure  => present,}') do
+    assert_match( /ensure: created/, result.stdout, "err: #{agent}")
+  end
+  run_cron_on(agent,:list,'tstuser') do
+    assert_match(/.bin.false/, result.stdout, "err: #{agent}")
+  end
+
+  step "Cron: allow changing command"
+  apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => "*", minute  => [1], ensure  => present,}') do
+    assert_match(/command changed '.bin.false'.* to '.bin.true'/, result.stdout, "err: #{agent}")
+  end
+  run_cron_on(agent,:list,'tstuser') do
+    assert_match(/1 . . . . .bin.true/, result.stdout, "err: #{agent}")
+  end
+
+  step "Cron: allow changing time"
+  apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => "1", minute  => [1], ensure  => present,}') do
+    assert_match(/hour: defined 'hour' as \['1'\]/, result.stdout, "err: #{agent}")
+  end
+  run_cron_on(agent,:list,'tstuser') do
+    assert_match(/1 1 . . . .bin.true/, result.stdout, "err: #{agent}")
+  end
+
+  step "Cron: allow changing time(array)"
+  apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => ["1","2"], minute  => [1], ensure  => present,}') do
+    assert_match(/hour: hour changed \['1'\].* to \['1', '2'\]/, result.stdout, "err: #{agent}")
+  end
+  run_cron_on(agent,:list,'tstuser') do
+    assert_match(/1 1,2 . . . .bin.true/, result.stdout, "err: #{agent}")
+  end
+
+  step "Cron: allow changing time(array modification)"
+  apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => ["3","2"], minute  => [1], ensure  => present,}') do
+    assert_match(/hour: hour changed \['1', '2'\].* to \['3', '2'\]/, result.stdout, "err: #{agent}")
+  end
+  run_cron_on(agent,:list,'tstuser') do
+    assert_match(/1 3,2 . . . .bin.true/, result.stdout, "err: #{agent}")
+  end
+  step "Cron: allow changing time(array modification to *)"
+  apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => "*", minute  => "*", ensure  => present,}') do
+    assert_match(/minute: undefined 'minute' from \['1'\]/,result.stdout, "err: #{agent}")
+    assert_match(/hour: undefined 'hour' from \['3', '2'\]/,result.stdout, "err: #{agent}")
+  end
+  run_cron_on(agent,:list,'tstuser') do
+    assert_match(/\* \* . . . .bin.true/, result.stdout, "err: #{agent}")
+  end
+
+end
diff --git a/spec/acceptance/tests/resource/cron/should_be_idempotent.rb b/spec/acceptance/tests/resource/cron/should_be_idempotent.rb
new file mode 100644
index 0000000..0d302c2
--- /dev/null
+++ b/spec/acceptance/tests/resource/cron/should_be_idempotent.rb
@@ -0,0 +1,38 @@
+test_name "Cron: check idempotency"
+confine :except, :platform => 'windows'
+confine :except, :platform => /^eos-/ # See PUP-5500
+confine :except, :platform => /^fedora-28/
+tag 'audit:medium',
+    'audit:refactor',  # Use block style `test_name`
+    'audit:acceptance' # Could be done at the integration (or unit) layer though
+                       # actual changing of resources could irreparably damage a
+                       # host running this, or require special permissions.
+
+require 'puppet/acceptance/common_utils'
+extend Puppet::Acceptance::CronUtils
+
+teardown do
+  step "Cron: cleanup"
+  agents.each do |agent|
+    clean agent
+  end
+end
+
+
+agents.each do |agent|
+  step "ensure the user exist via puppet"
+  setup agent
+
+  step "Cron: basic - verify that it can be created"
+  apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => "*", minute  => [1], ensure  => present,}') do
+    assert_match( /ensure: created/, result.stdout, "err: #{agent}")
+  end
+  run_cron_on(agent,:list,'tstuser') do
+    assert_match(/. . . . . .bin.true/, result.stdout, "err: #{agent}")
+  end
+
+  step "Cron: basic - should not create again"
+  apply_manifest_on(agent, 'cron { "myjob": command => "/bin/true", user    => "tstuser", hour    => "*", minute  => [1], ensure  => present,}') do
+    assert_no_match( /ensure: created/, result.stdout, "err: #{agent}")
+  end
+end
diff --git a/spec/acceptance/tests/resource/cron/should_create_cron.rb b/spec/acceptance/tests/resource/cron/should_create_cron.rb
new file mode 100644
index 0000000..7c3b53f
--- /dev/null
+++ b/spec/acceptance/tests/resource/cron/should_create_cron.rb
@@ -0,0 +1,36 @@
+test_name "should create cron"
+confine :except, :platform => 'windows'
+confine :except, :platform => /^eos-/ # See PUP-5500
+confine :except, :platform => /^fedora-28/
+tag 'audit:medium',
+    'audit:refactor',  # Use block style `test_name`
+    'audit:acceptance' # Could be done at the integration (or unit) layer though
+                       # actual changing of resources could irreparably damage a
+                       # host running this, or require special permissions.
+
+require 'puppet/acceptance/common_utils'
+extend Puppet::Acceptance::CronUtils
+
+teardown do
+  step "Cron: cleanup"
+  agents.each do |agent|
+    clean agent
+  end
+end
+
+agents.each do |host|
+  step "ensure the user exist via puppet"
+  setup host
+
+  step "apply the resource on the host using puppet resource"
+  on(host, puppet_resource("cron", "crontest", "user=tstuser",
+                           "command=/bin/true", "ensure=present")) do
+    assert_match(/created/, stdout, "Did not create crontab for tstuser on #{host}")
+  end
+
+  step "verify that crontab -l contains what you expected"
+  run_cron_on(host, :list, 'tstuser') do
+    assert_match(/\* \* \* \* \* \/bin\/true/, stdout, "Incorrect crontab for tstuser on #{host}")
+  end
+
+end
diff --git a/spec/acceptance/tests/resource/cron/should_match_existing.rb b/spec/acceptance/tests/resource/cron/should_match_existing.rb
new file mode 100644
index 0000000..a59d8ed
--- /dev/null
+++ b/spec/acceptance/tests/resource/cron/should_match_existing.rb
@@ -0,0 +1,36 @@
+test_name "puppet should match existing job"
+confine :except, :platform => 'windows'
+confine :except, :platform => /^eos-/ # See PUP-5500
+confine :except, :platform => /^fedora-28/
+tag 'audit:medium',
+    'audit:refactor',  # Use block style `test_name`
+    'audit:unit'
+
+require 'puppet/acceptance/common_utils'
+extend Puppet::Acceptance::CronUtils
+
+teardown do
+  step "Cron: cleanup"
+  agents.each do |agent|
+    clean agent
+  end
+end
+
+agents.each do |host|
+  step "ensure the user exist via puppet"
+  setup host
+
+  step "Create the existing cron job by hand..."
+  run_cron_on(host,:add,'tstuser',"* * * * * /bin/true")
+
+  step "Apply the resource on the host using puppet resource"
+  on(host, puppet_resource("cron", "crontest", "user=tstuser",
+                           "command=/bin/true", "ensure=present")) do
+    assert_match(/present/, stdout, "Failed creating crontab for tstuser on #{host}")
+  end
+
+  step "Verify that crontab -l contains what you expected"
+  run_cron_on(host, :list, 'tstuser') do
+    assert_match(/\* \* \* \* \* \/bin\/true/, stdout, "Did not find crontab for tstuser on #{host}")
+  end
+end
diff --git a/spec/acceptance/tests/resource/cron/should_remove_cron.rb b/spec/acceptance/tests/resource/cron/should_remove_cron.rb
new file mode 100644
index 0000000..1320272
--- /dev/null
+++ b/spec/acceptance/tests/resource/cron/should_remove_cron.rb
@@ -0,0 +1,39 @@
+test_name "puppet should remove a crontab entry as expected"
+confine :except, :platform => 'windows'
+confine :except, :platform => /^eos-/ # See PUP-5500
+confine :except, :platform => /^fedora-28/
+tag 'audit:medium',
+    'audit:refactor',  # Use block style `test_name`
+    'audit:acceptance' # Could be done at the integration (or unit) layer though
+                       # actual changing of resources could irreparably damage a
+                       # host running this, or require special permissions.
+
+require 'puppet/acceptance/common_utils'
+extend Puppet::Acceptance::CronUtils
+
+teardown do
+  step "Cron: cleanup"
+  agents.each do |agent|
+    clean agent
+  end
+end
+
+agents.each do |host|
+  step "ensure the user exist via puppet"
+  setup host
+
+  step "create the existing job by hand..."
+  run_cron_on(host,:add,'tstuser',"* * * * * /bin/true")
+
+  step "apply the resource on the host using puppet resource"
+  on(host, puppet_resource("cron", "crontest", "user=tstuser",
+                           "command=/bin/true", "ensure=absent")) do
+    assert_match(/crontest\D+ensure:\s+removed/, stdout, "Didn't remove crobtab entry for tstuser on #{host}")
+  end
+
+  step "verify that crontab -l contains what you expected"
+  run_cron_on(host, :list, 'tstuser') do
+    assert_no_match(/\/bin\/true/, stderr, "Error: Found entry for tstuser on #{host}")
+  end
+
+end
diff --git a/spec/acceptance/tests/resource/cron/should_remove_leading_and_trailing_whitespace.rb b/spec/acceptance/tests/resource/cron/should_remove_leading_and_trailing_whitespace.rb
new file mode 100644
index 0000000..33f7142
--- /dev/null
+++ b/spec/acceptance/tests/resource/cron/should_remove_leading_and_trailing_whitespace.rb
@@ -0,0 +1,42 @@
+test_name "(#656) leading and trailing whitespace in cron entries should should be stripped"
+confine :except, :platform => 'windows'
+confine :except, :platform => /^eos-/ # See PUP-5500
+confine :except, :platform => /^fedora-28/
+tag 'audit:medium',
+    'audit:refactor',  # Use block style `test_name`
+    'audit:unit'
+
+require 'puppet/acceptance/common_utils'
+extend Puppet::Acceptance::CronUtils
+
+teardown do
+  step "Cron: cleanup"
+  agents.each do |agent|
+    clean agent
+  end
+end
+
+agents.each do |host|
+  step "create user account for testing cron entries"
+  setup host
+
+  step "apply the resource on the host using puppet resource"
+  on(host, puppet_resource("cron", "crontest", "user=tstuser", "command='   date > /dev/null    '", "ensure=present")) do
+    assert_match(/created/, stdout, "Did not create crontab for tstuser on #{host}")
+  end
+
+  step "verify the added crontab entry has stripped whitespace"
+  run_cron_on(host, :list, 'tstuser') do
+    assert_match(/\* \* \* \* \* date > .dev.null/, stdout, "Incorrect crontab for tstuser on #{host}")
+  end
+
+  step "apply the resource with trailing whitespace and check nothing happened"
+  on(host, puppet_resource("cron", "crontest", "user=tstuser", "command='date > /dev/null    '", "ensure=present")) do
+    assert_no_match(/ensure: created/, stdout, "Rewrote the line with trailing space in crontab for tstuser on #{host}")
+  end
+
+  step "apply the resource with leading whitespace and check nothing happened"
+  on(host, puppet_resource("cron", "crontest", "user=tstuser", "command='     date > /dev/null'", "ensure=present")) do
+    assert_no_match(/ensure: created/, stdout, "Rewrote the line with trailing space in crontab for tstuser on #{host}")
+  end
+end
diff --git a/spec/acceptance/tests/resource/cron/should_remove_matching.rb b/spec/acceptance/tests/resource/cron/should_remove_matching.rb
new file mode 100644
index 0000000..2857a4f
--- /dev/null
+++ b/spec/acceptance/tests/resource/cron/should_remove_matching.rb
@@ -0,0 +1,40 @@
+test_name "puppet should remove a crontab entry based on command matching"
+confine :except, :platform => 'windows'
+confine :except, :platform => /^eos-/ # See PUP-5500
+confine :except, :platform => /^fedora-28/
+tag 'audit:medium',
+    'audit:refactor',  # Use block style `test_name`
+    'audit:acceptance' # Could be done at the integration (or unit) layer though
+                       # actual changing of resources could irreparably damage a
+                       # host running this, or require special permissions.
+
+require 'puppet/acceptance/common_utils'
+extend Puppet::Acceptance::CronUtils
+
+teardown do
+  step "Cron: cleanup"
+  agents.each do |agent|
+    clean agent
+  end
+end
+
+agents.each do |host|
+  step "ensure the user exist via puppet"
+  setup host
+
+  step "create the existing job by hand..."
+  run_cron_on(host,:add,'tstuser',"* * * * * /bin/true")
+
+  step "Remove cron resource"
+  on(host, puppet_resource("cron", "bogus", "user=tstuser",
+                           "command=/bin/true", "ensure=absent")) do
+    assert_match(/bogus\D+ensure: removed/, stdout, "Removing cron entry failed for tstuser on #{host}")
+  end
+
+  step "verify that crontab -l contains what you expected"
+  run_cron_on(host,:list,'tstuser') do
+    count = stdout.scan("/bin/true").length
+    fail_test "found /bin/true the wrong number of times (#{count})" unless count == 0
+  end
+
+end
diff --git a/spec/acceptance/tests/resource/cron/should_update_existing.rb b/spec/acceptance/tests/resource/cron/should_update_existing.rb
new file mode 100644
index 0000000..a4bf177
--- /dev/null
+++ b/spec/acceptance/tests/resource/cron/should_update_existing.rb
@@ -0,0 +1,42 @@
+test_name "puppet should update existing crontab entry"
+confine :except, :platform => 'windows'
+confine :except, :platform => /^eos-/ # See PUP-5500
+confine :except, :platform => /^fedora-28/
+tag 'audit:medium',
+    'audit:refactor',  # Use block style `test_name`
+    'audit:acceptance' # Could be done at the integration (or unit) layer though
+                       # actual changing of resources could irreparably damage a
+                       # host running this, or require special permissions.
+
+require 'puppet/acceptance/common_utils'
+extend Puppet::Acceptance::CronUtils
+
+teardown do
+  step "Cron: cleanup"
+  agents.each do |agent|
+    clean agent
+  end
+end
+
+agents.each do |host|
+  step "ensure the user exist via puppet"
+  setup host
+
+  step "create the existing job by hand..."
+  run_cron_on(host,:add,'tstuser',"* * * * * /bin/true")
+
+  step "verify that crontab -l contains what you expected"
+  run_cron_on(host,:list,'tstuser') do
+    assert_match(/\* \* \* \* \* \/bin\/true/, stdout, "Didn't find correct crobtab entry for tstuser on #{host}")
+  end
+
+  step "apply the resource change on the host"
+  on(host, puppet_resource("cron", "crontest", "user=tstuser", "command=/bin/true", "ensure=present", "hour='0-6'")) do
+    assert_match(/hour\s+=>\s+\['0-6'\]/, stdout, "Modifying cron entry failed for tstuser on #{host}")
+  end
+
+  step "verify that crontab -l contains what you expected"
+  run_cron_on(host,:list,'tstuser') do
+    assert_match(/\* 0-6 \* \* \* \/bin\/true/, stdout, "Didn't find correctly modified time entry in crobtab entry for tstuser on #{host}")
+  end
+end
diff --git a/spec/fixtures/integration/provider/cron/crontab/create_normal_entry b/spec/fixtures/integration/provider/cron/crontab/create_normal_entry
new file mode 100644
index 0000000..e3e2c04
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/create_normal_entry
@@ -0,0 +1,19 @@
+# HEADER: some simple
+# HEADER: header
+@daily /bin/unnamed_special_command >> /dev/null 2>&1
+
+# commend with blankline above and below
+
+17-19,22 0-23/2 * * 2 /bin/unnamed_regular_command
+
+# Puppet Name: My daily failure
+MAILTO=""
+@daily /bin/false
+# Puppet Name: Monthly job
+SHELL=/bin/sh
+MAILTO=mail@company.com
+15 14 1 * * $HOME/bin/monthly
+# Puppet Name: new entry
+MAILTO=""
+SHELL=/bin/bash
+12 * * * 2 /bin/new
diff --git a/spec/fixtures/integration/provider/cron/crontab/create_special_entry b/spec/fixtures/integration/provider/cron/crontab/create_special_entry
new file mode 100644
index 0000000..ee25954
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/create_special_entry
@@ -0,0 +1,18 @@
+# HEADER: some simple
+# HEADER: header
+@daily /bin/unnamed_special_command >> /dev/null 2>&1
+
+# commend with blankline above and below
+
+17-19,22 0-23/2 * * 2 /bin/unnamed_regular_command
+
+# Puppet Name: My daily failure
+MAILTO=""
+@daily /bin/false
+# Puppet Name: Monthly job
+SHELL=/bin/sh
+MAILTO=mail@company.com
+15 14 1 * * $HOME/bin/monthly
+# Puppet Name: new special entry
+MAILTO=bob@company.com
+@reboot echo "Booted" 1>&2
diff --git a/spec/fixtures/integration/provider/cron/crontab/crontab_user1 b/spec/fixtures/integration/provider/cron/crontab/crontab_user1
new file mode 100644
index 0000000..2c7d542
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/crontab_user1
@@ -0,0 +1,15 @@
+# HEADER: some simple
+# HEADER: header
+@daily /bin/unnamed_special_command >> /dev/null 2>&1
+
+# commend with blankline above and below
+
+17-19,22 0-23/2 * * 2 /bin/unnamed_regular_command
+
+# Puppet Name: My daily failure
+MAILTO=""
+@daily /bin/false
+# Puppet Name: Monthly job
+SHELL=/bin/sh
+MAILTO=mail@company.com
+15 14 1 * * $HOME/bin/monthly
diff --git a/spec/fixtures/integration/provider/cron/crontab/crontab_user2 b/spec/fixtures/integration/provider/cron/crontab/crontab_user2
new file mode 100644
index 0000000..267e643
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/crontab_user2
@@ -0,0 +1,4 @@
+# HEADER: some simple
+# HEADER: header
+# Puppet Name: some_unrelevant job
+* * * * * /bin/true
diff --git a/spec/fixtures/integration/provider/cron/crontab/modify_entry b/spec/fixtures/integration/provider/cron/crontab/modify_entry
new file mode 100644
index 0000000..ed06fd4
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/modify_entry
@@ -0,0 +1,13 @@
+# HEADER: some simple
+# HEADER: header
+@daily /bin/unnamed_special_command >> /dev/null 2>&1
+
+# commend with blankline above and below
+
+17-19,22 0-23/2 * * 2 /bin/unnamed_regular_command
+
+# Puppet Name: My daily failure
+MAILTO=""
+@daily /bin/false
+# Puppet Name: Monthly job
+@monthly /usr/bin/monthly
diff --git a/spec/fixtures/integration/provider/cron/crontab/moved_cronjob_input1 b/spec/fixtures/integration/provider/cron/crontab/moved_cronjob_input1
new file mode 100644
index 0000000..2c7d542
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/moved_cronjob_input1
@@ -0,0 +1,15 @@
+# HEADER: some simple
+# HEADER: header
+@daily /bin/unnamed_special_command >> /dev/null 2>&1
+
+# commend with blankline above and below
+
+17-19,22 0-23/2 * * 2 /bin/unnamed_regular_command
+
+# Puppet Name: My daily failure
+MAILTO=""
+@daily /bin/false
+# Puppet Name: Monthly job
+SHELL=/bin/sh
+MAILTO=mail@company.com
+15 14 1 * * $HOME/bin/monthly
diff --git a/spec/fixtures/integration/provider/cron/crontab/moved_cronjob_input2 b/spec/fixtures/integration/provider/cron/crontab/moved_cronjob_input2
new file mode 100644
index 0000000..0b68287
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/moved_cronjob_input2
@@ -0,0 +1,6 @@
+# HEADER: some simple
+# HEADER: header
+# Puppet Name: some_unrelevant job
+* * * * * /bin/true
+# Puppet Name: My daily failure
+@daily /bin/false
diff --git a/spec/fixtures/integration/provider/cron/crontab/purged b/spec/fixtures/integration/provider/cron/crontab/purged
new file mode 100644
index 0000000..b302836
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/purged
@@ -0,0 +1,8 @@
+# HEADER: some simple
+# HEADER: header
+
+# commend with blankline above and below
+
+
+# Puppet Name: only managed entry
+* * * * * /bin/true
diff --git a/spec/fixtures/integration/provider/cron/crontab/remove_named_resource b/spec/fixtures/integration/provider/cron/crontab/remove_named_resource
new file mode 100644
index 0000000..e1c1716
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/remove_named_resource
@@ -0,0 +1,12 @@
+# HEADER: some simple
+# HEADER: header
+@daily /bin/unnamed_special_command >> /dev/null 2>&1
+
+# commend with blankline above and below
+
+17-19,22 0-23/2 * * 2 /bin/unnamed_regular_command
+
+# Puppet Name: Monthly job
+SHELL=/bin/sh
+MAILTO=mail@company.com
+15 14 1 * * $HOME/bin/monthly
diff --git a/spec/fixtures/integration/provider/cron/crontab/remove_unnamed_resource b/spec/fixtures/integration/provider/cron/crontab/remove_unnamed_resource
new file mode 100644
index 0000000..2dcbfe2
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/remove_unnamed_resource
@@ -0,0 +1,14 @@
+# HEADER: some simple
+# HEADER: header
+@daily /bin/unnamed_special_command >> /dev/null 2>&1
+
+# commend with blankline above and below
+
+
+# Puppet Name: My daily failure
+MAILTO=""
+@daily /bin/false
+# Puppet Name: Monthly job
+SHELL=/bin/sh
+MAILTO=mail@company.com
+15 14 1 * * $HOME/bin/monthly
diff --git a/spec/fixtures/integration/provider/cron/crontab/unspecialized b/spec/fixtures/integration/provider/cron/crontab/unspecialized
new file mode 100644
index 0000000..e6a4082
--- /dev/null
+++ b/spec/fixtures/integration/provider/cron/crontab/unspecialized
@@ -0,0 +1,15 @@
+# HEADER: some simple
+# HEADER: header
+@daily /bin/unnamed_special_command >> /dev/null 2>&1
+
+# commend with blankline above and below
+
+17-19,22 0-23/2 * * 2 /bin/unnamed_regular_command
+
+# Puppet Name: My daily failure
+MAILTO=""
+* * * * * /bin/false
+# Puppet Name: Monthly job
+SHELL=/bin/sh
+MAILTO=mail@company.com
+15 14 1 * * $HOME/bin/monthly
diff --git a/spec/fixtures/unit/provider/cron/crontab/single_line.yaml b/spec/fixtures/unit/provider/cron/crontab/single_line.yaml
new file mode 100644
index 0000000..da2853e
--- /dev/null
+++ b/spec/fixtures/unit/provider/cron/crontab/single_line.yaml
@@ -0,0 +1,272 @@
+---
+:longcommment:
+  :text: "# This is a comment"
+  :record:
+    :line: "# This is a comment"
+    :record_type: :comment
+:special:
+  :text: "@hourly /bin/date"
+  :record:
+    :special: hourly
+    :command: /bin/date
+    :record_type: :crontab
+:long_name:
+  :text: "# Puppet Name: long_name"
+  :record:
+    :line: "# Puppet Name: long_name"
+    :name: long_name
+    :record_type: :comment
+:multiple_minutes:
+  :text: 5,15 * * * * /bin/date
+  :record:
+    :minute:
+    - "5"
+    - "15"
+    :command: /bin/date
+    :record_type: :crontab
+:environment:
+  :text: ONE=TWO
+  :record:
+    :line: ONE=TWO
+    :record_type: :environment
+:empty:
+  :text: ""
+  :record:
+    :line: ""
+    :record_type: :blank
+:simple:
+  :text: "* * * * * /bin/date"
+  :record:
+    :command: /bin/date
+    :record_type: :crontab
+:whitespace:
+  :text: "   "
+  :record:
+    :line: "   "
+    :record_type: :blank
+:minute_and_hour:
+  :text: 5 15 * * * /bin/date
+  :record:
+    :minute:
+    - "5"
+    :hour:
+    - "15"
+    :command: /bin/date
+    :record_type: :crontab
+:lowercase_environment:
+  :text: a=b
+  :record:
+    :line: a=b
+    :record_type: :environment
+:special_with_spaces:
+  :text: "@daily /bin/echo testing"
+  :record:
+    :special: daily
+    :command: /bin/echo testing
+    :record_type: :crontab
+:tabs:
+  :text: !binary |
+    CQ==
+
+  :record:
+    :line: !binary |
+      CQ==
+
+    :record_type: :blank
+:multiple_minute_and_hour:
+  :text: 5,10 15,20 * * * /bin/date
+  :record:
+    :minute:
+    - "5"
+    - "10"
+    :hour:
+    - "15"
+    - "20"
+    :command: /bin/date
+    :record_type: :crontab
+:name:
+  :text: "# Puppet Name: testing"
+  :record:
+    :line: "# Puppet Name: testing"
+    :name: testing
+    :record_type: :comment
+:another_env:
+  :text: Testing=True
+  :record:
+    :line: Testing=True
+    :record_type: :environment
+:shortcomment:
+  :text: "#"
+  :record:
+    :line: "#"
+    :record_type: :comment
+:spaces_in_command:
+  :text: "* * * * * /bin/echo testing"
+  :record:
+    :command: /bin/echo testing
+    :record_type: :crontab
+:fourth_env:
+  :text: True=False
+  :record:
+    :line: True=False
+    :record_type: :environment
+:simple_with_minute:
+  :text: 5 * * * * /bin/date
+  :record:
+    :minute:
+    - "5"
+    :command: /bin/date
+    :record_type: :crontab
+:spaces_in_command_with_times:
+  :text: 5,10 15,20 * * * /bin/echo testing
+  :record:
+    :minute:
+    - "5"
+    - "10"
+    :hour:
+    - "15"
+    - "20"
+    :command: /bin/echo testing
+    :record_type: :crontab
+:name_with_spaces:
+  :text: "# Puppet Name: another name"
+  :record:
+    :line: "# Puppet Name: another name"
+    :name: another name
+    :record_type: :comment
+---
+:longcommment:
+  :text: "# This is a comment"
+  :record:
+    :line: "# This is a comment"
+    :record_type: :comment
+:special:
+  :text: "@hourly /bin/date"
+  :record:
+    :special: hourly
+    :command: /bin/date
+    :record_type: :crontab
+:long_name:
+  :text: "# Puppet Name: long_name"
+  :record:
+    :line: "# Puppet Name: long_name"
+    :name: long_name
+    :record_type: :comment
+:multiple_minutes:
+  :text: 5,15 * * * * /bin/date
+  :record:
+    :minute:
+    - "5"
+    - "15"
+    :command: /bin/date
+    :record_type: :crontab
+:environment:
+  :text: ONE=TWO
+  :record:
+    :line: ONE=TWO
+    :record_type: :environment
+:empty:
+  :text: ""
+  :record:
+    :line: ""
+    :record_type: :blank
+:simple:
+  :text: "* * * * * /bin/date"
+  :record:
+    :command: /bin/date
+    :record_type: :crontab
+:whitespace:
+  :text: "   "
+  :record:
+    :line: "   "
+    :record_type: :blank
+:minute_and_hour:
+  :text: 5 15 * * * /bin/date
+  :record:
+    :minute:
+    - "5"
+    :hour:
+    - "15"
+    :command: /bin/date
+    :record_type: :crontab
+:lowercase_environment:
+  :text: a=b
+  :record:
+    :line: a=b
+    :record_type: :environment
+:special_with_spaces:
+  :text: "@daily /bin/echo testing"
+  :record:
+    :special: daily
+    :command: /bin/echo testing
+    :record_type: :crontab
+:tabs:
+  :text: !binary |
+    CQ==
+
+  :record:
+    :line: !binary |
+      CQ==
+
+    :record_type: :blank
+:multiple_minute_and_hour:
+  :text: 5,10 15,20 * * * /bin/date
+  :record:
+    :minute:
+    - "5"
+    - "10"
+    :hour:
+    - "15"
+    - "20"
+    :command: /bin/date
+    :record_type: :crontab
+:name:
+  :text: "# Puppet Name: testing"
+  :record:
+    :line: "# Puppet Name: testing"
+    :name: testing
+    :record_type: :comment
+:another_env:
+  :text: Testing=True
+  :record:
+    :line: Testing=True
+    :record_type: :environment
+:shortcomment:
+  :text: "#"
+  :record:
+    :line: "#"
+    :record_type: :comment
+:spaces_in_command:
+  :text: "* * * * * /bin/echo testing"
+  :record:
+    :command: /bin/echo testing
+    :record_type: :crontab
+:fourth_env:
+  :text: True=False
+  :record:
+    :line: True=False
+    :record_type: :environment
+:simple_with_minute:
+  :text: 5 * * * * /bin/date
+  :record:
+    :minute:
+    - "5"
+    :command: /bin/date
+    :record_type: :crontab
+:spaces_in_command_with_times:
+  :text: 5,10 15,20 * * * /bin/echo testing
+  :record:
+    :minute:
+    - "5"
+    - "10"
+    :hour:
+    - "15"
+    - "20"
+    :command: /bin/echo testing
+    :record_type: :crontab
+:name_with_spaces:
+  :text: "# Puppet Name: another name"
+  :record:
+    :line: "# Puppet Name: another name"
+    :name: another name
+    :record_type: :comment
diff --git a/spec/fixtures/unit/provider/cron/crontab/vixie_header.txt b/spec/fixtures/unit/provider/cron/crontab/vixie_header.txt
new file mode 100644
index 0000000..7ccfc37
--- /dev/null
+++ b/spec/fixtures/unit/provider/cron/crontab/vixie_header.txt
@@ -0,0 +1,3 @@
+# DO NOT EDIT THIS FILE - edit the master and reinstall.
+# (- installed on Thu Apr 12 12:16:01 2007)
+# (Cron version V5.0 -- $Id: crontab.c,v 1.12 2004/01/23 18:56:42 vixie Exp $)
diff --git a/spec/fixtures/unit/provider/cron/parsed/managed b/spec/fixtures/unit/provider/cron/parsed/managed
new file mode 100644
index 0000000..c48d20a
--- /dev/null
+++ b/spec/fixtures/unit/provider/cron/parsed/managed
@@ -0,0 +1,6 @@
+# Puppet Name: real_job
+* * * * * /bin/true
+# Puppet Name: complex_job
+MAILTO=foo@example.com
+SHELL=/bin/sh
+@reboot /bin/true >> /dev/null 2>&1
diff --git a/spec/fixtures/unit/provider/cron/parsed/simple b/spec/fixtures/unit/provider/cron/parsed/simple
new file mode 100644
index 0000000..477553e
--- /dev/null
+++ b/spec/fixtures/unit/provider/cron/parsed/simple
@@ -0,0 +1,9 @@
+# use /bin/sh to run commands, no matter what /etc/passwd says
+SHELL=/bin/sh
+# mail any output to `paul', no matter whose crontab this is
+MAILTO=paul
+#
+# run five minutes after midnight, every day
+5 0 * * *       $HOME/bin/daily.job >> $HOME/tmp/out 2>&1
+# run at 2:15pm on the first of every month -- output mailed to paul
+15 14 1 * *     $HOME/bin/monthly
diff --git a/spec/integration/provider/cron/crontab_spec.rb b/spec/integration/provider/cron/crontab_spec.rb
new file mode 100644
index 0000000..192674f
--- /dev/null
+++ b/spec/integration/provider/cron/crontab_spec.rb
@@ -0,0 +1,242 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'puppet/file_bucket/dipper'
+require 'puppet_spec/compiler'
+
+describe Puppet::Type.type(:cron).provider(:crontab), '(integration)', :unless => Puppet.features.microsoft_windows? do
+  include PuppetSpec::Files
+  include PuppetSpec::Compiler
+
+  before :each do
+    Puppet::Type.type(:cron).stubs(:defaultprovider).returns described_class
+    described_class.stubs(:suitable?).returns true
+    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to filebucket
+
+    # I don't want to execute anything
+    described_class.stubs(:filetype).returns Puppet::Util::FileType::FileTypeFlat
+    described_class.stubs(:default_target).returns crontab_user1
+
+    # I don't want to stub Time.now to get a static header because I don't know
+    # where Time.now is used elsewhere, so just go with a very simple header
+    described_class.stubs(:header).returns "# HEADER: some simple\n# HEADER: header\n"
+    FileUtils.cp(my_fixture('crontab_user1'), crontab_user1)
+    FileUtils.cp(my_fixture('crontab_user2'), crontab_user2)
+  end
+
+  after :each do
+    described_class.clear
+  end
+
+  let :crontab_user1 do
+    tmpfile('cron_integration_specs')
+  end
+
+  let :crontab_user2 do
+    tmpfile('cron_integration_specs')
+  end
+
+  def expect_output(fixture_name)
+    expect(File.read(crontab_user1)).to eq(File.read(my_fixture(fixture_name)))
+  end
+
+  describe "when managing a cron entry" do
+
+    it "should be able to purge unmanaged entries" do
+      apply_with_error_check(<<-MANIFEST)
+      cron {
+        'only managed entry':
+          ensure      => 'present',
+          command     => '/bin/true',
+          target      => '#{crontab_user1}',
+      }
+      resources { 'cron': purge => 'true' }
+      MANIFEST
+      expect_output('purged')
+    end
+
+    describe "with ensure absent" do
+      it "should do nothing if entry already absent" do
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'no_such_entry':
+            ensure => 'absent',
+            target => '#{crontab_user1}',
+        }
+        MANIFEST
+        expect_output('crontab_user1')
+      end
+
+      it "should remove the resource from crontab if present" do
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'My daily failure':
+            ensure => 'absent',
+            target => '#{crontab_user1}',
+        }
+        MANIFEST
+        expect_output('remove_named_resource')
+      end
+
+      it "should remove a matching cronentry if present" do
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'no_such_named_resource_in_crontab':
+            ensure   => absent,
+            minute   => [ '17-19', '22' ],
+            hour     => [ '0-23/2' ],
+            weekday  => 'Tue',
+            command  => '/bin/unnamed_regular_command',
+            target   => '#{crontab_user1}',
+        }
+        MANIFEST
+        expect_output('remove_unnamed_resource')
+      end
+    end
+
+    describe "with ensure present" do
+
+      context "and no command specified" do
+        it "should work if the resource is already present" do
+          apply_with_error_check(<<-MANIFEST)
+          cron {
+            'My daily failure':
+              special => 'daily',
+              target  => '#{crontab_user1}',
+          }
+          MANIFEST
+          expect_output('crontab_user1')
+        end
+        it "should fail if the resource needs creating" do
+          manifest = <<-MANIFEST
+          cron {
+            'Entirely new resource':
+              special => 'daily',
+              target  => '#{crontab_user1}',
+          }
+          MANIFEST
+          apply_compiled_manifest(manifest) do |res|
+            if res.ref == 'Cron[Entirely new resource]'
+              res.expects(:err).with(regexp_matches(/no command/))
+            else
+              res.expects(:err).never
+            end
+          end
+        end
+      end
+
+      it "should do nothing if entry already present" do
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'My daily failure':
+            special => 'daily',
+            command => '/bin/false',
+            target  => '#{crontab_user1}',
+        }
+        MANIFEST
+        expect_output('crontab_user1')
+      end
+
+      it "should work correctly when managing 'target' but not 'user'" do
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'My daily failure':
+            special => 'daily',
+            command => '/bin/false',
+            target  => '#{crontab_user1}',
+        }
+        MANIFEST
+        expect_output('crontab_user1')
+      end
+
+      it "should do nothing if a matching entry already present" do
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'no_such_named_resource_in_crontab':
+            ensure   => present,
+            minute   => [ '17-19', '22' ],
+            hour     => [ '0-23/2' ],
+            command  => '/bin/unnamed_regular_command',
+            target   => '#{crontab_user1}',
+        }
+        MANIFEST
+        expect_output('crontab_user1')
+      end
+
+      it "should add a new normal entry if currently absent" do
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'new entry':
+            ensure      => present,
+            minute      => '12',
+            weekday     => 'Tue',
+            command     => '/bin/new',
+            environment => [
+              'MAILTO=""',
+              'SHELL=/bin/bash'
+            ],
+            target      => '#{crontab_user1}',
+        }
+        MANIFEST
+        expect_output('create_normal_entry')
+      end
+
+      it "should add a new special entry if currently absent" do
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'new special entry':
+            ensure      => present,
+            special     => 'reboot',
+            command     => 'echo "Booted" 1>&2',
+            environment => 'MAILTO=bob@company.com',
+            target      => '#{crontab_user1}',
+        }
+        MANIFEST
+        expect_output('create_special_entry')
+      end
+
+      it "should change existing entry if out of sync" do
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'Monthly job':
+            ensure      => present,
+            special     => 'monthly',
+            #minute => ['22'],
+            command     => '/usr/bin/monthly',
+            environment => [],
+            target      => '#{crontab_user1}',
+        }
+        MANIFEST
+        expect_output('modify_entry')
+      end
+      it "should change a special schedule to numeric if requested" do
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'My daily failure':
+            special     => 'absent',
+            command     => '/bin/false',
+            target      => '#{crontab_user1}',
+        }
+        MANIFEST
+        expect_output('unspecialized')
+      end
+      it "should not try to move an entry from one file to another" do
+        # force the parsedfile provider to also parse user1's crontab
+        apply_with_error_check(<<-MANIFEST)
+        cron {
+          'foo':
+            ensure => absent,
+            target => '#{crontab_user1}';
+          'My daily failure':
+            special      => 'daily',
+            command      => "/bin/false",
+            target       => '#{crontab_user2}',
+        }
+        MANIFEST
+        expect(File.read(crontab_user1)).to eq(File.read(my_fixture('moved_cronjob_input1')))
+        expect(File.read(crontab_user2)).to eq(File.read(my_fixture('moved_cronjob_input2')))
+      end
+    end
+  end
+
+end
diff --git a/spec/lib/puppet_spec/compiler.rb b/spec/lib/puppet_spec/compiler.rb
new file mode 100644
index 0000000..8964a26
--- /dev/null
+++ b/spec/lib/puppet_spec/compiler.rb
@@ -0,0 +1,112 @@
+module PuppetSpec::Compiler
+  module_function
+
+  def compile_to_catalog(string, node = Puppet::Node.new('test'))
+    Puppet[:code] = string
+    # see lib/puppet/indirector/catalog/compiler.rb#filter
+    Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
+  end
+
+  # Does not removed virtual resources in compiled catalog (i.e. keeps unrealized)
+  def compile_to_catalog_unfiltered(string, node = Puppet::Node.new('test'))
+    Puppet[:code] = string
+    # see lib/puppet/indirector/catalog/compiler.rb#filter
+    Puppet::Parser::Compiler.compile(node)
+  end
+
+  def compile_to_ral(manifest, node = Puppet::Node.new('test'))
+    catalog = compile_to_catalog(manifest, node)
+    ral = catalog.to_ral
+    ral.finalize
+    ral
+  end
+
+  def compile_to_relationship_graph(manifest, prioritizer = Puppet::Graph::SequentialPrioritizer.new)
+    ral = compile_to_ral(manifest)
+    graph = Puppet::Graph::RelationshipGraph.new(prioritizer)
+    graph.populate_from(ral)
+    graph
+  end
+
+  def apply_compiled_manifest(manifest, prioritizer = Puppet::Graph::SequentialPrioritizer.new)
+    catalog = compile_to_ral(manifest)
+    if block_given?
+      catalog.resources.each { |res| yield res }
+    end
+    transaction = Puppet::Transaction.new(catalog,
+                                         Puppet::Transaction::Report.new,
+                                         prioritizer)
+    transaction.evaluate
+    transaction.report.finalize_report
+
+    transaction
+  end
+
+  def apply_with_error_check(manifest)
+    apply_compiled_manifest(manifest) do |res|
+      res.expects(:err).never
+    end
+  end
+
+  def order_resources_traversed_in(relationships)
+    order_seen = []
+    relationships.traverse { |resource| order_seen << resource.ref }
+    order_seen
+  end
+
+  def collect_notices(code, node = Puppet::Node.new('foonode'))
+    Puppet[:code] = code
+    compiler = Puppet::Parser::Compiler.new(node)
+    node.environment.check_for_reparse
+    logs = []
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      yield(compiler)
+    end
+    logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
+    logs
+  end
+
+  def eval_and_collect_notices(code, node = Puppet::Node.new('foonode'), topscope_vars = {})
+    collect_notices(code, node) do |compiler|
+      unless topscope_vars.empty?
+        scope = compiler.topscope
+        topscope_vars.each {|k,v| scope.setvar(k, v) }
+      end
+      if block_given?
+        compiler.compile do |catalog|
+          yield(compiler.topscope, catalog)
+          catalog
+        end
+      else
+        compiler.compile
+      end
+    end
+  end
+
+  # Compiles a catalog, and if source is given evaluates it and returns its result.
+  # The catalog is returned if no source is given.
+  # Topscope variables are set before compilation
+  # Uses a created node 'testnode' if none is given.
+  # (Parameters given by name)
+  #
+  def evaluate(code: 'undef', source: nil, node: Puppet::Node.new('testnode'), variables: {})
+    source_location = caller[0]
+    Puppet[:code] = code
+    compiler = Puppet::Parser::Compiler.new(node)
+    unless variables.empty?
+      scope = compiler.topscope
+      variables.each {|k,v| scope.setvar(k, v) }
+    end
+
+    if source.nil?
+      compiler.compile
+      # see lib/puppet/indirector/catalog/compiler.rb#filter
+      return compiler.filter { |r| r.virtual? }
+    end
+
+    # evaluate given source is the context of the compiled state and return its result
+    compiler.compile do |catalog |
+      Puppet::Pops::Parser::EvaluatingParser.singleton.evaluate_string(compiler.topscope, source, source_location)
+    end
+  end
+end
diff --git a/spec/lib/puppet_spec/files.rb b/spec/lib/puppet_spec/files.rb
new file mode 100644
index 0000000..b34daed
--- /dev/null
+++ b/spec/lib/puppet_spec/files.rb
@@ -0,0 +1,108 @@
+require 'fileutils'
+require 'tempfile'
+require 'tmpdir'
+require 'pathname'
+
+# A support module for testing files.
+module PuppetSpec::Files
+  def self.cleanup
+    $global_tempfiles ||= []
+    while path = $global_tempfiles.pop do
+      begin
+        Dir.unstub(:entries)
+        FileUtils.rm_rf path, :secure => true
+      rescue Errno::ENOENT
+        # nothing to do
+      end
+    end
+  end
+
+  module_function
+
+  def make_absolute(path)
+    path = File.expand_path(path)
+    path[0] = 'c' if Puppet.features.microsoft_windows?
+    path
+  end
+
+  def tmpfile(name, dir = nil)
+    dir ||= Dir.tmpdir
+    path = Puppet::FileSystem.expand_path(make_tmpname(name, nil).encode(Encoding::UTF_8), dir)
+    record_tmp(File.expand_path(path))
+
+    path
+  end
+
+  def file_containing(name, contents)
+    file = tmpfile(name)
+    File.open(file, 'wb') { |f| f.write(contents) }
+    file
+  end
+
+  def script_containing(name, contents)
+    file = tmpfile(name)
+    if Puppet.features.microsoft_windows?
+      file += '.bat'
+      text = contents[:windows]
+    else
+      text = contents[:posix]
+    end
+    File.open(file, 'wb') { |f| f.write(text) }
+    Puppet::FileSystem.chmod(0755, file)
+    file
+  end
+
+  def tmpdir(name)
+    dir = Puppet::FileSystem.expand_path(Dir.mktmpdir(name).encode!(Encoding::UTF_8))
+
+    record_tmp(dir)
+
+    dir
+  end
+
+  # Copied from ruby 2.4 source
+  def make_tmpname((prefix, suffix), n)
+    prefix = (String.try_convert(prefix) or
+              raise ArgumentError, "unexpected prefix: #{prefix.inspect}")
+    suffix &&= (String.try_convert(suffix) or
+                raise ArgumentError, "unexpected suffix: #{suffix.inspect}")
+    t = Time.now.strftime("%Y%m%d")
+    path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}".dup
+    path << "-#{n}" if n
+    path << suffix if suffix
+    path
+  end
+
+  def dir_containing(name, contents_hash)
+    dir_contained_in(tmpdir(name), contents_hash)
+  end
+
+  def dir_contained_in(dir, contents_hash)
+    contents_hash.each do |k,v|
+      if v.is_a?(Hash)
+        Dir.mkdir(tmp = File.join(dir,k))
+        dir_contained_in(tmp, v)
+      else
+        file = File.join(dir, k)
+        File.open(file, 'wb') {|f| f.write(v) }
+      end
+    end
+    dir
+  end
+
+  def record_tmp(tmp)
+    # ...record it for cleanup,
+    $global_tempfiles ||= []
+    $global_tempfiles << tmp
+  end
+
+  def expect_file_mode(file, mode)
+    actual_mode = "%o" % Puppet::FileSystem.stat(file).mode
+    target_mode = if Puppet.features.microsoft_windows?
+      mode
+    else
+      "10" + "%04i" % mode.to_i
+    end
+    expect(actual_mode).to eq(target_mode)
+  end
+end
diff --git a/spec/spec_helper_local.rb b/spec/spec_helper_local.rb
new file mode 100644
index 0000000..8757be6
--- /dev/null
+++ b/spec/spec_helper_local.rb
@@ -0,0 +1,17 @@
+dir = File.expand_path(File.dirname(__FILE__))
+$LOAD_PATH.unshift File.join(dir, 'lib')
+
+# Container for various Puppet-specific RSpec helpers.
+module PuppetSpec
+end
+
+require 'puppet_spec/files'
+
+RSpec.configure do |config|
+  config.before :each do |_test|
+    base = PuppetSpec::Files.tmpdir('tmp_settings')
+    Puppet[:vardir] = File.join(base, 'var')
+
+    FileUtils.mkdir_p Puppet[:statedir]
+  end
+end
\ No newline at end of file
diff --git a/spec/unit/provider/cron/crontab_spec.rb b/spec/unit/provider/cron/crontab_spec.rb
new file mode 100644
index 0000000..98ae589
--- /dev/null
+++ b/spec/unit/provider/cron/crontab_spec.rb
@@ -0,0 +1,207 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe Puppet::Type.type(:cron).provider(:crontab) do
+  subject do
+    provider = Puppet::Type.type(:cron).provider(:crontab)
+    provider.initvars
+    provider
+  end
+
+  def compare_crontab_text(have, want)
+    # We should have four header lines, and then the text...
+    expect(have.lines.to_a[0..3]).to be_all {|x| x =~ /^# / }
+    expect(have.lines.to_a[4..-1].join('')).to eq(want)
+  end
+
+  context "with the simple samples" do
+    FIELDS = {
+      :crontab => %w{command minute hour month monthday weekday}.collect { |o| o.intern },
+      :environment => [:line],
+      :blank => [:line],
+      :comment => [:line],
+    }
+
+    def compare_crontab_record(have, want)
+      want.each do |param, value|
+        expect(have).to be_key param
+        expect(have[param]).to eq(value)
+      end
+
+      (FIELDS[have[:record_type]] - want.keys).each do |name|
+        expect(have[name]).to eq(:absent)
+      end
+    end
+
+    ########################################################################
+    # Simple input fixtures for testing.
+    samples = YAML.load(File.read(my_fixture('single_line.yaml')))
+
+    samples.each do |name, data|
+      it "should parse crontab line #{name} correctly" do
+        compare_crontab_record subject.parse_line(data[:text]), data[:record]
+      end
+
+      it "should reconstruct the crontab line #{name} from the record" do
+        expect(subject.to_line(data[:record])).to eq(data[:text])
+      end
+    end
+
+    records = []
+    text    = ""
+
+    # Sorting is from the original, and avoids :empty being the last line,
+    # since the provider will ignore that and cause this to fail.
+    samples.sort_by {|x| x.first.to_s }.each do |name, data|
+      records << data[:record]
+      text    << data[:text] + "\n"
+    end
+
+    it "should parse all sample records at once" do
+      subject.parse(text).zip(records).each do |round|
+        compare_crontab_record(*round)
+      end
+    end
+
+    it "should reconstitute the file from the records" do
+      compare_crontab_text subject.to_file(records), text
+    end
+
+    context "multi-line crontabs" do
+      tests = { :simple    => [:spaces_in_command_with_times],
+        :with_name => [:name, :spaces_in_command_with_times],
+        :with_env  => [:environment, :spaces_in_command_with_times],
+        :with_multiple_envs => [:environment, :lowercase_environment, :spaces_in_command_with_times],
+        :with_name_and_env => [:name_with_spaces, :another_env, :spaces_in_command_with_times],
+        :with_name_and_multiple_envs => [:long_name, :another_env, :fourth_env, :spaces_in_command_with_times]
+      }
+
+      all_records = []
+      all_text    = ''
+
+      tests.each do |name, content|
+        data    = content.map {|x| samples[x] or raise "missing sample data #{x}" }
+        text    = data.map {|x| x[:text] }.join("\n") + "\n"
+        records = data.map {|x| x[:record] }
+
+        # Capture the whole thing for later, too...
+        all_records += records
+        all_text    += text
+
+        context name.to_s.gsub('_', ' ') do
+          it "should regenerate the text from the record" do
+            compare_crontab_text subject.to_file(records), text
+          end
+
+          it "should parse the records from the text" do
+            subject.parse(text).zip(records).each do |round|
+              compare_crontab_record(*round)
+            end
+          end
+        end
+      end
+
+      it "should parse the whole set of records from the text" do
+        subject.parse(all_text).zip(all_records).each do |round|
+          compare_crontab_record(*round)
+        end
+      end
+
+      it "should regenerate the whole text from the set of all records" do
+        compare_crontab_text subject.to_file(all_records), all_text
+      end
+    end
+  end
+
+  context "when receiving a vixie cron header from the cron interface" do
+    it "should not write that header back to disk" do
+      vixie_header = File.read(my_fixture('vixie_header.txt'))
+      vixie_records = subject.parse(vixie_header)
+      compare_crontab_text subject.to_file(vixie_records), ""
+    end
+  end
+
+  context "when adding a cronjob with the same command as an existing job" do
+    let(:record) { {:name => "existing", :user => "root", :command => "/bin/true", :record_type => :crontab} }
+    let(:resource) { Puppet::Type::Cron.new(:name => "test", :user => "root", :command => "/bin/true") }
+    let(:resources) { { "test" => resource } }
+
+    before :each do
+      subject.stubs(:prefetch_all_targets).returns([record])
+    end
+
+# this would be a more fitting test, but I haven't yet
+# figured out how to get it working
+#    it "should include both jobs in the output" do
+#      subject.prefetch(resources)
+#      class Puppet::Provider::ParsedFile
+#        def self.records
+#          @records
+#        end
+#      end
+#      subject.to_file(subject.records).should match /Puppet name: test/
+#    end
+
+    it "should not base the new resource's provider on the existing record" do
+      subject.expects(:new).with(record).never
+      subject.stubs(:new)
+      subject.prefetch(resources)
+    end
+  end
+
+  context "when prefetching an entry now managed for another user" do
+    let(:resource) do
+     s = stub(:resource)
+     s.stubs(:[]).with(:user).returns 'root'
+     s.stubs(:[]).with(:target).returns 'root'
+     s
+    end
+
+    let(:record) { {:name => "test", :user => "nobody", :command => "/bin/true", :record_type => :crontab} }
+    let(:resources) { { "test" => resource } }
+
+    before :each do
+      subject.stubs(:prefetch_all_targets).returns([record])
+    end
+
+    it "should try and use the match method to find a more fitting record" do
+      subject.expects(:match).with(record, resources)
+      subject.prefetch(resources)
+    end
+
+    it "should not match a provider to the resource" do
+      resource.expects(:provider=).never
+      subject.prefetch(resources)
+    end
+
+    it "should not find the resource when looking up the on-disk record" do
+      subject.prefetch(resources)
+      expect(subject.resource_for_record(record, resources)).to be_nil
+    end
+  end
+
+  context "when matching resources to existing crontab entries" do
+    let(:first_resource) { Puppet::Type::Cron.new(:name => :one, :user => 'root', :command => '/bin/true') }
+    let(:second_resource) { Puppet::Type::Cron.new(:name => :two, :user => 'nobody', :command => '/bin/false') }
+
+    let(:resources) {{:one => first_resource, :two => second_resource}}
+
+    describe "with a record with a matching name and mismatching user (#2251)" do
+      # Puppet::Resource objects have #should defined on them, so in these
+      # examples we have to use the monkey patched `must` alias for the rspec
+      # `should` method.
+
+      it "doesn't match the record to the resource" do
+        record = {:name => :one, :user => 'notroot', :record_type => :crontab}
+        expect(subject.resource_for_record(record, resources)).to be_nil
+      end
+    end
+
+    describe "with a record with a matching name and matching user" do
+      it "matches the record to the resource" do
+        record = {:name => :two, :target => 'nobody', :command => '/bin/false'}
+        expect(subject.resource_for_record(record, resources)).to eq(second_resource)
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/cron/parsed_spec.rb b/spec/unit/provider/cron/parsed_spec.rb
new file mode 100644
index 0000000..6cec867
--- /dev/null
+++ b/spec/unit/provider/cron/parsed_spec.rb
@@ -0,0 +1,358 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+describe Puppet::Type.type(:cron).provider(:crontab) do
+
+  let :provider do
+    described_class.new(:command => '/bin/true')
+  end
+
+  let :resource do
+    Puppet::Type.type(:cron).new(
+      :minute      => %w{0 15 30 45},
+      :hour        => %w{8-18 20-22},
+      :monthday    => %w{31},
+      :month       => %w{12},
+      :weekday     => %w{7},
+      :name        => 'basic',
+      :command     => '/bin/true',
+      :target      => 'root',
+      :provider    => provider
+    )
+  end
+
+  let :resource_special do
+    Puppet::Type.type(:cron).new(
+      :special => 'reboot',
+      :name    => 'special',
+      :command => '/bin/true',
+      :target  => 'nobody'
+    )
+  end
+
+  let :resource_sparse do
+    Puppet::Type.type(:cron).new(
+      :minute => %w{42},
+      :target => 'root',
+      :name   => 'sparse'
+    )
+  end
+
+  let :record_special do
+    {
+      :record_type => :crontab,
+      :special     => 'reboot',
+      :command     => '/bin/true',
+      :on_disk     => true,
+      :target      => 'nobody'
+    }
+  end
+
+  let :record do
+    {
+      :record_type => :crontab,
+      :minute      => %w{0 15 30 45},
+      :hour        => %w{8-18 20-22},
+      :monthday    => %w{31},
+      :month       => %w{12},
+      :weekday     => %w{7},
+      :special     => :absent,
+      :command     => '/bin/true',
+      :on_disk     => true,
+      :target      => 'root'
+    }
+  end
+
+  describe "when determining the correct filetype" do
+    it "should use the suntab filetype on Solaris" do
+      Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+      expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeSuntab)
+    end
+
+    it "should use the aixtab filetype on AIX" do
+      Facter.stubs(:value).with(:osfamily).returns 'AIX'
+      expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeAixtab)
+    end
+
+    it "should use the crontab filetype on other platforms" do
+      Facter.stubs(:value).with(:osfamily).returns 'Not a real operating system family'
+      expect(described_class.filetype).to eq(Puppet::Util::FileType::FileTypeCrontab)
+    end
+  end
+
+  # I'd use ENV.expects(:[]).with('USER') but this does not work because
+  # ENV["USER"] is evaluated at load time.
+  describe "when determining the default target" do
+    it "should use the current user #{ENV['USER']}", :if => ENV['USER'] do
+      expect(described_class.default_target).to eq(ENV['USER'])
+    end
+
+    it "should fallback to root", :unless => ENV['USER'] do
+      expect(described_class.default_target).to eq("root")
+    end
+  end
+
+  describe ".targets" do
+    let(:tabs) { [ described_class.default_target ] + %w{foo bar} }
+    before do
+      File.expects(:readable?).returns true
+      File.stubs(:file?).returns true
+      File.stubs(:writable?).returns true
+    end
+    after do
+      File.unstub :readable?, :file?, :writable?
+      Dir.unstub :foreach
+    end
+    it "should add all crontabs as targets" do
+      Dir.expects(:foreach).multiple_yields(*tabs)
+      expect(described_class.targets).to eq(tabs)
+    end
+  end
+
+  describe "when parsing a record" do
+    it "should parse a comment" do
+      expect(described_class.parse_line("# This is a test")).to eq({
+        :record_type => :comment,
+        :line        => "# This is a test",
+      })
+    end
+
+    it "should get the resource name of a PUPPET NAME comment" do
+      expect(described_class.parse_line('# Puppet Name: My Fancy Cronjob')).to eq({
+        :record_type => :comment,
+        :name        => 'My Fancy Cronjob',
+        :line        => '# Puppet Name: My Fancy Cronjob',
+      })
+    end
+
+    it "should ignore blank lines" do
+      expect(described_class.parse_line('')).to eq({:record_type => :blank, :line => ''})
+      expect(described_class.parse_line(' ')).to eq({:record_type => :blank, :line => ' '})
+      expect(described_class.parse_line("\t")).to eq({:record_type => :blank, :line => "\t"})
+      expect(described_class.parse_line("  \t ")).to eq({:record_type => :blank, :line => "  \t "})
+    end
+
+    it "should extract environment assignments" do
+      # man 5 crontab: MAILTO="" with no value can be used to surpress sending
+      # mails at all
+      expect(described_class.parse_line('MAILTO=""')).to eq({:record_type => :environment, :line => 'MAILTO=""'})
+      expect(described_class.parse_line('FOO=BAR')).to eq({:record_type => :environment, :line => 'FOO=BAR'})
+      expect(described_class.parse_line('FOO_BAR=BAR')).to eq({:record_type => :environment, :line => 'FOO_BAR=BAR'})
+      expect(described_class.parse_line('SPACE = BAR')).to eq({:record_type => :environment, :line => 'SPACE = BAR'})
+    end
+
+    it "should extract a cron entry" do
+      expect(described_class.parse_line('* * * * * /bin/true')).to eq({
+        :record_type => :crontab,
+        :hour        => :absent,
+        :minute      => :absent,
+        :month       => :absent,
+        :weekday     => :absent,
+        :monthday    => :absent,
+        :special     => :absent,
+        :command     => '/bin/true'
+      })
+      expect(described_class.parse_line('0,15,30,45 8-18,20-22 31 12 7 /bin/true')).to eq({
+        :record_type => :crontab,
+        :minute      => %w{0 15 30 45},
+        :hour        => %w{8-18 20-22},
+        :monthday    => %w{31},
+        :month       => %w{12},
+        :weekday     => %w{7},
+        :special     => :absent,
+        :command     => '/bin/true'
+      })
+      # A percent sign will cause the rest of the string to be passed as
+      # standard input and will also act as a newline character. Not sure
+      # if puppet should convert % to a \n as the command property so the
+      # test covers the current behaviour: Do not do any conversions
+      expect(described_class.parse_line('0 22 * * 1-5   mail -s "It\'s 10pm" joe%Joe,%%Where are your kids?%')).to eq({
+        :record_type => :crontab,
+        :minute      => %w{0},
+        :hour        => %w{22},
+        :monthday    => :absent,
+        :month       => :absent,
+        :weekday     => %w{1-5},
+        :special     => :absent,
+        :command     => 'mail -s "It\'s 10pm" joe%Joe,%%Where are your kids?%'
+      })
+    end
+
+    describe "it should support special strings" do
+      ['reboot','yearly','anually','monthly', 'weekly', 'daily', 'midnight', 'hourly'].each do |special|
+        it "should support @#{special}" do
+          expect(described_class.parse_line("@#{special} /bin/true")).to eq({
+            :record_type => :crontab,
+            :hour        => :absent,
+            :minute      => :absent,
+            :month       => :absent,
+            :weekday     => :absent,
+            :monthday    => :absent,
+            :special     => special,
+            :command     => '/bin/true'
+          })
+        end
+      end
+    end
+  end
+
+  describe ".instances" do
+    before :each do
+      described_class.stubs(:default_target).returns 'foobar'
+    end
+
+    describe "on linux" do
+      before do
+        Facter.stubs(:value).with(:osfamily).returns 'Linux'
+        Facter.stubs(:value).with(:operatingsystem)
+      end
+
+      it "should contain no resources for a user who has no crontab" do
+        # `crontab...` does only capture stdout here. On vixie-cron-4.1
+        # STDERR shows "no crontab for foobar" but stderr is ignored as
+        # well as the exitcode.
+        described_class.target_object('foobar').expects(:`).with('crontab -u foobar -l 2>/dev/null').returns ""
+        expect(described_class.instances.select { |resource|
+          resource.get('target') == 'foobar'
+        }).to be_empty
+      end
+
+      it "should contain no resources for a user who is absent" do
+        # `crontab...` does only capture stdout. On vixie-cron-4.1
+        # STDERR shows "crontab:  user `foobar' unknown" but stderr is
+        # ignored as well as the exitcode
+        described_class.target_object('foobar').expects(:`).with('crontab -u foobar -l 2>/dev/null').returns ""
+        expect(described_class.instances.select { |resource|
+          resource.get('target') == 'foobar'
+        }).to be_empty
+      end
+
+      it "should be able to create records from not-managed records" do
+        described_class.stubs(:target_object).returns File.new(my_fixture('simple'))
+        parameters = described_class.instances.map do |p|
+          h = {:name => p.get(:name)}
+          Puppet::Type.type(:cron).validproperties.each do |property|
+            h[property] = p.get(property)
+          end
+          h
+        end
+
+        expect(parameters[0][:name]).to match(%r{unmanaged:\$HOME/bin/daily.job_>>_\$HOME/tmp/out_2>&1-\d+})
+        expect(parameters[0][:minute]).to eq(['5'])
+        expect(parameters[0][:hour]).to eq(['0'])
+        expect(parameters[0][:weekday]).to eq(:absent)
+        expect(parameters[0][:month]).to eq(:absent)
+        expect(parameters[0][:monthday]).to eq(:absent)
+        expect(parameters[0][:special]).to eq(:absent)
+        expect(parameters[0][:command]).to match(%r{\$HOME/bin/daily.job >> \$HOME/tmp/out 2>&1})
+        expect(parameters[0][:ensure]).to eq(:present)
+        expect(parameters[0][:environment]).to eq(:absent)
+        expect(parameters[0][:user]).to eq(:absent)
+
+        expect(parameters[1][:name]).to match(%r{unmanaged:\$HOME/bin/monthly-\d+})
+        expect(parameters[1][:minute]).to eq(['15'])
+        expect(parameters[1][:hour]).to eq(['14'])
+        expect(parameters[1][:weekday]).to eq(:absent)
+        expect(parameters[1][:month]).to eq(:absent)
+        expect(parameters[1][:monthday]).to eq(['1'])
+        expect(parameters[1][:special]).to eq(:absent)
+        expect(parameters[1][:command]).to match(%r{\$HOME/bin/monthly})
+        expect(parameters[1][:ensure]).to eq(:present)
+        expect(parameters[1][:environment]).to eq(:absent)
+        expect(parameters[1][:user]).to eq(:absent)
+        expect(parameters[1][:target]).to eq('foobar')
+      end
+
+      it "should be able to parse puppet managed cronjobs" do
+        described_class.stubs(:target_object).returns File.new(my_fixture('managed'))
+        expect(described_class.instances.map do |p|
+          h = {:name => p.get(:name)}
+          Puppet::Type.type(:cron).validproperties.each do |property|
+            h[property] = p.get(property)
+          end
+          h
+        end).to eq([
+          {
+            :name        => 'real_job',
+            :minute      => :absent,
+            :hour        => :absent,
+            :weekday     => :absent,
+            :month       => :absent,
+            :monthday    => :absent,
+            :special     => :absent,
+            :command     => '/bin/true',
+            :ensure      => :present,
+            :environment => :absent,
+            :user        => :absent,
+            :target      => 'foobar'
+          },
+          {
+            :name        => 'complex_job',
+            :minute      => :absent,
+            :hour        => :absent,
+            :weekday     => :absent,
+            :month       => :absent,
+            :monthday    => :absent,
+            :special     => 'reboot',
+            :command     => '/bin/true >> /dev/null 2>&1',
+            :ensure      => :present,
+            :environment => [
+              'MAILTO=foo@example.com',
+              'SHELL=/bin/sh'
+            ],
+            :user        => :absent,
+            :target      => 'foobar'
+          }
+        ])
+      end
+    end
+  end
+
+  describe ".match" do
+    describe "normal records" do
+      it "should match when all fields are the same" do
+        expect(described_class.match(record,{resource[:name] => resource})).to eq(resource)
+      end
+
+      {
+        :minute      => %w{0 15 31 45},
+        :hour        => %w{8-18},
+        :monthday    => %w{30 31},
+        :month       => %w{12 23},
+        :weekday     => %w{4},
+        :command     => '/bin/false',
+        :target      => 'nobody'
+      }.each_pair do |field, new_value|
+        it "should not match a record when #{field} does not match" do
+          record[field] = new_value
+          expect(described_class.match(record,{resource[:name] => resource})).to be_falsey
+        end
+      end
+    end
+
+    describe "special records" do
+      it "should match when all fields are the same" do
+        expect(described_class.match(record_special,{resource_special[:name] => resource_special})).to eq(resource_special)
+      end
+
+      {
+        :special => 'monthly',
+        :command => '/bin/false',
+        :target  => 'root'
+      }.each_pair do |field, new_value|
+        it "should not match a record when #{field} does not match" do
+          record_special[field] = new_value
+          expect(described_class.match(record_special,{resource_special[:name] => resource_special})).to be_falsey
+        end
+      end
+    end
+
+    describe "with a resource without a command" do
+      it "should not raise an error" do
+        expect { described_class.match(record,{resource_sparse[:name] => resource_sparse}) }.to_not raise_error
+      end
+    end
+
+  end
+end
diff --git a/spec/unit/type/cron_spec.rb b/spec/unit/type/cron_spec.rb
new file mode 100644
index 0000000..4241e51
--- /dev/null
+++ b/spec/unit/type/cron_spec.rb
@@ -0,0 +1,543 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows? do
+  let(:simple_provider) do
+    @provider_class = described_class.provide(:simple) { mk_resource_methods }
+    @provider_class.stubs(:suitable?).returns true
+    @provider_class
+  end
+
+  before :each do
+    described_class.stubs(:defaultprovider).returns @provider_class
+  end
+
+  after :each do
+    described_class.unprovide(:simple)
+  end
+
+  it "should have :name be its namevar" do
+    expect(described_class.key_attributes).to eq([:name])
+  end
+
+  describe "when validating attributes" do
+    [:name, :provider].each do |param|
+      it "should have a #{param} parameter" do
+        expect(described_class.attrtype(param)).to eq(:param)
+      end
+    end
+
+    [:command, :special, :minute, :hour, :weekday, :month, :monthday, :environment, :user, :target].each do |property|
+      it "should have a #{property} property" do
+        expect(described_class.attrtype(property)).to eq(:property)
+      end
+    end
+
+    [:command, :minute, :hour, :weekday, :month, :monthday].each do |cronparam|
+      it "should have #{cronparam} of type CronParam" do
+        expect(described_class.attrclass(cronparam).ancestors).to include CronParam
+      end
+    end
+  end
+
+
+  describe "when validating values" do
+
+    describe "ensure" do
+      it "should support present as a value for ensure" do
+        expect { described_class.new(:name => 'foo', :ensure => :present) }.to_not raise_error
+      end
+
+      it "should support absent as a value for ensure" do
+        expect { described_class.new(:name => 'foo', :ensure => :present) }.to_not raise_error
+      end
+
+      it "should not support other values" do
+        expect { described_class.new(:name => 'foo', :ensure => :foo) }.to raise_error(Puppet::Error, /Invalid value/)
+      end
+    end
+
+    describe "command" do
+      it "should discard leading spaces" do
+        expect(described_class.new(:name => 'foo', :command => " /bin/true")[:command]).not_to match Regexp.new(" ")
+      end
+      it "should discard trailing spaces" do
+        expect(described_class.new(:name => 'foo', :command => "/bin/true ")[:command]).not_to match Regexp.new(" ")
+      end
+    end
+
+    describe "minute" do
+      it "should support absent" do
+        expect { described_class.new(:name => 'foo', :minute => 'absent') }.to_not raise_error
+      end
+
+      it "should support *" do
+        expect { described_class.new(:name => 'foo', :minute => '*') }.to_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        expect(described_class.new(:name => 'foo', :minute => 'absent')[:minute]).to eq(:absent)
+      end
+
+      it "should translate * to :absent" do
+        expect(described_class.new(:name => 'foo', :minute => '*')[:minute]).to eq(:absent)
+      end
+
+      it "should support valid single values" do
+        expect { described_class.new(:name => 'foo', :minute => '0') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => '1') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => '59') }.to_not raise_error
+      end
+
+      it "should not support non numeric characters" do
+        expect { described_class.new(:name => 'foo', :minute => 'z59') }.to raise_error(Puppet::Error, /z59 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '5z9') }.to raise_error(Puppet::Error, /5z9 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '59z') }.to raise_error(Puppet::Error, /59z is not a valid minute/)
+      end
+
+      it "should not support single values out of range" do
+
+        expect { described_class.new(:name => 'foo', :minute => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '60') }.to raise_error(Puppet::Error, /60 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '61') }.to raise_error(Puppet::Error, /61 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '120') }.to raise_error(Puppet::Error, /120 is not a valid minute/)
+      end
+
+      it "should support valid multiple values" do
+        expect { described_class.new(:name => 'foo', :minute => ['0','1','59'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => ['40','30','20'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => ['10','30','20'] ) }.to_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        expect { described_class.new(:name => 'foo', :minute => ['0','1','60'] ) }.to raise_error(Puppet::Error, /60 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => ['0','120','59'] ) }.to raise_error(Puppet::Error, /120 is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => ['-1','1','59'] ) }.to raise_error(Puppet::Error, /-1 is not a valid minute/)
+        # two invalid
+        expect { described_class.new(:name => 'foo', :minute => ['0','61','62'] ) }.to raise_error(Puppet::Error, /(61|62) is not a valid minute/)
+        # all invalid
+        expect { described_class.new(:name => 'foo', :minute => ['-1','61','62'] ) }.to raise_error(Puppet::Error, /(-1|61|62) is not a valid minute/)
+      end
+
+      it "should support valid step syntax" do
+        expect { described_class.new(:name => 'foo', :minute => '*/2' ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :minute => '10-16/2' ) }.to_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        expect { described_class.new(:name => 'foo', :minute => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid minute/)
+        expect { described_class.new(:name => 'foo', :minute => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid minute/)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # expect { described_class.new(:name => 'foo', :minute => '*/120' ) }.to raise_error(Puppet::Error, /is not a valid minute/)
+      end
+    end
+
+    describe "hour" do
+      it "should support absent" do
+        expect { described_class.new(:name => 'foo', :hour => 'absent') }.to_not raise_error
+      end
+
+      it "should support *" do
+        expect { described_class.new(:name => 'foo', :hour => '*') }.to_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        expect(described_class.new(:name => 'foo', :hour => 'absent')[:hour]).to eq(:absent)
+      end
+
+      it "should translate * to :absent" do
+        expect(described_class.new(:name => 'foo', :hour => '*')[:hour]).to eq(:absent)
+      end
+
+      it "should support valid single values" do
+        expect { described_class.new(:name => 'foo', :hour => '0') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '11') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '12') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '13') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '23') }.to_not raise_error
+      end
+
+      it "should not support non numeric characters" do
+        expect { described_class.new(:name => 'foo', :hour => 'z15') }.to raise_error(Puppet::Error, /z15 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '1z5') }.to raise_error(Puppet::Error, /1z5 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '15z') }.to raise_error(Puppet::Error, /15z is not a valid hour/)
+      end
+
+      it "should not support single values out of range" do
+        expect { described_class.new(:name => 'foo', :hour => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '24') }.to raise_error(Puppet::Error, /24 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '120') }.to raise_error(Puppet::Error, /120 is not a valid hour/)
+      end
+
+      it "should support valid multiple values" do
+        expect { described_class.new(:name => 'foo', :hour => ['0','1','23'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => ['5','16','14'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => ['16','13','9'] ) }.to_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        expect { described_class.new(:name => 'foo', :hour => ['0','1','24'] ) }.to raise_error(Puppet::Error, /24 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => ['0','-1','5'] ) }.to raise_error(Puppet::Error, /-1 is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => ['-1','1','23'] ) }.to raise_error(Puppet::Error, /-1 is not a valid hour/)
+        # two invalid
+        expect { described_class.new(:name => 'foo', :hour => ['0','25','26'] ) }.to raise_error(Puppet::Error, /(25|26) is not a valid hour/)
+        # all invalid
+        expect { described_class.new(:name => 'foo', :hour => ['-1','24','120'] ) }.to raise_error(Puppet::Error, /(-1|24|120) is not a valid hour/)
+      end
+
+      it "should support valid step syntax" do
+        expect { described_class.new(:name => 'foo', :hour => '*/2' ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :hour => '10-18/4' ) }.to_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        expect { described_class.new(:name => 'foo', :hour => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid hour/)
+        expect { described_class.new(:name => 'foo', :hour => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid hour/)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # expect { described_class.new(:name => 'foo', :hour => '*/26' ) }.to raise_error(Puppet::Error, /is not a valid hour/)
+      end
+    end
+
+    describe "weekday" do
+      it "should support absent" do
+        expect { described_class.new(:name => 'foo', :weekday => 'absent') }.to_not raise_error
+      end
+
+      it "should support *" do
+        expect { described_class.new(:name => 'foo', :weekday => '*') }.to_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        expect(described_class.new(:name => 'foo', :weekday => 'absent')[:weekday]).to eq(:absent)
+      end
+
+      it "should translate * to :absent" do
+        expect(described_class.new(:name => 'foo', :weekday => '*')[:weekday]).to eq(:absent)
+      end
+
+      it "should support valid numeric weekdays" do
+        expect { described_class.new(:name => 'foo', :weekday => '0') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => '1') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => '6') }.to_not raise_error
+        # According to http://www.manpagez.com/man/5/crontab 7 is also valid (Sunday)
+        expect { described_class.new(:name => 'foo', :weekday => '7') }.to_not raise_error
+      end
+
+      it "should support valid weekdays as words (long version)" do
+        expect { described_class.new(:name => 'foo', :weekday => 'Monday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Tuesday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Wednesday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Thursday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Friday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Saturday') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Sunday') }.to_not raise_error
+      end
+
+      it "should support valid weekdays as words (3 character version)" do
+        expect { described_class.new(:name => 'foo', :weekday => 'Mon') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Tue') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Wed') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Thu') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Fri') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Sat') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => 'Sun') }.to_not raise_error
+      end
+
+      it "should not support numeric values out of range" do
+        expect { described_class.new(:name => 'foo', :weekday => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => '8') }.to raise_error(Puppet::Error, /8 is not a valid weekday/)
+      end
+
+      it "should not support invalid weekday names" do
+        expect { described_class.new(:name => 'foo', :weekday => 'Sar') }.to raise_error(Puppet::Error, /Sar is not a valid weekday/)
+      end
+
+      it "should support valid multiple values" do
+        expect { described_class.new(:name => 'foo', :weekday => ['0','1','6'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => ['Mon','Wed','Friday'] ) }.to_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        expect { described_class.new(:name => 'foo', :weekday => ['0','1','8'] ) }.to raise_error(Puppet::Error, /8 is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => ['Mon','Fii','Sat'] ) }.to raise_error(Puppet::Error, /Fii is not a valid weekday/)
+        # two invalid
+        expect { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Sat'] ) }.to raise_error(Puppet::Error, /(Mos|Fii) is not a valid weekday/)
+        # all invalid
+        expect { described_class.new(:name => 'foo', :weekday => ['Mos','Fii','Saa'] ) }.to raise_error(Puppet::Error, /(Mos|Fii|Saa) is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => ['-1','8','11'] ) }.to raise_error(Puppet::Error, /(-1|8|11) is not a valid weekday/)
+      end
+
+      it "should support valid step syntax" do
+        expect { described_class.new(:name => 'foo', :weekday => '*/2' ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :weekday => '0-4/2' ) }.to_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        expect { described_class.new(:name => 'foo', :weekday => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid weekday/)
+        expect { described_class.new(:name => 'foo', :weekday => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid weekday/)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # expect { described_class.new(:name => 'foo', :weekday => '*/9' ) }.to raise_error(Puppet::Error, /is not a valid weekday/)
+      end
+    end
+
+    describe "month" do
+      it "should support absent" do
+        expect { described_class.new(:name => 'foo', :month => 'absent') }.to_not raise_error
+      end
+
+      it "should support *" do
+        expect { described_class.new(:name => 'foo', :month => '*') }.to_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        expect(described_class.new(:name => 'foo', :month => 'absent')[:month]).to eq(:absent)
+      end
+
+      it "should translate * to :absent" do
+        expect(described_class.new(:name => 'foo', :month => '*')[:month]).to eq(:absent)
+      end
+
+      it "should support valid numeric values" do
+        expect { described_class.new(:name => 'foo', :month => '1') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => '12') }.to_not raise_error
+      end
+
+      it "should support valid months as words" do
+        expect( described_class.new(:name => 'foo', :month => 'January')[:month]   ).to eq(['1'])
+        expect( described_class.new(:name => 'foo', :month => 'February')[:month]  ).to eq(['2'])
+        expect( described_class.new(:name => 'foo', :month => 'March')[:month]     ).to eq(['3'])
+        expect( described_class.new(:name => 'foo', :month => 'April')[:month]     ).to eq(['4'])
+        expect( described_class.new(:name => 'foo', :month => 'May')[:month]       ).to eq(['5'])
+        expect( described_class.new(:name => 'foo', :month => 'June')[:month]      ).to eq(['6'])
+        expect( described_class.new(:name => 'foo', :month => 'July')[:month]      ).to eq(['7'])
+        expect( described_class.new(:name => 'foo', :month => 'August')[:month]    ).to eq(['8'])
+        expect( described_class.new(:name => 'foo', :month => 'September')[:month] ).to eq(['9'])
+        expect( described_class.new(:name => 'foo', :month => 'October')[:month]   ).to eq(['10'])
+        expect( described_class.new(:name => 'foo', :month => 'November')[:month]  ).to eq(['11'])
+        expect( described_class.new(:name => 'foo', :month => 'December')[:month]  ).to eq(['12'])
+      end
+
+      it "should support valid months as words (3 character short version)" do
+        expect( described_class.new(:name => 'foo', :month => 'Jan')[:month] ).to eq(['1'])
+        expect( described_class.new(:name => 'foo', :month => 'Feb')[:month] ).to eq(['2'])
+        expect( described_class.new(:name => 'foo', :month => 'Mar')[:month] ).to eq(['3'])
+        expect( described_class.new(:name => 'foo', :month => 'Apr')[:month] ).to eq(['4'])
+        expect( described_class.new(:name => 'foo', :month => 'May')[:month] ).to eq(['5'])
+        expect( described_class.new(:name => 'foo', :month => 'Jun')[:month] ).to eq(['6'])
+        expect( described_class.new(:name => 'foo', :month => 'Jul')[:month] ).to eq(['7'])
+        expect( described_class.new(:name => 'foo', :month => 'Aug')[:month] ).to eq(['8'])
+        expect( described_class.new(:name => 'foo', :month => 'Sep')[:month] ).to eq(['9'])
+        expect( described_class.new(:name => 'foo', :month => 'Oct')[:month] ).to eq(['10'])
+        expect( described_class.new(:name => 'foo', :month => 'Nov')[:month] ).to eq(['11'])
+        expect( described_class.new(:name => 'foo', :month => 'Dec')[:month] ).to eq(['12'])
+      end
+
+      it "should not support numeric values out of range" do
+        expect { described_class.new(:name => 'foo', :month => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '0') }.to raise_error(Puppet::Error, /0 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '13') }.to raise_error(Puppet::Error, /13 is not a valid month/)
+      end
+
+      it "should not support words that are not valid months" do
+        expect { described_class.new(:name => 'foo', :month => 'Jal') }.to raise_error(Puppet::Error, /Jal is not a valid month/)
+      end
+
+      it "should not support single values out of range" do
+
+        expect { described_class.new(:name => 'foo', :month => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '60') }.to raise_error(Puppet::Error, /60 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '61') }.to raise_error(Puppet::Error, /61 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '120') }.to raise_error(Puppet::Error, /120 is not a valid month/)
+      end
+
+      it "should support valid multiple values" do
+        expect { described_class.new(:name => 'foo', :month => ['1','9','12'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => ['Jan','March','Jul'] ) }.to_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        expect { described_class.new(:name => 'foo', :month => ['0','1','12'] ) }.to raise_error(Puppet::Error, /0 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => ['1','13','10'] ) }.to raise_error(Puppet::Error, /13 is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => ['Jan','Feb','Jxx'] ) }.to raise_error(Puppet::Error, /Jxx is not a valid month/)
+        # two invalid
+        expect { described_class.new(:name => 'foo', :month => ['Jan','Fex','Jux'] ) }.to raise_error(Puppet::Error, /(Fex|Jux) is not a valid month/)
+        # all invalid
+        expect { described_class.new(:name => 'foo', :month => ['-1','0','13'] ) }.to raise_error(Puppet::Error, /(-1|0|13) is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => ['Jax','Fex','Aux'] ) }.to raise_error(Puppet::Error, /(Jax|Fex|Aux) is not a valid month/)
+      end
+
+      it "should support valid step syntax" do
+        expect { described_class.new(:name => 'foo', :month => '*/2' ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :month => '1-12/3' ) }.to_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        expect { described_class.new(:name => 'foo', :month => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid month/)
+        expect { described_class.new(:name => 'foo', :month => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid month/)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # expect { described_class.new(:name => 'foo', :month => '*/13' ) }.to raise_error(Puppet::Error, /is not a valid month/)
+      end
+    end
+
+    describe "monthday" do
+      it "should support absent" do
+        expect { described_class.new(:name => 'foo', :monthday => 'absent') }.to_not raise_error
+      end
+
+      it "should support *" do
+        expect { described_class.new(:name => 'foo', :monthday => '*') }.to_not raise_error
+      end
+
+      it "should translate absent to :absent" do
+        expect(described_class.new(:name => 'foo', :monthday => 'absent')[:monthday]).to eq(:absent)
+      end
+
+      it "should translate * to :absent" do
+        expect(described_class.new(:name => 'foo', :monthday => '*')[:monthday]).to eq(:absent)
+      end
+
+      it "should support valid single values" do
+        expect { described_class.new(:name => 'foo', :monthday => '1') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => '30') }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => '31') }.to_not raise_error
+      end
+
+      it "should not support non numeric characters" do
+        expect { described_class.new(:name => 'foo', :monthday => 'z23') }.to raise_error(Puppet::Error, /z23 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '2z3') }.to raise_error(Puppet::Error, /2z3 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '23z') }.to raise_error(Puppet::Error, /23z is not a valid monthday/)
+      end
+
+      it "should not support single values out of range" do
+        expect { described_class.new(:name => 'foo', :monthday => '-1') }.to raise_error(Puppet::Error, /-1 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '0') }.to raise_error(Puppet::Error, /0 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '32') }.to raise_error(Puppet::Error, /32 is not a valid monthday/)
+      end
+
+      it "should support valid multiple values" do
+        expect { described_class.new(:name => 'foo', :monthday => ['1','23','31'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => ['31','23','1'] ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => ['1','31','23'] ) }.to_not raise_error
+      end
+
+      it "should not support multiple values if at least one is invalid" do
+        # one invalid
+        expect { described_class.new(:name => 'foo', :monthday => ['1','23','32'] ) }.to raise_error(Puppet::Error, /32 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => ['-1','12','23'] ) }.to raise_error(Puppet::Error, /-1 is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => ['13','32','30'] ) }.to raise_error(Puppet::Error, /32 is not a valid monthday/)
+        # two invalid
+        expect { described_class.new(:name => 'foo', :monthday => ['-1','0','23'] ) }.to raise_error(Puppet::Error, /(-1|0) is not a valid monthday/)
+        # all invalid
+        expect { described_class.new(:name => 'foo', :monthday => ['-1','0','32'] ) }.to raise_error(Puppet::Error, /(-1|0|32) is not a valid monthday/)
+      end
+
+      it "should support valid step syntax" do
+        expect { described_class.new(:name => 'foo', :monthday => '*/2' ) }.to_not raise_error
+        expect { described_class.new(:name => 'foo', :monthday => '10-16/2' ) }.to_not raise_error
+      end
+
+      it "should not support invalid steps" do
+        expect { described_class.new(:name => 'foo', :monthday => '*/A' ) }.to raise_error(Puppet::Error, /\*\/A is not a valid monthday/)
+        expect { described_class.new(:name => 'foo', :monthday => '*/2A' ) }.to raise_error(Puppet::Error, /\*\/2A is not a valid monthday/)
+        # As it turns out cron does not complaining about steps that exceed the valid range
+        # expect { described_class.new(:name => 'foo', :monthday => '*/32' ) }.to raise_error(Puppet::Error, /is not a valid monthday/)
+      end
+    end
+
+    describe "special" do
+      %w(reboot yearly annually monthly weekly daily midnight hourly).each do |value|
+        it "should support the value '#{value}'" do
+          expect { described_class.new(:name => 'foo', :special => value ) }.to_not raise_error
+        end
+      end
+
+      context "when combined with numeric schedule fields" do
+        context "which are 'absent'" do
+          [ %w(reboot yearly annually monthly weekly daily midnight hourly), :absent ].flatten.each { |value|
+            it "should accept the value '#{value}' for special" do
+              expect {
+                described_class.new(:name => 'foo', :minute => :absent, :special => value )
+              }.to_not raise_error
+            end
+          }
+        end
+        context "which are not absent" do
+          %w(reboot yearly annually monthly weekly daily midnight hourly).each { |value|
+            it "should not accept the value '#{value}' for special" do
+              expect {
+                described_class.new(:name => 'foo', :minute => "1", :special => value )
+              }.to raise_error(Puppet::Error, /cannot specify both a special schedule and a value/)
+            end
+          }
+          it "should accept the 'absent' value for special" do
+            expect {
+              described_class.new(:name => 'foo', :minute => "1", :special => :absent )
+            }.to_not raise_error
+          end
+        end
+      end
+    end
+
+    describe "environment" do
+      it "it should accept an :environment that looks like a path" do
+        expect do
+          described_class.new(:name => 'foo',:environment => 'PATH=/bin:/usr/bin:/usr/sbin')
+        end.to_not raise_error
+      end
+
+      it "should not accept environment variables that do not contain '='" do
+        expect do
+          described_class.new(:name => 'foo',:environment => 'INVALID')
+        end.to raise_error(Puppet::Error, /Invalid environment setting "INVALID"/)
+      end
+
+      it "should accept empty environment variables that do not contain '='" do
+        expect do
+          described_class.new(:name => 'foo',:environment => 'MAILTO=')
+        end.to_not raise_error
+      end
+
+      it "should accept 'absent'" do
+        expect do
+          described_class.new(:name => 'foo',:environment => 'absent')
+        end.to_not raise_error
+      end
+
+    end
+  end
+
+  describe "when autorequiring resources" do
+
+    before :each do
+      @user_bob = Puppet::Type.type(:user).new(:name => 'bob', :ensure => :present)
+      @user_alice = Puppet::Type.type(:user).new(:name => 'alice', :ensure => :present)
+      @catalog = Puppet::Resource::Catalog.new
+      @catalog.add_resource @user_bob, @user_alice
+    end
+
+    it "should autorequire the user" do
+      @resource = described_class.new(:name => 'dummy', :command => '/usr/bin/uptime', :user => 'alice')
+      @catalog.add_resource @resource
+      req = @resource.autorequire
+      expect(req.size).to eq(1)
+      expect(req[0].target).to eq(@resource)
+      expect(req[0].source).to eq(@user_alice)
+    end
+  end
+
+  it "should not require a command when removing an entry" do
+    entry = described_class.new(:name => "test_entry", :ensure => :absent)
+    expect(entry.value(:command)).to eq(nil)
+  end
+
+  it "should default to user => root if Etc.getpwuid(Process.uid) returns nil (#12357)" do
+    Etc.expects(:getpwuid).returns(nil)
+    entry = described_class.new(:name => "test_entry", :ensure => :present)
+    expect(entry.value(:user)).to eql "root"
+  end
+end