terrestrial 0.3.0 → 0.5.0

data/spec/terrestrial/adapters/sequel_postgres_adapter_spec.rb

@@ -0,0 +1,138 @@
+require "spec_helper"
+
+require "terrestrial/adapters/sequel_postgres_adapter"
+require "terrestrial/upsert_record"
+
+RSpec.describe Terrestrial::Adapters::SequelPostgresAdapter, backend: "sequel" do
+
+  let(:adapter) { Terrestrial::Adapters::SequelPostgresAdapter.new(datastore) }
+
+  describe "#tables" do
+    it "returns all table names as symbols" do
+      expect(adapter.tables).to match_array(
+        [:users, :posts, :categories, :comments, :categories_to_posts]
+      )
+    end
+  end
+
+  describe "#primary_key" do
+    context "when the table has a regular primary key" do
+      let(:table_name) { :users }
+      it "returns the primary key field(s) for a table as an array of symbols" do
+        expect(adapter.primary_key(table_name)).to eq([:id])
+      end
+    end
+
+    context "when the table has no primary key" do
+      let(:table_name) { :categories_to_posts }
+
+      it "returns an empty array" do
+        expect(adapter.primary_key(table_name)).to eq([])
+      end
+    end
+  end
+
+  describe "#unique_indexes" do
+    before(:all) do
+      adapter_support.create_tables(schema_with_unique_index.fetch(:tables))
+      adapter_support.add_unique_indexes(schema_with_unique_index.fetch(:unique_indexes))
+    end
+
+    after(:all) do
+      adapter_support.drop_tables(schema_with_unique_index.fetch(:tables).keys)
+    end
+
+    before(:each) { adapter_support.clean_table(:unique_index_table) }
+
+    context "when the table has no primary key" do
+      let(:table_name) { :unique_index_table }
+
+      it "returns an array of the indexed fields" do
+        expect(adapter.unique_indexes(table_name)).to eq([
+          [:field_one, :field_two]
+        ])
+      end
+
+      context "when there is no conflicting row" do
+        let(:record) {
+          create_record(field_one: "1", field_two: "2", text: "initial value")
+        }
+
+        it "upserts resulting in a new row" do
+          expect { adapter.upsert(record) }
+            .to change { datastore[:unique_index_table].count }
+            .by(1)
+        end
+      end
+
+      context "when a conflicting row" do
+        let(:updated_record) {
+          create_record(field_one: "1", field_two: "2", text: "new value")
+        }
+
+        before do
+          record = create_record(field_one: "1", field_two: "2", text: "initial value")
+          adapter.upsert(record)
+        end
+
+        it "upserts, updating the existing row" do
+          expect { adapter.upsert(updated_record) }
+            .to change { datastore[:unique_index_table].count }
+            .by(0)
+
+          expect(adapter[:unique_index_table].first.fetch(:text)).to eq("new value")
+        end
+      end
+    end
+
+    def create_record(values)
+      Terrestrial::UpsertRecord.new(
+        mapping,
+        object,
+        values,
+        0,
+      )
+    end
+
+    let(:object) { double(:object)
+    }
+
+    let(:mapping) {
+      double(
+        :mapping,
+        namespace: :unique_index_table,
+        primary_key: [],
+        database_owned_fields: [],
+        database_default_fields: [],
+        post_save: nil,
+      )
+    }
+
+    context "when the has a primary key and no other indexes" do
+      let(:table_name) { :users }
+
+      it "returns an empty array" do
+        expect(adapter.unique_indexes(table_name)).to eq([])
+      end
+    end
+
+    def adapter_support
+      Terrestrial::SequelTestSupport
+    end
+
+    def schema_with_unique_index
+      {
+        tables: {
+          unique_index_table: [
+            { name: :field_one, type: String, options: { null: false } },
+            { name: :field_two, type: String, options: { null: false } },
+            { name: :text, type: String, options: { null: false } },
+          ],
+        },
+        unique_indexes: [
+          [:unique_index_table, :field_one, :field_two]
+        ],
+      }
+    end
+  end
+end

data/spec/terrestrial/deleted_record_spec.rb

@@ -29,31 +29,4 @@ RSpec.describe Terrestrial::DeletedRecord do
       }.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/terrestrial/dirty_map_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 require "terrestrial/dirty_map"
-require "terrestrial/upserted_record"
+require "terrestrial/upsert_record"
 require "terrestrial/deleted_record"
 
 RSpec.describe Terrestrial::DirtyMap do
