mcollective-client 1.3.3

data/spec/unit/facts_spec.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Facts do
+    before do
+      class Facts::Testfacts<Facts::Base; end
+
+      PluginManager.delete("facts_plugin")
+      PluginManager << {:type => "facts_plugin", :class => "MCollective::Facts::Testfacts"}
+    end
+
+    describe "#has_fact?" do
+      it "should correctly report fact presense" do
+        Facts::Testfacts.any_instance.stubs("load_facts_from_source").returns({"foo" => "bar"})
+
+        Facts.has_fact?("foo", "foo").should == false
+        Facts.has_fact?("foo", "bar").should == true
+      end
+    end
+
+    describe "#get_fact" do
+      it "should return the correct fact" do
+        Facts::Testfacts.any_instance.stubs("load_facts_from_source").returns({"foo" => "bar"})
+
+        Facts.get_fact("foo").should == "bar"
+      end
+    end
+
+    describe "#[]" do
+      it "should return the correct fact" do
+        Facts::Testfacts.any_instance.stubs("load_facts_from_source").returns({"foo" => "bar"})
+
+        Facts["foo"].should == "bar"
+      end
+    end
+  end
+end

data/spec/unit/log_spec.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Log do
+    before do
+      @logger = mock("logger provider")
+      @logger.stubs(:log)
+      @logger.stubs(:start)
+      @logger.stubs(:set_logging_level)
+      @logger.stubs(:valid_levels)
+    end
+
+    describe "#cofigure" do
+      it "should default to console logging if called prior to configuration" do
+        Config.instance.instance_variable_set("@configured", false)
+        Log.configure
+        Log.logger.should ==  MCollective::Logger::Console_logger
+      end
+    end
+
+    describe "#instance" do
+      it "should return the correct reference" do
+        Log.configure(@logger)
+        Log.instance.should == MCollective::Log
+      end
+    end
+
+    describe "#log" do
+      it "should log at debug level" do
+        @logger.expects(:log).with(:debug, anything, regexp_matches(/debug test/))
+        Log.configure(@logger)
+        Log.debug("debug test")
+      end
+
+      it "should log at info level" do
+        @logger.expects(:log).with(:info, anything, regexp_matches(/info test/))
+        Log.configure(@logger)
+        Log.info("info test")
+      end
+
+      it "should log at fatal level" do
+        @logger.expects(:log).with(:fatal, anything, regexp_matches(/fatal test/))
+        Log.configure(@logger)
+        Log.fatal("fatal test")
+      end
+
+      it "should log at error level" do
+        @logger.expects(:log).with(:error, anything, regexp_matches(/error test/))
+        Log.configure(@logger)
+        Log.error("error test")
+      end
+
+      it "should log at warning level" do
+        @logger.expects(:log).with(:warn, anything, regexp_matches(/warn test/))
+        Log.configure(@logger)
+        Log.warn("warn test")
+      end
+    end
+
+    describe "#cycle_level" do
+      it "should cycle logger class levels" do
+        @logger.expects(:cycle_level)
+
+        Log.configure(@logger)
+        Log.cycle_level
+      end
+    end
+  end
+end

data/spec/unit/logger/base_spec.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective::Logger
+  describe Base do
+    before do
+      Base.any_instance.stubs(:set_logging_level).returns(true)
+      Base.any_instance.stubs(:valid_levels).returns({:info  => :info_test,
+                                                       :warn  => :warning_test,
+                                                       :debug => :debug_test,
+                                                       :fatal => :crit_test,
+                                                       :error => :err_test})
+    end
+
+    describe "#initialize" do
+      it "should check for valid levels" do
+        Base.any_instance.stubs(:valid_levels).returns({})
+
+        expect {
+          Base.new
+        }.to raise_error(/Logger class did not specify a map for/)
+      end
+
+      it "should accept correct levels" do
+        Base.new
+      end
+    end
+
+    describe "#valid_levels" do
+      it "should report if valid_levels was not implimented" do
+        Base.any_instance.unstub(:valid_levels)
+
+        expect {
+          logger = Base.new
+        }.to raise_error("The logging class did not supply a valid_levels method")
+      end
+    end
+
+    describe "#log" do
+      it "should report if log was not implimented" do
+        logger = Base.new
+
+        expect {
+          logger.send(:log, nil, nil, nil)
+        }.to raise_error("The logging class did not supply a log method")
+      end
+    end
+
+    describe "#start" do
+      it "should report if log was not implimented" do
+        logger = Base.new
+
+        expect {
+          logger.send(:start)
+        }.to raise_error("The logging class did not supply a start method")
+      end
+    end
+
+    describe "#map_level" do
+      it "should map levels correctly" do
+        logger = Base.new
+
+        logger.send(:map_level, :info).should == :info_test
+        logger.send(:map_level, :warn).should == :warning_test
+        logger.send(:map_level, :debug).should == :debug_test
+        logger.send(:map_level, :fatal).should == :crit_test
+        logger.send(:map_level, :error).should == :err_test
+      end
+    end
+
+    describe "#get_next_level" do
+      it "should supply the correct next level" do
+        logger = Base.new
+        logger.set_level(:fatal)
+
+        logger.send(:get_next_level).should == :debug
+      end
+    end
+
+    describe "#cycle_level" do
+      it "should set the level to the next one and log the event" do
+        logger = Base.new
+
+        logger.stubs(:get_next_level).returns(:error)
+
+        logger.expects(:set_level).with(:error)
+        logger.expects(:log).with(:error, "", "Logging level is now ERROR")
+
+        logger.cycle_level
+      end
+    end
+
+    describe "#set_level" do
+      it "should set the active level" do
+        logger = Base.new
+
+        logger.set_level(:error)
+
+        logger.active_level.should == :error
+      end
+
+      it "should set the level on the logger" do
+        logger = Base.new
+
+        logger.set_level(:error)
+      end
+    end
+  end
+end

