seomoz-ripple 1.0.0.pre

data/spec/ripple/associations_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Ripple::Associations do
+  require 'support/models/invoice'
+  require 'support/models/customer'
+  require 'support/models/note'
+
+  it "should provide access to the associations hash" do
+    Invoice.should respond_to(:associations)
+    Invoice.associations.should be_kind_of(Hash)
+  end
+
+  it "should collect the embedded associations" do
+    Invoice.embedded_associations.should == Array(Invoice.associations[:note])
+  end
+
+  it "should collect the linked associations" do
+    Invoice.linked_associations.should == Array(Invoice.associations[:customer])
+  end
+
+  it "should collect the stored_key associations" do
+    Account.stored_key_associations.should == Array(Account.associations[:transactions])
+    Transaction.stored_key_associations.should == Array(Transaction.associations[:account])
+  end
+
+  it "should copy associations to a subclass" do
+    Invoice.associations[:foo] = "bar"
+    class SubInvoice < Invoice; end
+    SubInvoice.associations[:foo].should == "bar"
+  end
+
+  describe "when adding a :many association" do
+    it "should add accessor and mutator methods" do
+      Invoice.many :items
+      Invoice.instance_methods.map(&:to_sym).should include(:items)
+      Invoice.instance_methods.map(&:to_sym).should include(:items=)
+    end
+  end
+
+  describe "when adding a :one association" do
+    it "should add accessor, mutator, and query methods" do
+      Invoice.one :payee
+      Invoice.instance_methods.map(&:to_sym).should include(:payee)
+      Invoice.instance_methods.map(&:to_sym).should include(:payee=)
+      Invoice.instance_methods.map(&:to_sym).should include(:payee?)
+    end
+  end
+
+  before(:all) do
+    @orig_invoice = Invoice
+    Object.send(:remove_const, :Invoice)
+    class Invoice < @orig_invoice; end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, :SubInvoice) if defined?(SubInvoice)
+    Object.send(:remove_const, :Invoice)
+    Object.send(:const_set, :Invoice, @orig_invoice)
+  end
+end
+
+describe Ripple::Association do
+  it "should initialize with a type and name" do
+    lambda { Ripple::Association.new(:many, :pages) }.should_not raise_error
+  end
+
+  describe "determining the class name" do
+    it "should default to the camelized class name on :one relationships" do
+      @association = Ripple::Association.new(:one, :page)
+      @association.class_name.should == "Page"
+    end
+
+    it "should default to the singularized camelized class name on :many relationships" do
+      @association = Ripple::Association.new(:many, :pages)
+      @association.class_name.should == "Page"
+    end
+
+    it "should use the :class_name option when given" do
+      @association = Ripple::Association.new(:many, :pages, :class_name => "Note")
+      @association.class_name.should == "Note"
+    end
+  end
+
+  describe "determining the target class" do
+    require 'support/models/tree'
+
+    it "should default to the constantized class name" do
+      @association = Ripple::Association.new(:one, :t, :class_name => "Trunk")
+      @association.klass.should == Trunk
+    end
+
+    it "should be determined by the derived class name" do
+      @association = Ripple::Association.new(:many, :branches)
+      @association.klass.should == Branch
+    end
+
+    it "should use the :class option when given" do
+      @association = Ripple::Association.new(:many, :pages, :class => Leaf)
+      @association.klass.should == Leaf
+    end
+  end
+
+  it "should be many when type is :many" do
+    Ripple::Association.new(:many, :pages).should be_many
+  end
+
+  it "should be one when type is :one" do
+    Ripple::Association.new(:one, :pages).should be_one
+  end
+
+  it "should determine an instance variable based on the name" do
+    Ripple::Association.new(:many, :pages).ivar.should == "@_pages"
+  end
+
+  describe "key correspondence" do
+    require 'support/models/profile'
+    require 'support/models/user'
+
+    it "should raise an exception if trying to use a many association when :using => :key" do
+      expect { Profile.many :user, :using => :key }.to raise_error(ArgumentError, "You cannot use a many association using :key")
+    end
+
+    it "should add the key_delegate attr_accessor to the model declaring the association" do
+      Profile.one :user, :using => :key
+      Profile.new.should respond_to(:key_delegate)
+      Profile.new.should respond_to(:key_delegate=)
+    end
+  end
+end

