mcollective-client 1.3.3

data/spec/unit/ssl_spec.rb

@@ -0,0 +1,244 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe SSL do
+    before do
+      @rootdir = File.dirname(__FILE__)
+      @ssl = SSL.new("#{@rootdir}/../fixtures/test-public.pem", "#{@rootdir}/../fixtures/test-private.pem")
+    end
+
+    it "should be able to decode base64 text it encoded" do
+      @ssl.base64_decode(@ssl.base64_encode("foo")).should == "foo"
+    end
+
+    it "should decrypt what it encrypted with RSA" do
+      crypted = @ssl.aes_encrypt("foo")
+      decrypted = @ssl.aes_decrypt(crypted[:key], crypted[:data])
+
+      decrypted.should == "foo"
+    end
+
+    it "should be able to decrypt using RSA private key what it encrypted with RSA public key" do
+      crypted = @ssl.rsa_encrypt_with_public("foo")
+      decrypted = @ssl.rsa_decrypt_with_private(crypted)
+
+      decrypted.should == "foo"
+    end
+
+    it "should be able to decrypt using RSA public key what it encrypted with RSA private key" do
+      crypted = @ssl.rsa_encrypt_with_private("foo")
+      decrypted = @ssl.rsa_decrypt_with_public(crypted)
+
+      decrypted.should == "foo"
+    end
+
+    it "using a helper it should be able to decrypt with private key what it encrypted using the public key" do
+      @ssl.decrypt_with_private(@ssl.encrypt_with_public("foo")).should == "foo"
+      @ssl.decrypt_with_private(@ssl.encrypt_with_public("foo", false), false).should == "foo"
+    end
+
+    it "using a helper it should be able to decrypt with public key what it encrypted using the private key" do
+      @ssl.decrypt_with_public(@ssl.encrypt_with_private("foo")).should == "foo"
+      @ssl.decrypt_with_public(@ssl.encrypt_with_private("foo", false), false).should == "foo"
+    end
+
+    describe "#initialize" do
+      it "should default to aes-256-cbc" do
+        @ssl.ssl_cipher.should == "aes-256-cbc"
+      end
+
+      it "should take the configured value when present" do
+        Config.any_instance.stubs("ssl_cipher").returns("aes-128-cbc")
+        @ssl = SSL.new("#{@rootdir}/../fixtures/test-public.pem", "#{@rootdir}/../fixtures/test-private.pem")
+
+        @ssl.ssl_cipher.should == "aes-128-cbc"
+      end
+
+      it "should set the supplied ssl cipher" do
+        @ssl = SSL.new("#{@rootdir}/../fixtures/test-public.pem", "#{@rootdir}/../fixtures/test-private.pem", nil, "aes-128-cbc")
+        @ssl.ssl_cipher.should == "aes-128-cbc"
+      end
+
+      it "should prefer the supplied cipher over configured cipher" do
+        Config.any_instance.stubs("aes_key_size").returns("foo-foo-foo")
+        @ssl = SSL.new("#{@rootdir}/../fixtures/test-public.pem", "#{@rootdir}/../fixtures/test-private.pem", nil, "aes-128-cbc")
+
+        @ssl.ssl_cipher.should == "aes-128-cbc"
+      end
+
+      it "should fail on invalid ciphers" do
+        expect {
+          @ssl = SSL.new("#{@rootdir}/../fixtures/test-public.pem", "#{@rootdir}/../fixtures/test-private.pem", nil, "foo-foo-foo")
+        }.to raise_error("The supplied cipher 'foo-foo-foo' is not supported")
+      end
+    end
+
+    describe "#read_key" do
+      it "should fail on non exiting files" do
+        expect {
+          @ssl.read_key(:public, "/nonexisting")
+        }.to raise_error("Could not find key /nonexisting")
+      end
+
+      it "should fail on unknown key types" do
+        expect {
+          @ssl.read_key(:unknown, @ssl.public_key_file)
+        }.to raise_error("Can only load :public or :private keys")
+      end
+
+      it "should read a public key" do
+        @ssl.read_key(:public, "#{@rootdir}/../fixtures/test-public.pem")
+      end
+
+      it "should read the public key from a certificate" do
+        @ssl.read_key(:public, "#{@rootdir}/../fixtures/test-cert.pem").to_s.should match /.+BEGIN.+PUBLIC KEY.+END.+PUBLIC KEY.+/m
+      end
+
+      it "should return nil if no key was given" do
+        @ssl.read_key(:public).should == nil
+      end
+
+      it "should return nil if nil key was given" do
+        @ssl.read_key(:public, nil).should == nil
+      end
+
+      it "should clear the OpenSSL error queue on ruby 1.8" do
+        Util.expects(:ruby_version).returns("1.8.7")
+        OpenSSL.expects(:errors)
+        @ssl.read_key(:public, "#{@rootdir}/../fixtures/test-public.pem")
+        @ssl.read_key(:private, "#{@rootdir}/../fixtures/test-private.pem")
+      end
+
+      it "should not clear the OpenSSL error queue on ruby > 1.8" do
+        Util.expects(:ruby_version).returns("1.9.3")
+        OpenSSL.expects(:errors).never
+        @ssl.read_key(:public, "#{@rootdir}/../fixtures/test-public.pem")
+        @ssl.read_key(:private, "#{@rootdir}/../fixtures/test-private.pem")
+      end
+    end
+
+    describe "#base64_encode" do
+      it "should correctly encode" do
+        @ssl.base64_encode("foo").should == "Zm9v\n"
+        SSL.base64_encode("foo").should == "Zm9v\n"
+      end
+    end
+
+    describe "#base64_decode" do
+      it "should correctly decode" do
+        @ssl.base64_decode("Zm9v").should == "foo"
+        SSL.base64_decode("Zm9v").should == "foo"
+      end
+    end
+
+    describe "#aes_encrypt" do
+      it "should create a key and data" do
+        crypted = @ssl.aes_encrypt("foo")
+
+        crypted.include?(:key).should == true
+        crypted.include?(:data).should == true
+      end
+    end
+
+    describe "#aes_decrypt" do
+      it "should decrypt correctly given key and data" do
+        key = @ssl.base64_decode("rAaCyW6qB0XqZNa9hji0qHwrI3P47t8diLNXoemW9ss=")
+        data = @ssl.base64_decode("mSthvO/wSl0ArNOcgysTVw==")
+
+        @ssl.aes_decrypt(key, data).should == "foo"
+      end
+
+      it "should decrypt correctly given key, data and cipher" do
+        key = @ssl.base64_decode("VEma3a/R7fjw2M4d0NIctA==")
+        data = @ssl.base64_decode("FkH6qLvKTn7a+uNPe8ciHA==")
+
+        # the default aes-256-cbc should fail here, the key above is 128 bit
+        # the exception classes changed mid-1.9.2 :(
+        if OpenSSL.constants.include?("CipherError")
+          expect { @ssl.aes_decrypt(key, data) }.to raise_error(OpenSSL::CipherError)
+        else
+          expect { @ssl.aes_decrypt(key, data) }.to raise_error(OpenSSL::Cipher::CipherError)
+        end
+
+        # new ssl instance configured for aes-128-cbc, should work
+        @ssl = SSL.new("#{@rootdir}/../fixtures/test-public.pem", "#{@rootdir}/../fixtures/test-private.pem", nil, "aes-128-cbc")
+        @ssl.aes_decrypt(key, data).should == "foo"
+      end
+    end
+
+    describe "#md5" do
+      it "should produce correct md5 sums" do
+        # echo -n 'hello world'|md5sum
+        @ssl.md5("hello world").should == "5eb63bbbe01eeed093cb22bb8f5acdc3"
+      end
+    end
+    describe "#sign" do
+      it "should sign the message without base64 by default" do
+        SSL.md5(@ssl.sign("hello world")).should == "8269b23f55945aaa82efbff857c845a6"
+      end
+
+      it "should support base64 encoding messages" do
+        SSL.md5(@ssl.sign("hello world", true)).should == "8a4eb3c3d44d22c46dc36a7e441d8db0"
+      end
+    end
+
+    describe "#verify_signature" do
+      it "should correctly verify a message signed using the same keypair" do
+        @ssl.verify_signature(@ssl.sign("hello world"), "hello world").should == true
+        @ssl.verify_signature(@ssl.sign("hello world", true), "hello world", true).should == true
+      end
+
+      it "should fail to verify messages not signed by the key" do
+        @ssl.verify_signature("evil fake signature", "hello world").should == false
+      end
+    end
+
+    describe "#decrypt_with_public" do
+      it "should decrypt correctly given key and data in base64 format" do
+        crypted = {:key=> "YaRcSDdcKgnRZ4Eu2eirl/+lzDgVkPZ41kXAQQNOi+6AfjdbbOW7Zblibx9r\n3TzZAi0ulA94gqNAXPvPC8LaO8W9TtJwlto/RHwDM7ZdfqEImSYoVACFNq28\n+0MLr3K3hIBsB1pyxgFTQul+MrCq+3Fik7Nj7ZKkJUT2veyqbg8=",
+          :data=>"TLVw1EYeOaGDmEC/R2I/cA=="}
+
+        @ssl.decrypt_with_public(crypted).should == "foo"
+      end
+    end
+
+    describe "#decrypt_with_private" do
+      it "should decrypt correctly given key and data in base64 format" do
+        crypted = {:key=> "kO1kUgJBiEBdoajN4OHp9BOie6dCznf1YKbBnp3LOyBxcDDQtjxEBlPmjQve\npXrQJ5xpLX6oNBxzU18Pf2SKYUZSbzIkDUb97GQY0WoBQsdM2OwPXH+HtF2A\no5N8iIx9srPAEAFa6hZAdqvcmRT/SzhP1kH+Gyy8fyvW8HGBjNY=",
+          :data=>"gDTaHCmes/Yua4jtjmgukQ=="}
+
+        @ssl.decrypt_with_private(crypted).should == "foo"
+      end
+    end
+
+    describe "#decrypt_with_private" do
+      it "should fail if not given a key" do
+        expect {
+          @ssl.decrypt_with_private({:iv => "x", :data => "x"})
+        }.to raise_error("Crypted data should include a key")
+      end
+
+      it "should fail if not given data" do
+        expect {
+          @ssl.decrypt_with_private({:iv => "x", :key => "x"})
+        }.to raise_error("Crypted data should include data")
+      end
+    end
+
+    describe "#decrypt_with_public" do
+      it "should fail if not given a key" do
+        expect {
+          @ssl.decrypt_with_public({:iv => "x", :data => "x"})
+        }.to raise_error("Crypted data should include a key")
+      end
+
+      it "should fail if not given data" do
+        expect {
+          @ssl.decrypt_with_public({:iv => "x", :key => "x"})
+        }.to raise_error("Crypted data should include data")
+      end
+    end
+  end
+end

