moped-gridfs 1.0.0

data/spec/lib/moped/gridfs/getters.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+shared_examples :getters do
+
+  before do
+    file = bucket.open("file", "w")
+    file.write("foobar")
+    file.metadata = {pdf: true}
+  end
+
+  let(:file) { bucket.open("file", access_mode) }
+
+  let(:truncate_mode) { file.__send__(:truncate?) }
+
+  describe '#length' do
+
+    it 'returns the file length' do
+      expect(file.length).to eq(truncate_mode ? 0 : 6)
+    end
+  end
+
+  describe '#content_type' do
+
+    it 'returns the contentType value' do
+      expect(file.content_type).to eq('application/octet-stream')
+    end
+  end
+
+  describe '#chunk_size' do
+
+    it 'returns the file chunk size' do
+      expect(file.chunk_size).to eq(file.default_chunk_size)
+    end
+  end
+
+  describe '#filename' do
+
+    it 'returns the file chunk size' do
+      expect(file.filename).to eq("file")
+    end
+  end
+
+  describe '#md5' do
+
+    it 'returns the file chunk size' do
+      expected = Digest::MD5.hexdigest("foobar")
+      expect(file.md5).to eq(truncate_mode ? nil : expected)
+    end
+  end
+
+  describe '#metadata' do
+    it 'returns the file metadata' do
+      expected = {'pdf' => true}
+      expect(file.metadata).to eq(truncate_mode ? Hash.new : expected)
+    end
+  end
+
+  describe '#contentType' do
+
+    it 'is not defined' do
+      expect(file).not_to respond_to(:contentType)
+    end
+  end
+
+  describe '#chunkSize' do
+
+    it 'is not defined' do
+      expect(file).not_to respond_to(:chunkSize)
+    end
+  end
+
+  describe '#uploadDate' do
+
+    it 'is not defined' do
+      expect(file).not_to respond_to(:uploadDate)
+    end
+  end
+end

data/spec/lib/moped/gridfs/read.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+shared_examples :read do
+
+  context '#read' do
+
+    context 'when the file is empty' do
+
+      before do
+        bucket.open("file", "w").write('')
+      end
+
+      it 'returns an empty string' do
+        expect(bucket.open("file", access_mode).read).to eq('')
+      end
+    end
+
+    ["a", "\xE9a", "a"*($chunk_size-1), "a"*$chunk_size, "a"*($chunk_size)+"b"].each do |buffer|
+
+      before { buffer.force_encoding('BINARY') }
+
+      context "given a file #{buffer.size}-byte(s) long" do
+
+        let!(:file) do
+          bucket.open("file", "w").write(buffer)
+          file = bucket.open("file", access_mode)
+          file.rewind if file.append?
+          file
+        end
+
+        it 'changes the position' do
+          (1..buffer.size).to_a.concat([buffer.size*2]) do |i|
+            file.rewind
+            expect(file.read(i)).to eq(buffer[0..i - 1])
+          end
+        end
+
+        context "when called without args" do
+
+          it 'returns the whole file content' do
+            expect(file.read).to eq(buffer)
+          end
+        end
+
+        context "when called multiple times to read some bytes each time" do
+
+          it 'returns the expected data' do
+            data = []
+            data << file.read(1) until file.eof?
+            expect(data.size).to eq(buffer.size)
+            expect(data.join).to eq(buffer)
+          end
+
+          it 'changes the position' do
+            readed = 0
+            steps = []
+            2.times { steps << buffer.size / 2 }
+            steps << buffer.size % 2
+
+            steps.each_with_index do |size, index|
+              file.read(size)
+              expect(file.pos).to eq(readed += size)
+            end
+          end
+        end
+
+        context 'when zero is passed' do
+
+          it 'returns an empty string' do
+            expect(file.read(0)).to eq('')
+          end
+
+          it 'does not change the position' do
+            file.read(0)
+            expect(file.pos).to be_zero
+          end
+        end
+
+        context 'when a negative number is passed' do
+
+          before { file.read(1) }
+
+          it 'raises an error' do
+            expect { file.read(-1) }.to raise_error
+          end
+
+          it 'does not change the position' do
+            expect(file.pos).to eq(1)
+          end
+        end
+
+        context "when an integer is passed" do
+
+          it 'returns the content of the file up to the given position' do
+            expect(file.read(buffer.size * 2)).to eq(buffer)
+
+            (1..buffer.size).to_a do |i|
+              file.rewind
+              expect(file.read(i)).to eq(buffer[0..i - 1])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/moped/gridfs/setters.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+shared_examples :setters do
+
+  before do
+    file = bucket.open("file", "w")
+    file.write("foobar")
+    file.metadata = {pdf: true}
+  end
+
+  let(:file) { bucket.open("file", access_mode) }
+
+  let(:truncate_mode) { file.__send__(:truncate?) }
+
+  describe '#length=' do
+
+    it 'is not defined' do
+      expect(file).not_to respond_to(:length=)
+    end
+  end
+
+  describe '#content_type=' do
+
+    before { file.content_type = "foo" }
+
+    it 'changes the contentType attribute in memory' do
+      expect(file.content_type).to eq("foo")
+    end
+
+    it 'changes the contentType attribute on disk' do
+      expect(bucket.open("file", "r").content_type).to eq("foo")
+    end
+  end
+
+  describe '#contentType=' do
+
+    it 'is not defined' do
+      expect(file).not_to respond_to(:contentType=)
+    end
+  end
+
+  describe '#chunk_size=' do
+
+    it 'is not defined' do
+      expect(file).not_to respond_to(:chunk_size=)
+    end
+  end
+
+  describe '#chunkSize=' do
+
+    it 'is not defined' do
+      expect(file).not_to respond_to(:chunkSize=)
+    end
+  end
+
+  describe '#filename=' do
+
+    before { file.filename = "foo" }
+
+    it 'changes the contentType attribute in memory' do
+      expect(file.filename).to eq("foo")
+    end
+
+    it 'changes the contentType attribute on disk' do
+      expect { bucket.open("foo", "r") }.not_to raise_error
+    end
+  end
+
+  describe '#md5=' do
+
+    it 'is not defined' do
+      expect(file).not_to respond_to(:md5=)
+    end
+  end
+
+
+  describe '#metadata=' do
+
+    let(:metadata) { {key: 'value'} }
+
+    before { file.metadata = metadata }
+
+    it 'changes the contentType attribute in memory' do
+      expect(file.metadata).to eq(metadata)
+    end
+
+    it 'changes the contentType attribute on disk' do
+      expect(bucket.open("file", "r").metadata).to eq('key' => 'value')
+    end
+  end
+
+  describe '#uploadDate=' do
+
+    it 'is not defined' do
+      expect(file).not_to respond_to(:uploadDate=)
+    end
+  end
+
+  describe '#upload_date=' do
+
+    let(:now) { Time.new(2013,01,01).utc }
+
+    before { file.upload_date = now }
+
+    it 'changes the contentType attribute in memory' do
+      expect(file.upload_date).to eq(now)
+    end
+
+    it 'changes the contentType attribute on disk' do
+      expect(bucket.open("file", "r").upload_date).to eq(now)
+    end
+  end
+end