data/spec/unit/logger/syslog_logger_spec.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  unless Util.windows?
+    require 'mcollective/logger/syslog_logger'
+
+    module Logger
+      describe Syslog_logger do
+        describe "#start" do
+          before do
+            Config.any_instance.stubs(:logfacility).returns("user")
+            Config.any_instance.stubs(:loglevel).returns("error")
+          end
+
+          it "should close the syslog if already opened" do
+            Syslog.expects("opened?").returns(true)
+            Syslog.expects(:close).once
+            Syslog.expects(:open).once
+
+            logger = Syslog_logger.new
+            logger.start
+          end
+
+          it "should open syslog with the correct facility" do
+            logger = Syslog_logger.new
+            Syslog.expects(:open).with("rspec", 3, Syslog::LOG_USER).once
+            logger.start
+          end
+
+          it "should set the logger level correctly" do
+            logger = Syslog_logger.new
+            Syslog.expects(:open).with("rspec", 3, Syslog::LOG_USER).once
+            logger.expects(:set_level).with(:error).once
+            logger.start
+          end
+        end
+
+        describe "#syslog_facility" do
+          it "should support valid facilities" do
+            logger = Syslog_logger.new
+            logger.syslog_facility("LOCAL1").should == Syslog::LOG_LOCAL1
+            logger.syslog_facility("local1").should == Syslog::LOG_LOCAL1
+          end
+
+          it "should set LOG_USER for unknown facilities" do
+            logger = Syslog_logger.new
+            IO.any_instance.expects(:puts).with("Invalid syslog facility rspec supplied, reverting to USER")
+            logger.syslog_facility("rspec").should == Syslog::LOG_USER
+          end
+        end
+
+        describe "#log" do
+          it "should log higher than configured levels" do
+            logger = Syslog_logger.new
+            logger.set_level(:debug)
+            Syslog.expects(:err).once
+            logger.log(:error, "rspec", "rspec")
+          end
+
+          it "should not log lower than configured levels" do
+            logger = Syslog_logger.new
+            logger.set_level(:fatal)
+            Syslog.expects(:debug).never
+            logger.log(:debug, "rspec", "rspec")
+          end
+
+          it "should log using the correctly mapped level" do
+            logger = Syslog_logger.new
+            Syslog.expects(:err).with("rspec rspec").once
+            logger.set_level(:debug)
+            logger.log(:error, "rspec", "rspec")
+          end
+
+          it "should resort to STDERR output if all else fails" do
+            logger = Syslog_logger.new
+            IO.any_instance.expects(:puts).with("error: rspec").once
+
+            logger.log(:error, "rspec", "rspec")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/matcher/parser_spec.rb