data/spec/ripple/attribute_methods/dirty_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Ripple::AttributeMethods::Dirty do
+  let(:company)    { Company.new }
+  let(:ceo)        { CEO.new(:name => 'John Doe') }
+  let(:department) { Department.new(:name => 'Marketing') }
+  let(:manager)    { Manager.new(:name => 'Billy Willy') }
+  let(:invoice)    { Invoice.new }
+
+  describe "previous_changes" do
+    before do
+      company.robject.stub!(:store).and_return(true)
+      company.name = 'Fizz Buzz, Inc.'
+    end
+    
+    it "should capture previous changes when saving" do
+      company.save
+      company.previous_changes.should include('name')
+    end
+
+    it "should make previous changes available to after callbacks" do
+      my_class = Class.new(Company) do
+        after_save {|c| c['pc'] = previous_changes }
+      end
+      comp = my_class.new
+      comp.robject.stub!(:store).and_return(true)
+      comp.name = 'Fizz Buzz, Inc.'
+      comp.save
+      comp['pc'].should include('name')
+    end
+  end
+
+  describe "#changed?" do
+
+    it "returns true if the document's attributes have changed (regardless of whether or not it has any embedded associated documents)" do
+      company.name = 'Fizz Buzz, Inc'
+      company.should be_changed
+    end
+
+
+    context "when the document's attributes have not changed" do
+      it 'returns false if it has no embedded associated documents' do
+        company.should_not be_changed
+      end
+
+      context 'when the document has embedded associated documents' do
+        before(:each) do
+          company.ceo = ceo
+          company.invoices << invoice
+          company.departments << department
+          department.managers << manager
+        end
+
+        it 'returns false if all the embedded documents are not changed' do
+          company.should_not be_changed
+        end
+
+        it 'does not consider changes to linked associated documents' do
+          invoice.should_not_receive(:changed?)
+          company.changed?
+        end
+
+        it 'returns true if a one embedded association document is changed' do
+          ceo.should_receive(:changed?).and_return(true)
+          company.should be_changed
+        end
+
+        it 'returns true if a many embedded association document is changed' do
+          department.should_receive(:changed?).and_return(true)
+          company.should be_changed
+        end
+
+        it 'recurses through the whole embedded document structure to find changed grandchild documents' do
+          manager.should_receive(:changed?).and_return(true)
+          company.should be_changed
+        end
+      end
+    end
+  end
+end

