[blacksmith] Bump version to 0.2.0

Previous attempt didn't work properly. This version uses the proper
`provider.has_command` api to specify the env vars which should be used.

Also catches the exit 1 thrown when `equo match --installed` doesn't
find anything, now that the wrapper script is no longer hiding the exit
code behind an explicit `exit 0`.

.pmtignore

@@ -0,0 +1 @@
+vendor/

CHANGELOG.md

@@ -1,9 +1,23 @@
-## Unreleased
+## 2016-10-13 Release 0.2.0
+
+- Add `locale` fact
+- Remove obsolete `has_entropy` fact
+- Improve `entropy` package provider to set locale envvar directly
+  and not shell out to a distributed script to set locale.
+
+## 2016-10-13 Release 0.1.2
+
+- Improved package regexes for valdiation and parsing
+  (now following the Gentoo EAPI6 PMS document to ensure correctness)
+- Removed validation for required parameters in `entropy_*` types
+
+## 2016-10-13 Release 0.1.0
 
 - Added support for additional types:
   - `entropy_splitdebug`
   - `entropy_splitdebug_mask`
   - `entropy_keywords`
+- Added spec tests for most types and providers
 
 ## 2016-10-10 Release 0.0.2
 

README.md

@@ -243,6 +243,19 @@ For more info on package keywords, see https://wiki.gentoo.org/wiki/KEYWORDS
 * `entropy_splitdebug` Manages entropy package debug information
 * `entropy_splitdebug_mask` Manages entropy package debug information masks
 
+### Facts
+
+#### `locale`
+
+Identifies the system-wide default locale, as set by `eselect`.
+
+This is used internally by the entropy package provider to run `equo` commands
+using the correct locale.
+
+#### `operatingsystem`
+
+Overrides the detection of the operating system on Sabayon systems to `Sabayon`.
+
 ## Limitations
 
 This module is actively used by the developer against current Sabayon versions.

lib/facter/has_entropy.rb

@@ -1,7 +0,0 @@
-Facter.add(:has_entropy) do
-    confine :kernel => :linux
-    setcode do
-        FileTest.exists?("/usr/bin/equo")
-    end
-end
-

lib/facter/locale.rb

@@ -0,0 +1,7 @@
+Facter.add(:locale) do
+    confine :osfamily => :gentoo
+    setcode do
+      Facter::Core::Execution.exec('eselect --colour=no --brief locale show').strip
+    end
+end
+

lib/puppet/provider/entropy_keywords/parsed.rb

@@ -18,25 +18,22 @@ Puppet::Type.type(:entropy_keywords).provide(:parsed,
     :match      => /^\s*#/
 
   text_line :unmanaged,
-    :match   => %r{^(\S+)\s+([<>]?=)?([a-zA-Z+\/-]*)(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?:\s+repo=([a-zA-Z0-9\._-]+))?\s*$}
+    :match   => %r{^(\S+)\s+([<>]?=)?(?:((?:[A-Za-z0-9+_.-]+/)?[a-zA-Z0-9+_-]+)?(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?)?(?:\s*repo=([a-zA-Z0-9\._-]+))?\s*$}
 
   record_line :parsed,
     :fields => %w{keyword operator package version repo name},
-    :match   => %r{^(\S+)\s+([<>]?=)?([a-zA-Z+\/-]*)(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?:\s+repo=([a-zA-Z0-9\._-]+))?\s+## Puppet Name: (.*)\s*$},
+    :match   => %r{^(\S+)\s+([<>]?=)?(?:((?:[A-Za-z0-9+_.-]+/)?[a-zA-Z0-9+_-]+)?(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?)?(?:\s*repo=([a-zA-Z0-9\._-]+))?\s+## Puppet Name: (.*)\s*$},
-    :block_eval => :instance do
+    :to_line => proc { |record|
-
-    def to_line(record)
       line = record[:keyword] + " "
       line += record[:operator]        if record[:operator]
       line += record[:package]         if record[:package]
       line += "-" + record[:version]   if record[:version]
-      line += " repo=" + record[:repo]     if record[:repo]
+      line += " "                      if record[:package] && record[:repo]
+      line += "repo=" + record[:repo]  if record[:repo]
       line += " ## Puppet Name: " + record[:name]
 
       line
-    end
+    }
-
-  end
 
 end
 

lib/puppet/provider/entropy_mask/parsed.rb

@@ -18,17 +18,15 @@ Puppet::Type.type(:entropy_mask).provide(:parsed,
     :match      => /^\s*#/
 
   text_line :unmanaged,
-    :match   => %r{^([<>]?=)?([a-zA-Z+\/-]*)(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9\._-]+))?\s*$}
+    :match   => %r{^([<>]?=)?((?:[A-Za-z0-9+_.-]+/)?[a-zA-Z0-9+_-]+)?(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9\._-]+))?\s*$}
 
   record_line :parsed,
     :fields => %w{operator package version slot use tag repo name},
-    :match   => %r{^([<>]?=)?([a-zA-Z+\/-]*)(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9\._-]+))?\s+#+ Puppet Name: (.*)\s*$},
+    :match   => %r{^([<>]?=)?((?:[A-Za-z0-9+_.-]+/)?[a-zA-Z0-9+_-]+)?(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9\._-]+))?\s+#+ Puppet Name: (.*)\s*$},
-    :block_eval => :instance do
+    :to_line => proc { |record|
-
-    def to_line(record)
       line = ""
       line += record[:operator]        if record[:operator]
-      line += record[:package]
+      line += record[:package]         if record[:package]
       line += "-" + record[:version]   if record[:version]
       line += ":" + record[:slot]      if record[:slot]
       line += "[" + record[:use] + "]" if record[:use]
@@ -37,9 +35,7 @@ Puppet::Type.type(:entropy_mask).provide(:parsed,
       line += " ## Puppet Name: " + record[:name]
 
       line
-    end
+    }
-
-  end
 
 end
 

lib/puppet/provider/entropy_splitdebug/parsed.rb

@@ -18,17 +18,15 @@ Puppet::Type.type(:entropy_splitdebug).provide(:parsed,
     :match      => /^\s*#/
 
   text_line :unmanaged,
-    :match   => %r{^([<>]?=)?([a-zA-Z+\/-]*)(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9\._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9\._-]+))?(?:::([a-zA-Z0-9\._-]+))?\s*$}
+    :match   => %r{^([<>]?=)?((?:[A-Za-z0-9+_.-]+/)?[a-zA-Z0-9+_-]+)?(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9\._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9\._-]+))?(?:::([a-zA-Z0-9\._-]+))?\s*$}
 
   record_line :parsed,
     :fields => %w{operator package version slot use tag repo name},
