fake_dropbox 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+gemspec
+

data/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2011 Juliusz Gonera
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,97 @@
+fake_dropbox
+============
+
+fake_dropbox is a simple fake implementation of the Dropbox API written in Ruby
+using the Sinatra framework. It can be used for developing and testing
+applications that use Dropbox. There are no real authentication and users (you
+are always authenticated), the server stores files on the local machine.
+
+Can be used either as a standalone app listening on a port or intercept calls to
+the real Dropbox in Ruby apps.
+
+It partially implements [version 0](https://www.dropbox.com/developers/reference/oldapi)
+of the Dropbox API which should be compatible with [version 1](https://www.dropbox.com/developers/reference/api).
+If you find it useful and want to add support for more features, go ahead ;)
+
+
+Installation
+------------
+
+Using RubyGems:
+
+    gem install fake_dropbox
+
+To get the latest development version just clone the repository:
+
+    git clone git://github.com/jgonera/fake_dropbox.git
+    cd fake_dropbox
+    gem install bundler
+    bundle install
+
+Then, if you want to install it as a gem:
+
+    rake install
+
+
+How to use
+----------
+
+### Running the server
+
+If you installed fake_dropbox as a gem, you should be able to run:
+
+    DROPBOX_DIR=/home/joe/somedir fake_dropbox [PORT]
+
+You have to specify an environment variable `DROPBOX_DIR` which will point the
+server to the directory on which the fake API should operate. Additionally, you
+can specify a custom port (default is 4321).
+
+### Intercepting requests in Ruby apps
+
+You can also use this gem to intercept requests to Dropbox in your Ruby app,
+without modifying any of its code or specifying a custom host or port. This
+is achieved by using the [WebMock](https://github.com/bblimke/webmock) library.
+
+The class responsible for this is `FakeDropbox::Glue`. To intercept requests to
+the real Dropbox, just instantiate this class in your code:
+
+    fake_dropbox = FakeDropbox::Glue.new
+
+You can provide an optional argument to the constructor, pointing to the
+directory you want to use for your fake Dropbox:
+
+    fake_dropbox = FakeDropbox::Glue.new('/home/joe/somedir')
+
+If you don't provide it, a temporary directory will be created in the system's
+temporary path.
+
+Moreover:
+
+* `#dropbox_dir` returns the fake Dropbox directory.
+* `#empty!` deletes everything in the `dropbox_dir` *recursively*.
+Even though it should work only if the `dropbox_dir` resides inside the system's
+temporary path, you should use it with caution.
+
+A support file for Cucumber tests could look like this:
+
+    require 'fake_dropbox'
+
+    fake_dropbox = FakeDropbox::Glue.new
+
+    After do
+      fake_dropbox.empty!
+    end
+
+### Using without installing as a gem
+
+If you cloned the repository and you don't want to install fake_dropbox as a
+gem, you can run it using `rackup` while in the fake_dropbox directory:
+
+    DROPBOX_DIR=/home/joe/somedir rackup
+
+
+Copyright
+---------
+
+Copyright © 2011 Juliusz Gonera. fake_dropbox is released under the MIT license, see LICENSE for details.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/fake_dropbox

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '../lib'))
+
+if not ENV.include? 'DROPBOX_DIR'
+  puts "You have to specify the DROPBOX_DIR in ENV, e.g."
+  puts "DROPBOX_DIR=/home/joe/somedir"
+  exit
+end
+
+require 'rack'
+require 'fake_dropbox/server'
+
+Rack::Server.start(app: FakeDropbox::Server, Port: ARGV[0] || 4321)

data/config.ru

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
+require 'fake_dropbox/server'
+run FakeDropbox::Server

