puppet 4.5.3-x64-mingw32 → 4.6.1-x64-mingw32

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

@@ -0,0 +1,424 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+  module Types
+    describe 'The TypeSet Type' do
+      include PuppetSpec::Compiler
+
+      let(:parser) { TypeParser.singleton }
+      let(:pp_parser) { Parser::EvaluatingParser.new }
+      let(:env) { Puppet::Node::Environment.create('test', []) }
+      let(:loaders) { Loaders.new(env) }
+      let(:loader) { loaders.find_loader(nil) }
+
+      def type_set_t(name, body_string, name_authority)
+        i12n_literal_hash = pp_parser.parse_string("{#{body_string}}").current.body
+        typeset = PTypeSetType.new(name, i12n_literal_hash, name_authority)
+        loader.set_entry(Loader::TypedName.new(:type, name.downcase, name_authority), typeset)
+        typeset
+      end
+
+      # Creates and parses an alias type declaration of a TypeSet, e.g.
+      # ```
+      # type <name> = TypeSet[{<body_string>}]
+      # ```
+      # The declaration implies the name authority {Pcore::RUNTIME_NAME_AUTHORITY}
+      #
+      # @param name [String] the name of the type set
+      # @param body [String] the body (initialization hash) of the type-set
+      # @return [PTypeSetType] the created type set
+      def parse_type_set(name, body, name_authority = Pcore::RUNTIME_NAME_AUTHORITY)
+        type_set_t(name, body, name_authority)
+        parser.parse(name, loader)
+      end
+
+      context 'when validating the initialization hash' do
+        context 'it will allow that it' do
+          it 'has no types and no references' do
+            ts = <<-OBJECT
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            OBJECT
+            expect { parse_type_set('MySet', ts) }.not_to raise_error
+          end
+
+          it 'has only references' do
+            parse_type_set('FirstSet', <<-OBJECT)
+              version => '1.0.0',
+              pcore_version => '1.0.0',
+              types => {
+                Car => Object[{}]
+              }
+            OBJECT
+
+            expect { parse_type_set('SecondSet', <<-OBJECT) }.not_to raise_error
+              version => '1.0.0',
+              pcore_version => '1.0.0',
+              references => {
+                First => {
+                  name => 'FirstSet',
+                  version_range => '1.x'
+                }
+              }
+            OBJECT
+          end
+
+          it 'has multiple references to equally named TypeSets using different name authorities' do
+            parse_type_set('FirstSet', <<-OBJECT, 'http://example.com/ns1')
+              version => '1.0.0',
+              pcore_version => '1.0.0',
+              types => {
+                Car => Object[{}]
+              }
+            OBJECT
+
+            parse_type_set('FirstSet', <<-OBJECT, 'http://example.com/ns2')
+              version => '1.0.0',
+              pcore_version => '1.0.0',
+              types => {
+                Car => Object[{}]
+              }
+            OBJECT
+
+            expect { parse_type_set('SecondSet', <<-OBJECT) }.not_to raise_error
+              version => '1.0.0',
+              pcore_version => '1.0.0',
+              references => {
+                First_1 => {
+                  name_authority => 'http://example.com/ns1',
+                  name => 'FirstSet',
+                  version_range => '1.x'
+                },
+                First_2 => {
+                  name => 'FirstSet',
+                  name_authority => 'http://example.com/ns2',
+                  version_range => '1.x'
+                }
+              }
+            OBJECT
+          end
+        end
+
+        context 'it raises an error when' do
+          it 'pcore_version is missing' do
+            ts = <<-OBJECT
+            version => '1.0.0',
+            OBJECT
+            expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+              /expected a value for key 'pcore_version'/)
+          end
+
+          it 'version is missing' do
+            ts = <<-OBJECT
+            pcore_version => '1.0.0',
+            OBJECT
+            expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+              /expected a value for key 'version'/)
+          end
+
+          it 'the version is an invalid semantic version' do
+            ts = <<-OBJECT
+            version => '1.x',
+            pcore_version => '1.0.0',
+            OBJECT
+            expect { parse_type_set('MySet', ts) }.to raise_error(Semantic::Version::ValidationFailure)
+          end
+
+          it 'the pcore_version is an invalid semantic version' do
+            ts = <<-OBJECT
+            version => '1.0.0',
+            pcore_version => '1.x',
+            OBJECT
+            expect { parse_type_set('MySet', ts) }.to raise_error(Semantic::Version::ValidationFailure)
+          end
+
+          it 'the pcore_version is outside of the range of that is parsable by this runtime' do
+            ts = <<-OBJECT
+            version => '1.0.0',
+            pcore_version => '2.0.0',
+            OBJECT
+            expect { parse_type_set('MySet', ts) }.to raise_error(ArgumentError,
+              /The pcore version for TypeSet 'MySet' is not understood by this runtime. Expected range 1\.x, got 2\.0\.0/)
+          end
+
+          it 'the name authority is an invalid URI' do
+            ts = <<-OBJECT
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            name_authority => 'not a valid URI'
+            OBJECT
+            expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+              /entry 'name_authority' expected a match for Pattern\[.*\], got 'not a valid URI'/m)
+          end
+
+          context 'the types map' do
+            it 'is empty' do
+              ts = <<-OBJECT
+                pcore_version => '1.0.0',
+                version => '1.0.0',
+                types => {}
+              OBJECT
+              expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+                /entry 'types' expected size to be at least 1, got 0/)
+            end
+
+            it 'is not a map' do
+              ts = <<-OBJECT
+                pcore_version => '1.0.0',
+                version => '1.0.0',
+                types => []
+              OBJECT
+              expect { parse_type_set('MySet', ts) }.to raise_error(Puppet::Error,
+                /entry 'types' expected a Hash value, got Array/)
+            end
+
+            it 'contains values that are not types' do
+              ts = <<-OBJECT
+                pcore_version => '1.0.0',
+                version => '1.0.0',
+                types => {
+                  Car => 'brum'
+                }
+              OBJECT
+              expect { parse_type_set('MySet', ts) }.to raise_error(Puppet::Error,
+                /The expression <'brum'> is not a valid type specification/)
+            end
+
+            it 'contains keys that are not SimpleNames' do
+              ts = <<-OBJECT
+                pcore_version => '1.0.0',
+                version => '1.0.0',
+                types => {
+                  car => Integer
+                }
+              OBJECT
+              expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+                /key of entry 'car' expected a match for Pattern\[\/\\A\[A-Z\]\\w\*\\z\/\], got 'car'/)
+            end
+          end
+
+          context 'the references hash' do
+            it 'is empty' do
+              ts = <<-OBJECT
+                pcore_version => '1.0.0',
+                version => '1.0.0',
+                references => {}
+              OBJECT
+              expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+                /entry 'references' expected size to be at least 1, got 0/)
+            end
+
+            it 'is not a hash' do
+              ts = <<-OBJECT
+                pcore_version => '1.0.0',
+                version => '1.0.0',
+                references => []
+              OBJECT
+              expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+                /entry 'references' expected a Hash value, got Array/)
+            end
+
+            it 'contains something other than reference initialization maps' do
+              ts = <<-OBJECT
+                pcore_version => '1.0.0',
+                version => '1.0.0',
+                references => {Ref => 2}
+              OBJECT
+              expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+                /entry 'references' entry 'Ref' expected a Struct value, got Integer/)
+            end
+
+            it 'contains several initialization that refers to the same TypeSet' do
+              ts = <<-OBJECT
+                pcore_version => '1.0.0',
+                version => '1.0.0',
+                references => {
+                  A => { name => 'Vehicle::Cars', version_range => '1.x' },
+                  V => { name => 'Vehicle::Cars', version_range => '1.x' },
+                }
+              OBJECT
+              expect { parse_type_set('MySet', ts) }.to raise_error(ArgumentError,
+                /references TypeSet 'http:\/\/puppet\.com\/2016\.1\/runtime\/Vehicle::Cars' more than once using overlapping version ranges/)
+            end
+
+            it 'contains an initialization maps with an alias that collides with a type name' do
+              ts = <<-OBJECT
+                pcore_version => '1.0.0',
+                version => '1.0.0',
+                types => {
+                  Car => Object[{}]
+                },
+                references => {
+                  Car => { name => 'Vehicle::Car', version_range => '1.x' }
+                }
+              OBJECT
+              expect { parse_type_set('MySet', ts) }.to raise_error(ArgumentError,
+                /references a TypeSet using alias 'Car'. The alias collides with the name of a declared type/)
+            end
+
+            context 'contains an initialization map that' do
+              it 'has no version range' do
+                ts = <<-OBJECT
+                  pcore_version => '1.0.0',
+                  version => '1.0.0',
+                  references => { Ref => { name => 'X' } }
+                OBJECT
+                expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+                  /entry 'references' entry 'Ref' expected a value for key 'version_range'/)
+              end
+
+              it 'has no name' do
+                ts = <<-OBJECT
+                  pcore_version => '1.0.0',
+                  version => '1.0.0',
+                  references => { Ref => { version_range => '1.x' } }
+                OBJECT
+                expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+                  /entry 'references' entry 'Ref' expected a value for key 'name'/)
+              end
+
+              it 'has a name that is not a QRef' do
+                ts = <<-OBJECT
+                  pcore_version => '1.0.0',
+                  version => '1.0.0',
+                  references => { Ref => { name => 'cars', version_range => '1.x' } }
+                OBJECT
+                expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+                  /entry 'references' entry 'Ref' entry 'name' expected a match for Pattern\[\/\\A\[A-Z\]\[\\w\]\*\(\?:::\[A-Z\]\[\\w\]\*\)\*\\z\/\], got 'cars'/)
+              end
+
+              it 'has a version_range that is not a valid SemVer range' do
+                ts = <<-OBJECT
+                  pcore_version => '1.0.0',
+                  version => '1.0.0',
+                  references => { Ref => { name => 'Cars', version_range => 'X' } }
+                OBJECT
+                expect { parse_type_set('MySet', ts) }.to raise_error(ArgumentError,
+                  /Unparsable version range: "X"/)
+              end
+
+              it 'has an alias that is not a SimpleName' do
+                ts = <<-OBJECT
+                  pcore_version => '1.0.0',
+                  version => '1.0.0',
+                  references => { 'cars' => { name => 'X', version_range => '1.x' } }
+                OBJECT
+                expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
+                  /entry 'references' key of entry 'cars' expected a match for Pattern\[\/\\A\[A-Z\]\\w\*\\z\/\], got 'cars'/)
+              end
+            end
+          end
+        end
+      end
+
+      context 'when declaring types' do
+        it 'can declare a type Alias' do
+          expect { parse_type_set('TheSet', <<-OBJECT) }.not_to raise_error
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            types => { PositiveInt => Integer[0, default] }
+          OBJECT
+        end
+
+        it 'can declare a type and Object type' do
+          expect { parse_type_set('TheSet', <<-OBJECT) }.not_to raise_error
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            types => { Complex => Object[{}] }
+          OBJECT
+        end
+
+        it 'can declare an Object type that references other types in the same set' do
+          expect { parse_type_set('TheSet', <<-OBJECT) }.not_to raise_error
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            types => {
+              Real => Float,
+              Complex => Object[{
+                attributes => {
+                  real => Real,
+                  imaginary => Real
+                }
+              }]
+            }
+          OBJECT
+        end
+
+        it 'can declare an alias that references itself' do
+          expect { parse_type_set('TheSet', <<-OBJECT) }.not_to raise_error
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            types => {
+              Tree => Hash[String,Variant[String,Tree]]
+            }
+          OBJECT
+        end
+
+        it 'can declare a type that references types in another type set' do
+          parse_type_set('Vehicles', <<-OBJECT)
+              version => '1.0.0',
+              pcore_version => '1.0.0',
+              types => {
+                Car => Object[{}],
+                Bicycle => Object[{}]
+              }
+          OBJECT
+          expect { parse_type_set('TheSet', <<-OBJECT) }.not_to raise_error
+              version => '1.0.0',
+              pcore_version => '1.0.0',
+              types => {
+                Transports => Variant[Vecs::Car,Vecs::Bicycle]
+              },
+              references => {
+                Vecs => {
+                  name => 'Vehicles',
+                  version_range => '1.x'
+                }
+              }
+          OBJECT
+        end
+
+        it 'can declare a type that references types in a type set referenced by another type set' do
+          parse_type_set('Vehicles', <<-OBJECT)
+              version => '1.0.0',
+              pcore_version => '1.0.0',
+              types => {
+                Car => Object[{}],
+                Bicycle => Object[{}]
+              }
+          OBJECT
+          parse_type_set('Transports', <<-OBJECT)
+              version => '1.0.0',
+              pcore_version => '1.0.0',
+              types => {
+                Transports => Variant[Vecs::Car,Vecs::Bicycle]
+              },
+              references => {
+                Vecs => {
+                  name => 'Vehicles',
+                  version_range => '1.x'
+                }
+              }
+          OBJECT
+          expect { parse_type_set('TheSet', <<-OBJECT) }.not_to raise_error
+              version => '1.0.0',
+              pcore_version => '1.0.0',
+              types => {
+                MotorPowered => Variant[T::Vecs::Car],
+                Pedaled => Variant[T::Vecs::Bicycle],
+                All => T::Transports
+              },
+              references => {
+                T => {
+                  name => 'Transports',
+                  version_range => '1.x'
+                }
+              }
+          OBJECT
+        end
+      end
+    end
+  end
+end

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

