reorm 0.1.0

data/spec/reorm/field_path_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe Reorm::FieldPath do
+  describe "#name()" do
+    subject {
+      Reorm::FieldPath.new(:first, :second, :third)
+    }
+
+    it "returns the last element of the field path as the name" do
+      expect(subject.name).to eq(:third)
+    end
+  end
+
+  describe "#value()" do
+    it "fetches the value from the input" do
+      field = Reorm::FieldPath.new(:first)
+      expect(field.value({first: 1})).to eq(1)
+    end
+
+    it "traverses a hierarchy if one has been specified" do
+    field = Reorm::FieldPath.new(:first, :second, :third)
+    expect(field.value({first: {second: {third: 3}}})).to eq(3)
+    end
+
+    it "returns nil of the field does not exist" do
+      field = Reorm::FieldPath.new(:first, :second, :third)
+      expect(field.value({first: 1})).to be_nil
+    end
+  end
+
+  describe "#value!()" do
+    it "raises an exception if the value does not exist" do
+      field = Reorm::FieldPath.new(:first, :second, :third)
+      expect {
+        field.value!({first: 1})
+      }.to raise_exception(Reorm::Error, "Unable to locate the #{field.name} (full path: #{field}) field for an instance of the Hash class.")
+    end
+  end
+
+  describe "#exists?()" do
+    subject {
+      Reorm::FieldPath.new(:first, :second, :third)
+    }
+
+    it "returns true if the field exists within the specified document" do
+      expect(subject.exists?({first: {second: {third: 3}}})).to eq(true)
+    end
+
+    it "returns false if the field does not exist within the specified document" do
+      expect(subject.exists?({first: 1})).to eq(false)
+    end
+  end
+
+  describe "#to_s" do
+    it "returns the correct value for a simple field path" do
+      field = Reorm::FieldPath.new(:first)
+      expect(field.to_s).to eq("first")
+    end
+
+    it "returns the correct value for a more complicated field path" do
+      field = Reorm::FieldPath.new(:first, :second, :third)
+      expect(field.to_s).to eq("first -> second -> third")
+    end
+  end
+end

data/spec/reorm/model_spec.rb

