mcollective-client 2.0.0 → 2.2.0

data/spec/unit/data_spec.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Data do
+    describe "#load_data_sources" do
+      it "should use the pluginmanager to load data sources" do
+        PluginManager.expects(:find_and_load).with("data").returns([])
+        Data.load_data_sources
+      end
+
+      it "should remove plugins that should not be active on this node" do
+        PluginManager.expects(:find_and_load).with("data").returns(["rspec_data"])
+        PluginManager.expects(:grep).returns(["rspec_data"])
+        PluginManager.expects(:delete).with("rspec_data")
+
+        ddl = mock
+        ddl.stubs(:meta).returns({:timeout => 1})
+        DDL.stubs(:new).returns(ddl)
+        Data::Base.expects(:activate?).returns(false)
+        PluginManager.expects("[]").with("rspec_data").returns(Data::Base.new)
+        Data.load_data_sources
+      end
+
+      it "should handle exceptions and delete broken plugins" do
+        PluginManager.expects(:find_and_load).with("data").returns(["rspec_data"])
+        PluginManager.expects(:grep).returns(["rspec_data"])
+        PluginManager.expects(:delete).with("rspec_data")
+
+        ddl = mock
+        ddl.stubs(:meta).returns({:timeout => 1})
+        DDL.stubs(:new).returns(ddl)
+        Data::Base.expects(:activate?).raises("rspec failure")
+        Log.expects(:debug).once.with("Disabling data plugin rspec_data due to exception RuntimeError: rspec failure")
+        PluginManager.expects("[]").with("rspec_data").returns(Data::Base.new)
+        Data.load_data_sources
+      end
+    end
+
+    describe "#ddl" do
+      it "should load the right data ddl" do
+        DDL.expects(:new).with("fstat_data", :data).times(3)
+        Data.ddl("fstat")
+        Data.ddl("fstat_data")
+        Data.ddl(:fstat)
+      end
+    end
+
+    describe "#pluginname" do
+      it "should return the correct plugin name" do
+        Data.pluginname("Rspec").should == "rspec_data"
+        Data.pluginname("Rspec_data").should == "rspec_data"
+      end
+    end
+
+    describe "#[]" do
+      it "should return the correct plugin" do
+        PluginManager.expects("[]").with("rspec_data").times(4)
+        Data["Rspec"]
+        Data["rspec"]
+        Data["rspec_data"]
+        Data["rspec_Data"]
+      end
+    end
+
+    describe "#method_missing" do
+      it "should raise errors for unknown plugins" do
+        PluginManager.expects("include?").with("rspec_data").returns(false)
+        expect { Data.rspec_data }.to raise_error(NoMethodError)
+      end
+
+      it "should do a lookup on the right plugin" do
+        rspec_data = mock
+        rspec_data.expects(:lookup).returns("rspec")
+
+        PluginManager.expects("include?").with("rspec_data").returns(true)
+        PluginManager.expects("[]").with("rspec_data").returns(rspec_data)
+
+        Data.rspec_data("rspec").should == "rspec"
+      end
+    end
+
+    describe "#ddl_transform_intput" do
+      it "should convert boolean data" do
+        ddl = mock
+        ddl.stubs(:entities).returns({:data => {:input => {:query => {:type => :boolean}}}})
+        Data.ddl_transform_input(ddl, "1").should == true
+        Data.ddl_transform_input(ddl, "0").should == false
+      end
+
+      it "should conver numeric data" do
+        ddl = mock
+        ddl.stubs(:entities).returns({:data => {:input => {:query => {:type => :number}}}})
+        Data.ddl_transform_input(ddl, "1").should == 1
+        Data.ddl_transform_input(ddl, "0").should == 0
+        Data.ddl_transform_input(ddl, "1.1").should == 1.1
+      end
+
+      it "should return the original input on any failure" do
+        ddl = mock
+        ddl.expects(:entities).raises("rspec failure")
+        Data.ddl_transform_input(ddl, 1).should == 1
+      end
+    end
+
+    describe "#ddl_has_output?" do
+      it "should correctly verify output keys" do
+        ddl = mock
+        ddl.stubs(:entities).returns({:data => {:output => {:rspec => {}}}})
+        Data.ddl_has_output?(ddl, "rspec").should == true
+        Data.ddl_has_output?(ddl, :rspec).should == true
+        Data.ddl_has_output?(ddl, :foo).should == false
+        Data.ddl_has_output?(ddl, "foo").should == false
+      end
+
+      it "should return false for any exception" do
+        ddl = mock
+        ddl.stubs(:entities).returns(nil)
+        Data.ddl_has_output?(ddl, "rspec").should == false
+      end
+    end
+
+    describe "#ddl_validate" do
+      before do
+        @ddl = mock
+        @ddl.expects(:meta).returns({:name => "rspec test"})
+      end
+
+      it "should ensure the ddl has a dataquery" do
+        @ddl.expects(:entities).returns({})
+        expect { Data.ddl_validate(@ddl, "rspec") }.to raise_error("No dataquery has been defined in the DDL for data plugin rspec test")
+      end
+
+      it "should ensure the ddl has an input" do
+        @ddl.expects(:entities).returns({:data => {:input => {}, :output => {}}})
+        expect { Data.ddl_validate(@ddl, "rspec") }.to raise_error("No :query input has been defined in the DDL for data plugin rspec test")
+      end
+
+      it "should ensure the ddl has output" do
+        @ddl.expects(:entities).returns({:data => {:input => {:query => {}}, :output => {}}})
+        expect { Data.ddl_validate(@ddl, "rspec") }.to raise_error("No output has been defined in the DDL for data plugin rspec test")
+      end
+
+      it "should skip optional arguments that were not supplied" do
+        @ddl.expects(:entities).returns({:data => {:input => {:query => {:optional => true}}, :output => {:test => {}}}})
+        @ddl.expects(:validate_input_argument).never
+        Data.ddl_validate(@ddl, nil).should == true
+      end
+
+      it "should validate the argument" do
+        @ddl.expects(:entities).returns({:data => {:input => {:query => {}}, :output => {:test => {}}}})
+        @ddl.expects(:validate_input_argument).returns("rspec validated")
+        Data.ddl_validate(@ddl, "rspec").should == "rspec validated"
+      end
+    end
+  end
+end

