terrestrial 0.3.0 → 0.5.0

data/spec/database_owned_fields_and_timestamps_spec.rb

@@ -0,0 +1,200 @@
+require "spec_helper"
+
+require "support/have_persisted_matcher"
+require "support/object_store_setup"
+require "support/seed_data_setup"
+
+# Because some systems use triggers to generate/maintain timestamps at the
+# database level they are used as an example for field that the database owns.
+# This means the application layer should always read from and never write to
+# that field.
+RSpec.describe "Database owned fields", backend: "sequel" do
+  include_context "object store setup"
+
+  before(:all) do
+    create_db_timestamp_tables
+  end
+
+  after(:all) do
+    drop_db_timestamp_tables
+  end
+
+  let(:user_store) {
+    object_store[:users]
+  }
+
+  let(:object_store) {
+    Terrestrial.object_store(config: with_db_owned_fields_config)
+  }
+
+  let(:user_with_post) {
+    User.new(
+      id: "users/1",
+      first_name: "Hansel",
+      last_name: "Trickett",
+      email: "hansel@tricketts.org",
+      posts: [post],
+    )
+  }
+
+  let(:post) {
+    Post.new(
+      id: "posts/1",
+      author: nil,
+      subject: "Biscuits",
+      body: "I like them",
+      comments: [],
+      categories: [],
+      created_at: nil,
+      updated_at: nil,
+    )
+  }
+
+  let(:with_db_owned_fields_config) {
+    Terrestrial.config(datastore)
+      .setup_mapping(:users) { |users|
+        users.has_many(:posts, foreign_key: :author_id)
+      }
+      .setup_mapping(:posts) { |posts|
+        posts.relation_name(:timestamped_posts)
+        posts.database_owned_field(:created_at)
+        posts.database_owned_field(:updated_at)
+      }
+  }
+
+  context "new objects" do
+    it "adds the current time to the timestamp fields" do
+      user_store.save(user_with_post)
+
+      expect(datastore).to have_persisted(
+        :timestamped_posts,
+        hash_including(
+          created_at: an_instance_of(Time),
+        )
+      )
+    end
+
+    it "updates the objects with the new timestamp values" do
+      expect(post).to receive(:created_at=).with(an_instance_of(Time))
+
+      user_store.save(user_with_post)
+    end
+
+    it "does not insert values for the database owned fields" do
+      user_store.save(user_with_post)
+
+      posts_insert = query_counter
+        .inserts
+        .select { |sql| sql.include?("timestamped_posts") }
+        .fetch(0)
+
+      expect(posts_insert).not_to include("created_at")
+    end
+  end
+
+  context "updating existing objects" do
+    before do
+      user_store.save(user_with_post)
+      post.body = "new body"
+    end
+
+    context "when the database owned value does not change" do
+      it "regardless, updates the object with the returned value" do
+        expect(post).to receive(:created_at=).with(an_instance_of(Time))
+
+        user_store.save(user_with_post)
+      end
+    end
+
+    context "when the value changes in the database (without worrying about how)" do
+      before do
+        datastore[:timestamped_posts]
+          .where(id: post.id)
+          .update("created_at" => party_time)
+      end
+
+      let(:party_time) { Time.parse("1999-01-01 00:00:00 UTC") }
+
+      it "regardless, updates the object with the returned value" do
+        expect(post).to receive(:created_at=).with(party_time)
+
+        user_store.save(user_with_post)
+      end
+    end
+
+    context "when the database owned value is changed in the object" do
+      it "reverts the object value back to the database value (you may wish to prevent overwriting in your domain model)" do
+        original_time = post.created_at
+        party_time = Time.parse("1999-01-01 00:00:00 UTC")
+        post.created_at = party_time
+
+        expect(post).to receive(:created_at=).with(original_time)
+
+        user_store.save(user_with_post)
+      end
+
+      it "does not insert values for the database owned fields" do
+        user_store.save(user_with_post)
+
+        posts_insert = query_counter
+          .inserts
+          .select { |sql| sql.include?("timestamped_posts") }
+          .fetch(0)
+
+        expect(posts_insert).not_to include("created_at")
+      end
+    end
+  end
+
+  def schema
+    {
+      :tables => {
+        :timestamped_posts => [
+          {
+            :name => :id,
+            :type => String,
+            :options => {
+              :primary_key => true,
+            }
+          },
+          {
+            :name => :subject,
+            :type => String,
+          },
+          {
+            :name => :body,
+            :type => String,
+          },
+          {
+            :name => :author_id,
+            :type => String,
+          },
+          {
+            :name => :created_at,
+            :type => DateTime,
+            :options => {
+              :default => Sequel::CURRENT_TIMESTAMP,
+              :null => false,
+            },
+          },
+          {
+            :name => :updated_at,
+            :type => DateTime,
+            :options => {
+              :default => Sequel::CURRENT_TIMESTAMP,
+              :null => false,
+            },
+          },
+        ],
+      },
+    }
+  end
+
+  def create_db_timestamp_tables
+    Terrestrial::SequelTestSupport.create_tables(schema.fetch(:tables))
+  end
+
+  def drop_db_timestamp_tables
+    Terrestrial::SequelTestSupport.drop_tables(schema.fetch(:tables).keys)
+  end
+end