@@ -0,0 +1,268 @@
+require "spec_helper"
+
+class ValidationTestModel < Reorm::Model
+	before_validate :called
+	after_validate :called
+
+	def initialize(setting=nil)
+		super(blah: setting)
+		@calls = 0
+	end
+	attr_reader :calls
+
+	def called
+		@calls += 1
+	end
+
+	def validate
+		super
+		errors.add(:blah, "has not been set") if [nil, ""].include?(blah)
+	end
+end
+
+class SaveTestModel < Reorm::Model
+	after_create :on_after_create
+	after_save :on_after_save
+	after_update :on_after_update
+	before_create :on_before_create
+	before_save :on_before_save
+	before_update :on_before_update
+
+	def initialize(properties={})
+		super(properties)
+		@events = []
+	end
+	attr_reader :events
+
+	def reset_events
+		@events = []
+	end
+
+	def on_after_create
+		@events << :after_create
+	end
+
+	def on_after_save
+		@events << :after_save
+	end
+
+	def on_after_update
+		@events << :after_update
+	end
+
+	def on_before_create
+		@events << :before_create
+	end
+
+	def on_before_save
+		@events << :before_save
+	end
+
+	def on_before_update
+		@events << :before_update
+	end
+end
+
+describe Reorm::Model do
+	describe "#valid?()" do
+		subject {
+			ValidationTestModel.new
+		}
+
+		it "returns true if the an object does not fail validation" do
+			subject.blah = 1
+			expect(subject.valid?).to eq(true)
+		end
+
+		it "returns false if an object fails validation" do
+			expect(subject.valid?).to eq(false)
+		end
+	end
+
+	describe "#validate" do
+		subject {
+			ValidationTestModel.new
+		}
+
+		it "resets the list of errors for an object" do
+			expect(subject.valid?).to eq(false)
+			expect(subject.errors.clear?).to eq(false)
+			subject.blah = 123
+			subject.validate
+			expect(subject.errors.clear?).to eq(true)
+		end
+
+		it "fires a before and after validation events when called" do
+			subject.validate
+			expect(subject.calls).to eq(2)
+		end
+	end
+
+	describe "#save()" do
+		describe "for a previously unsaved object" do
+			subject {
+				SaveTestModel.new(one: 1, two: 2, three: 3)
+			}
+
+			it "creates a record when called on a valid object" do
+				subject.save
+				expect(subject.id).not_to be_nil
+				record = nil
+				Reorm.connection do |connection|
+					record = r.table(subject.table_name).get(subject.id).run(connection)
+				end
+				expect(record).not_to be_nil
+				expect(record["id"]).to eq(subject.id)
+				expect(record["one"]).to eq(subject.one)
+				expect(record["two"]).to eq(subject.two)
+				expect(record["three"]).to eq(subject.three)
+			end
+
+			it "fires the before create, before save, after save and after create events" do
+				subject.save
+				expect(subject.events).to eq([:before_create, :before_save, :after_save, :after_create])
+			end
+
+			it "raises an exception if the object is invalid and validation is required" do
+				expect {
+					ValidationTestModel.new(nil).save
+				}.to raise_exception(Reorm::Error, "Validation error encountered saving an instance of the ValidationTestModel class.")
+			end
+
+			it "does not raises an exception if the object is invalid but validation is off" do
+				expect {
+					ValidationTestModel.new(nil).save(false)
+				}.not_to raise_exception
+			end
+		end
+
+		describe "for a previously saved object" do
+			subject {
+				SaveTestModel.new(one: 1, two: 2, three: 3)
+			}
+
+			before do
+				subject.save
+				subject.reset_events
+			end
+
+			it "updates the objects record when called on a valid object" do
+				subject.two = "TWO"
+				subject.save
+				record = nil
+				Reorm.connection do |connection|
+					record = r.table(subject.table_name).get(subject.id).run(connection)
+				end
+				expect(record).not_to be_nil
+				expect(record["id"]).to eq(subject.id)
+				expect(record["one"]).to eq(subject.one)
+				expect(record["two"]).to eq(subject.two)
+				expect(record["three"]).to eq(subject.three)
+			end
+
+			it "fires the before update, before save, after save and after update events" do
+				subject.save
+				expect(subject.events).to eq([:before_update, :before_save, :after_save, :after_update])
+			end
+
+			it "raises an exception if the object is invalid and validation is required" do
+				model = ValidationTestModel.new(1)
+				model.save
+				model.blah = nil
+				expect {
+					model.save
+				}.to raise_exception(Reorm::Error, "Validation error encountered saving an instance of the ValidationTestModel class.")
+			end
+
+			it "does not raises an exception if the object is invalid but validation is off" do
+				model = ValidationTestModel.new(1)
+				model.save
+				model.blah = nil
+				expect {
+					model.save(false)
+				}.not_to raise_exception
+			end
+		end
+	end
+
+	describe "#[]()" do
+		subject {
+			SaveTestModel.new(one: 1, two: "Two")
+		}
+
+		it "returns the value of the named property if it exists" do
+			expect(subject[:one]).to eq(1)
+			expect(subject[:two]).to eq("Two")
+		end
+
+		it "returns nil if the named property does not exist" do
+			expect(subject[:blah]).to be_nil
+		end
+	end
+
+	describe "#[]=()" do
+		subject {
+			SaveTestModel.new(one: 1, two: "Two")
+		}
+
+    it "assigns the property value if it does not exist" do
+			subject[:three] = 3
+			expect(subject.three).to eq(3)
+		end
+
+		it "updates the property value if it does exist" do
+			subject[:one] = "One"
+			expect(subject[:one]).to eq("One")
+		end
+	end
+
+	describe "#create()" do
+		let(:standin) {
+			SaveTestModel.new
+		}
+
+		it "creates and saves an instance of the specified class" do
+			expect(standin).to receive(:save)
+			expect(SaveTestModel).to receive(:new).and_return(standin)
+			expect(SaveTestModel.create).to eq(standin)
+		end
+	end
+
+	describe "#all()" do
+		before do
+			SaveTestModel.create(one: 1, two: 2)
+			SaveTestModel.create(one: 3, two: 4)
+			SaveTestModel.create(one: 5, two: 6)
+		end
+
+		subject {
+			SaveTestModel
+		}
+
+		it "returns a cursor for the model records" do
+			cursor = subject.all
+			expect(cursor).not_to be_nil
+			expect(cursor.class).to eq(Reorm::Cursor)
+			expect(cursor.inject([]) {|list, entry| list << entry.one}.sort).to eq([1,3,5])
+		end
+	end
+
+	describe "#filter()" do
+		before do
+			SaveTestModel.create(one: 1, two: 2)
+			SaveTestModel.create(one: 3, two: 4)
+			SaveTestModel.create(one: 5, two: 6)
+		end
+
+		subject {
+			SaveTestModel
+		}
+
+		it "returns a cursor for the model records" do
+			cursor = subject.filter(two: 4)
+			expect(cursor).not_to be_nil
+			expect(cursor.class).to eq(Reorm::Cursor)
+			expect(cursor.inject([]) {|list, entry| list << entry.one}.sort).to eq([3])
+		end
+	end
+end

data/spec/reorm/modules/event_source_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+class EventSourceTest
+  include Reorm::EventHandler
+  include Reorm::EventSource
+  extend Reorm::EventHandler
+  extend Reorm::EventSource
+
+  def initialize
+    @count = 0
+  end
+  attr_reader :count
+
+  def reset
+    @count = 0
+  end
+
+  def event_handler
+    @count += 1
+  end
+end
+
+describe EventSourceTest do
+  subject {
+    EventSourceTest.new
+  }
+
+  before do
+    subject.reset
+  end
+
+  describe "#fire_events()" do
+    describe "called at the instance level" do
+      it "calls methods assigned to events when those events are fired" do
+        subject.before_create :event_handler
+        subject.fire_events(events: [:before_create])
+        expect(subject.count).to eq(1)
+      end
+    end
+
+    describe "called at the class level" do
+      it "calls methods assigned to events when those events are fired" do
+        EventSourceTest.before_create :event_handler
+        EventSourceTest.fire_events({target: subject, events: [:before_create]})
+        expect(subject.count).to eq(1)
+      end
+    end
+  end
+end

data/spec/reorm/modules/table_backed_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+class TableBackedClass
+  include Reorm::TableBacked
+end
+
+describe TableBackedClass do
+  describe "class level methods" do
+    class TableBackedClass1
+      include Reorm::TableBacked
+      table_name "my_table_1"
+      primary_key :other
+    end
+
+    subject {
+      TableBackedClass1
+    }
+
+    it "allows the table name to be set and retrieved at the class level" do
+      expect(subject.table_name).to eq("my_table_1")
+    end
+
+    it "allows the primary key to be set and retrieved at the class leve" do
+      expect(subject.primary_key).to eq(:other)
+    end
+  end
+
+  describe "instance level methods" do
+    class TableBackedClass2
+      include Reorm::TableBacked
+    end
+
+    subject {
+      TableBackedClass2.new
+    }
+
+    it "allows the table name to be retrieved at the instance level" do
+      expect(subject.table_name).to eq("table_backed_class2s")
+    end
+
+    it "allows the primary key to be set and retrieved at the instance level" do
+      instance = TableBackedClass.new
+      expect(subject.primary_key).to eq(:id)
+    end
+  end
+end

data/spec/reorm/modules/timestamped_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+class TimestampedTestClass < Reorm::Model
+	include Reorm::Timestamped
+end
+
+describe Reorm::Timestamped do
+	subject {
+		TimestampedTestClass
+	}
+
+	it "set the timestamp fields when a record is created" do
+		record = subject.create(label: "First")
+		expect(record.created_at).not_to be_nil
+		expect(record.updated_at).to be_nil
+	end
+
+	it "set the update_at field when a record is updated" do
+		record = subject.create(label: "Second")
+		created = record.created_at.to_i
+		sleep(0.2)
+
+		record.label = "Updated"
+		record.save
+		expect(record.created_at.to_i).to eq(created)
+		expect(record.updated_at).not_to be_nil
+	end
+end

data/spec/reorm/modules/validation_modules_spec.rb

