puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

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

@@ -1,115 +0,0 @@
-#! /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 function calls" do
-  include TransformerRspecHelper
-
-  context "When transforming calls as statements" do
-    context "in top level scope" do
-      it "foo()" do
-        astdump(parse("foo()")).should == "(invoke foo)"
-      end
-
-      it "notice bar" do
-        astdump(parse("notice bar")).should == "(invoke notice bar)"
-      end
-    end
-
-    context "in nested scopes" do
-      it "if true { foo() }" do
-        astdump(parse("if true {foo()}")).should == "(if true\n  (then (invoke foo)))"
-      end
-
-      it "if true { notice bar}" do
-        astdump(parse("if true {notice bar}")).should == "(if true\n  (then (invoke notice bar)))"
-      end
-    end
-    context "in general" do
-      {
-        "require bar"      => '(invoke require bar)',
-        "realize bar"      => '(invoke realize bar)',
-        "contain bar"      => '(invoke contain bar)',
-        "include bar"      => '(invoke include bar)',
-        "tag bar"          => '(invoke tag bar)',
-
-        "info bar"         => '(invoke info bar)',
-        "notice bar"       => '(invoke notice bar)',
-        "err bar"          => '(invoke err bar)',
-        "warning bar"      => '(invoke warning bar)',
-        "debug bar"        => '(invoke debug bar)',
-
-        "fail bar"         => '(invoke fail bar)',
-
-        "notice {a => 1}"  => "(invoke notice ({} ('a' 1)))",
-        "notice 1,2,3"     => "(invoke notice 1 2 3)",
-        "notice(1,2,3)"    => "(invoke notice 1 2 3)",
-      }.each do |source, result|
-        it "should transform #{source} to #{result}" do
-          astdump(parse(source)).should == result
-        end
-      end
-
-      {
-        "foo bar"      => '(block foo bar)',
-        "tag"          => 'tag',
-      }.each do |source, result|
-        it "should not transform #{source}, and instead produce #{result}" do
-          astdump(parse(source)).should == result
-        end
-      end
-
-    end
-  end
-
-  context "When transforming calls as expressions" do
-    it "$a = foo()" do
-      astdump(parse("$a = foo()")).should == "(= $a (call foo))"
-    end
-
-    it "$a = foo(bar)" do
-      astdump(parse("$a = foo()")).should == "(= $a (call foo))"
-    end
-
-    # For egrammar where a bare word can be a "statement"
-    it "$a = foo bar # assignment followed by bare word is ok in egrammar" do
-      astdump(parse("$a = foo bar")).should == "(block (= $a foo) bar)"
-    end
-
-    context "in nested scopes" do
-      it "if true { $a = foo() }" do
-        astdump(parse("if true { $a = foo()}")).should == "(if true\n  (then (= $a (call foo))))"
-      end
-
-      it "if true { $a= foo(bar)}" do
-        astdump(parse("if true {$a = foo(bar)}")).should == "(if true\n  (then (= $a (call foo bar))))"
-      end
-    end
-  end
-
-  context "When transforming method calls" do
-    it "$a.foo" do
-      astdump(parse("$a.foo")).should == "(call-method (. $a foo))"
-    end
-
-    it "$a.foo || { }" do
-      astdump(parse("$a.foo || { }")).should == "(call-method (. $a foo) (lambda ()))"
-    end
-
-    it "$a.foo ||{[]} # check transformation to block with empty array" do
-      astdump(parse("$a.foo || {[]}")).should == "(call-method (. $a foo) (lambda (block ([]))))"
-    end
-
-    it "$a.foo |$x| { }" do
-      astdump(parse("$a.foo |$x| { }")).should == "(call-method (. $a foo) (lambda (parameters x) ()))"
-    end
-
-    it "$a.foo |$x| { $b = $x}" do
-      astdump(parse("$a.foo |$x| { $b = $x}")).should ==
-      "(call-method (. $a foo) (lambda (parameters x) (block (= $b $x))))"
-    end
-  end
-end

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