data/spec/deletion_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe "Deletion" do
 
   describe "Deleting the root" do
     it "deletes the root object" do
-      user_store.delete(user, cascade: true)
+      user_store.delete(user)
 
       expect(datastore).not_to have_persisted(
         :users,

data/spec/error_handling/factory_error_handling_spec.rb

@@ -49,10 +49,7 @@ RSpec.describe "factory error handling" do
         users.factory(factory)
       }
 
-    @object_store = Terrestrial.object_store(
-      mappings: config,
-      datastore: datastore,
-    )
+    @object_store = Terrestrial.object_store(config: config)
   end
 
   def seed_user(record)

data/spec/error_handling/serialization_error_spec.rb

@@ -37,10 +37,7 @@ RSpec.describe "Serialization error handling" do
         users.serializer(serializer)
       }
 
-      @object_store = Terrestrial.object_store(
-        mappings: config,
-        datastore: datastore,
-      )
+      @object_store = Terrestrial.object_store(config: config)
     end
 
     def save_user

data/spec/error_handling/upsert_error_spec.rb

@@ -104,13 +104,12 @@ RSpec.describe "Upsert error handling" do
       rescue Terrestrial::UpsertError => error
       end
 
-      expect(error.message).to eq(
-        [
-          "Error upserting record into `users` with data `#{serialization_result}`.",
-          "Got Error: Sequel::NotNullConstraintViolation PG::NotNullViolation: ERROR:  null value in column \"id\" violates not-null constraint",
-          "DETAIL:  Failing row contains (null, Hansel, Trickett, hansel@tricketts.org).\n",
-        ].join("\n")
-      )
+      aggregate_failures do
+        expect(error.message).to start_with("Error upserting record into `users` with data `#{serialization_result}`.")
+        expect(error.message).to include("Got Error: Sequel::NotNullConstraintViolation")
+        expect(error.message).to include("in column \"id\"")
+        expect(error.message).to include("DETAIL:  Failing row contains (null, Hansel, Trickett, hansel@tricketts.org)")
+      end
     end
   end
 
@@ -124,9 +123,6 @@ RSpec.describe "Upsert error handling" do
         users.serializer(serializer)
       }
 
-    @object_store = Terrestrial.object_store(
-      mappings: config,
-      datastore: datastore,
-    )
+    @object_store = Terrestrial.object_store(config: config)
   end
 end

data/spec/graph_persistence_spec.rb

@@ -31,21 +31,8 @@ RSpec.describe "Graph persistence" do
       )
     end
 
-    it "doesn't send associated objects to the database as columns" do
-      user.email = modified_email
-      user_store.save(user)
-
-      expect(datastore).not_to have_persisted(
-        :users,
-        hash_including(
-          posts: anything,
-        )
-      )
-    end
-
-    # TODO move to a dirty tracking spec?
-    context "when mutating entity fields in place" do
-      it "saves the object" do
+    context "when mutating an entity's fields in place" do
+      it "updates the row with new, mutated values" do
         user.email << "MUTATED"
 
         user_store.save(user)
@@ -110,11 +97,13 @@ RSpec.describe "Graph persistence" do
     let(:new_post_attrs) {
       {
         id: "posts/neu",
+        author: nil,
         subject: "I am new",
         body: "new body",
         comments: [],
         categories: [],
         created_at: Time.now,
+        updated_at: Time.now,
       }
     }
 
@@ -242,6 +231,47 @@ RSpec.describe "Graph persistence" do
       end
     end
 
+    context "duplicate a node" do
+      let(:post_with_one_category) { user.posts.to_a.last }
+
+      # Spoiler alert: it does mutate the graph
+      #
+      # Feature?: The posts <=> category relationship because unique when persisted
+      # because there are no indexes on the `categories_to_posts` table making
+      # the combination of foreign keys a de facto primary key.
+      #
+      # If there was an additional primary key id field without a unique index
+      # this would not be the case.
+      #
+      # It would be nice if the collection proxy for posts <=> categories was a
+      # variant that behaved like set. Unfortunately uniqueness can only be
+      # determined by the user-defind objects' identities as the proxy would
+      # not have access to datastore ids.
+      #
+      # Mappings are available when the proxy is constructed so this is
+      # possible but awkward.
+      xit "does not mutate the graph" do
+        existing_category = post_with_one_category.categories.first
+        post_with_one_category.categories.push(existing_category)
+
+        expect(post_with_one_category.categories.map(&:id))
+          .to eq(["categories/2"])
+      end
+
+      it "does not persist the change" do
+        existing_category = post_with_one_category.categories.first
+        post_with_one_category.categories.push(existing_category)
+
+        user_store.save(user)
+
+        expect(
+          datastore[:categories_to_posts]
+            .where(:post_id => post_with_one_category.id)
+            .count
+        ).to eq(1)
+      end
+    end
+
     context "modify a node" do
       let(:category) { user.posts.first.categories.first }
       let(:modified_category_name) { "modified category" }
