puppet 3.1.0.rc1 → 3.1.0.rc2

data/spec/integration/dsl/defaults_spec.rb

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

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

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

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

data/spec/integration/dsl/params_spec.rb

@@ -1,146 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'matchers/catalog'
-require 'puppet_spec/compiler'
-
-include PuppetSpec::Compiler
-
-describe Puppet::DSL do
-  prepare_compiler
-
-  describe "params" do
-
-    it "should be able to set and read a variable" do
-      p = compile_to_catalog(<<-MANIFEST)
-        node default {
-          $asdf = "foo"
-
-          notify {"$asdf": }
-        }
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        node "default" do
-          params[:asdf] = "foo"
-
-          notify params[:asdf]
-        end
-      MANIFEST
-      r.resources.map(&:name).should include "Notify/foo"
-
-      r.should be_equivalent_to_catalog p
-    end
-
-    it "should be able to read params for a resource" do
-      p = compile_to_catalog(<<-MANIFEST)
-        define foo($msg) {
-          notify {"$msg": }
-        }
-
-        foo {"foo": msg => "asdf"}
-      MANIFEST
-
-      r = compile_ruby_to_catalog(<<-MANIFEST)
-        define :foo, :arguments => {:msg => nil} do
-          notify params[:msg]
-        end
-
-        foo :foo, :msg => "asdf"
-      MANIFEST
-      r.resources.map(&:name).should include "Notify/asdf"
-
-      r.should be_equivalent_to_catalog p
-    end
-
-    context "defined in outer scope" do
-      it "should available in inner scope" do
-        p = compile_to_catalog(<<-MANIFEST)
-          $foobar = "baz"
-          define foo() {
-            notify {"$foobar": }
-          }
-
-          foo {"foo": }
-        MANIFEST
-
-        r = compile_ruby_to_catalog(<<-MANIFEST)
-          params[:foobar] = "baz"
-
-          define :foo do
-            notify params[:foobar]
-          end
-
-          foo :foo
-        MANIFEST
-        r.resources.map(&:name).should include "Notify/baz"
-
-        r.should be_equivalent_to_catalog p
-      end
-
-      it "should be overwritten in inner scope" do
-        p = compile_to_catalog(<<-MANIFEST)
-          $foobar = "baz"
-          define foo() {
-            $foobar = "asdf"
-            notify {"$foobar": }
-          }
-
-          foo {"foo": }
-        MANIFEST
-
-        r = compile_ruby_to_catalog(<<-MANIFEST)
-          params[:foobar] = "baz"
-
-          define :foo do
-            params[:foobar] = "asdf"
-            notify params[:foobar]
-          end
-
-          foo :foo
-        MANIFEST
-        r.resources.map(&:name).should include "Notify/asdf"
-
-        r.should be_equivalent_to_catalog p
-      end
-
-      it "should not be overwritten in outer scope" do
-        p = compile_to_catalog(<<-MANIFEST)
-          $foobar = "baz"
-          define foo() {
-            $foobar = "asdf"
-            notify {"$foobar": }
-          }
-
-          notify {"$foobar": }
-
-          foo {"foo": }
-        MANIFEST
-
-        r = compile_ruby_to_catalog(<<-MANIFEST)
-          params[:foobar] = "baz"
-
-          define :foo do
-            params[:foobar] = "asdf"
-            notify params[:foobar]
-          end
-
-          notify params[:foobar]
-
-          foo :foo
-        MANIFEST
-        r.resources.map(&:name).tap do |names|
-          %w[asdf baz].each do |name|
-            names.should include "Notify/#{name}"
-          end
-        end
-
-        r.should be_equivalent_to_catalog p
-
-
-      end
-
-    end
-
-  end
-end
-