riak-record 0.0.4 → 0.1.0

data/spec/riak_record/associations_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class Author < RiakRecord::Base
+  bucket_name "authors"
+  data_attributes :name
+end
+
+class Post #< ActiveRecord
+  include RiakRecord::Associations
+
+  belongs_to_riak :author, :class_name => 'Author', :foreign_key => :author_id
+  has_many_riak :comments, :class_name => 'Comment', :foreign_key => :post_id
+
+  def id
+    1
+  end
+
+  def author_id
+    @author_id ||= "12"
+  end
+
+  def author_id=(v)
+    @author_id = v
+  end
+
+end
+
+class Comment < RiakRecord::Base
+  bucket_name "comments"
+  data_attributes :comment
+
+  index_int_attributes :post_id
+end
+
+describe RiakRecord::Associations do
+  let(:post){ post = Post.new }
+
+  describe "belongs_to_riak" do
+    before :each do
+      @author = Author.new("12")
+      @author.name = 'Dr.Seuss'
+      @author.save
+
+      @real_author = Author.new("13")
+      @real_author.name = 'T. Geisel'
+      @real_author.save
+    end
+
+    it "should return the riak object" do
+      expect(post.author.name).to eq(@author.name)
+    end
+
+    it "should change the results when you change the foreign key value" do
+      expect{
+        post.author_id = @real_author.id
+      }.to change{ post.author.name }.from(@author.name).to(@real_author.name)
+    end
+
+    it "should set the foreign_key" do
+      expect{
+        post.author = @real_author
+      }.to change{ post.author_id }.from(@author.id).to(@real_author.id)
+    end
+
+  end
+
+  describe "has_many_riak" do
+    before :each do
+      @comment = Comment.new("1")
+      @comment.comment = "first!"
+      @comment.post_id = post.id
+      @comment.save
+
+      @other_comment = Comment.new("2")
+      @other_comment.comment = "+2"
+      @other_comment.post_id = post.id
+      @other_comment.save
+
+      @comment_for_other_post = Comment.new("3")
+      @comment_for_other_post.comment = "first!"
+      @comment_for_other_post.post_id = post.id + 1
+      @comment_for_other_post.save
+    end
+    it "should return a RiakRecord::Finder" do
+      expect(post.comments).to be_an_instance_of(RiakRecord::Finder)
+    end
+
+    it "should include the associated records" do
+      expect(post.comments.all.map(&:id)).to include(@comment.id, @other_comment.id)
+      expect(post.comments.all.map(&:id)).to_not include(@comment_for_other_post.id)
+    end
+  end
+end

data/spec/riak_record/base_spec.rb

