puppet 6.29.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/integration/util/rdoc/parser_spec.rb

@@ -91,7 +91,7 @@ end
         File.join(modules_dir, 'a_module', 'lib', 'facter', 'a_fact.rb'),
         <<-EOF
 # The a_fact fact comment
-Puppet.runtime[:facter].add("a_fact") do
+Facter.add("a_fact") do
 end
         EOF
       ],

data/spec/integration/util/windows/adsi_spec.rb

@@ -55,24 +55,6 @@ describe Puppet::Util::Windows::ADSI::User,
       end
     end
   end
-
-  describe '.current_user_name_with_format' do
-    context 'when desired format is NameSamCompatible' do
-      it 'should get the same user name as the current_user_name method but fully qualified' do
-        user_name = Puppet::Util::Windows::ADSI::User.current_user_name
-        fully_qualified_user_name = Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name
-
-        expect(fully_qualified_user_name).to match(/^.+\\#{user_name}$/)
-      end
-
-      it 'should have the same SID as with the current_user_name method' do
-        user_name = Puppet::Util::Windows::ADSI::User.current_user_name
-        fully_qualified_user_name = Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name
-
-        expect(Puppet::Util::Windows::SID.name_to_sid(user_name)).to eq(Puppet::Util::Windows::SID.name_to_sid(fully_qualified_user_name))
-      end
-    end
-  end
 end
 
 describe Puppet::Util::Windows::ADSI::Group,
@@ -175,9 +157,7 @@ describe Puppet::Util::Windows::ADSI::Group,
 
       # touch the native_object member to have it lazily loaded, so COM objects can be stubbed
       admins.native_object
-      without_partial_double_verification do
-        allow(admins.native_object).to receive(:Members).and_return(members)
-      end
+      allow(admins.native_object).to receive(:Members).and_return(members)
 
       # well-known NULL SID
       expect(admins.members[0].sid).to eq('S-1-0-0')

data/spec/integration/util/windows/monkey_patches/process_spec.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Process', if: Puppet::Util::Platform.windows? do
+  describe '.create' do
+    context 'with common flags' do
+      it do
+        Process.create(
+          app_name: 'cmd.exe /c echo 123',
+          creation_flags: 0x00000008,
+          process_inherit: false,
+          thread_inherit: false,
+          cwd: 'C:\\'
+        )
+      end
+
+      context 'when FFI call fails' do
+        before do
+          allow(Process).to receive(:CreateProcessW).and_return(false)
+        end
+
+        it 'raises SystemCallError' do
+          expect do
+            Process.create(
+              app_name: 'cmd.exe /c echo 123',
+              creation_flags: 0x00000008
+            )
+          end.to raise_error(SystemCallError)
+        end
+      end
+    end
+
+    context 'with logon' do
+      context 'without password' do
+        it 'raises error' do
+          expect do
+            Process.create(
+              app_name: 'cmd.exe /c echo 123',
+              creation_flags: 0x00000008,
+              with_logon: 'test'
+            )
+          end.to raise_error(ArgumentError, 'password must be specified if with_logon is used')
+        end
+      end
+
+      context 'with common flags' do
+        before do
+          allow(Process).to receive(:CreateProcessWithLogonW).and_return(true)
+        end
+
+        it do
+          Process.create(
+            app_name: 'cmd.exe /c echo 123',
+            creation_flags: 0x00000008,
+            process_inherit: false,
+            thread_inherit: false,
+            with_logon: 'test',
+            password: 'password',
+            cwd: 'C:\\'
+          )
+        end
+
+        context 'when FFI call fails' do
+          before do
+            allow(Process).to receive(:CreateProcessWithLogonW).and_return(false)
+          end
+
+          it 'raises SystemCallError' do
+            expect do
+              Process.create(
+                app_name: 'cmd.exe /c echo 123',
+                creation_flags: 0x00000008,
+                with_logon: 'test',
+                password: 'password'
+              )
+            end.to raise_error(SystemCallError)
+          end
+        end
+      end
+    end
+
+    describe 'validations' do
+      context 'when args is not a hash' do
+        it 'raises TypeError' do
+          expect do
+            Process.create('test')
+          end.to raise_error(TypeError, 'hash keyword arguments expected')
+        end
+      end
+
+      context 'when args key is invalid' do
+        it 'raises ArgumentError' do
+          expect do
+            Process.create(invalid_key: 'test')
+          end.to raise_error(ArgumentError, "invalid key 'invalid_key'")
+        end
+      end
+
+      context 'when startup_info is invalid' do
+        it 'raises ArgumentError' do
+          expect do
+            Process.create(startup_info: { invalid_key: 'test' })
+          end.to raise_error(ArgumentError, "invalid startup_info key 'invalid_key'")
+        end
+      end
+
+      context 'when app_name and command_line are missing' do
+        it 'raises ArgumentError' do
+          expect do
+            Process.create(creation_flags: 0)
+          end.to raise_error(ArgumentError, 'command_line or app_name must be specified')
+        end
+      end
+
+      context 'when executable is not found' do
+        it 'raises Errno::ENOENT' do
+          expect do
+            Process.create(app_name: 'non_existent')
+          end.to raise_error(Errno::ENOENT)
+        end
+      end
+    end
+
+    context 'when environment is not specified' do
+      it 'passes local environment' do
+        stdout_read, stdout_write = IO.pipe
+        ENV['TEST_ENV'] = 'B'
+
+        Process.create(
+          app_name: 'cmd.exe /c echo %TEST_ENV%',
+          creation_flags: 0x00000008,
+          startup_info: { stdout: stdout_write }
+        )
+
+        stdout_write.close
+        expect(stdout_read.read.chomp).to eql('B')
+      end
+    end
+
+    context 'when environment is specified' do
+      it 'does not pass local environment' do
+        stdout_read, stdout_write = IO.pipe
+        ENV['TEST_ENV'] = 'B'
+
+        Process.create(
+          app_name: 'cmd.exe /c echo %TEST_ENV%',
+          creation_flags: 0x00000008,
+          environment: '',
+          startup_info: { stdout: stdout_write }
+        )
+
+        stdout_write.close
+        expect(stdout_read.read.chomp).to eql('%TEST_ENV%')
+      end
+
+      it 'supports :environment as a string' do
+        stdout_read, stdout_write = IO.pipe
+
+        Process.create(
+          app_name: 'cmd.exe /c echo %A% %B%',
+          creation_flags: 0x00000008,
+          environment: 'A=C;B=D',
+          startup_info: { stdout: stdout_write }
+        )
+
+        stdout_write.close
+        expect(stdout_read.read.chomp).to eql('C D')
+      end
+
+      it 'supports :environment as a string' do
+        stdout_read, stdout_write = IO.pipe
+
+        Process.create(
+          app_name: 'cmd.exe /c echo %A% %C%',
+          creation_flags: 0x00000008,
+          environment: ['A=B;X;', 'C=;D;Y'],
+          startup_info: { stdout: stdout_write }
+        )
+
+        stdout_write.close
+        expect(stdout_read.read.chomp).to eql('B;X; ;D;Y')
+      end
+    end
+  end
+
+  describe '.setpriority' do
+    let(:priority) { Process::BELOW_NORMAL_PRIORITY_CLASS }
+
+    context 'when success' do
+      it 'returns 0' do
+        expect(Process.setpriority(0, Process.pid, priority)).to eql(0)
+      end
+
+      it 'treats an int argument of zero as the current process' do
+        expect(Process.setpriority(0, 0, priority)).to eql(0)
+      end
+    end
+
+    context 'when invalid arguments are sent' do
+      it 'raises TypeError' do
+        expect {
+          Process.setpriority('test', 0, priority)
+        }.to raise_error(TypeError)
+      end
+    end
+
+    context 'when process is not found' do
+      before do
+        allow(Process).to receive(:OpenProcess).and_return(0)
+      end
+      it 'raises SystemCallError' do
+        expect {
+          Process.setpriority(0, 0, priority)
+        }.to raise_error(SystemCallError)
+      end
+    end
+
+    context 'when priority is not set' do
+      before do
+        allow(Process).to receive(:SetPriorityClass).and_return(false)
+      end
+
+      it 'raises SystemCallError' do
+        expect {
+          Process.setpriority(0, 0, priority)
+        }.to raise_error(SystemCallError)
+      end
+    end
+  end
+end

data/spec/integration/util/windows/principal_spec.rb

@@ -7,7 +7,6 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet::Util::Platform.wi
   let (:system_bytes) { [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0] }
   let (:null_sid_bytes) { [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }
   let (:administrator_bytes) { [1, 2, 0, 0, 0, 0, 0, 5, 32, 0, 0, 0, 32, 2, 0, 0] }
-  let (:all_application_packages_bytes) { [1, 2, 0, 0, 0, 0, 0, 15, 2, 0, 0, 0, 1, 0, 0, 0] }
   let (:computer_sid) { Puppet::Util::Windows::SID.name_to_principal(Puppet::Util::Windows::ADSI.computer_name) }
   # BUILTIN is localized on German Windows, but not French
   # looking this up like this dilutes the values of the tests as we're comparing two mechanisms
@@ -122,26 +121,6 @@ describe Puppet::Util::Windows::SID::Principal, :if => Puppet::Util::Platform.wi
       expect(principal.to_s).to eq(builtin_localized)
     end
 
-    it "should always sanitize the account name first" do
-      expect(Puppet::Util::Windows::SID::Principal).to receive(:sanitize_account_name).with('NT AUTHORITY\\SYSTEM').and_call_original
-      Puppet::Util::Windows::SID::Principal.lookup_account_name('NT AUTHORITY\\SYSTEM')
-    end
-
-    it "should be able to create an instance from an account name prefixed by APPLICATION PACKAGE AUTHORITY" do
-      principal = Puppet::Util::Windows::SID::Principal.lookup_account_name('APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES')
-      expect(principal.account).to eq('ALL APPLICATION PACKAGES')
-      expect(principal.sid_bytes).to eq(all_application_packages_bytes)
-      expect(principal.sid).to eq('S-1-15-2-1')
-      expect(principal.domain).to eq('APPLICATION PACKAGE AUTHORITY')
-      expect(principal.domain_account).to eq('APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES')
-      expect(principal.account_type).to eq(:SidTypeWellKnownGroup)
-      expect(principal.to_s).to eq('APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES')
-    end
-
-    it "should fail without proper account name sanitization when it is prefixed by APPLICATION PACKAGE AUTHORITY" do
-      given_account_name = 'APPLICATION PACKAGE AUTHORITY\\ALL APPLICATION PACKAGES'
-      expect { Puppet::Util::Windows::SID::Principal.lookup_account_name(nil, false, given_account_name) }.to raise_error(Puppet::Util::Windows::Error, /No mapping between account names and security IDs was done./)
-    end
   end
 
   describe ".lookup_account_sid" do

data/spec/integration/util/windows/process_spec.rb

@@ -1,14 +1,22 @@
 require 'spec_helper'
+require 'facter'
 
 describe "Puppet::Util::Windows::Process", :if => Puppet::Util::Platform.windows?  do
   describe "as an admin" do
-    it "should have the SeCreateSymbolicLinkPrivilege necessary to create symlinks" do
+    it "should have the SeCreateSymbolicLinkPrivilege necessary to create symlinks on Vista / 2008+",
+      :if => Facter.value(:kernelmajversion).to_f >= 6.0 && Puppet::Util::Platform.windows? do
       # this is a bit of a lame duck test since it requires running user to be admin
       # a better integration test would create a new user with the privilege and verify
       expect(Puppet::Util::Windows::User).to be_admin
       expect(Puppet::Util::Windows::Process.process_privilege_symlink?).to be_truthy
     end
 
+    it "should not have the SeCreateSymbolicLinkPrivilege necessary to create symlinks on 2003 and earlier",
+      :if => Facter.value(:kernelmajversion).to_f < 6.0 && Puppet::Util::Platform.windows? do
+      expect(Puppet::Util::Windows::User).to be_admin
+      expect(Puppet::Util::Windows::Process.process_privilege_symlink?).to be_falsey
+    end
+
     it "should be able to lookup a standard Windows process privilege" do
       Puppet::Util::Windows::Process.lookup_privilege_value('SeShutdownPrivilege') do |luid|
         expect(luid).not_to be_nil

data/spec/integration/util/windows/registry_spec.rb

@@ -146,6 +146,16 @@ describe Puppet::Util::Windows::Registry do
         utf_8_bytes = ENDASH_UTF_8 + TM_UTF_8
         utf_8_str = utf_8_bytes.pack('c*').force_encoding(Encoding::UTF_8)
 
+        # this problematic Ruby codepath triggers a conversion of UTF-16LE to
+        # a local codepage which can totally break when that codepage has no
+        # conversion from the given UTF-16LE characters to local codepage
+        # a prime example is that IBM437 has no conversion from a Unicode en-dash
+        expect(Win32::Registry).not_to receive(:export_string)
+
+        # also, expect that we're using our variants of keys / values, not Rubys
+        expect(Win32::Registry).not_to receive(:each_key)
+        expect(Win32::Registry).not_to receive(:each_value)
+
         hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS | regsam) do |reg|
           reg.write("#{guid}", Win32::Registry::REG_SZ, utf_16_str)
 
@@ -263,12 +273,6 @@ describe Puppet::Util::Windows::Registry do
           type: Win32::Registry::REG_EXPAND_SZ,
           value: "\0\0\0reg expand string",
           expected_value: ""
-        },
-        {
-          name: 'REG_EXPAND_SZ_2',
-          type: Win32::Registry::REG_EXPAND_SZ,
-          value: "1\x002\x003\x004\x00\x00\x00\x90\xD8UoY".force_encoding("UTF-16LE"),
-          expected_value: "1234"
         }
       ].each do |pair|
         it 'reads up to the first wide null' do