@@ -0,0 +1,106 @@
+#! /usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module Matcher
+    describe Parser do
+      describe '#parse' do
+        it "should parse statements seperated by '='" do
+          parser = Parser.new("foo=bar")
+          parser.execution_stack.should == [{"statement" => "foo=bar"}]
+        end
+
+        it "should parse statements seperated by '<'" do
+          parser = Parser.new("foo<bar")
+          parser.execution_stack.should == [{"statement" => "foo<bar"}]
+        end
+
+        it "should parse statements seperated by '>'" do
+          parser = Parser.new("foo>bar")
+          parser.execution_stack.should == [{"statement" => "foo>bar"}]
+        end
+
+        it "should parse statements seperated by '<='" do
+          parser = Parser.new("foo<=bar")
+          parser.execution_stack.should == [{"statement" => "foo<=bar"}]
+        end
+
+        it "should parse statements seperated by '>='" do
+          parser = Parser.new("foo>=bar")
+          parser.execution_stack.should == [{"statement" => "foo>=bar"}]
+        end
+
+        it "should parse class regex statements" do
+          parser = Parser.new("/foo/")
+          parser.execution_stack.should == [{"statement" => "/foo/"}]
+        end
+
+        it "should parse fact regex statements" do
+          parser = Parser.new("foo=/bar/")
+          parser.execution_stack.should == [{"statement" => "foo=/bar/"}]
+        end
+
+        it "should parse a correct 'and' token" do
+          parser = Parser.new("foo=bar and bar=foo")
+          parser.execution_stack.should == [{"statement" => "foo=bar"}, {"and" => "and"}, {"statement" => "bar=foo"}]
+        end
+
+        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'")
+        end
+
+        it "should parse a correct 'or' token" do
+          parser = Parser.new("foo=bar or bar=foo")
+          parser.execution_stack.should == [{"statement" => "foo=bar"}, {"or" => "or"}, {"statement" => "bar=foo"}]
+        end
+
+        it "should not parse an incorrect and token" do
+          expect {
+            parser = Parser.new("or foo=bar")
+          }.to raise_error("Error at column 9. \n Expression cannot start with 'or'")
+        end
+
+        it "should parse a correct 'not' token" do
+          parser = Parser.new("! bar=foo")
+          parser.execution_stack.should == [{"not" => "not"}, {"statement" => "bar=foo"}]
+          parser = Parser.new("not bar=foo")
+          parser.execution_stack.should == [{"not" => "not"}, {"statement" => "bar=foo"}]
+        end
+
+        it "should not parse an incorrect 'not' token" do
+          expect {
+            parser = Parser.new("foo=bar !")
+          }.to raise_error("Error at column 8. \nExpected 'and', 'or', ')'. Found 'not'")
+        end
+
+        it "should parse correct parentheses" do
+          parser = Parser.new("(foo=bar)")
+          parser.execution_stack.should == [{"(" => "("}, {"statement" => "foo=bar"}, {")" => ")"}]
+        end
+
+        it "should fail on incorrect parentheses" do
+          expect {
+            parser = Parser.new(")foo=bar(")
+          }.to raise_error("Error. Missing parentheses '('.")
+        end
+
+        it "should fail on missing parentheses" do
+          expect {
+            parser = Parser.new("(foo=bar")
+          }.to raise_error("Error. Missing parentheses ')'.")
+        end
+
+        it "should parse correctly formatted compound statements" do
+          parser = Parser.new("(foo=bar or foo=rab) and (bar=foo)")
+          parser.execution_stack.should == [{"(" => "("}, {"statement"=>"foo=bar"}, {"or"=>"or"}, {"statement"=>"foo=rab"},
+                                            {")"=>")"}, {"and"=>"and"}, {"("=>"("}, {"statement"=>"bar=foo"},
+                                            {")"=>")"}]
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/matcher/scanner_spec.rb

@@ -0,0 +1,71 @@
+#! /usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  module Matcher
+    describe 'scanner' do
+      it "should identify a '(' token" do
+        scanner = Scanner.new("(")
+        token = scanner.get_token
+        token.should == ["(", "("]
+      end
+
+      it "should identify a ')' token" do
+        scanner = Scanner.new(")")
+        token = scanner.get_token
+        token.should == [")", ")"]
+      end
+
+      it "should identify a 'and' token" do
+        scanner = Scanner.new("and ")
+        token = scanner.get_token
+        token.should == ["and", "and"]
+      end
+
+      it "should identify a 'or' token" do
+        scanner = Scanner.new("or ")
+        token = scanner.get_token
+        token.should == ["or", "or"]
+      end
+
+      it "should identify a 'not' token" do
+        scanner = Scanner.new("not ")
+        token = scanner.get_token
+        token.should == ["not", "not"]
+      end
+
+      it "should identify a '!' token" do
+        scanner = Scanner.new("!")
+        token = scanner.get_token
+        token.should == ["not", "not"]
+      end
+
+      it "should identify a fact statement token" do
+        scanner = Scanner.new("foo=bar")
+        token = scanner.get_token
+        token.should == ["statement", "foo=bar"]
+      end
+
+      it "should identify a fact statement token" do
+        scanner = Scanner.new("foo=bar")
+        token = scanner.get_token
+        token.should == ["statement", "foo=bar"]
+      end
+
+      it "should identify a class statement token" do
+        scanner = Scanner.new("/class/")
+        token = scanner.get_token
+        token.should == ["statement", "/class/"]
+      end
+
+      it "should fail if expression terminates with 'and'" do
+        scanner = Scanner.new("and")
+
+        expect {
+          token = scanner.get_token
+        }.to raise_error("Class name cannot be 'and', 'or', 'not'. Found 'and'")
+      end
+    end
+  end
+end