puppet_forge 1.0.6 → 2.0.0

data/spec/unit/forge/middleware/symbolify_json_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe PuppetForge::Middleware::SymbolifyJson do
+  let(:basic_array) { [1, "two", 3] }
+  let(:basic_hash) { { "id" => 1, "data" => "x" } }
+  let(:symbolified_hash) { { :id => 1, :data => "x" } }
+  let(:internal_hash) { { :id => 2, :data => basic_hash } }
+
+  let(:hash_with_array) { { "id" => 3, "data" => basic_array } }
+  let(:array_with_hash) { [1, "two", basic_hash] }
+
+  let(:complex_array) { [array_with_hash, hash_with_array] }
+  let(:complex_hash) { { "id" => 4, "data" => [complex_array, basic_array], "more_data" => hash_with_array } }
+  let(:complex_request) { { "id" => 5, "data" => complex_hash } }
+
+  let(:middleware) { described_class.new() }
+
+  context "#process_array" do
+    it "doesn't change an array with no array or hash inside" do
+      processed_array = middleware.process_array(basic_array)
+      expect(processed_array).to eql( [1, "two", 3] )
+    end
+
+    it "changes all keys of a hash inside the array" do
+      processed_array = middleware.process_array(array_with_hash)
+      expect(processed_array).to eql( [ 1, "two", { :id => 1, :data => "x" } ] )
+    end
+  end
+
+  context "#process_hash" do
+    it "changes all keys that respond to :to_sym into Symbols and doesn't change values." do
+      processed_hash = middleware.process_hash(basic_hash)
+      expect(processed_hash).to eql( { :id => 1, :data => "x" } )
+    end
+
+    it "doesn't change keys that don't respond to :to_sym" do
+      processed_hash = middleware.process_hash(basic_hash.merge({ 1 => 2 }))
+      expect(processed_hash).to eql( { :id => 1, :data => "x", 1 => 2 } )
+    end
+
+    it "can process a hash that is already symbolified" do
+      processed_hash = middleware.process_hash(symbolified_hash)
+      expect(processed_hash).to eql( { :id => 1, :data => "x" })
+    end
+
+    it "can process a hash with a hash inside of it" do
+      processed_hash = middleware.process_hash(internal_hash)
+      expect(processed_hash).to eql( {:id => 2, :data => { :id => 1, :data => "x" } })
+    end
+
+    it "can process a hash with an array inside of it" do
+      processed_hash = middleware.process_hash(hash_with_array)
+      expect(processed_hash).to eql( { :id => 3, :data => [1, "two", 3] } ) 
+    end
+
+    it "can handle extensively nested arrays and hashes" do
+      processed_hash = middleware.process_hash(complex_request)
+      expect(processed_hash).to eql( { :id => 5, :data => { :id => 4 , :data=>[ [ [1, "two", { :id => 1, :data => "x" } ], { :id=>3, :data => [1, "two", 3] } ], [1, "two", 3] ], :more_data => { :id => 3, :data => [1, "two", 3] } } } )
+    end
+  end
+
+end
+