data/spec/unit/ddl/agentddl_spec.rb

@@ -0,0 +1,217 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module DDL
+    describe AgentDDL do
+      before :each do
+        Cache.delete!(:ddl) rescue nil
+        @ddl = DDL.new("rspec", :agent, false)
+        @ddl.metadata(:name => "name", :description => "description", :author => "author", :license => "license", :version => "version", :url => "url", :timeout => "timeout")
+      end
+
+      describe "#input" do
+        it "should validate that an :optional property is set" do
+          expect { @ddl.input(:x, {:y => 1}) }.to raise_error("Input needs a :optional property")
+        end
+      end
+
+      describe "#validate_rpc_request" do
+        it "should ensure the action is known" do
+          @ddl.action(:test, :description => "rspec")
+
+          expect {
+            @ddl.validate_rpc_request(:fail, {})
+          }.to raise_error("Attempted to call action fail for rspec but it's not declared in the DDL")
+
+          @ddl.validate_rpc_request(:test, {})
+        end
+
+        it "should check all required arguments are present" do
+          @ddl.action(:test, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :test)
+          @ddl.input(:optional, :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => true, :validation => "",
+                     :maxlength => 1)
+          @ddl.input(:required, :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => false, :validation => "",
+                     :maxlength => 1)
+
+          expect {
+            @ddl.validate_rpc_request(:test, {})
+          }.to raise_error("Action test needs a required argument")
+
+          @ddl.validate_rpc_request(:test, {:required => "f"}).should == true
+        end
+
+        it "should input validate every supplied key" do
+          @ddl.action(:test, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :test)
+          @ddl.input(:optional, :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => true, :validation => "",
+                     :maxlength => 1)
+          @ddl.input(:required, :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => false, :validation => "",
+                     :maxlength => 1)
+
+
+          @ddl.expects(:validate_input_argument).with(@ddl.entities[:test][:input], :required, "f")
+          @ddl.expects(:validate_input_argument).with(@ddl.entities[:test][:input], :optional, "f")
+
+          @ddl.validate_rpc_request(:test, {:required => "f", :optional => "f"}).should == true
+        end
+      end
+
+      describe "#is_function" do
+        before :each do
+          PluginManager.expects(:find).with("aggregate").returns(["plugin"])
+        end
+
+        it "should return true if the aggregate function is present" do
+          @ddl.is_function?("plugin").should == true
+        end
+
+        it "should return false if the aggregate function is not present" do
+          @ddl.is_function?("no_plugin").should == false
+        end
+      end
+
+      describe "#method_missing" do
+        it "should call super if the aggregate plugin isn't present" do
+          expect{
+            @ddl.test
+          }.to raise_error(NoMethodError)
+        end
+
+        it "should call super if @process_aggregate_function is false" do
+          expect{
+            result = @ddl.test(:value)
+          }.to raise_error(NoMethodError)
+        end
+
+        it "should return the function hash" do
+          Config.instance.mode = :client
+          @ddl.instance_variable_set(:@process_aggregate_functions, true)
+          result = @ddl.method_missing(:test_function, :rspec)
+          result.should == {:args => [:rspec], :function => :test_function }
+        end
+      end
+
+      describe "#actions" do
+        it "should return the correct list of actions" do
+          @ddl.action(:test1, :description => "rspec")
+          @ddl.action(:test2, :description => "rspec")
+
+          @ddl.actions.sort.should == [:test1, :test2]
+        end
+      end
+
+      describe "#action_interface" do
+        it "should return the correct interface" do
+          @ddl.action(:test1, :description => "rspec")
+          @ddl.action_interface(:test1).should == {:description=>"rspec", :output=>{}, :input=>{}, :action=>:test1, :display=>:failed}
+        end
+      end
+
+      describe "#display" do
+        it "should ensure a valid display property is set" do
+          @ddl.action(:test, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :test)
+
+          [:ok, :failed, :flatten, :always].each do |display|
+            @ddl.display(display)
+
+            action = @ddl.action_interface(:test)
+            action[:display].should == display
+          end
+
+          expect {
+            @ddl.display(:foo)
+          }.to raise_error(/Display preference foo is not valid/)
+        end
+      end
+
+      describe "#summarize" do
+        before :each do
+          @block_result = nil
+          @block = Proc.new{@block_result = :success}
+        end
+
+        after :each do
+          @block_result = nil
+        end
+
+        it "should call the block parameter if config mode is not server" do
+          Config.instance.mode = :client
+          result = @ddl.summarize(&@block)
+          @block_result.should == :success
+        end
+
+        it "should not call the block parameter if config mode is server" do
+          Config.instance.mode = :server
+          result = @ddl.summarize(&@block)
+          @block_result.should == nil
+        end
+      end
+
+      describe "#aggregate" do
+        it "should raise an exception if aggregate format isn't a hash" do
+          expect{
+            @ddl.aggregate(:foo, :format)
+          }.to raise_error(DDLValidationError, "Formats supplied to aggregation functions should be a hash")
+        end
+
+        it "should raise an exception if format hash does not include a :format key" do
+          expect{
+            @ddl.aggregate(:foo, {})
+          }.to raise_error(DDLValidationError, "Formats supplied to aggregation functions must have a :format key")
+        end
+
+        it "should raise an exception if aggregate function is not a hash" do
+          expect{
+            @ddl.aggregate(:foo)
+          }.to raise_error(DDLValidationError, "Functions supplied to aggregate should be a hash")
+        end
+
+        it "should raise an exception if function hash does not include a :args key" do
+          expect{
+            @ddl.stubs(:entities).returns({nil => {:action => :foo}})
+            @ddl.aggregate({})
+          }.to raise_error(DDLValidationError, "aggregate method for action 'foo' missing a function parameter")
+        end
+
+        it "should correctly add an aggregate function to the function array" do
+          @ddl.stubs(:entities).returns({nil => {:aggregate => nil}})
+          @ddl.aggregate({:function => :foo, :args => [:bar]})
+          @ddl.entities.should == {nil => {:aggregate => [{:function => :foo, :args => [:bar]}]}}
+        end
+      end
+
+      describe "#action" do
+        it "should ensure a description is set" do
+          expect {
+            @ddl.action("act", {})
+          }.to raise_error("Action needs a :description property")
+        end
+
+        it "should create a default action structure" do
+          @ddl.action("act", :description => "rspec")
+
+          action = @ddl.action_interface("act")
+
+          action.class.should == Hash
+          action[:action].should == "act"
+          action[:input].should == {}
+          action[:output].should == {}
+          action[:display].should == :failed
+          action[:description].should == "rspec"
+        end
+
+        it "should call a block if one is given and set the correct action name" do
+          @ddl.action("act", :description => "rspec") { @ddl.instance_variable_get("@current_entity").should == "act" }
+        end
+      end
+    end
+  end
+end

