puppet 3.1.1 → 3.2.0.rc1

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

@@ -0,0 +1,182 @@
+#! /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.
+        astdump(parse("class class {}")).should == "(class class ())"
+      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.)
+        #
+        astdump(parse("class class inherits default {}")).should == "(class class::class (inherits default) ())"
+      end
+
+      it "class foo inherits class" do
+        astdump(parse("class foo inherits class {}")).should == "(class foo (inherits class) ())"
+      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
+        astdump(parse("define class {}")).should == "(define class ())"
+      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
+      expect { parse("node wat inherits /apache.*/ {}")}.to raise_error(Puppet::ParseError)
+    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/visitor_spec.rb

@@ -0,0 +1,94 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+describe Puppet::Pops::Visitor do
+  describe "A visitor and a visitable in a configuration with min and max args set to 0" do
+    class DuckProcessor
+      def initialize
+        @friend_visitor = Puppet::Pops::Visitor.new(self, "friend", 0, 0)
+      end
+
+      def hi(o, *args)
+        @friend_visitor.visit(o, *args)
+      end
+
+      def friend_Duck(o)
+        "Hi #{o.class}"
+      end
+
+      def friend_Numeric(o)
+        "Howdy #{o.class}"
+      end
+    end
+
+    class Duck
+      include Puppet::Pops::Visitable
+    end
+
+    it "should select the expected method when there are no arguments" do
+      duck = Duck.new
+      duck_processor = DuckProcessor.new
+      duck_processor.hi(duck).should == "Hi Duck"
+    end
+
+    it "should fail if there are too many arguments" do
+      duck = Duck.new
+      duck_processor = DuckProcessor.new
+      expect { duck_processor.hi(duck, "how are you?") }.to raise_error(/^Visitor Error: Too many.*/)
+    end
+
+    it "should select method for superclass" do
+      duck_processor = DuckProcessor.new
+      duck_processor.hi(42).should == "Howdy Fixnum"
+    end
+
+    it "should select method for superclass" do
+      duck_processor = DuckProcessor.new
+      duck_processor.hi(42.0).should == "Howdy Float"
+    end
+
+    it "should fail if class not handled" do
+      duck_processor = DuckProcessor.new
+      expect { duck_processor.hi("wassup?") }.to raise_error(/Visitor Error: the configured.*/)
+    end
+  end
+
+  describe "A visitor and a visitable in a configuration with min =1, and max args set to 2" do
+    class DuckProcessor2
+      def initialize
+        @friend_visitor = Puppet::Pops::Visitor.new(self, "friend", 1, 2)
+      end
+
+      def hi(o, *args)
+        @friend_visitor.visit(o, *args)
+      end
+
+      def friend_Duck(o, drink, eat="grain")
+        "Hi #{o.class}, drink=#{drink}, eat=#{eat}"
+      end
+    end
+
+    class Duck
+      include Puppet::Pops::Visitable
+    end
+
+    it "should select the expected method when there are is one arguments" do
+      duck = Duck.new
+      duck_processor = DuckProcessor2.new
+      duck_processor.hi(duck, "water").should == "Hi Duck, drink=water, eat=grain"
+    end
+
+    it "should fail if there are too many arguments" do
+      duck = Duck.new
+      duck_processor = DuckProcessor2.new
+      expect { duck_processor.hi(duck, "scotch", "soda", "peanuts") }.to raise_error(/^Visitor Error: Too many.*/)
+    end
+
+    it "should fail if there are too few arguments" do
+      duck = Duck.new
+      duck_processor = DuckProcessor2.new
+      expect { duck_processor.hi(duck) }.to raise_error(/^Visitor Error: Too few.*/)
+    end
+  end
+end