puppet 3.4.3 → 3.5.0.rc1

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

@@ -23,14 +23,102 @@ describe 'The type factory' do
       Puppet::Pops::Types::TypeFactory.pattern().class().should == Puppet::Pops::Types::PPatternType
     end
 
-    it 'literal() returns PLiteralType' do
-      Puppet::Pops::Types::TypeFactory.literal().class().should == Puppet::Pops::Types::PLiteralType
+    it 'regexp() returns PRegexpType' do
+      Puppet::Pops::Types::TypeFactory.regexp().class().should == Puppet::Pops::Types::PRegexpType
+    end
+
+    it 'enum() returns PEnumType' do
+      Puppet::Pops::Types::TypeFactory.enum().class().should == Puppet::Pops::Types::PEnumType
+    end
+
+    it 'variant() returns PVariantType' do
+      Puppet::Pops::Types::TypeFactory.variant().class().should == Puppet::Pops::Types::PVariantType
+    end
+
+    it 'scalar() returns PScalarType' do
+      Puppet::Pops::Types::TypeFactory.scalar().class().should == Puppet::Pops::Types::PScalarType
     end
 
     it 'data() returns PDataType' do
       Puppet::Pops::Types::TypeFactory.data().class().should == Puppet::Pops::Types::PDataType
     end
 
+    it 'optional() returns POptionalType' do
+      Puppet::Pops::Types::TypeFactory.optional().class().should == Puppet::Pops::Types::POptionalType
+    end
+
+    it 'collection() returns PCollectionType' do
+      Puppet::Pops::Types::TypeFactory.collection().class().should == Puppet::Pops::Types::PCollectionType
+    end
+
+    it 'catalog_entry() returns PCatalogEntryType' do
+      Puppet::Pops::Types::TypeFactory.catalog_entry().class().should == Puppet::Pops::Types::PCatalogEntryType
+    end
+
+    it 'struct() returns PStructType' do
+      Puppet::Pops::Types::TypeFactory.struct().class().should == Puppet::Pops::Types::PStructType
+    end
+
+    it 'tuple() returns PTupleType' do
+      Puppet::Pops::Types::TypeFactory.tuple().class().should == Puppet::Pops::Types::PTupleType
+    end
+
+    it 'undef() returns PNilType' do
+      Puppet::Pops::Types::TypeFactory.undef().class().should == Puppet::Pops::Types::PNilType
+    end
+
+    it 'range(to, from) returns PIntegerType' do
+      t = Puppet::Pops::Types::TypeFactory.range(1,2)
+      t.class().should == Puppet::Pops::Types::PIntegerType
+      t.from.should == 1
+      t.to.should == 2
+    end
+
+    it 'range(default, default) returns PIntegerType' do
+      t = Puppet::Pops::Types::TypeFactory.range(:default,:default)
+      t.class().should == Puppet::Pops::Types::PIntegerType
+      t.from.should == nil
+      t.to.should == nil
+    end
+
+    it 'float_range(to, from) returns PFloatType' do
+      t = Puppet::Pops::Types::TypeFactory.float_range(1.0, 2.0)
+      t.class().should == Puppet::Pops::Types::PFloatType
+      t.from.should == 1.0
+      t.to.should == 2.0
+    end
+
+    it 'float_range(default, default) returns PFloatType' do
+      t = Puppet::Pops::Types::TypeFactory.float_range(:default, :default)
+      t.class().should == Puppet::Pops::Types::PFloatType
+      t.from.should == nil
+      t.to.should == nil
+    end
+
+    it 'resource() creates a generic PResourceType' do
+      pr = Puppet::Pops::Types::TypeFactory.resource()
+      pr.class().should == Puppet::Pops::Types::PResourceType
+      pr.type_name.should == nil
+    end
+
+    it 'resource(x) creates a PResourceType[x]' do
+      pr = Puppet::Pops::Types::TypeFactory.resource('x')
+      pr.class().should == Puppet::Pops::Types::PResourceType
+      pr.type_name.should == 'x'
+    end
+
+    it 'host_class() creates a generic PHostClassType' do
+      hc = Puppet::Pops::Types::TypeFactory.host_class()
+      hc.class().should == Puppet::Pops::Types::PHostClassType
+      hc.class_name.should == nil
+    end
+
+    it 'host_class(x) creates a PHostClassType[x]' do
+      hc = Puppet::Pops::Types::TypeFactory.host_class('x')
+      hc.class().should == Puppet::Pops::Types::PHostClassType
+      hc.class_name.should == 'x'
+    end
+
     it 'array_of(fixnum) returns PArrayType[PIntegerType]' do
       at = Puppet::Pops::Types::TypeFactory.array_of(1)
       at.class().should == Puppet::Pops::Types::PArrayType
