rightscale-nanite 0.4.1.4 → 0.4.1.10

data/spec/packet_spec.rb

@@ -1,220 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-class TestPacket < Nanite::Packet
-  @@cls_attr = "ignore"
-  def initialize(attr1)
-    @attr1 = attr1
-  end
-end
-
-describe "Packet: Base class" do
-
-  before(:all) do
-  end
-
-  it "should be an abstract class" do
-    lambda { Nanite::Packet.new }.should raise_error(NotImplementedError, "Nanite::Packet is an abstract class.")
-  end
-
-  it "should know how to dump itself to JSON" do
-    packet = TestPacket.new(1)
-    packet.should respond_to(:to_json)
-  end
-
-  it "should dump the class name in 'json_class' JSON key" do
-    packet = TestPacket.new(42)
-    packet.to_json().should =~ /\"json_class\":\"TestPacket\"/
-  end
-
-  it "should dump instance variables in 'data' JSON key" do
-    packet = TestPacket.new(188)
-    packet.to_json().should =~ /\"data\":\{\"attr1\":188\}/
-  end
-
-  it "should not dump class variables" do
-    packet = TestPacket.new(382)
-    packet.to_json().should_not =~ /cls_attr/
-  end
-
-  it "should store instance variables in 'data' JSON key as JSON object" do
-    packet = TestPacket.new(382)
-    packet.to_json().should =~ /\"data\":\{[\w:"]+\}/
-  end
-
-  it "should remove '@' from instance variables" do
-    packet = TestPacket.new(2)
-    packet.to_json().should_not =~ /@attr1/
-    packet.to_json().should =~ /attr1/
-  end
-end
-
-
-describe "Packet: FileStart" do
-  it "should dump/load as JSON objects" do
-    packet = Nanite::FileStart.new('foo.txt', 'somewhere/foo.txt', '0xdeadbeef')
-    packet2 = JSON.parse(packet.to_json)
-    packet.filename.should == packet2.filename
-    packet.dest.should == packet2.dest
-    packet.token.should == packet2.token
-  end
-
-  it "should dump/load as Marshalled ruby objects" do
-    packet = Nanite::FileStart.new('foo.txt', 'somewhere/foo.txt', '0xdeadbeef')
-    packet2 = Marshal.load(Marshal.dump(packet))
-    packet.filename.should == packet2.filename
-    packet.dest.should == packet2.dest
-    packet.token.should == packet2.token
-  end
-end
-
-
-describe "Packet: FileEnd" do
-  it "should dump/load as JSON objects" do
-    packet = Nanite::FileEnd.new('0xdeadbeef', 'metadata')
-    packet2 = JSON.parse(packet.to_json)
-    packet.meta.should == packet2.meta
-    packet.token.should == packet2.token
-  end
-
-  it "should dump/load as Marshalled ruby objects" do
-    packet = Nanite::FileEnd.new('0xdeadbeef', 'metadata')
-    packet2 = Marshal.load(Marshal.dump(packet))
-    packet.meta.should == packet2.meta
-    packet.token.should == packet2.token
-  end
-end
-
-
-describe "Packet: FileChunk" do
-  it "should dump/load as JSON objects" do
-    packet = Nanite::FileChunk.new('chunk','0xdeadbeef')
-    packet2 = JSON.parse(packet.to_json)
-    packet.chunk.should == packet2.chunk
-    packet.token.should == packet2.token
-  end
-
-  it "should dump/load as Marshalled ruby objects" do
-    packet = Nanite::FileChunk.new('chunk','0xdeadbeef')
-    packet2 = Marshal.load(Marshal.dump(packet))
-    packet.chunk.should == packet2.chunk
-    packet.token.should == packet2.token
-  end
-end
-
-
-describe "Packet: Request" do
-  it "should dump/load as JSON objects" do
-    packet = Nanite::Request.new('/some/foo', 'payload', :from => 'from', :token => '0xdeadbeef', :reply_to => 'reply_to')
-    packet2 = JSON.parse(packet.to_json)
-    packet.type.should == packet2.type
-    packet.payload.should == packet2.payload
-    packet.from.should == packet2.from
-    packet.token.should == packet2.token
-    packet.reply_to.should == packet2.reply_to
-  end
-
-  it "should dump/load as Marshalled ruby objects" do
-    packet = Nanite::Request.new('/some/foo', 'payload', :from => 'from', :token => '0xdeadbeef', :reply_to => 'reply_to')
-    packet2 = Marshal.load(Marshal.dump(packet))
-    packet.type.should == packet2.type
-    packet.payload.should == packet2.payload
-    packet.from.should == packet2.from
-    packet.token.should == packet2.token
-    packet.reply_to.should == packet2.reply_to
-  end
-end
-
-
-describe "Packet: Result" do
-  it "should dump/load as JSON objects" do
-    packet = Nanite::Result.new('0xdeadbeef', 'to', 'results', 'from')
-    packet2 = JSON.parse(packet.to_json)
-    packet.token.should == packet2.token
-    packet.to.should == packet2.to
-    packet.results.should == packet2.results
-    packet.from.should == packet2.from
-  end
-
-  it "should dump/load as Marshalled ruby objects" do
-    packet = Nanite::Result.new('0xdeadbeef', 'to', 'results', 'from')
-    packet2 = Marshal.load(Marshal.dump(packet))
-    packet.token.should == packet2.token
-    packet.to.should == packet2.to
-    packet.results.should == packet2.results
-    packet.from.should == packet2.from
-  end
-end
-
-
-describe "Packet: IntermediateMessage" do
-  it "should dump/load as JSON objects" do
-    packet = Nanite::IntermediateMessage.new('0xdeadbeef', 'to', 'from', 'messagekey', 'message')
-    packet2 = JSON.parse(packet.to_json)
-    packet.token.should == packet2.token
-    packet.to.should == packet2.to
-    packet.from.should == packet2.from
-    packet.messagekey.should == packet2.messagekey
-    packet.message.should == packet2.message
-  end
-
-  it "should dump/load as Marshalled ruby objects" do
-    packet = Nanite::IntermediateMessage.new('0xdeadbeef', 'to', 'from', 'messagekey', 'message')
-    packet2 = Marshal.load(Marshal.dump(packet))
-    packet.token.should == packet2.token
-    packet.to.should == packet2.to
-    packet.from.should == packet2.from
-    packet.messagekey.should == packet2.messagekey
-    packet.message.should == packet2.message
-  end
-end
-
-
-describe "Packet: Register" do
-  it "should dump/load as JSON objects" do
-    packet = Nanite::Register.new('0xdeadbeef', ['/foo/bar', '/nik/qux'], 0.8, ['foo'])
-    packet2 = JSON.parse(packet.to_json)
-    packet.identity.should == packet2.identity
-    packet.services.should == packet2.services
-    packet.status.should == packet2.status
-  end
-
-  it "should dump/load as Marshalled ruby objects" do
-    packet = Nanite::Register.new('0xdeadbeef', ['/foo/bar', '/nik/qux'], 0.8, ['foo'])
-    packet2 = Marshal.load(Marshal.dump(packet))
-    packet.identity.should == packet2.identity
-    packet.services.should == packet2.services
-    packet.status.should == packet2.status
-  end
-end
-
-
-describe "Packet: UnRegister" do
-  it "should dump/load as JSON objects" do
-    packet = Nanite::UnRegister.new('0xdeadbeef')
-    packet2 = JSON.parse(packet.to_json)
-    packet.identity.should == packet2.identity
-  end
-
-  it "should dump/load as Marshalled ruby objects" do
-    packet = Nanite::UnRegister.new('0xdeadbeef')
-    packet2 = Marshal.load(Marshal.dump(packet))
-    packet.identity.should == packet2.identity
-  end
-end
-
-
-describe "Packet: Ping" do
-  it "should dump/load as JSON objects" do
-    packet = Nanite::Ping.new('0xdeadbeef', 0.8)
-    packet2 = JSON.parse(packet.to_json)
-    packet.identity.should == packet2.identity
-    packet.status.should == packet2.status
-  end
-
-  it "should dump/load as Marshalled ruby objects" do
-    packet = Nanite::Ping.new('0xdeadbeef', 0.8)
-    packet2 = Marshal.load(Marshal.dump(packet))
-    packet.identity.should == packet2.identity
-    packet.status.should == packet2.status
-  end
-end