data/fake_dropbox.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require "fake_dropbox/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fake_dropbox"
+  s.version     = FakeDropbox::VERSION
+  s.authors     = ["Juliusz Gonera"]
+  s.email       = ["jgonera@gmail.com"]
+  s.homepage    = "https://github.com/jgonera/fake_dropbox"
+  s.summary     = %q{A simple fake implementation of the Dropbox API}
+  s.description = %q{Written in Ruby using the Sinatra framework. For development and testing purposes, no real authentication and users, stores files on the local machine. Can be used either as a standalone app listening on a port or intercept calls to the real Dropbox in Ruby apps.}
+
+  s.rubyforge_project = "fake_dropbox"
+  s.extra_rdoc_files  = ['README.md', 'LICENSE']
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency 'sinatra', '~> 1.2.6'
+  s.add_dependency 'json', '~> 1.6.1'
+  s.add_dependency 'rack', '~> 1.3.2'
+  s.add_dependency 'rack-test', '~> 0.6.1'
+  s.add_dependency 'webmock', '~> 1.7.7'
+  
+  s.add_development_dependency 'rspec', '~> 2.7.0'
+end

data/lib/fake_dropbox/glue.rb

@@ -0,0 +1,33 @@
+require 'webmock'
+require 'tmpdir'
+require 'fileutils'
+require 'fake_dropbox/server'
+
+module FakeDropbox
+  class Glue
+    attr_accessor :dropbox_dir
+    
+    def initialize(dropbox_dir=ENV['DROPBOX_DIR'])
+      if dropbox_dir
+        raise "Directory #{dropbox_dir} doesn't exist!" unless File.exists? dropbox_dir
+        @dropbox_dir = dropbox_dir
+      else
+        @dropbox_dir = File.join(Dir.tmpdir, 'fake_dropbox')
+        Dir.mkdir(@dropbox_dir) unless File.exists? @dropbox_dir
+      end
+      
+      ENV['DROPBOX_DIR'] = @dropbox_dir
+      WebMock.stub_request(:any, /.*dropbox.com.*/).to_rack(FakeDropbox::Server)
+    end
+    
+    def empty!
+      if File.expand_path(@dropbox_dir).start_with? Dir.tmpdir
+        Dir.glob(File.join(@dropbox_dir, '*')).each do |entry|
+          FileUtils.remove_entry_secure entry
+        end
+      else
+        raise "Will not empty a directory which is outside of system's temporary path!"
+      end
+    end
+  end
+end

data/lib/fake_dropbox/server.rb

@@ -0,0 +1,83 @@
+require 'sinatra/base'
+require 'json'
+require 'fileutils'
+require 'fake_dropbox/utils'
+
+module FakeDropbox
+  class Server < Sinatra::Base
+    before do
+      if not request.path.start_with?('/__sinatra__')
+        @dropbox_dir = env['DROPBOX_DIR'] || ENV['DROPBOX_DIR']
+        raise 'no DROPBOX_DIR in ENV' if not @dropbox_dir
+      end
+    end
+    
+    helpers FakeDropbox::Utils
+
+    not_found do
+      # only catch 404 not returned by the API
+      if request.env['sinatra.error'].class == Sinatra::NotFound
+        puts "[fake_dropbox] Unknown URI: #{request.request_method} #{request.path}"
+        "Unknown URI: #{request.request_method} #{request.path}"
+      end
+    end
+    
+    post '/:version/oauth/request_token' do
+      'oauth_token_secret=fake&oauth_token=fake'
+    end
+    
+    post '/:version/oauth/access_token' do
+      'oauth_token_secret=fake&oauth_token=fake'
+    end
+
+    post '/:version/files/:mode*' do
+      dir = File.join(@dropbox_dir, params[:splat])
+      return status 404 unless File.exists?(dir) and File.directory?(dir)
+    
+      tempfile = params[:file][:tempfile]
+      filename = params[:file][:filename]
+      file_path = File.join(params[:splat], filename)
+      FileUtils.cp(tempfile.path, File.join(@dropbox_dir, file_path))
+      File.delete(tempfile.path) if File.exists? tempfile.path
+      
+      content_type :json
+      metadata(file_path).to_json
+    end
+    
+    get '/:version/files/:mode*' do
+      file_path = File.join(@dropbox_dir, params[:splat])
+      return status 404 unless File.exists?(file_path)
+      
+      IO.read(file_path)
+    end
+    
+    get '/:version/metadata/:mode*' do
+      content_type :json
+      metadata(params[:splat][0], params['list'] == 'true').to_json
+    end
+    
+    post '/:version/fileops/create_folder' do
+      dir = params[:path]
+      dir_path = File.join(@dropbox_dir, dir)
+      
+      return status 400 unless ['dropbox', 'sandbox'].include? params[:root]
+      return status 403 if File.exists?(dir_path)
+      # seems that directories are created recursively (API docs wrong?)
+      #return status 404 unless File.exists?(File.dirname(dir_path))
+      
+      FileUtils.mkdir_p dir_path
+      
+      content_type :json
+      metadata(dir).to_json
+    end
+    
+    post '/:version/fileops/delete' do
+      entry = safe_path(params[:path])
+      entry_path = File.join(@dropbox_dir, entry)
+      
+      return status 404 unless File.exists?(entry_path)
+      
+      FileUtils.remove_entry_secure entry_path
+    end
+  end
+end