@@ -49,10 +137,10 @@ describe 'The type factory' do
       at.element_type.class.should == Puppet::Pops::Types::PDataType
     end
 
-    it 'hash_of_data returns PHashType[PLiteralType,PDataType]' do
+    it 'hash_of_data returns PHashType[PScalarType,PDataType]' do
       ht = Puppet::Pops::Types::TypeFactory.hash_of_data
       ht.class().should == Puppet::Pops::Types::PHashType
-      ht.key_type.class.should == Puppet::Pops::Types::PLiteralType
+      ht.key_type.class.should == Puppet::Pops::Types::PScalarType
       ht.element_type.class.should == Puppet::Pops::Types::PDataType
     end
 
@@ -61,5 +149,21 @@ describe 'The type factory' do
       ht.class().should == Puppet::Pops::Types::PRubyType
       ht.ruby_class.should == 'Fixnum'
     end
+
+    it 'a size constrained collection can be created from array' do
+      t = Puppet::Pops::Types::TypeFactory.array_of_data()
+      Puppet::Pops::Types::TypeFactory.constrain_size(t, 1,2).should == t
+      t.size_type.class.should == Puppet::Pops::Types::PIntegerType
+      t.size_type.from.should == 1
+      t.size_type.to.should == 2
+    end
+
+    it 'a size constrained collection can be created from hash' do
+      t = Puppet::Pops::Types::TypeFactory.hash_of_data()
+      Puppet::Pops::Types::TypeFactory.constrain_size(t, 1,2).should == t
+      t.size_type.class.should == Puppet::Pops::Types::PIntegerType
+      t.size_type.from.should == 1
+      t.size_type.to.should == 2
+    end
   end
 end

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

@@ -16,36 +16,51 @@ describe Puppet::Pops::Types::TypeParser do
   end
 
   it "rejects an invalid type simple type" do
-    expect { parser.parse("NotAType") }.to raise_type_error_for("NotAType")
+    expect { parser.parse("notAType") }.to raise_error(Puppet::ParseError, /The expression <notAType> is not a valid type specification/)
   end
 
   it "rejects an unknown parameterized type" do
-    expect { parser.parse("NotAType[Integer]") }.to raise_type_error_for("NotAType")
+    expect { parser.parse("notAType[Integer]") }.to raise_error(Puppet::ParseError,
+      /The expression <notAType\[Integer\]> is not a valid type specification/)
   end
 
-  it "does not support types that do not make sense in the puppet language" do
-    expect { parser.parse("Object") }.to raise_type_error_for("Object")
-    expect { parser.parse("Collection[Integer]") }.to raise_type_error_for("Collection")
+  it "rejects an unknown type parameter" do
+    expect { parser.parse("Array[notAType]") }.to raise_error(Puppet::ParseError,
+      /The expression <Array\[notAType\]> is not a valid type specification/)
+  end
+
+  [
+    'Object', 'Data', 'CatalogEntry', 'Boolean', 'Scalar', 'Undef', 'Numeric',
+  ].each do |name|
+    it "does not support parameterizing unparameterized type <#{name}>" do
+      expect { parser.parse("#{name}[Integer]") }.to raise_unparameterized_error_for(name)
+    end
   end
 
   it "parses a simple, unparameterized type into the type object" do
+    expect(the_type_parsed_from(types.object)).to be_the_type(types.object)
     expect(the_type_parsed_from(types.integer)).to be_the_type(types.integer)
     expect(the_type_parsed_from(types.float)).to be_the_type(types.float)
     expect(the_type_parsed_from(types.string)).to be_the_type(types.string)
     expect(the_type_parsed_from(types.boolean)).to be_the_type(types.boolean)
     expect(the_type_parsed_from(types.pattern)).to be_the_type(types.pattern)
     expect(the_type_parsed_from(types.data)).to be_the_type(types.data)
+    expect(the_type_parsed_from(types.catalog_entry)).to be_the_type(types.catalog_entry)
+    expect(the_type_parsed_from(types.collection)).to be_the_type(types.collection)
+    expect(the_type_parsed_from(types.tuple)).to be_the_type(types.tuple)
+    expect(the_type_parsed_from(types.struct)).to be_the_type(types.struct)
+    expect(the_type_parsed_from(types.optional)).to be_the_type(types.optional)
   end
 
   it "interprets an unparameterized Array as an Array of Data" do
     expect(parser.parse("Array")).to be_the_type(types.array_of_data)
   end
 
-  it "interprets an unparameterized Hash as a Hash of Literal to Data" do
+  it "interprets an unparameterized Hash as a Hash of Scalar to Data" do
     expect(parser.parse("Hash")).to be_the_type(types.hash_of_data)
   end
 
-  it "interprets a parameterized Hash[t] as a Hash of Literal to t" do
+  it "interprets a parameterized Hash[t] as a Hash of Scalar to t" do
     expect(parser.parse("Hash[Integer]")).to be_the_type(types.hash_of(types.integer))
   end
 
@@ -57,9 +72,94 @@ describe Puppet::Pops::Types::TypeParser do
     expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
   end
 
-  it "rejects an array spec with the wrong number of parameters" do
-    expect { parser.parse("Array[Integer, Integer]") }.to raise_the_parameter_error("Array", 1, 2)
-    expect { parser.parse("Hash[Integer, Integer, Integer]") }.to raise_the_parameter_error("Hash", "1 or 2", 3)
+  it "parses a size constrained collection using capped range" do
+    parameterized_array = types.array_of(types.integer)
+    types.constrain_size(parameterized_array, 1,2)
+    parameterized_hash = types.hash_of(types.integer, types.boolean)
+    types.constrain_size(parameterized_hash, 1,2)
+
+    expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
+    expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
+  end
+
+  it "parses a size constrained collection with open range" do
+    parameterized_array = types.array_of(types.integer)
+    types.constrain_size(parameterized_array, 1,:default)
+    parameterized_hash = types.hash_of(types.integer, types.boolean)
+    types.constrain_size(parameterized_hash, 1,:default)
+
+    expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
+    expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
+  end
+
+  it "parses optional type" do
+    opt_t = types.optional(Integer)
+    expect(the_type_parsed_from(opt_t)).to be_the_type(opt_t)
+  end
+
+  it "parses tuple type" do
+    tuple_t = types.tuple(Integer, String)
+    expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
+  end
+
+  it "parses tuple type with occurence constraint" do
+    tuple_t = types.tuple(Integer, String)
+    types.constrain_size(tuple_t, 2, 5)
+    expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
+  end
+
+  it "parses struct type" do
+    struct_t = types.struct({'a'=>Integer, 'b'=>String})
+    expect(the_type_parsed_from(struct_t)).to be_the_type(struct_t)
+  end
+
+  it "rejects an collection spec with the wrong number of parameters" do
+    expect { parser.parse("Array[Integer, 1,2,3]") }.to raise_the_parameter_error("Array", "1 to 3", 4)
+    expect { parser.parse("Hash[Integer, Integer, 1,2,3]") }.to raise_the_parameter_error("Hash", "1 to 4", 5)
+  end
+
+  it "interprets anything that is not a built in type to be a resource type" do
+    expect(parser.parse("File")).to be_the_type(types.resource('file'))
+  end
+
+  it "parses a resource type with title" do
+    expect(parser.parse("File['/tmp/foo']")).to be_the_type(types.resource('file', '/tmp/foo'))
+  end
+
+  it "parses a resource type using 'Resource[type]' form" do
+    expect(parser.parse("Resource[File]")).to be_the_type(types.resource('file'))
+  end
+
+  it "parses a resource type with title using 'Resource[type, title]'" do
+    expect(parser.parse("Resource[File, '/tmp/foo']")).to be_the_type(types.resource('file', '/tmp/foo'))
+  end
+
+  it "parses a host class type" do
+    expect(parser.parse("Class")).to be_the_type(types.host_class())
+  end
+
+  it "parses a parameterized host class type" do
+    expect(parser.parse("Class[foo::bar]")).to be_the_type(types.host_class('foo::bar'))
+  end
+
+  it 'parses an integer range' do
+   expect(parser.parse("Integer[1,2]")).to be_the_type(types.range(1,2))
+  end
+
+  it 'parses a float range' do
+   expect(parser.parse("Float[1.0,2.0]")).to be_the_type(types.float_range(1.0,2.0))
+  end
+
+  it 'parses a collection size range' do
+   expect(parser.parse("Collection[1,2]")).to be_the_type(types.constrain_size(types.collection,1,2))
+  end
+
+  it 'parses a type type' do
+    expect(parser.parse("Type[Integer]")).to be_the_type(types.type_type(types.integer))
+  end
+
+  it 'parses a ruby type' do
+    expect(parser.parse("Ruby['Integer']")).to be_the_type(types.ruby_type('Integer'))
   end
 
   matcher :be_the_type do |type|