data/spec/rsa_key_pair_spec.rb

@@ -1,33 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Nanite::RsaKeyPair do
-
-  before(:all) do
-    @pair = Nanite::RsaKeyPair.new
-  end
-
-  it 'should create a private and a public keys' do
-    @pair.has_private?.should be_true
-  end
-
-  it 'should strip out private key in to_public' do
-    @pair.to_public.has_private?.should be_false
-  end
-
-  it 'should save' do
-    filename = File.join(File.dirname(__FILE__), "key.pem")
-    @pair.save(filename)
-    File.size(filename).should be > 0
-    File.delete(filename)
-  end
-
-  it 'should load' do
-    filename = File.join(File.dirname(__FILE__), "key.pem")
-    @pair.save(filename)
-    key = Nanite::RsaKeyPair.load(filename)
-    File.delete(filename)
-    key.should_not be_nil
-    key.data.should == @pair.data
-  end
-
-end

data/spec/secure_serializer_spec.rb

@@ -1,41 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-module Nanite
-  
-  # Add the ability to compare pings for test purposes
-  class Ping
-    def ==(other)
-      @status == other.status && @identity == other.identity
-    end
-  end
-  
-end
-
-describe Nanite::SecureSerializer do
-  
-  include SpecHelpers
-
-  before(:all) do
-    @certificate, @key = issue_cert
-    @store = Nanite::StaticCertificateStore.new(@certificate, @certificate)
-    @identity = "id"
-    @data = Nanite::Ping.new("Test", 0.5)
-  end
-  
-  it 'should raise when not initialized' do
-    lambda { Nanite::SecureSerializer.dump(@data) }.should raise_error
-  end
-
-  it 'should deserialize signed data' do
-    Nanite::SecureSerializer.init(@identity, @certificate, @key, @store, false)
-    data = Nanite::SecureSerializer.dump(@data)
-    Nanite::SecureSerializer.load(data).should == @data
-  end
-  
-  it 'should deserialize encrypted data' do
-    Nanite::SecureSerializer.init(@identity, @certificate, @key, @store, true)
-    data = Nanite::SecureSerializer.dump(@data)
-    Nanite::SecureSerializer.load(data).should == @data
-  end
-
-end

