fakes3 0.1.0 → 0.1.1

data/Gemfile.lock

@@ -8,25 +8,38 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
+    archive-tar-minitar (0.5.2)
     aws-s3 (0.6.2)
       builder
       mime-types
       xml-simple
-    builder (2.1.2)
-    mime-types (1.16)
-    right_aws (2.0.0)
-      right_http_connection (>= 1.2.1)
-    right_http_connection (1.2.4)
-    thor (0.14.4)
-    xml-simple (1.0.12)
+    builder (3.0.0)
+    columnize (0.3.6)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    mime-types (1.18)
+    right_aws (3.0.4)
+      right_http_connection (>= 1.2.5)
+    right_http_connection (1.3.0)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    thor (0.14.6)
+    xml-simple (1.1.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   aws-s3
-  builder
   bundler (>= 1.0.0)
   fakes3!
   right_aws
-  thor
+  ruby-debug19

data/README.md

@@ -3,7 +3,10 @@ FakeS3 is a lightweight server that responds to the same calls Amazon S3 respond
 It is extremely useful for testing of S3 in a sandbox environment without actually
 making calls to Amazon, which not only require network, but also cost you precious dollars.  
 
-For now there is a basic file store backend.
+The goal of Fake S3 is to minimize runtime dependencies and be more of a
+development tool to test S3 calls in your code rather than a production server
+looking to duplicate S3 functionality.  Trying RiakCS, ParkPlace/Boardwalk, or
+Ceph might be a place to start if that is your goal.
 
 FakeS3 doesn't support all of the S3 command set, but the basic ones like put, get,
 list, copy, and make bucket are supported.  More coming soon.
@@ -20,20 +23,20 @@ To run a fakes3 server, you just specify a root and a port.
 
 Take a look at the test cases to see client example usage.  For now, FakeS3 is
 mainly tested with s3cmd, aws-s3 gem, and right_aws.  There are plenty more
-libraries out there, and please do mention other clients.
+libraries out there, and please do mention if other clients work or not.
 
 ## Running Tests
-In order to run the tests add the following line to your /etc/hosts:
 
-    127.0.0.1 s3.localhost
-
-Then start the test server using
+Start the test server using
 
     rake test_server
 
-
 Then in another terminal window run
 
     rake test
 
 It is a TODO to get this to be just one command
+
+## More Information
+
+Check out the wiki https://github.com/jubos/fake-s3/wiki

data/Rakefile

@@ -9,6 +9,7 @@ Rake::TestTask.new(:test) do |t|
   t.ruby_opts << '-I.'
 end
 
+desc "Run the test_server"
 task :test_server do |t|
   system("bundle exec bin/fakes3 --port 10453 --root test_root")
 end

data/lib/fakes3/bucket.rb

@@ -1,5 +1,7 @@
 require 'builder'
+require 'thread'
 require 'fakes3/s3_object'
+require 'fakes3/red_black_tree'
 
 module FakeS3
   class Bucket
@@ -8,10 +10,52 @@ module FakeS3
     def initialize(name,creation_date,objects)
       @name = name
       @creation_date = creation_date
-      @objects = []
+      @objects = SortedSet.new
+      @objects = RedBlackTree.new
       objects.each do |obj|
-        @objects << obj
+        @objects.add(obj)
       end
+      @mutex = Mutex.new
+    end
+
+    def <<(object)
+      # Unfortunately have to synchronize here since the RB Tree is not thread
+      # safe. Probably can get finer granularity if performance is important
+      @mutex.synchronize do
+        exists = @objects.search(object.name)
+        if exists.nil?
+          @objects.add(object.name,object)
+        end
+      end
+    end
+
+    def delete(object_name)
+      @objects.delete_via_key(object_name)
+    end
+
+    def query_for_range(options)
+      marker = options[:marker]
+      prefix = options[:prefix]
+      max_keys = options[:max_keys] || 1000
+      delimiter = options[:delimiter]
+
+      matches = []
+      is_truncated = false
+
+      @mutex.synchronize do
+        matches, is_truncated = @objects.search_for_range(
+          marker,prefix,max_keys,delimiter)
+      end
+
+      bq = BucketQuery.new
+      bq.bucket = self
+      bq.marker = marker
+      bq.prefix = prefix
+      bq.max_keys = max_keys
+      bq.delimiter = delimiter
+      bq.matches = matches
+      bq.is_truncated = is_truncated
+      return bq
     end
 
   end

data/lib/fakes3/bucket_query.rb

@@ -0,0 +1,11 @@
+module FakeS3
+  class BucketQuery
+    attr_accessor :prefix,:matches,:marker,:max_keys,
+                  :delimiter,:bucket,:is_truncated
+
+    # Syntactic sugar
+    def is_truncated?
+      @is_truncated
+    end
+  end
+end

data/lib/fakes3/file_store.rb

@@ -112,9 +112,9 @@ module FakeS3
       return obj
     end
 
-    def store_object(bucket,object,request)
+    def store_object(bucket,object_name,request)
       begin
-        filename = File.join(@root,bucket,object)
+        filename = File.join(@root,bucket.name,object_name)
         FileUtils.mkdir_p(filename)
 
         metadata_dir = File.join(filename,SHUCK_METADATA_DIR)
@@ -124,6 +124,7 @@ module FakeS3
         metadata = File.join(filename,SHUCK_METADATA_DIR,"metadata")
 
         md5 = Digest::MD5.new
+        # TODO put a tmpfile here first and mv it over at the end
 
         File.open(content,'wb') do |f|
           request.body do |chunk|
@@ -139,9 +140,14 @@ module FakeS3
         File.open(metadata,'w') do |f|
           f << YAML::dump(metadata_struct)
         end
+
         obj = S3Object.new
+        obj.name = object_name
         obj.md5 = metadata_struct[:md5]
         obj.content_type = metadata_struct[:content_type]
+
+        # TODO need a semaphore here since bucket is not probably not thread safe
+        bucket << obj
         return obj
       rescue
         puts $!
@@ -149,5 +155,17 @@ module FakeS3
         return nil
       end
     end
+
+    def delete_object(bucket,object_name,request)
+      begin
+        filename = File.join(@root,bucket.name,object_name)
+        FileUtils.rm_rf(filename)
+        bucket.delete(object_name)
+      rescue
+        puts $!
+        $!.backtrace.each { |line| puts line }
+        return nil
+      end
+    end
   end
 end

data/lib/fakes3/red_black_tree.rb

@@ -0,0 +1,395 @@
+# Algorithm based on "Introduction to Algorithms" by Cormen and others
+# Retrieved from
+# https://github.com/headius/redblack/blob/master/red_black_tree.rb
+#
+# Modified by Curtis Spencer
+class RedBlackTree
+  class Node
+    attr_accessor :color
+    attr_accessor :key
+    attr_accessor :left
+    attr_accessor :right
+    attr_accessor :parent
+    attr_accessor :value
+
+    RED = :red
+    BLACK = :black
+    COLORS = [RED, BLACK].freeze
+
+    def initialize(key, value, color = RED)
+      raise ArgumentError, "Bad value for color parameter" unless COLORS.include?(color)
+      @color = color
+      @key = key
+      @value = value
+      @left = @right = @parent = NilNode.instance
+    end
+
+    def black?
+      return color == BLACK
+    end
+
+    def red?
+      return color == RED
+    end
+  end
+
+  class NilNode < Node
+    class << self
+      private :new
+      @instance = nil
+
+      # it's not thread safe
+      def instance
+        if @instance.nil?
+          @instance = new
+
+          def instance
+            return @instance
+          end
+        end
+
+        return @instance
+      end
+    end
+
+    def initialize
+      self.color = BLACK
+      self.key = 0
+      self.left = nil
+      self.right = nil
+      self.parent = nil
+    end
+
+    def nil?
+      return true
+    end
+  end
+
+  include Enumerable
+
+  attr_accessor :root
+  attr_accessor :size
+
+  def initialize
+    self.root = NilNode.instance
+    self.size = 0
+  end
+
+  def add(key,value)
+    insert(Node.new(key,value))
+  end
+
+  def insert(x)
+    insert_helper(x)
+
+    x.color = Node::RED
+    while x != root && x.parent.color == Node::RED
+      if x.parent == x.parent.parent.left
+        y = x.parent.parent.right
+        if !y.nil? && y.color == Node::RED
+          x.parent.color = Node::BLACK
+          y.color = Node::BLACK
+          x.parent.parent.color = Node::RED
+          x = x.parent.parent
+        else
+          if x == x.parent.right
+            x = x.parent
+            left_rotate(x)
+          end
+          x.parent.color = Node::BLACK
+          x.parent.parent.color = Node::RED
+          right_rotate(x.parent.parent)
+        end
+      else
+        y = x.parent.parent.left
+        if !y.nil? && y.color == Node::RED
+          x.parent.color = Node::BLACK
+          y.color = Node::BLACK
+          x.parent.parent.color = Node::RED
+          x = x.parent.parent
+        else
+          if x == x.parent.left
+            x = x.parent
+            right_rotate(x)
+          end
+          x.parent.color = Node::BLACK
+          x.parent.parent.color = Node::RED
+          left_rotate(x.parent.parent)
+        end
+      end
+    end
+    root.color = Node::BLACK
+  end
+
+  alias << insert
+
+  def delete(z)
+    y = (z.left.nil? || z.right.nil?) ? z : successor(z)
+    x = y.left.nil? ? y.right : y.left
+    x.parent = y.parent
+
+    if y.parent.nil?
+      self.root = x
+    else
+      if y == y.parent.left
+        y.parent.left = x
+      else
+        y.parent.right = x
+      end
+    end
+
+    z.key = y.key if y != z
+
+    if y.color == Node::BLACK
+      delete_fixup(x)
+    end
+
+    self.size -= 1
+    return y
+  end
+
+  def minimum(x = root)
+    while !x.left.nil?
+      x = x.left
+    end
+    return x
+  end
+
+  def maximum(x = root)
+    while !x.right.nil?
+      x = x.right
+    end
+    return x
+  end
+
+  def successor(x)
+    if !x.right.nil?
+      return minimum(x.right)
+    end
+    y = x.parent
+    while !y.nil? && x == y.right
+      x = y
+      y = y.parent
+    end
+    return y
+  end
+
+  def predecessor(x)
+    if !x.left.nil?
+      return maximum(x.left)
+    end
+    y = x.parent
+    while !y.nil? && x == y.left
+      x = y
+      y = y.parent
+    end
+    return y
+  end
+
+  def inorder_walk(x = root)
+    x = self.minimum
+    while !x.nil?
+      yield x.key
+      x = successor(x)
+    end
+  end
+
+  alias each inorder_walk
+
+  def reverse_inorder_walk(x = root)
+    x = self.maximum
+    while !x.nil?
+      yield x.key
+      x = predecessor(x)
+    end
+  end
+
+  alias reverse_each reverse_inorder_walk
+
+  def search(key, x = root)
+    while !x.nil? && x.key != key
+      key < x.key ? x = x.left : x = x.right
+    end
+    return x
+  end
+
+  # Search for a successor even if the key doesn't exist
+  def search_for_possible_successor(key, x = root)
+    node = search(key)
+    pseudo = false
+    if node.class == NilNode
+      insert(Node.new(key,nil))
+      node = search(key)
+      pseudo = true
+    end
+
+    succ = successor(node)
+    delete(node) if pseudo
+    return nil if !succ
+    return succ
+  end
+
+  def delete_via_key(key)
+    node = search(key)
+    return if node.class == NilNode
+    delete(node)
+  end
+
+  # Return array of matches and a boolean to denote whether truncation occurred
+  def search_for_range(marker,prefix,max_keys,delimiter)
+    succ = nil
+    if marker
+      succ = search_for_possible_successor(marker)
+    else
+      succ = self.minimum
+    end
+
+    return [],false if succ.class == NilNode
+
+    keys_count = 0
+    keys = []
+    is_truncated = false
+
+    loop do
+      if !prefix or succ.key.index(prefix) == 0
+        keys_count += 1
+        if keys_count <= max_keys
+          keys << succ.value
+        else
+          is_truncated = true
+          break
+        end
+      end
+      succ = successor(succ)
+      if succ.class == NilNode
+        break
+      end
+    end
+
+    return keys,is_truncated
+  end
+
+  def empty?
+    return self.root.nil?
+  end
+
+  def black_height(x = root)
+    height = 0
+    while !x.nil?
+      x = x.left
+      height +=1 if x.nil? || x.black?
+    end
+    return height
+  end
+
+private
+
+  def left_rotate(x)
+    raise "x.right is nil!" if x.right.nil?
+    y = x.right
+    x.right = y.left
+    y.left.parent = x if !y.left.nil?
+    y.parent = x.parent
+    if x.parent.nil?
+      self.root = y
+    else
+      if x == x.parent.left
+        x.parent.left = y
+      else
+        x.parent.right = y
+      end
+    end
+    y.left = x
+    x.parent = y
+  end
+
+  def right_rotate(x)
+    raise "x.left is nil!" if x.left.nil?
+    y = x.left
+    x.left = y.right
+    y.right.parent = x if !y.right.nil?
+    y.parent = x.parent
+    if x.parent.nil?
+      self.root = y
+    else
+      if x == x.parent.left
+        x.parent.left = y
+      else
+        x.parent.right = y
+      end
+    end
+    y.right = x
+    x.parent = y
+  end
+
+  def insert_helper(z)
+    y = NilNode.instance
+    x = root
+    while !x.nil?
+      y = x
+      z.key < x.key ? x = x.left : x = x.right
+    end
+    z.parent = y
+    if y.nil?
+      self.root = z
+    else
+      z.key < y.key ? y.left = z : y.right = z
+    end
+    self.size += 1
+  end
+
+  def delete_fixup(x)
+    while x != root && x.color == Node::BLACK
+      if x == x.parent.left
+        w = x.parent.right
+        if w.color == Node::RED
+          w.color = Node::BLACK
+          x.parent.color = Node::RED
+          left_rotate(x.parent)
+          w = x.parent.right
+        end
+        if w.left.color == Node::BLACK && w.right.color == Node::BLACK
+          w.color = Node::RED
+          x = x.parent
+        else
+          if w.right.color == Node::BLACK
+            w.left.color = Node::BLACK
+            w.color = Node::RED
+            right_rotate(w)
+            w = x.parent.right
+          end
+          w.color = x.parent.color
+          x.parent.color = Node::BLACK
+          w.right.color = Node::BLACK
+          left_rotate(x.parent)
+          x = root
+        end
+      else
+        w = x.parent.left
+        if w.color == Node::RED
+          w.color = Node::BLACK
+          x.parent.color = Node::RED
+          right_rotate(x.parent)
+          w = x.parent.left
+        end
+        if w.right.color == Node::BLACK && w.left.color == Node::BLACK
+          w.color = Node::RED
+          x = x.parent
+        else
+          if w.left.color == Node::BLACK
+            w.right.color = Node::BLACK
+            w.color = Node::RED
+            left_rotate(w)
+            w = x.parent.left
+          end
+          w.color = x.parent.color
+          x.parent.color = Node::BLACK
+          w.left.color = Node::BLACK
+          right_rotate(x.parent)
+          x = root
+        end
+      end
+    end
+    x.color = Node::BLACK
+  end
+end

data/lib/fakes3/s3_object.rb

@@ -1,5 +1,11 @@
 module FakeS3
   class S3Object
+    include Comparable
     attr_accessor :name,:size,:creation_date,:md5,:io,:content_type
+
+    # Sort by the object's name
+    def <=>(object)
+      @name <=> object.name
+    end
   end
 end

data/lib/fakes3/server.rb

@@ -1,21 +1,27 @@
 require 'webrick'
 require 'fakes3/file_store'
 require 'fakes3/xml_adapter'
+require 'fakes3/bucket_query'
+require 'fakes3/unsupported_operation'
 
 module FakeS3
   class Request
     CREATE_BUCKET = "CREATE_BUCKET"
     LIST_BUCKETS = "LIST_BUCKETS"
     LS_BUCKET = "LS_BUCKET"
+    HEAD = "HEAD"
     STORE = "STORE"
     COPY = "COPY"
     GET = "GET"
     GET_ACL = "GET_ACL"
     SET_ACL = "SET_ACL"
     MOVE = "MOVE"
-    DELETE = "DELETE"
+    DELETE_OBJECT = "DELETE_OBJECT"
+    DELETE_BUCKET = "DELETE_BUCKET"
 
-    attr_accessor :bucket,:object,:type,:src_bucket,:src_object,:method,:webrick_request,:path,:is_path_style
+    attr_accessor :bucket,:object,:type,:src_bucket,
+                  :src_object,:method,:webrick_request,
+                  :path,:is_path_style,:query,:http_verb
 
     def inspect
       puts "-----Inspect FakeS3 Request"
@@ -26,6 +32,7 @@ module FakeS3
       puts "Object: #{@object}"
       puts "Src Bucket: #{@src_bucket}"
       puts "Src Object: #{@src_object}"
+      puts "Query: #{@query}"
       puts "-----Done"
     end
   end
@@ -51,8 +58,15 @@ module FakeS3
         bucket_obj = @store.get_bucket(s_req.bucket)
         if bucket_obj
           response.status = 200
-          response.body = XmlAdapter.bucket(bucket_obj)
           response['Content-Type'] = "application/xml"
+          query = {
+            :marker => s_req.query["marker"] ? s_req.query["marker"].to_s : nil,
+            :prefix => s_req.query["prefix"] ? s_req.query["prefix"].to_s : nil,
+            :max_keys => s_req.query["max_keys"] ? s_req.query["max_keys"].to_s : nil,
+            :delimiter => s_req.query["delimiter"] ? s_req.query["delimiter"].to_s : nil
+          }
+          bq = bucket_obj.query_for_range(query)
+          response.body = XmlAdapter.bucket_query(bq)
         else
           response.status = 404
           response.body = XmlAdapter.error_no_such_bucket(s_req.bucket)
@@ -98,19 +112,23 @@ module FakeS3
           end
         end
         response['Content-Length'] = File::Stat.new(real_obj.io.path).size
-        response.body = real_obj.io
+        if s_req.http_verb == 'HEAD'
+          response.body = ""
+        else
+          response.body = real_obj.io
+        end
       end
     end
 
     def do_PUT(request,response)
       s_req = normalize_request(request)
 
-
       case s_req.type
       when Request::COPY
         @store.copy_object(s_req.src_bucket,s_req.src_object,s_req.bucket,s_req.object)
       when Request::STORE
-        real_obj = @store.store_object(s_req.bucket,s_req.object,s_req.webrick_request)
+        bucket_obj = @store.get_bucket(s_req.bucket)
+        real_obj = @store.store_object(bucket_obj,s_req.object,s_req.webrick_request)
         response['Etag'] = real_obj.md5
       when Request::CREATE_BUCKET
         @store.create_bucket(s_req.bucket)
@@ -126,11 +144,47 @@ module FakeS3
     end
 
     def do_DELETE(request,response)
-      p request
+      s_req = normalize_request(request)
+
+      case s_req.type
+      when Request::DELETE_OBJECT
+        bucket_obj = @store.get_bucket(s_req.bucket)
+        @store.delete_object(bucket_obj,s_req.object,s_req.webrick_request)
+      end
+
+      response.status = 204
+      response.body = ""
     end
 
     private
 
+    def normalize_delete(webrick_req,s_req)
+      path = webrick_req.path
+      path_len = path.size
+      query = webrick_req.query
+      if path == "/" and s_req.is_path_style
+        # Probably do a 404 here
+      else
+        if s_req.is_path_style
+          elems = path[1,path_len].split("/")
+          s_req.bucket = elems[0]
+        else
+          elems = path.split("/")
+        end
+
+        if elems.size == 0
+          raise UnsupportedOperation
+        elsif elems.size == 1
+          s_req.type = Request::DELETE_BUCKET
+          s_req.query = query
+        else
+          s_req.type = Request::DELETE_OBJECT
+          object = elems[1,elems.size].join('/')
+          s_req.object = object
+        end
+      end
+    end
+
     def normalize_get(webrick_req,s_req)
       path = webrick_req.path
       path_len = path.size
@@ -150,6 +204,7 @@ module FakeS3
           s_req.type = Request::LIST_BUCKETS
         elsif elems.size == 1
           s_req.type = Request::LS_BUCKET
+          s_req.query = query
         else
           if query["acl"] == ""
             s_req.type = Request::GET_ACL
@@ -219,11 +274,15 @@ module FakeS3
         s_req.is_path_style = false
       end
 
+      s_req.http_verb = webrick_req.request_method
+
       case webrick_req.request_method
       when 'PUT'
         normalize_put(webrick_req,s_req)
-      when 'GET'
+      when 'GET','HEAD'
         normalize_get(webrick_req,s_req)
+      when 'DELETE'
+        normalize_delete(webrick_req,s_req)
       else
         raise "Unknown Request"
       end

data/lib/fakes3/unsupported_operation.rb

@@ -0,0 +1,4 @@
+module FakeS3
+  class UnsupportedOperation < RuntimeError
+  end
+end

data/lib/fakes3/version.rb

@@ -1,3 +1,3 @@
 module FakeS3
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/fakes3/xml_adapter.rb

@@ -28,9 +28,10 @@ module FakeS3
     #<Error>
     #  <Code>NoSuchKey</Code>
     #  <Message>The resource you requested does not exist</Message>
-    #  <Resource>/mybucket/myfoto.jpg</Resource> 
+    #  <Resource>/mybucket/myfoto.jpg</Resource>
     #  <RequestId>4442587FB7D0A2F9</RequestId>
-    #</Error> 
+    #</Error>
+    #
     def self.error_no_such_bucket(name)
       output = ""
       xml = Builder::XmlMarkup.new(:target => output)
@@ -72,6 +73,54 @@ module FakeS3
       output
     end
 
+    # A bucket query gives back the bucket along with contents
+    #  <Contents>
+    #<Key>Nelson</Key>
+#    <LastModified>2006-01-01T12:00:00.000Z</LastModified>
+#    <ETag>&quot;828ef3fdfa96f00ad9f27c383fc9ac7f&quot;</ETag>
+#    <Size>5</Size>
+#    <StorageClass>STANDARD</StorageClass>
+#    <Owner>
+#      <ID>bcaf161ca5fb16fd081034f</ID>
+#      <DisplayName>webfile</DisplayName>
+#     </Owner>
+#    </Contents>
+
+    def self.append_objects_to_list_bucket_result(lbr,objects)
+      return if objects.nil? or objects.size == 0
+
+      objects.each do |s3_object|
+        lbr.Contents { |contents|
+          contents.Key(s3_object.name)
+          contents.LastModifed(s3_object.creation_date)
+          contents.ETag("\"#{s3_object.md5}\"")
+          contents.Size(s3_object.size)
+          contents.StorageClass("STANDARD")
+
+          contents.Owner { |owner|
+            owner.ID("abc")
+            owner.DisplayName("You")
+          }
+        }
+      end
+    end
+
+    def self.bucket_query(bucket_query)
+      output = ""
+      bucket = bucket_query.bucket
+      xml = Builder::XmlMarkup.new(:target => output)
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      xml.ListBucketResult(:xmlns => "http://s3.amazonaws.com/doc/2006-03-01/") { |lbr|
+        lbr.Name(bucket.name)
+        lbr.Prefix(bucket_query.prefix)
+        lbr.Marker(bucket_query.marker)
+        lbr.MaxKeys(bucket_query.max_keys)
+        lbr.IsTruncated(bucket_query.is_truncated?)
+        append_objects_to_list_bucket_result(lbr,bucket_query.matches)
+      }
+      output
+    end
+
     # ACL xml
     def self.acl(object = nil)
       output = ""

data/test/right_aws_commands_test.rb

@@ -8,7 +8,7 @@ class RightAWSCommandsTest < Test::Unit::TestCase
   def setup
     @s3 = RightAws::S3Interface.new('1E3GDYEOGFJPIT7XXXXXX','hgTHt68JY07JKUY08ftHYtERkjgtfERn57XXXXXX',
                                     {:multi_thread => false, :server => 'localhost',
-                                      :port => 10453, :protocol => 'http',:logger => Logger.new("/dev/null") })
+                                      :port => 10453, :protocol => 'http',:logger => Logger.new("/dev/null"),:no_subdomains => true })
   end
 
   def teardown

