wyngle-ripple 0.1.0

data/spec/ripple/properties_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+
+describe Ripple::Properties do
+  # require 'support/models/email'
+
+  it "should make the model class have a property definition method" do
+    Email.should respond_to(:property)
+  end
+
+  it "should add properties to the class via the property method" do
+    Email.property :from, String
+    Email.properties.should include(:from)
+  end
+
+  it "should make the model class have a collection of properties" do
+    Email.should respond_to(:properties)
+    Email.properties.should be_kind_of(Hash)
+  end
+
+  it "should make subclasses inherit properties from the parent class" do
+    Email.properties[:foo] = "bar"
+    class Forward < Email; end
+    Forward.properties[:foo].should == "bar"
+  end
+end
+
+describe Ripple::Property do
+  it "should have a key symbol" do
+    prop = Ripple::Property.new('foo', String)
+    prop.should respond_to(:key)
+    prop.key.should == :foo
+  end
+
+  it "should have a type" do
+    prop = Ripple::Property.new('foo', String)
+    prop.should respond_to(:type)
+    prop.type.should == String
+  end
+
+  it "should capture extra options" do
+    prop = Ripple::Property.new('foo', String, 'default' => "bar")
+    prop.should respond_to(:options)
+    prop.options.should == {:default => "bar"}
+  end
+
+  it "should expose validation options" do
+    prop = Ripple::Property.new('foo', String, 'default' => "bar", :presence => true)
+    prop.validation_options.should == {:presence => true}
+  end
+
+  describe "default value" do
+    it "should be nil when not specified" do
+      prop = Ripple::Property.new('foo', String)
+      prop.default.should be_nil
+    end
+
+    it "should allow literal values" do
+      prop = Ripple::Property.new('foo', String, :default => "bar")
+      prop.default.should == "bar"
+    end
+
+    it "should cast to the proper type" do
+      prop = Ripple::Property.new('foo', String, :default => :bar)
+      prop.default.should == "bar"
+    end
+
+    it "should allow false for a Boolean" do
+      prop = Ripple::Property.new('foo', Boolean, :default => false)
+      prop.default.should == false
+    end
+
+    it "should allow lambdas for deferred evaluation" do
+      prop = Ripple::Property.new('foo', String, :default => lambda { "bar" })
+      prop.default.should == "bar"
+    end
+  end
+
+  describe "casting a value" do
+    describe "when type is Boolean" do
+      before :each do
+        @prop = Ripple::Property.new('foo', Boolean)
+      end
+
+      [0, 0.0, "", "0", [], false, "f", "FALSE"].each do |v|
+        it "should cast #{v.inspect} to false" do
+          @prop.type_cast(v).should == false
+        end
+      end
+
+      [1, 1.0, "true", "1", [1], true, "t", "TRUE"].each do |v|
+        it "should cast #{v.inspect} to true" do
+          @prop.type_cast(v).should == true
+        end
+      end
+
+      it "should not cast nil" do
+        @prop.type_cast(nil).should be_nil
+      end
+    end
+
+    describe "when type is String" do
+      before :each do
+        @prop = Ripple::Property.new('foo', String)
+      end
+
+      it "should cast anything to a string using to_s" do
+        @prop.type_cast("s").should == "s"
+        @prop.type_cast(1).should == "1"
+        @prop.type_cast(true).should == "true"
+        @prop.type_cast(false).should == "false"
+        if RUBY_VERSION < "1.9"
+          @prop.type_cast([]).should == ""
+        else
+          @prop.type_cast([]).should == "[]"
+        end
+      end
+
+      it "should not cast nil" do
+        @prop.type_cast(nil).should be_nil
+      end
+
+    end
+
+    describe "when type is an Integer type" do
+      before :each do
+        @prop = Ripple::Property.new(:foo, Integer)
+      end
+
+      [5.0, "5", "     5", "05", Rational(10,2)].each do |v|
+        it "should cast #{v.inspect} to 5" do
+          @prop.type_cast(v).should == 5
+        end
+      end
+
+      [0.0, "0", "     000"].each do |v|
+        it "should cast #{v.inspect} to 0" do
+          @prop.type_cast(v).should == 0
+        end
+      end
+
+      it "should not cast the blank string" do
+        @prop.type_cast("").should be_nil
+        @prop.type_cast("   ").should be_nil
+      end
+
+      [true, false, [], {}, :symbol, ["something else"]].each do |v|
+        it "should raise an error casting #{v.inspect}" do
+          lambda { @prop.type_cast(v) }.should raise_error(Ripple::PropertyTypeMismatch)
+        end
+      end
+    end
+
+    describe "when type is a Float type" do
+      before :each do
+        @prop = Ripple::Property.new(:foo, Float)
+      end
+
+      [0, "0", "0.0", "    0.0"].each do |v|
+        it "should cast #{v.inspect} to 0.0" do
+          @prop.type_cast(v).should == 0.0
+        end
+      end
+
+      [5.0, "5", "     5.0", "05", Rational(10,2)].each do |v|
+        it "should cast #{v.inspect} to 5.0" do
+          @prop.type_cast(v).should == 5.0
+        end
+      end
+
+      it "should not cast the blank string" do
+        @prop.type_cast("").should be_nil
+        @prop.type_cast("   ").should be_nil
+      end
+
+      [true, false, :symbol, [], {}].each do |v|
+        it "should raise an error casting #{v.inspect}" do
+          lambda { @prop.type_cast(v) }.should raise_error(Ripple::PropertyTypeMismatch)
+        end
+      end
+    end
+
+    describe "when type is a Numeric type" do
+      before :each do
+        @prop = Ripple::Property.new(:foo, Numeric)
+      end
+
+      [5.0, "5", "      5.0", "05"].each do |v|
+        it "should cast #{v.inspect} to 5" do
+          @prop.type_cast(v).should == 5
+        end
+      end
+
+      [5.2, "5.2542", "   6.4", "0.5327284"].each do |v|
+        it "should cast #{v.inspect} to a float" do
+          @prop.type_cast(v).should be_kind_of(Float)
+        end
+      end
+
+      it "should not cast the blank string" do
+        @prop.type_cast("").should be_nil
+        @prop.type_cast("   ").should be_nil
+      end
+    end
+
+    describe "when type is a Time type" do
+      before :each do
+        @prop = Ripple::Property.new(:foo, Time)
+      end
+
+      ["Tue, 16 Mar 2010 12:00:00 -0000","2010/03/16 12:00:00 GMT", Time.utc(2010,03,16,12)].each do |v|
+        it "should cast #{v.inspect} to #{Time.utc(2010,03,16,12).inspect}" do
+          @prop.type_cast(v).should == Time.utc(2010,03,16,12)
+        end
+      end
+
+      it "should not cast blank types" do
+        @prop.type_cast([]).should be_nil
+        @prop.type_cast({}).should be_nil
+        @prop.type_cast("").should be_nil
+        @prop.type_cast("  ").should be_nil
+      end
+    end
+
+    describe "when type is a Date type" do
+      before :each do
+        @prop = Ripple::Property.new(:foo, Date)
+      end
+
+      ["Tue, 16 Mar 2010 00:00:00 -0000", "2010/03/16 12:00:00 GMT", Time.utc(2010,03,16,12), "2010/03/16"].each do |v|
+        it "should cast #{v.inspect} to 2010/03/16" do
+          @prop.type_cast(v).should == Date.civil(2010,3,16)
+        end
+      end
+
+      it "should not cast blank types" do
+        @prop.type_cast([]).should be_nil
+        @prop.type_cast({}).should be_nil
+        @prop.type_cast("").should be_nil
+        @prop.type_cast("  ").should be_nil
+      end
+    end
+
+    describe "when type is a Set type" do
+      let(:prop) { Ripple::Property.new(:foo, Set) }
+
+      it "casts an array to a a set" do
+        prop.type_cast([1]).should be_a(Set)
+        prop.type_cast([1]).to_a.should == [1]
+      end
+
+      it "does not cast nil" do
+        prop.type_cast(nil).should be_nil
+      end
+
+      it "raises an error when casting a non-enumerable" do
+        expect {
+          prop.type_cast(1)
+        }.to raise_error(Ripple::PropertyTypeMismatch)
+      end
+    end
+  end
+end