data/spec/integration/util/windows/security_spec.rb

@@ -822,7 +822,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet::Util::Platform.window
     end
 
     describe "locked files" do
-      let (:explorer) { File.join(Dir::WINDOWS, "explorer.exe") }
+      let (:explorer) { File.join(ENV['SystemRoot'], "explorer.exe") }
 
       it "should get the owner" do
         expect(winsec.get_owner(explorer)).to match(/^S-1-5-/)

data/spec/lib/matchers/include.rb

@@ -0,0 +1,27 @@
+module Matchers; module Include
+  extend RSpec::Matchers::DSL
+
+  matcher :include_in_any_order do |*matchers|
+    match do |enumerable|
+      @not_matched = []
+      expected_as_array.each do |matcher|
+        if enumerable.empty?
+          break
+        end
+
+        if found = enumerable.find { |elem| matcher.matches?(elem) }
+          enumerable = enumerable.reject { |elem| elem == found }
+        else
+          @not_matched << matcher
+        end
+      end
+
+
+      @not_matched.empty? && enumerable.empty?
+    end
+
+    failure_message do |enumerable|
+      "did not match #{@not_matched.collect(&:description).join(', ')} in #{enumerable.inspect}: <#{@not_matched.collect(&:failure_message).join('>, <')}>"
+    end
+  end
+end; end