data/spec/lib/moped/gridfs/write.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+shared_examples :write do
+
+  describe '#write' do
+    ["a", "\xE9a", "a"*($chunk_size-1), "a"*$chunk_size, "a"*($chunk_size)+"b"].each do |buffer|
+
+      before { buffer.force_encoding('BINARY') }
+
+      pos1 = buffer.size + rand(1..$chunk_size*2)
+
+      pos2 = rand(0..buffer.size-1)
+
+      context "given a #{buffer.size}-byte(s) long buffer" do
+
+        context "when start from a position greater (#{pos1}) than the file length" do
+
+          let(:file) { bucket.open("file", access_mode) }
+
+          before do
+            file.write(buffer)
+            file.seek(pos1)
+            file.write(buffer)
+          end
+
+          it 'writes the data' do
+            expect(bucket.open("file", "r").read).to eq(buffer * 2)
+          end
+
+          it 'updates the length' do
+            expect(file.length).to eq(buffer.size * 2)
+          end
+
+          it 'updates the position' do
+            expect(file.pos).to eq(buffer.size * 2)
+          end
+
+          it 'updates the md5' do
+            expect(file.md5).to eq(Digest::MD5.hexdigest(buffer+buffer))
+          end
+
+          it 'writes the length attributes' do
+            expect(bucket.open("file", "r").length).to eq(buffer.size * 2)
+          end
+        end
+
+        context "when start from a position (#{pos2}) lesser than the file length" do
+
+          let(:file) { bucket.open("file", access_mode) }
+
+          let(:buffer2) { 'data' }
+
+          before do
+            file.write(buffer)
+            file.seek(pos2)
+            file.write(buffer2)
+          end
+
+          let(:expected) do
+            if file.append?
+              buffer + buffer2
+            else
+              s = buffer2.size
+              pos2.zero? ? "#{buffer2}#{buffer[s..-1]}" : "#{buffer[0..pos2-1]}#{buffer2}#{buffer[pos2+s..-1]}"
+            end
+          end
+
+          it 'write the data' do
+            expect(bucket.open("file", "r").read).to eq(expected)
+          end
+
+          it 'updates the length' do
+            expect(file.length).to eq(expected.size)
+          end
+
+          it 'updates the position' do
+            expected_pos = file.append? ? buffer.size + buffer2.size : pos2 + buffer2.size
+            expect(file.pos).to eq(expected_pos)
+          end
+
+          it 'updates the md5' do
+            expect(file.md5).to eq(Digest::MD5.hexdigest(expected))
+          end
+
+          it 'writes the length attributes' do
+            expect(bucket.open("file", "r").length).to eq(expected.size)
+          end
+        end
+
+        context 'when start from a non-zero position' do
+
+          let(:file) { bucket.open("file", access_mode) }
+
+          before do
+            file.seek($chunk_size * 3)
+            file.write(buffer)
+          end
+
+          it 'writes from the start' do
+            expect(bucket.open("file", "r").read).to eq(buffer)
+          end
+
+          it 'updates the length' do
+            expect(file.length).to eq(buffer.size)
+          end
+
+          it 'updates the position' do
+            expect(file.pos).to eq(buffer.size)
+          end
+
+          it 'updates the md5' do
+            expect(file.md5).to eq(Digest::MD5.hexdigest(buffer))
+          end
+
+          it 'writes the length attributes' do
+            expect(bucket.open("file", "r").length).to eq(buffer.size)
+          end
+        end
+
+        (1..5).each do |n|
+          context "when is written #{n} times" do
+            let(:file) { bucket.open("file", access_mode) }
+
+            before do
+              n.times { file.write(buffer) }
+            end
+
+            it 'writes the data' do
+              expect(bucket.open("file", "r").read).to eq(buffer*n)
+            end
+
+            it 'writes the length attributes' do
+              expect(bucket.open("file", "r").length).to eq(buffer.size*n)
+            end
+
+          it 'updates the md5' do
+            expect(file.md5).to eq(Digest::MD5.hexdigest(buffer*n))
+          end
+
+            it 'updates the length' do
+              expect(file.length).to eq(buffer.size*n)
+            end
+
+            it 'updates the position' do
+              expect(file.pos).to eq(buffer.size*n)
+            end
+          end
+        end
+      end
+    end
+  end
+end