right_agent 2.0.7-x86-mingw32

data/spec/serialize/message_pack_spec.rb

@@ -0,0 +1,131 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module RightScale
+  class TestClass
+    include Serializable
+
+    attr_accessor :var1, :var2
+
+    def initialize(*a)
+      @var1 = a[0]
+      @var2 = a[1]
+    end
+
+    def serialized_members
+      [@var1, @var2]
+    end
+
+    def ==(rhs)
+      @var1 == rhs.var1 && @var2 == rhs.var2
+    end
+  end
+end
+
+class NonSerializableTestClass
+  attr_accessor :var1
+
+  def initialize(*a)
+    @var1 = a[0]
+  end
+
+  def to_msgpack(*a)
+    {
+      'msgpack_class' => self.class.name,
+      'data'          => serialized_members
+    }.to_msgpack(*a)
+  end
+
+  def serialized_members
+    [@var1]
+  end
+end
+
+describe MessagePack do
+
+  it "should serialize an object when dump and unserialize when load to produce equivalent object" do
+    object = [1, 3.14, {"key" => "value"}]
+    MessagePack.load(MessagePack.dump(object)).should == object
+  end
+
+  it "should behave like JSON in terms of not preserving symbols" do
+    object = [1, 3.14, {:key => "value"}]
+    MessagePack.load(MessagePack.dump(object)).should == [1, 3.14, {"key" => "value"}]
+  end
+
+  it "should serialize arbitrary objects when dump and recreate when load" do
+    object = RightScale::TestClass.new({"key" => "value"}, [1, 2, "abc"])
+    data = MessagePack.dump(object)
+    (data =~ /msgpack_class.*RightScale::TestClass/).should be_true
+    MessagePack.load(data).should == object
+  end
+
+  it "should do nested creation of objects within arrays" do
+    test = RightScale::TestClass.new({"key" => "value"}, [1, 2, "abc"])
+    object = [1, 3.14, test]
+    data = MessagePack.dump(object)
+    (data =~ /msgpack_class.*RightScale::TestClass/).should be_true
+    MessagePack.load(data).should == object
+  end
+
+  it "should do nested creation of objects within hashes" do
+    test = RightScale::TestClass.new({"key" => "value"}, [1, 2, "abc"])
+    object = {"my_data" => [99, 4.3, 712345], "my_test" => test}
+    data = MessagePack.dump(object)
+    (data =~ /msgpack_class.*RightScale::TestClass/).should be_true
+    MessagePack.load(data).should == object
+  end
+
+  it "should do nested creation of objects recursively" do
+    test1 = RightScale::TestClass.new("some", "test")
+    test2 = RightScale::TestClass.new({"key" => "value"}, [1, 2, "abc"])
+    object = [{"my_data" => [99, 4.3, 712345], "my_tests" => {"test1" => test1, "test2" => test2}}, test1, test2]
+    data = MessagePack.dump(object)
+    (data =~ /msgpack_class.*RightScale::TestClass/).should be_true
+    MessagePack.load(data).should == object
+  end
+
+  it "should do nested creation of objects that are arguments in the creation of nested objects" do
+    test1 = RightScale::TestClass.new("some", "test")
+    test2 = RightScale::TestClass.new({"key" => "value"}, test1)
+    object = [{"my_data" => [99, 4.3, 712345], "my_tests" => {"test1" => test1, "test2" => test2}}, test1, test2]
+    data = MessagePack.dump(object)
+    (data =~ /msgpack_class.*RightScale::TestClass/).should be_true
+    MessagePack.load(data).should == object
+  end
+
+  it "should raise an exception if it finds a msgpack_class but there is no msgpack_generate method" do
+    data = MessagePack.dump(NonSerializableTestClass.new(nil))
+    (data =~ /msgpack_class.*NonSerializableTestClass/).should be_true
+    lambda { MessagePack.load(data) }.should raise_error(ArgumentError, /missing msgpack_create method/)
+  end
+
+  it "should raise an exception if it cannot resolve a named msgpack_class" do
+    object = [1, 3.14, {"msgpack_class" => "RightScale::BogusClass"}]
+    data = MessagePack.dump(object)
+    (data =~ /msgpack_class.*RightScale::BogusClass/).should be_true
+    lambda { MessagePack.load(data) }.should raise_error(ArgumentError, /Cannot find const/)
+  end
+
+end

data/spec/serialize/secure_serializer_spec.rb

