puppet 3.1.0.rc1 → 3.1.0.rc2

data/spec/unit/dsl/parser_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/dsl'
-require 'puppet/dsl/parser'
-include PuppetSpec::DSL
-
-describe Puppet::DSL::Parser do
-  prepare_compiler_and_scope_for_evaluation
-
-  describe "scope" do
-    it "should allow to access current scope" do
-      scope = mock
-      scope.stubs(:known_resource_types)
-      evaluate_in_scope :scope => scope do
-        Puppet::DSL::Parser.current_scope.should be scope
-      end
-    end
-
-    it "should fail when trying to remove scope from empty stack" do
-      lambda do
-        Puppet::DSL::Parser.remove_scope
-      end.should raise_error RuntimeError
-    end
-
-    it "allows to add and remove a scope" do
-      scope = mock
-      Puppet::DSL::Parser.add_scope scope
-      Puppet::DSL::Parser.current_scope.should be scope
-      Puppet::DSL::Parser.remove_scope
-      Puppet::DSL::Parser.current_scope.should be nil
-    end
-  end
-
-  describe "#evaluate" do
-    let(:filename)  { "testfile" }
-    let(:string)    { "test" }
-    let(:ruby_code) { Array.new   }
-    let(:main)      { mock "main" }
-    subject         { Puppet::DSL::Parser }
-
-    it "sets ruby_code for main object" do
-      main.expects(:ruby_code).returns ruby_code
-      subject.prepare_for_evaluation main, string, filename
-      ruby_code.count.should == 1
-    end
-
-    it "sets parsed file's filename for ruby dsl" do
-      main.stubs(:ruby_code).returns ruby_code
-      subject.prepare_for_evaluation main, string, filename
-
-      ruby_code.first.inspect.should == filename.inspect
-    end
-
-  end
-
-end
-

data/spec/unit/dsl/resource_decorator_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/dsl'
-require 'puppet/resource'
-require 'puppet/dsl/resource_decorator'
-
-include PuppetSpec::DSL
-
-describe Puppet::DSL::ResourceDecorator do
-  it "should yield resource proxy to a block" do
-    Puppet::DSL::ResourceDecorator.new mock do |r|
-      # there is no way to test whether r is a ResourceDecorator instance due to
-      # BlankSlate class nature, so I only test that something is yielded to
-      # a block
-      expect {r}.not_to be_nil
-    end
-  end
-
-  context "when accessing" do
-    let(:resource) { mock "Resource" }
-
-    describe "getting" do
-      it "should proxy messages to a resource" do
-        resource.expects(:[]).with(:param).returns 42
-
-        Puppet::DSL::ResourceDecorator.new resource do |r|
-          r.param.should == 42
-        end
-      end
-
-
-      it "should cache methods for future use" do
-        resource.expects(:[]).twice.with(:foobar).returns 42
-
-        Puppet::DSL::ResourceDecorator.new resource do |r|
-          r.foobar.should == 42
-          r.foobar.should == 42
-        end
-      end
-    end
-
-    describe "setting" do
-      prepare_compiler_and_scope_for_evaluation
-      it "should proxy get messages to a resource" do
-        resource.expects(:[]=).with :param, '42'
-
-        Puppet::DSL::ResourceDecorator.new resource do |r|
-          r.param = 42
-        end
-      end
-
-      it "should call `reference' on resource references" do
-        evaluate_in_context { notify "bar" }
-
-        resource.expects(:[]=).with :param, "Notify[bar]"
-        ref = evaluate_in_context { Puppet::DSL::Context::Notify["bar"] }
-        Puppet::DSL::ResourceDecorator.new resource do |r|
-          r.param = ref
-        end
-      end
-
-      it "should cache methods for future use" do
-        resource.expects(:[]=).twice.with :foobar, '42'
-
-        Puppet::DSL::ResourceDecorator.new resource do |r|
-          r.foobar = 42
-          r.foobar = 42
-        end
-      end
-
-      it "doesn't convert values to string when resource is given" do
-        value = Puppet::Parser::Resource.new "test", "whatever", {:scope => scope}
-        value.expects(:to_s).never
-        resource.expects(:[]=)
-
-        Puppet::DSL::ResourceDecorator.new resource do |r|
-          r.key = value
-        end
-      end
-
-      it "converts values to string when unless resource is given" do
-        value = mock
-        value.expects :to_s
-        resource.expects :[]=
-
-        Puppet::DSL::ResourceDecorator.new resource do |r|
-          r.foo = value
-        end
-      end
-
-    end
-  end
-
-end
-

data/spec/unit/dsl/resource_reference_spec.rb

