puppet 3.0.2 → 3.1.0.rc1

data/spec/integration/dsl/params_spec.rb

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

data/spec/integration/dsl/relationships_spec.rb

@@ -0,0 +1,46 @@
+require 'puppet'
+require 'spec_helper'
+require 'matchers/catalog'
+require 'puppet_spec/compiler'
+
+include PuppetSpec::Compiler
+
+describe Puppet::DSL do
+  prepare_compiler
+
+  describe "relationships" do
+    it "allows requiring resources" do
+      p = compile_to_catalog(<<-'END')
+        define foo() {
+          notify {"foo": message => "foo" }
+        }
+        define bar() {
+          notify {"bar": message => "bar" }
+        }
+
+        node "default" {
+          bar {"bar": }
+          foo {"foo": require => Bar["bar"] }
+        }
+      END
+
+      r = compile_ruby_to_catalog(<<-'END')
+        define :foo do
+          notify "foo", :message => "foo"
+        end
+
+        define :bar do
+          notify "bar", :message => "bar"
+        end
+
+        node "default" do
+          bar "bar"
+          foo "foo", :require => Bar["bar"]
+        end
+      END
+
+      r.should be_equivalent_to_catalog p
+    end
+  end
+end
+

data/spec/integration/dsl/resources_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+require 'matchers/catalog'
+require 'puppet_spec/compiler'
+
+include PuppetSpec::Compiler
+
+describe Puppet::DSL do
+  prepare_compiler
+
+  describe "resources" do
+
+    it "should be able to define resource" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo() {
+          notice("foo")
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define "foo" do
+          notice "foo"
+        end
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to define resource with parameters" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo($msg) {
+          notice($msg)
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define :foo, :arguments => {:msg => nil} do
+          notice params[:msg]
+        end
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to use defined resource" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo() {
+          notice("foo")
+        }
+
+        foo {"foo": }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define :foo do
+          notice "foo"
+        end
+
+        foo "foo"
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to use defined resource in a node" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo() {
+          notice("foo")
+        }
+
+        node default {
+          foo {"foo": }
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define :foo do
+          notice "foo"
+        end
+
+        node 'default' do
+          foo "foo"
+        end
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to use defined resource in a class" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo() {
+          notice($name)
+        }
+
+        class bar {
+          foo {"foo": }
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define :foo do
+          notice params[:name]
+        end
+
+        hostclass :bar do
+          foo "foo"
+        end
+      MANIFEST
+
+      r.should be_equivalent_to_catalog p
+    end
+
+    it "should be able to export resources" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo($msg = "bar") {
+          notify {$msg: message => $msg}
+        }
+
+        node default {
+          @@foo {"foobar":}
+
+          Foo <<| |>>
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define :foo, :arguments => {:msg => "bar"} do
+          notify params[:msg], :message => params[:msg]
+        end
+
+        node "default" do
+          export do
+            foo "foobar"
+          end
+
+          Foo.collect
+        end
+      MANIFEST
+
+      p.should be_equivalent_to_catalog r
+    end
+
+    it "should be able to virtualise resources" do
+      p = compile_to_catalog(<<-MANIFEST)
+        define foo($msg = "bar") {
+          notify {$msg: message => $msg}
+        }
+
+        node default {
+          @foo {"foobar":}
+
+          Foo <| |>
+        }
+      MANIFEST
+
+      r = compile_ruby_to_catalog(<<-MANIFEST)
+        define :foo, :arguments => {:msg => "bar"} do
+          notify params[:msg], :message => params[:msg]
+        end
+
+        node "default" do
+          virtual do
+            foo "foobar"
+          end
+
+          Foo.realise
+        end
+      MANIFEST
+
+      p.should be_equivalent_to_catalog r
+    end
+
+    context "references" do
+      before :each do
+        @catalog = compile_to_catalog(<<-MANIFEST)
+                     file {"redis.conf": owner => root}
+
+                     service {"redis": require => File['redis.conf']}
+                   MANIFEST
+      end
+
+      it "should be able to reference other resources" do
+        compile_ruby_to_catalog(<<-MANIFEST).should be_equivalent_to_catalog @catalog
+          file "redis.conf", :owner => "root"
+
+          service "redis", :require => File["redis.conf"]
+        MANIFEST
+      end
+
+      it "should be able to reference other resources using a block" do
+        r = compile_ruby_to_catalog(<<-MANIFEST).should be_equivalent_to_catalog @catalog
+          file "redis.conf", :owner => "root"
+
+          service "redis" do |s|
+            s.require = File["redis.conf"]
+          end
+        MANIFEST
+      end
+    end
+
+  end
+end
+

data/spec/integration/dsl/type_loading_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'puppet_spec/modules'
+require 'puppet_spec/files'
+
+include PuppetSpec::Compiler
+include PuppetSpec::Modules
+include PuppetSpec::Files
+
+describe Puppet::DSL do
+  def mk_manifest(file, content)
+    name = self.module.name + "::" + file.gsub("/", "::").split(".")[0]
+    path = File.join(modulebase, self.module.name, "manifests", file)
+    FileUtils.mkdir_p(File.split(path)[0])
+
+    File.open(path, "w") { |f| f.print content }
+  end
+
+  prepare_compiler
+
+  let(:modulebase) do
+    base = File.join(tmpdir("base"), "modules")
+    FileUtils.mkdir_p(base)
+    Puppet[:modulepath] = base
+    base
+  end
+
+  let(:module) { PuppetSpec::Modules.create "module", modulebase }
+
+  describe "type loader" do
+
+    it "should load ruby code when referenced from puppet" do
+      mk_manifest("foo.rb", <<-MANIFEST)
+        hostclass :'module::foo' do; end
+      MANIFEST
+
+      compile_to_catalog(<<-MANIFEST)
+        include module::foo
+      MANIFEST
+    end
+
+    it "should load ruby code when referenced from ruby" do
+      mk_manifest("bar.rb", <<-MANIFEST)
+        hostclass :'module::bar' do; end
+      MANIFEST
+
+      compile_ruby_to_catalog(<<-MANIFEST)
+        use :'module::bar'
+      MANIFEST
+    end
+
+    it "should load puppet code when referenced from ruby" do
+      mk_manifest("baz.pp", <<-MANIFEST)
+        class module::baz {}
+      MANIFEST
+
+      compile_ruby_to_catalog(<<-MANIFEST)
+        use :'module::bar'
+      MANIFEST
+    end
+
+  end
+end
+