mcollective-client 2.0.0 → 2.2.0

data/spec/unit/generators/base_spec.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env rspec
+
+require "spec_helper"
+
+module MCollective
+  module Generators
+    describe Base do
+      before :each do
+        @erb = mock
+        @erb.stubs(:result)
+        File.stubs(:dirname).returns("/tmp")
+        @base = Base.new(nil, nil, nil, nil, nil, nil, nil)
+      end
+
+      describe "#initialize" do
+        it "should set the correct metaparameters" do
+          res = Base.new("name", "description", "author", "license", "version", "url", "timeout")
+          res.meta.should == {:name => "name",
+                              :description => "description",
+                              :author => "author",
+                              :license => "license",
+                              :version => "version",
+                              :url => "url",
+                              :timeout => "timeout"}
+        end
+      end
+
+      describe "#create_metadata_string" do
+        it "should load the ddl template if it is present" do
+          File.expects(:read).returns("ddl")
+          ERB.expects(:new).with("ddl", nil, "-").returns(@erb)
+          @base.create_metadata_string
+        end
+
+        it "should raise an error if the template is not present" do
+          File.expects(:read).raises(Errno::ENOENT)
+          expect{
+            @base.create_metadata_string
+          }.to raise_error(Errno::ENOENT)
+        end
+      end
+
+      describe "#create_plugin_string " do
+        it "should load the plugin template if it is present" do
+          File.expects(:read).returns("plugin")
+          ERB.expects(:new).with("plugin", nil, "-").returns(@erb)
+          @base.create_plugin_string
+        end
+
+        it "should raise an error if the template is not present" do
+          File.expects(:read).raises(Errno::ENOENT)
+          expect{
+            @base.create_plugin_string
+          }.to raise_error(Errno::ENOENT)
+        end
+      end
+
+      describe "#write_plugins" do
+        it "should fail if the directory already exists" do
+          Dir.expects(:mkdir).raises(Errno::EEXIST)
+          @base.plugin_name = "foo"
+          expect{
+            @base.write_plugins
+          }.to raise_error(RuntimeError)
+        end
+
+        it "should create the directory and the plugin files if it doesn't exist" do
+          Dir.stubs(:pwd).returns("/tmp")
+          @base.stubs(:puts)
+
+          Dir.expects(:mkdir).with("foo")
+          Dir.expects(:mkdir).with("foo/agent")
+          File.expects(:open).with("foo/agent/foo.ddl", "w")
+          File.expects(:open).with("foo/agent/foo.rb", "w")
+
+          @base.plugin_name = "foo"
+          @base.mod_name = "agent"
+          @base.write_plugins
+        end
+      end
+    end
+  end
+end

data/spec/unit/generators/data_generator_spec.rb

@@ -0,0 +1,37 @@
+#! /usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module Generators
+      describe DataGenerator do
+
+        before :each do
+          DataGenerator.stubs(:create_metadata_string).returns("meta\n")
+        end
+
+        describe "#create_ddl" do
+          it "create the correct ddl string" do
+            DataGenerator.any_instance.stubs(:create_plugin_content)
+            DataGenerator.any_instance.stubs(:create_plugin_string)
+            DataGenerator.any_instance.stubs(:write_plugins)
+
+            ddl = DataGenerator.new("foo", ["output"]).ddl
+            expected = File.read(File.join(File.dirname(__FILE__), "snippets", "data_ddl")).chop
+            ddl.should == expected
+          end
+        end
+
+        describe "#create_plugin_content" do
+          it "should create the correct plugin content" do
+            DataGenerator.any_instance.stubs(:create_ddl)
+            DataGenerator.any_instance.stubs(:create_plugin_string)
+            DataGenerator.any_instance.stubs(:write_plugins)
+
+            ddl = DataGenerator.new("foo", ["output"]).content
+            ddl.should == "      query do |what|\n        result[:output] = nil\n      end\n"
+          end
+        end
+      end
+  end
+end

data/spec/unit/generators/snippets/agent_ddl