data/spec/unit/forge/tar/mini_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe PuppetForge::Tar::Mini do
+  let(:entry_class) do
+    Class.new do
+      attr_accessor :typeflag, :name
+      def initialize(name, typeflag)
+        @name = name
+        @typeflag = typeflag
+      end
+    end
+  end
+  let(:sourcefile) { '/the/module.tar.gz' }
+  let(:destdir)    { File.expand_path '/the/dest/dir' }
+  let(:sourcedir)  { '/the/src/dir' }
+  let(:destfile)   { '/the/dest/file.tar.gz' }
+  let(:minitar)    { described_class.new }
+  let(:tarfile_contents) { [entry_class.new('file', '0'), \
+                            entry_class.new('symlink', '2'), \
+                            entry_class.new('invalid', 'F')] }
+
+  it "unpacks a tar file" do
+    unpacks_the_entry(:file_start, 'thefile')
+
+    minitar.unpack(sourcefile, destdir)
+  end
+
+  it "does not allow an absolute path" do
+    unpacks_the_entry(:file_start, '/thefile')
+
+    expect {
+      minitar.unpack(sourcefile, destdir)
+    }.to raise_error(PuppetForge::InvalidPathInPackageError,
+                     "Attempt to install file into \"/thefile\" under \"#{destdir}\"")
+  end
+
+  it "does not allow a file to be written outside the destination directory" do
+    unpacks_the_entry(:file_start, '../../thefile')
+
+    expect {
+      minitar.unpack(sourcefile, destdir)
+    }.to raise_error(PuppetForge::InvalidPathInPackageError,
+                     "Attempt to install file into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
+  end
+
+  it "does not allow a directory to be written outside the destination directory" do
+    unpacks_the_entry(:dir, '../../thedir')
+
+    expect {
+      minitar.unpack(sourcefile, destdir)
+    }.to raise_error(PuppetForge::InvalidPathInPackageError,
+                     "Attempt to install file into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
+  end
+
+  it "packs a tar file" do
+    writer = double('GzipWriter')
+
+    expect(Zlib::GzipWriter).to receive(:open).with(destfile).and_yield(writer)
+    expect(Archive::Tar::Minitar).to receive(:pack).with(sourcedir, writer)
+
+    minitar.pack(sourcedir, destfile)
+  end
+
+  it "returns filenames in a tar separated into correct categories" do
+    reader = double('GzipReader')
+
+    expect(Zlib::GzipReader).to receive(:open).with(sourcefile).and_yield(reader)
+    expect(Archive::Tar::Minitar).to receive(:open).with(reader).and_return(tarfile_contents)
+    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, ['file']).and_yield(:file_start, 'thefile', nil)
+    
+    file_lists = minitar.unpack(sourcefile, destdir)
+
+    expect(file_lists[:valid]).to eq(['file'])
+    expect(file_lists[:invalid]).to eq(['invalid'])
+    expect(file_lists[:symlinks]).to eq(['symlink'])
+  end
+
+  def unpacks_the_entry(type, name)
+    reader = double('GzipReader')
+
+    expect(Zlib::GzipReader).to receive(:open).with(sourcefile).and_yield(reader)
+    expect(minitar).to receive(:validate_files).with(reader).and_return({:valid => [name]})
+    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name]).and_yield(type, name, nil)
+  end
+end

data/spec/unit/forge/tar_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe PuppetForge::Tar do
+
+  it "returns an instance of minitar" do
+    expect(described_class.instance).to be_a_kind_of PuppetForge::Tar::Mini
+  end
+
+end

data/spec/unit/forge/unpacker_spec.rb

