authorize 0.0.1

data/test/test/unit/redis_array_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+class RedisArrayTest < ActiveSupport::TestCase
+  def setup
+    Authorize::Redis::Array.index.clear
+    @factory = Authorize::Redis::Factory.new
+  end
+
+  test 'push element' do
+    aid, element = 'array_id', 'element'
+    Authorize::Redis::Array.db.expects(:rpush).with(aid, element)
+    s = Authorize::Redis::Array.load(aid)
+    s.push(element)
+  end
+
+  test 'delete element' do
+    aid, element = 'array_id', 'element'
+    Authorize::Redis::Array.db.expects(:rpop).with(aid)
+    s = Authorize::Redis::Array.load(aid)
+    s.pop
+  end
+
+  test 'index' do
+    a = @factory.array('test', %w(ant bear cat))
+    assert_equal "cat", a[2]
+  end
+
+  test 'range index' do
+    a = @factory.array('test', %w(ant bear cat))
+    assert_equal %w(bear cat), a[1..2]
+  end
+
+  test 'to_a' do
+    a = @factory.array('test', %w(ant bear cat))
+    assert_equal %w(ant bear cat), a.to_a
+  end
+
+  test 'load proxy from store' do
+    aid, element = 'array_id', 'element'
+    Authorize::Redis::Array.db.expects(:lrange).with(aid, 0, -1).returns([element])
+    s = Authorize::Redis::Array.load(aid)
+    assert_equal 1, s.length
+  end
+
+  test 'enumerable' do
+    s = Authorize::Redis::Array.new
+    s.push(23);s.push(27)
+    assert_equal "2327", s.inject{|m, e| m + e}
+  end
+
+  test 'valid' do
+    a = @factory.array('a', ['a'])
+    assert a.valid?
+  end
+
+  test 'valid when empty' do
+    a = Authorize::Redis::Array.new
+    assert a.valid?
+  end
+end

data/test/test/unit/redis_connection_manager_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class RedisConnectionManagerTest < ActiveSupport::TestCase
+  extend Authorize::Redis
+
+  def setup
+    @connection = stub('connection')
+    @specification = stub('specification')
+  end
+
+  test 'acquire_connection connects' do
+    manager = Authorize::Redis::ConnectionManager.new(@specification, :size => 1)
+    @specification.expects(:connect! => @connection)
+    assert_same @connection, manager.acquire_connection
+  end
+
+  test 'acquire_connection is idempotent for a given thread' do
+    manager = Authorize::Redis::ConnectionManager.new(@specification, :size => 1)
+    @specification.expects(:connect!).once.returns(@connection)
+    c0 = manager.acquire_connection
+    c1 = manager.acquire_connection
+    assert_same c0, c1
+  end
+
+  test 'acquire connection blocks when full' do
+    begin
+      manager = Authorize::Redis::ConnectionManager.new(@specification, :size => 1)
+      @specification.expects(:connect! => @connection)
+      c = manager.acquire_connection
+      t = Thread.new(manager) {|m| m.acquire_connection}
+      t.run
+      assert_equal 'sleep', t.status
+      manager.release_connection
+      t.run
+      assert_equal false, t.status # Thread has run to completion.
+    ensure
+      t.exit
+    end
+  end
+
+  test 'release connection' do
+    manager = Authorize::Redis::ConnectionManager.new(@specification, :size => 1)
+    @specification.expects(:connect! => @connection)
+    c = manager.acquire_connection
+    manager.release_connection
+    assert manager.pool.include?(c)
+  end
+
+  test 'connection is unique per thread' do
+    manager = Authorize::Redis::ConnectionManager.new(@specification)
+    @specification.expects(:connect!).once.returns(@connection)
+    2.times { manager.connection }
+  end
+end