@@ -0,0 +1,19 @@
+metadata
+action "action1", :description => "%ACTIONDESCRIPTION%" do
+     # Example Input
+     input :name,
+           :prompt => "%PROMPT%",
+           :description => "%DESCRIPTION%",
+           :type => %TYPE%,
+           :validation => '%VALIDATION%',
+           :optional => %OPTIONAL%,
+           :maxlength => %MAXLENGTH%
+
+     # Example output
+     output :name,
+            :description => "%DESCRIPTION%",
+            :display_as => "%DISPLAYAS%"
+end
+
+action "action2", :description => "%ACTIONDESCRIPTION%" do
+end

data/spec/unit/generators/snippets/data_ddl

@@ -0,0 +1,20 @@
+metadata :name => "%FULLNANE%",
+         :description => "%DESCRIPTION%",
+         :author => "%AUTHOR%",
+         :license => "%LICENSE%",
+         :version => "%VERSION%",
+         :url => "%URL%",
+         :timeout => %TIMEOUT%
+
+dataquery :description => "Query information" do
+  input :query,
+        :prompt => "%PROMP%",
+        :description => "%DESCRIPTION%",
+        :type => %TYPE%,
+        :validation => %VALIDATION%,
+        :maxlength => %MAXLENGTH%
+
+  output :output,
+         :description => "%DESCRIPTION%",
+         :display_as => "%DESCRIPTION%"
+end

data/spec/unit/logger/console_logger_spec.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  require 'mcollective/logger/console_logger'
+
+  module Logger
+    describe Console_logger do
+      describe "#start" do
+        it "should default to :info and allow the config to override" do
+          logger = Console_logger.new
+          logger.expects(:set_level).with(:info)
+          Config.instance.expects(:configured).returns(true)
+          Config.instance.expects(:loglevel).returns("error")
+          logger.expects(:set_level).with(:error)
+          logger.start
+        end
+      end
+
+      describe "#color" do
+        it "should not colorize if color was disabled" do
+          logger = Console_logger.new
+          Config.instance.stubs(:color).returns(false)
+          logger.color(:error).should == ""
+          logger.color(:reset).should == ""
+        end
+
+        it "should correctly colorize by level" do
+          logger = Console_logger.new
+          Config.instance.stubs(:color).returns(true)
+          logger.color(:error).should == Util.color(:red)
+          logger.color(:reset).should == Util.color(:reset)
+        end
+      end
+
+      describe "#log" do
+        it "should log higher than configured levels" do
+          io = StringIO.new
+          io.expects(:puts).with("error 2012/07/03 15:11:35: rspec message")
+
+          time = stub
+          time.expects(:strftime).returns("2012/07/03 15:11:35")
+
+          Time.expects(:new).returns(time)
+
+          Config.instance.stubs(:color).returns(false)
+          logger = Console_logger.new
+          logger.set_level(:warn)
+          logger.log(:error, "rspec", "message", io)
+        end
+
+        it "should not log lower than configured levels" do
+          io = StringIO.new
+          io.expects(:puts).never
+
+          logger = Console_logger.new
+          logger.set_level(:warn)
+          logger.log(:debug, "rspec", "message", io)
+        end
+
+        it "should resort to STDERR output if all else fails" do
+          io = StringIO.new
+          io.expects(:puts).raises
+
+          last_resort_io = StringIO.new
+          last_resort_io.expects(:puts).with("warn: message")
+
+          logger = Console_logger.new
+          logger.set_level(:debug)
+          logger.log(:warn, "rspec", "message", io, last_resort_io)
+        end
+      end
+    end
+  end
+end

data/spec/unit/logger/syslog_logger_spec.rb

@@ -10,8 +10,8 @@ module MCollective
       describe Syslog_logger do
         describe "#start" do
           before do
-            Config.any_instance.stubs(:logfacility).returns("user")
-            Config.any_instance.stubs(:loglevel).returns("error")
+            Config.instance.stubs(:logfacility).returns("user")
+            Config.instance.stubs(:loglevel).returns("error")
           end
 
           it "should close the syslog if already opened" do