@@ -12,247 +12,563 @@ 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!(:parser) { TypeParser.singleton }
   let(:generator) { RubyGenerator.new }
 
-  context 'when generating anonymous classes' do
+  context 'when generating from Object types' do
+    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
+
+    context 'when generating anonymous classes' do
 
-    scope = nil
+      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) }
+      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
+      before(:each) do
+        eval_and_collect_notices(source) do |topscope, catalog|
+          scope = topscope
+        end
       end
-    end
 
-    after(:each) { typeset = nil }
+      after(:each) { typeset = nil }
 
-    context 'the generated class' do
-      it 'inherits the PuppetObject module' do
-        expect(first < PuppetObject).to be_truthy
-      end
+      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
+        it 'is the superclass of a generated subclass' do
+          expect(second < first).to be_truthy
+        end
       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
+      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 '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 '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')
-        )
+        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
 
-      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')
-        )
+      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
 
-      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
+      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 '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)
+    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
 
-      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)
+      after(:all) do
+        # Don't want generated module to leak outside this test
+        PuppetSpec.send(:remove_const, :RubyGenerator)
       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)
+      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 '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")
-        )
+      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
-    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)
+      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
 
-  context 'when generating static code' do
-    module_def = nil
+  context 'when generating from TypeSets' do
+    def source
+      <<-CODE
+        type MyModule = TypeSet[{
+          pcore_version => '1.0.0',
+          version => '1.0.0',
+          types   => {
+            MyInteger => Integer,
+            FirstGenerated => Object[{
+              attributes => {
+                name => String,
+                age  => { type => Integer, value => 30 },
+                what => { type => String, value => 'what is this', kind => constant }
+              }
+            }],
+            SecondGenerated => Object[{
+              parent => FirstGenerated,
+              attributes => {
+                address => String,
+                zipcode => String,
+                email => String,
+                another => { type => Optional[FirstGenerated], value => undef },
+                number => MyInteger
+              }
+            }]
+          },
+        }]
+
+        type OtherModule = TypeSet[{
+          pcore_version => '1.0.0',
+          version => '1.0.0',
+          types   => {
+            MyFloat => Float,
+            ThirdGenerated => Object[{
+              attributes => {
+                first => My::FirstGenerated
+              }
+            }],
+            FourthGenerated => Object[{
+              parent => My::SecondGenerated,
+              attributes => {
+                complex => { type => Optional[ThirdGenerated], value => undef },
+                n1 => My::MyInteger,
+                n2 => MyFloat
+              }
+            }]
+          },
+          references => {
+            My => { name => 'MyModule', version_range => '1.x' }
+          }
+        }]
+      CODE
+    end
+
+    context 'when generating anonymous classes' do
 