data/test/test/unit/redis_factory_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+require 'authorize/redis/factory'
+require 'set'
+
+class RedisFactoryTest < ActiveSupport::TestCase
+  test 'string factory' do
+    key, value = 'key', 'value'
+    Authorize::Redis::Base.db.expects(:set).with(key, value)
+    obj = Authorize::Redis::Factory.new.string(key, value)
+    assert_kind_of Authorize::Redis::String, obj
+    assert_equal key, obj.id
+  end
+
+  test 'set factory' do
+    key, value = 'key', Set['value0', 'value1']
+    elements = value.to_a
+    Authorize::Redis::Base.db.expects(:sadd).with(key, elements.first)
+    Authorize::Redis::Base.db.expects(:sadd).with(key, elements.last)
+    obj = Authorize::Redis::Factory.new.set(key, value)
+    assert_kind_of Authorize::Redis::Set, obj
+    assert_equal key, obj.id
+  end
+
+  test 'hash factory' do
+    key, value = 'key', {'key0' => 'value0', 'key1' => 'value1'}
+    keys = value.keys
+    Authorize::Redis::Base.db.expects(:hset).with(key, keys.first, value[keys.first])
+    Authorize::Redis::Base.db.expects(:hset).with(key, keys.last, value[keys.last])
+    obj = Authorize::Redis::Factory.new.hash(key, value)
+    assert_kind_of Authorize::Redis::Hash, obj
+    assert_equal key, obj.id
+  end
+
+  test 'array factory' do
+    key, value = 'key', ['value0', 'value1']
+    Authorize::Redis::Base.db.expects(:rpush).with(key, value.first).in_sequence
+    Authorize::Redis::Base.db.expects(:rpush).with(key, value.last).in_sequence
+    obj = Authorize::Redis::Factory.new.array(key, value)
+    assert_kind_of Authorize::Redis::Array, obj
+    assert_equal key, obj.id
+  end
+
+  test 'build with block' do
+    namespace, key, value = :namespace, 'key', 'value'
+    Authorize::Redis::Base.db.expects(:set).with([namespace, key].join('::'), value)
+    Authorize::Redis::Factory.build(namespace){string(key, value)}
+  end
+
+  test 'factory with nested namespace' do
+    outer_namespace, inner_namespace, key, value = :outer_namespace, :inner_namespace, 'key', {'key0' => 'value0', 'key1' => 'value1'}
+    keys = value.keys
+    fullkey = [outer_namespace, inner_namespace, key].join('::')
+    Authorize::Redis::Base.db.expects(:hset).with(fullkey, keys.first, value[keys.first])
+    Authorize::Redis::Base.db.expects(:hset).with(fullkey, keys.last, value[keys.last])
+    Authorize::Redis::Factory.build(outer_namespace){namespace(inner_namespace){hash(key, value)}}
+  end
+
+  test 'factory with colliding key and namespace' do
+    namespace, ckey, key, value1, value2 = :namespace, 'kns', 'key', 'value1', Set['member0', 'member1']
+    elements = value2.to_a
+    Authorize::Redis::Base.db.expects(:set).with([namespace, ckey].join('::'), value1)
+    Authorize::Redis::Base.db.expects(:sadd).with([namespace, ckey, key].join('::'), elements.first)
+    Authorize::Redis::Base.db.expects(:sadd).with([namespace, ckey, key].join('::'), elements.last)
+    Authorize::Redis::Factory.build(namespace){string(ckey, value1){set(key, value2)}}
+  end
+
+  test 'factory restores namespace after block' do
+    ns, key1, value1, key2, value2 = 'namespace', 'key1', 'value1', 'key2', 'value2'
+    Authorize::Redis::Base.db.expects(:set).with([ns, key1].join('::'), value1)
+    Authorize::Redis::Base.db.expects(:set).with(key2, value2)
+    f = Authorize::Redis::Factory.build
+    f.namespace(ns){string(key1, value1)}
+    f.string(key2, value2)
+  end
+
+  test 'returned object has namespaced id' do
+    namespace, key, value = :namespace, 'key', 'value'
+    fqk = [namespace, key].join('::')
+    Authorize::Redis::Base.db.expects(:set).with(fqk, value)
+    f = Authorize::Redis::Factory.build(namespace)
+    obj = f.string(key, value)
+    assert_kind_of Authorize::Redis::String, obj
+    assert_equal fqk, obj.id
+  end
+end

data/test/test/unit/redis_fixture_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+require 'authorize/redis/fixtures'
+require 'set'
+
+class RedisFixtureTest < ActiveSupport::TestCase
+  def setup
+    Authorize::Redis::String.index.clear # Clear the cache
+    Authorize::Redis::Set.index.clear
+    Authorize::Redis::Hash.index.clear
+  end
+
+  test 'fixtures' do
+    Authorize::Redis::Fixtures.create_fixtures(Authorize::Redis::Base.db, Pathname.new(fixture_path).join('redis', 'redis.yml'))
+    assert_equal 'x', Authorize::Redis::String.new('string').__getobj__
+    assert_equal %w(1 2).to_set, Authorize::Redis::Set.new("set").__getobj__
+    assert_equal({"a" => "1", "b" => "2"}, Authorize::Redis::Hash.new("hash").__getobj__)
+  end
+end

