ruby-atmos-pure 1.0.3

data/test/test_object_create.rb

@@ -0,0 +1,167 @@
+require 'credentials'
+require 'test/unit'
+require 'atmos'
+
+
+class AtmosObjectCreateTest < Test::Unit::TestCase
+
+   def initialize(id)
+      super(id)
+      @cleanup = []
+   end
+
+   def setup
+      @s = Atmos::Test::Util.static_store
+   end
+
+
+   def teardown
+      @cleanup.each do |obj|
+         obj.delete
+      end
+      $stdout.flush
+   end
+
+   def test_create_empty_object_via_object_interface
+      obj = @s.create
+      @cleanup.push(obj)
+
+      assert_not_nil(obj)
+      assert_equal({}, obj.metadata)
+      assert_equal({}, obj.listable_metadata)
+      assert_equal({Atmos::Test::Util.user => :full}, obj.user_acl)
+      assert_equal({Atmos::Test::Util.group => :none}, obj.group_acl)
+   end
+  
+   def test_create_empty_object_via_namespace_interface
+      time = Time.now()
+      time = time.to_i
+      ns   = "/foo/bar#{time}"
+
+      obj = @s.create(:namespace => ns)
+      @cleanup.push(obj)
+
+      assert_not_nil(obj)
+      assert_equal({}, obj.metadata)
+      assert_equal({}, obj.listable_metadata)
+      assert_equal({Atmos::Test::Util.user => :full}, obj.user_acl)
+      assert_equal({Atmos::Test::Util.group => :none}, obj.group_acl)
+   end
+  
+   def test_create_object_with_bad_option
+      assert_raise Atmos::Exceptions::ArgumentException do 
+         @cleanup.push(@s.create(:tag => ['testtag']))
+      end
+   end
+  
+   def test_create_object_with_md_as_string
+      assert_raise Atmos::Exceptions::ArgumentException do 
+         @cleanup.push(@s.create(:metadata => 'testtag'))
+      end
+   end
+   
+   def test_create_object_with_md_as_array
+      assert_raise Atmos::Exceptions::ArgumentException do 
+         @cleanup.push(@s.create(:metadata => ['testtag']))
+      end
+   end
+   
+   def test_create_object_with_metadata
+      md    = {'non' => 'listable', 'user' => 'metadata', 'a' => 'b'}
+      obj = @s.create(:metadata => md)
+      @cleanup.push(obj)
+      assert_not_nil(obj)
+      
+      assert(obj.metadata.non_listable?)
+      assert(!obj.metadata.listable?)
+      assert_not_equal({}, obj.metadata)
+      assert_equal(md, obj.metadata)
+      
+      assert_equal({}, obj.listable_metadata)
+      assert_equal({Atmos::Test::Util.user => :full}, obj.user_acl)
+      assert_equal({Atmos::Test::Util.group => :none}, obj.group_acl)
+   end
+  
+   def test_create_object_with_listable_metadata
+      lmd = {'x' => 'a', 'y' => 'b', 'z' => 'c'}
+      obj = @s.create(:listable_metadata => lmd)
+      @cleanup.push(obj)
+      assert_not_nil(obj)
+      assert_equal({}, obj.metadata)
+      assert_equal({Atmos::Test::Util.user => :full}, obj.user_acl)
+      assert_equal({Atmos::Test::Util.group => :none}, obj.group_acl)
+      
+      assert_not_equal({}, obj.listable_metadata)
+      assert_equal(lmd, obj.listable_metadata)
+      assert(!obj.listable_metadata.non_listable?)
+      assert(obj.listable_metadata.listable?)
+   end
+  
+   def test_create_object_with_mixed_metadata
+      md    = {'non' => 'listable', 'user' => 'metadata', 'a' => 'b'}
+      lmd = {'x' => 'a', 'y' => 'b', 'z' => 'c'}
+      obj = @s.create(:metadata => md, :listable_metadata => lmd)
+      @cleanup.push(obj)
+      assert_not_nil(obj)
+      assert_equal({Atmos::Test::Util.user => :full}, obj.user_acl)
+      assert_equal({Atmos::Test::Util.group => :none}, obj.group_acl)
+      
+      assert(!obj.listable_metadata.non_listable?)
+      assert(obj.listable_metadata.listable?)
+      assert_not_equal({}, obj.listable_metadata)
+      assert_equal(lmd, obj.listable_metadata)
+
+      assert(obj.metadata.non_listable?)
+      assert(!obj.metadata.listable?)
+      assert_not_equal({}, obj.metadata)
+      assert_equal(md, obj.metadata)
+   end
+  
+#  def test_create_object_with_acl
+#  end
+  
+   def test_create_object_with_data_as_string_with_length
+      data = "some stupid blob content"
+      obj = @s.create(:data => data, :length => data.length)
+      @cleanup.push(obj)
+      assert_equal(data, obj.data)
+   end
+   
+   def test_create_object_with_data_as_string_without_length
+      data = "some stupid blob content"
+      obj = @s.create(:data => data)
+      @cleanup.push(obj)
+      assert_equal(data, obj.data)
+   end
+   
+   def test_create_object_with_data_as_stream_with_length
+      contents = open(Atmos::Test::Util.small_text_filename).read
+      data = open(Atmos::Test::Util.small_text_filename)
+      obj = @s.create(:data => data, :length => data.stat.size)
+      @cleanup.push(obj)
+      assert_equal(contents, obj.data)
+   end
+
+   def test_create_object_with_data_as_stream_without_length
+      file = open(Atmos::Test::Util.small_text_filename)
+      contents = file.read
+      file.close
+      data = open(Atmos::Test::Util.small_text_filename)
+      obj = @s.create(:data => data)
+      @cleanup.push(obj)
+      assert_equal(contents, obj.data)
+   end
+   
+   def donttest_create_with_IO_as_data
+       @s   = Atmos::Test::Util.static_store
+    @md  = {'non' => 'listable', 'user' => 'metadata', 'a' => 'b'}
+    @lmd = {'x' => 'a', 'y' => 'b', 'z' => 'c'}
+    data = open(Atmos::Test::Util.small_binary_filename)
+    obj  = @s.create(:metadata => @md, 
+                     :listable_metadata => @lmd,
+                     :data => File.new(Atmos::Test::Util.small_binary_filename, "rb"))
+    @cleanup.push(obj)
+    @aoid = obj.aoid
+ end
+
+end