@@ -11,13 +11,24 @@ RSpec.describe Terrestrial::DirtyMap do
 
   let(:storage) { {} }
 
-  let(:record) {
-    create_record( namespace, identity_fields, attributes, depth)
+  let(:record) { create_record(mapping, attributes) }
+  let(:dirty_record) {
+    create_record( mapping, attributes.merge(name: "record/dirty_name"))
+  }
+
+  let(:mapping) {
+    double(
+      :mapping,
+      namespace: namespace,
+      primary_key: identity_fields,
+      database_owned_fields: [],
+      database_default_fields: [],
+    )
   }
 
   let(:namespace) { :table_name }
   let(:identity_fields) { [:id] }
-  let(:depth) { 0 }
+  let(:identity) { { id: "record/id" } }
 
   let(:attributes) {
     {
@@ -72,22 +83,9 @@ RSpec.describe Terrestrial::DirtyMap do
   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
+    context "when the record has not been loaded (a new record)" do
       it "return true" do
-        expect(dirty_map.dirty?(clean_record)).to be(true)
+        expect(dirty_map.dirty?(record)).to be(true)
       end
     end
 
@@ -98,7 +96,7 @@ RSpec.describe Terrestrial::DirtyMap do
 
       context "when the record is unchanged" do
         it "returns false" do
-          expect(dirty_map.dirty?(clean_record)).to be(false)
+          expect(dirty_map.dirty?(record)).to be(false)
         end
       end
 
@@ -110,12 +108,7 @@ RSpec.describe Terrestrial::DirtyMap do
 
       context "when the record is deleted" do
         let(:deleted_record) {
-          Terrestrial::DeletedRecord.new(
-            namespace,
-            identity_fields,
-            attributes,
-            depth,
-          )
+          Terrestrial::DeletedRecord.new(mapping, attributes, _depth = 0)
         }
 
         it "is always dirty" do
@@ -125,32 +118,27 @@ RSpec.describe Terrestrial::DirtyMap do
 
       context "when the record's attributes hash is mutated" do
         before do
-          attributes.merge!(name: "new_value")
+          record.attributes.merge!(name: "new_value")
         end
 
         it "returns true" do
-          expect(dirty_map.dirty?(clean_record)).to be(true)
+          expect(dirty_map.dirty?(record)).to be(true)
         end
       end
 
       context "when a record's string value is mutated" do
         before do
-          attributes.fetch(:name) << "MUTANT"
+          record.attributes.fetch(:name) << "MUTANT"
         end
 
         it "returns true" do
-          expect(dirty_map.dirty?(clean_record)).to be(true)
+          expect(dirty_map.dirty?(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,
-          )
+          create_record(mapping, partial_clean_attrbiutes)
         }
 
         let(:partial_clean_attrbiutes) {
@@ -164,12 +152,7 @@ RSpec.describe Terrestrial::DirtyMap do
 
       context "when record contains a changed subset of the fields loaded" do
         let(:partial_record) {
-          create_record(
-            namespace,
-            identity_fields,
-            partial_dirty_attrbiutes,
-            depth,
-          )
+          create_record(mapping, partial_dirty_attrbiutes)
         }
 
         let(:partial_dirty_attrbiutes) {
@@ -185,12 +168,7 @@ RSpec.describe Terrestrial::DirtyMap do
 
       context "when record contains an unchanged superset of the fields loaded" do
         let(:super_record) {
-          create_record(
-            namespace,
-            identity_fields,
-            super_clean_attributes,
-            depth,
-          )
+          create_record(mapping, super_clean_attributes)
         }
 
         let(:super_clean_attributes) {
@@ -202,45 +180,42 @@ RSpec.describe Terrestrial::DirtyMap do
         end
       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
+  describe "#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(record)
-        end
+    context "when a record with same identity has been loaded (existing record)" do
+      before do
+        dirty_map.load(record)
+      end
+
+      let(:dup_record) { create_record(mapping, attributes) }
 
-        context "with a equivalent record" do
-          it "returns an empty record" do
-            expect(dirty_map.reject_unchanged_fields(clean_record)).to be_empty
-          end
+      context "with a equivalent record" do
+        it "returns an empty record" do
+          expect(dirty_map.reject_unchanged_fields(dup_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
+      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)
+            .updatable_attributes
+          ).to eq( name: "record/dirty_name" )
         end
       end
     end
   end
 
-  def create_record(namespace, identity_fields, attributes, depth)
-    Terrestrial::UpsertedRecord.new(
-      namespace,
-      identity_fields,
-      attributes,
-      depth,
-    )
+  def create_record(mapping, attributes)
+    Terrestrial::Record.new(mapping, attributes)
   end
 end

data/spec/terrestrial/functional_pipeline_spec.rb

@@ -0,0 +1,153 @@
+require "terrestrial/functional_pipeline"
+RSpec.describe Terrestrial::FunctionalPipeline do
+  subject(:pipeline) { Terrestrial::FunctionalPipeline.new }
+
+  let(:input) { double(:input) }
+  let(:step1) { double(:step1, call: "step1_result") }
+  let(:step2) { double(:step2, call: "step2_result") }
+  let(:step3) { double(:step3, call: "step3_result") }
+
+  describe "#append" do
+    it "returns a new pipeline" do
+      expect(pipeline.append(:step1, step1)).not_to be(pipeline)
+    end
+
+    it "appends a step to the existing steps" do
+      p1 = pipeline.append(:step1, step1)
+      result, _ = p1.call(input)
+
+      expect(result).to eq("step1_result")
+    end
+  end
+
+  context "three step pipeline" do
+    let(:pipeline) do
+      Terrestrial::FunctionalPipeline.from_array(
+        [
+          [:step1, step1],
+          [:step2, step2],
+          [:step3, step3],
+        ]
+      )
+    end
+
+    describe "#call" do
+      it "calls the first step with the input" do
+        pipeline.call(input)
+
+        expect(step1).to have_received(:call).with(input)
+      end
+
+      it "calls the second step with the result of the first" do
+        pipeline.call(input)
+
+        expect(step2).to have_received(:call).with("step1_result")
+      end
+
+      it "calls the thrid step with the result of the second" do
+        pipeline.call(input)
+
+        expect(step3).to have_received(:call).with("step2_result")
+      end
+
+      it "returns the result of the last step" do
+        result, _ = pipeline.call(input)
+
+        expect(result).to eq("step3_result")
+      end
+
+      it "returns the intermediate results of all steps" do
+        _, intermediates = pipeline.call(input)
+
+        expect(intermediates).to eq([
+          [:input, input],
+          [:step1, "step1_result"],
+          [:step2, "step2_result"],
+          [:step3, "step3_result"],
+        ])
+      end
+
+      context "when called with a block" do
+        it "yields the result of each step to the block" do
+          yielded = []
+
+          pipeline.call(input) do |name, result|
+            yielded << [name, result]
+          end
+
+          expect(yielded).to eq([
+            [:step1, "step1_result"],
+            [:step2, "step2_result"],
+            [:step3, "step3_result"],
+          ])
+        end
+      end
+    end
+
+    describe "#describe" do
+      it "returns the list of named steps" do
+        expect(pipeline.describe).to eq([:step1, :step2, :step3])
+      end
+    end
+
+    describe "#take_until" do
+      it "returns a new a pipeline" do
+        expect(pipeline.take_until(:step2)).to be_a(Terrestrial::FunctionalPipeline)
+      end
+
+      describe "the new pipeline" do
+        subject(:new_pipeline) { pipeline.take_until(:step2) }
+
+        it "contains steps from the beginning up to specified step" do
+          expect(new_pipeline.describe).to eq([:step1, :step2])
+        end
+
+        context "when executed" do
+          it "returns the result of the steps"  do
+            result, _ = new_pipeline.call(input)
+
+            expect(result).to eq("step2_result")
+          end
+        end
+      end
+    end
+
+    describe "#drop_until" do
+      it "returns a new a pipeline" do
+        expect(pipeline.drop_until(:step2)).to be_a(Terrestrial::FunctionalPipeline)
+      end
+
+      describe "the new pipeline" do
+        subject(:new_pipeline) { pipeline.drop_until(:step2) }
+
+        it "contains steps that appear before the specified step" do
+          expect(new_pipeline.describe).to eq([:step3])
+        end
+
+        context "when executed" do
+          it "starts execution with the step after the specified one" do
+            result, _ = new_pipeline.call(input)
+
+            expect(step3).to have_received(:call).with(input)
+          end
+
+          it "does not execute steps dropped from the original pipeline" do
+            result, _ = new_pipeline.call(input)
+
+            expect(step1).not_to have_received(:call)
+            expect(step2).not_to have_received(:call)
+          end
+
+          it "returns the result of the steps"  do
+            result, _ = new_pipeline.call(input)
+
+            expect(result).to eq("step3_result")
+          end
+        end
+      end
+    end
+
+    describe "#each" do
+    end
+  end
+end