data/spec/lib/matchers/include_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'matchers/include'
+
+describe "include matchers" do
+  include Matchers::Include
+
+  context :include_in_any_order do
+    it "matches an empty list" do
+      expect([]).to include_in_any_order()
+    end
+
+    it "matches a list with a single element" do
+      expect([1]).to include_in_any_order(eq(1))
+    end
+
+    it "does not match when an expected element is missing" do
+      expect([1]).to_not include_in_any_order(eq(2))
+    end
+
+    it "matches a list with 2 elements in a different order from the expectation" do
+      expect([1, 2]).to include_in_any_order(eq(2), eq(1))
+    end
+
+    it "does not match when there are more than just the expected elements" do
+      expect([1, 2]).to_not include_in_any_order(eq(1))
+    end
+
+    it "matches multiple, equal elements when there are multiple, equal exepectations" do
+      expect([1, 1]).to include_in_any_order(eq(1), eq(1))
+    end
+  end
+end

data/spec/lib/puppet/test_ca.rb

@@ -30,7 +30,7 @@ module Puppet
     end
 
     def create_request(name)
-      key = OpenSSL::PKey::RSA.new(2048)
+      key = OpenSSL::PKey::RSA.new(1024)
       csr = OpenSSL::X509::Request.new
       csr.public_key = key.public_key
       csr.subject = OpenSSL::X509::Name.new([["CN", name]])