data/test/s3_commands_test.rb

@@ -15,44 +15,44 @@ class S3CommandsTest < Test::Unit::TestCase
   end
 
   def test_create_bucket
-    bucket = Bucket.create("mybucket")
+    bucket = Bucket.create("ruby_aws_s3")
     assert_not_nil bucket
   end
 
   def test_store
-    bucket = Bucket.create("mybucket")
-    S3Object.store("hello","world","mybucket")
+    bucket = Bucket.create("ruby_aws_s3")
+    S3Object.store("hello","world","ruby_aws_s3")
 
     output = ""
-    obj = S3Object.stream("hello","mybucket") do |chunk|
+    obj = S3Object.stream("hello","ruby_aws_s3") do |chunk|
       output << chunk
     end
     assert_equal "world", output
   end
 
   def test_large_store
-    bucket = Bucket.create("mybucket")
+    bucket = Bucket.create("ruby_aws_s3")
     buffer = ""
     500000.times do
       buffer << "#{(rand * 100).to_i}"
     end
 
     buf_len = buffer.length
-    S3Object.store("big",buffer,"mybucket")
+    S3Object.store("big",buffer,"ruby_aws_s3")
 
     output = ""
-    S3Object.stream("big","mybucket") do |chunk|
+    S3Object.stream("big","ruby_aws_s3") do |chunk|
       output << chunk
     end
     assert_equal buf_len,output.size
   end
 
   def test_multi_directory
