ahoward-helene 0.0.3

data/test/auth.rb

@@ -0,0 +1,31 @@
+# TODO - needs to bootstrap from a test config file - for now rely on
+#
+# ENV['AWS_ACCESS_KEY_ID']
+# ENV['AWS_SECRET_ACCESS_KEY']
+#
+
+config = YAML.load((File.read(File.expand_path("~/.aws.yml")) rescue "{}"))
+
+if access_key_id = config["access_key_id"]
+  ENV['ACCESS_KEY_ID']            = access_key_id
+  ENV['AMAZON_ACCESS_KEY_ID']     = access_key_id
+  ACCESS_KEY_ID                   = access_key_id
+  AMAZON_ACCESS_KEY_ID            = access_key_id
+end
+
+if secret_access_key = config["secret_access_key"]
+  ENV['SECRET_ACCESS_KEY']        = secret_access_key
+  ENV['AMAZON_SECRET_ACCESS_KEY'] = secret_access_key
+  ACCESS_SECRET_KEY               = secret_access_key
+  AMAZON_SECRET_ACCESS_KEY        = secret_access_key
+end
+
+if ca_file = config["ca_file"]
+  ENV['CA_FILE']        = ca_file
+  ENV['AMAZON_CA_FILE'] = ca_file
+  CA_FILE               = ca_file
+  AMAZON_CA_FILE        = ca_file
+  
+  # It's too late to count on helene.rb to load this, so we need to do it:
+  Rightscale::HttpConnection.params[:ca_file] = ca_file
+end

data/test/helper.rb

@@ -0,0 +1,98 @@
+module Helene
+  module Test
+    module Models
+      def model(name, &block)
+        name = name.to_s
+        @models ||= {}
+        @models[name] ||= Class.new(Helene::Sdb::Base){ domain "helene-test-model-#{ name }" }
+        class_name = name.classify
+        ::Object.send(:remove_const, class_name) if ::Object.const_defined?(class_name)
+        ::Object.const_set(class_name, @models[name])
+        @models[name].module_eval(&block) if block
+        @models[name]
+      end
+
+      def models
+        ('a' .. 'e').map{|name| model(name)}
+      end
+
+      extend self
+    end
+
+    Helper = lambda do
+      def self.setup(&block)
+        define_method(:setup, &block)
+      end
+
+      alias_method '__assert__', 'assert'
+
+      def assert(*args, &block)
+        if block
+          label = 'assertion: ' + args.join(' ')
+          result = nil
+          assert_nothing_raised{ result = block.call }
+          __assert__(result, label)
+          result
+        else
+          __assert__(*args)
+          args.first
+        end
+      end
+
+      def eventually_assert(*args, &block)
+        options = args.extract_options!.to_options!
+        first = args.shift || caller.first(1)
+        label = "eventually_assert(#{ first.to_s.inspect })"
+
+        min = 0.01
+        max = 1.28
+        sleeps = []
+        m = min
+        while m < max; sleeps << m and m *= 2; end
+        
+        a = Time.now.to_f
+        42.times do |i|
+          bool =
+            begin
+              block.call
+            rescue => e
+              m, c, b = e.message, e.class, (e.backtrace||{}).join("\n")
+              STDERR.puts "\n#{ m }(#{ c })\n#{ b }"
+              false
+            end
+          if bool
+            args = [bool, label]
+            assert(*args)
+            return true
+          end
+          STDERR.puts "\n#{ label.to_s } (not true yet...)"
+          sleep(sleeps[ i % sleeps.size ])
+        end
+        b = Time.now.to_f
+        elapsed = b - a
+        STDERR.puts "\n#{ label.to_s } (never became true in #{ elapsed } seconds!)"
+        assert(false, label)
+      end
+
+      def subclass_of exception
+        class << exception
+          def ==(other) super or self > other end
+        end
+        exception
+      end
+
+      include Models
+    end
+  end
+end
+
+module Kernel
+private
+  def testing(*args, &block)
+    Class.new(::Test::Unit::TestCase) do
+      module_eval &Helene::Test::Helper
+      module_eval(&block)
+    end
+  end
+end
+

data/test/integration/ensure.rb

@@ -0,0 +1,8 @@
+
+testing 'ensure' do
+  should 'clean out all test models' do
+    models.threadify do |model|
+      assert_nothing_raised{ model.all.threadify{|record| record.delete} }
+    end
+  end
+end

data/test/integration/s3/bucket.rb

