protobuffy 3.1.0

data/spec/lib/protobuf/generators/field_generator_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+require 'protobuf/generators/field_generator'
+
+describe ::Protobuf::Generators::FieldGenerator do
+
+  let(:label_enum) { :LABEL_OPTIONAL }
+  let(:name) { 'foo_bar' }
+  let(:number) { 3 }
+  let(:type_enum) { :TYPE_STRING }
+  let(:type_name) { nil }
+  let(:default_value) { nil }
+  let(:extendee) { nil }
+  let(:field_options) { {} }
+
+  let(:field_fields) { { :label => label_enum,
+                         :name => name,
+                         :number => number,
+                         :type => type_enum,
+                         :type_name => type_name,
+                         :default_value => default_value,
+                         :extendee => extendee,
+                         :options => field_options } }
+
+  let(:field) { ::Google::Protobuf::FieldDescriptorProto.new(field_fields) }
+
+  describe '#compile' do
+    subject { described_class.new(field).to_s }
+
+    it { should eq "optional :string, :foo_bar, 3\n" }
+
+    context 'when the type is another message' do
+      let(:type_enum) { :TYPE_MESSAGE }
+      let(:type_name) { '.foo.bar.Baz' }
+
+      it { should eq "optional ::Foo::Bar::Baz, :foo_bar, 3\n" }
+    end
+
+    context 'when a default value is used' do
+      let(:type_enum) { :TYPE_INT32 }
+      let(:default_value) { '42' }
+      it { should eq "optional :int32, :foo_bar, 3, :default => 42\n" }
+
+      context 'when type is an enum' do
+        let(:type_enum) { :TYPE_ENUM }
+        let(:type_name) { '.foo.bar.Baz' }
+        let(:default_value) { 'QUUX' }
+
+        it { should eq "optional ::Foo::Bar::Baz, :foo_bar, 3, :default => ::Foo::Bar::Baz::QUUX\n" }
+      end
+
+      context 'when the type is a string' do
+        let(:type_enum) { :TYPE_STRING }
+        let(:default_value) { "a default \"string\"" }
+
+        it { should eq %Q{optional :string, :foo_bar, 3, :default => "a default \"string\""\n} }
+      end
+
+      context 'when float or double field type' do
+        let(:type_enum) { :TYPE_DOUBLE }
+
+        context 'when the default value is "nan"' do
+          let(:default_value) { 'nan' }
+          it { should match(/::Float::NAN/) }
+        end
+
+        context 'when the default value is "inf"' do
+          let(:default_value) { 'inf' }
+          it { should match(/::Float::INFINITY/) }
+        end
+
+        context 'when the default value is "-inf"' do
+          let(:default_value) { '-inf' }
+          it { should match(/-::Float::INFINITY/) }
+        end
+      end
+    end
+
+    context 'when the field is an extension' do
+      let(:extendee) { 'foo.bar.Baz' }
+
+      it { should eq "optional :string, :foo_bar, 3, :extension => true\n" }
+    end
+
+    context 'when field is packed' do
+      let(:field_options) { { :packed => true } }
+
+      it { should eq "optional :string, :foo_bar, 3, :packed => true\n" }
+    end
+
+    context 'when field is deprecated' do
+      let(:field_options) { { :deprecated => true } }
+
+      it { should eq "optional :string, :foo_bar, 3, :deprecated => true\n" }
+    end
+  end
+
+end
+

data/spec/lib/protobuf/generators/file_generator_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+require 'protobuf/generators/file_generator'
+
+describe ::Protobuf::Generators::FileGenerator do
+
+  let(:base_descriptor_fields) { { :name => 'test/foo.proto' } }
+  let(:descriptor_fields) { base_descriptor_fields }
+  let(:file_descriptor) { ::Google::Protobuf::FileDescriptorProto.new(descriptor_fields) }
+
+  subject { described_class.new(file_descriptor) }
+  its(:file_name) { should eq 'test/foo.pb.rb' }
+
+  describe '#print_import_requires' do
+    let(:descriptor_fields) do
+      base_descriptor_fields.merge!({ :dependency => [ 'test/bar.proto',
+                                                       'test/baz.proto' ] })
+    end
+
+    it 'prints a ruby require for each dependency' do
+      subject.should_receive(:print_require).with('test/bar.pb')
+      subject.should_receive(:print_require).with('test/baz.pb')
+      subject.print_import_requires
+    end
+
+  end
+
+end
+