-    bucket = Bucket.create("mybucket")
-    S3Object.store("dir/myfile/123.txt","recursive","mybucket")
+    bucket = Bucket.create("ruby_aws_s3")
+    S3Object.store("dir/myfile/123.txt","recursive","ruby_aws_s3")
 
     output = ""
-    obj = S3Object.stream("dir/myfile/123.txt","mybucket") do |chunk|
+    obj = S3Object.stream("dir/myfile/123.txt","ruby_aws_s3") do |chunk|
       output << chunk
     end
     assert_equal "recursive", output
@@ -66,4 +66,62 @@ class S3CommandsTest < Test::Unit::TestCase
       assert_equal AWS::S3::NoSuchBucket,$!.class
     end
   end
+
+  def test_find_object
+    bucket = Bucket.create('find_bucket')
+    obj_name = 'short'
+    S3Object.store(obj_name,'short_text','find_bucket')
+    short = S3Object.find(obj_name,"find_bucket")
+    assert_not_nil(short)
+    assert_equal(short.value,'short_text')
+  end
+
+  def test_find_non_existent_object
+    bucket = Bucket.create('find_bucket')
+    obj_name = 'doesnotexist'
+    assert_raise AWS::S3::NoSuchKey do
+      should_throw = S3Object.find(obj_name,"find_bucket")
+    end
+
+    # Try something higher in the alphabet
+    assert_raise AWS::S3::NoSuchKey do
+      should_throw = S3Object.find("zzz","find_bucket")
+    end
+  end
+
+  def test_exists?
+    bucket = Bucket.create('ruby_aws_s3')
+    obj_name = 'dir/myfile/exists.txt'
+    S3Object.store(obj_name,'exists','ruby_aws_s3')
+    assert S3Object.exists?(obj_name, 'ruby_aws_s3')
+    assert !S3Object.exists?('dir/myfile/doesnotexist.txt','ruby_aws_s3')
+  end
+
+  def test_delete
+    bucket = Bucket.create("ruby_aws_s3")
+    S3Object.store("something_to_delete","asdf","ruby_aws_s3")
+    something = S3Object.find("something_to_delete","ruby_aws_s3")
+    S3Object.delete("something_to_delete","ruby_aws_s3")
+  end
+
+  def test_larger_lists
+    Bucket.create("ruby_aws_s3_many")
+    (0..100).each do |i|
+      ('a'..'z').each do |letter|
+        name = "#{letter}#{i}"
+        S3Object.store(name,"asdf","ruby_aws_s3_many")
+      end
+    end
+
+    bucket = Bucket.find("ruby_aws_s3_many")
+    assert_equal(bucket.objects.first.key,"a0")
+    assert_equal(bucket.size,1000)
+  end
+
+  # Copying an object
+  #S3Object.copy 'headshot.jpg', 'headshot2.jpg', 'photos'
+
+  # Renaming an object
+  #S3Object.rename 'headshot.jpg', 'portrait.jpg', 'photos'
+
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Curtis Spencer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-13 00:00:00 -07:00
+date: 2012-04-16 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -103,11 +103,14 @@ files:
 - fakes3.gemspec
 - lib/fakes3.rb
 - lib/fakes3/bucket.rb
+- lib/fakes3/bucket_query.rb
 - lib/fakes3/cli.rb
 - lib/fakes3/file_store.rb
 - lib/fakes3/rate_limitable_file.rb
+- lib/fakes3/red_black_tree.rb
 - lib/fakes3/s3_object.rb
 - lib/fakes3/server.rb
+- lib/fakes3/unsupported_operation.rb
 - lib/fakes3/version.rb
 - lib/fakes3/xml_adapter.rb
 - test/local_s3_cfg