-    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
+      typeset = nil
+
+      let(:first_type) { typeset['My::FirstGenerated'] }
+      let(:second_type) { typeset['My::SecondGenerated'] }
+      let(:third_type) { typeset['ThirdGenerated'] }
+      let(:fourth_type) { typeset['FourthGenerated'] }
+      let(:first) { generator.create_class(first_type) }
+      let(:second) { generator.create_class(second_type) }
+      let(:third) { generator.create_class(third_type) }
+      let(:fourth) { generator.create_class(fourth_type) }
+
+      before(:each) do
         eval_and_collect_notices(source) do |scope, catalog|
-          first_type = parser.parse('MyModule::FirstGenerated', scope)
-          second_type = parser.parse('MyModule::SecondGenerated', scope)
+          typeset = parser.parse('OtherModule', scope)
+        end
+      end
 
-          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)
+      after(:each) { typeset = nil }
+
+      context 'the typeset' do
+        it 'produces expected string representation' do
+          typeset.to_s == "TypeSet[{"+
+            "pcore_version => '1.0.0', "+
+            "name_authority => 'http://puppet.com/2016.1/runtime', "+
+            "name => 'OtherModule', "+
+            "version => '1.0.0', "+
+            "types => {"+
+            "MyFloat => Float, "+
+            "ThirdGenerated => Object[{"+
+            "attributes => {"+
+            "'first' => MyModule::FirstGenerated}}], "+
+            "FourthGenerated => Object[{"+
+            "parent => MyModule::SecondGenerated, "+
+            "attributes => {"+
+            "'complex' => {"+
+            "type => Optional[ThirdGenerated], "+
+            "value => ?}, "+
+            "'n1' => MyModule::MyInteger, "+
+            "'n2' => MyFloat}}]}, "+
+            "references => [{"+
+            "'name' => 'MyModule', "+
+            "'alias' => 'My', "+
+            "'version_range' => '1.x'}]}]"
+        end
+      end
 