@@ -1,123 +0,0 @@
-#! /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 conditionals" do
-  include TransformerRspecHelper
-
-  context "When transforming if statements" do
-    it "if true { $a = 10 }" do
-      astdump(parse("if true { $a = 10 }")).should == "(if true\n  (then (= $a 10)))"
-    end
-
-    it "if true { $a = 10 } else {$a = 20}" do
-      astdump(parse("if true { $a = 10 } else {$a = 20}")).should ==
-      ["(if true",
-        "  (then (= $a 10))",
-        "  (else (= $a 20)))"].join("\n")
-    end
-
-    it "if true { $a = 10 } elsif false { $a = 15} else {$a = 20}" do
-      astdump(parse("if true { $a = 10 } elsif false { $a = 15} else {$a = 20}")).should ==
-      ["(if true",
-        "  (then (= $a 10))",
-        "  (else (if false",
-        "      (then (= $a 15))",
-        "      (else (= $a 20)))))"].join("\n")
-    end
-
-    it "if true { $a = 10 $b = 10 } else {$a = 20}" do
-      astdump(parse("if true { $a = 10 $b = 20} else {$a = 20}")).should ==
-      ["(if true",
-        "  (then (block (= $a 10) (= $b 20)))",
-        "  (else (= $a 20)))"].join("\n")
-    end
-  end
-
-  context "When transforming unless statements" do
-    # Note that Puppet 3.1 does not have an "unless x", it is encoded as "if !x"
-    it "unless true { $a = 10 }" do
-      astdump(parse("unless true { $a = 10 }")).should == "(if (! true)\n  (then (= $a 10)))"
-    end
-
-    it "unless true { $a = 10 } else {$a = 20}" do
-      astdump(parse("unless true { $a = 10 } else {$a = 20}")).should ==
-      ["(if (! true)",
-        "  (then (= $a 10))",
-        "  (else (= $a 20)))"].join("\n")
-    end
-
-    it "unless true { $a = 10 } elsif false { $a = 15} else {$a = 20} # is illegal" do
-      expect { parse("unless true { $a = 10 } elsif false { $a = 15} else {$a = 20}")}.to raise_error(Puppet::ParseError)
-    end
-  end
-
-  context "When transforming selector expressions" do
-    it "$a = $b ? banana => fruit " do
-      astdump(parse("$a = $b ? banana => fruit")).should ==
-      "(= $a (? $b (banana => fruit)))"
-    end
-
-    it "$a = $b ? { banana => fruit}" do
-      astdump(parse("$a = $b ? { banana => fruit }")).should ==
-      "(= $a (? $b (banana => fruit)))"
-    end
-
-    it "$a = $b ? { banana => fruit, grape => berry }" do
-      astdump(parse("$a = $b ? {banana => fruit, grape => berry}")).should ==
-      "(= $a (? $b (banana => fruit) (grape => berry)))"
-    end
-
-    it "$a = $b ? { banana => fruit, grape => berry, default => wat }" do
-      astdump(parse("$a = $b ? {banana => fruit, grape => berry, default => wat}")).should ==
-      "(= $a (? $b (banana => fruit) (grape => berry) (:default => wat)))"
-    end
-
-    it "$a = $b ? { default => wat, banana => fruit, grape => berry,  }" do
-      astdump(parse("$a = $b ? {default => wat, banana => fruit, grape => berry}")).should ==
-      "(= $a (? $b (:default => wat) (banana => fruit) (grape => berry)))"
-    end
-  end
-
-  context "When transforming case statements" do
-    it "case $a { a : {}}" do
-      astdump(parse("case $a { a : {}}")).should ==
-      ["(case $a",
-        "  (when (a) (then ())))"
-      ].join("\n")
-    end
-
-    it "case $a { /.*/ : {}}" do
-      astdump(parse("case $a { /.*/ : {}}")).should ==
-      ["(case $a",
-        "  (when (/.*/) (then ())))"
-      ].join("\n")
-    end
-
-    it "case $a { a, b : {}}" do
-      astdump(parse("case $a { a, b : {}}")).should ==
-      ["(case $a",
-        "  (when (a b) (then ())))"
-      ].join("\n")
-    end
-
-    it "case $a { a, b : {} default : {}}" do
-      astdump(parse("case $a { a, b : {} default : {}}")).should ==
-      ["(case $a",
-        "  (when (a b) (then ()))",
-        "  (when (:default) (then ())))"
-      ].join("\n")
-    end
-
-    it "case $a { a : {$b = 10 $c = 20}}" do
-      astdump(parse("case $a { a : {$b = 10 $c = 20}}")).should ==
-      ["(case $a",
-        "  (when (a) (then (block (= $b 10) (= $c 20)))))"
-      ].join("\n")
-    end
-  end
-
-end

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

@@ -1,190 +0,0 @@
-#! /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/transformer_rspec_helper.rb

@@ -1,27 +0,0 @@
-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