data/lib/fake_dropbox/utils.rb

@@ -0,0 +1,40 @@
+module FakeDropbox
+  module Utils
+    DATE_FORMAT = '%a, %d %b %Y %H:%M:%S %z'
+    
+    def metadata(path, list=false)
+      full_path = File.join(@dropbox_dir, path)
+      path.insert(0, '/') if path[0] != '/'
+      bytes = File.directory?(path) ? 0 : File.size(full_path)
+      
+      metadata = {
+        thumb_exists: false,
+        bytes: bytes,
+        modified: File.mtime(full_path).strftime(DATE_FORMAT),
+        path: path,
+        is_dir: File.directory?(full_path),
+        size: "#{bytes} bytes",
+        root: "dropbox"
+      }
+      
+      if File.directory?(full_path)
+        metadata[:icon] = "folder"
+        
+        if list
+          entries = Dir.entries(full_path).reject { |x| ['.', '..'].include? x }
+          metadata[:contents] = entries.map do |entry|
+            metadata(File.join(path, entry))
+          end
+        end
+      else
+        metadata[:icon] = "page_white"
+      end
+      
+      metadata
+    end
+    
+    def safe_path(path)
+      path.gsub(/(\.\.\/|\/\.\.)/, '')
+    end
+  end
+end

data/lib/fake_dropbox/version.rb

@@ -0,0 +1,3 @@
+module FakeDropbox
+  VERSION = "0.1.0"
+end

data/lib/fake_dropbox.rb

@@ -0,0 +1,5 @@
+require "fake_dropbox/version"
+require 'fake_dropbox/glue'
+require 'fake_dropbox/utils'
+require 'fake_dropbox/server'
+

data/spec/fixtures/dummy.txt

@@ -0,0 +1 @@
+Hello, I'm a test file