-          module_def = generator.module_definition([first_type, second_type], 'Generated stuff')
+      context 'the generated class' do
+        it 'inherits the PuppetObject module' do
+          expect(first < PuppetObject).to be_truthy
         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)
+        it 'is the superclass of a generated subclass' do
+          expect(second < first).to be_truthy
         end
       end
-    end
 
-    after(:all) do
-      # Don't want generated module to leak outside this test
-      PuppetSpec.send(:remove_const, :RubyGenerator)
-    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)
+          expect(third.method(:create).arity).to eql(1)
+          expect(fourth.method(:create).arity).to eql(-8)
+        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 '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 '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
+        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
 
-    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)
+        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
 
-      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)
+      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
 
-      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')
-        )
+      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
 
-      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')
-        )
+    context 'when generating static code' do
+      module_def = nil
+      module_def2 = 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?
+          typeset = nil
+          eval_and_collect_notices(source) do |scope, catalog|
+            typeset1 = parser.parse('MyModule', scope)
+            typeset2 = parser.parse('OtherModule', scope)
+
+            loader = Loaders.find_loader(nil)
+            Loaders.implementation_registry.register_type_mapping(
+              PRuntimeType.new(:ruby, [/^PuppetSpec::RubyGenerator::My::(\w+)$/, 'MyModule::\1']),
+              [/^MyModule::(\w+)$/, 'PuppetSpec::RubyGenerator::My::\1'], loader)
+
+            Loaders.implementation_registry.register_type_mapping(
+              PRuntimeType.new(:ruby, [/^PuppetSpec::RubyGenerator::Other::(\w+)$/, 'OtherModule::\1']),
+              [/^OtherModule::(\w+)$/, 'PuppetSpec::RubyGenerator::Other::\1'], loader)
+
+            module_def = generator.module_definition_from_typeset(typeset1)
+            module_def2 = generator.module_definition_from_typeset(typeset2)
+          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)
+            eval(module_def2, root_binding)
+          end
+        end
       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