@@ -1,150 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/dsl'
-require 'puppet/dsl/resource_reference'
-include PuppetSpec::DSL
-
-describe Puppet::DSL::ResourceReference do
-  prepare_compiler_and_scope_for_evaluation
-  let(:typeref) { Puppet::DSL::TypeReference.new "notify" }
-
-  describe "#initialize" do
-
-    it "should validate resource existance" do
-      scope.expects(:findresource).returns(!nil)
-      evaluate_in_scope do
-        Puppet::DSL::ResourceReference.new typeref, "foo"
-      end
-    end
-
-    it "should raise ArgumentError when resource doesn't exist" do
-      scope.expects(:findresource).returns nil
-      evaluate_in_scope do
-        lambda do
-          Puppet::DSL::ResourceReference.new typeref, "foo"
-        end.should raise_error ArgumentError
-      end
-    end
-
-  end
-
-  describe "#reference" do
-    before :each do
-      evaluate_in_context { notify "foo" }
-    end
-
-    it "should return string reference of a resource" do
-      evaluate_in_scope do
-        Puppet::DSL::ResourceReference.new(typeref, "foo").reference.should == "Notify[foo]"
-      end
-    end
-
-    it "should be aliased to #to_s" do
-      evaluate_in_scope do
-        r = Puppet::DSL::ResourceReference.new(typeref, "foo")
-        r.reference.should == r.to_s
-      end
-    end
-
-  end
-
-  describe "#override" do
-    before :each do
-      evaluate_in_context { notify "foo" }
-    end
-
-    it "should create new resource override" do
-      evaluate_in_scope do
-        r = Puppet::DSL::ResourceReference.new typeref, "foo"
-        r.override :message => "asdf"
-        r.resource[:message].should == "asdf"
-      end
-    end
-
-    it "should return the override" do
-      evaluate_in_scope do
-        Puppet::DSL::ResourceReference.new(typeref, "foo").
-          override(:message => "bar").should == {:message => "bar"}
-      end
-    end
-
-    it "should allow passing a hash" do
-      evaluate_in_scope do
-        lambda do
-          Puppet::DSL::ResourceReference.new(typeref, "foo").
-            override(:message => "foobar").should == {:message => "foobar"}
-        end.should_not raise_error
-      end
-    end
-
-    it "should allow passing a block" do
-      evaluate_in_scope do
-        Puppet::DSL::ResourceReference.new(typeref, "foo").override do |foo|
-          foo.message = "foobarbaz"
-        end.should == {:message => "foobarbaz"}
-      end
-    end
-
-    it "should allow passing both block and a hash; block overwrites hash" do
-      evaluate_in_scope do
-        Puppet::DSL::ResourceReference.new(typeref, "foo").
-          override(:message => "foobar") do |foo|
-          foo.message = "foobarbaz"
-          end.should == {:message => "foobarbaz"}
-      end
-    end
-
-    it "should raise ArgumentError when neither block or hash is passed" do
-      evaluate_in_scope do
-        lambda do
-          Puppet::DSL::ResourceReference.new(typeref, "foo").override
-        end.should raise_error ArgumentError
-      end
-
-    end
-  end
-
-  describe "#realize" do
-
-    it "realizes the resource if it was virtual" do
-      evaluate_in_context { virtual notify "foobarbaz" }
-      evaluate_in_scope do
-        Puppet::DSL::ResourceReference.new(typeref, "foobarbaz").realize
-      end
-
-      scope.compiler.collections.map(&:resources).flatten.map(&:name).should include "foobarbaz"
-    end
-
-    it "does nothing when the resource is not virtual" do
-      evaluate_in_context { notify "foobarbaz" }
-      evaluate_in_scope do
-        Puppet::DSL::ResourceReference.new(typeref, "foobarbaz").realize
-      end
-
-      scope.compiler.collections.map(&:resources).flatten.map(&:name).should_not include "foobarbaz"
-    end
-  end
-
-  describe "#collect" do
-
-    it "collects the resource if it was exported" do
-      evaluate_in_context { export notify "foobarbaz" }
-      evaluate_in_scope do
-        Puppet::DSL::ResourceReference.new(typeref, "foobarbaz").collect
-      end
-
-      scope.compiler.collections.map(&:resources).flatten.map(&:name).should include "foobarbaz"
-    end
-
-    it "does nothein when resource is not exported" do
-      evaluate_in_context { notify "foobarbaz" }
-      evaluate_in_scope do
-        Puppet::DSL::ResourceReference.new(typeref, "foobarbaz").collect
-      end
-
-      scope.compiler.collections.map(&:resources).flatten.map(&:name).should_not include "foobarbaz"
-    end
-
-  end
-
-end
-