data/spec/unit/{rpc/ddl_spec.rb → ddl/base_spec.rb}

@@ -3,22 +3,230 @@
 require 'spec_helper'
 
 module MCollective
-  module RPC
-    describe DDL do
+  module DDL
+    describe Base do
       before :each do
-        @ddl = DDL.new("rspec", false)
+        Cache.delete!(:ddl) rescue nil
+        @ddl = DDL.new("rspec", :agent, false)
+        @ddl.metadata(:name => "name", :description => "description", :author => "author", :license => "license", :version => "version", :url => "url", :timeout => "timeout")
+      end
+
+      describe "#template_for_plugintype" do
+        it "should return the backward compat path for agent ddls" do
+          @ddl.template_for_plugintype.should == "rpc-help.erb"
+        end
+
+        it "should return correct new path for other ddls" do
+          @ddl.instance_variable_set("@plugintype", :data)
+          @ddl.template_for_plugintype.should == "data-help.erb"
+        end
+      end
+
+      describe "#help" do
+        it "should use conventional template paths when none is provided" do
+          File.expects(:read).with("/etc/mcollective/rpc-help.erb").returns("rspec")
+          File.expects(:read).with("/etc/mcollective/metadata-help.erb").returns("rspec")
+          @ddl.help.should == "rspec"
+        end
+
+        it "should use template from help template path when provided template name is not an absolute file path" do
+          File.expects(:read).with("/etc/mcollective/foo").returns("rspec")
+          File.expects(:read).with("/etc/mcollective/metadata-help.erb").returns("rspec")
+          @ddl.help("foo").should == "rspec"
+        end
+
+        it "should use supplied template path when one is provided" do
+          File.expects(:read).with("/foo").returns("rspec")
+          File.expects(:read).with("/etc/mcollective/metadata-help.erb").returns("rspec")
+          @ddl.help("/foo").should == "rspec"
+        end
+
+        it "should correctly execute the template with a valid binding" do
+          @ddl.instance_variable_set("@meta", "meta")
+          @ddl.instance_variable_set("@entities", "actions")
+          File.expects(:read).with("/template").returns("<%= meta %>:<%= entities %>")
+          File.expects(:read).with("/etc/mcollective/metadata-help.erb").returns("rspec")
+          @ddl.help("/template").should == "meta:actions"
+        end
+      end
+
+      describe "#validate_input_arguments" do
+        before :all do
+          Config.instance.stubs(:configured).returns(true)
+          Config.instance.stubs(:libdir).returns([File.join(File.dirname(__FILE__), "../../../plugins")])
+        end
+
+        it "should ensure strings are String" do
+          @ddl.action(:string, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :string)
+          @ddl.input(:string, :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => true, :validation => "",
+                     :maxlength => 1)
+
+          expect {
+            @ddl.validate_input_argument(@ddl.entities[:string][:input], :string, 1)
+          }.to raise_error("Cannot validate input: value should be a string")
+
+          @ddl.validate_input_argument(@ddl.entities[:string][:input], :string, "1")
+        end
+
+        it "should ensure strings are not longer than maxlength" do
+          @ddl.action(:string, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :string)
+          @ddl.input(:string, :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => true, :validation => "",
+                     :maxlength => 1)
+
+          expect {
+            @ddl.validate_input_argument(@ddl.entities[:string][:input], :string, "too long")
+          }.to raise_error("Cannot validate input: Input string is longer than 1 character(s)")
+
+          @ddl.validate_input_argument(@ddl.entities[:string][:input], :string, "1")
+        end
+
+        it "should validate strings using regular expressions" do
+          @ddl.action(:string, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :string)
+          @ddl.input(:string, :prompt => "prompt", :description => "descr",
+                     :type => :string, :optional => true, :validation => "^regex$",
+                     :maxlength => 100)
+
+          expect {
+            @ddl.validate_input_argument(@ddl.entities[:string][:input], :string, "doesnt validate")
+          }.to raise_error("Cannot validate input: value should match ^regex$")
+
+          @ddl.validate_input_argument(@ddl.entities[:string][:input], :string, "regex")
+        end
+
+        it "should validate list arguments correctly" do
+          @ddl.action(:list, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :list)
+          @ddl.input(:list, :prompt => "prompt", :description => "descr",
+                     :type => :list, :optional => true, :list => [1,2])
+
+          expect {
+            @ddl.validate_input_argument(@ddl.entities[:list][:input], :list, 3)
+          }.to raise_error("Cannot validate input: value should be one of 1, 2")
+
+          @ddl.validate_input_argument(@ddl.entities[:list][:input], :list, 1)
+        end
+
+        it "should validate boolean arguments correctly" do
+          @ddl.action(:bool, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :bool)
+          @ddl.input(:bool, :prompt => "prompt", :description => "descr",
+                     :type => :boolean, :optional => true)
+
+          expect {
+            @ddl.validate_input_argument(@ddl.entities[:bool][:input], :bool, 3)
+          }.to raise_error("Cannot validate input: value should be a boolean")
+
+          @ddl.validate_input_argument(@ddl.entities[:bool][:input], :bool, true)
+          @ddl.validate_input_argument(@ddl.entities[:bool][:input], :bool, false)
+        end
+
+        it "should validate integer arguments correctly" do
+          @ddl.action(:test, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :test)
+          @ddl.input(:int, :prompt => "prompt", :description => "descr",
+                     :type => :integer, :optional => true)
+
+          expect {
+            @ddl.validate_input_argument(@ddl.entities[:test][:input], :int, "1")
+          }.to raise_error("Cannot validate input: value should be a integer")
+
+          expect {
+            @ddl.validate_input_argument(@ddl.entities[:test][:input], :int, 1.1)
+          }.to raise_error("Cannot validate input: value should be a integer")
+
+          @ddl.validate_input_argument(@ddl.entities[:test][:input], :int, 1)
+        end
+
+        it "should validate float arguments correctly" do
+          @ddl.action(:test, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :test)
+          @ddl.input(:float, :prompt => "prompt", :description => "descr",
+                     :type => :float, :optional => true)
+
+          expect {
+            @ddl.validate_input_argument(@ddl.entities[:test][:input], :float, "1")
+          }.to raise_error("Cannot validate input: value should be a float")
+
+          expect {
+            @ddl.validate_input_argument(@ddl.entities[:test][:input], :float, 1)
+          }.to raise_error("Cannot validate input: value should be a float")
+
+          @ddl.validate_input_argument(@ddl.entities[:test][:input], :float, 1.1)
+        end
+
+        it "should validate number arguments correctly" do
+          @ddl.action(:test, :description => "rspec")
+          @ddl.instance_variable_set("@current_entity", :test)
+          @ddl.input(:number, :prompt => "prompt", :description => "descr",
+                     :type => :number, :optional => true)
+
+          expect {
+            @ddl.validate_input_argument(@ddl.entities[:test][:input], :number, "1")
+          }.to raise_error("Cannot validate input: value should be a number")
+
+          @ddl.validate_input_argument(@ddl.entities[:test][:input], :number, 1)
+          @ddl.validate_input_argument(@ddl.entities[:test][:input], :number, 1.1)
+        end
+      end
+
+      describe "#requires" do
+        it "should only accept hashes as arguments" do
+          expect { @ddl.requires(1) }.to raise_error(/should be a hash/)
+        end
+
+        it "should only accept valid requirement types" do
+          expect { @ddl.requires(:rspec => "1") }.to raise_error(/is not a valid requirement/)
+          @ddl.requires(:mcollective => "1.0.0")
+        end
+
+        it "should save the requirement" do
+          @ddl.requires(:mcollective => "1.0.0")
+
+          @ddl.requirements.should == {:mcollective => "1.0.0"}
+        end
+      end
+
+      describe "#validate_requirements" do
+        it "should fail for older versions of mcollective" do
+          Util.stubs(:mcollective_version).returns("0.1")
+          expect { @ddl.requires(:mcollective => "2.0") }.to raise_error(/requires.+version 2.0/)
+        end
+
+        it "should pass for newer versions of mcollective" do
+          Util.stubs(:mcollective_version).returns("2.0")
+          @ddl.requires(:mcollective => "0.1")
+          @ddl.validate_requirements.should == true
+        end
+
+        it "should bypass checks in development" do
+          Util.stubs(:mcollective_version).returns("@DEVELOPMENT_VERSION@")
+          Log.expects(:warn).with(regexp_matches(/skipped in development/))
+          @ddl.requires(:mcollective => "0.1")
+        end
+      end
+
+      describe "#loaddlfile" do
+        it "should raise the correct error when a ddl isnt present" do
+          @ddl.expects(:findddlfile).returns(false)
+          expect { @ddl.loadddlfile }.to raise_error("Can't find DDL for agent plugin 'rspec'")
+        end
       end
 
       describe "#findddlfile" do
         it "should construct the correct ddl file name" do
