spec/message_spec.rb in dripdrop-0.5.0 vs spec/message_spec.rb in dripdrop-0.6.0

@@ -7,12 +7,12 @@
 describe DripDrop::Message do
   describe "basic message" do
     def create_basic
       attrs = {
         :name => 'test',
-        :head => {:foo => :bar},
-        :body => [:foo, :bar, :baz]
+        :head => {'foo' => 'bar'},
+        :body => ['foo', 'bar', 'baz']
       }
       message = DripDrop::Message.new(attrs[:name],:head => attrs[:head],
                                                    :body => attrs[:body])
       [message, attrs]
     end
@@ -26,11 +26,11 @@
         lambda {
           DripDrop::Message.new('nameonly')
         }.should_not raise_exception
       end
       it "should set the head to a single key hash containing message class if nil provided" do
-        DripDrop::Message.new('nilhead', :head => nil).head.should == {:msg_class => 'DripDrop::Message'}
+        DripDrop::Message.new('nilhead', :head => nil).head.should == {'msg_class' => 'DripDrop::Message'}
       end
       it "should raise an exception if a non-hash, non-nil head is provided" do
         lambda {
           DripDrop::Message.new('arrhead', :head => [])
         }.should raise_exception(ArgumentError)
@@ -38,14 +38,14 @@
     end
     describe "encoding" do
       before(:all) do
         @message, @attrs = create_basic
       end
-      it "should encode to valid BERT hash without error" do
+      it "should encode to valid MessagePack hash without error" do
         enc = @message.encoded
         enc.should be_a(String)
-        BERT.decode(enc).should be_a(Hash)
+        MessagePack.unpack(enc).should be_a(Hash)
       end
       it "should decode encoded messages without errors" do
         DripDrop::Message.decode(@message.encoded).should be_a(DripDrop::Message)
       end
       it "should encode to valid JSON without error" do
@@ -65,12 +65,12 @@
     end
     describe "subclassing" do
       def create_auto_message
         attrs = {
           :name => 'test',
-          :head => {:foo => :bar, :msg_class => 'SpecMessageClass'},
-          :body => [:foo, :bar, :baz]
+          :head => {'foo' => 'bar', 'msg_class' => 'SpecMessageClass'},
+          :body => ['foo', 'bar', 'baz']
         }
 
         message = DripDrop::AutoMessageClass.create_message(attrs)
 
         [message, attrs]
@@ -79,24 +79,19 @@
         @message, @attrs = create_auto_message
       end
       it "should be added to the subclass message class hash if SubclassedMessage included" do
         DripDrop::AutoMessageClass.message_subclasses.should include('SpecMessageClass' => SpecMessageClass)
       end
-      it "should set the msg_class using a symbol, not a string when using JSON" do
-        msg = DripDrop::Message.decode_json(DripDrop::Message.new('test').json_encoded)
-        msg.head['msg_class'].should be_nil
-        msg.head[:msg_class].should  == 'DripDrop::Message'
-      end
       it "should throw an exception if we try to recreate a message of the wrong class" do
         msg = DripDrop::Message.new('test')
         lambda{SpecMessageClass.recreate_message(msg.to_hash)}.should raise_exception
       end
 
       describe "DripDrop::AutoMessageClass" do
-        it "should create a properly classed message based on head[:msg_class]" do
+        it "should create a properly classed message based on head['msg_class']" do
           @message.should be_a(SpecMessageClass)
         end
-        it "should recreate a message based on head[:msg_class]" do
+        it "should recreate a message based on head['msg_class']" do
           DripDrop::AutoMessageClass.recreate_message(@message.to_hash).should be_a(SpecMessageClass)
         end
       end
     end
   end