data/test/test/unit/redis_hash_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+require 'authorize/redis/factory'
+
+class RedisHashTest < ActiveSupport::TestCase
+  def setup
+    Authorize::Redis::Hash.index.clear
+    @factory = Authorize::Redis::Factory.new
+  end
+
+  test 'hash keys are stringified' do
+    h = Authorize::Redis::Hash.new
+    h.set("", 'empty')
+    h.set(nil, 'nil')
+    assert_equal 'nil', h.get(nil)
+  end
+
+  test 'merge' do
+    h = @factory.hash('h', {'key' => 'a'})
+    h.merge('key' => 'A')
+    assert_equal 'A', h['key']
+  end
+
+  test 'merge with empty hash' do
+    h = @factory.hash('h', {'key' => 'a'})
+    h.merge({})
+    assert_equal 'a', h['key']
+  end
+
+  test 'index getter' do
+    h = @factory.hash('h', {'key' => 'a'})
+    assert_equal h['key'], 'a'
+  end
+
+  test 'valid' do
+    h = @factory.hash('h', {'key' => 'a'})
+    assert h.valid?
+  end
+
+  test 'valid when empty' do
+    h = Authorize::Redis::Hash.new
+    assert h.valid?
+  end
+end

data/test/test/unit/redis_model_reference_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+require 'authorize/redis/model_reference'
+
+class RedisModelReferenceTest < ActiveSupport::TestCase
+  include Authorize::Redis
+
+  def setup
+    Authorize::Redis::String.index.clear # Clear the cache
+    Authorize::Redis::Set.index.clear
+    Authorize::Redis::Hash.index.clear
+    Authorize::Redis::Factory.build('X') do
+      string('reference1', subordinate_key('target'))
+      hash('target', {'key' => 'value'})
+      string('reference2', subordinate_key('missingtarget'))
+    end
+  end
+
+  test 'set reference' do
+    key = 'X::reference0'
+    h = Authorize::Redis::Hash.load('X::target')
+    Authorize::Redis::String.db.expects(:set).with(key, h.id).returns(h.id)
+    assert ModelReference.set_reference(key, h)
+  end
+
+  test 'set reference with nil' do
+    key = 'X::reference0'
+    h = Authorize::Redis::Hash.load('X::target')
+    Authorize::Redis::String.db.expects(:del).with(key).returns('0')
+    assert_nil ModelReference.set_reference(key, nil)
+  end
+
+  test 'load reference' do
+    assert_kind_of Authorize::Redis::Hash, ModelReference.load_reference('X::reference1', Authorize::Redis::Hash)
+  end
+
+  test 'load reference with invalid reference' do
+    assert_nil ModelReference.load_reference('X::missing_reference', Authorize::Redis::Hash)
+  end
+end

data/test/test/unit/redis_set_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+class RedisSetTest < ActiveSupport::TestCase
+  def setup
+    Authorize::Redis::String.index.clear # Clear the cache
+    Authorize::Redis::Set.index.clear
+    Authorize::Redis::Hash.index.clear
+    @factory = Authorize::Redis::Factory.new
+  end
+
+  test 'add member' do
+    sid, member = 'set_id', 'member'
+    Authorize::Redis::Set.db.expects(:sadd).with(sid, member)
+    s = Authorize::Redis::Set.load(sid)
+    s.add(member)
+  end
+
+  test 'delete member' do
+    sid, member = 'set_id', 'member'
+    Authorize::Redis::Set.db.expects(:srem).with(sid, member)
+    s = Authorize::Redis::Set.load(sid)
+    s.delete(member)
+  end
+
+  test 'load proxy from store' do
+    sid, member = 'set_id', 'member'
+    Authorize::Redis::Set.db.expects(:smembers).with(sid).returns([member])
+    s = Authorize::Redis::Set.load(sid)
+    assert_equal 1, s.length
+  end
+
+  test 'enumerable' do
+    s = Authorize::Redis::Set.new
+    s.add(23);s.add(27)
+    assert_equal "2327", s.inject{|m, e| m + e}
+  end
+
+  test 'valid' do
+    s = @factory.set('h', Set['a'])
+    assert s.valid?
+  end
+
+  test 'valid when empty' do
+    s = Authorize::Redis::Set.new
+    assert s.valid?
+  end
+
+  test 'include' do
+    s = @factory.set('h', Set['a'])
+    assert s.include?('a')
+  end
+
+  test 'sample single' do
+    s = @factory.set('h', Set['a', 'b'])
+    assert s.sample
+  end
+
+  test 'sample multiple' do
+    # depends on Ruby 1.9
+#    s = @factory.set('h', Set['a', 'b'])
+#    assert_equal Set['a', 'b'], s.sample(3)
+  end
+
+  test 'first multiple' do
+    s = @factory.set('h', Set['a', 'b'])
+    assert_equal ['a', 'b'].to_set, s.first(3).to_set
+  end
+end

data/test/test/unit/redis_string_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'authorize/redis/factory'
+
+class RedisStringTest < ActiveSupport::TestCase
+  def setup
+    Authorize::Redis::String.index.clear
+    @factory = Authorize::Redis::Factory.new
+  end
+
+  test 'valid' do
+    s = @factory.string('key', 'value')
+    assert s.valid?
+  end
+
+  test 'valid when empty' do
+    s = Authorize::Redis::String.new
+    assert s.valid?
+  end
+
+  test 'invalid when key references wrong type' do
+    @factory.hash('h', {'key' => 'value'})
+    s = Authorize::Redis::String.new('h')
+    assert !s.valid?
+  end
+end

