right_agent 0.5.1

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,102 @@
+#
+# 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
+
+  # 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
+    @certificate, @key = issue_cert
+    @store = RightScale::StaticCertificateStore.new(@certificate, @certificate)
+    @identity = "id"
+  end
+
+  it 'should raise when not initialized' do
+    data = RightScale::Result.new("token", "to", "from", ["results"])
+    lambda { RightScale::SecureSerializer.dump(data) }.should raise_error
+  end
+
+  it 'should raise when data not serialized with MessagePack or JSON' do
+    data = RightScale::Result.new("token", "to", "from", ["results"])
+    RightScale::SecureSerializer.init(RightScale::Serializer.new, @identity, @certificate, @key, @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
+
+  describe "using MessagePack" do
+
+    before(:each) do
+      flexmock(JSON).should_receive(:dump).never
+      flexmock(JSON).should_receive(:load).never
+      @data = RightScale::Result.new("token", "to", "from", ["results"], nil, nil, nil, nil, [12, 12])
+    end
+
+    it 'should unserialize signed data' do
+      RightScale::SecureSerializer.init(RightScale::Serializer.new, @identity, @certificate, @key, @store, false)
+      data = RightScale::SecureSerializer.dump(@data)
+      RightScale::SecureSerializer.load(data).should == @data
+    end
+
+    it 'should unserialize encrypted data' do
+      RightScale::SecureSerializer.init(RightScale::Serializer.new, @identity, @certificate, @key, @store, true)
+      data = RightScale::SecureSerializer.dump(@data)
+      RightScale::SecureSerializer.load(data).should == @data
+    end
+
+  end
+
+  describe "using JSON" do
+
+    before(:each) do
+      flexmock(MessagePack).should_receive(:dump).never
+      flexmock(MessagePack).should_receive(:load).never
+      @data = RightScale::Result.new("token", "to", "from", ["results"], nil, nil, nil, nil, [11, 11])
+    end
+
+    it 'should unserialize signed data' do
+      RightScale::SecureSerializer.init(RightScale::Serializer.new, @identity, @certificate, @key, @store, false)
+      data = RightScale::SecureSerializer.dump(@data)
+      RightScale::SecureSerializer.load(data).should == @data
+    end
+
+    it 'should unserialize encrypted data' do
+      RightScale::SecureSerializer.init(RightScale::Serializer.new, @identity, @certificate, @key, @store, true)
+      data = RightScale::SecureSerializer.dump(@data)
+      RightScale::SecureSerializer.load(data).should == @data
+    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,174 @@
+#
+# 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'))
+
+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.parse(serializer.load(data)).should == date
+      end
+
+      it "should serialize Time object" do
+        serializer = RightScale::Serializer.new(:msgpack)
+        time = Time.now
+        data = serializer.dump(time)
+        Time.parse(serializer.load(data)).to_i.should == time.to_i
+      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]).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 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