puppet 4.4.0 → 4.5.0

data/spec/unit/pops/types/p_sem_ver_type_spec.rb

@@ -0,0 +1,285 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Types
+describe 'Semantic Versions' do
+  include PuppetSpec::Compiler
+
+  context 'the SemVer type' do
+    it 'is normalized in a Variant' do
+      t = TypeFactory.variant(TypeFactory.sem_ver('>=1.0.0 <2.0.0'), TypeFactory.sem_ver('>=1.5.0 <4.0.0')).normalize
+      expect(t).to be_a(PSemVerType)
+      expect(t).to eql(TypeFactory.sem_ver('>=1.0.0 <4.0.0'))
+    end
+  end
+
+  context 'when used in Puppet expressions' do
+
+    context 'the SemVer type' do
+      it 'can have multiple range arguments' do
+        code = <<-CODE
+          $t = SemVer[SemVerRange('>=1.0.0 <2.0.0'), SemVerRange('>=3.0.0 <4.0.0')]
+          notice(SemVer('1.2.3') =~ $t)
+          notice(SemVer('2.3.4') =~ $t)
+          notice(SemVer('3.4.5') =~ $t)
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true', 'false', 'true'])
+      end
+
+      it 'can have multiple range arguments in string form' do
+        code = <<-CODE
+          $t = SemVer['>=1.0.0 <2.0.0', '>=3.0.0 <4.0.0']
+          notice(SemVer('1.2.3') =~ $t)
+          notice(SemVer('2.3.4') =~ $t)
+          notice(SemVer('3.4.5') =~ $t)
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true', 'false', 'true'])
+      end
+
+      it 'range arguments are normalized' do
+        code = <<-CODE
+          notice(SemVer['>=1.0.0 <2.0.0', '>=1.5.0 <4.0.0'] == SemVer['>=1.0.0 <4.0.0'])
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true'])
+      end
+
+      it 'is assignable to a type containing ranges with a merged range that is assignable but individual ranges are not' do
+        code = <<-CODE
+          $x = SemVer['>=1.0.0 <2.0.0', '>=1.5.0 <3.0.0']
+          $y = SemVer['>=1.2.0 <2.8.0']
+          notice($y < $x)
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true'])
+     end
+    end
+
+    context 'the SemVerRange type' do
+      it 'a range is an instance of the type' do
+        code = <<-CODE
+          notice(SemVerRange('3.0.0 - 4.0.0') =~ SemVerRange)
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true'])
+      end
+    end
+
+    context 'a SemVer instance' do
+      it 'can be created from a String' do
+        code = <<-CODE
+          $x = SemVer('1.2.3')
+          notice(assert_type(SemVer, $x))
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['1.2.3'])
+      end
+
+      it 'can be compared to another instance for equality' do
+        code = <<-CODE
+          $x = SemVer('1.2.3')
+          $y = SemVer('1.2.3')
+          notice($x == $y)
+          notice($x != $y)
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true', 'false'])
+      end
+
+      it 'can be compared to another instance for magnitude' do
+        code = <<-CODE
+          $x = SemVer('1.1.1')
+          $y = SemVer('1.2.3')
+          notice($x < $y)
+          notice($x <= $y)
+          notice($x > $y)
+          notice($x >= $y)
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true', 'true', 'false', 'false'])
+      end
+
+      it 'can be matched against a version range' do
+        code = <<-CODE
+          $v = SemVer('1.1.1')
+          notice($v =~ SemVerRange('>1.0.0'))
+          notice($v =~ SemVerRange('>1.1.1'))
+          notice($v =~ SemVerRange('>=1.1.1'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true', 'false', 'true'])
+      end
+
+      it 'can be matched against a SemVerRange in case expression' do
+        code = <<-CODE
+          case SemVer('1.1.1') {
+            SemVerRange('>1.1.1'): {
+              notice('high')
+            }
+            SemVerRange('>1.0.0'): {
+              notice('mid')
+            }
+            default: {
+              notice('low')
+            }
+          }
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['mid'])
+      end
+
+      it 'can be matched against a SemVer in case expression' do
+        code = <<-CODE
+          case SemVer('1.1.1') {
+            SemVer('1.1.0'): {
+              notice('high')
+            }
+            SemVer('1.1.1'): {
+              notice('mid')
+            }
+            default: {
+              notice('low')
+            }
+          }
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['mid'])
+      end
+
+      it "can be matched against a versions in 'in' expression" do
+        code = <<-CODE
+          notice(SemVer('1.1.1') in [SemVer('1.0.0'), SemVer('1.1.1'), SemVer('2.3.4')])
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true'])
+      end
+
+      it "can be matched against a VersionRange using an 'in' expression" do
+        code = <<-CODE
+          notice(SemVer('1.1.1') in SemVerRange('>1.0.0'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true'])
+      end
+
+      it "can be matched against multiple VersionRanges using an 'in' expression" do
+        code = <<-CODE
+          notice(SemVer('1.1.1') in [SemVerRange('>=1.0.0 <1.0.2'), SemVerRange('>=1.1.0 <1.1.2')])
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true'])
+      end
+    end
+
+    context 'a String representing a SemVer' do
+      it 'can be matched against a version range' do
+        code = <<-CODE
+          $v = '1.1.1'
+          notice($v =~ SemVerRange('>1.0.0'))
+          notice($v =~ SemVerRange('>1.1.1'))
+          notice($v =~ SemVerRange('>=1.1.1'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true', 'false', 'true'])
+      end
+
+      it 'can be matched against a SemVerRange in case expression' do
+        code = <<-CODE
+          case '1.1.1' {
+            SemVerRange('>1.1.1'): {
+              notice('high')
+            }
+            SemVerRange('>1.0.0'): {
+              notice('mid')
+            }
+            default: {
+              notice('low')
+            }
+          }
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['mid'])
+      end
+
+      it 'can be matched against a SemVer in case expression' do
+        code = <<-CODE
+          case '1.1.1' {
+            SemVer('1.1.0'): {
+              notice('high')
+            }
+            SemVer('1.1.1'): {
+              notice('mid')
+            }
+            default: {
+              notice('low')
+            }
+          }
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['mid'])
+      end
+
+      it "can be matched against a VersionRange using an 'in' expression" do
+        code = <<-CODE
+          notice('1.1.1' in SemVerRange('>1.0.0'))
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true'])
+      end
+
+      it "can be matched against multiple VersionRanges using an 'in' expression" do
+        code = <<-CODE
+          notice('1.1.1' in [SemVerRange('>=1.0.0 <1.0.2'), SemVerRange('>=1.1.0 <1.1.2')])
+        CODE
+        expect(eval_and_collect_notices(code)).to eql(['true'])
+      end
+    end
+
+    context 'matching SemVer' do
+      suitability = {
+        [ '1.2.3',         '1.2.2' ] => false,
+        [ '>=1.2.3',       '1.2.2' ] => false,
+        [ '<=1.2.3',       '1.2.2' ] => true,
+        [ '1.2.3 - 1.2.4', '1.2.2' ] => false,
+        [ '~1.2.3',        '1.2.2' ] => false,
+        [ '~1.2',          '1.2.2' ] => true,
+        [ '~1',            '1.2.2' ] => true,
+        [ '1.2.x',         '1.2.2' ] => true,
+        [ '1.x',           '1.2.2' ] => true,
+
+        [ '1.2.3',         '1.2.3-alpha' ] => true,
+        [ '>=1.2.3',       '1.2.3-alpha' ] => true,
+        [ '<=1.2.3',       '1.2.3-alpha' ] => true,
+        [ '>1.2.3',        '1.2.3-alpha' ] => false,
+        [ '<1.2.3',        '1.2.3-alpha' ] => false,
+        [ '1.2.3 - 1.2.4', '1.2.3-alpha' ] => true,
+        [ '1.2.3 - 1.2.4', '1.2.4-alpha' ] => true,
+        [ '1.2.3 - 1.2.4', '1.2.5-alpha' ] => false,
+        [ '~1.2.3',        '1.2.3-alpha' ] => true,
+        [ '~1.2.3',        '1.3.0-alpha' ] => false,
+        [ '~1.2',          '1.2.3-alpha' ] => true,
+        [ '~1.2',          '2.0.0-alpha' ] => false,
+        [ '~1',            '1.2.3-alpha' ] => true,
+        [ '~1',            '2.0.0-alpha' ] => false,
+        [ '1.2.x',         '1.2.3-alpha' ] => true,
+        [ '1.2.x',         '1.3.0-alpha' ] => false,
+        [ '1.x',           '1.2.3-alpha' ] => true,
+        [ '1.x',           '2.0.0-alpha' ] => false,
+
+        [ '1.2.3',         '1.2.3' ] => true,
+        [ '>=1.2.3',       '1.2.3' ] => true,
+        [ '<=1.2.3',       '1.2.3' ] => true,
+        [ '1.2.3 - 1.2.4', '1.2.3' ] => true,
+        [ '~1.2.3',        '1.2.3' ] => true,
+        [ '~1.2',          '1.2.3' ] => true,
+        [ '~1',            '1.2.3' ] => true,
+        [ '1.2.x',         '1.2.3' ] => true,
+        [ '1.x',           '1.2.3' ] => true,
+
+        [ '1.2.3',         '1.2.4' ] => false,
+        [ '>=1.2.3',       '1.2.4' ] => true,
+        [ '<=1.2.3',       '1.2.4' ] => false,
+        [ '1.2.3 - 1.2.4', '1.2.4' ] => true,
+#        [ '~1.2.3',        '1.2.4' ] => true, Awaits fix for PUP-6242
+        [ '~1.2',          '1.2.4' ] => true,
+        [ '~1',            '1.2.4' ] => true,
+        [ '1.2.x',         '1.2.4' ] => true,
+        [ '1.x',           '1.2.4' ] => true,
+      }
+      suitability.each do |arguments, expected|
+        it "'#{arguments[1]}' against SemVerRange '#{arguments[0]}', yields #{expected}" do
+          code = "notice(SemVer('#{arguments[1]}') =~ SemVerRange('#{arguments[0]}'))"
+          expect(eval_and_collect_notices(code)).to eql([expected.to_s])
+        end
+      end
+    end
+  end
+end
+end
+end

data/spec/unit/pops/types/recursion_guard_spec.rb

@@ -1,34 +1,35 @@
 require 'spec_helper'
 require 'puppet/pops/types/recursion_guard'
 
-describe 'the Puppet::Pops::Types::RecursionGuard' do
-  let(:guard) { Puppet::Pops::Types::RecursionGuard.new }
+module Puppet::Pops::Types
+describe 'the RecursionGuard' do
+  let(:guard) { RecursionGuard.new }
 
   it "should detect recursion in 'this' context" do
     x = Object.new
-    expect(guard.add_this(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
-    expect(guard.add_this(x)).to eq(Puppet::Pops::Types::RecursionGuard::SELF_RECURSION_IN_THIS)
+    expect(guard.add_this(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_this(x)).to eq(RecursionGuard::SELF_RECURSION_IN_THIS)
   end
 
   it "should detect recursion in 'that' context" do
     x = Object.new
-    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
-    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::SELF_RECURSION_IN_THAT)
+    expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(x)).to eq(RecursionGuard::SELF_RECURSION_IN_THAT)
   end
 
   it "should keep 'this' and 'that' context separate" do
     x = Object.new
-    expect(guard.add_this(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
-    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_this(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should detect when there's a recursion in both 'this' and 'that' context" do
     x = Object.new
     y = Object.new
-    expect(guard.add_this(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
-    expect(guard.add_that(y)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
-    expect(guard.add_this(x)).to eq(Puppet::Pops::Types::RecursionGuard::SELF_RECURSION_IN_THIS)
-    expect(guard.add_that(y)).to eq(Puppet::Pops::Types::RecursionGuard::SELF_RECURSION_IN_BOTH)
+    expect(guard.add_this(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(y)).to eq(RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_this(x)).to eq(RecursionGuard::SELF_RECURSION_IN_THIS)
+    expect(guard.add_that(y)).to eq(RecursionGuard::SELF_RECURSION_IN_BOTH)
   end
 
   it "should report that 'this' is recursive after a recursion has been detected" do
@@ -62,30 +63,31 @@ describe 'the Puppet::Pops::Types::RecursionGuard' do
   it "should not call 'hash' on an added instance" do
     x = mock
     x.expects(:hash).never
-    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call '==' on an added instance" do
     x = mock
     x.expects(:==).never
-    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call 'eq?' on an added instance" do
     x = mock
     x.expects(:eq?).never
-    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call 'eql?' on an added instance" do
     x = mock
     x.expects(:eql?).never
-    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 
   it "should not call 'equal?' on an added instance" do
     x = mock
     x.expects(:equal?).never
-    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(x)).to eq(RecursionGuard::NO_SELF_RECURSION)
   end
 end
+end

data/spec/unit/pops/types/ruby_generator_spec.rb

@@ -0,0 +1,261 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+require 'puppet/pops/types/ruby_generator'
+
+def root_binding
+  return binding
+end
+
+module Puppet::Pops
+module Types
+describe 'Puppet Ruby Generator' do
+  include PuppetSpec::Compiler
+
+  def source
+    <<-CODE
+    type MyModule::FirstGenerated = Object[{
+      attributes => {
+        name => String,
+        age  => { type => Integer, value => 30 },
+        what => { type => String, value => 'what is this', kind => constant }
+      }
+    }]
+    type MyModule::SecondGenerated = Object[{
+      parent => MyModule::FirstGenerated,
+      attributes => {
+        address => String,
+        zipcode => String,
+        email => String,
+        another => { type => Optional[MyModule::FirstGenerated], value => undef },
+        number => Integer
+      }
+    }]
+    CODE
+  end
+
+  let!(:parser) { TypeParser.new }
+  let(:generator) { RubyGenerator.new }
+
+  context 'when generating anonymous classes' do
+
+    scope = nil
+
+    let(:first_type) { parser.parse('MyModule::FirstGenerated', scope) }
+    let(:second_type) { parser.parse('MyModule::SecondGenerated', scope) }
+    let(:first) { generator.create_class(first_type) }
+    let(:second) { generator.create_class(second_type) }
+
+    before(:each) do
+      eval_and_collect_notices(source) do |topscope, catalog|
+        scope = topscope
+      end
+    end
+
+    after(:each) { typeset = nil }
+
+    context 'the generated class' do
+      it 'inherits the PuppetObject module' do
+        expect(first < PuppetObject).to be_truthy
+      end
+
+      it 'is the superclass of a generated subclass' do
+        expect(second < first).to be_truthy
+      end
+    end
+
+    context 'the #create class method' do
+      it 'has an arity that reflects optional arguments' do
+        expect(first.method(:create).arity).to eql(-2)
+        expect(second.method(:create).arity).to eql(-6)
+      end
+
+      it 'creates an instance of the class' do
+        inst = first.create('Bob Builder', 52)
+        expect(inst).to be_a(first)
+        expect(inst.name).to eq('Bob Builder')
+        expect(inst.age).to eq(52)
+      end
+
+      it 'will perform type assertion of the arguments' do
+        expect { first.create('Bob Builder', '52') }.to(
+          raise_error(TypeAssertionError,
+            'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got String')
+        )
+      end
+
+      it 'will not accept nil as given value for an optional parameter that does not accept nil' do
+        expect { first.create('Bob Builder', nil) }.to(
+          raise_error(TypeAssertionError,
+            'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got Undef')
+        )
+      end
+
+      it 'reorders parameters to but the optional parameters last' do
+        inst = second.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+        expect(inst.name).to eq('Bob Builder')
+        expect(inst.address).to eq('42 Cool Street')
+        expect(inst.zipcode).to eq('12345')
+        expect(inst.email).to eq('bob@example.com')
+        expect(inst.number).to eq(23)
+        expect(inst.what).to eql('what is this')
+        expect(inst.age).to eql(30)
+        expect(inst.another).to be_nil
+      end
+    end
+
+    context 'the #from_hash class method' do
+      it 'has an arity of one' do
+        expect(first.method(:from_hash).arity).to eql(1)
+        expect(second.method(:from_hash).arity).to eql(1)
+      end
+
+      it 'creates an instance of the class' do
+        inst = first.from_hash('name' => 'Bob Builder', 'age' => 52)
+        expect(inst).to be_a(first)
+        expect(inst.name).to eq('Bob Builder')
+        expect(inst.age).to eq(52)
+      end
+
+      it 'accepts an initializer where optional keys are missing' do
+        inst = first.from_hash('name' => 'Bob Builder')
+        expect(inst).to be_a(first)
+        expect(inst.name).to eq('Bob Builder')
+        expect(inst.age).to eq(30)
+      end
+
+      it 'does not accept an initializer where optional values are nil and type does not accept nil' do
+        expect { first.from_hash('name' => 'Bob Builder', 'age' => nil) }.to(
+          raise_error(TypeAssertionError,
+            "MyModule::FirstGenerated initializer had wrong type, entry 'age' expected an Integer value, got Undef")
+        )
+      end
+    end
+
+    context 'creates an instance' do
+      it 'that the TypeCalculator infers to the Object type' do
+        expect(TypeCalculator.infer(first.from_hash('name' => 'Bob Builder'))).to eq(first_type)
+      end
+    end
+  end
+
+  context 'when generating static code' do
+    module_def = nil
+
+    before(:each) do
+      # Ideally, this would be in a before(:all) but that is impossible since lots of Puppet
+      # environment specific settings are configured by the spec_helper in before(:each)
+      if module_def.nil?
+        first_type = nil
+        second_type = nil
+        eval_and_collect_notices(source) do |scope, catalog|
+          first_type = parser.parse('MyModule::FirstGenerated', scope)
+          second_type = parser.parse('MyModule::SecondGenerated', scope)
+
+          loader = Loaders.find_loader(nil)
+          Loaders.implementation_registry.register_type_mapping(
+            PRuntimeType.new(:ruby, [/^PuppetSpec::RubyGenerator::(\w+)$/, 'MyModule::\1']),
+            [/^MyModule::(\w+)$/, 'PuppetSpec::RubyGenerator::\1'], loader)
+
+          module_def = generator.module_definition([first_type, second_type], 'Generated stuff')
+        end
+        Loaders.clear
+        Puppet[:code] = nil
+
+        # Create the actual classes in the PuppetSpec::RubyGenerator module
+        Puppet.override(:loaders => Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
+          eval(module_def, root_binding)
+        end
+      end
+    end
+
+    after(:all) do
+      # Don't want generated module to leak outside this test
+      PuppetSpec.send(:remove_const, :RubyGenerator)
+    end
+
+    it 'the #_ptype class method returns a resolved Type' do
+      first_type = PuppetSpec::RubyGenerator::FirstGenerated._ptype
+      expect(first_type).to be_a(PObjectType)
+      second_type = PuppetSpec::RubyGenerator::SecondGenerated._ptype
+      expect(second_type).to be_a(PObjectType)
+      expect(second_type.parent).to eql(first_type)
+    end
+
+    it 'the #_plocation class method returns a file URI' do
+      loc = PuppetSpec::RubyGenerator::SecondGenerated._plocation
+      expect(loc).to be_a(URI)
+      expect(loc.to_s).to match(/^file:\/.*ruby_generator_spec.rb\?line=\d+$/)
+    end
+
+    context 'the #create class method' do
+      it 'has an arity that reflects optional arguments' do
+        expect(PuppetSpec::RubyGenerator::FirstGenerated.method(:create).arity).to eql(-2)
+        expect(PuppetSpec::RubyGenerator::SecondGenerated.method(:create).arity).to eql(-6)
+      end
+
+      it 'creates an instance of the class' do
+        inst = PuppetSpec::RubyGenerator::FirstGenerated.create('Bob Builder', 52)
+        expect(inst).to be_a(PuppetSpec::RubyGenerator::FirstGenerated)
+        expect(inst.name).to eq('Bob Builder')
+        expect(inst.age).to eq(52)
+      end
+
+      it 'will perform type assertion of the arguments' do
+        expect { PuppetSpec::RubyGenerator::FirstGenerated.create('Bob Builder', '52') }.to(
+          raise_error(TypeAssertionError,
+            'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got String')
+        )
+      end
+
+      it 'will not accept nil as given value for an optional parameter that does not accept nil' do
+        expect { PuppetSpec::RubyGenerator::FirstGenerated.create('Bob Builder', nil) }.to(
+          raise_error(TypeAssertionError,
+            'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got Undef')
+        )
+      end
+
+      it 'reorders parameters to but the optional parameters last' do
+        inst = PuppetSpec::RubyGenerator::SecondGenerated.create('Bob Builder', '42 Cool Street', '12345', 'bob@example.com', 23)
+        expect(inst.name).to eq('Bob Builder')
+        expect(inst.address).to eq('42 Cool Street')
+        expect(inst.zipcode).to eq('12345')
+        expect(inst.email).to eq('bob@example.com')
+        expect(inst.number).to eq(23)
+        expect(inst.what).to eql('what is this')
+        expect(inst.age).to eql(30)
+        expect(inst.another).to be_nil
+      end
+    end
+
+    context 'the #from_hash class method' do
+      it 'has an arity of one' do
+        expect(PuppetSpec::RubyGenerator::FirstGenerated.method(:from_hash).arity).to eql(1)
+        expect(PuppetSpec::RubyGenerator::SecondGenerated.method(:from_hash).arity).to eql(1)
+      end
+
+      it 'creates an instance of the class' do
+        inst = PuppetSpec::RubyGenerator::FirstGenerated.from_hash('name' => 'Bob Builder', 'age' => 52)
+        expect(inst).to be_a(PuppetSpec::RubyGenerator::FirstGenerated)
+        expect(inst.name).to eq('Bob Builder')
+        expect(inst.age).to eq(52)
+      end
+
+      it 'accepts an initializer where optional keys are missing' do
+        inst = PuppetSpec::RubyGenerator::FirstGenerated.from_hash('name' => 'Bob Builder')
+        expect(inst).to be_a(PuppetSpec::RubyGenerator::FirstGenerated)
+        expect(inst.name).to eq('Bob Builder')
+        expect(inst.age).to eq(30)
+      end
+
+      it 'does not accept an initializer where optional values are nil and type does not accept nil' do
+        expect { PuppetSpec::RubyGenerator::FirstGenerated.from_hash('name' => 'Bob Builder', 'age' => nil) }.to(
+          raise_error(TypeAssertionError,
+            "MyModule::FirstGenerated initializer had wrong type, entry 'age' expected an Integer value, got Undef")
+        )
+      end
+    end
+  end
+end
+end
+end