+      after(:all) do
+        # Don't want generated module to leak outside this test
+        PuppetSpec.send(:remove_const, :RubyGenerator)
       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)
+      it 'the #_ptype class method returns a resolved Type' do
+        first_type = PuppetSpec::RubyGenerator::My::FirstGenerated._ptype
+        expect(first_type).to be_a(PObjectType)
+        second_type = PuppetSpec::RubyGenerator::My::SecondGenerated._ptype
+        expect(second_type).to be_a(PObjectType)
+        expect(second_type.parent).to eql(first_type)
       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)
+      it 'the #_plocation class method returns a file URI' do
+        loc = PuppetSpec::RubyGenerator::My::SecondGenerated._plocation
+        expect(loc).to be_a(URI)
+        expect(loc.to_s).to match(/^file:\/.*ruby_generator_spec.rb\?line=\d+$/)
       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)
+      context 'the #create class method' do
+        it 'has an arity that reflects optional arguments' do
+          expect(PuppetSpec::RubyGenerator::My::FirstGenerated.method(:create).arity).to eql(-2)
+          expect(PuppetSpec::RubyGenerator::My::SecondGenerated.method(:create).arity).to eql(-6)
+        end
+
+        it 'creates an instance of the class' do
+          inst = PuppetSpec::RubyGenerator::My::FirstGenerated.create('Bob Builder', 52)
+          expect(inst).to be_a(PuppetSpec::RubyGenerator::My::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::My::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::My::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::My::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
 
-      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")
-        )
+      context 'the #from_hash class method' do
+        it 'has an arity of one' do
+          expect(PuppetSpec::RubyGenerator::My::FirstGenerated.method(:from_hash).arity).to eql(1)
+          expect(PuppetSpec::RubyGenerator::My::SecondGenerated.method(:from_hash).arity).to eql(1)
+        end
+
+        it 'creates an instance of the class' do
+          inst = PuppetSpec::RubyGenerator::My::FirstGenerated.from_hash('name' => 'Bob Builder', 'age' => 52)
+          expect(inst).to be_a(PuppetSpec::RubyGenerator::My::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::My::FirstGenerated.from_hash('name' => 'Bob Builder')
+          expect(inst).to be_a(PuppetSpec::RubyGenerator::My::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::My::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