@@ -0,0 +1,58 @@
+require 'tmpdir'
+require 'spec_helper'
+
+describe PuppetForge::Unpacker do
+
+  let(:source)      { Dir.mktmpdir("source") }
+  let(:target)      { Dir.mktmpdir("unpacker") }
+  let(:module_name) { 'myusername-mytarball' }
+  let(:filename)    { Dir.mktmpdir("module") + "/module.tar.gz" }
+  let(:working_dir) { Dir.mktmpdir("working_dir") }
+  let(:trash_dir)   { Dir.mktmpdir("trash_dir") }
+
+  it "attempts to untar file to temporary location" do
+
+    minitar = double('PuppetForge::Tar::Mini')
+
+    expect(minitar).to receive(:unpack).with(filename, anything()) do |src, dest|
+      FileUtils.mkdir(File.join(dest, 'extractedmodule'))
+      File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
+        file.puts JSON.generate('name' => module_name, 'version' => '1.0.0')
+      end
+      true
+    end
+
+    expect(PuppetForge::Tar).to receive(:instance).and_return(minitar)
+    PuppetForge::Unpacker.unpack(filename, target, trash_dir)
+    expect(File).to be_directory(target)
+  end
+
+  it "returns the appropriate categories of the contents of the tar file from the tar implementation" do
+
+    minitar = double('PuppetForge::Tar::Mini')
+
+    expect(minitar).to receive(:unpack).with(filename, anything()) do |src, dest|
+      FileUtils.mkdir(File.join(dest, 'extractedmodule'))
+      File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
+        file.puts JSON.generate('name' => module_name, 'version' => '1.0.0')
+      end
+      { :valid => [File.join('extractedmodule', 'metadata.json')], :invalid => [], :symlinks => [] }
+    end
+
+    expect(PuppetForge::Tar).to receive(:instance).and_return(minitar)
+    file_lists = PuppetForge::Unpacker.unpack(filename, target, trash_dir)
+    expect(file_lists).to eq({:valid=>["extractedmodule/metadata.json"], :invalid=>[], :symlinks=>[]})
+    expect(File).to be_directory(target)
+  end
+
+  it "attempts to set the ownership of a target dir to a source dir's owner" do
+
+    source_path = Pathname.new(source)
+    target_path = Pathname.new(target)
+
+    expect(FileUtils).to receive(:chown_R).with(source_path.stat.uid, source_path.stat.gid, target_path)
+
+    PuppetForge::Unpacker.harmonize_ownership(source_path, target_path)
+  end
+
+end

data/spec/unit/forge/v3/base/paginated_collection_spec.rb

@@ -2,53 +2,65 @@ require 'spec_helper'
 
 describe PuppetForge::V3::Base::PaginatedCollection do
   let(:klass) do
-    Class.new do
-      def self.get_collection(url)
-        data = {
-          '/v3/collection'        => [ :A, :B, :C ],
-          '/v3/collection?page=2' => [ :D, :E, :F ],
-          '/v3/collection?page=3' => [ :G, :H ],
-        }
-
-        meta = {
-          '/v3/collection' => {
-            :limit    => 3,
-            :offset   => 0,
-            :first    => '/v3/collection',
-            :previous => nil,
-            :current  => '/v3/collection',
-            :next     => '/v3/collection?page=2',
-            :total    => 8,
-          },
-          '/v3/collection?page=2' => {
-            :limit    => 3,
-            :offset   => 0,
-            :first    => '/v3/collection',
-            :previous => '/v3/collection',
-            :current  => '/v3/collection?page=2',
-            :next     => '/v3/collection?page=3',
-            :total    => 8,
-          },
-          '/v3/collection?page=3' => {
-            :limit    => 3,
-            :offset   => 0,
-            :first    => '/v3/collection',
-            :previous => '/v3/collection?page=2',
-            :current  => '/v3/collection?page=3',
-            :next     => nil,
-            :total    => 8,
-          },
-        }
-
-        PuppetForge::V3::Base::PaginatedCollection.new(self, data[url], meta[url], {})
-      end
+    allow(PuppetForge::V3::Base).to receive(:get_collection) do |url|
+      data = {
+        '/v3/collection'        => [ { :data => :A }, { :data => :B }, { :data => :C } ],
+        '/v3/collection?page=2' => [ { :data => :D }, { :data => :E }, { :data => :F } ],
+        '/v3/collection?page=3' => [ { :data => :G }, { :data => :H } ],
+      }
+
+      meta = {
+        '/v3/collection' => {
+          :limit    => 3,
+          :offset   => 0,
+          :first    => '/v3/collection',
+          :previous => nil,
+          :current  => '/v3/collection',
+          :next     => '/v3/collection?page=2',
+          :total    => 8,
+        },
+        '/v3/collection?page=2' => {
+          :limit    => 3,
+          :offset   => 0,
+          :first    => '/v3/collection',
+          :previous => '/v3/collection',
+          :current  => '/v3/collection?page=2',
+          :next     => '/v3/collection?page=3',
+          :total    => 8,
+        },
+        '/v3/collection?page=3' => {
+          :limit    => 3,
+          :offset   => 0,
+          :first    => '/v3/collection',
+          :previous => '/v3/collection?page=2',
+          :current  => '/v3/collection?page=3',
+          :next     => nil,
+          :total    => 8,
+        },
+      }
+
+      PuppetForge::V3::Base::PaginatedCollection.new(PuppetForge::V3::Base, data[url], meta[url], {})
     end