-          Config.any_instance.expects(:libdir).returns(["/nonexisting"])
+          Config.instance.expects(:libdir).returns(["/nonexisting"])
           File.expects("exist?").with("/nonexisting/mcollective/agent/foo.ddl").returns(false)
 
           @ddl.findddlfile("foo").should == false
         end
 
         it "should check each libdir for a ddl file" do
-          Config.any_instance.expects(:libdir).returns(["/nonexisting1", "/nonexisting2"])
+          Config.instance.expects(:libdir).returns(["/nonexisting1", "/nonexisting2"])
           File.expects("exist?").with("/nonexisting1/mcollective/agent/foo.ddl").returns(false)
           File.expects("exist?").with("/nonexisting2/mcollective/agent/foo.ddl").returns(false)
 
@@ -26,12 +234,19 @@ module MCollective
         end
 
         it "should return the ddl file path if found" do
-          Config.any_instance.expects(:libdir).returns(["/nonexisting"])
+          Config.instance.expects(:libdir).returns(["/nonexisting"])
           File.expects("exist?").with("/nonexisting/mcollective/agent/foo.ddl").returns(true)
           Log.expects(:debug).with("Found foo ddl at /nonexisting/mcollective/agent/foo.ddl")
 
           @ddl.findddlfile("foo").should == "/nonexisting/mcollective/agent/foo.ddl"
         end