data/spec/lib/protobuf/generators/service_generator_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+require 'protobuf/generators/service_generator'
+
+describe ::Protobuf::Generators::ServiceGenerator do
+
+  let(:methods) {
+    [
+      { :name => 'Search', :input_type => 'FooRequest', :output_type => 'FooResponse' },
+      { :name => 'FooBar', :input_type => '.foo.Request', :output_type => '.bar.Response' }
+    ]
+  }
+  let(:service_fields) { { :name => 'TestService',
+                           :method => methods } }
+
+  let(:service) { ::Google::Protobuf::ServiceDescriptorProto.new(service_fields) }
+
+  subject { described_class.new(service) }
+
+  describe '#compile' do
+    let(:compiled) {
+      %q{class TestService < ::Protobuf::Rpc::Service
+  rpc :search, FooRequest, FooResponse
+  rpc :foo_bar, ::Foo::Request, ::Bar::Response
+end
+
+}
+    }
+
+    it 'compiles the service and it\'s rpc methods' do
+      subject.compile
+      subject.to_s.should eq(compiled)
+    end
+  end
+
+  describe '#build_method' do
+    it 'returns a string identifying the given method descriptor' do
+      subject.build_method(service.method.first).should eq("rpc :search, FooRequest, FooResponse")
+    end
+  end
+
+end
+

data/spec/lib/protobuf/lifecycle_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'protobuf/lifecycle'
+
+describe ::Protobuf::Lifecycle do
+  subject { described_class }
+
+  before(:each) do
+    ::ActiveSupport::Notifications.notifier = ::ActiveSupport::Notifications::Fanout.new
+  end
+
+  it "registers a string as the event_name" do
+    ::ActiveSupport::Notifications.should_receive(:subscribe).with("something")
+      subject.register("something") { true }
+  end
+
+  it "only registers blocks for event callbacks" do
+    expect {
+      subject.register("something")
+    }.to raise_error( /block/ )
+  end
+
+  it "calls the registered block when triggered" do
+    this = nil
+    subject.register("this") do
+      this = "not nil"
+    end
+
+    subject.trigger("this")
+    this.should_not be_nil
+    this.should eq("not nil")
+  end
+
+  it "calls multiple registered blocks when triggered" do
+    this = nil
+    that = nil
+
+    subject.register("this") do
+      this = "not nil"
+    end
+
+    subject.register("this") do
+      that = "not nil"
+    end
+
+    subject.trigger("this")
+    this.should_not be_nil
+    this.should eq("not nil")
+    that.should_not be_nil
+    that.should eq("not nil")
+  end
+
+  context 'when the registered block has arity' do
+    context 'and the triggered event does not have args' do
+      it 'does not pass the args' do
+        outer_bar = nil
+
+        subject.register('foo') do |bar|
+          bar.should be_nil
+          outer_bar = 'triggered'
+        end
+
+        subject.trigger('foo')
+        outer_bar.should eq 'triggered'
+      end
+    end
+
+    context 'and the triggered event has arguments' do
+      it 'does not pass the args' do
+        outer_bar = nil
+
+        subject.register('foo') do |bar|
+          bar.should_not be_nil
+          outer_bar = bar
+        end
+
+        subject.trigger('foo', 'baz')
+        outer_bar.should eq 'baz'
+      end
+    end
+  end
+
+  context "normalized event names" do
+    specify { subject.normalized_event_name(:derp).should eq("derp") }
+    specify { subject.normalized_event_name(:Derp).should eq("derp") }
+    specify { subject.normalized_event_name("DERP").should eq("derp") }
+    specify { subject.normalized_event_name("derp").should eq("derp") }
+  end
+
+end

data/spec/lib/protobuf/logger_spec.rb