@@ -306,9 +336,11 @@ RSpec.describe "Graph persistence" do
       it "populates that association with a nil" do
         post = Post.new(
           id: "posts/orphan",
+          author: nil,
           subject: "Nils gonna getcha",
           body: "",
           created_at: Time.parse("2015-09-05T15:00:00+01:00"),
+          updated_at: Time.parse("2015-09-05T15:00:00+01:00"),
           categories: [],
           comments: [],
         )
@@ -326,7 +358,7 @@ RSpec.describe "Graph persistence" do
     end
 
     context "when an existing partent object reference is set to nil" do
-      it "populates that association with a nil" do
+      it "does not orphan the object and sets the foreign key according to position in the object graph" do
         comment = user
           .posts
           .flat_map(&:comments)
@@ -340,7 +372,7 @@ RSpec.describe "Graph persistence" do
           :comments,
           hash_including(
             id: "comments/1",
-            commenter_id: nil,
+            commenter_id: "users/1",
           )
         )
       end
@@ -358,9 +390,11 @@ RSpec.describe "Graph persistence" do
         user.posts.first.subject = unpersistable_object
 
         user_store.save(user)
-      rescue Terrestrial::Error
+      rescue Object => e
       end
 
+      expect(e).to be_a(Terrestrial::Error)
+
       post_change = datastore[:users].to_a.map(&:to_a).sort
 
       expect(pre_change).to eq(post_change)

data/spec/ordered_association_spec.rb

@@ -13,12 +13,10 @@ RSpec.describe "Ordered associations" do
     let(:posts) { object_store[:users].first.posts }
 
     before do
-      configs.fetch(:users).fetch(:associations).fetch(:posts).merge!(
-        order: Terrestrial::QueryOrder.new(
-          fields: [:created_at],
-          direction: "DESC",
-        )
-      )
+      mappings
+        .setup_mapping(:users) { |users|
+          users.has_many(:posts, foreign_key: :author_id, order_fields: [:created_at], order_direction: :DESC)
+        }
     end
 
     it "enumerates the objects in order specified in the config" do
@@ -30,12 +28,12 @@ RSpec.describe "Ordered associations" do
 
   context "many to many associatin ordered by reverse alphabetical name" do
     before do
-      configs.fetch(:posts).fetch(:associations).fetch(:categories).merge!(
-        order: Terrestrial::QueryOrder.new(
-          fields: [:name],
-          direction: "DESC",
-        )
-      )
+      mappings
+        .setup_mapping(:posts) { |posts|
+          posts.fields([:id, :subject, :body, :created_at, :updated_at])
+          posts.has_many(:comments)
+          posts.has_many_through(:categories, order_fields: [:name], order_direction: :DESC)
+        }
     end
 
     let(:categories) { object_store[:users].first.posts.first.categories }

data/spec/predefined_queries_spec.rb

@@ -14,15 +14,15 @@ RSpec.describe "Predefined subset queries" do
   context "on the top level mapper" do
     context "subset is defined with a block" do
       before do
-        configs.fetch(:users).merge!(
-          subsets: {
-            tricketts: ->(dataset) {
+        mappings
+          .setup_mapping(:users) { |users|
+            users.has_many(:posts, foreign_key: :author_id)
+            users.subset(:tricketts) { |dataset|
               dataset
                 .where(last_name: "Trickett")
                 .order(:first_name)
-            },
-          },
-        )
+            }
+          }
       end
 
       it "maps the result of the subset" do
@@ -36,13 +36,15 @@ RSpec.describe "Predefined subset queries" do
 
   context "on a has many association" do
     before do
-      configs.fetch(:posts).merge!(
-        subsets: {
-          body_contains: ->(dataset, search_string) {
+      mappings
+        .setup_mapping(:posts) { |posts|
+          posts.fields([:id, :subject, :body, :created_at, :updated_at])
+          posts.has_many(:comments)
+          posts.has_many_through(:categories)
+          posts.subset(:body_contains) { |dataset, search_string|
             dataset.where(body: /#{search_string}/)
-          },
-        },
-      )
+          }
+        }
     end
 
     let(:user) { users.first }