defog 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f78e9196fe479090f8c5a32df1c2bc936d45c48
-  data.tar.gz: 28c49ba6db95862f3b245e5aab5d703d4b5afa21
+  metadata.gz: 2a60db0801e91688744ef767c60e5f2c63bc4459
+  data.tar.gz: e889069aa987fec086b1f1fe355bc5807c7fe7ec
 SHA512:
-  metadata.gz: 1fedff27855d7b2adb3685bdadd3be1c937a9f9dae9c66240524e28773f08b593fa9f673f92d091f9fdb1ba7848e2cff871dd419acfb5ff8751aed82a5af0949
-  data.tar.gz: deedf9a852806d1d41d74267586c7cabe5e50a92e358f00f073f24d06bc8d603b86ca9306a2fee213de8e58cae539bcc7b8ead5875d6b4255d2e47e12558e31b
+  metadata.gz: 98059d13cc752f0552a2afa0699808efbc25715c66fcb1e3bc35760fc47bcc88ed8e729e54fb2a8be305e42eca48ae8191b2e2a19588e844d837811ee6697008
+  data.tar.gz: 6ad35f25424c6bd77b59d419bf1efc9e9cab2ac85477452ad44419177b3f877dc9d9ce90ef29877a01859043171f5962c9d65e90b98924c4d3f88037a98cc490

data/.travis.yml

@@ -1,3 +1,4 @@
+sudo: false
 rvm:
   - 1.9.3
   - 2.1.3

data/README.md

@@ -253,6 +253,7 @@ plus appropriate rspec examples.)
 ## History
 
 Release Notes:
+* 0.9.4 - Bug fix: don't fail when checking atime if file gets deleted by another process (more robust)
 * 0.9.3 - Bug fix: don't fail when measuring cache if file gets deleted by another process (more robust)
 * 0.9.2 - Bug fix: don't fail when measuring cache if file gets deleted by another process (more robust)
 * 0.9.1 - Bug fix: don't fail when measuring cache if file gets deleted by another process

data/defog.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rdoc'
-  gem.add_development_dependency 'rspec', "<2.99"
+  gem.add_development_dependency 'rspec', "~> 3.0"
   gem.add_development_dependency 'simplecov'
-  gem.add_development_dependency 'simplecov-gem-adapter'
+  gem.add_development_dependency 'simplecov-gem-profile'
 end

data/lib/defog/proxy.rb

@@ -237,7 +237,10 @@ module Defog
       begin
         path.send method
       rescue Errno::ENOENT
-        0
+        case method
+        when :atime then Time.new(0)
+        else 0
+        end
       end
     end
 

data/lib/defog/version.rb

@@ -1,3 +1,3 @@
 module Defog
-  VERSION = "0.9.3"
+  VERSION = "0.9.4"
 end

data/spec/file_spec.rb

@@ -6,7 +6,7 @@ shared_examples "get proxy" do
     create_remote("hello")
     should_log /Download/
     file = @proxy.file(key, @mode)
-    File.exist?(file.path).should be_true
+    expect(File.exist?(file.path)).to be_truthy
     file.close
   end
 
@@ -17,24 +17,24 @@ shared_examples "get proxy" do
   it "should overwrite existing proxy if it's not valid " do
     create_remote("hello")
     create_proxy("goodbye")
-    proxy_path.read.should == "goodbye"
+    expect(proxy_path.read).to eq("goodbye")
     should_log /Download/
     @proxy.file(key, @mode)
-    proxy_path.read.should == "hello"
+    expect(proxy_path.read).to eq("hello")
   end
 
   it "should use existing proxy if it's valid" do
     create_remote("hello")
     create_proxy("hello")
     handle = @proxy.file(key)
-    handle.proxy_path.should_not_receive(:open).with(/^w/)
+    expect(handle.proxy_path).not_to receive(:open).with(/^w/)
     should_not_log /Download/
     handle.open(@mode)
   end
 
   it "should include key info in exception messages" do
     create_remote("error me")