@@ -0,0 +1,136 @@
+require 'protobuf/logger'
+require 'stringio'
+require 'fileutils'
+
+describe Protobuf::Logger do
+
+  subject { Protobuf::Logger }
+
+  before(:each) do
+    Protobuf::Logger.reset_device!
+    Protobuf::Logger.file = '/dev/null'
+    Protobuf::Logger.level = ::Logger::INFO
+  end
+
+  after(:all) do
+    ::FileUtils.rm_f('myfile.log')
+  end
+
+  describe '.instance' do
+
+    it 'doesn\'t create a logger if the file was not set' do
+      subject.file = nil
+      subject.instance.should be_nil
+    end
+
+    it 'doesn\'t create a logger if the level was not set' do
+      subject.level = nil
+      subject.instance.should be_nil
+    end
+
+    it 'gets a new instance of the logger when file and level are set' do
+      subject.file.should_not be_nil
+      subject.level.should_not be_nil
+      subject.instance.should_not be_nil
+    end
+
+    it 'keeps the same object from multiple calls to instance' do
+      subject.instance === subject.instance
+    end
+
+  end
+
+  describe '.configure' do
+    before(:each) { subject.reset_device! }
+    it 'sets the file and level in one call' do
+      subject.file.should_not be
+      subject.level.should_not be
+      subject.instance.should_not be
+      subject.configure :file => 'myfile.log', :level => ::Logger::WARN
+      subject.file.should == 'myfile.log'
+      subject.level.should == ::Logger::WARN
+      subject.instance.level.should == ::Logger::WARN
+    end
+
+  end
+
+  describe '.reset_device!' do
+
+    it 'resets the logger instance, file, and level' do
+      subject.instance.should be
+      subject.file.should be
+      subject.level.should be
+      subject.reset_device!
+      subject.instance.should_not be
+      subject.file.should_not be
+      subject.level.should_not be
+    end
+
+  end
+
+  context 'when logging' do
+
+    it 'doesn\'t raise errors when log instance is nil' do
+      subject.reset_device!
+      subject.instance.should be_nil
+      expect {
+        subject.debug 'No errors here'
+        subject.info 'No errors here'
+        subject.warn 'No errors here'
+        subject.error 'No errors here'
+        subject.fatal 'No errors here'
+        subject.add 'No errors here'
+        subject.log 'No errors here'
+      }.to_not raise_error
+    end
+
+    it 'logs correctly when instance is valid' do
+      subject.instance.should_not be_nil
+      subject.instance.should_receive(:info).with('Should log great')
+      subject.info 'Should log great'
+    end
+
+  end
+
+  describe Protobuf::Logger::LogMethods do
+
+    context 'when included in another class' do
+
+      before(:all) do
+        class MyTestClass
+          include Protobuf::Logger::LogMethods
+        end
+      end
+
+      subject { MyTestClass.new }
+
+      it { should respond_to(:log_debug) }
+      it { should respond_to(:log_info) }
+      it { should respond_to(:log_warn) }
+      it { should respond_to(:log_error) }
+      it { should respond_to(:log_fatal) }
+      it { should respond_to(:log_add) }
+      it { should respond_to(:log_log) }
+
+      context '#log_exception' do
+        it 'logs the exception message as an error and backtrace as debug' do
+          subject.should_receive(:log_error).twice
+          subject.should_receive(:log_debug)
+          subject.log_exception(RuntimeError.new('this is an exception'))
+        end
+      end
+
+      its(:log_signature) { should eq "[MyTestClass]" }
+      describe '#sign_message' do
+        specify { subject.sign_message("this is a test").should eq "[MyTestClass] this is a test" }
+        specify { subject.class.sign_message("this is a test").should eq "[MyTestClass] this is a test" }
+      end
+
+      it 'passes all embedded log calls to Logger instance' do
+        Protobuf::Logger.instance.should_receive(:debug).with('[MyTestClass] log this')
+        subject.log_debug('log this')
+      end
+
+    end
+  end
+end

data/spec/lib/protobuf/message_spec.rb