-    :match   => %r{^([<>]?=)?([a-zA-Z+\/-]*)(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9\._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9\._-]+))?(?:::([a-zA-Z0-9\._-]+))?\s+#+ Puppet Name: (.*)\s*$},
+    :match   => %r{^([<>]?=)?((?:[A-Za-z0-9+_.-]+/)?[a-zA-Z0-9+_-]+)?(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9\._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9\._-]+))?(?:::([a-zA-Z0-9\._-]+))?\s+#+ Puppet Name: (.*)\s*$},
-    :block_eval => :instance do
+    :to_line => proc { |record|
-
-    def to_line(record)
       line = ""
       line += record[:operator]        if record[:operator]
-      line += record[:package]
+      line += record[:package]         if record[:package]
       line += "-" + record[:version]   if record[:version]
       line += ":" + record[:slot]      if record[:slot]
       line += "[" + record[:use] + "]" if record[:use]
@@ -37,9 +35,7 @@ Puppet::Type.type(:entropy_splitdebug).provide(:parsed,
       line += " ## Puppet Name: " + record[:name]
 
       line
-    end
+    }
-
-  end
    
 end
 

lib/puppet/provider/entropy_splitdebug_mask/parsed.rb

@@ -1,7 +1,7 @@
 require 'puppet/provider/parsedfile'
 file = "/etc/entropy/packages/package.splitdebug.mask"
 
-Puppet::Type.type(:entropy_splitdebug).provide(:parsed,
+Puppet::Type.type(:entropy_splitdebug_mask).provide(:parsed,
   :parent => Puppet::Provider::ParsedFile,
   :default_target => file,
   :filetype => :flat
@@ -18,17 +18,15 @@ Puppet::Type.type(:entropy_splitdebug).provide(:parsed,
     :match      => /^\s*#/
 
   text_line :unmanaged,
-    :match   => %r{^([<>]?=)?([a-zA-Z+\/-]*)(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9\._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9._-]+))?\s*$}
+    :match   => %r{^([<>]?=)?((?:[A-Za-z0-9+_.-]+/)?[a-zA-Z0-9+_-]+)?(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9\._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9._-]+))?\s*$}
 
   record_line :parsed,
     :fields => %w{operator package version slot use tag repo name},
-    :match   => %r{^([<>]?=)?([a-zA-Z+\/-]*)(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9._-]+))?\s+#+ Puppet Name: (.*)\s*$},
+    :match   => %r{^([<>]?=)?((?:[A-Za-z0-9+_.-]+/)?[a-zA-Z0-9+_-]+)?(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9._-]+))?\s+#+ Puppet Name: (.*)\s*$},
-    :block_eval => :instance do
+    :to_line => proc { |record|
-
-    def to_line(record)
       line = ""
       line += record[:operator]        if record[:operator]
-      line += record[:package]
+      line += record[:package]         if record[:package]
       line += "-" + record[:version]   if record[:version]
       line += ":" + record[:slot]      if record[:slot]
       line += "[" + record[:use] + "]" if record[:use]
@@ -37,9 +35,7 @@ Puppet::Type.type(:entropy_splitdebug).provide(:parsed,
       line += " ## Puppet Name: " + record[:name]
 
       line
-    end
+    }
-
-  end
    
 end
 

lib/puppet/provider/entropy_unmask/parsed.rb

@@ -18,17 +18,15 @@ Puppet::Type.type(:entropy_unmask).provide(:parsed,
     :match      => /^\s*#/
 
   text_line :unmanaged,
-    :match   => %r{^([<>]?=)?([a-zA-Z+\/-]*)(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9._-]+))?\s*$}
+    :match   => %r{^([<>]?=)?((?:[A-Za-z0-9+_.-]+/)?[a-zA-Z0-9+_-]+)?(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9._-]+))?\s*$}
 
   record_line :parsed,
     :fields => %w{operator package version slot use tag repo name},