@@ -46,11 +46,6 @@ module Puppet
         ext = ef.create_extension(["subjectAltName", opts[:subject_alt_names], false])
         cert.add_extension(ext)
       end
-      if exts = opts[:extensions]
-        exts.each do |e|
-          cert.add_extension(OpenSSL::X509::Extension.new(*e))
-        end
-      end
       cert.sign(issuer_key, @digest)
       { private_key: key, cert: cert }
     end
@@ -132,7 +127,7 @@ module Puppet
       key = if opts[:key_type] == :ec
               key = OpenSSL::PKey::EC.generate('prime256v1')
             else
-              key = OpenSSL::PKey::RSA.new(2048)
+              key = OpenSSL::PKey::RSA.new(1024)
             end
       cert = OpenSSL::X509::Certificate.new
       cert.public_key = if key.is_a?(OpenSSL::PKey::EC)

data/spec/lib/puppet_spec/https.rb

@@ -40,7 +40,7 @@ class PuppetSpec::HTTPSServer
 
     IO.pipe {|stop_pipe_r, stop_pipe_w|
       store = OpenSSL::X509::Store.new
-      Array(@ca_cert).each { |c| store.add_cert(c) }
+      store.add_cert(@ca_cert)
       store.purpose = OpenSSL::X509::PURPOSE_SSL_CLIENT
       ctx = OpenSSL::SSL::SSLContext.new
       ctx.cert_store = store

data/spec/lib/puppet_spec/modules.rb

@@ -36,7 +36,7 @@ module PuppetSpec::Modules
         end
       end
 
-      if (plans = options[:plans])
+      if plans = options[:plans]
         plans_dir = File.join(module_dir, 'plans')
         FileUtils.mkdir_p(plans_dir)
         plans.each do |plan_file|
@@ -48,17 +48,6 @@ module PuppetSpec::Modules
         end
       end
 
-      if (scripts = options[:scripts])
-        scripts_dir = File.join(module_dir, 'scripts')
-        FileUtils.mkdir_p(scripts_dir)
-        scripts.each do |script_file|
-          if script_file.is_a?(String)
-            script_file = { :name => script_file, :content => "" }
-          end
-          File.write(File.join(scripts_dir, script_file[:name]), script_file[:content])
-        end
-      end
-
       (options[:files] || {}).each do |fname, content|
         path = File.join(module_dir, fname)
         FileUtils.mkdir_p(File.dirname(path))
@@ -72,7 +61,7 @@ module PuppetSpec::Modules
       module_dir = File.join(dir, name)
       FileUtils.mkdir_p(module_dir)
 
-      if (metadata = options[:metadata])
+      if metadata = options[:metadata]
         File.open(File.join(module_dir, 'metadata.json'), 'w') do |f|
           f.write(metadata.to_json)
         end

data/spec/lib/puppet_spec/puppetserver.rb

@@ -31,19 +31,6 @@ class PuppetSpec::Puppetserver
     end
   end
 
-  class FileMetadataServlet < WEBrick::HTTPServlet::AbstractServlet
-    def do_GET request, response
-      response['Content-Type'] = 'application/json'
-      response.body = "{\"path\":\"/etc/puppetlabs/code/environments/production/modules\",\"relative_path\":\".\",\"links\":\"follow\",\"owner\":0,\"group\":0,\"mode\":493,\"checksum\":{\"type\":\"ctime\",\"value\":\"{ctime}2020-03-06 20:14:25 UTC\"},\"type\":\"directory\",\"destination\":null}"
-    end
-  end
-
-  class FileContentServlet < WEBrick::HTTPServlet::AbstractServlet
-    def do_GET request, response
-      response.status = 404
-    end
-  end
-
   class ReportServlet < WEBrick::HTTPServlet::AbstractServlet
     def do_PUT request, response
       response['Content-Type'] = 'application/json'
@@ -72,40 +59,6 @@ class PuppetSpec::Puppetserver
     end
   end
 
-  class CertificateServlet < WEBrick::HTTPServlet::AbstractServlet
-    def initialize(server, ca_cert)
-      super(server)
-      @ca_cert = ca_cert
-    end
-
-    def do_GET request, response
-      if request.path =~ %r{/puppet-ca/v1/certificate/ca$}
-        response['Content-Type'] = 'text/plain'
-        response.body = @ca_cert.to_pem
-      else
-        response.status = 404
-      end
-    end
-  end
-
-  class CertificateRevocationListServlet < WEBrick::HTTPServlet::AbstractServlet
-    def initialize(server, crl)
-      super(server)
-      @crl = crl
-    end
-
-    def do_GET request, response
-      response['Content-Type'] = 'text/plain'
-      response.body = @crl.to_pem
-    end
-  end
-
-  class CertificateRequestServlet < WEBrick::HTTPServlet::AbstractServlet
-    def do_PUT request, response
-      response.status = 404
-    end
-  end
-
   def initialize
     @ca_cert = cert_fixture('ca.pem')
     @ca_crl = crl_fixture('crl.pem')
@@ -150,27 +103,22 @@ class PuppetSpec::Puppetserver
   end
 
   def register_mounts(mounts: {})
-    register_mount('/status/v1/simple/master', proc { |req, res|  }, nil)
+    register_mount('/status/v1/simple/server', proc { |req, res|  }, nil)
     register_mount('/puppet/v3/node', mounts[:node], NodeServlet)
     register_mount('/puppet/v3/catalog', mounts[:catalog], CatalogServlet)
-    register_mount('/puppet/v3/file_metadata', mounts[:file_metadata], FileMetadataServlet)
     register_mount('/puppet/v3/file_metadatas', mounts[:file_metadatas], FileMetadatasServlet)
-    register_mount('/puppet/v3/file_content', mounts[:file_content], FileContentServlet)
     register_mount('/puppet/v3/static_file_content', mounts[:static_file_content], StaticFileContentServlet)
     register_mount('/puppet/v3/report', mounts[:report], ReportServlet)
     register_mount('/puppet/v3/file_bucket_file', mounts[:filebucket], FilebucketServlet)
-    register_mount('/puppet-ca/v1/certificate', mounts[:certificate], CertificateServlet, @ca_cert)
-    register_mount('/puppet-ca/v1/certificate_revocation_list', mounts[:certificate_revocation_list], CertificateRevocationListServlet, @ca_crl)
-    register_mount('/puppet-ca/v1/certificate_request', mounts[:certificate_request], CertificateRequestServlet)
   end
 
-  def register_mount(path, user_proc, default_servlet, *args)
+  def register_mount(path, user_proc, default_servlet)
     handler = if user_proc
                 WEBrick::HTTPServlet::ProcHandler.new(user_proc)
               else
                 default_servlet
               end
-    @https.mount(path, handler, *args)
+    @https.mount(path, handler)
   end
 
   def upload_directory

data/spec/lib/puppet_spec/settings.rb

@@ -11,6 +11,7 @@ module PuppetSpec::Settings
     :confdir      => { :type => :directory, :default => "test", :desc => "confdir" },
     :codedir      => { :type => :directory, :default => "test", :desc => "codedir" },
     :vardir       => { :type => :directory, :default => "test", :desc => "vardir" },
+    :publicdir    => { :type => :directory, :default => "test", :desc => "publicdir" },
     :rundir       => { :type => :directory, :default => "test", :desc => "rundir" },
   }.freeze
 
@@ -20,7 +21,6 @@ module PuppetSpec::Settings
   end.freeze
 
   def set_puppet_conf(confdir, settings)
-    FileUtils.mkdir_p(confdir)
     write_file(File.join(confdir, "puppet.conf"), settings)
   end
 

data/spec/shared_behaviours/documentation_on_faces.rb

@@ -176,6 +176,8 @@ shared_examples_for "documentation on faces" do
       subject.license = "foo"
       expect(subject.license).to eq("foo")
     end
+
+    it "should accept symbols to specify existing licenses..."
   end
 
   describe "#copyright" do