data/spec/ripple/attribute_methods_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe Ripple::AttributeMethods do
+  require 'support/models/widget'
+
+  before :each do
+    @widget = Widget.new
+  end
+
+  describe "object key" do
+    it "should provide access to the key" do
+      @widget.should respond_to(:key)
+      @widget.key.should be_nil
+    end
+
+    it "should provide a mutator for the key" do
+      @widget.should respond_to(:key=)
+      @widget.key = "cog"
+      @widget.key.should == "cog"
+    end
+
+    it "should not set the key from mass assignment" do
+      @widget.key = 'widget-key'
+      @widget.attributes = {'key' => 'new-key'}
+      @widget.key.should == 'widget-key'
+    end
+
+    it "should typecast the key to a string" do
+      @widget.key = 10
+      @widget.key.should == "10"
+    end
+  end
+
+  describe "accessors" do
+    it "should be defined for defined properties" do
+      @widget.should respond_to(:size)
+      @widget.should respond_to(:name)
+    end
+
+    it "should return nil if no default is defined on the property" do
+      @widget.size.should be_nil
+    end
+
+    it "should return the property default if defined and not set" do
+      @widget.name.should == "widget"
+      @widget.manufactured.should == false
+    end
+
+    it "dups the default if it is duplicable so that two document do not share the same mutable value" do
+      widget2 = Widget.new
+      @widget.name.should_not be(widget2.name)
+      widget2.name.gsub!("w", "f")
+      @widget.name.should == "widget"
+    end
+
+    it "should allow raw attribute access when accessing the document with []" do
+      @widget['name'].should == 'widget'
+    end
+
+    it "should expose the property directly" do
+      @widget.name.gsub!("w","f")
+      @widget.name.should == "fidget"
+    end
+  end
+
+  describe "mutators" do
+    it "should have mutators for defined properties" do
+      @widget.should respond_to(:size=)
+      @widget.should respond_to(:name=)
+    end
+
+    it "should assign the value of the attribute" do
+      @widget.size = 10
+      @widget.size.should == 10
+    end
+
+    it "should allow assignment of undefined attributes when assigning to the document with []=" do
+      @widget.should_not respond_to(:shoe_size)
+      @widget['shoe_size'] = 8
+      @widget['shoe_size'].should == 8
+    end
+
+    it "should type cast assigned values automatically" do
+      @widget.name = :so_what
+      @widget.name.should == "so_what"
+    end
+
+    it "should raise an error when assigning a bad value" do
+      lambda { @widget.size = true }.should raise_error(Ripple::PropertyTypeMismatch)
+    end
+  end
+
+  describe "query methods" do
+    it "should be defined for defined properties" do
+      @widget.should respond_to(:size?)
+      @widget.should respond_to(:name?)
+    end
+
+    it "should be false when the attribute is nil" do
+      @widget.size.should be_nil
+      @widget.size?.should be_false
+    end
+
+    it "should be true when the attribute has a value present" do
+      @widget.size = 10
+      @widget.size?.should be_true
+    end
+
+    it "should be false for 0 values" do
+      @widget.size = 0
+      @widget.size?.should be_false
+    end
+
+    it "should be false for empty values" do
+      @widget.name = ""
+      @widget.name?.should be_false
+    end
+  end
+
+  it "should track changes to attributes" do
+    @widget.name = "foobar"
+    @widget.changed?.should be_true
+    @widget.name_changed?.should be_true
+    @widget.name_change.should == ["widget", "foobar"]
+    @widget.changes.should == {"name" => ["widget", "foobar"]}
+  end
+
+  it "should report that an attribute is changed only if its value actually changes" do
+    @widget.name = "widget"
+    @widget.changed?.should be_false
+    @widget.name_changed?.should be_false
+    @widget.changes.should be_blank
+  end
+
+  it "should refresh the attribute methods when adding a new property" do
+    Widget.should_receive(:undefine_attribute_methods)
+    Widget.property :start_date, Date
+    Widget.properties.delete(:start_date) # cleanup
+  end
+
+  describe "#attributes" do
+    it "it returns a hash representation of all of the attributes" do
+      @widget.attributes.should == {"name" => "widget", "size" => nil, "manufactured" => false, "shipped_at" => nil}
+    end
+
+    it "does not include ghost attributes (attributes that do not have a defined property)" do
+      @widget['some_undefined_prop'] = 3.14159
+      @widget.attributes.should_not include('some_undefined_prop')
+    end
+  end
+
+  describe "#raw_attributes" do
+    it "returns a hash representation, including attributes for undefined properties" do
+      @widget['some_undefined_prop'] = 17
+      @widget.raw_attributes.should == {
+        'name'                => 'widget',
+        'size'                => nil,
+        'manufactured'        => false,
+        'shipped_at'          => nil,
+        'some_undefined_prop' => 17
+      }
+    end
+  end
+
+  it "should load attributes from mass assignment" do
+    @widget.attributes = {"name" => "Riak", "size" => 100000 }
+    @widget.name.should == "Riak"
+    @widget.size.should == 100000
+  end
+
+  it "should assign attributes on initialization" do
+    @widget = Widget.new(:name => "Riak")
+    @widget.name.should == "Riak"
+  end
+
+  it "should have no changed attributes after initialization" do
+    @widget = Widget.new(:name => "Riak")
+    @widget.changes.should be_blank
+  end
+
+  it "should allow adding to the @attributes hash for attributes that do not exist" do
+    @widget = Widget.new
+    @widget['foo'] = 'bar'
+    @widget.instance_eval { @attributes['foo'] }.should == 'bar'
+  end
+
+  it "should allow reading from the @attributes hash for attributes that do not exist" do
+    @widget = Widget.new
+    @widget['foo'] = 'bar'
+    @widget['foo'].should == 'bar'
+  end
+
+  it "should allow a block upon initialization to set attributes protected from mass assignment" do
+    @widget = Widget.new { |w| w.key = 'some-key' }
+    @widget.key.should == 'some-key'
+  end
+
+  it "should raise an argument error when assigning a non hash to attributes" do
+    @widget = Widget.new
+    lambda { @widget.attributes = nil }.should raise_error(ArgumentError)
+  end
+
+  it "should protect attributes from mass assignment when initialized" do
+    @widget = Widget.new(:manufactured => true)
+    @widget.manufactured.should be_false
+  end
+
+  it "should protect attributes from mass assignment by default" do
+    @widget = Widget.new
+    @widget.attributes = { :manufactured => true }
+    @widget.manufactured.should be_false
+  end
+
+  it "should allow protected attributes to be mass assigned via raw_attributes=" do
+    @widget = Widget.new
+    @widget.send(:raw_attributes=, { :manufactured => true })
+    @widget.manufactured.should be_true
+  end
+
+  it "should allow mass assigning arbitrary attributes via raw_attributes" do
+    @widget = Widget.new
+    @widget.__send__(:raw_attributes=, :explode => '?BOOM')
+    @widget[:explode].should eq('?BOOM')
+  end
+
+  it "should raise an ArgumentError with an undefined property message when mass assigning a property that doesn't exist" do
+    lambda { @widget = Widget.new(:explode => '?BOOM') }.should raise_error(ArgumentError, %q[Undefined property :explode for class 'Widget'])
+  end
+
+end

data/spec/ripple/bucket_access_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Ripple::Document::BucketAccess do
+  require 'support/models/invoice'
+  require 'support/models/late_invoice'
+  require 'support/models/paid_invoice'
+
+  it "should use the plural model name as the bucket name" do
+    Invoice.bucket_name.should == "invoices"
+  end
+
+  it "should use the parent bucket name by default (SBI)" do
+    LateInvoice.bucket_name.should == "invoices"
+  end
+
+  it "should allow a class to set the bucket name" do
+    PaidInvoice.bucket_name.should == "paid"
+  end
+
+  it "should allow access to the bucket" do
+    Invoice.bucket.should be_kind_of(Riak::Bucket)
+    Invoice.bucket.client.should == Ripple.client
+    Invoice.bucket.name.should == "invoices"
+  end
+end