-    File.any_instance.should_receive(:write) { raise Encoding::UndefinedConversionError, "dummy" }
+    expect_any_instance_of(File).to receive(:write) { raise Encoding::UndefinedConversionError, "dummy" }
     expect {
       @proxy.file(key, "r")
     }.to raise_error Encoding::UndefinedConversionError, /#{key}/
@@ -46,22 +46,22 @@ shared_examples "read" do
     create_remote("read me")
     @proxy.file(key, @mode) do |file|
       file.rewind
-      file.read.should == "read me"
+      expect(file.read).to eq("read me")
     end
   end
 
   it "should pass 'b' mode through" do
     create_remote("binary me")
     @proxy.file(key, "#{@mode}b") do |file|
-      file.external_encoding.name.should == "ASCII-8BIT"
+      expect(file.external_encoding.name).to eq("ASCII-8BIT")
     end
   end
 
   it "should pass encodings through" do
     create_remote("encode me")
     @proxy.file(key, "#{@mode}:EUC-JP:UTF-8") do |file|
-      file.external_encoding.name.should == "EUC-JP"
-      file.internal_encoding.name.should == "UTF-8"
+      expect(file.external_encoding.name).to eq("EUC-JP")
+      expect(file.internal_encoding.name).to eq("UTF-8")
     end
   end
 
@@ -72,7 +72,7 @@ shared_examples "read after write" do
     @proxy.file(key, @mode) do |file|
       file.write "read me"
       file.rewind
-      file.read.should == "read me"
+      expect(file.read).to eq("read me")
     end
   end
 end
@@ -83,7 +83,7 @@ shared_examples "write" do
     @proxy.file(key, @mode, :persist => true) do |file|
       file.write "write me"
     end
-    proxy_path.read.should =~ /write me$/
+    expect(proxy_path.read).to match(/write me$/)
   end
 end
 
@@ -94,7 +94,7 @@ shared_examples "append" do
       file.write "goodbye"
       should_log /Upload/
     end
-    proxy_path.read.should == "hellogoodbye"
+    expect(proxy_path.read).to eq("hellogoodbye")
   end
 end
 
@@ -105,7 +105,7 @@ shared_examples "create" do
     file = @proxy.file(key, @mode)
     create_proxy("upload me")
     file.close
-    remote_body.should == "upload me"
+    expect(remote_body).to eq("upload me")
   end
 
   it "should not create remote if proxy is deleted" do
@@ -114,7 +114,7 @@ shared_examples "create" do
       file.write("ignore me")
       proxy_path.unlink
     end
-    expect {remote_body}.to raise_error
+    expect(remote_body).to be_nil
   end
 
   it "should not create remote if :synchronize => false" do
@@ -122,19 +122,19 @@ shared_examples "create" do
     file = @proxy.file(key, @mode)
     create_proxy("ignore me")
     file.close(:synchronize => false)
-    expect {remote_body}.to raise_error
+    expect(remote_body).to be_nil
   end
 
   it "should create remote asynchronously if :synchronize => async" do
     should_log /Upload/
     file = @proxy.file(key, @mode)
     create_proxy("upload me in thread")