data/spec/unit/symbol.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+class Symbol
+  describe "#<=>" do
+    it "should be sortable" do
+      [:foo, :bar].sort.should == [:bar, :foo]
+    end
+  end
+end

data/spec/unit/unix_daemon.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+require 'mcollective/unix_daemon'
+
+module MCollective
+  describe UnixDaemon do
+    describe "#daemonize_runner" do
+      it "should not run on the windows platform" do
+        Util.expects("windows?").returns(true)
+        expect { UnixDaemon.daemonize_runner }.to raise_error("The Unix Daemonizer can not be used on the Windows Platform")
+      end
+
+      it "should write the pid file if requested" do
+        f = mock
+        f.expects(:write).with(Process.pid)
+
+        File.expects(:open).with("/nonexisting", "w").yields(f)
+
+        r = mock
+        r.expects(:run)
+
+        Runner.expects(:new).returns(r)
+        UnixDaemon.expects(:daemonize).yields
+
+        UnixDaemon.daemonize_runner("/nonexisting")
+      end
+
+      it "should not write a pid file unless requested" do
+        r = mock
+        r.expects(:run)
+
+        UnixDaemon.expects(:daemonize).yields
+        Runner.expects(:new).returns(r)
+        File.expects(:open).never
+
+        UnixDaemon.daemonize_runner(nil)
+      end
+    end
+  end
+end

