bson 3.2.7-java → 4.0.0.beta-java

data/spec/bson/code_with_scope_spec.rb

@@ -63,8 +63,8 @@ describe BSON::CodeWithScope do
     end
     let(:obj) { described_class.new(code, scope) }
     let(:bson) do
-      "#{47.to_bson}#{(code.length + 1).to_bson}#{code}#{BSON::NULL_BYTE}" +
-      "#{scope.to_bson}"
+      "#{47.to_bson.to_s}#{(code.length + 1).to_bson.to_s}#{code}#{BSON::NULL_BYTE}" +
+      "#{scope.to_bson.to_s}"
     end
 
     it_behaves_like "a bson element"
@@ -79,7 +79,7 @@ describe BSON::CodeWithScope do
       { "name" => "test" }
     end
     let(:obj) { described_class.new(code, scope) }
-    let(:bson) { StringIO.new(obj.to_bson) }
+    let(:bson) { BSON::ByteBuffer.new(obj.to_bson.to_s) }
     let!(:deserialized) { described_class.from_bson(bson) }
 
     it "deserializes the javascript" do
@@ -89,9 +89,5 @@ describe BSON::CodeWithScope do
     it "deserializes the scope" do
       expect(deserialized.scope).to eq(scope)
     end
-
-    it "does not leave any extra bytes" do
-      expect(bson.read(1)).to be_nil
-    end
   end
 end

data/spec/bson/document_spec.rb

@@ -159,6 +159,20 @@ describe BSON::Document do
           expect(doc.send(method, "indigo")).to be false
         end
       end
+
+      context "when the key exists and is requested with a symbol" do
+
+        it "returns true" do
+          expect(doc.send(method, :blue)).to be true
+        end
+      end
+
+      context "when the key does not exist and is requested with a symbol" do
+
+        it "returns false" do
+          expect(doc.send(method, :indigo)).to be false
+        end
+      end
     end
   end
 
@@ -166,6 +180,13 @@ describe BSON::Document do
 
     describe "##{method}" do
 
+      let(:key) { :purple }
+      let(:val) { :'5422a8' }
+
+      before do
+        doc[key] = val
+      end
+
       context "when the value exists" do
 
         it "returns true" do
@@ -179,6 +200,21 @@ describe BSON::Document do
           expect(doc.send(method, "ABCABC")).to be false
         end
       end
+
+      context "when the value exists and is requested with a symbol" do
+
+        it "returns true" do
+
+          expect(doc.send(method, :'5422a8')).to be true
+        end
+      end
+
+      context "when the value does not exist and is requested with a symbol" do
+
+        it "returns false" do
+          expect(doc.send(method, :ABCABC)).to be false
+        end
+      end
     end
   end
 
@@ -653,11 +689,11 @@ describe BSON::Document do
       end
 
       let(:serialized) do
-        document.to_bson
+        document.to_bson.to_s
       end
 
       let(:deserialized) do
-        described_class.from_bson(StringIO.new(serialized))
+        described_class.from_bson(BSON::ByteBuffer.new(serialized))
       end
 
       it 'deserializes the documents' do
@@ -688,7 +724,7 @@ describe BSON::Document do
       end
 
       it "properly serializes the symbol" do
-        expect(obj.to_bson).to eq(bson)
+        expect(obj.to_bson.to_s).to eq(bson)
       end
     end
 
@@ -723,7 +759,7 @@ describe BSON::Document do
       it_behaves_like "a deserializable bson element"
 
       let(:raw) do
-        StringIO.new(bson)
+        BSON::ByteBuffer.new(bson)
       end
 
       it "returns an instance of a BSON::Document" do
@@ -768,7 +804,7 @@ describe BSON::Document do
       end
 
       let(:deserialized) do
-        described_class.from_bson(StringIO.new(document.to_bson))
+        described_class.from_bson(BSON::ByteBuffer.new(document.to_bson.to_s))
       end
 
       it "serializes and deserializes properly" do
@@ -812,30 +848,50 @@ describe BSON::Document do
       it_behaves_like "a document able to handle utf-8"
     end
 