@@ -0,0 +1,132 @@
+#
+# Copyright (c) 2009-2013 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module RightScale
+
+  # Add the ability to compare results for test purposes
+  class Result
+    def ==(other)
+      @token == other.token && @to == other.to && @from == other.from && @results == other.results
+    end
+  end
+
+end
+
+describe RightScale::SecureSerializer do
+  
+  include RightScale::SpecHelper
+
+  before(:all) do
+    @dump_cert, @dump_key = issue_cert
+    @load_cert, @load_key = issue_cert
+    @dump_store = RightScale::StaticCertificateStore.new(@dump_cert, @dump_key, @load_cert, @load_cert)
+    @load_store = RightScale::StaticCertificateStore.new(@load_cert, @load_key, @dump_cert, @dump_cert)
+    @dump_id = RightScale::AgentIdentity.new("rs", "dump_agent", 1).to_s
+    @load_id = RightScale::AgentIdentity.new("rs", "load_agent", 1).to_s
+  end
+
+  it "must be initialized before use" do
+    data = RightScale::Result.new("token", "to", ["results"], "from")
+    lambda { RightScale::SecureSerializer.dump(data) }.should raise_error(Exception, "Secure serializer not initialized")
+  end
+
+  it "must specify agent identity" do
+    lambda { RightScale::SecureSerializer.init(RightScale::Serializer.new, nil, @load_store, false) }.
+        should raise_error(Exception, "Missing local agent identity")
+  end
+
+  it "must specify a credentials store" do
+    lambda { RightScale::SecureSerializer.init(RightScale::Serializer.new, @load_id, nil, false) }.
+        should raise_error(Exception, "Missing credentials store")
+  end
+
+  it "certificate store must contain certificate and key for agent" do
+    flexmock(@load_store).should_receive(:get_receiver).and_return([nil, nil]).once
+    lambda { RightScale::SecureSerializer.init(RightScale::Serializer.new, @load_id, @load_store, false) }.
+        should raise_error(Exception, "Missing local agent public certificate")
+  end
+
+  it "data must be serialized with MessagePack or JSON" do
+    data = RightScale::Result.new("token", "to", ["results"], "from")
+    RightScale::SecureSerializer.init(RightScale::Serializer.new, @load_id, @load_store, false)
+    lambda { RightScale::SecureSerializer.load(Marshal.dump(data)) }.should raise_error(RightScale::Serializer::SerializationError)
+    lambda { RightScale::SecureSerializer.load(YAML.dump(data)) }.should raise_error(RightScale::Serializer::SerializationError)
+  end
+
+  # Test with protocol versions on the boundary where msgpack was first supported
+  [[:msgpack, version_can_handle_msgpack_result, JSON],
+   [:json, version_cannot_handle_msgpack_result, MessagePack]].each do |type, version, other_class|
+
+    context "using #{type.inspect}" do
+
+      before(:each) do
+        flexmock(other_class).should_receive(:dump).never
+        flexmock(other_class).should_receive(:load).never
+        @data = RightScale::Result.new("token", "to", ["results"], "from", nil, nil, nil, nil, [version, version])
+        @serializer = RightScale::Serializer.new(type)
+      end
+
+      it "unserializes signed data" do
+        RightScale::SecureSerializer.init(@serializer, @dump_id, @dump_store, false)
+        data = RightScale::SecureSerializer.dump(@data)
+        RightScale::SecureSerializer.init(@serializer, @load_id, @load_store, false)
+        RightScale::SecureSerializer.load(data).should == @data
+      end
+
+      it "unserializes encrypted data" do
+        RightScale::SecureSerializer.init(@serializer, @dump_id, @dump_store, true)
+        data = RightScale::SecureSerializer.dump(@data)
+        @serializer.load(data)["encrypted"].should be_true
+        RightScale::SecureSerializer.init(@serializer, @load_id, @load_store, false)
+        RightScale::SecureSerializer.load(data).should == @data
+      end
+
+      it "encrypt option on initialization overrides dump option" do
+        RightScale::SecureSerializer.init(@serializer, @dump_id, @dump_store, true)
+        data = RightScale::SecureSerializer.dump(@data, false)
+        @serializer.load(data)["encrypted"].should be_true
+      end
+
+      it "uses id when supplied to choose credentials" do
+        RightScale::SecureSerializer.init(@serializer, @dump_id, @dump_store, true)
+        data = RightScale::SecureSerializer.dump(@data)
+        RightScale::SecureSerializer.init(@serializer, @load_id, @load_store, false)
+        flexmock(@load_store).should_receive(:get_receiver).with("id").and_return([@load_cert, @load_key]).once
+        RightScale::SecureSerializer.load(data, "id").should == @data
+      end
+
+      it "must be able to retrieve certificate and key to decrypt message" do
+        RightScale::SecureSerializer.init(@serializer, @dump_id, @dump_store, true)
+        data = RightScale::SecureSerializer.dump(@data)
+        RightScale::SecureSerializer.init(@serializer, @dump_id, @load_store, false)
+        flexmock(@load_store).should_receive(:get_receiver).with("id").and_return([nil, @load_key], [@load_cert, nil]).twice
+        lambda { RightScale::SecureSerializer.load(data, "id") }.
+            should raise_error(RightScale::SecureSerializer::MissingCertificate, /Could not find a certificate/)
+        lambda { RightScale::SecureSerializer.load(data, "id") }.
+            should raise_error(RightScale::SecureSerializer::MissingPrivateKey, /Could not find a private key/)
+      end
+    end
+  end
+
+end