@@ -0,0 +1,368 @@
+require 'spec_helper'
+
+describe Protobuf::Message do
+
+  describe '.decode' do
+    let(:message) { ::Test::Resource.new(:name => "Jim") }
+
+    it 'creates a new message object decoded from the given bytes' do
+      ::Test::Resource.decode(message.encode).should eq message
+    end
+  end
+
+  describe 'defining a new field' do
+    context 'when defining a field with a tag that has already been used' do
+      it 'raises a TagCollisionError' do
+        expect {
+          Class.new(Protobuf::Message) do
+            optional ::Protobuf::Field::Int32Field, :foo, 1
+            optional ::Protobuf::Field::Int32Field, :bar, 1
+          end
+        }.to raise_error(Protobuf::TagCollisionError, /Field number 1 has already been used/)
+      end
+    end
+
+    context 'when defining an extension field with a tag that has already been used' do
+      it 'raises a TagCollisionError' do
+        expect {
+          Class.new(Protobuf::Message) do
+            extensions 100...110
+            optional ::Protobuf::Field::Int32Field, :foo, 100
+            optional ::Protobuf::Field::Int32Field, :bar, 100, :extension => true
+          end
+        }.to raise_error(Protobuf::TagCollisionError, /Field number 100 has already been used/)
+      end
+    end
+
+    context 'when defining a field with a name that has already been used' do
+      it 'raises a DuplicateFieldNameError' do
+        expect {
+          Class.new(Protobuf::Message) do
+            optional ::Protobuf::Field::Int32Field, :foo, 1
+            optional ::Protobuf::Field::Int32Field, :foo, 2
+          end
+        }.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
+      end
+    end
+
+    context 'when defining an extension field with a name that has already been used' do
+      it 'raises a DuplicateFieldNameError' do
+        expect {
+          Class.new(Protobuf::Message) do
+            extensions 100...110
+            optional ::Protobuf::Field::Int32Field, :foo, 1
+            optional ::Protobuf::Field::Int32Field, :foo, 100, :extension => true
+          end
+        }.to raise_error(Protobuf::DuplicateFieldNameError, /Field name foo has already been used/)
+      end
+    end
+  end
+
+  describe '.encode' do
+    let(:values) { { :name => "Jim" } }
+
+    it 'creates a new message object with the given values and returns the encoded bytes' do
+      ::Test::Resource.encode(values).should eq ::Test::Resource.new(values).encode
+    end
+  end
+
+  describe '#initialize' do
+    it "initializes the enum getter to 0" do
+      test_enum = Test::EnumTestMessage.new
+      test_enum.non_default_enum.should eq(0)
+    end
+
+    it "exposes the enum getter raw value through ! method" do
+      test_enum = Test::EnumTestMessage.new
+      test_enum.non_default_enum!.should be_nil
+    end
+
+    it "exposes the enum getter raw value through ! method (when set)" do
+      test_enum = Test::EnumTestMessage.new
+      test_enum.non_default_enum = 1
+      test_enum.non_default_enum!.should eq(1)
+    end
+
+    it "does not try to set attributes which have nil values" do
+      Test::EnumTestMessage.any_instance.should_not_receive("non_default_enum=")
+      Test::EnumTestMessage.new(:non_default_enum => nil)
+    end
+
+    it "takes a hash as an initialization argument" do
+      test_enum = Test::EnumTestMessage.new(:non_default_enum => 2)
+      test_enum.non_default_enum.should eq(2)
+    end
+
+    it "initializes with an object that responds to #to_hash" do
+      hashie_object = OpenStruct.new(:to_hash => { :non_default_enum => 2 })
+      test_enum = Test::EnumTestMessage.new(hashie_object)
+      test_enum.non_default_enum.should eq(2)
+    end
+  end
+
+  describe '#encode' do
+    context "encoding" do
+      it "accepts UTF-8 strings into string fields" do
+        message = ::Test::Resource.new(:name => "Kyle Redfearn\u0060s iPad")
+
+        expect { message.encode }.to_not raise_error
+      end
+
+      it "keeps utf-8 when utf-8 is input for string fields" do
+        name = "my name\xC3"
+        name.force_encoding("UTF-8")
+
+        message = ::Test::Resource.new(:name => name)
+        new_message = ::Test::Resource.decode(message.encode)
+        (new_message.name == name).should be_true
+      end
+
+      it "trims binary when binary is input for string fields" do
+        name = "my name\xC3"
+        name.force_encoding("ASCII-8BIT")
+
+        message = ::Test::Resource.new(:name => name)
+        new_message = ::Test::Resource.decode(message.encode)
+        (new_message.name == "my name").should be_true
+      end
+    end
+
+    context "when there's no value for a required field" do
+      let(:message) { ::Test::ResourceWithRequiredField.new }
+
+      it "raises a 'message not initialized' error" do
+        expect {
+          message.encode
+        }.to raise_error(Protobuf::SerializationError, /required/i)
+      end
+    end
+
+    context "repeated fields" do
+      let(:message) { ::Test::Resource.new(:name => "something") }
+
+      it "does not raise an error when repeated fields are []" do
+        expect {
+          message.repeated_enum = []
+          message.encode
+        }.to_not raise_error
+      end
+
+      it "sets the value to nil when empty array is passed" do
+        message.repeated_enum = []
+        message.instance_variable_get("@values")[:repeated_enum].should be_nil
+      end
+
+      it "does not compact the edit original array" do
+        a = [nil].freeze
+        message.repeated_enum = a
+        message.repeated_enum.should eq([])
+        a.should eq([nil].freeze)
+      end
+
+      it "compacts the set array" do
+        message.repeated_enum = [nil]
+        message.repeated_enum.should eq([])
+      end
+
+      it "raises TypeError when a non-array replaces it" do
+        expect {
+          message.repeated_enum = 2
+        }.to raise_error(/value of type/)
+      end
+    end
+  end
+
+  describe "boolean predicate methods" do
+    subject { Test::ResourceFindRequest.new(:name => "resource") }
+
+    it { should respond_to(:active?) }
+
+    it "sets the predicate to true when the boolean value is true" do
+      subject.active = true
+      subject.active?.should be_true
+    end
+
+    it "sets the predicate to false when the boolean value is false" do
+      subject.active = false
+      subject.active?.should be_false
+    end
+
+    it "does not put predicate methods on non-boolean fields" do
+      Test::ResourceFindRequest.new(:name => "resource").should_not respond_to(:name?)
+    end
+  end
+
+  describe "#respond_to_and_has?" do
+    subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
+
+    it "is false when the message does not have the field" do
+      subject.respond_to_and_has?(:other_field).should be_false
+    end
+
+    it "is true when the message has the field" do
+      subject.respond_to_and_has?(:non_default_enum).should be_true
+    end
+  end
+
+  describe "#respond_to_has_and_present?" do
+    subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
+
+    it "is false when the message does not have the field" do
+      subject.respond_to_and_has_and_present?(:other_field).should be_false
+    end
+
+    it "is false when the field is repeated and a value is not present" do
+      subject.respond_to_and_has_and_present?(:repeated_enums).should be_false
+    end
+
+    it "is false when the field is repeated and the value is empty array" do
+      subject.repeated_enums = []
+      subject.respond_to_and_has_and_present?(:repeated_enums).should be_false
+    end
+
+    it "is true when the field is repeated and a value is present" do
+      subject.repeated_enums = [2]
+      subject.respond_to_and_has_and_present?(:repeated_enums).should be_true
+    end
+
+    it "is true when the message has the field" do
+      subject.respond_to_and_has_and_present?(:non_default_enum).should be_true
+    end
+
+    context "#API" do
+      subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
+
+      it { should respond_to(:respond_to_and_has_and_present?) }
+      it { should respond_to(:responds_to_and_has_and_present?) }
+      it { should respond_to(:responds_to_has?) }
+      it { should respond_to(:respond_to_has?) }
+      it { should respond_to(:respond_to_has_present?) }
+      it { should respond_to(:responds_to_has_present?) }
+      it { should respond_to(:respond_to_and_has_present?) }
+      it { should respond_to(:responds_to_and_has_present?) }
+    end
+
+  end
+
+  describe '#to_hash' do
+    context 'generating values for an ENUM field' do
+      it 'converts the enum to its tag representation' do
+        hash = Test::EnumTestMessage.new(:non_default_enum => :TWO).to_hash
+        hash.should eq({ :non_default_enum => 2 })
+      end
+
+      it 'does not populate default values' do
+        hash = Test::EnumTestMessage.new.to_hash
+        hash.should eq(Hash.new)
+      end
+
+      it 'converts repeated enum fields to an array of the tags' do
+        hash = Test::EnumTestMessage.new(:repeated_enums => [ :ONE, :TWO, :TWO, :ONE ]).to_hash
+        hash.should eq({ :repeated_enums => [ 1, 2, 2, 1 ] })
+      end
+    end
+
+    context 'generating values for a Message field' do
+      it 'recursively hashes field messages' do
+        hash = Test::Nested.new({ :resource => { :name => 'Nested' } }).to_hash
+        hash.should eq({ :resource => { :name => 'Nested' } })
+      end
+
+      it 'recursively hashes a repeated set of messages' do
+        proto = Test::Nested.new(:multiple_resources => [
+          Test::Resource.new(:name => 'Resource 1'),
+          Test::Resource.new(:name => 'Resource 2')
+        ])
+
+        proto.to_hash.should eq({ :multiple_resources => [ { :name => 'Resource 1' },
+                                                           { :name => 'Resource 2' } ] })
+
+      end
+    end
+  end
+
+  describe '#to_json' do
+    subject do
+      ::Test::ResourceFindRequest.new({ :name => 'Test Name', :active => false })
+    end
+
+    its(:to_json) { should eq '{"name":"Test Name","active":false}' }
+  end
+
+  describe '.to_json' do
+    it 'returns the class name of the message for use in json encoding' do
+      expect {
+        ::Timeout.timeout(0.1) do
+          expect(::Test::Resource.to_json).to eq("Test::Resource")
+        end
+      }.not_to raise_error
+    end
+  end
+
+  describe "#define_setter" do
+    subject { ::Test::Resource.new }
+
+    it "allows string fields to be set to nil" do
+      expect { subject.name = nil }.to_not raise_error
+    end
+
+    it "does not allow string fields to be set to Numeric" do
+      expect { subject.name = 1}.to raise_error(/name/)
+    end
+  end
+
+  describe '.get_extension_field' do
+    it 'fetches an extension field by its tag' do
+      field = ::Test::Resource.get_extension_field(100)
+      expect(field).to be_a(::Protobuf::Field::BoolField)
+      expect(field.tag).to eq(100)
+      expect(field.name).to eq(:ext_is_searchable)
+      expect(field).to be_extension
+    end
+
+    it 'fetches an extension field by its symbolized name' do
+      expect(::Test::Resource.get_extension_field(:ext_is_searchable)).to be_a(::Protobuf::Field::BoolField)
+      expect(::Test::Resource.get_extension_field('ext_is_searchable')).to be_a(::Protobuf::Field::BoolField)
+    end
+
+    it 'returns nil when attempting to get a non-extension field' do
+      expect(::Test::Resource.get_extension_field(1)).to be_nil
+    end
+
+    it 'returns nil when field is not found' do
+      ::Test::Resource.get_extension_field(-1).should be_nil
+      ::Test::Resource.get_extension_field(nil).should be_nil
+    end
+  end
+
+  describe '.get_field' do
+    it 'fetches a non-extension field by its tag' do
+      field = ::Test::Resource.get_field(1)
+      expect(field).to be_a(::Protobuf::Field::StringField)
+      expect(field.tag).to eq(1)
+      expect(field.name).to eq(:name)
+      expect(field).not_to be_extension
+    end
+
+    it 'fetches a non-extension field by its symbolized name' do
+      expect(::Test::Resource.get_field(:name)).to be_a(::Protobuf::Field::StringField)
+      expect(::Test::Resource.get_field('name')).to be_a(::Protobuf::Field::StringField)
+    end
+
+    it 'fetches an extension field when forced' do
+      expect(::Test::Resource.get_field(100, true)).to be_a(::Protobuf::Field::BoolField)
+      expect(::Test::Resource.get_field(:ext_is_searchable, true)).to be_a(::Protobuf::Field::BoolField)
+      expect(::Test::Resource.get_field('ext_is_searchable', true)).to be_a(::Protobuf::Field::BoolField)
+    end
+
+    it 'returns nil when attempting to get an extension field' do
+      expect(::Test::Resource.get_field(100)).to be_nil
+    end
+
+    it 'returns nil when field is not defined' do
+      ::Test::Resource.get_field(-1).should be_nil
+      ::Test::Resource.get_field(nil).should be_nil
+    end
+  end
+
+end