@@ -0,0 +1,204 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class ExampleA < RiakRecord::Base
+  bucket_name 'example_a'
+  data_attributes :attribute1, :attribute2
+  index_int_attributes :index1, :index2
+  index_bin_attributes :index3, :index4
+end
+
+class ExampleB < RiakRecord::Base
+  bucket_name :example_b
+  index_int_attributes :example_a_id
+
+  belongs_to :example_a # optional :class_name => 'ExampleA', :key => :example_a_id || :example_a_key
+end
+
+describe RiakRecord::Base do
+  it "should set the bucket name on each instance of RiakRecord class" do
+    expect(ExampleA.bucket_name).to eq(RiakRecord::Base.namespace+":-:example_a")
+    expect(ExampleB.bucket_name).to eq(RiakRecord::Base.namespace+':-:example_b')
+  end
+
+  it "should share a client among all classes" do
+    expect(ExampleA.client).to_not eq(nil)
+    expect(ExampleA.client).to eq(ExampleB.client)
+  end
+
+  describe "index_names" do
+    it "should look up the index by symbol" do
+      expect( ExampleA.index_names[:index1] ).to eq("index1_int")
+      expect( ExampleA.index_names[:index3] ).to eq("index3_bin")
+    end
+  end
+
+  describe "reload" do
+    let(:record) { ExampleA.new("1234").tap{|p| p.attribute1 = 'bye'}.save }
+    it "should return the same obj" do
+      expect( record.reload ).to eq(record)
+    end
+    it "should discard unsaved changes" do
+      record.attribute1 = 'hello' # not saved
+      expect{
+        record.reload
+      }.to change{ record.attribute1 }.from('hello').to('bye')
+    end
+  end
+
+  describe "save" do
+    let(:record) { ExampleA.new("1234") }
+    it "should store the object" do
+      record.attribute1 = 'hello'
+      record.save
+      expect(record.reload.attribute1).to eq('hello')
+    end
+  end
+
+  describe "class methods" do
+    describe "new" do
+      context "when passed in an RObject" do
+        let(:robject) { Riak::RObject.new("a-key") }
+        let(:record) { ExampleA.new(robject) }
+        it "should wrap it" do
+          expect(record.riak_object).to eq(robject)
+          expect(record).to be_a(ExampleA)
+        end
+      end
+      context "when passed in a string" do
+        let(:key) { 'judy' }
+        let(:record) { ExampleA.new(key) }
+        it "should create an RObject with that id" do
+          expect(record).to be_a(ExampleA)
+          expect(record.riak_object).to be_a(Riak::RObject)
+          expect(record.riak_object.key).to eq(key)
+        end
+      end
+      context "when passed in nil" do
+        let(:record) { ExampleA.new() }
+        it "should create an RObject with no id" do
+          expect(record).to be_a(ExampleA)
+          expect(record.riak_object).to be_a(Riak::RObject)
+        end
+      end
+    end
+
+    describe "find" do
+      let(:bucket){ double }
+      let(:array){ Array.new }
+      before :each do
+        allow(ExampleA).to receive(:bucket).and_return(bucket)
+      end
+
+      it "should take an array and return an array" do
+        expect(bucket).to receive(:get_many).with(array).and_return([])
+        ExampleA.find(array)
+      end
+
+      it "should take a string and return nil if not found" do
+        e = Riak::FailedRequest.new("not found")
+        allow(e).to receive(:not_found?).and_return(true)
+        allow(bucket).to receive(:get).with("a-key").and_raise(e)
+        expect( ExampleA.find("a-key") ).to be_nil
+      end
+
+      it "should take a string and return an instance of Example" do
+        allow(bucket).to receive(:get).with("a-key").and_return(Riak::RObject.new("a-key"))
+        expect( ExampleA.find("a-key") ).to be_an_instance_of(ExampleA)
+      end
+    end
+
+    describe "where" do
+      it "should return an instance of RiakRecord::Finder" do
+        expect( ExampleA.where(:index1 => 'hello') ).to be_an_instance_of(RiakRecord::Finder)
+      end
+    end
+
+    describe "data_attributes" do
+      let(:riak_object) { Riak::RObject.new("obj").tap{|r| r.data = data } }
+      let(:data) { {'attribute1' => "1"} }
+      let(:record) { ExampleA.new(riak_object) }
+      it "should read and write each attribute" do
+        expect{
+          record.attribute1=('b')
+        }.to change{record.attribute1}.from("1").to('b')
+
+        expect{
+          record.attribute2 = 'c'
+        }.to change{record.attribute2}.from(nil).to('c')
+
+      end
+
+      it "should return attribute from riak_object data" do
+        expect( ExampleA.new(riak_object).attribute1 ).to eq("1")
+      end
+
+    end
+
+    describe "index_int_attributes" do
+      let(:riak_object) { Riak::RObject.new("obj").tap{|r| r.indexes["index1_int"] = [1] } }
+      let(:record) { ExampleA.new(riak_object) }
+      it "should read and write each index" do
+        expect{
+          record.index1=[2]
+        }.to change{record.riak_object.indexes["index1_int"]}.from([1]).to([2])
+      end
+
+      it "should handle non arrays" do
+        expect{
+          record.index2=2
+        }.to change{record.index2}.from([]).to([2])
+      end
+
+      it "should handle nil" do
+        expect{
+          record.index1 = nil
+        }.to change{record.index1}.from([1]).to([])
+      end
+    end
+
+    describe "index_bin_attributes" do
+      let(:riak_object) { Riak::RObject.new("obj").tap{|r| r.indexes["index3_bin"] = ['apple'] } }
+      let(:record) { ExampleA.new(riak_object) }
+      it "should read and write each index" do
+        expect{
+          record.index3=['mac']
+        }.to change{record.riak_object.indexes["index3_bin"]}.from(['apple']).to(['mac'])
+      end
+
+      it "should handle non arrays" do
+        expect{
+          record.index4='mac'
+        }.to change{record.index4}.from([]).to(['mac'])
+      end
+
+      it "should handle nil" do
+        expect{
+          record.index3 = nil
+        }.to change{record.index3}.from(['apple']).to([])
+      end
+    end
+
+    describe "namespacing buckets" do
+      it "should prepend namespace to bucket name" do
+        RiakRecord::Base.namespace = "namespace_test"
+        expect(ExampleA.bucket_name).to eq("namespace_test:-:example_a")
+      end
+    end
+
+    describe "belongs to" do
+      let(:record){ ExampleB.new(456).save }
+      let(:related_record){ ExampleA.new(123).save }
+      it "should set the relation" do
+        expect{
+          record.example_a = related_record
+        }.to change{ record.example_a_id }.from([]).to([related_record.id.to_i])
+      end
+
+      it "should find the relation" do
+        record.example_a = related_record
+        record.save
+        expect(record.reload.example_a).to eq(related_record)
+      end
+    end
+  end
+end

data/spec/riak_record/finder_spec.rb

@@ -0,0 +1,163 @@
+require 'pry'
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class Artist < RiakRecord::Base
+  bucket_name 'artist'
+  data_attributes :name, :bin_number
+  index_int_attributes :sales
+  index_bin_attributes :category
+end
+
+describe RiakRecord::Finder do
+  before :each do
+    @pop_artists = Array(1..155).map do |c|
+      a = Artist.new(c.to_s)
+      a.name = "Pop Artist #{c}"
+      a.category = "pop"
+      a.bin_number = c % 10
+      a.sales = (c % 10) * 100
+      a.save
+    end
+
+    @rock_artists = Array(156..203).map do |c|
+      a = Artist.new(c.to_s)
+      a.name = "Rock Artist #{c}"
+      a.category = "rock"
+      a.bin_number = c % 10
+      a.sales = (c % 10) * 100
+      a.save
+    end
+  end
+
+  let(:pop_finder){ RiakRecord::Finder.new(Artist, :category => 'pop') }
+  let(:country_finder){ RiakRecord::Finder.new(Artist, :category => 'country') }
+
+  describe "all" do
+
+    it "should return all the records that match the conditions" do
+      expect( pop_finder.all.map(&:id).sort ).to eq(@pop_artists.map(&:id).sort)
+    end
+
+    it "should not return all the record that do not match the conditions" do
+      expect( pop_finder.all.map(&:id) ).to_not include(@rock_artists.map(&:id))
+    end
+
+  end
+
+  describe "count" do
+    it "should return the count by map reduce" do
+      expect(pop_finder).to receive(:count_map_reduce).and_call_original
+      expect(pop_finder.count).to eq(155)
+    end
+
+    context "all results in memory" do
+      before :each do
+        pop_finder.all # load complete
+      end
+
+      it "should not count by map reduce if load complete" do
+        expect(pop_finder).to_not receive(:count_map_reduce)
+        expect(pop_finder.count).to eq(155)
+      end
+    end
+  end
+
+  describe "enumberable methods" do
+    it "should yield once per block" do
+      expect( pop_finder.all?{|o| o.category == 'rock'} ).to eq(true)
+    end
+  end
+
+  describe "any?" do
+    it "should return true if there are any" do
+      expect(pop_finder.any?).to eq(true)
+    end
+    it "should return false if there aren't any" do
+      expect(country_finder.any?).to eq(false)
+    end
+    it "should handle a block" do
+      expect(pop_finder.any?{|o| o.id == "none"}).to eq(false)
+      expect(pop_finder.any?{|o| o.id == @pop_artists.last.id}).to eq(true)
+    end
+  end
+
+  describe "empty? / none" do
+    it "should return true if there aren't any" do
+      expect(pop_finder.empty?).to eq(false)
+    end
+    it "should return false if there are any" do
+      expect(country_finder.empty?).to eq(true)
+    end
+    it "should return true if there aren't any" do
+      expect(pop_finder.none?).to eq(false)
+    end
+    it "should return false if there are any" do
+      expect(country_finder.none?).to eq(true)
+    end
+    it "should handle a block" do
+      expect(pop_finder.none?{|o| o.id == 'none'}).to eq(true)
+      expect(pop_finder.none?{|o| o.id == @pop_artists.last.id}).to eq(false)
+    end
+  end
+
+  describe "first" do
+    it "should return something if not empty" do
+      expect(pop_finder.first).to_not be_nil
+    end
+    it "should return nil if empty" do
+      expect(country_finder.first).to be_nil
+    end
+    it "should handle a quantity" do
+      expect(pop_finder.first(71).count).to eq(71)
+    end
+  end
+
+  describe "find" do
+    it "should return the first object to match block" do
+      expect(pop_finder.find{|o| o.id =~ /^4/}.id).to match(/^4/)
+    end
+  end
+
+  describe "detect" do
+    it "should return the first object to match block" do
+      expect(pop_finder.detect{|o| o.id =~ /^3/}.id).to match(/^3/)
+    end
+  end
+
+  describe "count_by(attribute)" do
+    let(:bin_number_counts){
+      { "0" => 15, "1" => 16, "2" => 16, "3" => 16, "4" => 16, "5" => 16, "6" => 15, "7" => 15, "8" => 15, "9" => 15}
+    }
+
+    let(:sales_counts){
+      { "0" => 15, "100" => 16, "200" => 16, "300" => 16, "400" => 16, "500" => 16, "600" => 15, "700" => 15, "800" => 15, "900" => 15}
+    }
+
+    it "should count_by" do
+      expect(pop_finder).to receive(:count_by_map_reduce).with(:bin_number).and_call_original
+      expect(pop_finder.count_by(:bin_number)).to eq(bin_number_counts)
+    end
+
+    context "everything loaded" do
+      before :each do
+        pop_finder.all
+      end
+
+      it "should count_by without map reduce" do
+        expect(pop_finder).to_not receive(:count_by_map_reduce).with(:bin_number)
+        expect(pop_finder.count_by(:bin_number)).to eq(bin_number_counts)
+      end
+
+    end
+
+    context "attribute is index" do
+      it "should count_by" do
+        expect(pop_finder).to receive(:count_by_map_reduce).with(:sales).and_call_original
+        expect(pop_finder.count_by(:sales)).to eq(sales_counts)
+      end
+
+    end
+
+  end
+
+end