data/test/test/unit/redis_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+class RedisTest < ActiveSupport::TestCase
+  def setup
+    Authorize::Redis::Base.index.clear # Clear the cache
+    Authorize::Redis::String.index.clear # Clear the cache
+  end
+
+  test 'identity' do
+    assert o0 = Authorize::Redis::Base.new('A')
+    assert o1 = Authorize::Redis::Base.new('B')
+    assert_not_same o0, o1
+  end
+
+  test 'equality by class and id' do
+    assert o0 = Authorize::Redis::Base.new('A')
+    assert o1 = Authorize::Redis::Base.new('A')
+    assert_equal o0, o1
+  end
+
+  test 'inequality by id' do
+    o0 = Authorize::Redis::Base.new('A')
+    o1 = Authorize::Redis::Base.new('B')
+    assert_not_equal o0, o1
+  end
+
+  test 'inequality by class' do
+    c0 = Class.new(Authorize::Redis::Base)
+    c1 = Class.new(Authorize::Redis::Base)
+    o0 = c0.new('A')
+    o1 = c1.new('B')
+    assert_not_equal o0, o1
+  end
+
+  # This test ensures that different object instances mapping to the same database value(s) are
+  # considered identical in the context of membership within a collection (Hash, Set, Array, etc.).
+  test 'hash equality' do
+    assert o0 = Authorize::Redis::Base.new('A')
+    assert o1 = Authorize::Redis::Base.new('A')
+    assert o0.eql?(o1)
+    assert_equal o0.hash, o1.hash
+  end
+
+  test 'initialize semantics' do
+    Authorize::Redis::Base.any_instance.expects(:initialize).once
+    Authorize::Redis::Base.any_instance.expects(:reload).never
+    Authorize::Redis::Base.new('x') # Even with an existing key...
+  end
+
+  test 'reload semantics' do
+    Authorize::Redis::Base.any_instance.expects(:reload)
+    Authorize::Redis::Base.any_instance.expects(:initialize).never
+    assert val1 = Authorize::Redis::Base.load('new_key') # Even with a new key
+  end
+
+  # Can Redis objects be serialized according to conventional Marshal contracts?
+  test 'serializability with Marshal' do
+    v0 = Authorize::Redis::String.new
+    v0.set("Hi Mom")
+    assert_instance_of String, s = Marshal.dump(v0)
+    assert_instance_of Authorize::Redis::String, v1 = Marshal.load(s)
+    assert_equal v0, v1
+  end
+
+  # Can Redis objects be serialized according to conventional YAML contracts?
+  test 'serializability with YAML' do
+    v0 = Authorize::Redis::String.new
+    v0.set("Hi Mom")
+    assert_instance_of String, s = YAML.dump(v0)
+    assert_instance_of Authorize::Redis::String, v1 = YAML.load(s)
+    assert_equal v0, v1
+  end
+
+  # Can Redis objects be serialized according to conventional YAML contracts?
+  test 'serializability with YAML as set' do
+    v0 = Authorize::Graph::Vertex.new
+    set0 = Set[v0]
+    assert_instance_of String, s = YAML.dump(set0)
+    assert_instance_of Set, set1 = YAML.load(s)
+    assert_instance_of Authorize::Graph::Vertex, v1 = set1.first
+    assert_equal v0, v1
+  end
+
+  # Do serialized and re-hyrdrated Redis objects honor the strict identity contract?
+  test 'serialization' do
+    v0 = Authorize::Redis::String.new
+    v0.set("Hi Mom")
+    v1 = Marshal.load(Marshal.dump(v0))
+    assert v0.eql?(v1)
+    assert_equal v0, v1
+  end
+
+  test 'exist' do
+    assert !Authorize::Redis::String.exists?('newkey')
+    Authorize::Redis::String.new("newkey").set(1)
+    assert Authorize::Redis::String.exists?('newkey')
+  end
+
+  test 'destroy' do
+    obj = Authorize::Redis::String.new
+    obj.set("Hi Mom")
+    obj.destroy
+    assert obj.frozen?
+    assert !Authorize::Redis::String.index.include?(obj.id)
+  end
+
+# --String-------------------------------------------------------------------
+  test 'proxy to native String' do
+    v = Authorize::Redis::String.new
+    v.set(23)
+    assert_equal "232", v + "2"
+  end
+
+  test 'proxy is frozen' do
+    v = Authorize::Redis::String.new
+    v.set("ABC")
+    assert_raises TypeError do
+      v << "DEF"
+    end
+  end
+end