+
+    PuppetForge::V3::Base
   end
 
   subject { klass.get_collection('/v3/collection') }
 
+  def collect_data(paginated)
+    paginated.to_a.collect do |x|
+      x.data
+    end
+  end
+
+  it '#all returns self for backwards compatibility.' do
+    paginated = subject.all
+
+    expect(paginated).to eq(subject)
+  end
+
   it 'maps to a single page of the collection' do
-    expect(subject.to_a).to eql([ :A, :B, :C ])
+    expect(collect_data(subject)).to eql([ :A, :B, :C ])
   end
 
   it 'knows the size of the entire collection' do
@@ -61,12 +73,12 @@ describe PuppetForge::V3::Base::PaginatedCollection do
 
   it 'enables page navigation' do
     expect(subject.next).to_not be_empty
-    expect(subject.next.to_a).to_not eql(subject.to_a)
-    expect(subject.next.previous.to_a).to eql(subject.to_a)
+    expect(collect_data(subject.next)).to_not eql(collect_data(subject))
+    expect(collect_data(subject.next.previous)).to eql(collect_data(subject))
   end
 
   it 'exposes the pagination metadata' do
-    expect(subject.metadata[:limit]).to be subject.size
+    expect(subject.limit).to be subject.size
   end
 
   it 'exposes previous_url and next_url' do
@@ -77,12 +89,22 @@ describe PuppetForge::V3::Base::PaginatedCollection do
   describe '#unpaginated' do
     it 'provides an iterator over the entire collection' do
       expected = [ :A, :B, :C, :D, :E, :F, :G, :H ]
-      expect(subject.unpaginated.to_a).to eql(expected)
+      actual = subject.unpaginated.to_a.collect do |x|
+        expect(x).to be_a(klass)
+        x.data
+      end
+
+      expect(actual).to eql(expected)
     end
 
     it "provides a full iterator regardless of which page it's started on" do
       expected = [ :A, :B, :C, :D, :E, :F, :G, :H ]
-      expect(subject.next.next.unpaginated.to_a).to eql(expected)
+
+      actual = subject.next.next.unpaginated.to_a.collect do |x|
+        expect(x).to be_a(klass)
+        x.data
+      end
+      expect(actual).to eql(expected)
     end
   end
 end

data/spec/unit/forge/v3/base_spec.rb

@@ -13,7 +13,7 @@ describe PuppetForge::V3::Base do
 
       collection = PuppetForge::V3::Base.new_collection(response_data)
 
-      expect(collection.limit).to eq(10)
+      expect(collection.limit).to eq(20)
       expect(collection.offset).to eq(0)
       expect(collection.total).to eq(0)
     end

