terrestrial 0.1.0 → 0.1.1

data/spec/sequel_mapper/collection_mutability_proxy_spec.rb

@@ -0,0 +1,135 @@
+require "spec_helper"
+
+require "terrestrial/collection_mutability_proxy"
+
+RSpec.describe Terrestrial::CollectionMutabilityProxy do
+  let(:proxy) {
+    Terrestrial::CollectionMutabilityProxy.new(lazy_enum)
+  }
+
+  let(:lazy_enum) { data_set.each.lazy }
+  let(:data_set) { (0..9) }
+
+  def id
+    ->(x) { x }
+  end
+
+  it "is Enumerable" do
+    expect(proxy).to be_a(Enumerable)
+  end
+
+  describe "#to_a" do
+    it "is equivalent to the original enumeration" do
+      expect(proxy.map(&id)).to eq(data_set.to_a)
+    end
+  end
+
+  describe "#to_ary" do
+    it "is equivalent to the original enumeration" do
+      expect(proxy.to_ary).to eq(data_set.to_a)
+    end
+
+    it "implicitly coerces to Array" do
+      expect([-1].concat(proxy)).to eq([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    end
+  end
+
+  describe "#each" do
+    context "when called with a block" do
+      it "returns self" do
+        expect(proxy.each(&id)).to eq(proxy)
+      end
+
+      it "yields each element to the block" do
+        yielded = []
+
+        proxy.each do |element|
+          yielded.push(element)
+        end
+
+        expect(yielded).to eq(data_set.to_a)
+      end
+
+      context "when calling each more than once" do
+        before do
+          proxy.each { |x| nil }
+          proxy.each { |x| nil }
+        end
+
+        it "rewinds the enumeration on each call" do
+          expect(proxy.map(&id)).to eq(data_set.to_a)
+        end
+      end
+    end
+
+    context "when a new element is pushed into the collection" do
+      let(:new_element) { double(:new_element) }
+
+      before do
+        proxy.push(new_element)
+      end
+
+      it "adds the new element to the enumeration" do
+        expect(proxy.to_a.last).to eq(new_element)
+      end
+    end
+  end
+
+  describe "#each_loaded" do
+    context "when called with a block" do
+      it "returns self" do
+        expect(proxy.each(&id)).to eq(proxy)
+      end
+
+      it "yields each element to the block" do
+        yielded = []
+
+        proxy.each do |element|
+          yielded.push(element)
+        end
+
+        expect(yielded).to eq(data_set.to_a)
+      end
+    end
+
+    context "when called without a block" do
+      it "returns an enumerator" do
+        expect(proxy.each).to be_a(Enumerator)
+      end
+    end
+  end
+
+  describe "#delete" do
+    it "returns self" do
+      expect(proxy.delete(3)).to be(proxy)
+    end
+
+    context "after removing a element from the enumeration" do
+      before do
+        proxy.delete(3)
+      end
+
+      it "skips that element in the enumeration" do
+        expect(proxy.map(&id)).to eq([0,1,2,4,5,6,7,8,9])
+      end
+    end
+  end
+
+  describe "#push" do
+    context "after pushing another element into the enumeration" do
+      before do
+        proxy.push(new_value)
+      end
+
+      let(:new_value) { double(:new_value) }
+
+      it "does not alter the other elements" do
+        expect(proxy.map(&id)[0..-2]).to eq([0,1,2,3,4,5,6,7,8,9])
+      end
+
+      it "appends the element to the enumeration" do
+        expect(proxy.map(&id).last).to eq(new_value)
+      end
+    end
+  end
+end

data/spec/sequel_mapper/deleted_record_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+require "terrestrial/deleted_record"
+
+RSpec.describe Terrestrial::DeletedRecord do
+  subject(:record) {
+    Terrestrial::DeletedRecord.new(namespace, identity, raw_data)
+  }
+
+  let(:namespace) { double(:namespace) }
+
+  let(:identity) {
+    { id: id }
+  }
+
+  let(:raw_data) {
+    {
+      name: name,
+    }
+  }
+
+  let(:id) { double(:id) }
+  let(:name) { double(:name) }
+
+  describe "#if_delete" do
+    it "invokes the callback" do
+      expect { |callback|
+        record.if_delete(&callback)
+      }.to yield_with_args(record)
+    end
+  end
+
+  describe "#==" do
+    context "with another record that deletes" do
+      let(:comparitor) {
+        record.merge({})
+      }
+
+      it "is equal" do
+        expect(record.==(comparitor)).to be(true)
+      end
+    end
+
+    context "with another record that does not delete" do
+      let(:comparitor) {
+        Class.new(Terrestrial::AbstractRecord) do
+          protected
+          def operation
+            :something_else
+          end
+        end
+      }
+
+      it "is not equal" do
+        expect(record.==(comparitor)).to be(false)
+      end
+    end
+  end
+end

data/spec/sequel_mapper/dirty_map_spec.rb

@@ -0,0 +1,214 @@
+require "spec_helper"
+
+require "terrestrial/dirty_map"
+require "terrestrial/upserted_record"
+require "terrestrial/deleted_record"
+
+RSpec.describe Terrestrial::DirtyMap do
+  subject(:dirty_map) {
+    Terrestrial::DirtyMap.new(storage)
+  }
+
+  let(:storage) { {} }
+
+  let(:loaded_record) {
+    create_record( namespace, identity_fields, attributes, depth)
+  }
+
+  let(:namespace) { :table_name }
+  let(:identity_fields) { [:id] }
+  let(:depth) { 0 }
+
+  let(:attributes) {
+    {
+      id: "record/id",
+      name: "record/name",
+      email: "record/email",
+    }
+  }
+
+  describe "#load" do
+    it "adds the record to its storage" do
+      dirty_map.load(loaded_record)
+
+      expect(storage.values).to include(loaded_record)
+    end
+
+    it "returns the loaded record" do
+      expect(dirty_map.load(loaded_record)).to eq(loaded_record)
+    end
+  end
+
+  describe "#dirty" do
+    let(:clean_record) {
+      create_record(namespace, identity_fields, attributes, depth)
+    }
+
+    let(:dirty_record) {
+      create_record(
+        namespace,
+        identity_fields,
+        attributes.merge(name: "record/dirty_name"),
+        depth,
+      )
+    }
+
+    context "when the record has not been loaded (new record)" do
+      it "return true" do
+        expect(dirty_map.dirty?(clean_record)).to be(true)
+      end
+    end
+
+    context "when a record with same identity has been loaded (existing record)" do
+      before do
+        dirty_map.load(loaded_record)
+      end
+
+      context "when the record is unchanged" do
+        it "returns false" do
+          expect(dirty_map.dirty?(clean_record)).to be(false)
+        end
+      end
+
+      context "when the record's attributes are changed" do
+        it "returns true" do
+          expect(dirty_map.dirty?(dirty_record)).to be(true)
+        end
+      end
+
+      context "when the record is deleted" do
+        let(:deleted_record) {
+          Terrestrial::DeletedRecord.new(
+            namespace,
+            identity_fields,
+            attributes,
+            depth,
+          )
+        }
+
+        it "is always dirty" do
+          expect(dirty_map.dirty?(deleted_record)).to be(true)
+        end
+      end
+
+      context "when the record's attributes hash is mutated" do
+        before do
+          attributes.merge!(name: "new_value")
+        end
+
+        it "returns true" do
+          expect(dirty_map.dirty?(clean_record)).to be(true)
+        end
+      end
+
+      context "when a record's string value is mutated" do
+        before do
+          attributes.fetch(:name) << "MUTANT"
+        end
+
+        it "returns true" do
+          expect(dirty_map.dirty?(clean_record)).to be(true)
+        end
+      end
+
+      context "when record contains an unchanged subset of the fields loaded" do
+        let(:partial_record) {
+          create_record(
+            namespace,
+            identity_fields,
+            partial_clean_attrbiutes,
+            depth,
+          )
+        }
+
+        let(:partial_clean_attrbiutes) {
+          attributes.reject { |k, _v| k == :email }
+        }
+
+        it "return false" do
+          expect(dirty_map.dirty?(partial_record)).to be(false)
+        end
+      end
+
+      context "when record contains a changed subset of the fields loaded" do
+        let(:partial_record) {
+          create_record(
+            namespace,
+            identity_fields,
+            partial_dirty_attrbiutes,
+            depth,
+          )
+        }
+
+        let(:partial_dirty_attrbiutes) {
+          attributes
+            .reject { |k, _v| k == :email }
+            .merge(name: "record/changed_name")
+        }
+
+        it "return false" do
+          expect(dirty_map.dirty?(partial_record)).to be(true)
+        end
+      end
+
+      context "when record contains an unchanged superset of the fields loaded" do
+        let(:super_record) {
+          create_record(
+            namespace,
+            identity_fields,
+            super_clean_attributes,
+            depth,
+          )
+        }
+
+        let(:super_clean_attributes) {
+          attributes.merge(unknown_key: "record/unknown_value")
+        }
+
+        it "return true" do
+          expect(dirty_map.dirty?(super_record)).to be(true)
+        end
+      end
+    end
+
+    context "#reject_unchanged_fields" do
+      context "when the record has not been loaded (new record)" do
+        it "returns an eqiuivalent record" do
+          expect(dirty_map.reject_unchanged_fields(dirty_record))
+            .to eq(dirty_record)
+        end
+      end
+
+      context "when a record with same identity has been loaded (existing record)" do
+        before do
+          dirty_map.load(loaded_record)
+        end
+
+        context "with a equivalent record" do
+          it "returns an empty record" do
+            expect(dirty_map.reject_unchanged_fields(clean_record)).to be_empty
+          end
+        end
+
+        context "a record with a changed field" do
+          it "returns a record containing just that field" do
+            expect(
+              dirty_map
+                .reject_unchanged_fields(dirty_record)
+                .non_identity_attributes
+            ).to eq( name: "record/dirty_name" )
+          end
+        end
+      end
+    end
+  end
+
+  def create_record(namespace, identity_fields, attributes, depth)
+    Terrestrial::UpsertedRecord.new(
+      namespace,
+      identity_fields,
+      attributes,
+      depth,
+    )
+  end
+end

data/spec/sequel_mapper/lazy_collection_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+require "terrestrial/lazy_collection"
+
+RSpec.describe Terrestrial::LazyCollection do
+  let(:proxy) {
+    Terrestrial::LazyCollection.new(
+      database_enum,
+      loader,
+      mapper,
+    )
+  }
+
+  let(:row1) { double(:row1) }
+  let(:row2) { double(:row2) }
+  let(:object1) { double(:object1) }
+  let(:object2) { double(:object2) }
+  let(:row_object_map) {
+    {
+      row1 => object1,
+      row2 => object2,
+    }
+  }
+  let(:collection_size) { row_object_map.size }
+
+  let(:database_enum) { [row1, row2].each.lazy }
+
+  let(:mapper) { double(:mapper) }
+
+  let(:loader_count) { @loader_count }
+  let(:loader) {
+    @loader_count = 0
+
+    ->(row) {
+      @loader_count = @loader_count + 1
+      row_object_map.fetch(row)
+    }
+  }
+
+  it "is Enumerable" do
+    expect(proxy).to be_a(Enumerable)
+  end
+
+  describe "#to_ary" do
+    it "is equivalent to the original enumeration" do
+      expect(proxy.to_ary).to eq([object1, object2])
+    end
+
+    it "implicitly coerces to Array" do
+      new_object = Object.new
+
+      expect([new_object].concat(proxy)).to eq([new_object, object1, object2])
+    end
+  end
+
+  describe "#each" do
+    it "iterates over all elements of the database_enum" do
+      elements = []
+      proxy.each { |x| elements.push(x) }
+
+      expect(elements).to eq([object1, object2])
+    end
+
+    context "when the collection is not loaded" do
+      it "loads the collection on first call" do
+        proxy.each { |x| x }
+
+        expect(loader_count).to eq(collection_size)
+      end
+    end
+
+    context "when the collection has already loaded (second call to #each)" do
+      before do
+        proxy.each { |x| x }
+      end
+
+      it "does not load a second time" do
+        expect {
+          proxy.each { |x| x }
+        }.not_to change { loader_count }
+      end
+    end
+
+    context "when #first has been called beforehand" do
+      before do
+        proxy.first
+      end
+
+      it "does not reload the first element of the collection" do
+        proxy.each { |x| x }
+
+        expect(loader_count).to eq(collection_size)
+      end
+
+      it "iterates over all elements" do
+        elements = []
+        proxy.each { |x| elements.push(x) }
+
+        expect(elements).to eq([object1, object2])
+      end
+    end
+
+    context "when drop has been called beforehand" do
+      it "loads each object just once" do
+        proxy.drop(1).each { |x| x }
+
+        expect(loader_count).to eq(collection_size)
+      end
+    end
+  end
+
+  describe "#first" do
+    it "loads only the first object" do
+      proxy.first
+
+      expect(loader_count).to eq(1)
+    end
+  end
+end

data/spec/sequel_mapper/lazy_object_proxy_spec.rb

@@ -0,0 +1,140 @@
+require "spec_helper"
+
+require "terrestrial/lazy_object_proxy"
+
+RSpec.describe Terrestrial::LazyObjectProxy do
+  subject(:proxy) {
+    Terrestrial::LazyObjectProxy.new(
+      object_loader,
+      key_fields,
+    )
+  }
+
+  let(:id) { double(:id) }
+  let(:key_fields)      { { id: id } }
+  let(:object_loader)   { double(:object_loader, call: proxied_object) }
+  let(:proxied_object)  { double(:proxied_object, name: name) }
+  let(:name)            { double(:name) }
+
+  describe "#__getobj__" do
+    it "loads the object" do
+      proxy.__getobj__
+
+      expect(object_loader).to have_received(:call)
+    end
+
+    it "returns the proxied object" do
+      expect(proxy.__getobj__).to be(proxied_object)
+    end
+  end
+
+  context "when no method is called on it" do
+    it "does not call the loader" do
+      proxy
+
+      expect(object_loader).not_to have_received(:call)
+    end
+  end
+
+  context "when a missing method is called on the proxy" do
+    it "is a true decorator" do
+      expect(proxied_object).to receive(:arbitrary_message)
+
+      proxy.arbitrary_message
+    end
+
+    it "loads the object" do
+      proxy.name
+
+      expect(object_loader).to have_received(:call)
+    end
+
+    it "returns delegates the message to the object" do
+      args = [ double, double ]
+      proxy.name(*args)
+
+      expect(proxied_object).to have_received(:name).with(*args)
+    end
+
+    it "returns the objects return value" do
+      expect(proxy.name).to eq(name)
+    end
+
+    context "when calling a method twice" do
+      it "loads the object once" do
+        proxy.name
+        proxy.name
+
+        expect(object_loader).to have_received(:call)
+      end
+    end
+  end
+
+  describe "#loaded?" do
+    context "before the object is loaded" do
+      it "returns false" do
+        expect(proxy).not_to be_loaded
+      end
+    end
+
+    context "after the object is loaded" do
+      def force_object_load(object)
+        object.__getobj__
+      end
+
+      before { force_object_load(proxy) }
+
+      it "returns true" do
+        expect(proxy).to be_loaded
+      end
+    end
+  end
+
+  describe "key fields" do
+    context "when key fields are provided before load (such as from foreign key)" do
+      it "does not load the object when that field is accessed" do
+        proxy.id
+
+        expect(proxy).not_to be_loaded
+      end
+
+      it "returns the given value" do
+        expect(proxy.id).to be(id)
+      end
+    end
+  end
+
+  describe "#respond_to?" do
+    context "when method corresponds to a key field" do
+      it "does not the load the object" do
+        proxy.respond_to?(:id)
+
+        expect(proxy).not_to be_loaded
+      end
+
+      it "repsonds to the method" do
+        expect(proxy).to respond_to(:id)
+      end
+    end
+
+    context "when the method is not a key field" do
+      it "loads the object" do
+        proxy.respond_to?(:something_arbitrary)
+
+        expect(proxy).to be_loaded
+      end
+
+      context "when lazy proxied object does respond to the method" do
+        it "responds to the method" do
+          expect(proxy).to respond_to(:name)
+        end
+      end
+
+      context "when lazy proxied object does not respond to the method" do
+        it "does not respond to the method" do
+          expect(proxy).not_to respond_to(:something_arbitrary)
+        end
+      end
+    end
+  end
+end