data/spec/unit/dsl/type_reference_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/dsl'
-require 'puppet/dsl/type_reference'
-include PuppetSpec::DSL
-
-describe Puppet::DSL::TypeReference do
-  prepare_compiler_and_scope_for_evaluation
-
-  describe "#initialize" do
-
-    it "should return a type reference" do
-      Puppet::DSL::Context.stubs(:const_defined?).returns true
-
-      Puppet::DSL::TypeReference.new("name").should_not be nil
-    end
-
-    it "should check whether the type exists" do
-      Puppet::DSL::Context.expects(:const_defined?).returns true
-
-      lambda do
-        Puppet::DSL::TypeReference.new "name"
-      end.should_not raise_error NameError
-    end
-
-    it "should raise NameError when the type doesn't exist" do
-      Puppet::DSL::Context.expects(:const_defined?).returns false
-      lambda do
-        Puppet::DSL::TypeReference.new "name"
-      end.should raise_error NameError
-    end
-
-    it "should canonize type name" do
-      Puppet::DSL::Context.stubs(:const_defined?).returns true
-      Puppet::DSL::TypeReference.new("name").type_name.should == "Name"
-    end
-
-  end
-
-  describe "#[]" do
-    let(:reference) { Puppet::DSL::TypeReference.new "notify" }
-
-    it "should return new ResourceReference instance" do
-      evaluate_in_context do
-        notify "test"
-      end
-
-      evaluate_in_scope do
-        reference["test"].should be_a Puppet::DSL::ResourceReference
-      end
-    end
-
-    it "should raise ArgumentError when the resource doesn't exist" do
-      evaluate_in_scope do
-        lambda do
-          reference["asdf"]
-        end.should raise_error ArgumentError
-      end
-    end
-
-    it "should cache created references" do
-      evaluate_in_context do
-        notify "test"
-      end
-
-      evaluate_in_scope do
-        resource = reference["test"]
-        resource.object_id.should be_equal reference["test"].object_id
-      end
-    end
-
-  end
-
-  describe "#collect" do
-    it "should create a new exported collection" do
-      evaluate_in_context do
-        Puppet::DSL::Context::Notify.collect
-      end
-      compiler.collections.map do |c|
-        [c.type, c.form]
-      end.should include ["Notify", :exported]
-    end
-
-    it "should return the created collection" do
-      evaluate_in_context do
-        Puppet::DSL::Context::Notify.collect
-      end.should be_a Puppet::Parser::Collector
-    end
-
-  end
-
-  describe "#realize" do
-    it "should create a new virtual collection" do
-      evaluate_in_context do
-        Puppet::DSL::Context::Notify.realize
-      end
-      compiler.collections.map do |c|
-        [c.type, c.form]
-      end.should include ["Notify", :virtual]
-    end
-
-    it "should return the created collection" do
-      evaluate_in_context do
-        Puppet::DSL::Context::Notify.realize
-      end.should be_a Puppet::Parser::Collector
-    end
-
-  end
-
-  describe "#defaults" do
-
-    it "should apply defaults for a type" do
-      evaluate_in_context do
-        Puppet::DSL::Context::Notify.defaults :message => 42
-      end
-      scope.lookupdefaults("Notify").should have_key :message
-    end
-
-    it "should return current defaults" do
-      evaluate_in_context do
-        Puppet::DSL::Context::Notify.defaults :message => 42
-      end.should == {:message => 42}
-    end
-
-    it "should return current defaults when called without arguments" do
-      evaluate_in_context do
-        Puppet::DSL::Context::Notify.defaults :message => 42
-        Puppet::DSL::Context::Notify.defaults
-      end.should == {:message => 42}
-    end
-
-    it "should allow to pass a hash" do
-      lambda do
-        evaluate_in_context do
-          Puppet::DSL::Context::Notify.defaults :message => 42
-        end
-      end.should_not raise_error
-    end
-
-    it "should allow to pass a block" do
-      lambda do
-        evaluate_in_context do
-          Puppet::DSL::Context::Notify.defaults do |d|
-            d.message = 42
-          end
-        end
-      end.should_not raise_error
-    end
-
-    it "should allow passing both hash and block; block overwrites hash" do
-      lambda do
-        evaluate_in_context do
-          Puppet::DSL::Context::Notify.defaults :message => 30 do |d|
-            d.message = 42
-          end
-        end.should == {:message => '42'}
-      end.should_not raise_error
-
-    end
-
-  end
-
-
-end
-