data/spec/serialize/serializable_spec.rb

@@ -0,0 +1,90 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'json/ext'
+
+class TestClass1
+
+  include RightScale::Serializable
+
+  attr_accessor :name, :array, :date
+
+  def initialize(*args)
+    @name  = args[0] if args.size > 0
+    @array = args[1] if args.size > 1
+    @date  = args[2] if args.size > 2
+  end
+
+  def serialized_members
+    [@name, @array, @date]
+  end
+end
+
+class TestClass2
+
+  include RightScale::Serializable
+
+  attr_accessor :attr1, :attr2
+
+  def initialize(*args)
+    attr1 = args[0]
+    attr2 = args[1] if args.size > 1
+  end
+
+  def serialized_members
+    [@attr1, @attr2]
+  end
+
+end
+
+describe RightScale::Serializable do
+
+  it 'should serialize using MessagePack' do
+    a1 = TestClass1.new
+    a1.name = "Test1"
+    a1.array = ["some", "stuff" ]
+
+    b1 = TestClass1.new
+    b1.name = "Test2"
+    b1.array = ["some", "more", "stuff"]
+
+    c = TestClass2.new([a1, b1], 1234)
+    a1.to_msgpack
+    TestClass2.msgpack_create(c.to_msgpack).should == c
+  end
+
+  it 'should serialize using JSON' do
+    a1 = TestClass1.new
+    a1.name = "Test1"
+    a1.array = ["some", "stuff" ]
+
+    b1 = TestClass1.new
+    b1.name = "Test2"
+    b1.array = ["some", "more", "stuff"]
+
+    c = TestClass2.new([a1, b1], 1234)
+    a1.to_json
+    TestClass2.json_create(c.to_msgpack).should == c
+  end
+
+end

data/spec/serialize/serializer_spec.rb