@@ -0,0 +1,106 @@
+testing Bucket = Helene::S3::Bucket do
+
+
+  context 'with a bucket created' do
+    setup do
+      create_bucket
+    end
+
+    context 'at the class level' do
+      should 'be able to delete a bucket' do
+        delete_bucket
+      end
+
+      should 'be able to list buckets' do
+        list = assert{ Bucket.list }
+        assert{ list.is_a?(Array) }
+        assert{ list.include?(bucket) }
+      end
+
+      should 'be able to instantiate a bucket by name' do
+        assert{ Bucket.new bucket.name }
+      end
+
+      should 'be able to generate a link to view all buckets' do
+        url = assert{ Bucket.url }
+        assert{ curl(url) =~ /ListAllMyBucketsResult/ }
+      end
+
+      should 'be able to generate a link to create a bucket' do
+        create_bucket_by_url
+      end
+
+      should 'be able to generate a link to delete a bucket' do
+        delete_bucket_by_url
+      end
+    end
+
+    context 'at the instance level' do
+      setup do
+        @pathname = File.expand_path(__FILE__)
+        @basename = File.basename(@pathname)
+        @data = IO.read(@pathname)
+      end
+
+      should 'be able to put a pathname' do
+        key = assert{ bucket.put(@pathname) }
+        assert{ curl(key.url) == @data }
+      end
+
+      should "be able to put an io - returning an object that knows it's url" do
+        key = assert{ open(@pathname){|io| bucket.put(io)} }
+        assert{ curl(key.url) == @data }
+      end
+
+      should "be able to put/get a path" do
+        key = assert{ bucket.put(@pathname) }
+        data = assert{ bucket.get(key.name) }
+        assert{ data == @data }
+      end
+    end
+  end
+
+
+
+
+  def bucket_name(options = {})
+    "helene-s3-bucket-test-#{ Helene.uuid }"
+  end
+
+  def create_bucket(options = {})
+    @bucket ||= assert{ Bucket.create(bucket_name, options) }
+    # at_exit{ @bucket.delete(:force => true) rescue nil if @bucket unless $! }
+    at_exit{ Bucket.delete(@bucket, :force => true) rescue nil if @bucket }
+  end
+
+  def create_bucket_by_url
+    name = bucket_name
+    url ||= assert{ Bucket.url(:create, name) }
+    assert{ curl(url, :PUT) }
+    assert{ @bucket_url = Bucket.new(name) }
+  end
+
+  def delete_bucket_by_url
+    create_bucket_by_url unless @bucket_url
+    name = @bucket_url.name
+    url ||= assert{ Bucket.url(:delete, name) }
+    assert{ curl(url, :DELETE) }
+    assert_raises(subclass_of(Exception)){ Bucket.new(name) }
+  end
+
+  def bucket
+    @bucket
+  end
+
+  def delete_bucket(options = {})
+    create_bucket unless @bucket
+    assert{ Bucket.delete(@bucket, options) }
+    @bucket = nil
+  end
+
+  def curl(url, options = {})
+    options = {:method => options} unless options.is_a?(Hash)
+    method = options[:method] || :GET
+    `curl --silent --insecure --location --request #{ method.to_s } #{ url.inspect } 2>/dev/null`
+  end
+end

data/test/integration/sdb/associations.rb

@@ -0,0 +1,45 @@
+testing Helene::Sdb::Base do
+
+  context 'associations' do
+    context 'has_many' do
+      setup do
+        @a = model(:a) do
+          has_many :bs
+        end
+        @b = model(:b) do
+          attribute :a_id
+        end
+      end
+
+      should 'support simple has_many' do
+        a = assert{ @a.create! }
+        assert{ a.respond_to?(:bs) }
+        b = assert{ @b.create! }
+        assert{ b.respond_to?(:a_id) }
+        assert{ a.bs << b }
+        assert{ b.a_id == a.id }
+      end
+    end
+
+    context 'has_one' do
+      setup do
+        @a = model(:a) do
+          has_one :b
+        end
+        @b = model(:b) do
+          attribute :a_id
+        end
+      end
+
+      should 'support simple has_one' do
+        a = assert{ @a.create! }
+        assert{ a.respond_to?(:b) }
+        b = assert{ @b.create! }
+        assert{ b.respond_to?(:a_id) }
+        assert{ a.b = b }
+        assert{ b.a_id == a.id }
+      end
+    end
+  end
+
+end

data/test/integration/sdb/creating.rb

@@ -0,0 +1,13 @@
+testing Helene::Sdb::Base do
+
+  context 'creating' do
+    setup do
+      @a = model(:a){}
+    end
+
+    should 'be able to create' do
+      assert{ @a.create! }
+    end
+  end
+
+end