-    Thread.should_receive(:new) { |&block|
-      expect {remote_body}.to raise_error
+    expect(Thread).to receive(:new) { |&block|
+      expect(remote_body).to be_nil
       block.call
     }
     file.close(:synchronize => :async)
-    remote_body.should == "upload me in thread"
+    expect(remote_body).to eq("upload me in thread")
   end
 
 end
@@ -143,25 +143,25 @@ shared_examples "update" do
 
   it "should overwrite remote" do
     create_remote("overwrite me")
-    remote_body.should == "overwrite me"
+    expect(remote_body).to eq("overwrite me")
     file = @proxy.file(key, @mode)
     create_proxy("upload me")
     should_log /Upload/
     file.close
-    remote_body.should == "upload me"
+    expect(remote_body).to eq("upload me")
   end
 
   it "should overwrite remote asynchronously if :synchronize => :async" do
     create_remote("overwrite me")
     file = @proxy.file(key, @mode)
     create_proxy("upload me")
-    Thread.should_receive(:new) { |&block|
-      remote_body.should == "overwrite me"
+    expect(Thread).to receive(:new) { |&block|
+      expect(remote_body).to eq("overwrite me")
       block.call
     }
     should_log /Upload/
     file.close(:synchronize => :async)
-    remote_body.should == "upload me"
+    expect(remote_body).to eq("upload me")
   end
 
   it "should not overwrite remote if proxy is deleted" do
@@ -171,7 +171,7 @@ shared_examples "update" do
       file.write("ignore me")
       proxy_path.unlink
     end
-    remote_body.should == "keep me"
+    expect(remote_body).to eq("keep me")
   end
 
   it "should not overwrite remote if :synchronize => false" do
@@ -180,7 +180,7 @@ shared_examples "update" do
     file = @proxy.file(key, @mode)
     create_proxy("ignore me")
     file.close(:synchronize => false)
-    remote_body.should == "keep me"
+    expect(remote_body).to eq("keep me")
   end
 
 end
@@ -189,41 +189,41 @@ shared_examples "persistence" do
   it "should delete proxy on close" do
     create_remote("whatever")
     file = @proxy.file(key, @mode)
-    proxy_path.should be_exist
+    expect(proxy_path).to be_exist
     file.close
-    proxy_path.should_not be_exist
+    expect(proxy_path).not_to be_exist
   end
 
   it "should delete proxy on close (block form)" do
     create_remote("whatever")
     @proxy.file(key, @mode) do |file|
-      proxy_path.should be_exist
+      expect(proxy_path).to be_exist
     end
-    proxy_path.should_not be_exist
+    expect(proxy_path).not_to be_exist
   end
 
   it "should not delete proxy if persisting" do
     create_remote("whatever")
     @proxy.file(key, @mode, :persist => true) do |file|
-      proxy_path.should be_exist
+      expect(proxy_path).to be_exist
     end
-    proxy_path.should be_exist
+    expect(proxy_path).to be_exist
   end
 
   it "close should override persist true" do
     create_remote("whatever")
     file = @proxy.file(key, @mode)
-    proxy_path.should be_exist
+    expect(proxy_path).to be_exist
     file.close(:persist => true)
-    proxy_path.should be_exist
+    expect(proxy_path).to be_exist
   end
 
   it "close should override persist false" do
     create_remote("whatever")
     file = @proxy.file(key, @mode, :persist => true)
-    proxy_path.should be_exist
+    expect(proxy_path).to be_exist
     file.close(:persist => false)
-    proxy_path.should_not be_exist
+    expect(proxy_path).not_to be_exist
   end
 
 end
@@ -263,7 +263,7 @@ shared_examples "a proxy file" do |proxyargs|
 
   it "should have a nice to_s" do
     @proxy.file(key, "w") {|f|
-      f.to_s.should include f.path
+      expect(f.to_s).to include f.path
     }
   end
 

data/spec/handle_spec.rb

@@ -11,21 +11,21 @@ shared_examples "a handle" do |proxyargs|
   end
 
   it "should have a nice to_s" do
-    @handle.to_s.should include key
+    expect(@handle.to_s).to include key
   end
 
   context "proxy path" do
     it "should start with proxy root" do
-      @handle.proxy_path.to_s.should start_with(@proxy.proxy_root.to_s)
+      expect(@handle.proxy_path.to_s).to start_with(@proxy.proxy_root.to_s)
     end
 
     it "should end with key" do
-      @handle.proxy_path.to_s.should end_with(key)
+      expect(@handle.proxy_path.to_s).to end_with(key)
     end
 
     it "should include prefix" do
       prefix = "IAmAPrefix"
-      Defog::Proxy.new(proxyargs.merge(:prefix => prefix)).file(key).proxy_path.to_s.should include(prefix.to_s)
+      expect(Defog::Proxy.new(proxyargs.merge(:prefix => prefix)).file(key).proxy_path.to_s).to include(prefix.to_s)
     end
   end
 
@@ -36,21 +36,21 @@ shared_examples "a handle" do |proxyargs|
     end
 
     it "should report exist? true" do
-      @handle.should be_exist
+      expect(@handle).to be_exist
     end
 
     it "should return md5 hash" do
-      @handle.md5_hash.should == Digest::MD5.hexdigest("i exist")
+      expect(@handle.md5_hash).to eq(Digest::MD5.hexdigest("i exist"))
     end
   end
 
   context "if remote cloud file does not exist" do
     it "should report exist? false" do
-      @handle.should_not be_exist
+      expect(@handle).not_to be_exist
     end
 
     it "should return nil md5 hash" do
-      @handle.md5_hash.should be_nil
+      expect(@handle.md5_hash).to be_nil
     end
   end
 
@@ -60,45 +60,45 @@ shared_examples "a handle" do |proxyargs|
 
     it "should delegate #{method.inspect} to the fog model #{fog_method.inspect} if the remote file exists" do
       create_remote("delegate me")
-      @handle.fog_model.class.any_instance.should_receive(fog_method).and_return { "dummy" }
-      @handle.send(method).should == "dummy"
+      expect_any_instance_of(@handle.fog_model.class).to receive(fog_method) { "dummy" }
+      expect(@handle.send(method)).to eq("dummy")
     end
 
     it "should return nil from #{method} if the remote file does not exist" do
-      @handle.send(method).should be_nil
+      expect(@handle.send(method)).to be_nil
     end
 
   end
 
   it "should delete a remote cloud file" do
     create_remote("delete me")
-    remote_exist?.should be_true
+    expect(remote_exist?).to be_truthy
     @handle.delete
-    remote_exist?.should be_false
+    expect(remote_exist?).to be_falsey
   end
 
   it "should return a URL to a file" do
     create_remote("reach out to me")
-    @handle.url.should be_a String
+    expect(@handle.url).to be_a String
   end
 
   it "should open a file" do
-    Defog::File.should_receive(:open).with(hash_including(:handle => @handle, :mode => "w"))
+    expect(Defog::File).to receive(:open).with(hash_including(:handle => @handle, :mode => "w"))
     @handle.open("w")
   end
 
   it "should return a Fog model" do
     create_remote("foggy")
-    @handle.fog_model.body.should == "foggy"
+    expect(@handle.fog_model.body).to eq("foggy")
   end
 
   it "should update when file changes" do
     create_remote("abc")
-    @proxy.file(key).size.should == 3
+    expect(@proxy.file(key).size).to eq(3)
     @proxy.file(key).open("w") do |f|
       f.write("defghij")
     end
-    @proxy.file(key).size.should == 7
+    expect(@proxy.file(key).size).to eq(7)
   end
 
 
@@ -117,7 +117,7 @@ describe Defog::Handle do
 
     it "should return a file:// URL" do
       @proxy = Defog::Proxy.new(args)
-      @proxy.file(key).url.should == "file://" + (LOCAL_CLOUD_PATH + key).to_s
+      expect(@proxy.file(key).url).to eq("file://" + (LOCAL_CLOUD_PATH + key).to_s)
     end
 
     context "with a rails app" do
@@ -125,14 +125,14 @@ describe Defog::Handle do
       it "should return a path relative to public if in public" do
         with_rails_defined do
           @proxy = Defog::Proxy.new(:provider => :local, :local_root => Rails.root + "public/defog")
-          @proxy.file(key).url.should == "/defog/#{key}"
+          expect(@proxy.file(key).url).to eq("/defog/#{key}")
         end
       end
 
       it "should return a file:// path if not in public" do
         with_rails_defined do
           @proxy = Defog::Proxy.new(args)
-          @proxy.file(key).url.should == "file://" + (LOCAL_CLOUD_PATH + key).to_s
+          expect(@proxy.file(key).url).to eq("file://" + (LOCAL_CLOUD_PATH + key).to_s)
         end
       end
     end
@@ -154,7 +154,7 @@ describe Defog::Handle do
       t = Time.now + 10*60
       #Fog::Storage::AWS::File.any_instance.should_receive(:url).with(t, "response-content-disposition" => "attachment")
       url = @proxy.file(key).url(:expiry => t, :query => {"response-content-disposition" => "attachment"})
-      url.should include "response-content-disposition=attachment"
+      expect(url).to include "response-content-disposition=attachment"
     end
 
 

data/spec/proxy_spec.rb

@@ -8,51 +8,51 @@ shared_examples "a proxy" do |args|
     end
 
     it "should have a nice to_s" do
-      @proxy.to_s.should include @proxy.provider.to_s
-      @proxy.to_s.should include @proxy.location
+      expect(@proxy.to_s).to include @proxy.provider.to_s
+      expect(@proxy.to_s).to include @proxy.location
     end
 
     it "file should return a handle" do
       handle = @proxy.file(key)
-      handle.proxy.should == @proxy
-      handle.key.should == key
+      expect(handle.proxy).to eq(@proxy)
+      expect(handle.key).to eq(key)
     end
 
     it "file should yield a handle" do
       ret = @proxy.file(key) do |handle|
-        handle.proxy.should == @proxy
-        handle.key.should == key
+        expect(handle.proxy).to eq(@proxy)
+        expect(handle.key).to eq(key)
         123
       end
-      ret.should == 123
+      expect(ret).to eq(123)
     end
 
     it "should forward file open to handle" do
-      Defog::Handle.should_receive(:new).with(@proxy, key).and_return { mock('Handle').tap { |handle|
-        handle.should_receive(:open).with("r+", :persist => true)
+      expect(Defog::Handle).to receive(:new).with(@proxy, key) { double('Handle').tap { |handle|
+        expect(handle).to receive(:open).with("r+", :persist => true)
       } }
       @proxy.file(key, "r+", :persist => true)
     end
 
     it "should return fog storage" do
-      @proxy.fog_connection.should == @proxy.fog_directory.service
+      expect(@proxy.fog_connection).to eq(@proxy.fog_directory.service)
     end
 
     it "should return fog directory" do
       create_remote("hello")
-      @proxy.fog_directory.files.get(key).body.should == "hello"
+      expect(@proxy.fog_directory.files.get(key).body).to eq("hello")
     end
   end
 
   context "settings" do
     it "should set default for :persist => true" do
       @proxy = Defog::Proxy.new(args.merge(:persist => true))
-      Defog::File.should_receive(:open).with(hash_including :persist => true)
+      expect(Defog::File).to receive(:open).with(hash_including :persist => true)
       @proxy.file(key, "w") do end
     end
     it "should set default for :synchronize => :async" do
       @proxy = Defog::Proxy.new(args.merge(:synchronize => :async))
-      Defog::File.should_receive(:open).with(hash_including :synchronize => :async)
+      expect(Defog::File).to receive(:open).with(hash_including :synchronize => :async)
       @proxy.file(key, "w") do end
     end
   end
@@ -73,11 +73,11 @@ shared_examples "a proxy" do |args|
       @proxy.each do |handle|
         seen << handle.key
       end
-      seen.should =~ [other_key("i0"), other_key("i1"), other_key("i2")]
+      expect(seen).to match_array([other_key("i0"), other_key("i1"), other_key("i2")])
     end
 
     it "should return an enumerator" do
-      @proxy.each.map(&:key).should =~ [other_key("i0"), other_key("i1"), other_key("i2")]
+      expect(@proxy.each.map(&:key)).to match_array([other_key("i0"), other_key("i1"), other_key("i2")])
     end
 
   end
@@ -86,14 +86,14 @@ shared_examples "a proxy" do |args|
     it "should return its prefix" do
       prefix = "me-first"
       @proxy = Defog::Proxy.new(args.merge(:prefix => prefix))
-      @proxy.prefix.should == prefix
+      expect(@proxy.prefix).to eq(prefix)
     end
 
     it "should use a prefix" do
       prefix = "me-first"
       @proxy = Defog::Proxy.new(args.merge(:prefix => prefix))
       @proxy.file(key, "w") { |f| f.puts "hello" }
-      @proxy.file(key).fog_model.key.should == prefix + key
+      expect(@proxy.file(key).fog_model.key).to eq(prefix + key)
     end
 
     it "should iterate only matches to prefix" do
@@ -105,7 +105,7 @@ shared_examples "a proxy" do |args|
       create_other_remote("yes-y1")
       create_other_remote("yes-y2")
       create_other_remote("yes-y3")
-      @proxy.each.map(&:key).should =~[other_key("y1"), other_key("y2"), other_key("y3")]
+      expect(@proxy.each.map(&:key)).to match_array([other_key("y1"), other_key("y2"), other_key("y3")])
     end
 
   end
@@ -113,20 +113,20 @@ shared_examples "a proxy" do |args|
   context "proxy root location" do
     it "should default proxy root to tmpdir/defog" do
       proxy = Defog::Proxy.new(args)
-      proxy.proxy_root.should == Pathname.new(Dir.tmpdir) + "defog" + "#{proxy.provider.to_s}-#{proxy.location}"
+      expect(proxy.proxy_root).to eq(Pathname.new(Dir.tmpdir) + "defog" + "#{proxy.provider.to_s}-#{proxy.location}")
     end
 
     it "should default proxy root to Rails.root" do
       with_rails_defined do
         proxy = Defog::Proxy.new(args)
-        proxy.proxy_root.should == Rails.root + "tmp/defog" + "#{proxy.provider.to_s}-#{proxy.location}"
+        expect(proxy.proxy_root).to eq(Rails.root + "tmp/defog" + "#{proxy.provider.to_s}-#{proxy.location}")
       end
     end
 
     it "should accept proxy root parameter" do
       path = Pathname.new("/a/random/path")
       proxy = Defog::Proxy.new(args.merge(:proxy_root => path))
-      proxy.proxy_root.should == path
+      expect(proxy.proxy_root).to eq(path)
     end
   end
 
@@ -144,15 +144,15 @@ shared_examples "a proxy" do |args|
     it "should raise an error trying to proxy a file larger than the cache" do
       create_remote("x" * 101)
       expect { @proxy.file(key, "r") }.to raise_error(Defog::Error::CacheFull)
-      proxy_path.should_not be_exist
+      expect(proxy_path).not_to be_exist
     end
 
     it "should not count existing proxy in total" do
       create_proxy("y" * 70)
       create_remote("x" * 70)
-      expect { @proxy.file(key, "r") do end }.to_not raise_error(Defog::Error::CacheFull)
-      proxy_path.should be_exist
-      proxy_path.read.should == remote_body
+      expect { @proxy.file(key, "r") do end }.not_to raise_error
+      expect(proxy_path).to be_exist
+      expect(proxy_path.read).to eq(remote_body)
     end
 
     it "should delete proxies to make room" do
@@ -160,11 +160,11 @@ shared_examples "a proxy" do |args|
       create_other_proxy("b", 30)
       create_other_proxy("c", 40)
       create_remote("x" * 80)
-      expect { @proxy.file(key, "r") do end }.to_not raise_error(Defog::Error::CacheFull)
-      proxy_path.should be_exist
-      other_proxy_path("a").should be_exist
-      other_proxy_path("b").should_not be_exist
-      other_proxy_path("c").should_not be_exist
+      expect { @proxy.file(key, "r") do end }.not_to raise_error
+      expect(proxy_path).to be_exist
+      expect(other_proxy_path("a")).to be_exist
+      expect(other_proxy_path("b")).not_to be_exist
+      expect(other_proxy_path("c")).not_to be_exist
     end
 
     [0, 3, 6].each do |sizect|
@@ -172,14 +172,14 @@ shared_examples "a proxy" do |args|
         create_other_proxy("a", 30)
         create_other_proxy("b", 30)
         create_other_proxy("c", 30)
-        create_remote("x" * 80)
+        create_remote("x" * 9)
         z = 0
-        Pathname.any_instance.stub(:size) { |path|
+        allow_any_instance_of(Pathname).to receive(:size) { |path|
           raise Errno::ENOENT if z == sizect
           z += 1
           30
         }
-        expect { @proxy.file(key, "r") do end }.to_not raise_error(Errno::ENOENT)
+        expect { @proxy.file(key, "r") do end }.not_to raise_error
       end
     end
 
@@ -188,28 +188,31 @@ shared_examples "a proxy" do |args|
       create_other_proxy("b", 30)
       create_other_proxy("c", 40)
       create_remote("x" * 80)
-      Pathname.any_instance.should_receive(:unlink).and_raise Errno::ENOENT
-      expect { @proxy.file(key, "r") do end }.to_not raise_error(Errno::ENOENT)
+      allow_any_instance_of(Pathname).to receive(:unlink) { raise Errno::ENOENT }
+      expect { @proxy.file(key, "r") do end }.not_to raise_error
     end
 
-    it "should not fail atime when proxies get deleted by another process" do
+    it "should not fail atime when a proxy gets deleted by another process" do
       create_other_proxy("a", 10)
       create_other_proxy("b", 30)
       create_other_proxy("c", 40)
       create_remote("x" * 80)
-      Pathname.any_instance.should_receive(:atime).and_raise Errno::ENOENT
-      expect { @proxy.file(key, "r") do end }.to_not raise_error(Errno::ENOENT)
+      allow_any_instance_of(Pathname).to receive(:atime) {
+        @raised = true and raise Errno::ENOENT unless @raised
+        Time.now
+      }
+      expect { @proxy.file(key, "r") do end }.not_to raise_error
     end
 
     it "should delete proxies to make room for hinted size" do
       create_other_proxy("a", 10)
       create_other_proxy("b", 30)
       create_other_proxy("c", 40)
-      expect { @proxy.file(key, "w", :size_hint => 80) do end }.to_not raise_error(Defog::Error::CacheFull)
-      proxy_path.should be_exist
-      other_proxy_path("a").should be_exist
-      other_proxy_path("b").should_not be_exist
-      other_proxy_path("c").should_not be_exist
+      expect { @proxy.file(key, "w", :size_hint => 80) do end }.not_to raise_error
+      expect(proxy_path).to be_exist
+      expect(other_proxy_path("a")).to be_exist
+      expect(other_proxy_path("b")).not_to be_exist
+      expect(other_proxy_path("c")).not_to be_exist
     end
 
     it "should not delete proxies that are open" do
@@ -220,12 +223,12 @@ shared_examples "a proxy" do |args|
       @proxy.file(other_key("R"), "r") do
         @proxy.file(other_key("S"), "w") do
           create_other_proxy("S", 30)
-          expect { @proxy.file(key, "r") do end }.to_not raise_error(Defog::Error::CacheFull)
-          proxy_path.should be_exist
-          other_proxy_path("R").should be_exist
-          other_proxy_path("S").should be_exist
-          other_proxy_path("a").should_not be_exist
-          other_proxy_path("b").should_not be_exist
+          expect { @proxy.file(key, "r") do end }.not_to raise_error
+          expect(proxy_path).to be_exist
+          expect(other_proxy_path("R")).to be_exist
+          expect(other_proxy_path("S")).to be_exist
+          expect(other_proxy_path("a")).not_to be_exist
+          expect(other_proxy_path("b")).not_to be_exist
         end
       end
     end
@@ -234,10 +237,10 @@ shared_examples "a proxy" do |args|
       create_other_remote("R", 60)
       create_remote("z" * 60)
       @proxy.file(other_key("R"), "r") do end
-      other_proxy_path("R").should be_exist
-      expect { @proxy.file(key, "r") do end }.to_not raise_error(Defog::Error::CacheFull)
-      proxy_path.should be_exist
-      other_proxy_path("R").should_not be_exist
+      expect(other_proxy_path("R")).to be_exist
+      expect { @proxy.file(key, "r") do end }.not_to raise_error
+      expect(proxy_path).to be_exist
+      expect(other_proxy_path("R")).not_to be_exist
     end
 
     it "should not delete proxies if there wouldn't be enough space" do
@@ -249,11 +252,11 @@ shared_examples "a proxy" do |args|
       @proxy.file(other_key("R"), "r") do
         @proxy.file(other_key("S"), "r") do
           expect { @proxy.file(key, "r") do end }.to raise_error(Defog::Error::CacheFull)
-          proxy_path.should_not be_exist
-          other_proxy_path("a").should be_exist
-          other_proxy_path("b").should be_exist
-          other_proxy_path("R").should be_exist
-          other_proxy_path("S").should be_exist
+          expect(proxy_path).not_to be_exist
+          expect(other_proxy_path("a")).to be_exist
+          expect(other_proxy_path("b")).to be_exist
+          expect(other_proxy_path("R")).to be_exist
+          expect(other_proxy_path("S")).to be_exist
         end
       end
     end
@@ -296,7 +299,7 @@ describe Defog::Proxy do
     it_should_behave_like "a proxy", args
 
     it "should use the deslashed local_root as the location" do
-      Defog::Proxy.new(args).location.should == LOCAL_CLOUD_PATH.to_s.gsub(%r{/},"-")
+      expect(Defog::Proxy.new(args).location).to eq(LOCAL_CLOUD_PATH.to_s.gsub(%r{/},"-"))
     end
 
   end
@@ -310,25 +313,25 @@ describe Defog::Proxy do
     it_should_behave_like "a proxy", args
 
     it "should use the bucket name as the location" do
-      Defog::Proxy.new(args).location.should == args[:bucket]
+      expect(Defog::Proxy.new(args).location).to eq(args[:bucket])
     end
 
     it "should share fog connection with same bucket" do
       proxy1 = Defog::Proxy.new(args)
       proxy2 = Defog::Proxy.new(args)
-      proxy1.fog_connection.should be_equal proxy2.fog_connection
+      expect(proxy1.fog_connection).to be_equal proxy2.fog_connection
     end
 
     it "should share fog connection with different bucket" do
       proxy1 = Defog::Proxy.new(args)
       proxy2 = Defog::Proxy.new(args.merge(:bucket => "other"))
-      proxy1.fog_connection.should be_equal proxy2.fog_connection
+      expect(proxy1.fog_connection).to be_equal proxy2.fog_connection
     end
 
     it "should not share fog connection with different connection args" do
       proxy1 = Defog::Proxy.new(args)
       proxy2 = Defog::Proxy.new(args.merge(:aws_access_key_id => "other"))
-      proxy1.fog_connection.should_not be_equal proxy2.fog_connection
+      expect(proxy1.fog_connection).not_to be_equal proxy2.fog_connection
     end
 
   end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 if RUBY_VERSION > "1.9"
   require 'simplecov'
-  require 'simplecov-gem-adapter'
+  require 'simplecov-gem-profile'
   SimpleCov.start 'gem'
 end
 

data/spec/support/helpers.rb

@@ -3,7 +3,7 @@ module Helpers
   def key
     # returns a key that will be different for each example, to avoid any
     # cross-example interactions
-    example.metadata[:full_description].gsub(/\+/,'plus').gsub(/\W/,'-') + "/filename"
+    RSpec.current_example.metadata[:full_description].gsub(/\+/,'plus').gsub(/\W/,'-') + "/filename"
   end
 
   def create_remote(body)
@@ -23,7 +23,7 @@ module Helpers
   end
 
   def remote_body
-    @proxy.file(key).fog_model.body
+    @proxy.file(key).fog_model.andand.body
   end
 
   def remote_exist?
@@ -40,11 +40,11 @@ module Helpers
   end
 
   def should_log(arg)
-    @proxy.logger.should_receive(:info).with(arg)
+    expect(@proxy.logger).to receive(:info).with(arg)
   end
 
   def should_not_log(arg)
-    @proxy.logger.should_not_receive(:info).with(arg)
+    expect(@proxy.logger).not_to receive(:info).with(arg)
   end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: defog
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - ronen barzel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-30 00:00:00.000000000 Z
+date: 2015-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -84,16 +84,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -109,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov-gem-adapter
+  name: simplecov-gem-profile
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -168,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Wrapper to fog gem, proxying access to cloud files as local files.  Access