puppet 3.0.2 → 3.1.0.rc1

data/spec/integration/application/apply_spec.rb

@@ -6,7 +6,7 @@ require 'puppet/application/apply'
 describe "apply" do
   include PuppetSpec::Files
 
-  describe "when applying provided catalogs", :if => Puppet.features.pson? do
+  describe "when applying provided catalogs" do
     it "should be able to apply catalogs provided in a file in pson" do
       file_to_create = tmpfile("pson_catalog")
       catalog = Puppet::Resource::Catalog.new

data/spec/integration/defaults_spec.rb

@@ -87,6 +87,7 @@ describe "Puppet defaults" do
 
   it "should use the service user and group for the yamldir" do
     Puppet.settings.stubs(:service_user_available?).returns true
+    Puppet.settings.stubs(:service_group_available?).returns true
     Puppet.settings.setting(:yamldir).owner.should == Puppet.settings[:user]
     Puppet.settings.setting(:yamldir).group.should == Puppet.settings[:group]
   end

data/spec/integration/dsl/classes_spec.rb

@@ -0,0 +1,191 @@
+require 'puppet'
+require 'spec_helper'
+require 'matchers/catalog'
+require 'puppet_spec/compiler'
+
+include PuppetSpec::Compiler
+
+describe Puppet::DSL do
+  prepare_compiler
+
+  describe "classes" do
+
+    it "should be able to create a class" do
+      p = compile_to_catalog(<<-MANIFEST)
+        class foo {}
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        hostclass :foo do; end
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "shouldn't evaluate the body of the class until it is used" do
+      p = compile_to_catalog(<<-MANIFEST)
+        class foo {
+          notify {"bar": }
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        hostclass :foo do
+          notify "bar"
+        end
+      MANIFEST
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to use created class" do
+      p = compile_to_catalog(<<-MANIFEST)
+        class foo {
+        }
+
+        node default {
+          include foo
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        hostclass :foo do
+        end
+
+        node "default" do
+          use :foo
+        end
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should evaluate contents of the class when the class is used" do
+      p = compile_to_catalog(<<-MANIFEST)
+        class foo {
+          notify {"bar": }
+        }
+
+        include foo
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        hostclass :foo do
+          notify "bar"
+        end
+
+        use :foo
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to create class with arguments and use them" do
+      p = compile_to_catalog(<<-MANIFEST)
+        class foo($param = "value") {}
+
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        hostclass :foo, :arguments => {:param => "value"} do; end
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to use class with arguments" do
+      p = compile_to_catalog(<<-MANIFEST)
+        class foo($param = "value") {
+          notify {"$param": }
+        }
+
+        class {"foo": param => "bar"}
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        hostclass :foo, :arguments => {:param => "value"} do
+          notify params[:param]
+        end
+
+        use :foo, :param => "bar"
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to create class with arguments with default values" do
+      p = compile_to_catalog(<<-MANIFEST)
+        class foo($param = "value") {
+          notify {"$param": }
+        }
+
+        class {"foo": param => "bar"}
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        hostclass :foo, :arguments => {:param => "value"} do
+          notify params[:param]
+        end
+
+        use :foo, :param => "bar"
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should allow inheritance" do
+      p = compile_to_catalog(<<-MANIFEST)
+        class foo {
+          notify {"foo": }
+        }
+
+        class bar inherits foo {
+          notify {"bar": }
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        hostclass :foo do
+          notify "foo"
+        end
+
+        hostclass :bar, :inherits => :foo do
+          notify "bar"
+        end
+
+        use :bar
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should allow inheritance with arguments" do
+      p = compile_to_catalog(<<-MANIFEST)
+        class foo {
+          notify {"foo": }
+        }
+
+        class bar($msg) inherits foo {
+          notify {"bar": message => $msg}
+        }
+
+        class {"bar": msg => "foobarbaz"}
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        hostclass :foo do
+          notify "foo"
+        end
+
+        hostclass :bar, :inherits => :foo, :arguments => {:msg => nil} do
+          notify "bar", :message => params[:msg]
+        end
+
+        use "bar", :msg => "foobarbaz"
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+  end
+end
+

data/spec/integration/dsl/defaults_spec.rb

@@ -0,0 +1,38 @@
+require 'puppet'
+require 'spec_helper'
+require 'matchers/catalog'
+require 'puppet_spec/compiler'
+
+include PuppetSpec::Compiler
+
+describe Puppet::DSL do
+  prepare_compiler
+
+  before :each do
+    @catalog = compile_to_catalog(<<-MANIFEST)
+                 Notify { message => "foo" }
+               MANIFEST
+  end
+
+  describe "defaults" do
+
+    it "should be able to update defaults for a resource" do
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        Notify.defaults :message => "foo"
+      MANIFEST
+
+      @catalog.should be_equivalent_to_catalog r
+    end
+
+    it "should be able to update defaults for a resource passing a block" do
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        Notify.defaults do |n|
+          n.message = "foo"
+        end
+      MANIFEST
+
+      @catalog.should be_equivalent_to_catalog r
+    end
+  end
+end
+

data/spec/integration/dsl/definitions_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'matchers/catalog'
+require 'puppet_spec/compiler'
+
+include PuppetSpec::Compiler
+
+describe Puppet::DSL do
+  prepare_compiler
+
+  describe "definitions" do
+
+    it "should be able to create the definition" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo() {
+          notify {"foo": }
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define :foo do
+          notify "foo"
+        end
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to create a resource using definition" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo() {
+          notify {"foo": }
+        }
+
+        foo {"bar": }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define :foo do
+          notify "foo"
+        end
+
+        foo "bar"
+      MANIFEST
+      r.resources.map(&:name).should include "Foo/bar"
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to create a definition with arguments" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo($name) {
+          notify {"$name": }
+        }
+
+        foo {"bar": name => "asdf"}
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define :foo, :arguments => {:name => nil} do
+          notify params[:name]
+        end
+
+        foo "bar", :name => "asdf"
+      MANIFEST
+      r.resources.map(&:name).should include "Notify/asdf"
+
+      r.should be_equivalent_to_catalog p
+
+    end
+
+  end
+end
+

data/spec/integration/dsl/functions_spec.rb

@@ -0,0 +1,95 @@
+require 'puppet'
+require 'spec_helper'
+require 'matchers/catalog'
+require 'puppet_spec/compiler'
+
+include PuppetSpec::Compiler
+
+describe Puppet::DSL do
+  prepare_compiler
+
+  describe "functions" do
+
+    it "should be able to use a function from a node" do
+      p = compile_to_catalog(<<-MANIFEST)
+        node default {
+          notice("foo")
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        node "default" do
+          notice "foo"
+        end
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to use a function from a hostclass" do
+      p = compile_to_catalog(<<-MANIFEST)
+        class foo {
+          notice("foo")
+        }
+
+        include foo
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        hostclass :foo do
+          notice "foo"
+        end
+
+        use :foo
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to use a function from a definition" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo() {
+          notice("foo")
+        }
+
+        foo {"bar": }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define :foo do
+          notice "foo"
+        end
+
+        foo "bar"
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to use a function from top level scope" do
+      p = compile_to_catalog(<<-MANIFEST)
+          notice("foo")
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+          notice "foo"
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to pass parameters to the function" do
+      p = compile_to_catalog(<<-MANIFEST)
+          notice("foo", "bar", 3)
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+          notice "foo", "bar", 3
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+  end
+end
+

data/spec/integration/dsl/nodes_spec.rb

@@ -0,0 +1,96 @@
+require 'puppet'
+require 'spec_helper'
+require 'matchers/catalog'
+require 'puppet_spec/compiler'
+
+include PuppetSpec::Compiler
+
+describe Puppet::DSL do
+  prepare_compiler
+
+  describe "nodes" do
+
+    it "should be able to create default node" do
+      p = compile_to_catalog(<<-MANIFEST)
+        node default {
+          notify{"foo": }
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        node "default" do
+          notify "foo"
+        end
+      MANIFEST
+      r.resources.map(&:name).should include "Notify/foo"
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to create named node" do
+      p = compile_to_catalog(<<-MANIFEST)
+        node "foonode" {
+          notify{"foo": }
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        node "foonode" do
+          notify "foo"
+        end
+      MANIFEST
+      r.resources.map(&:name).should include "Notify/foo"
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to create node with regexp" do
+      p = compile_to_catalog(<<-MANIFEST)
+        node /^foo/ {
+          notify{"foo": }
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        node /^foo/ do
+          notify "foo"
+        end
+      MANIFEST
+      r.resources.map(&:name).should include "Notify/foo"
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to create node inheriting from another node" do
+      p = compile_to_catalog(<<-MANIFEST)
+        node "base.example.com" {
+          notify {"base": }
+        }
+
+        node "foonode" inherits "base.example.com" {
+          notify {"foonode": }
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        node "base.example.com" do
+          notify "base"
+        end
+
+        node "foonode", :inherits => "base.example.com" do
+          notify "foonode"
+        end
+      MANIFEST
+
+      r.resources.map(&:name).tap do |names|
+        %w[base foonode].each do |node_name|
+          names.should include "Notify/#{node_name}"
+        end
+      end
+
+      r.should be_equivalent_to_catalog p
+    end
+
+  end
+end
+