data/test/test_object_get.rb

@@ -0,0 +1,55 @@
+require 'credentials'
+require 'test/unit'
+require 'atmos'
+
+
+class AtmosObjectGetTest < Test::Unit::TestCase
+
+   def initialize(id)
+      super(id)
+      @cleanup = []
+
+   end
+
+   def setup
+      @s = Atmos::Test::Util.static_store
+   end
+
+
+   def teardown
+      @cleanup.each do |obj|
+         obj.delete
+      end
+      $stdout.flush
+   end
+
+   def test_get_object_via_object_interface
+      obj = @s.create
+      @cleanup.push(obj)
+
+      obj = @s.get(:id => obj.aoid)
+      assert_not_nil(obj)
+      assert_equal({}, obj.metadata)
+      assert_equal({}, obj.listable_metadata)
+      assert_equal({Atmos::Test::Util.user => :full}, obj.user_acl)
+      assert_equal({Atmos::Test::Util.group => :none}, obj.group_acl)
+   end
+  
+   def test_get_object_via_namespace_interface
+      time = Time.now()
+      time = time.to_i#{}"%.6f" % a.to_f   #=> "1195480202.282373"
+
+      ns = "/foo/bar#{time}"
+      obj = @s.create(:namespace => ns)
+      obj = @s.get(:namespace => ns)
+      
+      assert_not_nil(obj)
+      assert_equal({}, obj.metadata)
+      assert_equal({}, obj.listable_metadata)
+      assert_equal({Atmos::Test::Util.user => :full}, obj.user_acl)
+      assert_equal({Atmos::Test::Util.group => :none}, obj.group_acl)
+      
+      obj.delete()
+   end
+  
+end

data/test/test_object_misc.rb

@@ -0,0 +1,80 @@
+require 'credentials'
+require 'test/unit'
+require 'atmos'
+
+
+class AtmosObjectMiscTest < Test::Unit::TestCase
+
+   def initialize(id)
+      super(id)
+      @cleanup = []
+   end
+
+   def setup
+      @s   = Atmos::Test::Util.static_store
+   end
+
+
+   def teardown
+      @cleanup.each do |obj|
+         obj.delete
+      end
+   end
+
+
+   def test_delete_existing_object
+   end
+  
+   def test_exists_on_existant_object
+      obj = @s.create()
+      @cleanup.push(obj)
+      assert(obj.exists?)
+   end
+   
+   def test_exists_on_non_existant_object
+      obj = @s.create()
+      obj.delete
+      assert(!obj.exists?)
+   end
+   
+   def test_delete_nonexisting_object
+      first = @s.create
+      assert_not_nil(first)
+      second = @s.get(:id => first.aoid)
+      assert_not_nil(second)
+      first.delete
+      assert_raise Atmos::Exceptions::NoSuchObjectException do 
+         second.delete
+      end 
+   end
+
+   def test_truncate_text_object
+      file = open(Atmos::Test::Util.small_text_filename)
+      contents = file.read
+      file.close
+      data = open(Atmos::Test::Util.small_text_filename)
+      obj = @s.create(:data => data)
+      @cleanup.push(obj)
+      assert_equal(contents, obj.data)
+      
+      obj.truncate
+      assert_equal("", obj.data)
+   end
+   
+   
+   def test_truncate_binary_object
+      file = open(Atmos::Test::Util.small_binary_filename)
+      contents = file.read
+      file.close
+      data = open(Atmos::Test::Util.small_binary_filename)
+      obj = @s.create(:data => data)
+      @cleanup.push(obj)
+
+#      assert_equal(contents, obj.data)
+      
+      obj.truncate
+      assert_equal("", obj.data)
+   end
+   
+   
+end

