ruby-atmos 0.6.0

data/test/test_object_create.rb

@@ -0,0 +1,152 @@
+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
+      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_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_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(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,114 @@
+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
+    @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
+      # something is very strange here
+      # the object shouldn't end up empty, but it does
+      # it doesn't end up empty when this file is run
+      # as a standalone test
+      file = open(Atmos::Test::Util.small_binary_filename)
+      contents = file.read
+      obj = @s.get(@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)
+ 
+      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
+
+      # something is very strange here
+      # the object shouldn't end up empty, but it does
+      # it doesn't end up empty when this file is run
+      # as a standalone test
+      file = open(Atmos::Test::Util.small_binary_filename)
+      contents = file.read
+      obj = @s.get(@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
+      
+      # something is very strange here
+      # the object shouldn't end up empty, but it does
+      # it doesn't end up empty when this file is run
+      # as a standalone test
+      file = open(Atmos::Test::Util.small_binary_filename)
+      contents = file.read
+      obj = @s.get(@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
+      # something is very strange here
+      # the object shouldn't end up empty, but it does
+      # it doesn't end up empty when this file is run
+      # as a standalone test
+      file = open(Atmos::Test::Util.small_binary_filename)
+      contents = file.read
+      obj = @s.get(@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,58 @@
+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
+      @obj = @s.create
+      @cleanup.push(@obj)
+   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

data/test/test_store.rb

@@ -0,0 +1,125 @@
+require 'test/unit'
+require 'credentials'
+require 'atmos'
+
+
+class AtmosStoreConstructorTest < Test::Unit::TestCase
+
+  def initialize( id )
+    super(id)
+  end
+
+  def setup
+  end
+
+
+  def teardown
+  end
+
+
+  def test_connect_without_parser
+     assert_raise Atmos::Exceptions::ArgumentException do
+        Atmos::Store.new(:uri    => Atmos::Test::Util.url,
+                         :uid    => Atmos::Test::Util.user,
+                         :secret => Atmos::Test::Util.secret)
+                      end
+  end
+  
+  def test_connect_with_parser
+     Atmos::Parser::parser = Atmos::Parser::NOKOGIRI
+    s = Atmos::Store.new(:url    => Atmos::Test::Util.url,
+                         :uid    => Atmos::Test::Util.uid,
+                         :secret => Atmos::Test::Util.secret)
+    assert_not_nil(s)
+  end
+  
+  def test_redirect
+     Atmos::Parser::parser = Atmos::Parser::NOKOGIRI
+     if (!Atmos::Test::Util.redirect_url.nil?)
+        assert_raise Atmos::Exceptions::NotImplementedException do
+           Atmos::Store.new(:url    => Atmos::Test::Util.redirect_url,
+                            :uid    => Atmos::Test::Util.uid,
+                            :secret => Atmos::Test::Util.secret)
+        end
+     end
+  end
+
+  def test_bad_option
+     Atmos::Parser::parser = Atmos::Parser::NOKOGIRI
+     assert_raise Atmos::Exceptions::ArgumentException do
+        Atmos::Store.new(:uri    => Atmos::Test::Util.url,
+                         :uid    => Atmos::Test::Util.user,
+                         :secret => Atmos::Test::Util.secret,
+                         :foo    => true)
+     end
+  end
+
+  def test_connect_to_bad_server_version
+  end
+  
+end
+
+
+class AtmosStoreTest < 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_get_atmos_version
+      rv = @s.server_version
+      assert_not_nil(rv)
+      assert_equal(String, rv.class)
+      assert_equal(Atmos::Test::Util.version, rv) if (!Atmos::Test::Util.version.nil?)
+   end
+  
+ 
+   def dont_test_iterate_through_listable_tags
+      i = 0;
+      ctag = "ruby-atmos-curseword#{$$}"
+      obj = @s.create(:listable_metadata => {ctag => true})
+      @cleanup.push(obj)
+      
+      @s.each_listable_tag do |tag|
+         i += 1
+      end
+      
+      assert(i > 0)
+  end
+  
+  
+   def test_iterate_through_listable_tags_with_token
+   end
+  
+  
+  
+   def test_iterate_through_objects_with_tag
+      srand()
+      tag = "ruby-atmos-curseword-#{rand()}"
+      
+      for i in (1...10)
+         obj = @s.create(:listable_metadata => {tag => true})
+      end
+      
+      i = 0
+      @s.each_object_with_listable_tag(tag) do |obj|
+         @cleanup.push(obj)
+         i += 1
+      end
+      assert_equal(9, i)
+  end
+  
+end