-    :match   => %r{^([<>]?=)?([a-zA-Z+\/-]*)(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9._-]+))?\s+#+ Puppet Name: (.*)\s*$},
+    :match   => %r{^([<>]?=)?((?:[A-Za-z0-9+_.-]+/)?[a-zA-Z0-9+_-]+)?(?:-(\d+(?:\.\d+)*[a-z]*(?:_(?:alpha|beta|pre|p|rc)\d*)?(?:-r\d+)?))?(?::([a-zA-Z0-9._-]+))?(?:\[([^\]]*)\])?(?:#([a-zA-Z0-9._-]+))?(?:::([a-zA-Z0-9._-]+))?\s+#+ Puppet Name: (.*)\s*$},
-    :block_eval => :instance do
+    :to_line => proc { |record|
-
-    def to_line(record)
       line = ""
       line += record[:operator]        if record[:operator]
-      line += record[:package]
+      line += record[:package]         if record[:package]
       line += "-" + record[:version]   if record[:version]
       line += ":" + record[:slot]      if record[:slot]
       line += "[" + record[:use] + "]" if record[:use]
@@ -37,9 +35,7 @@ Puppet::Type.type(:entropy_unmask).provide(:parsed,
       line += " ## Puppet Name: " + record[:name]
 
       line
-    end
+    }
-
-  end
    
 end
 

lib/puppet/provider/package/entropy.rb

@@ -1,7 +1,7 @@
 require 'puppet/provider/package'
 require 'fileutils'
 
-Puppet::Type.type(:package).provide :entropy, :parent => Puppet::Provider::Package do
+Puppet::Type.type(:package).provide(:entropy, :parent => Puppet::Provider::Package) do
   desc "Provides packaging support for Sabayon's entropy system."
 
   has_feature :versionable
@@ -9,18 +9,27 @@ Puppet::Type.type(:package).provide :entropy, :parent => Puppet::Provider::Packa
   has_feature :uninstallable
   has_feature :upgradeable
 
-  commands :equo => "#{File.dirname(__FILE__)}/entropy/equo_locale"
+  has_command(:equo, "equo") do
+    locale = Facter.value(:locale)
+    environment({
+      :LANG => locale,
+      :LC_ALL => locale,
+      :LANGUAHE => locale,
+    })
+  end
 
-  confine :has_entropy => true
+  # Require the locale fact exist
+  confine :false => Facter.value(:locale).nil?
+  confine :osfamily => :Gentoo
   
-  defaultfor :has_entropy => :true, :osfamily => :Gentoo
+  defaultfor :operatingsystem => :Sabayon
 
   def self.instances
     result_format = /^(\S+)\/(\S+)-([\.\d]+(?:_?(?:a(?:lpha)?|b(?:eta)?|pre|rc|p)\d*)?(?:-r\d+)?)(?:#(\S+))?$/
     result_fields = [:category, :name, :ensure]
 
     begin
-      search_output = equo "query", "list", "installed", "--quiet", "--verbose"
+      search_output = equo("query", "list", "installed", "--quiet", "--verbose").chomp
 
       packages = []
       search_output.each_line do |search_result|
@@ -32,6 +41,7 @@ Puppet::Type.type(:package).provide :entropy, :parent => Puppet::Provider::Packa
             package[field] = value unless !value or value.empty?
           end
           package[:provider] = :entropy
+
           packages << new(package)
         end
       end
@@ -70,13 +80,12 @@ Puppet::Type.type(:package).provide :entropy, :parent => Puppet::Provider::Packa
   end
 
   def query
-    result_format = /^(\S+)\/(\S+)-([\.\d]+(?:_(?:alpha|beta|pre|rc|p)\d+)?(?:-r\d+)?)(?:#(\S+))?$/
+    result_format = /^(\S+)\/(\S+)-([\.\d]+(?:_(?:alpha|beta|pre|rc|p)\d+)?(?:-r\d+)?)(?::[^#]+)?(?:#(\S+))?$/
     result_fields = [:category, :name, :version_available]
 
     begin
       # Look for an installed package from a known repository
-      search_output = equo "match", "--quiet", "--verbose", package_name
+      search_output = equo("match", "--quiet", "--verbose", package_name).chomp
-      search_output.chomp
 
       search_match = search_output.match(result_format)
       if search_match
@@ -85,8 +94,9 @@ Puppet::Type.type(:package).provide :entropy, :parent => Puppet::Provider::Packa
           package[field] = value unless !value or value.empty?
         end
 
-        installed_output = equo 'match', '--quiet', '--verbose', '--installed', package_name
+
-        installed_output.chomp
+        begin
+          installed_output = equo('match', '--quiet', '--verbose', '--installed', package_name).chomp
           installed_match = installed_output.match(result_format)
 
           if installed_match
@@ -95,14 +105,16 @@ Puppet::Type.type(:package).provide :entropy, :parent => Puppet::Provider::Packa
           else
             package[:ensure] = :absent
           end
+        rescue Puppet::ExecutionFailure
+          package[:ensure] = :absent
+        end
 
         return package
 
       else
         # List all installed packages and try and find if it's installed from outside a repository
         # If so, assume the installed version is the latest available
-        all_installed = equo "query", "list", "installed", "--quiet", "--verbose"
+        all_installed = equo("query", "list", "installed", "--quiet", "--verbose").chomp
-        all_installed.chomp
 
         all_installed.split("\n").each do |installed_package|
         

lib/puppet/provider/package/entropy/equo_locale

@@ -1,6 +0,0 @@
-#!/bin/bash
-
-source /etc/profile
-/usr/bin/equo $@
-
-exit 0

lib/puppet/type/entropy_keywords.rb

@@ -26,14 +26,12 @@ Puppet::Type.newtype(:entropy_keywords) do
 
   newproperty(:package) do
     desc "Name of the package being keyworded"
+    newvalues(%r{^(?:[A-Za-z0-9+_.-]+\/)?[a-zA-Z0-9+_-]+$})
   end
 
   newproperty(:version) do
     desc "Version of the package"
-
+    newvalues(%r{^(\d*(?:\.\d+[a-zA-Z]*)*)(?:_((?:alpha|beta|pre|rc)\d*))?(-r\d+)?$})
-    validate do |value|
-      raise(ArgumentError, "") if value !~ /^(\d*(?:\.\d+[a-zA-Z]*)*)(?:_((?:alpha|beta|pre|rc)\d*))?(-r\d+)?$/
-    end
   end
 
   newproperty(:repo) do
@@ -53,8 +51,6 @@ Puppet::Type.newtype(:entropy_keywords) do
   end
 
   validate do
-    raise(ArgumentError, "At least one of package or repo is required") if self[:package].nil? && self[:repo].nil?
-
     raise(ArgumentError, "Package is required when a version is specified") if self[:package].nil? && !self[:version].nil?
 
     raise(ArgumentError, "Version is required when an operator is specified") if self[:version].nil? && !self[:operator].nil?

lib/puppet/type/entropy_mask.rb

@@ -13,14 +13,12 @@ Puppet::Type.newtype(:entropy_mask) do
 
   newproperty(:package) do
     desc "Name of the package being masked"
+    newvalues(%r{^(?:[A-Za-z0-9+_.-]+\/)?[a-zA-Z0-9+_-]+$})
   end
 
   newproperty(:version) do
     desc "Version of the package"
-
+    newvalues(%r{^(\d*(?:\.\d+[a-zA-Z]*)*)(?:_((?:alpha|beta|pre|rc)\d*))?(-r\d+)?$})
-    validate do |value|
-      raise(ArgumentError, "") if value !~ /^(\d*(?:\.\d+[a-zA-Z]*)*)(?:_((?:alpha|beta|pre|rc)\d*))?(-r\d+)?$/
-    end
   end
 
   newproperty(:slot) do
@@ -52,8 +50,6 @@ Puppet::Type.newtype(:entropy_mask) do
   end
 
   validate do
-    raise(ArgumentError, "At least one of package, tag or repo is required") if self[:package].nil? && self[:tag].nil? && self[:repo].nil?
-
     raise(ArgumentError, "Package is required when a version is specified") if self[:package].nil? && !self[:version].nil?
 
     raise(ArgumentError, "Version is required when an operator is specified") if self[:version].nil? && !self[:operator].nil?

lib/puppet/type/entropy_splitdebug.rb

@@ -13,14 +13,12 @@ Puppet::Type.newtype(:entropy_splitdebug) do
 
   newproperty(:package) do
     desc "Name of the package with splitdebug"
+    newvalues(%r{^(?:[A-Za-z0-9+_.-]+\/)?[a-zA-Z0-9+_-]+$})
   end
 
   newproperty(:version) do
     desc "Version of the package"
-
+    newvalues(%r{^(\d*(?:\.\d+[a-zA-Z]*)*)(?:_((?:alpha|beta|pre|rc)\d*))?(-r\d+)?$})
-    validate do |value|
-      raise(ArgumentError, "") if value !~ /^(\d*(?:\.\d+[a-zA-Z]*)*)(?:_((?:alpha|beta|pre|rc)\d*))?(-r\d+)?$/
-    end
   end
 
   newproperty(:slot) do
@@ -52,6 +50,8 @@ Puppet::Type.newtype(:entropy_splitdebug) do
   end
 
   validate do
+    raise(ArgumentError, "Package is required when a version is specified") if self[:package].nil? && !self[:version].nil?
+
     raise(ArgumentError, "Version is required when an operator is specified") if self[:version].nil? && !self[:operator].nil?
   end
 

lib/puppet/type/entropy_splitdebug_mask.rb

@@ -13,14 +13,12 @@ Puppet::Type.newtype(:entropy_splitdebug_mask) do
 
   newproperty(:package) do
     desc "Name of the package with splitdebug mask"
+    newvalues(%r{^(?:[A-Za-z0-9+_.-]+\/)?[a-zA-Z0-9+_-]+$})
   end
 
   newproperty(:version) do
     desc "Version of the package"
-
+    newvalues(%r{^(\d*(?:\.\d+[a-zA-Z]*)*)(?:_((?:alpha|beta|pre|rc)\d*))?(-r\d+)?$})
-    validate do |value|
-      raise(ArgumentError, "") if value !~ /^(\d*(?:\.\d+[a-zA-Z]*)*)(?:_((?:alpha|beta|pre|rc)\d*))?(-r\d+)?$/
-    end
   end
 
   newproperty(:slot) do
@@ -52,6 +50,8 @@ Puppet::Type.newtype(:entropy_splitdebug_mask) do
   end
 
   validate do
+    raise(ArgumentError, "Package is required when a version is specified") if self[:package].nil? && !self[:version].nil?
+
     raise(ArgumentError, "Version is required when an operator is specified") if self[:version].nil? && !self[:operator].nil?
   end
 

lib/puppet/type/entropy_unmask.rb

@@ -13,14 +13,12 @@ Puppet::Type.newtype(:entropy_unmask) do
 
   newproperty(:package) do
     desc "Name of the package being masked"
+    newvalues(%r{^(?:[A-Za-z0-9+_.-]+\/)?[a-zA-Z0-9+_-]+$})
   end
 
   newproperty(:version) do
     desc "Version of the package"
-
+    newvalues(%r{^(\d*(?:\.\d+[a-zA-Z]*)*)(?:_((?:alpha|beta|pre|rc)\d*))?(-r\d+)?$})
-    validate do |value|
-      raise(ArgumentError, "") if value !~ /^(\d*(?:\.\d+[a-zA-Z]*)*)(?:_((?:alpha|beta|pre|rc)\d*))?(-r\d+)?$/
-    end
   end
 
   newproperty(:slot) do
@@ -52,6 +50,8 @@ Puppet::Type.newtype(:entropy_unmask) do
   end
 
   validate do
+    raise(ArgumentError, "Package is required when a version is specified") if self[:package].nil? && !self[:version].nil?
+
     raise(ArgumentError, "Version is required when an operator is specified") if self[:version].nil? && !self[:operator].nil?
   end
 

metadata.json

@@ -1,20 +1,27 @@
 {
   "name": "optiz0r-sabayon",
-  "version": "0.0.2",
+  "version": "0.2.0",
   "author": "Ben Roberts",
   "license": "MIT",
   "summary": "Extends Puppet with support for the Sabayon Linux distribution",
   "source": "https://github.com/Sabayon/puppet-sabayon.git",
   "project_page": "https://github.com/Sabayon/puppet-sabayon",
   "issues_url": "https://github.com/Sabayon/puppet-sabayon/issues",
-  "tags": ["sabayon", "entropy"],
+  "tags": [
+    "sabayon",
+    "entropy"
+  ],
   "operatingsystem_support": [
     {
-    "operatingsystem":"Sabayon",
+      "operatingsystem": "Sabayon",
-    "operatingsystemrelease":[ "16.07", "16.11" ]
+      "operatingsystemrelease": [
+        "16.07",
+        "16.11"
+      ]
     }
   ],
   "dependencies": [
+
   ],
   "data_provider": "hiera"
 }

spec/unit/provider/entropy_keywords/parsed_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+describe Puppet::Type.type(:entropy_keywords).provider(:parsed) do
+  before do
+    described_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
+    described_class.stubs(:filetype=)
+    @default_target = described_class.default_target
+  end
+
+  describe 'should have a default target of /etc/entropy/packages/package.keywords' do
+    it do
+      expect(described_class.default_target).to eq('/etc/entropy/packages/package.keywords')
+    end
+  end
+
+  describe 'when parsing' do
+    it 'should parse out the name' do
+      line = '** app-admin/foobar ## Puppet Name: foobar'
+      expect(described_class.parse_line(line)[:name]).to eq('foobar')
+    end
+
+    context 'with just a package name' do
+      line = '** app-admin/foobar ## Puppet Name: foobar'
+      parsed = described_class.parse_line(line)
+
+      it 'should parse out the keyword' do
+        expect(parsed[:keyword]).to eq('**')
+      end
+
+      it 'should parse out the package name' do
+        expect(parsed[:package]).to eq('app-admin/foobar')
+      end
+
+      it 'should have all other parameters undefined' do
+        [:operator, :version, :repo].each do |param|
+          expect(parsed[param]).to be_nil
+        end
+      end
+    end
+
+    context 'with a versioned package' do
+      line = '** app-admin/foobar-1.2.3_alpha1-r1 ## Puppet Name: foobar'
+      parsed = described_class.parse_line(line)
+
+      it 'should parse out the keyword' do
+        expect(parsed[:keyword]).to eq('**')
+      end
+
+      it 'should parse out the package name' do
+        expect(parsed[:package]).to eq('app-admin/foobar')
+      end
+
+      it 'should parse out the version' do
+        expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
+      end
+
+      it 'should have all other parameters undefined' do
+        [:operator, :repo].each do |param|
+          expect(parsed[param]).to be_nil
+        end
+      end
+    end
+
+    context 'with a package range' do
+      line = '** >=app-admin/foobar-1.2.3_alpha1-r1 ## Puppet Name: foobar'
+      parsed = described_class.parse_line(line)
+
+      it 'should parse out the keyword' do
+        expect(parsed[:keyword]).to eq('**')
+      end
+
+      it 'should parse out the package name' do
+        expect(parsed[:package]).to eq('app-admin/foobar')
+      end
+
+      it 'should parse out the version' do
+        expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
+      end
+
+      it 'should parse out the operator' do
+        expect(parsed[:operator]).to eq('>=')
+      end
+
+      it 'should have all other parameters undefined' do
+        [:repo].each do |param|
+          expect(parsed[param]).to be_nil
+        end
+      end
+    end
+
+    context 'with a package from a specific repo' do
+      line = '** app-admin/foobar repo=community ## Puppet Name: foobar'
+      parsed = described_class.parse_line(line)
+
+      it 'should parse out the keyword' do
+        expect(parsed[:keyword]).to eq('**')
+      end
+
+      it 'should parse out the package name' do
+        expect(parsed[:package]).to eq('app-admin/foobar')
+      end
+
+      it 'should parse out the repo' do
+        expect(parsed[:repo]).to eq('community')
+      end
+
+      it 'should have all other parameters undefined' do
+        [:operator, :version].each do |param|
+          expect(parsed[param]).to be_nil
+        end
+      end
+    end
+
+    context 'with all packages from a specific repo' do
+      line = 'amd64 repo=community ## Puppet Name: foobar'
+      parsed = described_class.parse_line(line)
+
+      it 'should parse out the keyword' do
+        expect(parsed[:keyword]).to eq('amd64')
+      end
+
+      it 'should parse out the repo' do
+        expect(parsed[:repo]).to eq('community')
+      end
+
+      it 'should have all other parameters undefined' do
+        [:package, :operator, :version].each do |param|
+          expect(parsed[param]).to be_nil
+        end
+      end
+    end
+
+    context 'with everything' do
+      line = '** >=app-admin/foobar-1.2.3a_alpha1-r1 repo=community ## Puppet Name: foobar'
+      parsed = described_class.parse_line(line)
+
+      expected = {
+        :name     => 'foobar',
+        :keyword  => '**',
+        :package  => 'app-admin/foobar',
+        :operator => '>=',
+        :version  => '1.2.3a_alpha1-r1',
+        :repo     => 'community',
+      }
+
+      it 'should parse out all parameters' do
+        expected.each do |param, value|
+          expect(parsed[param]).to eq(value)
+        end
+      end
+    end
+
+  end
+
+  describe 'when flushing' do 
+    before :each do
+      @ramfile = Puppet::Util::FileType::FileTypeRam.new(@default_target)
+      File.stubs(:exist?).with(@default_target).returns(true)
+      described_class.any_instance.stubs(:target_object).returns(@ramfile)
+    end
+
+    after :each do
+      described_class.clear
+    end
+
+    it 'should output a single package entry' do
+      resource = {
+        :record_type => :parsed,
+        :name        => 'test',
+        :keyword     => '**',
+        :package     => 'app-admin/foobar',
+      }
+      expect(described_class.to_line(resource)).to eq ('** app-admin/foobar ## Puppet Name: test')
+    end
+
+    it 'should output a versioned package entry' do
+      resource = {
+        :record_type => :parsed,
+        :name        => 'test',
+        :keyword     => '**',
+        :package     => 'app-admin/foobar',
+        :version     => '1.2.3',
+      }
+      expect(described_class.to_line(resource)).to eq ('** app-admin/foobar-1.2.3 ## Puppet Name: test')
+    end
+
+    it 'should output a ranged versioned package entry' do
+      resource = {
+        :record_type => :parsed,
+        :name        => 'test',
+        :keyword     => '**',
+        :package     => 'app-admin/foobar',
+        :version     => '1.2.3',
+        :operator    => '>=',
+      }
+      expect(described_class.to_line(resource)).to eq ('** >=app-admin/foobar-1.2.3 ## Puppet Name: test')
+    end
+
+    it 'should output a repo-specific package entry' do
+      resource = {
+        :record_type => :parsed,
+        :name        => 'test',
+        :keyword     => '**',
+        :package     => 'app-admin/foobar',
+        :repo        => 'community',
+      }
+      expect(described_class.to_line(resource)).to eq ('** app-admin/foobar repo=community ## Puppet Name: test')
+    end
+
+    it 'should output a whole-repo entry' do
+      resource = {
+        :record_type => :parsed,
+        :name        => 'test',
+        :keyword     => '**',
+        :repo        => 'community',
+      }
+      expect(described_class.to_line(resource)).to eq ('** repo=community ## Puppet Name: test')
+    end
+
+    it 'should output all fields for a package entry' do
+      resource = {
+        :record_type => :parsed,
+        :name        => 'test',
+        :keyword     => '**',
+        :package     => 'app-admin/foobar',
+        :operator    => '>=',
+        :version     => '1.2.3',
+        :repo        => 'community',
+      }
+      expect(described_class.to_line(resource)).to eq ('** >=app-admin/foobar-1.2.3 repo=community ## Puppet Name: test')
+    end
+  end
+end

spec/unit/provider/package_types/parsed_spec.rb

@@ -0,0 +1,304 @@
+require 'spec_helper'
+require 'puppet/type/entropy_mask'
+require 'puppet/type/entropy_unmask'
+require 'puppet/type/entropy_splitdebug'
+require 'puppet/type/entropy_splitdebug_mask'
+
+types = {
+    :entropy_mask            => Puppet::Type::Entropy_mask,
+    :entropy_unmask          => Puppet::Type::Entropy_unmask,
+    :entropy_splitdebug      => Puppet::Type::Entropy_splitdebug,
+    :entropy_splitdebug_mask => Puppet::Type::Entropy_splitdebug_mask,
+}
+
+default_targets = {
+    :entropy_mask            => '/etc/entropy/packages/package.mask',
+    :entropy_unmask          => '/etc/entropy/packages/package.unmask',
+    :entropy_splitdebug      => '/etc/entropy/packages/package.splitdebug',
+    :entropy_splitdebug_mask => '/etc/entropy/packages/package.splitdebug.mask',
+}
+
+types.each do |type_name, type|
+  describe Puppet::Type.type(type_name).provider(:parsed) do
+    before do
+      described_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
+      described_class.stubs(:filetype=)
+      @default_target = described_class.default_target
+    end
+
+    describe "should have a default target of #{default_targets[type_name]}" do
+      it do
+        expect(described_class.default_target).to eq(default_targets[type_name])
+      end
+    end
+
+    describe 'when parsing' do
+      it 'should parse out the name' do
+        line = 'app-admin/foobar ## Puppet Name: foobar'
+        expect(described_class.parse_line(line)[:name]).to eq('foobar')
+      end
+
+      context 'with just a package name' do
+        line = 'app-admin/foobar ## Puppet Name: foobar'
+        parsed = described_class.parse_line(line)
+
+        it 'should parse out the package name' do
+          expect(parsed[:package]).to eq('app-admin/foobar')
+        end
+
+        it 'should have all other parameters undefined' do
+          [:operator, :version, :slot, :use, :tag, :repo].each do |param|
+            expect(parsed[param]).to be_nil
+          end
+        end
+      end
+
+      context 'with a versioned package' do
+        line = 'app-admin/foobar-1.2.3_alpha1-r1 ## Puppet Name: foobar'
+        parsed = described_class.parse_line(line)
+
+        it 'should parse out the package name' do
+          expect(parsed[:package]).to eq('app-admin/foobar')
+        end
+
+        it 'should parse out the version' do
+          expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
+        end
+
+        it 'should have all other parameters undefined' do
+          [:operator, :slot, :use, :tag, :repo].each do |param|
+            expect(parsed[param]).to be_nil
+          end
+        end
+      end
+
+      context 'with a package range' do
+        line = '>=app-admin/foobar-1.2.3_alpha1-r1 ## Puppet Name: foobar'
+        parsed = described_class.parse_line(line)
+
+        it 'should parse out the package name' do
+          expect(parsed[:package]).to eq('app-admin/foobar')
+        end
+
+        it 'should parse out the version' do
+          expect(parsed[:version]).to eq('1.2.3_alpha1-r1')
+        end
+
+        it 'should parse out the operator' do
+          expect(parsed[:operator]).to eq('>=')
+        end
+
+        it 'should have all other parameters undefined' do
+          [:slot, :use, :tag, :repo].each do |param|
+            expect(parsed[param]).to be_nil
+          end
+        end
+      end
+
+      context 'with a slotted package' do
+        line = 'app-admin/foobar:1.1 ## Puppet Name: foobar'
+        parsed = described_class.parse_line(line)
+
+        it 'should parse out the package name' do
+          expect(parsed[:package]).to eq('app-admin/foobar')
+        end
+
+        it 'should parse out the slot' do
+          expect(parsed[:slot]).to eq('1.1')
+        end
+
+        it 'should have all other parameters undefined' do
+          [:operator, :version, :use, :tag, :repo].each do |param|
+            expect(parsed[param]).to be_nil
+          end
+        end
+      end
+
+      context 'with a package with use restrictions' do
+        line = 'app-admin/foobar[-foo,bar] ## Puppet Name: foobar'
+        parsed = described_class.parse_line(line)
+
+        it 'should parse out the package name' do
+          expect(parsed[:package]).to eq('app-admin/foobar')
+        end
+
+        it 'should parse out the use' do
+          expect(parsed[:use]).to eq('-foo,bar')
+        end
+
+        it 'should have all other parameters undefined' do
+          [:operator, :version, :slot, :tag, :repo].each do |param|
+            expect(parsed[param]).to be_nil
+          end
+        end
+      end
+
+      context 'with a tagged package' do
+        line = 'app-admin/foobar#server ## Puppet Name: foobar'
+        parsed = described_class.parse_line(line)
+
+        it 'should parse out the package name' do
+          expect(parsed[:package]).to eq('app-admin/foobar')
+        end
+
+        it 'should parse out the tag' do
+          expect(parsed[:tag]).to eq('server')
+        end
+
+        it 'should have all other parameters undefined' do
+          [:operator, :version, :slot, :use, :repo].each do |param|
+            expect(parsed[param]).to be_nil
+          end
+        end
+      end
+
+      context 'with a package from a specific repo' do
+        line = 'app-admin/foobar::community ## Puppet Name: foobar'
+        parsed = described_class.parse_line(line)
+
+        it 'should parse out the package name' do
+          expect(parsed[:package]).to eq('app-admin/foobar')
+        end
+
+        it 'should parse out the repo' do
+          expect(parsed[:repo]).to eq('community')
+        end
+
+        it 'should have all other parameters undefined' do
+          [:operator, :version, :slot, :use, :tag].each do |param|
+            expect(parsed[param]).to be_nil
+          end
+        end
+      end
+
+      context 'with everything' do
+        line = '>=app-admin/foobar-1.2.3a_alpha1-r1:1[-foo]#server::community ## Puppet Name: foobar'
+        parsed = described_class.parse_line(line)
+
+        expected = {
+          :name     => 'foobar',
+          :operator => '>=',
+          :package  => 'app-admin/foobar',
+          :version  => '1.2.3a_alpha1-r1',
+          :slot     => '1',
+          :use      => '-foo',
+          :tag      => 'server',
+          :repo     => 'community',
+        }
+
+        it 'should parse out all parameters' do
+          expected.each do |param, value|
+            expect(parsed[param]).to eq(value)
+          end
+        end
+      end
+
+    end
+
+    describe 'when flushing' do 
+      before :each do
+        @ramfile = Puppet::Util::FileType::FileTypeRam.new(@default_target)
+        File.stubs(:exist?).with(default_targets[type_name]).returns(true)
+        described_class.any_instance.stubs(:target_object).returns(@ramfile)
+      end
+
+      after :each do
+        described_class.clear
+      end
+
+      it 'should output a single package entry' do
+        resource = {
+          :record_type => :parsed,
+          :name        => 'test',
+          :package     => 'app-admin/foobar',
+        }
+        expect(described_class.to_line(resource)).to eq ('app-admin/foobar ## Puppet Name: test')
+      end
+
+      it 'should output a versioned package entry' do
+        resource = {
+          :record_type => :parsed,
+          :name        => 'test',
+          :package     => 'app-admin/foobar',
+          :version     => '1.2.3',
+        }
+        expect(described_class.to_line(resource)).to eq ('app-admin/foobar-1.2.3 ## Puppet Name: test')
+      end
+
+      it 'should output a ranged versioned package entry' do
+        resource = {
+          :record_type => :parsed,
+          :name        => 'test',
+          :package     => 'app-admin/foobar',
+          :version     => '1.2.3',
+          :operator    => '>=',
+        }
+        expect(described_class.to_line(resource)).to eq ('>=app-admin/foobar-1.2.3 ## Puppet Name: test')
+      end
+
+      it 'should output a use-restricted package entry' do
+        resource = {
+          :record_type => :parsed,
+          :name        => 'test',
+          :package     => 'app-admin/foobar',
+          :use         => '-foo,bar',
+        }
+        expect(described_class.to_line(resource)).to eq ('app-admin/foobar[-foo,bar] ## Puppet Name: test')
+      end
+
+      it 'should output a slotted package entry' do
+        resource = {
+          :record_type => :parsed,
+          :name        => 'test',
+          :package     => 'app-admin/foobar',
+          :slot        => '1.1',
+        }
+        expect(described_class.to_line(resource)).to eq ('app-admin/foobar:1.1 ## Puppet Name: test')
+      end
+
+      it 'should output a tagged package entry' do
+        resource = {
+          :record_type => :parsed,
+          :name        => 'test',
+          :package     => 'app-admin/foobar',
+          :tag         => 'server',
+        }
+        expect(described_class.to_line(resource)).to eq ('app-admin/foobar#server ## Puppet Name: test')
+      end
+
+      it 'should output a repo-specific package entry' do
+        resource = {
+          :record_type => :parsed,
+          :name        => 'test',
+          :package     => 'app-admin/foobar',
+          :repo        => 'community',
+        }
+        expect(described_class.to_line(resource)).to eq ('app-admin/foobar::community ## Puppet Name: test')
+      end
+
+      it 'should output a whole-repo entry' do
+        resource = {
+          :record_type => :parsed,
+          :name        => 'test',
+          :repo        => 'community',
+        }
+        expect(described_class.to_line(resource)).to eq ('::community ## Puppet Name: test')
+      end
+
+      it 'should output all fields for a package entry' do
+        resource = {
+          :record_type => :parsed,
+          :name        => 'test',
+          :package     => 'app-admin/foobar',
+          :operator    => '>=',
+          :version     => '1.2.3',
+          :slot        => '1.1',
+          :use         => '-foo,bar',
+          :tag         => 'server',
+          :repo        => 'community',
+        }
+        expect(described_class.to_line(resource)).to eq ('>=app-admin/foobar-1.2.3:1.1[-foo,bar]#server::community ## Puppet Name: test')
+      end
+    end
+  end
+end

spec/unit/type/enman_repo_spec.rb

@@ -0,0 +1,25 @@
+describe Puppet::Type.type(:enman_repo) do
+  before do
+    @provider = stub 'provider'
+    @provider.stubs(:name).returns(:enman)
+    described_class.stubs(:defaultprovider).returns(@provider)
+  end
+
+  it "should be an instance of Puppet::Type::Enman_repo" do
+    expect(described_class.new(:name => "test")).to be_an_instance_of Puppet::Type::Enman_repo
+  end
+
+  describe "when validating attributes" do
+    params     = [:name]
+
+    params.each do |param|
+      it "should have the #{param} param" do
+        expect(described_class.attrtype(param)).to eq :param
+      end
+    end
+  end
+
+  it "should have name as the namevar" do
+    expect(described_class.key_attributes).to eq [:name]
+  end
+end

spec/unit/type/entropy_keywords_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
+describe Puppet::Type.type(:entropy_keywords) do
-
-describe Puppet::Type.type(:entropy_mask) do
   before do
     @provider = stub 'provider'
     @provider.stubs(:name).returns(:parsed)
@@ -9,13 +7,13 @@ describe Puppet::Type.type(:entropy_mask) do
     described_class.stubs(:defaultprovider).returns(@provider)
   end
 
-  it "should be an instance of Puppet::Type::Entropy_mask" do
+  it "should be an instance of Puppet::Type::Entropy_keywords" do
-    expect(described_class.new(:name => "test", :package => "app-admin/dummy")).to be_an_instance_of Puppet::Type::Entropy_mask
+    expect(described_class.new(:name => "test", :package => "app-admin/dummy")).to be_an_instance_of Puppet::Type::Entropy_keywords
   end
 
   describe "when validating attributes" do
     params     = [:name]
-    properties = [:package, :operator, :version, :slot, :use, :tag, :repo, :target]
+    properties = [:package, :operator, :version, :repo, :target]
 
     params.each do |param|
       it "should have the #{param} param" do
@@ -42,12 +40,6 @@ describe Puppet::Type.type(:entropy_mask) do
   end
 
   describe "when validating required properties" do
-    it "should raise an error when no required attributes are passed" do
-      expect {
-        described_class.new(:name => "test")
-      }.to raise_error(Puppet::Error, /At least one of (.*) is required/)
-    end
-
     it "should raise an error when a version is passed with no package" do
       expect {
         described_class.new(:name => "test", :repo => "test", :version => "1.2.3")
@@ -63,19 +55,17 @@ describe Puppet::Type.type(:entropy_mask) do
 
   describe "when the catalog includes a matching package" do
     it "should have an autobefore relationship" do
-      mask = described_class.new(:name => "test", :package => "app-admin/dummy")
+      resource = described_class.new(:name => "test", :package => "app-admin/dummy")
       package = Puppet::Type.type(:package).new(:title => 'app-admin/dummy')
 
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource package
-      catalog.add_resource mask
+      catalog.add_resource resource
 
-      befores = mask.autobefore
+      befores = resource.autobefore
       expect(befores.size).to eq 1
-      expect(befores[0].source).to eq mask
+      expect(befores[0].source).to eq resource
       expect(befores[0].target).to eq package
     end
   end
 end
-
-# vim: set ts=2 sw=2 expandtab:

spec/unit/type/package_types_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'puppet/type/entropy_mask'
+require 'puppet/type/entropy_unmask'
+require 'puppet/type/entropy_splitdebug'
+require 'puppet/type/entropy_splitdebug_mask'
+
+types = {
+    :entropy_mask            => Puppet::Type::Entropy_mask,
+    :entropy_unmask          => Puppet::Type::Entropy_unmask,
+    :entropy_splitdebug      => Puppet::Type::Entropy_splitdebug,
+    :entropy_splitdebug_mask => Puppet::Type::Entropy_splitdebug_mask,
+}
+
+types.each do |type_name, type|
+  describe Puppet::Type.type(type_name) do
+    before do
+      @provider = stub 'provider'
+      @provider.stubs(:name).returns(:parsed)
+      @provider.stubs(:ancestors).returns([Puppet::Provider::ParsedFile])
+      @provider.stubs(:default_target).returns("defaulttarget")
+      described_class.stubs(:defaultprovider).returns(@provider)
+    end
+
+    it "should be an instance of #{type.class.name}" do
+      expect(described_class.new(:name => "test", :package => "app-admin/dummy")).to be_an_instance_of type
+    end
+
+    describe "when validating attributes" do
+      params     = [:name]
+      properties = [:package, :operator, :version, :slot, :use, :tag, :repo, :target]
+
+      params.each do |param|
+        it "should have the #{param} param" do
+          expect(described_class.attrtype(param)).to eq :param
+        end
+      end
+
+      properties.each do |property|
+        it "should have the #{property} property" do
+          expect(described_class.attrtype(property)).to eq :property
+        end
+      end
+
+    end
+
+    it "should have name as the namevar" do
+      expect(described_class.key_attributes).to eq [:name]
+    end
+
+    describe "when validating the target property" do
+      it "should default to the provider's default target" do
+        expect(described_class.new(:name => "test", :package => "app-admin/dummy").should(:target)).to eq "defaulttarget"
+      end
+    end
+
+    describe "when validating required properties" do
+      packages = [
+        'virtual/package',
+        'package',
+        'package-with-dash',
+        'package_with_underscores',
+        'category-123/package2',
+        'category.with.dots/package'
+      ]
+      packages.each do |package|
+        it "should accept valid package name #{package}" do
+          expect {
+            described_class.new(:name => 'test', :package => package)
+          }.not_to raise_error
+        end
+      end
+
+      packages = [
+        'two/category/package',
+        'invalid-package-1.2',
+        '/no-category-package',
+        'no-package-category/',
+      ]
+      packages.each do |package|
+        it "should reject invalid package name #{package}" do
+          expect {
+            described_class.new(:name => 'test', :package => package)
+          }.to raise_error(Puppet::Error)
+        end
+      end
+
+      it "should raise an error when a version is passed with no package" do
+        expect {
+          described_class.new(:name => "test", :repo => "test", :version => "1.2.3")
+        }.to raise_error(Puppet::Error, /Package is required/)
+      end
+
+      it "should raise an error when an operator is passed with no version" do
+        expect {
+          described_class.new(:name => "test", :package => "app-admin/dummy", :operator => "<=")
+        }.to raise_error(Puppet::Error, /Version is required/)
+      end
+    end
+
+    describe "when the catalog includes a matching package" do
+      it "should have an autobefore relationship" do
+        resource = described_class.new(:name => "test", :package => "app-admin/dummy")
+        package = Puppet::Type.type(:package).new(:title => 'app-admin/dummy')
+
+        catalog = Puppet::Resource::Catalog.new
+        catalog.add_resource package
+        catalog.add_resource resource
+
+        befores = resource.autobefore
+        expect(befores.size).to eq 1
+        expect(befores[0].source).to eq resource
+        expect(befores[0].target).to eq package
+      end
+    end
+  end
+end
+
+# vim: set ts=2 sw=2 expandtab: