risky 1.0.1 → 1.1.0

data/spec/risky/indexes_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class Indexed < Risky
+  include Risky::ListKeys
+  include Risky::Indexes
+
+  bucket :risky_indexes
+  value :value
+  value :unique
+  index :value
+  index :unique, :unique => true
+end
+
+
+describe 'indexes' do
+  before :all do
+    Indexed.delete_all
+  end
+
+  it 'can index a string' do
+    o = Indexed.new 'test', 'value' => 'value'
+    o.save.should_not be_false
+    Indexed.by_value('value').should === o
+  end
+
+  it 'can keep values unique (mostly)' do
+    o = Indexed.new '1', 'unique' => 'u'
+    o.save.should_not be_false
+
+    o2 = Indexed.new '2', 'unique' => 'u'
+    o2.save.should be_false
+    o2.errors[:unique].should == 'taken'
+  end
+end

data/spec/risky/resolver_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'risky/resolver'
+
+Thread.abort_on_exception = true
+
+class Multi < Risky
+  include Risky::ListKeys
+  include Risky::Resolver
+
+  bucket :risky_mult
+  allow_mult
+  value :users, :default => []
+  value :union, :resolve => :union
+  value :intersection, :resolve => Risky::Resolver::Resolvers.method(:intersection)
+  value :max, :resolve => :max
+  value :min, :resolve => :min
+  value :merge, :resolve => :merge
+  value :custom, :resolve => lambda { |xs|
+    :custom
+  }
+
+  def self.merge(v)
+    p = super v
+
+    p.users = v.map(&:users).min
+
+    p
+  end
+end
+
+def test(property, ins, out)
+  it property do
+    conflict(Multi, property, ins)[property].should == out
+  end
+end
+
+def set_test(property, ins, out)
+  it property do
+    conflict(Multi, property, ins)[property].to_set.should == out.to_set
+  end
+end
+
+
+describe Risky::Resolver do
+  set_test 'union', [[1], [2]], [1,2]
+  set_test 'union', [[1], nil], [1]
+  set_test 'union', [[1,4,1], [2,3], [4,4]], [1,2,3,4]
+  set_test 'intersection', [[1,2],[]], []
+  set_test 'intersection', [[1,2,3,4], [1,2,3], [2,3,4]], [2,3]
+  test 'min', [0,1,2,3], 0
+  test 'max', [0,2,4,2], 4
+  test 'max', [nil, nil], nil
+  test 'max', [nil, 4], 4
+  test 'custom', ['a', 'b', 'c'], :custom
+end