data/spec/serializer_spec.rb

@@ -1,107 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Nanite::Serializer do
-
-  describe "Format" do
-
-    it "supports JSON format" do
-      [ :json, "json" ].each do |format|
-        serializer = Nanite::Serializer.new(format)
-        serializer.instance_eval { @serializers.first }.should == JSON
-      end
-    end
-
-    it "supports Marshal format" do
-      [ :marshal, "marshal" ].each do |format|
-        serializer = Nanite::Serializer.new(format)
-        serializer.instance_eval { @serializers.first }.should == Marshal
-      end
-    end
-
-    it "supports YAML format" do
-      [ :yaml, "yaml" ].each do |format|
-        serializer = Nanite::Serializer.new(format)
-        serializer.instance_eval { @serializers.first }.should == YAML
-      end
-    end
-
-    it "should default to Marshal format if not specified" do
-      serializer = Nanite::Serializer.new
-      serializer.instance_eval { @serializers.first }.should == Marshal
-      serializer = Nanite::Serializer.new(nil)
-      serializer.instance_eval { @serializers.first }.should == Marshal
-    end
-
-  end # Format
-
-  describe "Serialization of Packet" do
-
-    it "should cascade through available serializers" do
-      serializer = Nanite::Serializer.new
-      serializer.should_receive(:cascade_serializers).with(:dump, "hello")
-      serializer.dump("hello")
-    end
-
-    it "should try all three supported formats (JSON, Marshal, YAML)" do
-      JSON.should_receive(:dump).with("hello").and_raise(StandardError)
-      Marshal.should_receive(:dump).with("hello").and_raise(StandardError)
-      YAML.should_receive(:dump).with("hello").and_raise(StandardError)
-
-      lambda { Nanite::Serializer.new.dump("hello") }.should raise_error(Nanite::Serializer::SerializationError)
-    end
-
-    it "should raise SerializationError if packet could not be serialized" do
-      JSON.should_receive(:dump).with("hello").and_raise(StandardError)
-      Marshal.should_receive(:dump).with("hello").and_raise(StandardError)
-      YAML.should_receive(:dump).with("hello").and_raise(StandardError)
-
-      serializer = Nanite::Serializer.new
-      lambda { serializer.dump("hello") }.should raise_error(Nanite::Serializer::SerializationError)
-    end
-
-    it "should return serialized packet" do
-      serialized_packet = mock("Packet")
-      Marshal.should_receive(:dump).with("hello").and_return(serialized_packet)
-
-      serializer = Nanite::Serializer.new(:marshal)
-      serializer.dump("hello").should == serialized_packet
-    end
-
-  end # Serialization of Packet
-
-  describe "De-Serialization of Packet" do
-
-    it "should cascade through available serializers" do
-      serializer = Nanite::Serializer.new
-      serializer.should_receive(:cascade_serializers).with(:load, "olleh")
-      serializer.load("olleh")
-    end
-
-    it "should try all three supported formats (JSON, Marshal, YAML)" do
-      JSON.should_receive(:load).with("olleh").and_raise(StandardError)
-      Marshal.should_receive(:load).with("olleh").and_raise(StandardError)
-      YAML.should_receive(:load).with("olleh").and_raise(StandardError)
-
-      lambda { Nanite::Serializer.new.load("olleh") }.should raise_error(Nanite::Serializer::SerializationError)
-    end
-
-    it "should raise SerializationError if packet could not be de-serialized" do
-      JSON.should_receive(:load).with("olleh").and_raise(StandardError)
-      Marshal.should_receive(:load).with("olleh").and_raise(StandardError)
-      YAML.should_receive(:load).with("olleh").and_raise(StandardError)
-
-      serializer = Nanite::Serializer.new
-      lambda { serializer.load("olleh") }.should raise_error(Nanite::Serializer::SerializationError)
-    end
-
-    it "should return de-serialized packet" do
-      deserialized_packet = mock("Packet")
-      Marshal.should_receive(:load).with("olleh").and_return(deserialized_packet)
-
-      serializer = Nanite::Serializer.new(:marshal)
-      serializer.load("olleh").should == deserialized_packet
-    end
-
-  end # De-Serialization of Packet
-
-end # Nanite::Serializer

