Update changelog for release 0.1.1

Previously, the entropy types would require that either package, tag, or repo
were provided, since that makes sense for the entropy files. Having a resource
that could not provide any of these would leave a malformed entry in the files.

I've had to remove that due to a deficiency in Puppet that's taken a long time
to track down. While the validation works fine for resources specified in
manifests, it breaks when parsing the records back in. Here's why:

- The provider instances method is called to retrieve a list of all entries
  in the entropy files. This correctly parses the name and properties into the
  provider instance object
- Puppet's type.rb enumerates through each of these, and tries to create a new
  Type insance using just the name and provider parameters from the provider
  instance. It then intends to iterate through the properties and add them one
  at a time.
  0c2157974a/lib/puppet/type.rb (L1180)
- The problem is that the top-level validation function is called when the
  object is first created, and at this time, none of the properties have been
  set, so the required properties have not been set and validation fails.

The top-level validation block cannot mandate a property be set, only other
types of condition.

.pmtignore

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

CHANGELOG.md

@@ -1,9 +1,16 @@
-## Unreleased
+## 2016-10-13 Release 0.1.1
+
+- 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
 

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 += " "                      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/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.1.1",
   "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",
-    "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: