puppet 3.5.0.rc1-x86-mingw32

data/spec/unit/pops/transformer/transform_containers_spec.rb

@@ -0,0 +1,190 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+# relative to this spec file (./) does not work as this file is loaded by rspec
+require File.join(File.dirname(__FILE__), '/transformer_rspec_helper')
+
+describe "transformation to Puppet AST for containers" do
+  include TransformerRspecHelper
+
+  context "When transforming file scope" do
+    it "$a = 10 $b = 20" do
+      astdump(parse("$a = 10 $b = 20")).should == "(block (= $a 10) (= $b 20))"
+    end
+
+    it "$a = 10" do
+      astdump(parse("$a = 10")).should == "(= $a 10)"
+    end
+  end
+
+  context "When transforming class" do
+    it "class foo {}" do
+      astdump(parse("class foo {}")).should == "(class foo ())"
+    end
+
+    it "class foo::bar {}" do
+      astdump(parse("class foo::bar {}")).should == "(class foo::bar ())"
+    end
+
+    it "class foo inherits bar {}" do
+      astdump(parse("class foo inherits bar {}")).should == "(class foo (inherits bar) ())"
+    end
+
+    it "class foo($a) {}" do
+      astdump(parse("class foo($a) {}")).should == "(class foo (parameters a) ())"
+    end
+
+    it "class foo($a, $b) {}" do
+      astdump(parse("class foo($a, $b) {}")).should == "(class foo (parameters a b) ())"
+    end
+
+    it "class foo($a, $b=10) {}" do
+      astdump(parse("class foo($a, $b=10) {}")).should == "(class foo (parameters a (= b 10)) ())"
+    end
+
+    it "class foo($a, $b) inherits belgo::bar {}" do
+      astdump(parse("class foo($a, $b) inherits belgo::bar{}")).should == "(class foo (inherits belgo::bar) (parameters a b) ())"
+    end
+
+    it "class foo {$a = 10 $b = 20}" do
+      astdump(parse("class foo {$a = 10 $b = 20}")).should == "(class foo (block (= $a 10) (= $b 20)))"
+    end
+
+    context "it should handle '3x weirdness'" do
+      it "class class {} # a class named 'class'" do
+        # Not as much weird as confusing that it is possible to name a class 'class'. Can have
+        # a very confusing effect when resolving relative names, getting the global hardwired "Class"
+        # instead of some foo::class etc.
+        # This is allowed in 3.x.
+        expect {
+        astdump(parse("class class {}")).should == "(class class ())"
+        }.to raise_error(/is not a valid classname/)
+      end
+
+      it "class default {} # a class named 'default'" do
+        # The weirdness here is that a class can inherit 'default' but not declare a class called default.
+        # (It will work with relative names i.e. foo::default though). The whole idea with keywords as
+        # names is flawed to begin with - it generally just a very bad idea.
+        expect { dump(parse("class default {}")).should == "(class default ())" }.to raise_error(Puppet::ParseError)
+      end
+
+      it "class foo::default {} # a nested name 'default'" do
+        astdump(parse("class foo::default {}")).should == "(class foo::default ())"
+      end
+
+      it "class class inherits default {} # inherits default", :broken => true do
+        astdump(parse("class class inherits default {}")).should == "(class class (inherits default) ())"
+      end
+
+      it "class class inherits default {} # inherits default" do
+        # TODO: See previous test marked as :broken=>true, it is actually this test (result) that is wacky,
+        # this because a class is named at parse time (since class evaluation is lazy, the model must have the
+        # full class name for nested classes - only, it gets this wrong when a class is named "class" - or at least
+        # I think it is wrong.)
+        #
+        expect {
+          astdump(parse("class class inherits default {}")).should == "(class class::class (inherits default) ())"
+        }.to raise_error(/is not a valid classname/)
+      end
+
+      it "class foo inherits class" do
+        expect {
+          astdump(parse("class foo inherits class {}")).should == "(class foo (inherits class) ())"
+        }.to raise_error(/is not a valid classname/)
+      end
+    end
+  end
+
+  context "When transforming define" do
+    it "define foo {}" do
+      astdump(parse("define foo {}")).should == "(define foo ())"
+    end
+
+    it "define foo::bar {}" do
+      astdump(parse("define foo::bar {}")).should == "(define foo::bar ())"
+    end
+
+    it "define foo($a) {}" do
+      astdump(parse("define foo($a) {}")).should == "(define foo (parameters a) ())"
+    end
+
+    it "define foo($a, $b) {}" do
+      astdump(parse("define foo($a, $b) {}")).should == "(define foo (parameters a b) ())"
+    end
+
+    it "define foo($a, $b=10) {}" do
+      astdump(parse("define foo($a, $b=10) {}")).should == "(define foo (parameters a (= b 10)) ())"
+    end
+
+    it "define foo {$a = 10 $b = 20}" do
+      astdump(parse("define foo {$a = 10 $b = 20}")).should == "(define foo (block (= $a 10) (= $b 20)))"
+    end
+
+    context "it should handle '3x weirdness'" do
+      it "define class {} # a define named 'class'" do
+        # This is weird because Class already exists, and instantiating this define will probably not
+        # work
+        expect {
+          astdump(parse("define class {}")).should == "(define class ())"
+        }.to raise_error(/is not a valid classname/)
+      end
+
+      it "define default {} # a define named 'default'" do
+        # Check unwanted ability to define 'default'.
+        # The expression below is not allowed (which is good).
+        #
+        expect { dump(parse("define default {}")).should == "(define default ())"}.to raise_error(Puppet::ParseError)
+      end
+    end
+  end
+
+  context "When transforming node" do
+    it "node foo {}" do
+      # AST can not differentiate between bare word and string
+      astdump(parse("node foo {}")).should == "(node (matches 'foo') ())"
+    end
+
+    it "node foo, x.bar, default {}" do
+      # AST can not differentiate between bare word and string
+      astdump(parse("node foo, x_bar, default {}")).should == "(node (matches 'foo' 'x_bar' :default) ())"
+    end
+
+    it "node 'foo' {}" do
+      # AST can not differentiate between bare word and string
+      astdump(parse("node 'foo' {}")).should == "(node (matches 'foo') ())"
+    end
+
+    it "node foo inherits x::bar {}" do
+      # AST can not differentiate between bare word and string
+      astdump(parse("node foo inherits x_bar {}")).should == "(node (matches 'foo') (parent x_bar) ())"
+    end
+
+    it "node foo inherits 'bar' {}" do
+      # AST can not differentiate between bare word and string
+      astdump(parse("node foo inherits 'bar' {}")).should == "(node (matches 'foo') (parent bar) ())"
+    end
+
+    it "node foo inherits default {}" do
+      # AST can not differentiate between bare word and string
+      astdump(parse("node foo inherits default {}")).should == "(node (matches 'foo') (parent default) ())"
+    end
+
+    it "node /web.*/ {}" do
+      astdump(parse("node /web.*/ {}")).should == "(node (matches /web.*/) ())"
+    end
+
+    it "node /web.*/, /do\.wop.*/, and.so.on {}" do
+      astdump(parse("node /web.*/, /do\.wop.*/, 'and.so.on' {}")).should == "(node (matches /web.*/ /do\.wop.*/ 'and.so.on') ())"
+    end
+
+    it "node wat inherits /apache.*/ {}" do
+      astdump(parse("node wat inherits /apache.*/ {}")).should == "(node (matches 'wat') (parent /apache.*/) ())"
+    end
+
+    it "node foo inherits bar {$a = 10 $b = 20}" do
+      # AST can not differentiate between bare word and string
+      astdump(parse("node foo inherits bar {$a = 10 $b = 20}")).should == "(node (matches 'foo') (parent bar) (block (= $a 10) (= $b 20)))"
+    end
+  end
+end

data/spec/unit/pops/transformer/transform_resource_spec.rb

@@ -0,0 +1,185 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+# relative to this spec file (./) does not work as this file is loaded by rspec
+require File.join(File.dirname(__FILE__), '/transformer_rspec_helper')
+
+describe "transformation to Puppet AST for resource declarations" do
+  include TransformerRspecHelper
+
+  context "When transforming regular resource" do
+    it "file { 'title': }" do
+      astdump(parse("file { 'title': }")).should == [
+        "(resource file",
+        "  ('title'))"
+      ].join("\n")
+    end
+
+    it "file { 'title': ; 'other_title': }" do
+      astdump(parse("file { 'title': ; 'other_title': }")).should == [
+        "(resource file",
+        "  ('title')",
+        "  ('other_title'))"
+      ].join("\n")
+    end
+
+    it "file { 'title': path => '/somewhere', mode => 0777}" do
+      astdump(parse("file { 'title': path => '/somewhere', mode => 0777}")).should == [
+        "(resource file",
+        "  ('title'",
+        "    (path => '/somewhere')",
+        "    (mode => 0777)))"
+      ].join("\n")
+    end
+
+    it "file { 'title1': path => 'x'; 'title2': path => 'y'}" do
+      astdump(parse("file { 'title1': path => 'x'; 'title2': path => 'y'}")).should == [
+        "(resource file",
+        "  ('title1'",
+        "    (path => 'x'))",
+        "  ('title2'",
+        "    (path => 'y')))",
+      ].join("\n")
+    end
+  end
+
+  context "When transforming resource defaults" do
+    it "File {  }" do
+      astdump(parse("File { }")).should == "(resource-defaults file)"
+    end
+
+    it "File { mode => 0777 }" do
+      astdump(parse("File { mode => 0777}")).should == [
+        "(resource-defaults file",
+        "  (mode => 0777))"
+      ].join("\n")
+    end
+  end
+
+  context "When transforming resource override" do
+    it "File['x'] {  }" do
+      astdump(parse("File['x'] { }")).should == "(override (slice file 'x'))"
+    end
+
+    it "File['x'] { x => 1 }" do
+      astdump(parse("File['x'] { x => 1}")).should == "(override (slice file 'x')\n  (x => 1))"
+    end
+
+    it "File['x', 'y'] { x => 1 }" do
+      astdump(parse("File['x', 'y'] { x => 1}")).should == "(override (slice file ('x' 'y'))\n  (x => 1))"
+    end
+
+    it "File['x'] { x => 1, y => 2 }" do
+      astdump(parse("File['x'] { x => 1, y=> 2}")).should == "(override (slice file 'x')\n  (x => 1)\n  (y => 2))"
+    end
+
+    it "File['x'] { x +> 1 }" do
+      astdump(parse("File['x'] { x +> 1}")).should == "(override (slice file 'x')\n  (x +> 1))"
+    end
+  end
+
+  context "When transforming virtual and exported resources" do
+    it "@@file { 'title': }" do
+      astdump(parse("@@file { 'title': }")).should ==  "(exported-resource file\n  ('title'))"
+    end
+
+    it "@file { 'title': }" do
+      astdump(parse("@file { 'title': }")).should ==  "(virtual-resource file\n  ('title'))"
+    end
+  end
+
+  context "When transforming class resource" do
+    it "class { 'cname': }" do
+      astdump(parse("class { 'cname': }")).should == [
+        "(resource class",
+        "  ('cname'))"
+      ].join("\n")
+    end
+
+    it "class { 'cname': x => 1, y => 2}" do
+      astdump(parse("class { 'cname': x => 1, y => 2}")).should == [
+        "(resource class",
+        "  ('cname'",
+        "    (x => 1)",
+        "    (y => 2)))"
+      ].join("\n")
+    end
+
+    it "class { 'cname1': x => 1; 'cname2': y => 2}" do
+      astdump(parse("class { 'cname1': x => 1; 'cname2': y => 2}")).should == [
+        "(resource class",
+        "  ('cname1'",
+        "    (x => 1))",
+        "  ('cname2'",
+        "    (y => 2)))",
+      ].join("\n")
+    end
+  end
+
+  context "When transforming Relationships" do
+    it "File[a] -> File[b]" do
+      astdump(parse("File[a] -> File[b]")).should == "(-> (slice file a) (slice file b))"
+    end
+
+    it "File[a] <- File[b]" do
+      astdump(parse("File[a] <- File[b]")).should == "(<- (slice file a) (slice file b))"
+    end
+
+    it "File[a] ~> File[b]" do
+      astdump(parse("File[a] ~> File[b]")).should == "(~> (slice file a) (slice file b))"
+    end
+
+    it "File[a] <~ File[b]" do
+      astdump(parse("File[a] <~ File[b]")).should == "(<~ (slice file a) (slice file b))"
+    end
+
+    it "Should chain relationships" do
+      astdump(parse("a -> b -> c")).should ==
+      "(-> (-> a b) c)"
+    end
+
+    it "Should chain relationships" do
+      astdump(parse("File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]")).should ==
+      "(<~ (<- (~> (-> (slice file a) (slice file b)) (slice file c)) (slice file d)) (slice file e))"
+    end
+  end
+
+  context "When transforming collection" do
+    context "of virtual resources" do
+      it "File <| |>" do
+        astdump(parse("File <| |>")).should == "(collect file\n  (<| |>))"
+      end
+    end
+
+    context "of exported resources" do
+      it "File <<| |>>" do
+        astdump(parse("File <<| |>>")).should == "(collect file\n  (<<| |>>))"
+      end
+    end
+
+    context "queries are parsed with correct precedence" do
+      it "File <| tag == 'foo' |>" do
+        astdump(parse("File <| tag == 'foo' |>")).should == "(collect file\n  (<| |> (== tag 'foo')))"
+      end
+
+      it "File <| tag == 'foo' and mode != 0777 |>" do
+        astdump(parse("File <| tag == 'foo' and mode != 0777 |>")).should == "(collect file\n  (<| |> (&& (== tag 'foo') (!= mode 0777))))"
+      end
+
+      it "File <| tag == 'foo' or mode != 0777 |>" do
+        astdump(parse("File <| tag == 'foo' or mode != 0777 |>")).should == "(collect file\n  (<| |> (|| (== tag 'foo') (!= mode 0777))))"
+      end
+
+      it "File <| tag == 'foo' or tag == 'bar' and mode != 0777 |>" do
+        astdump(parse("File <| tag == 'foo' or tag == 'bar' and mode != 0777 |>")).should ==
+        "(collect file\n  (<| |> (|| (== tag 'foo') (&& (== tag 'bar') (!= mode 0777)))))"
+      end
+
+      it "File <| (tag == 'foo' or tag == 'bar') and mode != 0777 |>" do
+        astdump(parse("File <| (tag == 'foo' or tag == 'bar') and mode != 0777 |>")).should ==
+        "(collect file\n  (<| |> (&& (|| (== tag 'foo') (== tag 'bar')) (!= mode 0777))))"
+      end
+    end
+  end
+end

data/spec/unit/pops/transformer/transformer_rspec_helper.rb

@@ -0,0 +1,27 @@
+require 'puppet/pops'
+require 'puppet/parser/ast'
+
+require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
+
+module TransformerRspecHelper
+  include FactoryRspecHelper
+  # Dumps the AST to string form
+  #
+  def astdump(ast)
+    ast = transform(ast) unless ast.kind_of?(Puppet::Parser::AST)
+    Puppet::Pops::Model::AstTreeDumper.new.dump(ast)
+  end
+
+  # Transforms the Pops model to an AST model
+  #
+  def transform(model)
+    Puppet::Pops::Model::AstTransformer.new.transform(model)
+  end
+
+  # Parses the string code to a Pops model
+  #
+  def parse(code)
+    parser = Puppet::Pops::Parser::Parser.new()
+    parser.parse_string(code)
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe 'The enumeration support' do
+  it 'produces an enumerator for Array' do
+  expect(Puppet::Pops::Types::Enumeration.enumerator([1,2,3]).respond_to?(:next)).to eql(true)
+  end
+
+  it 'produces an enumerator for Hash' do
+    expect(Puppet::Pops::Types::Enumeration.enumerator({:a=>1}).respond_to?(:next)).to eql(true)
+  end
+
+  it 'produces a char enumerator for String' do
+    enum = Puppet::Pops::Types::Enumeration.enumerator("abc")
+    expect(enum.respond_to?(:next)).to eql(true)
+    expect(enum.next).to eql('a')
+  end
+
+  it 'produces an enumerator for integer times' do
+    enum = Puppet::Pops::Types::Enumeration.enumerator(2)
+    expect(enum.next).to eql(0)
+    expect(enum.next).to eql(1)
+    expect{enum.next}.to raise_error(StopIteration)
+  end
+
+  it 'produces an enumerator for Integer range' do
+    range = Puppet::Pops::Types::TypeFactory.range(1,2)
+    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    expect(enum.next).to eql(1)
+    expect(enum.next).to eql(2)
+    expect{enum.next}.to raise_error(StopIteration)
+  end
+
+  it 'does not produce an enumerator for infinite Integer range' do
+    range = Puppet::Pops::Types::TypeFactory.range(1,:default)
+    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    expect(enum).to be_nil
+    range = Puppet::Pops::Types::TypeFactory.range(:default,2)
+    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    expect(enum).to be_nil
+  end
+
+  [3.14, /.*/, true, false, nil, :something].each do |x|
+    it "does not produce an enumerator for object of type #{x.class}" do
+      enum = Puppet::Pops::Types::Enumeration.enumerator(x)
+      expect(enum).to be_nil
+    end
+  end
+
+end