data/spec/risky/secondary_indexes_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+
+class Album < Risky
+  include Risky::ListKeys
+  include Risky::SecondaryIndexes
+
+  bucket :risky_albums
+  allow_mult
+  index2i :artist_id, :map => true
+  index2i :label_key, :map => '_key', :finder => :find_by_id, :allow_nil => true
+  index2i :genre, :type => :bin, :allow_nil => true
+  index2i :tags, :type => :bin, :multi => true, :allow_nil => true
+  value :name
+  value :year
+end
+
+class Artist < Risky
+  include Risky::ListKeys
+
+  bucket :risky_artists
+  value :name
+end
+
+class Label < Risky
+  include Risky::ListKeys
+
+  bucket :risky_labels
+  value :name
+
+  def self.find_by_id(id)
+    find(id)
+  end
+end
+
+class City < Risky
+  include Risky::SecondaryIndexes
+
+  bucket :risky_cities
+  index2i :country_id, :type => :invalid, :allow_nil => true
+  value :name
+  value :details
+end
+
+
+describe Risky::SecondaryIndexes do
+  let(:artist) { Artist.create(1, :name => 'Motorhead') }
+  let(:label) { Label.create(1, :name => 'Bronze Records') }
+
+  before :each do
+    Album.delete_all
+    Artist.delete_all
+    Label.delete_all
+  end
+
+  it "sets indexes on initialize" do
+    album = Album.new(1, {:name => 'Bomber', :year => 1979}, {:artist_id => 2})
+    album.indexes2i.should == {"artist_id" => 2 }
+  end
+
+  it "defines getter and setter methods" do
+    album = Album.new(1)
+    album.artist_id = 1
+    album.artist_id.should == 1
+  end
+
+  it "defines association getter and setter methods" do
+    album = Album.new(1)
+    album.artist = artist
+    album.artist.should == artist
+  end
+
+  it "defines association getter and setter methods when using suffix" do
+    album = Album.new(1)
+    album.label = label
+    album.label.should == label
+  end
+
+  it "can use a custom finder" do
+    album = Album.create(1, {:name => 'Bomber', :year => 1979},
+      {:artist_id => artist.id, :label_key => label.id})
+
+    Label.should_receive(:find_by_id).with(label.id).and_return(label)
+
+    album.label.should == label
+  end
+
+  it "resets association if associated object is not saved" do
+    artist = Artist.new('new_key')
+    album = Album.new('new_key')
+    album.artist = artist
+    album.artist.should be_nil
+  end
+
+  it "assigns attributs after association assignment" do
+    album = Album.new(1)
+    album.artist = artist
+    album.artist_id.should == artist.id
+  end
+
+  it "assigns association after attribute assignment" do
+    album = Album.new(1)
+    album.artist_id = artist.id
+    album.artist.should == artist
+  end
+
+  it "saves a model with indexes" do
+    album = Album.new(1, {:name => 'Ace of Spades' }, { :artist_id => 1 }).save
+    album.artist_id.should == 1
+  end
+
+  it "creates a model with indexes" do
+    album = Album.create(1, {:name => 'Ace of Spades' }, { :artist_id => 1 })
+    album.artist_id.should == 1
+  end
+
+  it "persists association after save" do
+    album = Album.new('persist_key')
+    album.name = 'Ace of Spades'
+    album.artist_id = artist.id
+    album.save
+
+    album.artist.should == artist
+    album.artist_id.should == artist.id
+
+    album.reload
+
+    album.artist.should == artist
+    album.artist_id.should == artist.id
+
+    album = Album.find(album.key)
+
+    album.artist.should == artist
+    album.artist_id.should == artist.id
+  end
+
+  it "finds first by int secondary index" do
+    album = Album.create(1, {:name => 'Bomber', :year => 1979},
+      {:artist_id => artist.id})
+
+    albums = Album.find_by_index(:artist_id, artist.id)
+    albums.should == album
+  end
+
+  it "finds all by int secondary index" do
+    album1 = Album.create(1, {:name => 'Bomber', :year => 1979},
+      {:artist_id => artist.id, :label_key => label.id})
+    album2 = Album.create(2, {:name => 'Ace Of Spaces', :year => 1980},
+      {:artist_id => artist.id, :label_key => label.id})
+
+    albums = Album.find_all_by_index(:artist_id, artist.id)
+    albums.should include(album1)
+    albums.should include(album2)
+  end
+
+  it "finds all by binary secondary index" do
+    album = Album.create(1, {:name => 'Bomber', :year => 1979},
+      {:artist_id => artist.id, :label_key => label.id, :genre => 'heavy'})
+
+    Album.find_all_by_index(:genre, 'heavy').should == [album]
+  end
+
+  it "finds all by multi binary secondary index" do
+    album = Album.create(1, {:name => 'Bomber', :year => 1979},
+      {:artist_id => artist.id, :label_key => label.id,
+       :tags => ['rock', 'heavy']})
+
+    Album.find_all_by_index(:tags, 'heavy').should == [album]
+    Album.find_all_by_index(:tags, 'rock').should == [album]
+  end
+
+  it "paginates keys" do
+    album1 = Album.create('1', {:name => 'Bomber', :year => 1979},
+      {:artist_id => artist.id, :label_key => label.id})
+    album2 = Album.create('2', {:name => 'Ace Of Spaces', :year => 1980},
+      {:artist_id => artist.id, :label_key => label.id})
+    album3 = Album.create('3', {:name => 'Overkill', :year => 1979},
+      {:artist_id => artist.id, :label_key => label.id})
+
+    page1 = Album.paginate_keys_by_index(:artist_id, artist.id, :max_results => 2)
+    page1.should == ['1', '2']
+    page1.continuation.should_not be_blank
+
+    page2 = Album.paginate_keys_by_index(:artist_id, artist.id, :max_results => 2, :continuation => page1.continuation)
+    page2.should == ['3']
+    page2.continuation.should be_blank
+  end
+
+  it "paginates risky objects" do
+    album1 = Album.create('1', {:name => 'Bomber', :year => 1979},
+      {:artist_id => artist.id, :label_key => label.id})
+    album2 = Album.create('2', {:name => 'Ace Of Spaces', :year => 1980},
+      {:artist_id => artist.id, :label_key => label.id})
+    album3 = Album.create('3', {:name => 'Overkill', :year => 1979},
+      {:artist_id => artist.id, :label_key => label.id})
+
+    page1 = Album.paginate_by_index(:artist_id, artist.id, :max_results => 2)
+    page1.should == [album1, album2]
+    page1.continuation.should_not be_blank
+
+    page2 = Album.paginate_by_index(:artist_id, artist.id, :max_results => 2, :continuation => page1.continuation)
+    page2.should == [album3]
+    page2.continuation.should be_blank
+  end
+
+  it "raises an exception when index is nil" do
+    album = Album.new(1)
+    expect { album.save }.to raise_error(ArgumentError)
+  end
+
+  it "raises an exception when type is invalid" do
+    city = City.new(1)
+    expect { city.save }.to raise_error(TypeError)
+  end
+
+  it "can inspect a model" do
+    album = Album.new(1, { :name => 'Bomber' }, { :artist_id => 2 })
+
+    album.inspect.should match(/Album 1/)
+    album.inspect.should match(/"name"=>"Bomber"/)
+    album.inspect.should match(/"artist_id"=>2/)
+  end
+end