+
+        it "should default to the current plugin and type" do
+          Config.instance.expects(:libdir).returns(["/nonexisting"])
+          File.expects("exist?").with("/nonexisting/mcollective/agent/rspec.ddl").returns(true)
+
+          @ddl.findddlfile.should == "/nonexisting/mcollective/agent/rspec.ddl"
+        end
       end
 
       describe "#metadata" do
@@ -44,7 +259,7 @@ module MCollective
 
             expect {
               @ddl.metadata(metadata)
-            }.to raise_error("Metadata needs a :#{tst}")
+            }.to raise_error("Metadata needs a :#{tst} property")
           end
         end
 
@@ -57,35 +272,10 @@ module MCollective
         end
       end
 
-      describe "#action" do
-        it "should ensure a description is set" do
-          expect {
-            @ddl.action("act", {})
-          }.to raise_error("Action needs a :description")
-        end
-
-        it "should create a default action structure" do
-          @ddl.action("act", :description => "rspec")
-
-          action = @ddl.action_interface("act")
-
-          action.class.should == Hash
-          action[:action].should == "act"
-          action[:input].should == {}
-          action[:output].should == {}
-          action[:display].should == :failed
-          action[:description].should == "rspec"
-        end
-
-        it "should call a block if one is given and set the correct action name" do
-          @ddl.action("act", :description => "rspec") { @ddl.instance_variable_get("@current_action").should == "act" }
-        end
-      end
-
       describe "#input" do
         it "should ensure required properties are set" do
           @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