data/spec/unit/matcher/parser_spec.rb

@@ -5,6 +5,10 @@ require 'spec_helper'
 module MCollective
   module Matcher
     describe Parser do
+      before :each do
+        Config.instance.stubs(:color).returns(false)
+      end
+
       describe '#parse' do
         it "should parse statements seperated by '='" do
           parser = Parser.new("foo=bar")
@@ -49,7 +53,7 @@ module MCollective
         it "should not parse an incorrect and token" do
           expect {
             parser = Parser.new("and foo=bar")
-          }.to raise_error("Error at column 10. \n Expression cannot start with 'and'")
+          }.to raise_error(RuntimeError, "Parse errors found while parsing -S input and foo=bar")
         end
 
         it "should parse a correct 'or' token" do
@@ -57,10 +61,10 @@ module MCollective
           parser.execution_stack.should == [{"statement" => "foo=bar"}, {"or" => "or"}, {"statement" => "bar=foo"}]
         end
 
-        it "should not parse an incorrect and token" do
-          expect {
+        it "should not parse an incorrect or token" do
+          expect{
             parser = Parser.new("or foo=bar")
-          }.to raise_error("Error at column 9. \n Expression cannot start with 'or'")
+          }.to raise_error(RuntimeError, "Parse errors found while parsing -S input or foo=bar")
         end
 
         it "should parse a correct 'not' token" do
@@ -71,9 +75,9 @@ module MCollective
         end
 
         it "should not parse an incorrect 'not' token" do
-          expect {
+          expect{
             parser = Parser.new("foo=bar !")
-          }.to raise_error("Error at column 8. \nExpected 'and', 'or', ')'. Found 'not'")
+          }.to raise_error(RuntimeError, "Parse errors found while parsing -S input foo=bar !")
         end
 
         it "should parse correct parentheses" do
@@ -82,15 +86,15 @@ module MCollective
         end
 
         it "should fail on incorrect parentheses" do
-          expect {
+          expect{
             parser = Parser.new(")foo=bar(")
-          }.to raise_error("Error. Missing parentheses '('.")
+          }.to raise_error(RuntimeError, "Malformed token(s) found while parsing -S input )foo=bar(")
         end
 
         it "should fail on missing parentheses" do
-          expect {
+          expect{
             parser = Parser.new("(foo=bar")
-          }.to raise_error("Error. Missing parentheses ')'.")
+          }.to raise_error(RuntimeError, "Missing parenthesis found while parsing -S input (foo=bar")
         end
 
         it "should parse correctly formatted compound statements" do
@@ -100,6 +104,19 @@ module MCollective
                                             {")"=>")"}]
         end
 
+        it "should parse complex fstatements and statements with operators seperated by whitespaces" do
+          parser = Parser.new("foo('bar').value = 1 and foo=bar or foo  = bar")
+          parser.execution_stack.should == [{"fstatement"=>"foo('bar').value=1"}, {"and"=>"and"}, {"statement"=>"foo=bar"}, {"or"=>"or"}, {"statement"=>"foo=bar"}]
+        end
+
+        it "should parse statements where classes are mixed with fact comparisons and fstatements" do
+          parser = Parser.new("klass and function('param').value = 1 and fact=value")
+          parser.execution_stack.should == [{"statement" => "klass"},
+                                            {"and" => "and"},
+                                            {"fstatement" => "function('param').value=1"},
+                                            {"and" => "and"},
+                                            {"statement" => "fact=value"}]
+        end
       end
     end
   end

data/spec/unit/matcher/scanner_spec.rb

@@ -59,12 +59,115 @@ module MCollective
         token.should == ["statement", "/class/"]
       end
 