@@ -82,6 +182,10 @@ describe Puppet::Pops::Types::TypeParser do
     raise_error(Puppet::ParseError, /Unknown type <#{type_name}>/)
   end
 
+  def raise_unparameterized_error_for(type_name)
+    raise_error(Puppet::ParseError, /Not a parameterized type <#{type_name}>/)
+  end
+
   def the_type_parsed_from(type)
     parser.parse(the_type_spec_for(type))
   end

data/spec/unit/pops/validator/validator_spec.rb

@@ -30,4 +30,39 @@ describe "validating 3x" do
     expect(validate(fqn('AAA').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
   end
 
-end
+  it 'should raise error for -= assignment' do
+    expect(validate(fqn('aaa').minus_set(2))).to have_issue(Puppet::Pops::Issues::UNSUPPORTED_OPERATOR)
+  end
+
+end
+
+describe "validating 4x" do
+  include ParserRspecHelper
+  include PuppetSpec::Pops
+
+  let(:acceptor) { Puppet::Pops::Validation::Acceptor.new() }
+  let(:validator) { Puppet::Pops::Validation::ValidatorFactory_4_0.new().validator(acceptor) }
+
+  def validate(model)
+    validator.validate(model)
+    acceptor
+  end
+
+  it 'should raise error for illegal names' do
+    pending "validation was too strict, now too relaxed - validation missing"
+    expect(validate(fqn('Aaa'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
+    expect(validate(fqn('AAA'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
+  end
+
+  it 'should raise error for illegal variable names' do
+    expect(validate(fqn('Aaa').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
+    expect(validate(fqn('AAA').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
+    expect(validate(fqn('aaa::_aaa').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
+  end
+
+  it 'should not raise error for variable name with underscore first in first name segment' do
+    expect(validate(fqn('_aa').var())).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
+    expect(validate(fqn('::_aa').var())).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
+  end
+
+end

data/spec/unit/provider/augeas/augeas_spec.rb

@@ -499,7 +499,8 @@ describe provider_class do
         @augeas.expects(:close)
 
         @provider.expects(:diff).never()
-        lambda { @provider.need_to_run? }.should raise_error
+        @provider.expects(:print_put_errors)
+        lambda { @provider.need_to_run? }.should raise_error(Puppet::Error)
       end
     end
   end
@@ -661,7 +662,20 @@ describe provider_class do
       @augeas.expects(:respond_to?).with("clearm").returns(false)
       @augeas.expects(:set).with("/foo/test[1]/Jar/Jar", "Foo").returns(true)
       @augeas.expects(:set).with("/foo/test[2]/Jar/Jar", "Bar").returns(true)
-      expect { @provider.execute_changes }.to raise_error RuntimeError, /command 'clearm' not supported/
+      expect { @provider.execute_changes }.to raise_error(RuntimeError, /command 'clearm' not supported/)
+    end
+
+    it "should throw error if saving failed" do
+      @resource[:changes] = ["set test[1]/Jar/Jar Foo","set test[2]/Jar/Jar Bar","clearm test Jar/Jar"]
+      @resource[:context] = "/foo/"
+      @augeas.expects(:respond_to?).with("clearm").returns(true)
+      @augeas.expects(:set).with("/foo/test[1]/Jar/Jar", "Foo").returns(true)
+      @augeas.expects(:set).with("/foo/test[2]/Jar/Jar", "Bar").returns(true)
+      @augeas.expects(:clearm).with("/foo/test", "Jar/Jar").returns(true)
+      @augeas.expects(:save).returns(false)
+      @provider.expects(:print_put_errors)
+      @augeas.expects(:match).returns([])
+      expect { @provider.execute_changes }.to raise_error(Puppet::Error)
     end
   end
 
@@ -674,7 +688,7 @@ describe provider_class do
       link = tmpfile('link')
       target = tmpfile('target')
       FileUtils.touch(target)
-      Puppet::FileSystem::File.new(target).symlink(link)
+      Puppet::FileSystem.symlink(target, link)
 
       resource = Puppet::Type.type(:augeas).new(
         :name => 'test',
@@ -689,7 +703,7 @@ describe provider_class do
       catalog.apply
 
       File.ftype(link).should == 'link'
-      Puppet::FileSystem::File.new(link).readlink().should == target
+      Puppet::FileSystem.readlink(link).should == target
       File.read(target).should =~ /PermitRootLogin no/
     end
   end
@@ -710,25 +724,34 @@ describe provider_class do
         @augeas.expects(:get).with("/augeas/files/foo/error/message").returns("Failed to...")
       end
 
-      it "and output to debug" do
+      it "and output only to debug when no path supplied" do
         @provider.expects(:debug).times(5)
-        @provider.print_load_errors
+        @provider.expects(:warning).never()
+        @provider.print_load_errors(nil)
       end
 
-      it "and output a warning and to debug" do
+      it "and output a warning and to debug when path supplied" do
+        @augeas.expects(:match).with("/augeas/files/foo//error").returns(["/augeas/files/foo/error"])
         @provider.expects(:warning).once()
         @provider.expects(:debug).times(4)
-        @provider.print_load_errors(:warning => true)
+        @provider.print_load_errors('/augeas/files/foo//error')
+      end
+
+      it "and output only to debug when path doesn't match" do
+        @augeas.expects(:match).with("/augeas/files/foo//error").returns([])
+        @provider.expects(:warning).never()
+        @provider.expects(:debug).times(5)
+        @provider.print_load_errors('/augeas/files/foo//error')
       end
     end
 
     it "should find load errors from lenses" do
-      @augeas.expects(:match).with("/augeas//error").returns(["/augeas/load/Xfm/error"])
+      @augeas.expects(:match).with("/augeas//error").twice.returns(["/augeas/load/Xfm/error"])
       @augeas.expects(:match).with("/augeas/load/Xfm/error/*").returns([])
       @augeas.expects(:get).with("/augeas/load/Xfm/error").returns(["Could not find lens php.aug"])
       @provider.expects(:warning).once()
       @provider.expects(:debug).twice()
-      @provider.print_load_errors(:warning => true)
+      @provider.print_load_errors('/augeas//error')
     end
 
     it "should find save errors and output to debug" do
@@ -756,7 +779,7 @@ describe provider_class do
     end
 
     it "should report load errors to debug only" do
-      @provider.expects(:print_load_errors).with(:warning => false)
+      @provider.expects(:print_load_errors).with(nil)
       aug = @provider.open_augeas
       aug.should_not == nil
     end
@@ -766,7 +789,7 @@ describe provider_class do
       @resource[:incl] = "/etc/hosts"
       @resource[:lens] = "Hosts.lns"
 
-      @provider.expects(:print_load_errors).with(:warning => true)
+      @provider.expects(:print_load_errors).with('/augeas//error')
       aug = @provider.open_augeas
       aug.should_not == nil
       aug.match("/files/etc/fstab").should == []
@@ -799,7 +822,7 @@ describe provider_class do
       it "should only load one file if relevant context given" do
         @resource[:context] = "/files/etc/fstab"
 
-        @provider.expects(:print_load_errors).with(:warning => true)
+        @provider.expects(:print_load_errors).with('/augeas/files/etc/fstab//error')
         aug = @provider.open_augeas
         aug.should_not == nil
         aug.match("/files/etc/fstab").should == ["/files/etc/fstab"]
@@ -810,7 +833,7 @@ describe provider_class do
         @resource[:context] = "/files/etc/test"
         @resource[:load_path] = my_fixture_dir
 
-        @provider.expects(:print_load_errors).with(:warning => true)
+        @provider.expects(:print_load_errors).with('/augeas/files/etc/test//error')
         aug = @provider.open_augeas
         aug.should_not == nil
         aug.match("/files/etc/fstab").should == []
@@ -821,7 +844,7 @@ describe provider_class do
       it "should load standard files if context isn't specific" do
         @resource[:context] = "/files/etc"
 
-        @provider.expects(:print_load_errors).with(:warning => false)
+        @provider.expects(:print_load_errors).with(nil)
         aug = @provider.open_augeas
         aug.should_not == nil
         aug.match("/files/etc/fstab").should == ["/files/etc/fstab"]
@@ -831,7 +854,7 @@ describe provider_class do
       it "should not optimise if the context is a complex path" do
         @resource[:context] = "/files/*[label()='etc']"
 
-        @provider.expects(:print_load_errors).with(:warning => false)
+        @provider.expects(:print_load_errors).with(nil)
         aug = @provider.open_augeas
         aug.should_not == nil
         aug.match("/files/etc/fstab").should == ["/files/etc/fstab"]