metry 1.2.0 → 2.0.0

data/vendor/rufus-tokyo/spec/tyrant_spec.rb

@@ -1,309 +0,0 @@
-
-#
-# Specifying rufus-tokyo
-#
-# Sun Feb  8 13:13:41 JST 2009
-#
-
-require File.dirname(__FILE__) + '/spec_base'
-
-require 'rufus/tokyo/tyrant'
-
-
-describe 'a missing Tokyo Rufus::Tokyo::Tyrant' do
-
-  it 'should raise an error' do
-
-    should.raise(RuntimeError) {
-      Rufus::Tokyo::Tyrant.new('tyrant.example.com', 45000)
-    }
-  end
-end
-
-describe 'a Tokyo Rufus::Tokyo::Tyrant' do
-
-  it 'should open and close' do
-
-    should.not.raise {
-      t = Rufus::Tokyo::Tyrant.new('127.0.0.1', 45000)
-      t.close
-    }
-  end
-
-  it 'should refuse to connect to a TyrantTable' do
-
-    lambda {
-      t = Rufus::Tokyo::Tyrant.new('127.0.0.1', 45001)
-    }.should.raise(ArgumentError)
-  end
-end
-
-describe 'a Tokyo Rufus::Tokyo::Tyrant' do
-
-  before do
-    @db = Rufus::Tokyo::Tyrant.new('127.0.0.1', 45000)
-    @db.clear
-  end
-  after do
-    @db.close
-  end
-
-  it 'should respond to stat' do
-
-    stat = @db.stat
-    stat['type'].should.equal('hash')
-  end
-
-  it 'should get put value' do
-
-    @db['alpha'] = 'bravo'
-    @db['alpha'].should.equal('bravo')
-  end
-
-  it 'should count entries' do
-
-    @db.size.should.equal(0)
-    3.times { |i| @db[i.to_s] = i.to_s }
-    @db.size.should.equal(3)
-  end
-
-  it 'should delete entries' do
-
-    @db['alpha'] = 'bravo'
-    @db.delete('alpha').should.equal('bravo')
-    @db.size.should.equal(0)
-  end
-
-  it 'should iterate entries' do
-
-    3.times { |i| @db[i.to_s] = i.to_s }
-    @db.values.should.equal(%w{ 0 1 2 })
-  end
-
-  it 'should accept and restitute \0 strings' do
-    s = "toto#{0.chr}nada"
-    @db[s] = s
-    @db[s].should.equal(s)
-  end
-
-  it 'should reply to #keys when there are keys containing \0' do
-
-    s = "toto#{0.chr}nada"
-    @db[s] = s
-    @db.keys.should.equal([ s ])
-  end
-
-  it 'should not respond to defrag' do
-
-    lambda() { @db.defrag }.should.raise(NoMethodError)
-  end
-end
-
-
-describe 'Rufus::Tokyo::Tyrant #keys' do
-
-  before do
-    @n = 50
-    @db = Rufus::Tokyo::Tyrant.new('127.0.0.1', 45000)
-    @db.clear
-    @n.times { |i| @db["person#{i}"] = 'whoever' }
-    @n.times { |i| @db["animal#{i}"] = 'whichever' }
-    @db["toto#{0.chr}5"] = 'toto'
-  end
-
-  after do
-    @db.close
-  end
-
-  it 'should return a Ruby Array by default' do
-
-    @db.keys.class.should.equal(::Array)
-  end
-
-  it 'should return a Cabinet List when :native => true' do
-
-    l = @db.keys(:native => true)
-    l.class.should.equal(Rufus::Tokyo::List)
-    l.size.should.equal(2 * @n + 1)
-    l.free
-  end
-
-  it 'should retrieve forward matching keys when :prefix => "prefix-"' do
-
-    @db.keys(:prefix => 'person').size.should.equal(@n)
-
-    l = @db.keys(:prefix => 'animal', :native => true)
-    l.size.should.equal(@n)
-    l.free
-  end
-
-  it 'should retrieve keys that contain \0' do
-
-    @db.keys.include?("toto#{0.chr}5").should.be.true
-  end
-
-  it 'should retrieve forward matching keys when key contains \0' do
-
-    @db.keys(:prefix => 'toto').should.equal([ "toto#{0.chr}5" ])
-  end
-
-  it 'should return a limited number of keys when :limit is set' do
-
-    @db.keys(:limit => 20).size.should.equal(20)
-  end
-
-  it 'should delete_keys_with_prefix' do
-
-    @db.delete_keys_with_prefix('animal')
-    @db.size.should.equal(@n + 1)
-    @db.keys(:prefix => 'animal').size.should.equal(0)
-  end
-end
-
-describe 'Rufus::Tokyo::Tyrant lget/lput/ldelete' do
-
-  before do
-    @db = Rufus::Tokyo::Tyrant.new('127.0.0.1', 45000)
-    @db.clear
-    3.times { |i| @db[i.to_s] = "val#{i}" }
-  end
-  after do
-    @db.close
-  end
-
-  it 'should get multiple values' do
-
-    @db.lget(%w{ 0 1 2 }).should.equal({"0"=>"val0", "1"=>"val1", "2"=>"val2"})
-  end
-
-  it 'should put multiple values' do
-
-    @db.lput('3' => 'val3', '4' => 'val4')
-    @db.lget(%w{ 2 3 }).should.equal({"2"=>"val2", "3"=>"val3"})
-  end
-
-  it 'should delete multiple values' do
-
-    @db.ldelete(%w{ 2 3 })
-    @db.lget(%w{ 0 1 2 }).should.equal({"0"=>"val0", "1"=>"val1"})
-  end
-end
-
-describe 'Rufus::Tokyo::Tyrant#add{int|double}' do
-
-  before do
-    @db = Rufus::Tokyo::Tyrant.new('127.0.0.1', 45000)
-    @db.clear
-  end
-  after do
-    @db.close
-  end
-
-  it 'should increment (int)' do
-
-    @db.addint('counter', 1).should.equal(1)
-    @db.incr('counter', 1).should.equal(2)
-    @db.addint('counter', 2).should.equal(4)
-    @db.incr('counter').should.equal(5)
-  end
-
-  it 'should fail gracefully if counter has already a [string] value (int)' do
-
-    @db['counter'] = 'a'
-    lambda { @db.addint('counter', 1) }.should.raise(Rufus::Tokyo::TokyoError)
-    @db['counter'].should.equal('a')
-  end
-
-  it 'should increment (double)' do
-
-    @db.adddouble('counter', 1.0).should.equal(1.0)
-    @db.incr('counter', 1.5).should.equal(2.5)
-    @db.adddouble('counter', 2.2).should.equal(4.7)
-  end
-
-  it 'should fail gracefully if counter has already a [string] value (double)' do
-
-    @db['counter'] = 'a'
-    lambda {
-      @db.adddouble('counter', 1.0)
-    }.should.raise(Rufus::Tokyo::TokyoError)
-    @db['counter'].should.equal('a')
-  end
-end
-
-describe 'Rufus::Tokyo::Tyrant (lua extensions)' do
-
-  before do
-    @db = Rufus::Tokyo::Tyrant.new('127.0.0.1', 45000)
-    @db.clear
-  end
-  after do
-    @db.close
-  end
-
-  it 'should call lua extensions' do
-
-    @db['toto'] = '0'
-    3.times { @db.ext(:incr, 'toto', '1') }
-    @db.ext('incr', 'toto', 2) # lax
-
-    @db['toto'].should.equal('5')
-  end
-
-  it 'should return nil when function is missing' do
-
-    @db.ext(:missing, 'nada', 'forever').should.equal(nil)
-  end
-end
-
-describe 'Rufus::Tokyo::Tyrant#putkeep' do
-
-  before do
-    @db = Rufus::Tokyo::Tyrant.new('127.0.0.1', 45000)
-    @db.clear
-  end
-  after do
-    @db.close
-  end
-
-  it 'should accept values' do
-
-    @db.putkeep('pillow', 'Shonagon')
-    @db.size.should.equal(1)
-  end
-
-  it 'should restitute values' do
-
-    @db.putkeep('pillow', 'Shonagon')
-    @db['pillow'].should.equal('Shonagon')
-  end
-
-  it 'should not overwrite values if already set' do
-
-    @db['pillow'] = 'Shonagon'
-    @db['pillow'].should.equal('Shonagon')
-
-    @db.putkeep('pillow', 'Ruby')
-    @db['pillow'].should.equal('Shonagon')
-  end
-
-  it 'should return true if not yet set' do
-
-    @db.putkeep('pillow', 'Shonagon').should.equal(true)
-  end
-
-  it 'should return false if already set' do
-
-    @db['pillow'] = 'Shonagon'
-    @db.putkeep('pillow', 'Ruby').should.equal(false)
-  end
-
-  it 'should accept binary data \0' do
-
-    s = "Sei#{0.chr}Shonagon"
-
-    @db.putkeep(s, s).should.be.true
-    @db[s].should.equal(s)
-  end
-end
-