data/test/integration/sdb/emptiness.rb

@@ -0,0 +1,56 @@
+testing Helene::Sdb::Base do
+
+  context 'emptiness' do
+    setup do
+      @a = model(:a) do
+        attribute :x, :string
+        attribute :y, :set_of_string
+      end
+    end
+
+    perform = 'represent nil'
+    should perform do
+      a = assert{ @a.create! :x => nil }
+      assert{ a.x.nil? }
+      eventually_assert(perform){ a.reload; a.x.nil? }
+    end
+
+    perform = 'represent the empty list'
+    should perform do
+      a = assert{ @a.create! :y => [] }
+      assert{ a.y==[] }
+      eventually_assert(perform){ a.reload; a.y==[] }
+    end
+
+    perform = 'represent a list of just nil'
+    should perform do
+      a = assert{ @a.create! :y => [nil] }
+      assert{ a.y==[nil] }
+      eventually_assert(perform){ a.reload; a.y==[nil] }
+    end
+
+    perform = 'represent the empty string'
+    should perform do
+      a = assert{ @a.create! :x => '' }
+      assert{ a.x=='' }
+      eventually_assert(perform){ a.reload; a.x=='' }
+    end
+
+    perform = 'represent a list of just the empty string'
+    should perform do
+      a = assert{ @a.create! :y => [''] }
+      assert{ a.y==[''] }
+      eventually_assert(perform){ a.reload; a.y==[''] }
+    end
+
+=begin
+    perform = 'represent a list nil and the empty string'
+    should perform do
+      a = assert{ @a.create! :y => [nil, ''] }
+      assert{ a.y==[nil, ''] }
+      eventually_assert(perform){ a.reload; a.y==[nil, ''] }
+    end
+=end
+  end
+
+end

data/test/integration/sdb/hooks.rb

@@ -0,0 +1,19 @@
+testing Helene::Sdb::Base do
+
+  context 'hooks' do
+    setup do
+      @a = model(:a) do
+        attribute :x, :string
+        before_save{ update :x => '42' }
+      end
+    end
+
+    perform = 'before_save'
+    should perform do
+      a = assert{ @a.create! }
+      assert{ a.x=='42' }
+      eventually_assert(perform){ a.reload; a.x=='42' }
+    end
+  end
+
+end

data/test/integration/sdb/limits.rb

@@ -0,0 +1,27 @@
+testing Helene::Sdb::Base do
+
+  context 'limit > 2500' do
+    setup do
+      @a = model(:a)
+    end
+
+    perform = 'get all the results'
+    should perform do
+      n = 2501
+      assert_nothing_raised do
+        # if @a.count < n
+          records = Array.new(n){ @a.new }
+          a = Time.now.to_f
+          @a.batch_put records
+          b = Time.now.to_f
+          #puts(b - a)
+        # end
+      end
+      eventually_assert(perform) do
+        result = @a.find(:all, :limit => n)
+        assert result.size == n
+      end
+    end
+  end
+
+end

data/test/integration/sdb/saving.rb

@@ -0,0 +1,21 @@
+testing Helene::Sdb::Base do
+
+  context 'saving' do
+    setup do
+      @a = model(:a)
+      @b = model(:b) do
+        attribute :foo, :null => false
+      end
+    end
+
+    should 'be able to save a valid object' do
+      assert{ @a.new.save }
+      assert{ @b.new(:foo=>'foo').save }
+    end
+
+    should 'not be able to save an invalid object' do
+      assert{ @b.new(:foo=>nil).save == false }
+    end
+  end
+
+end

data/test/integration/sdb/selecting.rb

@@ -0,0 +1,39 @@
+testing Helene::Sdb::Base do
+
+  context 'selecting' do
+    setup do
+      @a = model(:a)
+      @b = model(:b)
+      @c = model(:c)
+    end
+
+    perform = 'be able to find by id'
+    should perform do
+      a = assert{ @a.create! }
+      eventually_assert(perform) do
+        found = @a.find(a.id)
+        found and found.id == a.id
+      end
+    end
+
+    perform = 'be able to find by many ids'
+    should perform do
+      a = assert{ @a.create! }
+      eventually_assert(perform) do
+        list = @a.find([a.id, a.id])
+        list.all?{|found| found.id==a.id}
+      end
+    end
+
+    perform = 'be able to find by > 20 ids'
+    should perform do
+      a = assert{ @a.create! }
+      ids = Array.new(42){ a.id }
+      eventually_assert(perform) do
+        list = assert{ @a.find(ids) }
+        list and list.all?{|found| found.id == a.id}
+      end
+    end
+  end
+
+end