-    context "when non utf-8 values exist" do
+    context "when utf-8 values exist in wrong encoding" do
 
       let(:string) { "gültig" }
       let(:document) do
         described_class["type", string.encode("iso-8859-1")]
       end
 
+      it "raises an exception", unless: BSON::Environment.jruby? do
+        expect {
+          document.to_bson
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'converts the values', if: BSON::Environment.jruby? do
+        expect(
+          BSON::Document.from_bson(BSON::ByteBuffer.new(document.to_bson.to_s))
+        ).to eq({ "type" => string })
+      end
+    end
+
+    context "when binary strings with utf-8 values exist", if: BSON::Environment.jruby? && !(ENV['RUBY_VERSION'] =~ /jruby-9/) do
+
+      let(:string) { "europäisch" }
+      let(:document) do
+        described_class["type", string.encode("binary")]
+      end
+
       it "encodes and decodes the document properly" do
         expect(
-          BSON::Document.from_bson(StringIO.new(document.to_bson))
+          BSON::Document.from_bson(BSON::ByteBuffer.new(document.to_bson.to_s))
         ).to eq({ "type" => string })
       end
     end
 
-    context "when binary strings with utf-8 values exist" do
+    context "when binary strings with utf-8 values exist", unless: BSON::Environment.jruby? do
 
-      let(:string) { "europäischen" }
+      let(:string) { "europäisch" }
       let(:document) do
         described_class["type", string.encode("binary", "binary")]
       end
 
       it "encodes and decodes the document properly" do
         expect(
-          BSON::Document.from_bson(StringIO.new(document.to_bson))
+          BSON::Document.from_bson(BSON::ByteBuffer.new(document.to_bson.to_s))
         ).to eq({ "type" => string })
       end
     end

data/spec/bson/hash_spec.rb

@@ -29,8 +29,8 @@ describe Hash do
       end
 
       let(:bson) do
-        "#{20.to_bson}#{String::BSON_TYPE}key#{BSON::NULL_BYTE}" +
-        "#{6.to_bson}value#{BSON::NULL_BYTE}#{BSON::NULL_BYTE}"
+        "#{20.to_bson.to_s}#{String::BSON_TYPE}key#{BSON::NULL_BYTE}" +
+        "#{6.to_bson.to_s}value#{BSON::NULL_BYTE}#{BSON::NULL_BYTE}"
       end
 
       it_behaves_like "a serializable bson element"
@@ -44,9 +44,9 @@ describe Hash do
       end
 
       let(:bson) do
-        "#{32.to_bson}#{Hash::BSON_TYPE}field#{BSON::NULL_BYTE}" +
-        "#{20.to_bson}#{String::BSON_TYPE}key#{BSON::NULL_BYTE}" +
-        "#{6.to_bson}value#{BSON::NULL_BYTE}#{BSON::NULL_BYTE}#{BSON::NULL_BYTE}"
+        "#{32.to_bson.to_s}#{Hash::BSON_TYPE}field#{BSON::NULL_BYTE}" +
+        "#{20.to_bson.to_s}#{String::BSON_TYPE}key#{BSON::NULL_BYTE}" +
+        "#{6.to_bson.to_s}value#{BSON::NULL_BYTE}#{BSON::NULL_BYTE}#{BSON::NULL_BYTE}"
       end
 
       it_behaves_like "a serializable bson element"

data/spec/bson/int32_spec.rb

@@ -27,16 +27,18 @@ describe BSON::Int32 do
   end
 
   describe "when the integer is negative" do
+
     let(:decoded) { -1 }
-    let(:encoded) {StringIO.new([ -1 ].pack(BSON::Int32::PACK))}
+    let(:encoded) { BSON::ByteBuffer.new([ -1 ].pack(BSON::Int32::PACK)) }
     let(:decoded_2) { -50 }
-    let(:encoded_2) {StringIO.new([ -50 ].pack(BSON::Int32::PACK))}
+    let(:encoded_2) { BSON::ByteBuffer.new([ -50 ].pack(BSON::Int32::PACK)) }
+
     it "decodes a -1 correctly" do
       expect(BSON::Int32.from_bson(encoded)).to eq(decoded)
-    end  
+    end
+
     it "decodes a -50 correctly" do
       expect(BSON::Int32.from_bson(encoded_2)).to eq(decoded_2)
-    end  
+    end
   end
-  
 end

data/spec/bson/integer_spec.rb

@@ -63,14 +63,9 @@ describe Integer do
 
     let(:obj)  { Integer::MAX_32BIT - 1 }
     let(:encoded) { obj.to_s + BSON::NULL_BYTE }
-    let(:previous_content) { 'previous_content'.force_encoding(BSON::BINARY) }
 
     it "returns the encoded string" do
-      expect(obj.to_bson_key).to eq(encoded)
-    end
-
-    it "appends to optional previous content" do
-      expect(obj.to_bson_key(previous_content)).to eq(previous_content << encoded)
+      expect(obj.to_bson_key.to_s).to eq(encoded)
     end
   end
 end

data/spec/bson/object_id_spec.rb

@@ -379,44 +379,7 @@ describe BSON::ObjectId do
     end
 
     it "returns a hash of the raw bytes" do
-      expect(object_id.hash).to eq(object_id.to_bson.hash)
-    end
-  end
-
-  describe "#clone" do
-
-    context "when the data has not been generated yet" do
-
-      let!(:object_id) do
-        described_class.new
-      end
-
-      let!(:clone) do
-        object_id.clone
-      end
-
-      it "generates and copies the data" do
-        expect(clone).to eq(object_id)
-      end
-    end
-
-    context "when the data has been generated" do
-
-      let!(:object_id) do
-        described_class.new
-      end
-
-      let(:clone) do
-        object_id.clone
-      end
-
-      before do
-        object_id.to_s
-      end
-
-      it "copies the data" do
-        expect(clone).to eq(object_id)
-      end
+      expect(object_id.hash).to eq(object_id.to_bson.to_s.hash)
     end
   end
 
@@ -525,7 +488,7 @@ describe BSON::ObjectId do
     let(:time) { Time.utc(2013, 1, 1) }
     let(:type) { 7.chr }
     let(:obj)  { described_class.from_time(time) }
-    let(:bson) { obj.to_bson }
+    let(:bson) { obj.to_bson.to_s }
 
     it_behaves_like "a bson element"
     it_behaves_like "a serializable bson element"

data/spec/bson/regexp_spec.rb

@@ -37,7 +37,7 @@ describe Regexp do
     let(:obj)  { /test/ }
 
     let(:io) do
-      StringIO.new(bson)
+      BSON::ByteBuffer.new(bson)
     end
 
     let(:regex) do

data/spec/bson/string_spec.rb

@@ -22,109 +22,13 @@ describe String do
 
     let(:type) { 2.chr }
     let(:obj) { "test" }
-    let(:bson) { "#{5.to_bson}test#{BSON::NULL_BYTE}" }
+    let(:bson) { "#{5.to_bson.to_s}test#{BSON::NULL_BYTE}" }
 
     it_behaves_like "a bson element"
     it_behaves_like "a serializable bson element"
     it_behaves_like "a deserializable bson element"
   end
 
-  describe "#to_bson_cstring" do
-
-    context "when the string is valid" do
-
-      let(:string) do
-        "test"
-      end
-
-      let(:encoded) do
-        string.to_bson_cstring
-      end
-
-      let(:previous_content) do
-        'previous_content'.force_encoding(BSON::BINARY)
-      end
-
-      it "returns the encoded string" do
-        expect(encoded).to eq("test#{BSON::NULL_BYTE}")
-      end
-
-      it_behaves_like "a binary encoded string"
-
-      it "appends to optional previous content" do
-        expect(string.to_bson_cstring(previous_content)).to eq(previous_content << encoded)
-      end
-    end
-
-    context "when the string contains a null byte" do
-
-      let(:string) do
-        "test#{BSON::NULL_BYTE}ing"
-      end
-
-      it "raises an error" do
-        expect {
-          string.to_bson_cstring
-        }.to raise_error(ArgumentError)
-      end
-    end
-
-    context "when the string contains utf-8 characters" do
-
-      let(:string) do
-        "Straße"
-      end
-
-      let(:encoded) do
-        string.to_bson_cstring
-      end
-
-      let(:char) do
-        "ß".chr.force_encoding(BSON::BINARY)
-      end
-
-      it "returns the encoded string" do
-        expect(encoded).to eq("Stra#{char}e#{BSON::NULL_BYTE}")
-      end
-
-      it_behaves_like "a binary encoded string"
-    end
-
-    context "when the string is encoded in non utf-8" do
-
-      let(:string) do
-        "Straße".encode("iso-8859-1")
-      end
-
-      let(:encoded) do
-        string.to_bson_cstring
-      end
-
-      let(:char) do
-        "ß".chr.force_encoding(BSON::BINARY)
-      end
-
-      it "returns the encoded string" do
-        expect(encoded).to eq("Stra#{char}e#{BSON::NULL_BYTE}")
-      end
-
-      it_behaves_like "a binary encoded string"
-    end
-
-    context "when the string contains non utf-8 characters" do
-
-      let(:string) do
-        255.chr
-      end
-
-      it "raises an error" do
-        expect {
-          string.to_bson_cstring
-        }.to raise_error(EncodingError)
-      end
-    end
-  end
-
   describe "#to_bson_object_id" do
 
     context "when the string has 12 characters" do
@@ -152,107 +56,6 @@ describe String do
     end
   end
 
-  describe "#to_bson_string" do
-
-    context "when the string is valid" do
-
-      let(:string) do
-        "test"
-      end
-
-      let(:encoded) do
-        string.to_bson_string
-      end
-
-      let(:previous_content) do
-        'previous_content'.force_encoding(BSON::BINARY)
-      end
-
-      it "returns the string" do
-        expect(encoded).to eq(string)
-      end
-
-      it_behaves_like "a binary encoded string"
-
-      it "appends to optional previous content" do
-        expect(string.to_bson_string(previous_content)).to eq(previous_content << encoded)
-      end
-
-    end
-
-    context "when the string contains a null byte" do
-
-      let(:string) do
-        "test#{BSON::NULL_BYTE}ing"
-      end
-
-      let(:encoded) do
-        string.to_bson_string
-      end
-
-      it "retains the null byte" do
-        expect(encoded).to eq(string)
-      end
-
-      it_behaves_like "a binary encoded string"
-    end
-
-    context "when the string contains utf-8 characters" do
-
-      let(:string) do
-        "Straße"
-      end
-
-      let(:encoded) do
-        string.to_bson_string
-      end
-
-      let(:char) do
-        "ß".chr.force_encoding(BSON::BINARY)
-      end
-
-      it "returns the encoded string" do
-        expect(encoded).to eq("Stra#{char}e")
-      end
-
-      it_behaves_like "a binary encoded string"
-    end
-
-    context "when the string is encoded in non utf-8" do
-
-      let(:string) do
-        "Straße".encode("iso-8859-1")
-      end
-
-      let(:encoded) do
-        string.to_bson_string
-      end
-
-      let(:char) do
-        "ß".chr.force_encoding(BSON::BINARY)
-      end
-
-      it "returns the encoded string" do
-        expect(encoded).to eq("Stra#{char}e")
-      end
-
-      it_behaves_like "a binary encoded string"
-    end
-
-    context "when the string contains non utf-8 characters" do
-
-      let(:string) do
-        255.chr
-      end
-
-      it "raises an error" do
-        expect {
-          string.to_bson_string
-        }.to raise_error(EncodingError)
-      end
-    end
-  end
-
   context "when the class is loaded" do
 
     let(:registered) do
@@ -267,16 +70,11 @@ describe String do
   describe "#to_bson_key" do
 
     let(:string) { "test" }
-    let(:encoded) { string.to_s + BSON::NULL_BYTE }
-    let(:previous_content) { 'previous_content'.force_encoding(BSON::BINARY) }
+    let(:encoded) { string.to_s }
 
     it "returns the encoded string" do
       expect(string.to_bson_key).to eq(encoded)
     end
-
-    it "appends to optional previous content" do
-      expect(string.to_bson_key(previous_content)).to eq(previous_content << encoded)
-    end
   end
 
   describe "#to_hex_string" do