+          @ddl.instance_variable_set("@current_entity", :test)
 
           [:prompt, :description, :type, :optional].each do |arg|
             args = {:prompt => "prompt", :description => "descr", :type => "type", :optional => true}
@@ -93,7 +283,7 @@ module MCollective
 
             expect {
               @ddl.input(:test, args)
-            }.to raise_error("Input needs a :#{arg}")
+            }.to raise_error("Input needs a :#{arg} property")
           end
 
           @ddl.input(:test, {:prompt => "prompt", :description => "descr", :type => "type", :optional => true})
@@ -101,7 +291,7 @@ module MCollective
 
         it "should ensure strings have a validation and maxlength" do
           @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
+          @ddl.instance_variable_set("@current_entity", :test)
 
           expect {
             @ddl.input(:test, :prompt => "prompt", :description => "descr",
@@ -119,7 +309,7 @@ module MCollective
 
         it "should ensure lists have a list argument" do
           @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
+          @ddl.instance_variable_set("@current_entity", :test)
 
           expect {
             @ddl.input(:test, :prompt => "prompt", :description => "descr",
@@ -132,7 +322,7 @@ module MCollective
 
         it "should save correct data for a list input" do
           @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
+          @ddl.instance_variable_set("@current_entity", :test)
           @ddl.input(:test, :prompt => "prompt", :description => "descr",
                      :type => :list, :optional => true, :list => [])
 
@@ -147,7 +337,7 @@ module MCollective
 
         it "should save correct data for a string input" do
           @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
+          @ddl.instance_variable_set("@current_entity", :test)
           @ddl.input(:test, :prompt => "prompt", :description => "descr",
                      :type => :string, :optional => true, :validation => "",
                      :maxlength => 1)
@@ -166,7 +356,7 @@ module MCollective
       describe "#output" do
         it "should ensure a :description is set" do
           @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
+          @ddl.instance_variable_set("@current_entity", :test)
 
           expect {
             @ddl.output(:test, {})
@@ -175,7 +365,7 @@ module MCollective
 
         it "should ensure a :display_as is set" do
           @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
+          @ddl.instance_variable_set("@current_entity", :test)
 
           expect {
             @ddl.output(:test, {:description => "rspec"})
@@ -184,205 +374,29 @@ module MCollective
 
         it "should save correct data for an output" do
           @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
+          @ddl.instance_variable_set("@current_entity", :test)
 
-          @ddl.output(:test, {:description => "rspec", :display_as => "RSpec"})
+          @ddl.output(:test, {:description => "rspec", :display_as => "RSpec", :default => "default"})
 
           action = @ddl.action_interface(:test)
 
           action[:output][:test][:description].should == "rspec"
           action[:output][:test][:display_as].should == "RSpec"
+          action[:output][:test][:default].should == "default"
         end
-      end
 
-      describe "#display" do
-        it "should ensure a valid display property is set" do
+        it "should set unsupplied defaults to our internal unset representation" do
           @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
-
-          [:ok, :failed, :flatten, :always].each do |display|
-            @ddl.display(display)
-
-            action = @ddl.action_interface(:test)
-            action[:display].should == display
-          end
+          @ddl.instance_variable_set("@current_entity", :test)
 
-          expect {
-            @ddl.display(:foo)
-          }.to raise_error("Display preference foo is not valid, should be :ok, :failed, :flatten or :always")
-        end
-      end
-
-      describe "#help" do
-        it "should correctly execute the template with a valid binding" do
-          @ddl.instance_variable_set("@meta", "meta")
-          @ddl.instance_variable_set("@actions", "actions")
-          IO.expects(:read).with("/template").returns("<%= meta %>:<%= actions %>")
-          @ddl.help("/template").should == "meta:actions"
-        end
-      end
-
-      describe "#actions" do
-        it "should return the correct list of actions" do
-          @ddl.action(:test1, :description => "rspec")
-          @ddl.action(:test2, :description => "rspec")
+          @ddl.output(:test, {:description => "rspec", :display_as => "RSpec"})
 
-          @ddl.actions.sort.should == [:test1, :test2]
-        end
-      end
+          action = @ddl.action_interface(:test)
 
-      describe "#action_interface" do
-        it "should return the correct interface" do
-          @ddl.action(:test1, :description => "rspec")
-          @ddl.action_interface(:test1).should == {:description=>"rspec", :output=>{}, :input=>{}, :action=>:test1, :display=>:failed}
+          action[:output][:test][:default].should == nil
         end
       end
 
-      describe "#validate_request" do
-        it "should ensure the action is known" do
-          @ddl.action(:test, :description => "rspec")
-
-          expect {
-            @ddl.validate_request(:fail, {})
-          }.to raise_error("Attempted to call action fail for rspec but it's not declared in the DDL")
-
-          @ddl.validate_request(:test, {})
-        end
-
-        it "should check all required arguments are present" do
-          @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
-          @ddl.input(:optional, :prompt => "prompt", :description => "descr",
-                     :type => :string, :optional => true, :validation => "",
-                     :maxlength => 1)
-          @ddl.input(:required, :prompt => "prompt", :description => "descr",
-                     :type => :string, :optional => false, :validation => "",
-                     :maxlength => 1)
-
-          expect {
-            @ddl.validate_request(:test, {})
-          }.to raise_error("Action test needs a required argument")
-
-          @ddl.validate_request(:test, {:required => "f"}).should == true
-        end
-
-        it "should ensure strings are String" do
-          @ddl.action(:string, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :string)
-          @ddl.input(:string, :prompt => "prompt", :description => "descr",
-                     :type => :string, :optional => true, :validation => "",
-                     :maxlength => 1)
-
-          expect {
-            @ddl.validate_request(:string, {:string => 1})
-          }.to raise_error("Input string should be a string")
-
-          @ddl.validate_request(:string, {:string => "1"})
-        end
-
-        it "should ensure strings are not longer than maxlength" do
-          @ddl.action(:string, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :string)
-          @ddl.input(:string, :prompt => "prompt", :description => "descr",
-                     :type => :string, :optional => true, :validation => "",
-                     :maxlength => 1)
-
-          expect {
-            @ddl.validate_request(:string, {:string => "too long"})
-          }.to raise_error("Input string is longer than 1 character(s)")
-
-          @ddl.validate_request(:string, {:string => "1"})
-        end
-
-        it "should validate strings using regular expressions" do
-          @ddl.action(:string, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :string)
-          @ddl.input(:string, :prompt => "prompt", :description => "descr",
-                     :type => :string, :optional => true, :validation => "^regex$",
-                     :maxlength => 100)
-
-          expect {
-            @ddl.validate_request(:string, {:string => "doesnt validate"})
-          }.to raise_error("Input string does not match validation regex ^regex$")
-
-          @ddl.validate_request(:string, {:string => "regex"})
-        end
-
-        it "should validate list arguments correctly" do
-          @ddl.action(:list, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :list)
-          @ddl.input(:list, :prompt => "prompt", :description => "descr",
-                     :type => :list, :optional => true, :list => [1,2])
-
-          expect {
-            @ddl.validate_request(:list, {:list => 3})
-          }.to raise_error("Input list doesn't match list 1, 2")
-
-          @ddl.validate_request(:list, {:list => 1})
-        end
-
-        it "should validate boolean arguments correctly" do
-          @ddl.action(:bool, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :bool)
-          @ddl.input(:bool, :prompt => "prompt", :description => "descr",
-                     :type => :boolean, :optional => true)
-
-          expect {
-            @ddl.validate_request(:bool, {:bool => 3})
-          }.to raise_error("Input bool should be a boolean")
-
-          @ddl.validate_request(:bool, {:bool => true})
-          @ddl.validate_request(:bool, {:bool => false})
-        end
-
-        it "should validate integer arguments correctly" do
-          @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
-          @ddl.input(:int, :prompt => "prompt", :description => "descr",
-                     :type => :integer, :optional => true)
-
-          expect {
-            @ddl.validate_request(:test, {:int => "1"})
-          }.to raise_error("Input int should be a integer")
-
-          expect {
-            @ddl.validate_request(:test, {:int => 1.1})
-          }.to raise_error("Input int should be a integer")
-
-          @ddl.validate_request(:test, {:int => 1})
-        end
-
-        it "should validate float arguments correctly" do
-          @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
-          @ddl.input(:float, :prompt => "prompt", :description => "descr",
-                     :type => :float, :optional => true)
-
-          expect {
-            @ddl.validate_request(:test, {:float => "1"})
-          }.to raise_error("Input float should be a floating point number")
-
-          expect {
-            @ddl.validate_request(:test, {:float => 1})
-          }.to raise_error("Input float should be a floating point number")
-
-          @ddl.validate_request(:test, {:float => 1.1})
-        end
-
-        it "should validate number arguments correctly" do
-          @ddl.action(:test, :description => "rspec")
-          @ddl.instance_variable_set("@current_action", :test)
-          @ddl.input(:number, :prompt => "prompt", :description => "descr",
-                     :type => :number, :optional => true)
-
-          expect {
-            @ddl.validate_request(:test, {:number => "1"})
-          }.to raise_error("Input number should be a number")
-
-          @ddl.validate_request(:test, {:number => 1})
-          @ddl.validate_request(:test, {:number => 1.1})
-        end
-      end
     end
   end
 end