-      it "should fail if expression terminates with 'and'" do
-        scanner = Scanner.new("and")
+      it "should identify a function statement token with a dot value" do
+        scanner = Scanner.new("foo('bar').baz")
+        token = scanner.get_token
+        token.should == ["fstatement", "foo('bar').baz"]
+      end
+
+      it "should identify a function statement token without a dot value" do
+        scanner = Scanner.new("foo('bar')")
+        token = scanner.get_token
+        token.should == ["fstatement", "foo('bar')"]
+      end
+
+      it "should identify a function statement with multiple parameters" do
+        scanner = Scanner.new("foo('bar','baz')")
+        token = scanner.get_token
+        token.should == ["fstatement", "foo('bar','baz')"]
+      end
+
+      it "should identify a bad token when a function is missing its end bracket" do
+        scanner = Scanner.new("foo(")
+        token = scanner.get_token
+        token.should == ["bad_token", [0,3]]
+      end
+
+      it "should identify a bad token when there is a regex before a comparison operator" do
+        scanner = Scanner.new("/foo/=bar")
+        token = scanner.get_token
+        token.should == ["bad_token", [0,8]]
+      end
+
+      it "should identify a bad token where there is a forward slash before a comparison operator" do
+        scanner = Scanner.new("/foo=bar")
+        token = scanner.get_token
+        token.should == ["bad_token", [0,7]]
+      end
+
+      it "should identify a bad token where there is only one forward slash after a comparison operator" do
+        scanner = Scanner.new("foo=/bar")
+        token = scanner.get_token
+        token.should == ["bad_token", [0,7]]
+      end
+
+      it "should identify a bad token where function parameters are not in single quotes" do
+        scanner = Scanner.new("foo(bar)")
+        token = scanner.get_token
+        token.should == ["bad_token", [0,7]]
+      end
+
+      it "should identify a bad token where there are non alphanumerical or underscore chars in the dot value" do
+        scanner = Scanner.new("foo('bar').val-ue")
+        token = scanner.get_token
+        token.should == ["bad_token", [0,16]]
+      end
 
-        expect {
-          token = scanner.get_token
-        }.to raise_error("Class name cannot be 'and', 'or', 'not'. Found 'and'")
+      it "should identify a bad token where there are chained dot values" do
+        scanner = Scanner.new("foo('bar').a.b")
+        token = scanner.get_token
+        token.should == ["bad_token", [0,13]]
+      end
+
+      it "should identify bad tokens where function parameters are not comma seperated" do
+        scanner = Scanner.new("foo('a' 'b')")
+        token = scanner.get_token
+        token.should == ["bad_token", [0,11]]
+
+        scanner = Scanner.new("foo(\"a\" \"b\")")
+        token = scanner.get_token
+        token.should == ["bad_token", [0,11]]
+
+      end
+
+      it "should identify fstatement tokens where the values and the comparison operator are seperated by whitespaces" do
+        scanner = Scanner.new("foo('a').bar  = 1")
+        token = scanner.get_token
+        token.should == ["fstatement", "foo('a').bar=1"]
+      end
+
+      it "should identify statement tokens where the values and the comparison operator are seperated by whitespaces" do
+        scanner = Scanner.new("a =  c")
+        token = scanner.get_token
+        token.should == ["statement", "a=c"]
+      end
+
+      it "should idenify a function statement where a parameter is an empty string" do
+        scanner = Scanner.new("foo('')")
+        token = scanner.get_token
+        token.should == ["fstatement", "foo('')"]
+      end
+
+      it "should correctly tokenize a statement with escaped qoutes in parameters" do
+        scanner = Scanner.new("foo('\"bar\"')")
+        token = scanner.get_token
+        token.should == ["fstatement", "foo('\"bar\"')"]
+
+        scanner = Scanner.new('foo("\'bar\'")')
+        token =scanner.get_token
+        token.should == ["fstatement", "foo(\"'bar'\")"]
+      end
+
+      it "should correctly tokenize a statement where a regular expression contains parentheses" do
+        scanner = Scanner.new("foo=/bar(1|2)/")
+        token = scanner.get_token
+        token.should == ["statement", "foo=/bar(1|2)/"]
+      end
+
+      it "should correctly tokenize a statement with a comparison operator in a parameter" do
+        scanner = Scanner.new("foo('bar=baz')")
+        token = scanner.get_token
+        token.should == ["fstatement", "foo('bar=baz')"]
       end
     end
   end