data/spec/glue_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe "FakeDropbox::Glue" do
+  let(:stub_request) { double('stub_request').as_null_object }
+
+  before do
+    ENV.delete('DROPBOX_DIR')
+    Dir.stub(:tmpdir).and_return('/tmp')
+    File.stub(:exists?).and_return(true)
+    WebMock.stub(:stub_request).and_return(stub_request)
+  end
+    
+  describe ".new" do
+    it "stubs the Dropbox requests with WebMock" do
+      WebMock.should_receive(:stub_request)
+      stub_request.should_receive(:to_rack)
+      FakeDropbox::Glue.new('/tmp/somethingnonexistant')
+    end
+    
+    context "when invoked with an argument" do
+      it "sets the dropbox_dir" do
+        glue = FakeDropbox::Glue.new('/tmp/somethingnonexistant')
+        glue.dropbox_dir.should == '/tmp/somethingnonexistant'
+        ENV['DROPBOX_DIR'].should == glue.dropbox_dir
+      end
+    end
+    
+    context "when invoked with no arguments" do
+      it "creates dropbox_dir in system temp path" do
+        glue = FakeDropbox::Glue.new
+        glue.dropbox_dir.should == '/tmp/fake_dropbox'
+        ENV['DROPBOX_DIR'].should == glue.dropbox_dir
+      end
+    end
+  end
+  
+  describe "#empty!" do
+    context "when dropbox_dir is in temp path" do
+      subject { FakeDropbox::Glue.new('/tmp/somethingnonexistant') }
+      
+      it "deletes the dropbox_dir and all its contents" do
+        Dir.should_receive(:glob).with('/tmp/somethingnonexistant/*').and_return(['sth'])
+        FileUtils.should_receive(:remove_entry_secure).with('sth')
+        subject.empty!
+      end
+    end
+    
+    shared_examples_for "dangerous" do
+      it "does not delete the dropbox_dir" do
+        FileUtils.should_not_receive(:remove_entry_secure)
+        begin
+          subject.empty!
+        rescue
+        end
+      end
+
+      it "raises an exception" do
+        lambda { subject.empty! }.should raise_error
+      end
+    end
+    
+    context "when dropbox_dir is not in temp path" do
+      subject { FakeDropbox::Glue.new('/sth') }
+      it_behaves_like "dangerous"
+    end
+    
+    context "when dropbox_dir is not in temp path and is not absolute" do
+      subject { FakeDropbox::Glue.new('/tmp/../somethingnonexistant') }
+      it_behaves_like "dangerous"
+    end
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe 'FakeDropbox::Server' do
+  before do
+    @tmpdir = Dir.mktmpdir 'fake_dropbox-test'
+    @env = { 'DROPBOX_DIR' => @tmpdir }
+  end
+  
+  after do
+    FileUtils.remove_entry_secure @tmpdir
+  end
+  
+  describe "POST /<version>/oauth/request_token" do
+    it "returns a fake OAuth request token" do
+      post "/0/oauth/request_token", {}, @env
+      #File.open('/home/julas/Desktop/aaa.html', 'w') {|f| f.write(last_response.body) }
+      last_response.should be_ok
+      last_response.body.should include 'oauth_token=', 'oauth_token_secret='
+    end
+  end
+  
+  describe "POST /<version>/oauth/access_token" do
+    it "returns a fake OAuth access token" do
+      post "/0/oauth/access_token", {}, @env
+      last_response.should be_ok
+      last_response.body.should include 'oauth_token=', 'oauth_token_secret='
+    end
+  end
+  
+  describe "POST /<version>/files/dropbox/<path>" do
+    let(:uploaded_file) { Rack::Test::UploadedFile.new(fixture_path('dummy.txt')) }
+    let(:params) { { file: uploaded_file } }
+    
+    shared_examples_for "correct upload" do
+      it "saves the file in the directory" do
+        post "/0/files/dropbox" + path, params, @env
+        Dir.entries(dir).should include 'dummy.txt'
+        original_content = File.new(fixture_path('dummy.txt')).read
+        uploaded_content = File.new(File.join(dir, 'dummy.txt')).read
+        uploaded_content.should == original_content
+      end
+      
+      it "deletes the temporary file (RackMultipart*)" do
+        post "/0/files/dropbox" + path, params, @env
+        tempfile = last_request.params['file'][:tempfile]
+        File.exists?(tempfile.path).should == false
+      end
+      
+      it "returns file metadata" do
+        post "/0/files/dropbox" + path, params, @env
+        last_response.should be_ok
+        metadata = JSON.parse(last_response.body)
+        metadata['path'].should == path + '/dummy.txt'
+        metadata['modified'].should include Time.new.strftime('%a, %d %b %Y %H:%M')
+      end
+    end
+    
+    context "when the path is root" do
+      let (:path) { '' }
+      let (:dir) { @tmpdir }
+      
+      it_behaves_like "correct upload"
+    end
+    
+    context "when the path is not root" do
+      context "when the path exists" do
+        let (:path) { '/somedir' }
+        let (:dir) { File.join(@tmpdir, path) }
+        before { Dir.mkdir(dir) }
+        
+        it_behaves_like "correct upload"
+      end
+      
+      context "when the path does not exist" do
+        it "returns error 404" do
+          post "/0/files/dropbox/incorrect", params, @env
+          last_response.status.should == 404
+        end
+      end
+    end
+  end
+  
+  describe "GET /<version>/files/dropbox/<path>" do
+    context "when the file exists" do
+      before do
+        File.open(File.join(@tmpdir, 'file.ext'), 'w') do |f|
+          f.write "This is a test."
+        end
+      end
+    
+      it "returns file contents" do
+        get "/0/files/dropbox/file.ext", {}, @env
+        last_response.should be_ok
+        last_response.body.should == "This is a test."
+      end
+    end
+    
+    context "when the file does not exist" do
+      it "returns error 404" do
+        get "/0/files/dropbox/none.ext", {}, @env
+        last_response.status.should == 404
+      end
+    end
+  end
+  
+  describe "GET /<version>/metadata/dropbox/<path>" do
+    it "returns metadata" do
+      File.open(File.join(@tmpdir, 'file.ext'), 'w')
+      get "/0/metadata/dropbox/file.ext", {}, @env
+      last_response.should be_ok
+      metadata = JSON.parse(last_response.body)
+      metadata['path'].should == '/file.ext'
+      metadata.should_not include 'contents'
+    end
+    
+    context "when the path is a directory and want a list" do
+      it "returns its children metadata too" do
+        FileUtils.cp(fixture_path('dummy.txt'), @tmpdir)
+        get "/0/metadata/dropbox", {list: 'true'}, @env
+        metadata = JSON.parse(last_response.body)
+        metadata.should include 'contents'
+      end
+    end
+  end
+  
+  describe "POST /<version>/fileops/create_folder" do
+    shared_examples_for "creating folder" do
+      let(:params) { { path: path, root: 'dropbox' } }
+      
+      it "creates a folder" do
+        post "/0/fileops/create_folder", params, @env
+        File.exists?(File.join(@tmpdir, path)).should == true
+        File.directory?(File.join(@tmpdir, path)).should == true
+      end
+      
+      it "returns folder's metadata" do
+        metadata = post "/0/fileops/create_folder", params, @env
+        last_response.should be_ok
+        metadata = JSON.parse(last_response.body)
+        metadata['path'].should == path
+      end
+    end
+  
+    context "when the path to the folder exists" do
+      let(:path) { '/somedir' }
+      
+      it_behaves_like "creating folder"
+    end
+    
+    context "when the path to the folder does not exist" do
+      let(:path) { '/nonexistant/somedir' }
+    
+      it_behaves_like "creating folder"
+    end
+    
+    context "when the root is neither 'dropbox' nor 'sandbox'" do
+      let(:params) { { path: '/somedir', root: 'wrong' } }
+      
+      it "returns error 400" do
+        post "/0/fileops/create_folder", params, @env
+        last_response.status.should == 400
+      end
+    end
+    
+    # seems that directories are created recursively (API docs wrong?)
+#    context "when the path to the folder does not exist" do
+#      let(:params) { { path: '/nonexistant/somedir', root: 'dropbox' } }
+#      
+#      it "returns error 404" do
+#        post "/0/fileops/create_folder", params, @env
+#        last_response.status.should == 404
+#      end
+#    end
+    
+    context "when the path already exists" do
+      let(:params) { { path: '/somedir', root: 'dropbox' } }
+      before { Dir.mkdir(File.join(@tmpdir, 'somedir')) }
+      
+      it "returns error 403" do
+        post "/0/fileops/create_folder", params, @env
+        last_response.status.should == 403
+      end
+    end
+  end
+  
+  describe "POST /<version>/fileops/delete" do
+    let(:params) { { path: '/file.ext', root: 'dropbox' } }
+  
+    context "when the path exists" do
+      
+      shared_examples_for "deleting entry" do
+        it "removes the entry" do
+          post '/0/fileops/delete', params, @env
+          last_response.should be_ok
+          File.exists?(abs_path).should == false
+        end
+      end
+      
+      context "when it's a non-empty directory" do
+        let(:params) { { path: '/somedir', root: 'dropbox' } }
+        let(:abs_path) { File.join(@tmpdir, params[:path]) }
+        before do
+          Dir.mkdir(abs_path)
+          File.open(File.join(abs_path, 'file.ext'), 'w') { |f| f.write "Test file" }
+        end
+        
+        it_behaves_like "deleting entry"
+      end
+    
+      context "when it's not a non-empty directory" do
+        let(:params) { { path: '/file.ext', root: 'dropbox' } }
+        let(:abs_path) { File.join(@tmpdir, params[:path]) }
+        before { File.open(abs_path, 'w') { |f| f.write "Test file" } }
+        
+        it_behaves_like "deleting entry"
+      end
+      
+    end
+    
+    context "when the path doesn't exist" do
+      let(:params) { { path: '/nonexistant.ext', root: 'dropbox' } }
+      
+      it "returns error 404" do
+        post '/0/fileops/delete', params, @env
+        last_response.status.should == 404
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'rack/test'
+require 'fake_dropbox'
+require 'tmpdir'
+require 'fileutils'
+
+module TestHelpers
+  def fixture_path(filename='')
+    File.join(File.dirname(__FILE__), 'fixtures', filename)
+  end
+end
+
+RSpec.configure do |conf|
+  conf.include Rack::Test::Methods
+  conf.include TestHelpers
+end
+
+# ugly hack to show app errors when running rspec ;)
+module FakeDropbox
+  class Server
+    configure :test do
+      disable :raise_errors
+    end
+
+    error do
+      e = env['sinatra.error']
+      puts e.to_s
+      puts e.backtrace.join("\n")
+    end
+  end
+end
+
+def app
+  FakeDropbox::Server
+end
+