data/spec/unit/forge/v3/metadata_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+
+describe PuppetForge::Metadata do
+  let(:data) { {} }
+  let(:metadata) { PuppetForge::Metadata.new }
+
+  describe 'property lookups' do
+    subject { metadata }
+
+    %w[ name version author summary license source project_page issues_url
+    dependencies dashed_name release_name description ].each do |prop|
+      describe "##{prop}" do
+        it "responds to the property" do
+          subject.send(prop)
+        end
+      end
+    end
+  end
+
+  describe "#update" do
+    subject { metadata.update(data) }
+
+    context "with a valid name" do
+      let(:data) { { 'name' => 'billgates-mymodule' } }
+
+      it "extracts the author name from the name field" do
+        expect(subject.to_hash['author']).to eq('billgates')
+      end
+
+      it "extracts a module name from the name field" do
+        expect(subject.module_name).to eq('mymodule')
+      end
+
+      context "and existing author" do
+        before { metadata.update('author' => 'foo') }
+
+        it "avoids overwriting the existing author" do
+          expect(subject.to_hash['author']).to eq('foo')
+        end
+      end
+    end
+
+    context "with a valid name and author" do
+      let(:data) { { 'name' => 'billgates-mymodule', 'author' => 'foo' } }
+
+      it "use the author name from the author field" do
+        expect(subject.to_hash['author']).to eq('foo')
+      end
+
+      context "and preexisting author" do
+        before { metadata.update('author' => 'bar') }
+
+        it "avoids overwriting the existing author" do
+          expect(subject.to_hash['author']).to eq('foo')
+        end
+      end
+    end
+
+    context "with an invalid name" do
+      context "(short module name)" do
+        let(:data) { { 'name' => 'mymodule' } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
+        end
+      end
+
+      context "(missing namespace)" do
+        let(:data) { { 'name' => '/mymodule' } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
+        end
+      end
+
+      context "(missing module name)" do
+        let(:data) { { 'name' => 'namespace/' } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
+        end
+      end
+
+      context "(invalid namespace)" do
+        let(:data) { { 'name' => "dolla'bill$-mymodule" } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the namespace contains non-alphanumeric characters")
+        end
+      end
+
+      context "(non-alphanumeric module name)" do
+        let(:data) { { 'name' => "dollabils-fivedolla'" } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the module name contains non-alphanumeric (or underscore) characters")
+        end
+      end
+
+      context "(module name starts with a number)" do
+        let(:data) { { 'name' => "dollabills-5dollars" } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the module name must begin with a letter")
+        end
+      end
+    end
+
+
+    context "with an invalid version" do
+      let(:data) { { 'version' => '3.0' } }
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError, "Invalid 'version' field in metadata.json: version string cannot be parsed as a valid Semantic Version")
+      end
+    end
+
+    context "with a valid source" do
+      context "which is a GitHub URL" do
+        context "with a scheme" do
+          before { metadata.update('source' => 'https://github.com/billgates/amazingness') }
+
+          it "predicts a default project_page" do
+            expect(subject.to_hash['project_page']).to eq('https://github.com/billgates/amazingness')
+          end
+
+          it "predicts a default issues_url" do
+            expect(subject.to_hash['issues_url']).to eq('https://github.com/billgates/amazingness/issues')
+          end
+        end
+
+        context "without a scheme" do
+          before { metadata.update('source' => 'github.com/billgates/amazingness') }
+
+          it "predicts a default project_page" do
+            expect(subject.to_hash['project_page']).to eq('https://github.com/billgates/amazingness')
+          end
+
+          it "predicts a default issues_url" do
+            expect(subject.to_hash['issues_url']).to eq('https://github.com/billgates/amazingness/issues')
+          end
+        end
+      end
+
+      context "which is not a GitHub URL" do
+        before { metadata.update('source' => 'https://notgithub.com/billgates/amazingness') }
+
+        it "does not predict a default project_page" do
+          expect(subject.to_hash['project_page']).to be nil
+        end
+
+        it "does not predict a default issues_url" do
+          expect(subject.to_hash['issues_url']).to be nil
+        end
+      end
+
+      context "which is not a URL" do
+        before { metadata.update('source' => 'my brain') }
+
+        it "does not predict a default project_page" do
+          expect(subject.to_hash['project_page']).to be nil
+        end
+
+        it "does not predict a default issues_url" do
+          expect(subject.to_hash['issues_url']).to be nil
+        end
+      end
+
+    end
+
+    context "with a valid dependency", :pending => "dependency resolution is not yet in scope" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-goodmodule'}] }}
+
+      it "adds the dependency" do
+        expect(subject.dependencies.size).to eq(1)
+      end
+    end
+
+    context "with a invalid dependency name" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabsbadmodule'}] }}
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with a valid dependency version range", :pending => "dependency resolution is not yet in scope" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-badmodule', 'version_requirement' => '>= 2.0.0'}] }}
+
+      it "adds the dependency" do
+        expect(subject.dependencies.size).to eq(1)
+      end
+    end
+
+    context "with a invalid version range" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabsbadmodule', 'version_requirement' => '>= banana'}] }}
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with duplicate dependencies", :pending => "dependency resolution is not yet in scope" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-dupmodule', 'version_requirement' => '1.0.0'},
+        {'name' => 'puppetlabs-dupmodule', 'version_requirement' => '0.0.1'}] }
+      }
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "adding a duplicate dependency", :pending => "dependency resolution is not yet in scope" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-origmodule', 'version_requirement' => '1.0.0'}] }}
+
+      it "with a different version raises an exception" do
+        metadata.add_dependency('puppetlabs-origmodule', '>= 0.0.1')
+        expect { subject }.to raise_error(ArgumentError)
+      end
+
+      it "with the same version does not add another dependency" do
+        metadata.add_dependency('puppetlabs-origmodule', '1.0.0')
+        expect(subject.dependencies.size).to eq(1)
+      end
+    end
+  end
+
+  describe '#dashed_name' do
+    it 'returns nil in the absence of a module name' do
+      expect(metadata.update('version' => '1.0.0').release_name).to be_nil
+    end
+
+    it 'returns a hyphenated string containing namespace and module name' do
+      data = metadata.update('name' => 'foo-bar')
+      expect(data.dashed_name).to eq('foo-bar')
+    end
+
+    it 'properly handles slash-separated names' do
+      data = metadata.update('name' => 'foo/bar')
+      expect(data.dashed_name).to eq('foo-bar')
+    end
+
+    it 'is unaffected by author name' do
+      data = metadata.update('name' => 'foo/bar', 'author' => 'me')
+      expect(data.dashed_name).to eq('foo-bar')
+    end
+  end
+
+  describe '#release_name' do
+    it 'returns nil in the absence of a module name' do
+      expect(metadata.update('version' => '1.0.0').release_name).to be_nil
+    end
+
+    it 'returns nil in the absence of a version' do
+      expect(metadata.update('name' => 'foo/bar').release_name).to be_nil
+    end
+
+    it 'returns a hyphenated string containing module name and version' do
+      data = metadata.update('name' => 'foo/bar', 'version' => '1.0.0')
+      expect(data.release_name).to eq('foo-bar-1.0.0')
+    end
+
+    it 'is unaffected by author name' do
+      data = metadata.update('name' => 'foo/bar', 'version' => '1.0.0', 'author' => 'me')
+      expect(data.release_name).to eq('foo-bar-1.0.0')
+    end
+  end
+
+  describe "#to_hash" do
+    subject { metadata.to_hash }
+
+    it "contains the default set of keys" do
+      expect(subject.keys.sort).to eq(%w[ name version author summary license source issues_url project_page dependencies ].sort)
+    end
+
+    describe "['license']" do
+      it "defaults to Apache 2" do
+        expect(subject['license']).to eq("Apache-2.0")
+      end
+    end
+
+    describe "['dependencies']" do
+      it "defaults to an empty set" do
+        expect(subject['dependencies']).to eq(Set.new)
+      end
+    end
+
+    context "when updated with non-default data" do
+      subject { metadata.update('license' => 'MIT', 'non-standard' => 'yup').to_hash }
+
+      it "overrides the defaults" do
+        expect(subject['license']).to eq('MIT')
+      end
+
+      it 'contains unanticipated values' do
+        expect(subject['non-standard']).to eq('yup')
+      end
+    end
+  end
+end