terrestrial 0.3.0 → 0.5.0

data/spec/support/seed_data_setup.rb

@@ -1,4 +1,6 @@
 require "support/object_graph_setup"
+require "support/seed_records"
+
 RSpec.shared_context "seed data setup" do
   include_context "object graph setup"
 
@@ -10,158 +12,22 @@ RSpec.shared_context "seed data setup" do
 
   let(:seeded_records) {
     [
-      [ :users, hansel_record ],
-      [ :users, jasper_record ],
-      [ :users, poppy_record ],
-      [ :posts, biscuits_post_record ],
-      [ :posts, sleep_post_record ],
-      [ :posts, catch_frogs_post_record ],
-      [ :posts, chew_up_boxes_post_record ],
-      [ :comments, biscuits_post_comment_record ],
-      [ :categories, cat_biscuits_category_record ],
-      [ :categories, eating_and_sleeping_category_record ],
-      [ :categories, hunting_category_record ],
-      [ :categories, messing_stuff_up_category_record ],
-      *categories_to_posts_records.map { |record|
+      [ :users, SeedRecords.hansel_record ],
+      [ :users, SeedRecords.jasper_record ],
+      [ :users, SeedRecords.poppy_record ],
+      [ :posts, SeedRecords.biscuits_post_record ],
+      [ :posts, SeedRecords.sleep_post_record ],
+      [ :posts, SeedRecords.catch_frogs_post_record ],
+      [ :posts, SeedRecords.chew_up_boxes_post_record ],
+      [ :comments,   SeedRecords.biscuits_post_comment_record ],
+      [ :categories, SeedRecords.cat_biscuits_category_record ],
+      [ :categories, SeedRecords.eating_and_sleeping_category_record ],
+      [ :categories, SeedRecords.hunting_category_record ],
+      [ :categories, SeedRecords.messing_stuff_up_category_record ],
+      *SeedRecords.categories_to_posts_records.map { |record|
         [ :categories_to_posts, record ]
       },
     ]
   }
 
-  let(:hansel_record) {
-    {
-      id: "users/1",
-      first_name: "Hansel",
-      last_name: "Trickett",
-      email: "hansel@tricketts.org",
-    }
-  }
-
-  let(:jasper_record) {
-    {
-      id: "users/2",
-      first_name: "Jasper",
-      last_name: "Trickett",
-      email: "jasper@tricketts.org",
-    }
-  }
-
-  let(:poppy_record) {
-    {
-      id: "users/3",
-      first_name: "Poppy",
-      last_name: "Herzog",
-      email: "poppy@herzog.info",
-    }
-  }
-
-  let(:biscuits_post_record) {
-    {
-      id: "posts/1",
-      subject: "Biscuits",
-      body: "I like them",
-      author_id: "users/1",
-      created_at: Time.parse("2015-09-05T15:00:00+01:00"),
-    }
-  }
-
-  let(:sleep_post_record) {
-    {
-      id: "posts/2",
-      subject: "Sleeping",
-      body: "I do it three times purrr day",
-      author_id: "users/1",
-      created_at: Time.parse("2015-09-02T15:00:00+01:00"),
-    }
-  }
-
-  let(:catch_frogs_post_record) {
-    {
-      id: "posts/3",
-      subject: "Catching frongs",
-      body: "I love them while at the same time I hate them",
-      author_id: "users/2",
-      created_at: Time.parse("2015-09-03T15:00:00+01:00"),
-    }
-  }
-
-  let(:chew_up_boxes_post_record) {
-    {
-      id: "posts/4",
-      subject: "Chewing up boxes",
-      body: "I love them, and yet I destory them",
-      author_id: "users/2",
-      created_at: Time.parse("2015-09-10T11:00:00+01:00"),
-    }
-  }
-
-  let(:biscuits_post_comment_record) {
-    {
-      id: "comments/1",
-      body: "oh noes",
-      post_id: "posts/1",
-      commenter_id: "users/1",
-    }
-  }
-
-  let(:cat_biscuits_category_record) {
-    {
-      id: "categories/1",
-      name: "Cat biscuits",
-    }
-  }
-
-  let(:eating_and_sleeping_category_record) {
-    {
-      id: "categories/2",
-      name: "Eating and sleeping",
-    }
-  }
-
-  let(:hunting_category_record) {
-    {
-      id: "categories/3",
-      name: "Hunting",
-    }
-  }
-
-  let(:messing_stuff_up_category_record) {
-    {
-      id: "categories/4",
-      name: "Messing stuff up",
-    }
-  }
-
-  let(:categories_to_posts_records) {
-    [
-      {
-        post_id: "posts/1",
-        category_id: "categories/1",
-      },
-      {
-        post_id: "posts/1",
-        category_id: "categories/2",
-      },
-      {
-        post_id: "posts/2",
-        category_id: "categories/2",
-      },
-      {
-        post_id: "posts/3",
-        category_id: "categories/2",
-      },
-      {
-        post_id: "posts/3",
-        category_id: "categories/3",
-      },
-      {
-        post_id: "posts/4",
-        category_id: "categories/3",
-      },
-      {
-        post_id: "posts/4",
-        category_id: "categories/4",
-      },
-    ]
-  }
 end

data/spec/support/seed_records.rb

@@ -0,0 +1,141 @@
+module SeedRecords
+  module_function
+
+  def hansel_record
+    {
+      id: "users/1",
+      first_name: "Hansel",
+      last_name: "Trickett",
+      email: "hansel@tricketts.org",
+    }
+  end
+
+  def jasper_record
+    {
+      id: "users/2",
+      first_name: "Jasper",
+      last_name: "Trickett",
+      email: "jasper@tricketts.org",
+    }
+  end
+
+  def poppy_record
+    {
+      id: "users/3",
+      first_name: "Poppy",
+      last_name: "Herzog",
+      email: "poppy@herzog.info",
+    }
+  end
+
+  def biscuits_post_record
+    {
+      id: "posts/1",
+      subject: "Biscuits",
+      body: "I like them",
+      author_id: "users/1",
+      created_at: Time.parse("2015-09-02T15:00:00+01:00"),
+    }
+  end
+
+  def sleep_post_record
+    {
+      id: "posts/2",
+      subject: "Sleeping",
+      body: "I do it three times purrr day",
+      author_id: "users/1",
+      created_at: Time.parse("2015-09-03T15:00:00+01:00"),
+    }
+  end
+
+  def catch_frogs_post_record
+    {
+      id: "posts/3",
+      subject: "Catching frongs",
+      body: "I love them while at the same time I hate them",
+      author_id: "users/2",
+      created_at: Time.parse("2015-09-05T15:00:00+01:00"),
+    }
+  end
+
+  def chew_up_boxes_post_record
+    {
+      id: "posts/4",
+      subject: "Chewing up boxes",
+      body: "I love them, and yet I destory them",
+      author_id: "users/2",
+      created_at: Time.parse("2015-09-10T11:00:00+01:00"),
+    }
+  end
+
+  def biscuits_post_comment_record
+    {
+      id: "comments/1",
+      body: "oh noes",
+      post_id: "posts/1",
+      commenter_id: "users/1",
+    }
+  end
+
+  def cat_biscuits_category_record
+    {
+      id: "categories/1",
+      name: "Cat biscuits",
+    }
+  end
+
+  def eating_and_sleeping_category_record
+    {
+      id: "categories/2",
+      name: "Eating and sleeping",
+    }
+  end
+
+  def hunting_category_record
+    {
+      id: "categories/3",
+      name: "Hunting",
+    }
+  end
+
+  def messing_stuff_up_category_record
+    {
+      id: "categories/4",
+      name: "Messing stuff up",
+    }
+  end
+
+  def categories_to_posts_records
+    [
+      {
+        post_id: "posts/1",
+        category_id: "categories/1",
+      },
+      {
+        post_id: "posts/1",
+        category_id: "categories/2",
+      },
+      {
+        post_id: "posts/2",
+        category_id: "categories/2",
+      },
+      {
+        post_id: "posts/3",
+        category_id: "categories/2",
+      },
+      {
+        post_id: "posts/3",
+        category_id: "categories/3",
+      },
+      {
+        post_id: "posts/4",
+        category_id: "categories/3",
+      },
+      {
+        post_id: "posts/4",
+        category_id: "categories/4",
+      },
+    ]
+  end
+end
+

data/spec/support/sequel_test_support.rb

@@ -4,8 +4,7 @@ module Terrestrial
   module SequelTestSupport
     module_function def build_datastore(_schema)
       db_connection.tap { |db|
-        # This test is using the database so we better clean it out first
-        truncate_tables
+        clean_database
 
         # The query_counter will let us make assertions about how efficiently
         # the database is being used
@@ -21,6 +20,7 @@ module Terrestrial
     module_function def before_suite(schema)
       drop_tables
       create_tables(schema.fetch(:tables))
+      add_unique_indexes(schema.fetch(:unique_indexes))
       add_foreign_keys(schema.fetch(:foreign_keys))
     end
 
@@ -46,18 +46,31 @@ module Terrestrial
       end
     end
 
-    module_function def truncate_tables(tables = db_connection.tables)
-      tables.each do |table_name|
-        db_connection[table_name].truncate(cascade: true)
+    module_function def clean_database(tables = db_connection.tables)
+      stardard_test_tables = BLOG_SCHEMA.fetch(:tables).keys
+      test_tables_in_deletable_order = stardard_test_tables.reverse
+
+      clean_tables(test_tables_in_deletable_order)
+    end
+
+    module_function def clean_tables(names)
+      names.each do |name|
+        clean_table(name)
       end
     end
 
+    module_function def clean_table(name)
+      db_connection[name].delete
+    end
+
     module_function def db_connection
-      @@db_connection ||= Sequel.postgres(
-        host: ENV.fetch("PGHOST"),
-        user: ENV.fetch("PGUSER"),
-        database: ENV.fetch("PGDATABASE"),
-      ).tap { Sequel.default_timezone = :utc }
+      @db_connection ||= begin
+         Sequel.postgres(
+           host: ENV.fetch("PGHOST"),
+           user: ENV.fetch("PGUSER"),
+           database: ENV.fetch("PGDATABASE"),
+         ).tap { Sequel.default_timezone = :utc }
+       end
     end
 
     module_function def create_tables(tables)
@@ -76,10 +89,24 @@ module Terrestrial
       tables.keys
     end
 
+    module_function def add_unique_indexes(unique_indexes)
+      unique_indexes.each do |(table, *cols)|
+        db_connection.alter_table(table) do
+          add_unique_constraint(cols)
+        end
+      end
+    end
+
     module_function def add_foreign_keys(foreign_keys)
-      foreign_keys.each do |(table, fk_col, foreign_table, key_col)|
+      default_options = { deferrable: false, on_delete: :set_null }
+
+      foreign_keys.each do |(table, fk_col, foreign_table, key_col, options)|
+        options_with_defaults = default_options
+          .merge(options || {})
+          .merge(key: key_col)
+
         db_connection.alter_table(table) do
-          add_foreign_key([fk_col], foreign_table, key: key_col, deferrable: false, on_delete: :set_null)
+          add_foreign_key([fk_col], foreign_table, options_with_defaults)
         end
       end
     end
@@ -108,7 +135,7 @@ module Terrestrial
       end
 
       def write_count
-        insert_count + update_count
+        upserts.count
       end
 
       def update_count
@@ -119,6 +146,12 @@ module Terrestrial
         inserts.count
       end
 
+      def upserts
+        @info
+          .map { |query| query.gsub(/\A\([0-9\.]+s\) /, "") }
+          .select { |query| query.start_with?("INSERT") && query.include?("ON CONFLICT") }
+      end
+
       def updates
         @info
           .map { |query| query.gsub(/\A\([0-9\.]+s\) /, "") }

data/spec/terrestrial/abstract_record_spec.rb

@@ -1,31 +1,39 @@
 require "spec_helper"
 
-require "terrestrial/abstract_record"
+require "terrestrial/record"
 
-RSpec.describe Terrestrial::AbstractRecord do
+RSpec.describe Terrestrial::Record do
   subject(:record) {
-    Terrestrial::AbstractRecord.new(
-      namespace,
-      primary_key_fields,
-      raw_data,
-      depth,
+    Terrestrial::Record.new(
+      mapping,
+      attributes,
+    )
+  }
+
+  let(:mapping) {
+    double(
+      :mapping,
+      {
+        namespace: namespace,
+        primary_key: primary_key_fields,
+        database_owned_fields: [],
+        database_default_fields: [],
+      }
     )
   }
 
   let(:namespace) { double(:namespace) }
-  let(:primary_key_fields) { [ :id1, :id2 ] }
+  let(:primary_key_fields) { [:id] }
   let(:depth) { 0 }
 
-  let(:raw_data) {
+  let(:attributes) {
     {
-      id1: id1,
-      id2: id2,
+      id: id,
       name: name,
     }
   }
 
-  let(:id1) { double(:id1) }
-  let(:id2) { double(:id2) }
+  let(:id) { double(:id) }
   let(:name) { double(:name) }
 
   describe "#namespace" do
@@ -37,15 +45,56 @@ RSpec.describe Terrestrial::AbstractRecord do
   describe "#identity" do
     it "returns the primary key fields" do
       expect(record.identity).to eq(
-        id1: id1,
-        id2: id2,
+        id: id,
+      )
+    end
+  end
+
+  describe "#updatable?" do
+    context "when the record has attributes other than its identity attributes" do
+      let(:record) {
+        Terrestrial::Record.new(
+          mapping,
+          { id: "some-id", name: "some name" },
+        )
+      }
+
+      it "returns true" do
+        expect(record).to be_updatable
+      end
+    end
+
+    context "when the record contains only identity attributes" do
+      let(:record) {
+        Terrestrial::Record.new(
+          mapping,
+          { id: "some-id" },
+        )
+      }
+
+      it "returns false" do
+        expect(record).not_to be_updatable
+      end
+    end
+  end
+
+  describe "#updatable_attributes" do
+    it "filters out idetity attributes" do
+      expect(record.updatable_attributes).not_to include(
+        id: id,
+      )
+    end
+
+    it "returns a hash of only non-identity attributes" do
+      expect(record.updatable_attributes).to eq(
+        name: name,
       )
     end
   end
 
   describe "#fetch" do
     it "delegates to the underlying Hash representation" do
-      expect(record.fetch(:id1)).to eq(id1)
+      expect(record.fetch(:id)).to eq(id)
       expect(record.fetch(:name)).to eq(name)
       expect(record.fetch(:not_there, "nope")).to eq("nope")
       expect(record.fetch(:not_there) { "lord no" }).to eq("lord no")
@@ -55,13 +104,61 @@ RSpec.describe Terrestrial::AbstractRecord do
   describe "#to_h" do
     it "returns a raw_data merged with identity" do
       expect(record.to_h).to eq(
-        id1: id1,
-        id2: id2,
+        id: id,
         name: name,
       )
     end
   end
 
+  describe "#reject" do
+    it "returns a new record" do
+      expect(record.reject { true }).to be_a(Terrestrial::Record)
+    end
+
+    it "rejects matching non-identity attributes" do
+      filtered = record.reject { |k, _v| k == :name }
+
+      expect(filtered.to_h).not_to include(:name)
+    end
+
+    it "does not yield identity fields for rejection" do
+      captured = []
+
+      record.reject { |k, v| captured << [k, v] }
+
+      expect(captured).not_to include(:id1, :id2)
+    end
+
+    it "cannot reject the identity attributes" do
+      filtered = record.reject { true }
+
+      expect(filtered.to_h).to eq(
+        id: id,
+      )
+    end
+  end
+
+  describe "#empty?" do
+    context "when there are non-identity attributes" do
+      it "returns false" do
+        expect(record).not_to be_empty
+      end
+    end
+
+    context "when there are only identity attributes" do
+      let(:record) {
+        Terrestrial::Record.new(
+          mapping,
+          { id: "some-id" },
+        )
+      }
+
+      it "returns true" do
+        expect(record).to be_empty
+      end
+    end
+  end
+
   describe "#if_upsert" do
     it "returns self" do
       expect(
@@ -101,8 +198,7 @@ RSpec.describe Terrestrial::AbstractRecord do
 
     it "returns a new record with same identity" do
       expect(record.merge(extra_data).identity).to eq(
-        id1: id1,
-        id2: id2,
+        id: id,
       )
     end
 
@@ -116,8 +212,7 @@ RSpec.describe Terrestrial::AbstractRecord do
       merged_record = record.merge(extra_data)
 
       expect(merged_record.to_h).to eq(
-        id1: id1,
-        id2: id2,
+        id: id,
         name: name,
         location: location,
       )
@@ -145,99 +240,36 @@ RSpec.describe Terrestrial::AbstractRecord do
     end
   end
 
-  describe "#<=>" do
-    let(:deep_record) {
-      Terrestrial::AbstractRecord.new(
-        namespace,
-        primary_key_fields,
-        raw_data,
-        _depth = 5,
-      )
-    }
-
-    let(:shallow_record) {
-      Terrestrial::AbstractRecord.new(
-        namespace,
-        primary_key_fields,
-        raw_data,
-        _depth = 1,
-      )
-    }
+  describe "#==" do
+    context "compared to a record with the same attributes and mapping" do
+      let(:other) { Terrestrial::Record.new(mapping, attributes) }
 
-    context "when other record has deeper depth" do
-      it "is sortable by depth" do
-        expect([shallow_record, record, deep_record].sort).to eq(
-          [record, deep_record, shallow_record]
-        )
+      it "is equal" do
+        expect(record).to eq(other)
       end
     end
-  end
 
-  describe "#==" do
-    context "super class contract" do
-      let(:comparitor) { record.merge({}) }
+    context "compared to a record with the same mappiung different attributes" do
+      let(:other) { Terrestrial::Record.new(mapping, other_attributes) }
+      let(:other_attributes) { double(:other_attributes) }
 
-      it "compares" do
-        record == comparitor
+      it "is equal" do
+        expect(record).not_to eq(other)
       end
+    end
 
-      context "when subclassed" do
-        subject(:record) {
-          record_subclass.new(namespace, primary_key_fields, raw_data)
-        }
-
-        let(:record_subclass) {
-          Class.new(Terrestrial::AbstractRecord) {
-            protected
+    context "compared to a record with the same attributes and different mapping" do
+      let(:other) { Terrestrial::Record.new(other_mapping, attributes) }
+      let(:other_mapping) { double(:other_mapping) }
 
-            def operation
-              :do_a_thing
-            end
-          }
-        }
+      it "is not equal" do
+        expect(record).not_to eq(other)
+      end
+    end
 
-        context "when comparitor is of the wrong type" do
-          it "is not equal" do
-            expect(record.==(Object.new)).to be(false)
-          end
-        end
-
-        context "when the operation type is equal" do
-          context "when the combined `raw_data` and `identity` are equal" do
-            let(:comparitor) { record.merge({}) }
-
-            it "is equal" do
-              expect(record.==(comparitor)).to be(true)
-            end
-          end
-
-          context "when the combined `raw_data` and `identity` are not equal" do
-            let(:comparitor) { record.merge(something_else: "i'm different") }
-
-            it "is not equal" do
-              expect(record.==(comparitor)).to be(false)
-            end
-          end
-        end
-
-        context "when the operation name differs" do
-          let(:comparitor) {
-            record_class_with_different_operation.new(namespace, primary_key_fields, raw_data)
-          }
-
-          let(:record_class_with_different_operation) {
-            Class.new(Terrestrial::AbstractRecord) {
-              protected
-              def operation
-                :do_a_different_thing
-              end
-            }
-          }
-
-          it "is not equal" do
-            expect(record.==(comparitor)).to be(false)
-          end
-        end
+    context "compared to something completely different" do
+      it "is not equal" do
+        expect(record).not_to eq("something completetly different")
       end
     end
   end