data/spec/utils_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+class DummyClass
+  include FakeDropbox::Utils
+
+  def initialize(dropbox_dir)
+    @dropbox_dir = dropbox_dir
+  end
+end
+
+describe 'FakeDropbox::Utils' do
+  subject { DummyClass.new(fixture_path) }
+
+  describe "#metadata" do
+    it "returns correct metadata" do
+      metadata = subject.metadata('/')
+      metadata.should include :thumb_exists, :bytes, :modified, :path,
+        :is_dir, :size, :root, :icon
+    end    
+    
+    context "when path is a file" do
+      it "returns file metadata" do
+        file_path = fixture_path('dummy.txt')
+        metadata = subject.metadata('dummy.txt')
+        metadata.should_not include :contents
+        metadata[:is_dir].should == false
+        metadata[:bytes].should == File.size(file_path)
+        metadata[:path].should == '/dummy.txt'
+        metadata[:modified].should == File.mtime(file_path).strftime(FakeDropbox::Utils::DATE_FORMAT)
+      end
+    end
+    
+    context "when path is a dir" do
+      it "returns dir metadata" do
+        metadata = subject.metadata('/')
+        metadata[:is_dir].should == true
+        metadata[:bytes].should == 0
+        metadata[:path].should == '/'
+        metadata[:modified].should == File.mtime(fixture_path).strftime(FakeDropbox::Utils::DATE_FORMAT)
+      end
+      
+      context "when list is true" do
+        it "returns the metadata of all its children too" do
+          metadata = subject.metadata('/', true)
+          metadata.should include :contents
+          metadata[:contents][0].should == subject.metadata('dummy.txt')
+        end
+      end
+    end
+  end
+  
+  describe "#safe_path" do
+    it "returns a safe path" do
+      subject.safe_path('../aa/../bb/..').should == 'aa/bb'
+    end
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: fake_dropbox
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Juliusz Gonera
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-27 00:00:00.000000000 +02:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &16756060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *16756060
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &16787980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *16787980
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &16787520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *16787520
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &16787060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *16787060
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &16786600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *16786600
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &16786140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *16786140
+description: Written in Ruby using the Sinatra framework. For development and testing
+  purposes, no real authentication and users, stores files on the local machine. Can
+  be used either as a standalone app listening on a port or intercept calls to the
+  real Dropbox in Ruby apps.
+email:
+- jgonera@gmail.com
+executables:
+- fake_dropbox
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/fake_dropbox
+- config.ru
+- fake_dropbox.gemspec
+- lib/fake_dropbox.rb
+- lib/fake_dropbox/glue.rb
+- lib/fake_dropbox/server.rb
+- lib/fake_dropbox/utils.rb
+- lib/fake_dropbox/version.rb
+- spec/fixtures/dummy.txt
+- spec/glue_spec.rb
+- spec/server_spec.rb
+- spec/spec_helper.rb
+- spec/utils_spec.rb
+has_rdoc: true
+homepage: https://github.com/jgonera/fake_dropbox
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: fake_dropbox
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A simple fake implementation of the Dropbox API
+test_files: []