data/spec/risky/threads_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+class Crud < Risky
+  include Risky::ListKeys
+
+  bucket :risky_crud
+  value :value
+end
+
+class Concurrent < Risky
+  include Risky::ListKeys
+
+  bucket :risky_concurrent
+  allow_mult
+  value :v
+
+  # Merge value v together as a list
+  def self.merge(versions)
+    p = super versions
+    p.v = versions.inject([]) do |merged, version|
+      merged + [*version.v]
+    end.uniq
+    p
+  end
+end
+
+
+describe 'Threads' do
+  it 'supports concurrent modification' do
+    Concurrent.bucket.props['allow_mult'].should be_true
+
+    # Riak doesn't do well with concurrent *new* writes, so get an existing
+    # value in there first.
+    c = Concurrent.get_or_new('c')
+    c.v = []
+    c.save(:w => :all)
+
+    workers = 10
+
+    # Make a bunch of concurrent writes
+    (0...workers).map do |i|
+      Thread.new do
+        # Give them a little bit of jitter, just to make the vclocks interesting
+        sleep rand/6
+        c = Concurrent.get_or_new('c')
+        c.v << i
+        c.save or raise
+      end
+    end.each do |thread|
+      thread.join
+    end
+
+    # Check to ensure we obsoleted or have an extant write for every thread.
+    final = Concurrent['c', {:r => :all}]
+    final.v.compact.sort.should == (0...workers).to_a
+  end
+end

data/spec/risky_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+class User < Risky
+  include Risky::ListKeys
+
+  bucket 'risky_users'
+  allow_mult
+  value :admin, :default => false
+  value :age
+end
+
+describe 'Risky' do
+  before :each do
+    User.delete_all
+  end
+
+  it 'has a bucket' do
+    User.bucket.should be_kind_of Riak::Bucket
+  end
+
+  it "can store a value and retrieve it" do
+    user = User.new('test', 'admin' => true)
+    user.save.should_not be_false
+
+    user.key.should == 'test'
+    user.admin.should == true
+  end
+
+  it "can find" do
+    user = User.create('test')
+    User.find('test').should == user
+  end
+
+  it "can find all by key" do
+    user = User.create('test')
+    User.find_all_by_key(['test']).should == [user]
+  end
+
+  it "returns id as integer" do
+    user = User.new
+    user.id = 1
+    user.save
+    user.id.should == 1
+  end
+
+  it "returns id as string" do
+    user = User.new
+    user.id = 'test'
+    user.save
+    user.id.should == 'test'
+  end
+
+  it "can update attribute" do
+    user = User.new('test', 'admin' => true)
+    user.update_attribute(:admin, false)
+    user.admin.should be_false
+  end
+
+  it "can update attributes" do
+    user = User.new('test', 'admin' => true)
+    user.update_attributes({:admin => false})
+    user.admin.should be_false
+  end
+
+  context "conflict resolution" do
+    let(:key) { 'siblings' }
+
+    before :each do
+      User.new(key, 'age' => 20).save
+
+      user1 = User[key]
+      user2 = User[key]
+
+      user1.age = 21
+      user1.save
+
+      # no conflict
+      User.bucket.get(key).siblings.length.should == 1
+
+      user2.age = 22
+      user2.save
+
+      # it creates a new sibling because of conflict
+      User.bucket.get(key).siblings.length.should == 2
+    end
+
+    it 'it resolves the conflict on risky level' do
+      user = User[key]
+      User.bucket.get(key).siblings.length.should == 2
+      user.riak_object.siblings.length.should == 1
+    end
+
+    it 'resolves the conflict on riak data level' do
+      user = User[key]
+      user.save
+      user.riak_object.siblings.length.should == 1
+      User.bucket.get(key).siblings.length.should == 1
+    end
+  end
+end