data/spec/ripple/ripple_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Ripple do
+  it "should have a client" do
+    Ripple.client.should be_kind_of(Riak::Client)
+  end
+
+  it "should have a unique client per thread" do
+    client = Ripple.client
+    th = Thread.new { Ripple.client.should_not == client }
+    th.join
+  end
+
+  it "should be configurable" do
+    Ripple.should respond_to(:config)
+  end
+
+  it "should allow setting the client manually" do
+    Ripple.should respond_to(:client=)
+    client = Riak::Client.new(:http_port => 9000)
+    Ripple.client = client
+    Ripple.client.should == client
+  end
+
+  it "should reset the client when the configuration changes" do
+    c = Ripple.client
+    Ripple.config = {:http_port => 9000}
+    Ripple.client.should_not == c
+    Ripple.client.node.http_port.should == 9000
+  end
+
+  it "should raise No Such File or Directory when given a bad configuration file" do
+    lambda { Ripple.load_config('not-here') }.should raise_error(Ripple::MissingConfiguration)
+  end
+
+  it "should pass an empty hash into configure if the configuration file is missing the key" do
+    Ripple.should_receive(:config=).with({})
+    Ripple.load_config(File.join(File.dirname(__FILE__), '..', 'fixtures', 'config.yml'), [:ripple, 'not-here'])
+  end
+
+  it "should select the configuration hash from the config keys provided" do
+    Ripple.load_config(File.join(File.dirname(__FILE__), '..', 'fixtures', 'config.yml'), ['ripple_rails', 'development'])
+    Ripple.client.node.http_port.should == 9001
+    Ripple.client.node.host.should == '127.0.0.1'
+  end
+
+  it "should apply the configuration under the ripple key" do
+    Ripple.load_config(File.join(File.dirname(__FILE__), '..', 'fixtures', 'config.yml'))
+    Ripple.client.node.http_port.should == 9000
+    Ripple.client.node.host.should == 'localhost'
+  end
+
+  describe "date format" do
+    before { @date_format = Ripple.date_format }
+    after  { Ripple.date_format = @date_format }
+
+    it "should default to :iso8601" do
+      Ripple.date_format.should == :iso8601
+    end
+
+    it "should allow setting via the config" do
+      Ripple.config = {"date_format" => "rfc822"}
+      Ripple.date_format.should == :rfc822
+    end
+
+    it "should allow setting manually" do
+      Ripple.date_format = "rfc822"
+      Ripple.date_format.should == :rfc822
+    end
+  end
+end

data/spec/ripple/serialization_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Ripple::Serialization do
+  # require 'support/models/invoice'
+  # require 'support/models/note'
+  # require 'support/models/customer'
+
+  it "should provide JSON serialization" do
+    Invoice.new.should respond_to(:to_json)
+  end
+
+  context "when serializing" do
+    it "should include attributes" do
+      Note.new(:text => "Dear Jane,...").serializable_hash.should include('text')
+    end
+
+    it "should include the document key" do
+      doc = Invoice.new
+      doc.key = "1"
+      doc.serializable_hash['key'].should == "1"
+    end
+
+    it "should be able to exclude the document key" do
+      doc = Invoice.new
+      doc.key = "1"
+      doc.serializable_hash(:except => [:key]).should_not include("key")
+    end
+
+    it "should include embedded documents by default" do
+      doc = Invoice.new(:note => {:text => "Dear customer,..."}).serializable_hash
+      doc['note'].should eql({'text' => "Dear customer,..."})
+    end
+
+    it "should exclude the _type field from embedded documents" do
+      doc = Invoice.new
+      doc.note = Note.new :text => "Dear customer,..."
+      doc.serializable_hash['note'].should_not include("_type")
+    end
+
+    it "should exclude specified attributes" do
+      hash = Invoice.new.serializable_hash(:except => [:created_at])
+      hash.should_not include('created_at')
+    end
+
+    it "should limit to specified attributes" do
+      hash = Invoice.new.serializable_hash(:only => [:created_at])
+      hash.should include('created_at')
+      hash.should_not include('updated_at')
+    end
+  end
+end

data/spec/ripple/timestamps_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+shared_examples_for "a timestamped model" do
+  it "adds a created_at property" do
+    subject.should respond_to(:created_at)
+  end
+
+  it "adds an updated_at property" do
+    subject.should respond_to(:updated_at)
+  end
+
+  it "sets the created_at timestamp when the object is initialized" do
+    subject.created_at.should_not be_nil
+  end
+
+  it "does not set the updated_at timestamp when the object is initialized" do
+    subject.updated_at.should be_nil
+  end
+
+  it "sets the updated_at timestamp when the object is saved" do
+    record_to_save.save
+    subject.updated_at.should_not be_nil
+  end
+
+  it "updates the updated_at timestamp when the object is updated" do
+    record_to_save.save
+    start = subject.updated_at
+    record_to_save.save
+    subject.updated_at.should > start
+  end
+
+  it "does not update the created_at timestamp when the object is updated" do
+    record_to_save.save
+    start = subject.created_at
+    record_to_save.save
+    subject.created_at.should == start
+  end
+end
+
+describe Ripple::Timestamps do
+  # require 'support/models/clock'
+
+  before(:each) { clock.robject.stub!(:store).and_return(true) }
+
+  context "for a Ripple::Document" do
+    it_behaves_like "a timestamped model" do
+      subject { Clock.new }
+      let(:clock) { subject }
+      let(:record_to_save) { subject }
+    end
+  end
+
+  context "for a Ripple::EmbeddedDocument when directly saved" do
+    it_behaves_like "a timestamped model" do
+      let(:clock) { Clock.new }
+      subject { Mode.new }
+      let(:record_to_save) { subject }
+
+      before(:each) do
+        clock.modes << subject
+      end
+    end
+  end
+
+  context "for a Ripple::EmbeddedDocument when the parent is saved" do
+    it_behaves_like "a timestamped model" do
+      let(:clock) { Clock.new }
+      subject { Mode.new }
+      let(:record_to_save) { clock }
+
+      before(:each) do
+        clock.modes << subject
+      end
+
+      it "should pass-through property options to the created properties" do
+        [:created_at, :updated_at].each do |p|
+          subject.class.properties[p].validation_options.should include(:presence)
+          subject.class.indexes[p].should be
+        end
+      end
+    end
+  end
+end