@@ -0,0 +1,157 @@
+require "spec_helper"
+
+class ValidationsTestClass < Reorm::Model
+  include Reorm::Validations
+
+  def initialize(properties={})
+    super(properties)
+    @errors = Reorm::PropertyErrors.new
+  end
+  attr_reader :errors
+
+  def include?(property)
+    to_h.include?(property)
+  end
+end
+
+describe Reorm::Validations do
+  subject {
+    ValidationsTestClass.new
+  }
+  let(:path) {
+    "one -> two -> three".to_sym
+  }
+
+  describe "#validate_presence_of()" do
+    it "does not set an error if the field value is set" do
+      subject.one = {two: {three: 3}}
+      subject.validate_presence_of([:one, :two, :three])
+      expect(subject.errors.clear?).to eq(true)
+    end
+
+    it "sets an error if the object does not possess the field value" do
+      subject.validate_presence_of([:one, :two, :three])
+      expect(subject.errors.clear?).to eq(false)
+      expect(subject.errors).to include(path)
+      expect(subject.errors.messages(path)).to include("cannot be blank.")
+    end
+
+    it "sets an error if the object does possess the field value but its a blank string" do
+      subject.one = {two: {three: ""}}
+      subject.validate_presence_of([:one, :two, :three])
+      expect(subject.errors.clear?).to eq(false)
+      expect(subject.errors).to include(path)
+      expect(subject.errors.messages(path)).to include("cannot be blank.")
+    end
+
+    it "sets an error if the object does possess the field value but its nil" do
+      subject.one = {two: {three: nil}}
+      subject.validate_presence_of([:one, :two, :three])
+      expect(subject.errors.clear?).to eq(false)
+      expect(subject.errors).to include(path)
+      expect(subject.errors.messages(path)).to include("cannot be blank.")
+    end
+  end
+
+  describe "#validate_length_of()" do
+    describe "with a minimum setting" do
+      it "does not set an error if the object as a field value that exceeds the minimum length" do
+        subject.one = {two: {three: "12345"}}
+        subject.validate_length_of([:one, :two, :three], minimum: 3)
+        expect(subject.errors.clear?).to eq(true)
+      end
+
+      it "does not set an error if the object as a field value that equals the minimum length" do
+        subject.one = {two: {three: "123"}}
+        subject.validate_length_of([:one, :two, :three], minimum: 3)
+        expect(subject.errors.clear?).to eq(true)
+      end
+
+      it "does not set an error if the object does not possess the field value" do
+        subject.validate_length_of([:one, :two, :three], minimum: 3)
+        expect(subject.errors.clear?).to eq(false)
+        expect(subject.errors).to include(path)
+        expect(subject.errors.messages(path)).to include("is too short (minimum length is 3 characters).")
+      end
+
+      it "does set an error if the object has a field value that is less than the minimum length" do
+        subject.one = {two: {three: "12"}}
+        subject.validate_length_of([:one, :two, :three], minimum: 3)
+        expect(subject.errors.clear?).to eq(false)
+        expect(subject.errors).to include(path)
+        expect(subject.errors.messages(path)).to include("is too short (minimum length is 3 characters).")
+      end
+    end
+
+    describe "with a maximum setting" do
+      it "does not set an error if the object as a field value that is less than the maximum length" do
+        subject.one = {two: {three: "12"}}
+        subject.validate_length_of([:one, :two, :three], maximum: 3)
+        expect(subject.errors.clear?).to eq(true)
+      end
+
+      it "does not set an error if the object as a field value that equals the maximum length" do
+        subject.one = {two: {three: "123"}}
+        subject.validate_length_of([:one, :two, :three], maximum: 3)
+        expect(subject.errors.clear?).to eq(true)
+      end
+
+      it "does not set an error if the object does not possess the field value" do
+        subject.validate_length_of([:one, :two, :three], maximum: 3)
+        expect(subject.errors.clear?).to eq(true)
+      end
+
+      it "does set an error if the object has a field value that is greater than the maximum length" do
+        subject.one = {two: {three: "1234"}}
+        subject.validate_length_of([:one, :two, :three], maximum: 3)
+        expect(subject.errors.clear?).to eq(false)
+        expect(subject.errors).to include(path)
+        expect(subject.errors.messages(path)).to include("is too long (maximum length is 3 characters).")
+      end
+    end
+  end
+
+  describe "#validate_inclusion_of()" do
+    it "does not set an error if the object field value is one of the permitted set" do
+      subject.one = {two: {three: 3}}
+      subject.validate_inclusion_of([:one, :two, :three], 1, 2, 3, 4, 5)
+      expect(subject.errors.clear?).to eq(true)
+    end
+
+    it "does set an error if the object does not possess the field value" do
+      subject.validate_inclusion_of([:one, :two, :three], 1, 2, 3, 4, 5)
+      expect(subject.errors.clear?).to eq(false)
+      expect(subject.errors).to include(path)
+      expect(subject.errors.messages(path)).to include("is not set to one of its permitted values.")
+    end
+
+    it "does set an error if the object field value is not one of the permitted set" do
+      subject.one = {two: {three: 17}}
+      subject.validate_inclusion_of([:one, :two, :three], 1, 2, 3, 4, 5)
+      expect(subject.errors.clear?).to eq(false)
+      expect(subject.errors).to include(path)
+      expect(subject.errors.messages(path)).to include("is not set to one of its permitted values.")
+    end
+  end
+
+  describe "#validate_exclusion_of()" do
+    it "does not set an error if the object field value is not one of the excluded set" do
+      subject.one = {two: {three: 10}}
+      subject.validate_exclusion_of([:one, :two, :three], 1, 2, 3, 4, 5)
+      expect(subject.errors.clear?).to eq(true)
+    end
+
+    it "does not set an error if the object does not possess the field value" do
+      subject.validate_exclusion_of([:one, :two, :three], 1, 2, 3, 4, 5)
+      expect(subject.errors.clear?).to eq(true)
+    end
+
+    it "it does set an error if the object field value is one of the excluded set" do
+      subject.one = {two: {three: 4}}
+      subject.validate_exclusion_of([:one, :two, :three], 1, 2, 3, 4, 5)
+      expect(subject.errors.clear?).to eq(false)
+      expect(subject.errors).to include(path)
+      expect(subject.errors.messages(path)).to include("is set to an unpermitted value.")
+    end
+  end
+end