data/spec/unit/util_spec.rb

@@ -0,0 +1,342 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+module MCollective
+  describe Util do
+    before do
+      class MCollective::Connector::Stomp<MCollective::Connector::Base; end
+
+      PluginManager.clear
+      PluginManager << {:type => "connector_plugin", :class => MCollective::Connector::Stomp.new}
+    end
+
+    describe "#windows?" do
+      it "should correctly detect windows on unix platforms" do
+        RbConfig::CONFIG.expects("[]").returns("linux")
+        Util.windows?.should == false
+      end
+
+      it "should correctly detect windows on windows platforms" do
+        RbConfig::CONFIG.expects("[]").returns("win32")
+        Util.windows?.should == true
+      end
+    end
+
+    describe "#setup_windows_sleeper" do
+      it "should set up a thread on the windows platform" do
+        Thread.expects(:new)
+        Util.expects("windows?").returns(true).once
+        Util.setup_windows_sleeper
+      end
+
+      it "should not set up a thread on other platforms" do
+        Thread.expects(:new).never
+        Util.expects("windows?").returns(false).once
+        Util.setup_windows_sleeper
+      end
+    end
+
+    describe "#has_cf_class?" do
+      before do
+        logger = mock
+        logger.stubs(:log)
+        logger.stubs(:start)
+        Log.configure(logger)
+
+        config = mock
+        config.stubs(:classesfile).returns("/some/file")
+        Config.expects(:instance).returns(config)
+      end
+
+      it "should read the classes lines from the correct file" do
+        File.expects(:readlines).with("/some/file")
+
+        Util.has_cf_class?("test")
+      end
+
+      it "should support regular expression searches" do
+        File.stubs(:readlines).returns(["test_class_test"])
+        String.any_instance.expects(:match).with("^/").returns(true)
+        String.any_instance.expects(:match).with(Regexp.new("class")).returns(true)
+
+        Util.has_cf_class?("/class/").should == true
+      end
+
+      it "should support exact string matches" do
+        File.stubs(:readlines).returns(["test_class_test"])
+        String.any_instance.expects(:match).with("^/").returns(false)
+        String.any_instance.expects(:match).with(Regexp.new("test_class_test")).never
+
+        Util.has_cf_class?("test_class_test").should == true
+      end
+
+      it "should report a warning when the classes file cannot be parsed" do
+        File.stubs(:readlines).returns(nil)
+        Log.expects(:warn).with("Parsing classes file '/some/file' failed: NoMethodError: undefined method `each' for nil:NilClass")
+
+        Util.has_cf_class?("test_class_test").should == false
+      end
+    end
+
+    describe "#shellescape" do
+      it "should return '' for empty strings" do
+        Util.shellescape("").should == "''"
+      end
+
+      it "should quote newlines" do
+        Util.shellescape("\n").should == "'\n'"
+      end
+
+      it "should escape unwanted characters" do
+        Util.shellescape("foo;bar").should == 'foo\;bar'
+        Util.shellescape('foo`bar').should == 'foo\`bar'
+        Util.shellescape('foo$bar').should == 'foo\$bar'
+        Util.shellescape('foo|bar').should == 'foo\|bar'
+        Util.shellescape('foo&&bar').should == 'foo\&\&bar'
+        Util.shellescape('foo||bar').should == 'foo\|\|bar'
+        Util.shellescape('foo>bar').should == 'foo\>bar'
+        Util.shellescape('foo<bar').should == 'foo\<bar'
+        Util.shellescape('foobar').should == 'foobar'
+      end
+    end
+
+    describe "#make_subscription" do
+      it "should validate target types" do
+        expect {
+          Util.make_subscriptions("test", "test", "test")
+        }.to raise_error("Unknown target type test")
+
+        Config.any_instance.stubs(:collectives).returns(["test"])
+        Util.make_subscriptions("test", :broadcast, "test")
+      end
+
+      it "should return a subscription for each collective" do
+        Config.any_instance.stubs(:collectives).returns(["collective1", "collective2"])
+        Util.make_subscriptions("test", :broadcast).should == [{:type=>:broadcast,
+                                                                 :agent=>"test",
+                                                                 :collective=>"collective1"},
+                                                               {:type=>:broadcast,
+                                                                 :agent=>"test",
+                                                                 :collective=>"collective2"}]
+      end
+
+      it "should validate given collective" do
+        Config.any_instance.stubs(:collectives).returns(["collective1", "collective2"])
+
+        expect {
+          Util.make_subscriptions("test", :broadcast, "test")
+        }.to raise_error("Unknown collective 'test' known collectives are 'collective1, collective2'")
+      end
+
+      it "should return a single subscription array given a collective" do
+        Config.any_instance.stubs(:collectives).returns(["collective1", "collective2"])
+        Util.make_subscriptions("test", :broadcast, "collective1").should == [{:type=>:broadcast, :agent=>"test", :collective=>"collective1"}]
+      end
+    end
+
+    describe "#subscribe" do
+      it "should subscribe to multiple topics given an Array" do
+        subs1 = {:agent => "test_agent", :type => "test_type", :collective => "test_collective"}
+        subs2 = {:agent => "test_agent2", :type => "test_type2", :collective => "test_collective2"}
+
+        MCollective::Connector::Stomp.any_instance.expects(:subscribe).with("test_agent", "test_type", "test_collective").once
+        MCollective::Connector::Stomp.any_instance.expects(:subscribe).with("test_agent2", "test_type2", "test_collective2").once
+
+        Util.subscribe([subs1, subs2])
+      end
+
+      it "should subscribe to a single topic given a hash" do
+        MCollective::Connector::Stomp.any_instance.expects(:subscribe).with("test_agent", "test_type", "test_collective").once
+        Util.subscribe({:agent => "test_agent", :type => "test_type", :collective => "test_collective"})
+      end
+    end
+
+    describe "#unsubscribe" do
+      it "should unsubscribe to multiple topics given an Array" do
+        subs1 = {:agent => "test_agent", :type => "test_type", :collective => "test_collective"}
+        subs2 = {:agent => "test_agent2", :type => "test_type2", :collective => "test_collective2"}
+        MCollective::Connector::Stomp.any_instance.expects(:unsubscribe).with("test_agent", "test_type", "test_collective").once
+        MCollective::Connector::Stomp.any_instance.expects(:unsubscribe).with("test_agent2", "test_type2", "test_collective2").once
+
+        Util.unsubscribe([subs1, subs2])
+      end
+
+      it "should subscribe to a single topic given a hash" do
+        MCollective::Connector::Stomp.any_instance.expects(:unsubscribe).with("test_agent", "test_type", "test_collective").once
+        Util.unsubscribe({:agent => "test_agent", :type => "test_type", :collective => "test_collective"})
+      end
+    end
+
+    describe "#empty_filter?" do
+      it "should correctly compare empty filters" do
+        Util.empty_filter?(Util.empty_filter).should == true
+      end
+
+      it "should treat an empty hash as an empty filter" do
+        Util.empty_filter?({}).should == true
+      end
+
+      it "should detect non empty filters correctly" do
+        filter = Util.empty_filter
+        filter["cf_class"] << "meh"
+
+
+        Util.empty_filter?(filter).should == false
+      end
+    end
+
+    describe "#empty_filter" do
+      it "should create correct empty filters" do
+        Util.empty_filter.should == {"fact" => [], "cf_class" => [], "agent" => [], "identity" => [], "compound" => []}
+      end
+    end
+
+    describe "#default_options" do
+      it "should supply correct default options" do
+        empty_filter = Util.empty_filter
+        config_file = Util.config_file_for_user
+
+        Util.default_options.should == {:verbose => false, :disctimeout => 2, :timeout => 5, :config => config_file, :filter => empty_filter, :collective => nil}
+      end
+    end
+
+    describe "#has_fact?" do
+      it "should handle missing facts correctly" do
+        MCollective::Facts.expects("[]").with("foo").returns(nil).once
+        Util.has_fact?("foo", "1", "==").should == false
+      end
+
+      it "should handle regex in a backward compatible way" do
+        MCollective::Facts.expects("[]").with("foo").returns("foo").times(6)
+        Util.has_fact?("foo", "foo", "=~").should == true
+        Util.has_fact?("foo", "/foo/", "=~").should == true
+        Util.has_fact?("foo", "foo", "=~").should == true
+        Util.has_fact?("foo", "bar", "=~").should == false
+        Util.has_fact?("foo", "/bar/", "=~").should == false
+        Util.has_fact?("foo", "bar", "=~").should == false
+      end
+
+      it "should evaluate equality" do
+        MCollective::Facts.expects("[]").with("foo").returns("foo").twice
+        Util.has_fact?("foo", "foo", "==").should == true
+        Util.has_fact?("foo", "bar", "==").should == false
+      end
+
+      it "should handle numeric comparisons correctly" do
+        MCollective::Facts.expects("[]").with("foo").returns("1").times(8)
+        Util.has_fact?("foo", "2", ">=").should == false
+        Util.has_fact?("foo", "1", ">=").should == true
+        Util.has_fact?("foo", "2", "<=").should == true
+        Util.has_fact?("foo", "1", "<=").should == true
+        Util.has_fact?("foo", "1", "<").should == false
+        Util.has_fact?("foo", "1", ">").should == false
+        Util.has_fact?("foo", "1", "!=").should == false
+        Util.has_fact?("foo", "2", "!=").should == true
+      end
+
+      it "should handle alphabetic comparisons correctly" do
+        MCollective::Facts.expects("[]").with("foo").returns("b").times(8)
+        Util.has_fact?("foo", "c", ">=").should == false
+        Util.has_fact?("foo", "a", ">=").should == true
+        Util.has_fact?("foo", "a", "<=").should == false
+        Util.has_fact?("foo", "b", "<=").should == true
+        Util.has_fact?("foo", "b", "<").should == false
+        Util.has_fact?("foo", "b", ">").should == false
+        Util.has_fact?("foo", "b", "!=").should == false
+        Util.has_fact?("foo", "a", "!=").should == true
+      end
+    end
+
+    describe "#parse_fact_string" do
+      it "should parse old style regex fact matches" do
+        Util.parse_fact_string("foo=/bar/").should == {:fact => "foo", :value => "/bar/", :operator => "=~"}
+        Util.parse_fact_string("foo = /bar/").should == {:fact => "foo", :value => "/bar/", :operator => "=~"}
+      end
+
+      it "should parse old style equality" do
+        Util.parse_fact_string("foo=bar").should == {:fact => "foo", :value => "bar", :operator => "=="}
+        Util.parse_fact_string("foo = bar").should == {:fact => "foo", :value => "bar", :operator => "=="}
+      end
+
+      it "should parse regex fact matches" do
+        Util.parse_fact_string("foo=~bar").should == {:fact => "foo", :value => "bar", :operator => "=~"}
+        Util.parse_fact_string("foo =~ bar").should == {:fact => "foo", :value => "bar", :operator => "=~"}
+      end
+
+      it "should treat => like >=" do
+        Util.parse_fact_string("foo=>bar").should == {:fact => "foo", :value => "bar", :operator => ">="}
+        Util.parse_fact_string("foo => bar").should == {:fact => "foo", :value => "bar", :operator => ">="}
+      end
+
+      it "should treat =< like <=" do
+        Util.parse_fact_string("foo=<bar").should == {:fact => "foo", :value => "bar", :operator => "<="}
+        Util.parse_fact_string("foo =< bar").should == {:fact => "foo", :value => "bar", :operator => "<="}
+      end
+
+      it "should parse less than or equal" do
+        Util.parse_fact_string("foo<=bar").should == {:fact => "foo", :value => "bar", :operator => "<="}
+        Util.parse_fact_string("foo <= bar").should == {:fact => "foo", :value => "bar", :operator => "<="}
+      end
+
+      it "should parse greater than or equal" do
+        Util.parse_fact_string("foo>=bar").should == {:fact => "foo", :value => "bar", :operator => ">="}
+        Util.parse_fact_string("foo >= bar").should == {:fact => "foo", :value => "bar", :operator => ">="}
+      end
+
+      it "should parse less than" do
+        Util.parse_fact_string("foo<bar").should == {:fact => "foo", :value => "bar", :operator => "<"}
+        Util.parse_fact_string("foo < bar").should == {:fact => "foo", :value => "bar", :operator => "<"}
+      end
+
+      it "should parse greater than" do
+        Util.parse_fact_string("foo>bar").should == {:fact => "foo", :value => "bar", :operator => ">"}
+        Util.parse_fact_string("foo > bar").should == {:fact => "foo", :value => "bar", :operator => ">"}
+      end
+
+      it "should parse greater than" do
+        Util.parse_fact_string("foo>bar").should == {:fact => "foo", :value => "bar", :operator => ">"}
+        Util.parse_fact_string("foo > bar").should == {:fact => "foo", :value => "bar", :operator => ">"}
+      end
+
+      it "should parse not equal" do
+        Util.parse_fact_string("foo!=bar").should == {:fact => "foo", :value => "bar", :operator => "!="}
+        Util.parse_fact_string("foo != bar").should == {:fact => "foo", :value => "bar", :operator => "!="}
+      end
+
+      it "should parse equal to" do
+        Util.parse_fact_string("foo==bar").should == {:fact => "foo", :value => "bar", :operator => "=="}
+        Util.parse_fact_string("foo == bar").should == {:fact => "foo", :value => "bar", :operator => "=="}
+      end
+
+      it "should fail for facts in the wrong format" do
+        expect {
+          Util.parse_fact_string("foo")
+        }.to raise_error("Could not parse fact foo it does not appear to be in a valid format")
+      end
+    end
+
+    describe "#eval_compound_statement" do
+      it "should return correctly on a regex class statement" do
+        Util.expects(:has_cf_class?).with("/foo/").returns(true)
+        Util.eval_compound_statement({"statement" => "/foo/"}).should == true
+        Util.expects(:has_cf_class?).with("/foo/").returns(false)
+        Util.eval_compound_statement({"statement" => "/foo/"}).should == false
+      end
+
+      it "should return correcly for string and regex facts" do
+        Util.expects(:has_fact?).with("foo", "bar", "==").returns(true)
+        Util.eval_compound_statement({"statement" => "foo=bar"}).should == "true"
+        Util.expects(:has_fact?).with("foo", "/bar/", "=~").returns(false)
+        Util.eval_compound_statement({"statement" => "foo=/bar/"}).should == "false"
+      end
+
+      it "should return correctly on a string class statement" do
+        Util.expects(:has_cf_class?).with("foo").returns(true)
+        Util.eval_compound_statement({"statement" => "foo"}).should == true
+        Util.expects(:has_cf_class?).with("foo").returns(false)
+        Util.eval_compound_statement({"statement" => "foo"}).should == false
+      end
+    end
+  end
+end