data/spec/signature_spec.rb

@@ -1,30 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Nanite::Signature do
-  
-  include SpecHelpers
-
-  before(:all) do
-    @test_data = "Test Data"
-    @cert, @key = issue_cert
-    @sig = Nanite::Signature.new(@test_data, @cert, @key)
-  end
-
-  it 'should create signed data' do
-    @sig.to_s.should_not be_empty
-  end
-
-  it 'should verify the signature' do
-    cert2, key2 = issue_cert
-  
-    @sig.should be_a_match(@cert)
-    @sig.should_not be_a_match(cert2)
-  end
-
-  it 'should load from serialized signature' do
-    sig2 = Nanite::Signature.from_data(@sig.data)
-    sig2.should_not be_nil
-    sig2.should be_a_match(@cert)
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,30 +0,0 @@
-$TESTING=true
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-
-require 'rubygems'
-require 'spec'
-require 'nanite'
-
-module SpecHelpers
-
-  # Create test certificate
-  def issue_cert
-    test_dn = { 'C'  => 'US',
-                'ST' => 'California',
-                'L'  => 'Santa Barbara',
-                'O'  => 'Nanite',
-                'OU' => 'Certification Services',
-                'CN' => 'Nanite test' }
-    dn = Nanite::DistinguishedName.new(test_dn)
-    key = Nanite::RsaKeyPair.new
-    [ Nanite::Certificate.new(key, dn, dn), key ]
-  end
-
-  def run_in_em(stop_event_loop = true)
-    EM.run do
-      yield
-      EM.stop_event_loop if stop_event_loop
-    end
-  end
-  
-end  

data/spec/static_certificate_store_spec.rb

@@ -1,30 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Nanite::StaticCertificateStore do
-  
-  include SpecHelpers
-
-  before(:all) do
-    @signer, key = issue_cert
-    @recipient, key = issue_cert
-    @cert, @key = issue_cert
-    @store = Nanite::StaticCertificateStore.new(@signer, @recipient)
-  end
-
-  it 'should not raise when passed nil objects' do
-    res = nil
-    lambda { res = @store.get_signer(nil) }.should_not raise_error
-    res.should == [ @signer ]
-    lambda { res = @store.get_recipients(nil) }.should_not raise_error
-    res.should == [ @recipient ]
-  end
-
-  it 'should return signer certificates' do
-    @store.get_signer('anything').should == [ @signer ]
-  end
-
-  it 'should return recipient certificates' do
-    @store.get_recipients('anything').should == [ @recipient ]
-  end
-  
-end

data/spec/util_spec.rb

@@ -1,63 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe String do
-
-  describe ".snake_case" do
-
-    it "should downcase single word" do
-      ["FOO", "Foo", "foo"].each do |w|
-        w.snake_case.should == "foo"
-      end
-    end
-
-    it "should not separate numbers from end of word" do
-      ["Foo1234", "foo1234"].each do |w|
-        w.snake_case.should == "foo1234"
-      end
-    end
-
-    it "should separate numbers from word it starts with uppercase letter" do
-      "1234Foo".snake_case.should == "1234_foo"
-    end
-
-    it "should not separate numbers from word starts with lowercase letter" do
-      "1234foo".snake_case.should == "1234foo"
-    end
-
-    it "should downcase camel-cased words and connect with underscore" do
-      ["FooBar", "fooBar"].each do |w|
-        w.snake_case.should == "foo_bar"
-      end
-    end
-
-    it "should start new word with uppercase letter before lower case letter" do
-      ["FooBARBaz", "fooBARBaz"].each do |w|
-        w.snake_case.should == "foo_bar_baz"
-      end
-    end
-
-  end
-
-  describe ".to_const_path" do
-
-    it "should snake-case the string" do
-      str = "hello"
-      str.should_receive(:snake_case).and_return("snake-cased hello")
-      str.to_const_path
-    end
-
-    it "should leave (snake-cased) string without '::' unchanged" do
-      "hello".to_const_path.should == "hello"
-    end
-
-    it "should replace single '::' with '/'" do
-      "hello::world".to_const_path.should == "hello/world"
-    end
-    
-    it "should replace multiple '::' with '/'" do
-      "hello::nanite::world".to_const_path.should == "hello/nanite/world"
-    end
-
-  end
-
-end # String