@@ -0,0 +1,197 @@
+#
+# Copyright (c) 2009-2013 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe RightScale::Serializer do
+
+  describe "Format" do
+
+    it "supports MessagePack format" do
+      [ :msgpack, "msgpack" ].each do |format|
+        lambda { RightScale::Serializer.new(format).format.should == :msgpack }.should_not raise_error
+      end
+    end
+
+    it "supports JSON format" do
+      [ :json, "json" ].each do |format|
+        lambda { RightScale::Serializer.new(format).format.should == :json }.should_not raise_error
+      end
+    end
+
+    it "supports secure format" do
+      [ :secure, "secure" ].each do |format|
+        lambda { RightScale::Serializer.new(format).format.should == :secure }.should_not raise_error
+      end
+    end
+
+    it "should default to MessagePack format if none specified" do
+      RightScale::Serializer.new.format.should == :msgpack
+    end
+
+    it "should raise error if unsupported format specified" do
+      lambda { RightScale::Serializer.new(:yaml) }.should raise_error(ArgumentError)
+    end
+
+  end # Format
+
+  describe "Serialization" do
+
+    it "should use MessagePack as default serializer and not cascade to others" do
+      serializer = RightScale::Serializer.new
+      flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [MessagePack]).once
+      serializer.dump("hello")
+    end
+
+    it "should use preferred serializer if specified and not cascade to others" do
+      serializer = RightScale::Serializer.new(:json)
+      flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [JSON]).once
+      serializer.dump("hello")
+    end
+
+    it "should raise SerializationError if packet could not be serialized and not try other serializer" do
+      flexmock(MessagePack).should_receive(:dump).with("hello").and_raise(StandardError).once
+      flexmock(JSON).should_receive(:dump).with("hello").and_raise(StandardError).once
+      serializer = RightScale::Serializer.new(:msgpack)
+      lambda { serializer.dump("hello") }.should raise_error(RightScale::Serializer::SerializationError)
+      serializer = RightScale::Serializer.new(:json)
+      lambda { serializer.dump("hello") }.should raise_error(RightScale::Serializer::SerializationError)
+    end
+
+    it "should return serialized packet" do
+      serialized_packet = flexmock("Packet")
+      flexmock(MessagePack).should_receive(:dump).with("hello").and_return(serialized_packet).once
+      serializer = RightScale::Serializer.new
+      serializer.dump("hello").should == serialized_packet
+    end
+
+    it "should be able to override preferred format" do
+      serializer = RightScale::Serializer.new(:json)
+      flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [MessagePack]).once
+      flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [JSON]).never
+      serializer.dump("hello", :msgpack)
+    end
+
+    it "should not be able to override preferred format when secure" do
+      serializer = RightScale::Serializer.new(:secure)
+      flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [RightScale::SecureSerializer]).once
+      flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [MessagePack]).never
+      serializer.dump("hello", :msgpack)
+    end
+
+    describe "MessagePack for common classes" do
+
+      it "should serialize Date object" do
+        serializer = RightScale::Serializer.new(:msgpack)
+        date = Date.today
+        data = serializer.dump(date)
+        Date.strptime(serializer.load(data), "%Y-%m-%d").should == date
+      end
+
+      it "should serialize Time object" do
+        serializer = RightScale::Serializer.new(:msgpack)
+        time = Time.now
+        data = serializer.dump(time)
+        if RUBY_VERSION < "1.9.0"
+          Time.parse(serializer.load(data)).to_i.should == time.to_i
+        else
+          DateTime.parse(serializer.load(data)).to_time.to_i.should == time.to_i
+        end
+      end
+
+      it "should serialize DateTime object" do
+        serializer = RightScale::Serializer.new(:msgpack)
+        date_time = DateTime.now
+        data = serializer.dump(date_time)
+        DateTime.parse(serializer.load(data)).to_s.should == date_time.to_s
+      end
+
+    end
+
+  end # Serialization of Packet
+
+  describe "Unserialization" do
+
+    it "should cascade through available serializers" do
+      serializer = RightScale::Serializer.new
+      flexmock(serializer).should_receive(:cascade_serializers).with(:load, "olleh", [JSON, MessagePack], nil).once
+      serializer.load("olleh")
+    end
+
+    it "should try all supported formats (MessagePack, JSON)" do
+      flexmock(MessagePack).should_receive(:load).with("olleh").and_raise(StandardError).once
+      flexmock(JSON).should_receive(:load).with("olleh").and_raise(StandardError).once
+      lambda { RightScale::Serializer.new.load("olleh") }.should raise_error(RightScale::Serializer::SerializationError)
+    end
+
+    it "should try JSON format first if looks like JSON even if MessagePack preferred" do
+      object = [1, 2, 3]
+      serialized = object.to_json
+      flexmock(MessagePack).should_receive(:load).with(serialized).never
+      flexmock(JSON).should_receive(:load).with(serialized).and_return(object).once
+      RightScale::Serializer.new(:msgpack).load(serialized)
+    end
+
+    it "should try MessagePack format first if looks like MessagePack even if JSON preferred" do
+      object = [1, 2, 3]
+      serialized = object.to_msgpack
+      flexmock(JSON).should_receive(:load).with(serialized).never
+      flexmock(MessagePack).should_receive(:load).with(serialized).and_return(object).once
+      RightScale::Serializer.new(:json).load(serialized)
+    end
+
+    it "should pass optional id to SecureSerializer" do
+      object = [1, 2, 3]
+      serialized = "securely serialized"
+      flexmock(RightScale::SecureSerializer).should_receive(:load).with(serialized, "id").and_return(object).once
+      RightScale::Serializer.new(:secure).load(serialized, "id")
+    end
+
+    it "should not pass optional id to MessagePack serializer" do
+      object = [1, 2, 3]
+      serialized = object.to_msgpack
+      RightScale::Serializer.new(:msgpack).load(serialized, "id").should == object
+    end
+
+    it "should not pass optional id to JSON serializer" do
+      object = [1, 2, 3]
+      serialized = object.to_json
+      RightScale::Serializer.new(:json).load(serialized, "id").should == object
+    end
+
+    it "should raise SerializationError if packet could not be unserialized" do
+      flexmock(MessagePack).should_receive(:load).with("olleh").and_raise(StandardError).once
+      flexmock(JSON).should_receive(:load).with("olleh").and_raise(StandardError).once
+      serializer = RightScale::Serializer.new
+      lambda { serializer.load("olleh") }.should raise_error(RightScale::Serializer::SerializationError)
+    end
+
+    it "should return unserialized packet" do
+      unserialized_packet = flexmock("Packet")
+      flexmock(MessagePack).should_receive(:load).with("olleh").and_return(unserialized_packet).once
+      serializer = RightScale::Serializer.new(:msgpack)
+      serializer.load("olleh").should == unserialized_packet
+    end
+
+  end # De-Serialization of Packet
+
+end # RightScale::Serializer