data/test/test_object_read.rb

@@ -0,0 +1,98 @@
+require 'credentials'
+require 'test/unit'
+require 'atmos'
+
+
+class AtmosObjectReadTest < Test::Unit::TestCase
+
+   def initialize(id)
+      super(id)
+      @cleanup = []
+   end
+
+   def setup    
+      @s   = Atmos::Test::Util.static_store
+      @md  = {'non' => 'listable', 'user' => 'metadata', 'a' => 'b'}
+      @lmd = {'x' => 'a', 'y' => 'b', 'z' => 'c'}
+      data = open(Atmos::Test::Util.small_binary_filename)
+      obj  = @s.create(:metadata => @md, 
+                       :listable_metadata => @lmd,
+                       :data => File.new(Atmos::Test::Util.small_binary_filename, "rb"))
+      @cleanup.push(obj)
+      @aoid = obj.aoid
+   end
+
+
+  def teardown
+    @cleanup.each do |obj|
+      obj.delete
+    end
+  end
+   
+   
+  def test_read_partial_data_as_stream
+      obj = @s.get(:id => @aoid)
+      
+      file = open(Atmos::Test::Util.small_binary_filename)
+      contents = file.read
+      assert_equal(contents, obj.data)
+
+      f = File.new(Atmos::Test::Util.small_binary_filename, "rb")
+      contents = f.read(61)
+      data = obj.data(0...60)
+ 
+      readin = ""
+      obj.data_as_stream(0...60) do |chunk|
+         readin.concat(chunk)
+      end
+      
+      assert_equal(61, readin.length)
+      assert_equal(contents.length, readin.length)
+      assert_equal(contents, readin)
+   end
+
+   def test_read_data_as_stream
+
+      file = open(Atmos::Test::Util.small_binary_filename)
+      contents = file.read
+      obj = @s.get(:id => @aoid)
+      obj.update(contents)
+      assert_equal(contents, obj.data)
+
+      readin = ""
+      obj.data_as_stream do |chunk|
+         readin.concat(chunk)
+      end
+      
+      assert_equal(contents, readin)
+   end
+
+   def test_read_partial_data_as_string
+      
+      file = open(Atmos::Test::Util.small_binary_filename)
+      contents = file.read
+      obj = @s.get(:id => @aoid)
+      obj.update(contents)
+      assert_equal(contents, obj.data)
+
+
+      f = File.new(Atmos::Test::Util.small_binary_filename, "rb")
+      contents = f.read(61)
+      data = obj.data(0...60)
+      len = data.length
+      assert_equal(61, obj.data(0...60).length)
+      assert_equal(contents, obj.data(0...60))
+   end
+
+   def test_read_data_as_string
+      file = open(Atmos::Test::Util.small_binary_filename)
+      contents = file.read
+      obj = @s.get(:id => @aoid)
+      obj.update(contents)
+      assert_equal(contents, obj.data)
+      
+      assert_equal(contents, obj.data)
+      assert(obj.data.length > 0)
+   end
+
+end

data/test/test_object_update.rb

@@ -0,0 +1,59 @@
+require 'credentials'
+require 'test/unit'
+require 'atmos'
+
+
+class AtmosObjectUpdateTest < Test::Unit::TestCase
+
+   def initialize(id)
+      super(id)
+      @cleanup = []
+   end
+
+   def setup
+      @s   = Atmos::Test::Util.static_store
+      @obj = @s.create
+      @cleanup.push(@obj)
+      #print "test_object_update.setup(): obj: #{@obj}; objid: #{@obj.aoid}\n"
+   end
+
+
+   def teardown
+      @cleanup.each do |obj|
+         obj.delete
+      end
+      $stdout.flush
+   end
+
+   def test_object_ok
+      assert_not_nil(@obj)
+      assert_equal({}, @obj.metadata)
+      assert_equal({}, @obj.listable_metadata)
+      assert_equal({Atmos::Test::Util.user => :full}, @obj.user_acl)
+      assert_equal({Atmos::Test::Util.group => :none}, @obj.group_acl)
+   end
+      
+   def test_update_empty_obj
+      data = "Hello World"
+      @obj.update(data)
+      assert_equal(data, @obj.data)      
+   end
+   
+ #  def test_append_non_empty_object
+ #     data = @obj.data
+ #     @obj.append("!")
+ #     assert_equal(data+"!", @obj.data)
+ #     print "appended hello world object with !: #{@obj.data}\n"
+ #  end
+   
+   def test_update_object_in_place
+      data = "Hello World!"
+      @obj.update(data)
+      assert_equal(data, @obj.data)
+      
+      range = 0..4
+      @obj.update("Mad  ", range)
+      assert_equal("Mad   World!", @obj.data)
+   end
+    
+end