data/vendor/rufus-tokyo/spec/tyrant_table_spec.rb

@@ -1,479 +0,0 @@
-
-#
-# Specifying rufus-tokyo
-#
-# Sun Feb  8 22:55:11 JST 2009
-#
-
-require File.dirname(__FILE__) + '/spec_base'
-
-require 'rufus/tokyo/tyrant'
-
-
-describe 'Rufus::Tokyo::TyrantTable' do
-
-  it 'should refuse to connect to a plain Tyrant' do
-
-    lambda {
-      t = Rufus::Tokyo::TyrantTable.new('127.0.0.1', 45000)
-    }.should.raise(ArgumentError)
-  end
-end
-
-
-describe 'Rufus::Tokyo::TyrantTable' do
-
-  before do
-    @t = Rufus::Tokyo::TyrantTable.new('127.0.0.1', 45001)
-    #puts @t.stat.inject('') { |s, (k, v)| s << "#{k} => #{v}\n" }
-    @t.clear
-  end
-
-  after do
-    @t.close
-  end
-
-  it 'should respond to stat' do
-
-    @t.stat['type'].should.equal('table')
-  end
-
-  it 'should generate unique ids' do
-
-    @t.genuid.should.satisfy { |i| i > 0 }
-  end
-
-  it 'should clear db' do
-
-    @t.clear
-    @t.size.should.be.zero
-  end
-
-  it 'should return nil for missing keys' do
-
-    @t['missing'].should.be.nil
-  end
-
-  it 'should accept map input' do
-
-    @t['pk0'] = value = { 'name' => 'fred', 'age' => '22' }
-    @t['pk0'].should.equal(value)
-  end
-
-  it 'should raise an ArgumentError on non map or hash input' do
-
-    lambda {
-      @t['pk0'] = 'bad thing here'
-    }.should.raise(ArgumentError)
-  end
-
-  unless defined?(JRUBY_VERSION)
-    it 'should raise an ArgumentError on non-string column name' do
-
-      lambda {
-        @t['pk0'] = [ 1, 2 ]
-      }.should.raise(ArgumentError)
-      lambda {
-        @t['pk0'] = { 1 => 2 }
-      }.should.raise(ArgumentError)
-    end
-
-    it 'should raise an ArgumentError on non-string column value' do
-
-      lambda {
-        @t['pk0'] = { 'a' => 2 }
-      }.should.raise(ArgumentError)
-    end
-  end
-
-  it 'should return map values' do
-
-    @t['pk0'] = { 'name' => 'toto', 'age' => '30' }
-    @t['pk0'].should.equal({ 'name' => 'toto', 'age' => '30' })
-  end
-
-  it 'should delete records' do
-
-    @t['pk0'] = { 'name' => 'toto', 'age' => '30' }
-    @t.delete('pk0')
-    @t['pk0'].should.be.nil
-  end
-
-  it 'should return deleted value' do
-
-    @t['pk0'] = old = { 'name' => 'toto', 'age' => '30' }
-    @t.delete('pk0').should.equal(old)
-  end
-
-  it 'should change store size after deleting' do
-
-    @t['pk0'] = { 'name' => 'toto', 'age' => '30' }
-    @t.delete('pk0')
-    @t.size.should.be.zero
-  end
-
-  it 'should not support transactions' do
-    lambda {
-      @t.transaction {}
-    }.should.raise(NoMethodError)
-    lambda {
-      @t.abort
-    }.should.raise(NoMethodError)
-  end
-
-  it 'should store binary data \0' do
-    s = "toto#{0.chr}nada"
-    @t[s] = { s => s }
-    @t[s].should.equal({ s => s })
-  end
-
-end
-
-
-describe 'Rufus::Tokyo::Table #keys' do
-
-  before do
-    @n = 50
-    @tab = Rufus::Tokyo::TyrantTable.new('127.0.0.1', 45001)
-    @tab.clear
-    @n.times { |i| @tab["person#{i}"] = { 'name' => 'whoever' } }
-    @n.times { |i| @tab["animal#{i}"] = { 'name' => 'whichever' } }
-    @tab["toto#{0.chr}5"] = { 'name' => 'toto' }
-  end
-
-  after do
-    @tab.close
-  end
-
-  it 'should return a Ruby Array by default' do
-
-    @tab.keys.class.should.equal(::Array)
-  end
-
-  it 'should return a Cabinet List when :native => true' do
-
-    l = @tab.keys(:native => true)
-    l.class.should.equal(Rufus::Tokyo::List)
-    l.size.should.equal(2 * @n + 1)
-    l.free
-  end
-
-  it 'should retrieve forward matching keys when :prefix => "prefix-"' do
-
-    @tab.keys(:prefix => 'person').size.should.equal(@n)
-
-    l = @tab.keys(:prefix => 'animal', :native => true)
-    l.size.should.equal(@n)
-    l.free
-  end
-
-  it 'should retrieve keys that contain \0' do
-
-    @tab.keys.include?("toto#{0.chr}5").should.be.true
-  end
-
-  it 'should retrieve forward matching keys when key contains \0' do
-
-    @tab.keys(:prefix => 'toto').should.equal([ "toto#{0.chr}5" ])
-  end
-
-  it 'should return a limited number of keys when :limit is set' do
-
-    @tab.keys(:limit => 20).size.should.equal(20)
-  end
-
-  it 'should delete_keys_with_prefix' do
-
-    @tab.delete_keys_with_prefix('animal')
-    @tab.size.should.equal(@n + 1)
-    @tab.keys(:prefix => 'animal').size.should.equal(0)
-  end
-end
-
-
-def prepare_table_with_data (port)
-  t = Rufus::Tokyo::TyrantTable.new('127.0.0.1', port)
-  t.clear
-  t['pk0'] = { 'name' => 'jim', 'age' => '25', 'lang' => 'ja,en' }
-  t['pk1'] = { 'name' => 'jeff', 'age' => '32', 'lang' => 'en,es' }
-  t['pk2'] = { 'name' => 'jack', 'age' => '44', 'lang' => 'en' }
-  t['pk3'] = { 'name' => 'jake', 'age' => '45', 'lang' => 'en,li' }
-  t
-end
-
-describe 'a Tokyo Tyrant table' do
-
-  before do
-    @t = prepare_table_with_data(45001)
-  end
-  after do
-    @t.close
-    # TODO : well there are trailing indexes now... :(
-  end
-
-  it 'should accept lexical indexes' do
-    @t.set_index('name', :lexical).should.equal(true)
-  end
-
-  it 'should accept decimal indexes' do
-    @t.set_index('age', :decimal).should.equal(true)
-  end
-
-  it 'should accept removal of indexes' do
-    @t.set_index('age', :decimal)
-    @t.set_index('age', :remove).should.equal(true)
-  end
-
-  it 'should accept indexes on the primary key (well...)' do
-    @t.set_index(:pk, :lexical).should.equal(true)
-    @t.set_index('', :lexical).should.equal(true)
-  end
-end
-
-
-describe 'Rufus::Tokyo::TyrantTable#lget' do
-
-  before do
-    @t = prepare_table_with_data(45001)
-  end
-  after do
-    @t.close
-  end
-
-  it 'should return an empty hash for missing keys' do
-    @t.lget(%w{ pk97 pk98 }).should.equal({})
-  end
-
-  it 'should return multiple records' do
-    @t.lget(%w{ pk0 pk1 }).should.equal({
-      'pk0' => { 'name' => 'jim', 'age' => '25', 'lang' => 'ja,en' },
-      'pk1' => { 'name' => 'jeff', 'age' => '32', 'lang' => 'en,es' }
-    })
-  end
-end
-
-
-describe 'a Tokyo Tyrant table, like a Ruby Hash,' do
-
-  before do
-    @t = prepare_table_with_data(45001)
-  end
-  after do
-    @t.close
-  end
-
-  it 'should respond to #keys' do
-
-    @t.keys.should.equal([ 'pk0', 'pk1', 'pk2', 'pk3' ])
-  end
-
-  it 'should respond to #values' do
-
-    @t.values.should.equal([
-      { 'name' => 'jim', 'age' => '25', 'lang' => 'ja,en' },
-      { 'name' => 'jeff', 'age' => '32', 'lang' => 'en,es' },
-      { 'name' => 'jack', 'age' => '44', 'lang' => 'en' },
-      { 'name' => 'jake', 'age' => '45', 'lang' => 'en,li' }])
-  end
-
-  it 'should benefit from Enumerable' do
-
-    @t.find { |k, v|
-      v['name'] == 'jeff'
-    }.should.equal([
-      'pk1', { 'name' => 'jeff', 'age' => '32', 'lang' => 'en,es' }])
-  end
-end
-
-
-describe 'queries on Tokyo Tyrant tables' do
-
-  before do
-    @t = prepare_table_with_data(45001)
-  end
-  after do
-    @t.close
-  end
-
-  it 'can be executed' do
-
-    @t.query { |q|
-      q.add 'lang', :includes, 'en'
-    }.size.should.equal(4)
-  end
-
-  it 'can be prepared' do
-
-    @t.prepare_query { |q|
-      q.add 'lang', :includes, 'en'
-    }.should.satisfy { |q| q.class == Rufus::Tokyo::TableQuery }
-  end
-
-  it 'can be counted' do
-
-    #@t.prepare_query { |q|
-    #  q.add 'lang', :includes, 'en'
-    #}.count.should.equal(4)
-
-    q = @t.prepare_query { |q|
-      q.add 'lang', :includes, 'en'
-    }
-    q.run
-    q.count.should.equal(4)
-  end
-
-  it 'can be limited' do
-
-    @t.query { |q|
-      q.add 'lang', :includes, 'en'
-      q.limit 2
-    }.size.should.equal(2)
-  end
-
-  it 'can leverage regex matches' do
-
-    @t.query { |q|
-      q.add 'name', :matches, '^j.+k'
-    }.to_a.should.equal([
-      {:pk => 'pk2', "name"=>"jack", "lang"=>"en", "age"=>"44"},
-      {:pk => 'pk3', "name"=>"jake", "lang"=>"en,li", "age"=>"45"}])
-  end
-
-  it 'can leverage numerical comparison (gt)' do
-
-    @t.query { |q|
-      q.add 'age', :gt, '40'
-      q.pk_only
-    }.to_a.should.equal([ 'pk2', 'pk3' ])
-  end
-
-  it 'can have negated conditions' do
-
-    @t.query { |q|
-      q.add 'age', :gt, '40', false
-      q.pk_only
-    }.to_a.should.equal([ 'pk0', 'pk1' ])
-  end
-
-
-  if Rufus::Tokyo::TyrantLib.respond_to?(:qry_setlimit)
-
-    it 'can be limited and have an offset' do
-
-      @t.query { |q|
-        q.add 'lang', :includes, 'en'
-        q.order_by 'name', :desc
-        q.limit 2, 0
-      }.collect { |e| e['name'] }.should.equal(%w{ jim jeff })
-      @t.query { |q|
-        q.add 'lang', :includes, 'en'
-        q.order_by 'name', :desc
-        q.limit 2, 2
-      }.collect { |e| e['name'] }.should.equal(%w{ jake jack })
-    end
-  end
-
-  it 'can be deleted (searchout : query#delete)' do
-
-    @t.prepare_query { |q|
-      q.add 'lang', :includes, 'es'
-    }.delete
-
-    @t.size.should.equal(3)
-  end
-
-  it 'can be deleted immediately (searchout table#query_delete)' do
-
-    @t.query_delete { |q|
-      q.add 'lang', :includes, 'es'
-    }
-
-    @t.size.should.equal(3)
-  end
-end
-
-describe 'Tokyo Tyrant and TableQuery#process' do
-
-  before do
-    @t = prepare_table_with_data(45001)
-  end
-  after do
-    @t.close
-  end
-
-  it 'should not work' do
-
-    lambda {
-      @t.prepare_query { |q|
-        q.add 'lang', :includes, 'en'
-      }.process { |k, v|
-      }.free
-    }.should.raise(NoMethodError)
-  end
-end
-
-describe 'results from Tokyo Tyrant table queries' do
-
-  before do
-    @t = prepare_table_with_data(45001)
-  end
-
-  after do
-    @t.close
-  end
-
-  it 'can come ordered (strdesc)' do
-
-    @t.query { |q|
-      q.add 'lang', :includes, 'en'
-      q.order_by 'name', :desc
-      q.limit 2
-    }.to_a.should.equal([
-      {:pk => 'pk0', "name"=>"jim", "lang"=>"ja,en", "age"=>"25"},
-      {:pk => 'pk1', "name"=>"jeff", "lang"=>"en,es", "age"=>"32"}])
-  end
-
-  it 'can come ordered (strasc)' do
-
-    @t.query { |q|
-      q.add 'lang', :includes, 'en'
-      q.order_by 'name', :asc
-    }.to_a.should.equal([
-      {:pk => 'pk2', "name"=>"jack", "lang"=>"en", "age"=>"44"},
-      {:pk => 'pk3', "name"=>"jake", "lang"=>"en,li", "age"=>"45"},
-      {:pk => 'pk1', "name"=>"jeff", "lang"=>"en,es", "age"=>"32"},
-      {:pk => 'pk0', "name"=>"jim", "lang"=>"ja,en", "age"=>"25"}])
-  end
-
-  it 'can come ordered (numasc)' do
-
-    @t.query { |q|
-      q.add 'lang', :includes, 'en'
-      q.order_by 'age', :numasc
-    }.to_a.should.equal([
-      {:pk => 'pk0', "name"=>"jim", "lang"=>"ja,en", "age"=>"25"},
-      {:pk => 'pk1', "name"=>"jeff", "lang"=>"en,es", "age"=>"32"},
-      {:pk => 'pk2', "name"=>"jack", "lang"=>"en", "age"=>"44"},
-      {:pk => 'pk3', "name"=>"jake", "lang"=>"en,li", "age"=>"45"}])
-  end
-
-  it 'can come without the primary keys (no_pk)' do
-
-    @t.query { |q|
-      q.add 'name', :matches, '^j.+k'
-      q.no_pk
-    }.to_a.should.equal([
-      {"name"=>"jack", "lang"=>"en", "age"=>"44"},
-      {"name"=>"jake", "lang"=>"en,li", "age"=>"45"}])
-  end
-
-  it 'can consist only of the primary keys (pk_only)' do
-
-    @t.query { |q|
-      q.add 'name', :matches, '^j.+k'
-      q.pk_only
-    }.to_a.should.equal(["pk2", "pk3"])
-  end
-
-end
-