data/spec/riak_record_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe RiakRecord do
+end

data/spec/spec_helper.rb

@@ -18,14 +18,20 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'rspec'
-require 'riak-record'
+require 'riak_record'
 
-RiakRecord.client = Riak::Client.new(:host => 'localhost', :pb_port => '8087')
+RiakRecord::Base.client = Riak::Client.new(:host => 'localhost', :pb_port => '8087')
+Riak.disable_list_keys_warnings = true
 
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
-
+  config.before do
+    RiakRecord::Base.namespace = 'test'
+    RiakRecord::Base.all_buckets_in_namespace do |bucket|
+      bucket.keys.each{|k| bucket.delete(k) }
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: riak-record
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Robert Graff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-18 00:00:00.000000000 Z
+date: 2014-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: riak-client
@@ -94,6 +94,48 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.3.1
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier-guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |-
   RiakRecord is a thin and immature wrapper around riak-ruby-client. It creates a bucket for
     each class, provides a simple finder, and creates attribute reader.
@@ -108,13 +150,21 @@ files:
 - .rspec
 - Gemfile
 - Gemfile.lock
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- TODO.md
 - VERSION
-- lib/riak-record.rb
+- lib/riak_record.rb
+- lib/riak_record/associations.rb
+- lib/riak_record/base.rb
+- lib/riak_record/finder.rb
 - riak-record.gemspec
-- spec/riak-record_spec.rb
+- spec/riak_record/associations_spec.rb
+- spec/riak_record/base_spec.rb
+- spec/riak_record/finder_spec.rb
+- spec/riak_record_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/rgraff/riak-record
 licenses:

data/lib/riak-record.rb

@@ -1,77 +0,0 @@
-require 'riak'
-
-class RiakRecord
-  attr_reader :riak_object
-
-  def initialize(r = nil)
-    r = self.class.bucket.new(r) if r.nil? || r.is_a?(String)
-    raise ArgumentError unless r.is_a? Riak::RObject
-    @riak_object = r
-  end
-
-  def data
-    riak_object.data
-  end
-
-  def save
-    riak_object.store(:returnbody => false)
-  end
-
-  def self.bucket_name(name = :not_a_name)
-    @bucket_name = name unless name == :not_a_name
-    namespace.present? ? namespace+":-:"+@bucket_name : @bucket_name
-  end
-
-  def self.bucket
-    @bucket ||= client.bucket(bucket_name)
-  end
-
-  def self.record_attributes(*attributes)
-    attributes.each do |method_name|
-      define_method(method_name) do
-          data[method_name]
-      end
-
-      define_method("#{method_name}=".to_sym) do |value|
-        data[method_name] = value
-      end
-    end
-  end
-
-  def self.find(key_or_keys)
-    return find_many(key_or_keys) if key_or_keys.is_a?(Array)
-
-    begin
-      self.new(bucket.get(key_or_keys.to_s))
-    rescue Riak::FailedRequest => e
-      if e.not_found?
-        nil
-      else
-        raise e
-      end
-    end
-  end
-
-  def self.find_many(keys)
-    hash = bucket.get_many(keys.map(&:to_s))
-    keys.map{ |k| hash[k] }
-  end
-
-  @@namespace = nil
-  def self.namespace=(namespace)
-    @@namespace = namespace
-  end
-
-  def self.namespace
-    @@namespace
-  end
-
-  def self.client=(client)
-    @@client = client
-  end
-
-  def self.client
-    @@client
-  end
-
-end