terrestrial 0.1.1 → 0.3.0

data/lib/terrestrial/relation_mapping.rb

@@ -1,3 +1,7 @@
+require "terrestrial/error"
+require "terrestrial/upserted_record"
+require "terrestrial/deleted_record"
+
 module Terrestrial
   class RelationMapping
     def initialize(name:, namespace:, fields:, primary_key:, factory:, serializer:, associations:, subsets:)
@@ -12,11 +16,18 @@ module Terrestrial
     end
 
     attr_reader :name, :namespace, :fields, :primary_key, :factory, :serializer, :associations, :subsets
+    private :factory, :serializer
 
     def add_association(name, new_association)
       @associations = associations.merge(name => new_association)
     end
 
+    def load(record)
+      factory.call(record)
+    rescue => e
+      raise LoadError.new(namespace, factory, record, e)
+    end
+
     def serialize(object, depth, foreign_keys = {})
       object_attributes = serializer.call(object)
 
@@ -24,8 +35,18 @@ module Terrestrial
         record(object_attributes, depth, foreign_keys),
         extract_associations(object_attributes)
       ]
+    rescue => e
+      raise SerializationError.new(name, serializer, object, e)
+    end
+
+    def delete(object, depth)
+      object_attributes = serializer.call(object)
+
+      [deleted_record(object_attributes, depth)]
     end
 
+    private
+
     def record(attributes, depth, foreign_keys)
       UpsertedRecord.new(
         namespace,
@@ -35,6 +56,15 @@ module Terrestrial
       )
     end
 
+    def deleted_record(attributes, depth)
+      DeletedRecord.new(
+        namespace,
+        primary_key,
+        attributes,
+        depth,
+      )
+    end
+
     def extract_associations(attributes)
       Hash[
         associations.map { |name, _association|

data/lib/terrestrial/{mapper_facade.rb → relational_store.rb}

@@ -1,9 +1,11 @@
 require "terrestrial/graph_serializer"
 require "terrestrial/graph_loader"
+require "terrestrial/inspection_string"
 
 module Terrestrial
-  class MapperFacade
+  class RelationalStore
     include Enumerable
+    include InspectionString
 
     def initialize(mappings:, mapping_name:, datastore:, dataset:, load_pipeline:, dump_pipeline:)
       @mappings = mappings
@@ -133,5 +135,13 @@ module Terrestrial
         object_load_pipeline: load_pipeline,
       )
     end
+
+    def inspectable_properties
+      [
+        :mapping_name,
+        :dataset,
+        :eager_load,
+      ]
+    end
   end
 end

data/lib/terrestrial/version.rb

@@ -1,3 +1,3 @@
 module Terrestrial
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end

data/spec/config_override_spec.rb

@@ -1,20 +1,18 @@
 require "spec_helper"
 require "ostruct"
 
-require "support/mapper_setup"
-require "support/sequel_persistence_setup"
+require "support/object_store_setup"
 require "support/seed_data_setup"
 require "terrestrial"
 
 require "terrestrial/configurations/conventional_configuration"
 
 RSpec.describe "Configuration override" do
-  include_context "mapper setup"
-  include_context "sequel persistence setup"
+  include_context "object store setup"
   include_context "seed data setup"
 
-  let(:mappers) {
-    Terrestrial.mappers(mappings: override_config, datastore: datastore)
+  let(:object_store) {
+    Terrestrial.object_store(mappings: override_config, datastore: datastore)
   }
 
   let(:override_config) {
@@ -26,7 +24,7 @@ RSpec.describe "Configuration override" do
   }
 
   let(:user) {
-    user_mapper.where(id: "users/1").first
+    object_store[:users].where(id: "users/1").first
   }
 
   context "override the root mapper factory" do
@@ -89,15 +87,13 @@ RSpec.describe "Configuration override" do
         end
       }
 
-      let(:datastore) { db_connection }
-
       let(:unconventional_table_name) {
         :users_is_called_this_weird_thing_perhaps_for_legacy_reasons
       }
 
       it "maps data from the specified relation" do
         expect(
-          user_mapper.map(&:id)
+          object_store[:users].map(&:id)
         ).to eq(["users/1", "users/2", "users/3"])
       end
     end
@@ -184,10 +180,10 @@ RSpec.describe "Configuration override" do
     }
 
     it "provides access to the same data via the different configs" do
-      expect(mappers[:t1_users].first.id).to eq("users/1")
-      expect(mappers[:t1_users].first).to be_a(TypeOneUser)
-      expect(mappers[:t2_users].first.id).to eq("users/1")
-      expect(mappers[:t2_users].first).to be_a(TypeTwoUser)
+      expect(object_store[:t1_users].first.id).to eq("users/1")
+      expect(object_store[:t1_users].first).to be_a(TypeOneUser)
+      expect(object_store[:t2_users].first.id).to eq("users/1")
+      expect(object_store[:t2_users].first).to be_a(TypeTwoUser)
     end
   end
 end

data/spec/custom_serializers_spec.rb

@@ -1,19 +1,17 @@
 require "spec_helper"
 
 require "support/have_persisted_matcher"
-require "support/mapper_setup"
-require "support/sequel_persistence_setup"
+require "support/object_store_setup"
 require "support/seed_data_setup"
 require "terrestrial"
 
 require "terrestrial/configurations/conventional_configuration"
 
 RSpec.describe "Config override" do
-  include_context "mapper setup"
-  include_context "sequel persistence setup"
+  include_context "object store setup"
   include_context "seed data setup"
 
-  let(:user) { user_mapper.where(id: "users/1").first }
+  let(:user) { object_store[:users].where(id: "users/1").first }
 
   context "with an object that has private fields" do
     let(:user_serializer) {
@@ -36,7 +34,7 @@ RSpec.describe "Config override" do
         user.first_name = "This won't work"
         user.last_name = "because the serialzer is weird"
 
-        user_mapper.save(user)
+        object_store[:users].save(user)
 
         expect(datastore).to have_persisted(:users, hash_including(
           id: user.id,

data/spec/deletion_spec.rb

@@ -1,29 +1,27 @@
 require "spec_helper"
 
-require "support/mapper_setup"
-require "support/sequel_persistence_setup"
+require "support/object_store_setup"
 require "support/seed_data_setup"
 require "support/have_persisted_matcher"
 require "terrestrial"
 
 RSpec.describe "Deletion" do
-  include_context "mapper setup"
-  include_context "sequel persistence setup"
+  include_context "object store setup"
   include_context "seed data setup"
 
-  subject(:mapper) { user_mapper }
+  subject(:user_store) { object_store[:users] }
 
   let(:user) {
-    mapper.where(id: "users/1").first
+    user_store.where(id: "users/1").first
   }
 
   let(:reloaded_user) {
-    mapper.where(id: "users/1").first
+    user_store.where(id: "users/1").first
   }
 
   describe "Deleting the root" do
     it "deletes the root object" do
-      mapper.delete(user, cascade: true)
+      user_store.delete(user, cascade: true)
 
       expect(datastore).not_to have_persisted(
         :users,
@@ -37,7 +35,7 @@ RSpec.describe "Deletion" do
       end
 
       it "deletes the root object" do
-        mapper.delete(user)
+        user_store.delete(user)
 
         expect(datastore).not_to have_persisted(
           :users,
@@ -47,7 +45,7 @@ RSpec.describe "Deletion" do
 
       it "does not delete the child objects" do
         expect {
-          mapper.delete(user)
+          user_store.delete(user)
         }.not_to change { [datastore[:posts], datastore[:comments]].map(&:count) }
       end
     end
@@ -64,7 +62,7 @@ RSpec.describe "Deletion" do
 
     it "deletes the specified node" do
       user.posts.delete(post)
-      mapper.save(user)
+      user_store.save(user)
 
       expect(datastore).not_to have_persisted(
         :posts,
@@ -74,7 +72,7 @@ RSpec.describe "Deletion" do
 
     it "does not delete the parent object" do
       user.posts.delete(post)
-      mapper.save(user)
+      user_store.save(user)
 
       expect(datastore).to have_persisted(
         :users,
@@ -84,7 +82,7 @@ RSpec.describe "Deletion" do
 
     it "does not delete the sibling objects" do
       user.posts.delete(post)
-      mapper.save(user)
+      user_store.save(user)
 
       expect(reloaded_user.posts.count).to be > 0
     end
@@ -92,7 +90,7 @@ RSpec.describe "Deletion" do
     it "does not cascade delete" do
       expect {
         user.posts.delete(post)
-        mapper.save(user)
+        user_store.save(user)
       }.not_to change {
         datastore[:comments].map { |r| r.fetch(:id) }
       }

data/spec/error_handling/factory_error_handling_spec.rb

@@ -0,0 +1,61 @@
+require "terrestrial"
+require "terrestrial/configurations/conventional_configuration"
+
+RSpec.describe "factory error handling" do
+  context "factory with too few parameters" do
+    before do
+      seed_user(record)
+      override_user_factory_with(no_parameters_factory)
+    end
+
+    let(:record) {
+      {
+        id: "users/999",
+        first_name: "Badger",
+        last_name: "Smith",
+        email: "b@smith.biz",
+      }
+    }
+
+    let(:no_parameters_factory) {
+      ->() { }
+    }
+
+    it "raises a helpful error message" do
+      error = nil
+      begin
+        load_first_user
+      rescue Terrestrial::Error => error
+      end
+
+      expect(error.message).to eq(
+        [
+          "Error loading record from `users` relation `#{record.inspect}`.",
+          "Using: `#{no_parameters_factory.inspect}`.",
+          "Check that the factory is compatible.",
+          "Got Error: ArgumentError wrong number of arguments (given 1, expected 0)",
+        ].join("\n")
+      )
+    end
+  end
+
+  def load_first_user
+    @object_store[:users].first
+  end
+
+  def override_user_factory_with(factory)
+    config = Terrestrial.config(datastore)
+      .setup_mapping(:users) { |users|
+        users.factory(factory)
+      }
+
+    @object_store = Terrestrial.object_store(
+      mappings: config,
+      datastore: datastore,
+    )
+  end
+
+  def seed_user(record)
+    datastore[:users].insert(record)
+  end
+end

data/spec/error_handling/serialization_error_spec.rb

@@ -0,0 +1,50 @@
+require "support/object_store_setup"
+
+RSpec.describe "Serialization error handling" do
+  include_context "object store setup"
+  context "when a domain object is incompatible with its serializer" do
+    before do
+      override_user_serializer_with(incompatible_custom_serializer)
+    end
+
+    let(:user) { Object.new }
+
+    let(:incompatible_custom_serializer) {
+      ->(x) { raise "I am incompatible" }
+    }
+
+    it "rescues and re-raises a more detailed error" do
+      error = nil
+      begin
+        save_user
+      rescue Terrestrial::SerializationError => error
+      end
+
+      expect(error.message).to eq(
+        [
+          "Error serializing object with mapping `users` `#{user.inspect}`.",
+          "Using serializer: `#{incompatible_custom_serializer.inspect}`.",
+          "Check the specified serializer can transform objects into a Hash.",
+          "Got Error: RuntimeError I am incompatible",
+        ].join("\n")
+      )
+    end
+
+    # TODO: make configuration easier override
+    def override_user_serializer_with(serializer)
+      config = Terrestrial.config(datastore)
+      .setup_mapping(:users) { |users|
+        users.serializer(serializer)
+      }
+
+      @object_store = Terrestrial.object_store(
+        mappings: config,
+        datastore: datastore,
+      )
+    end
+
+    def save_user
+      @object_store[:users].save(user)
+    end
+  end
+end

data/spec/error_handling/upsert_error_spec.rb

@@ -0,0 +1,132 @@
+require "support/object_store_setup"
+require "terrestrial/inspection_string"
+
+RSpec.describe "Upsert error handling" do
+  include_context "object store setup"
+  let(:user) { double(:user) }
+
+  context "with an record that raises error on persistence" do
+    before do
+      use_custom_serializer( ->(_) { unpersistable_record } )
+    end
+    let(:unpersistable_record) { UnpersistableRecord.new(original_error) }
+    let(:original_error) { RuntimeError.new("Cannot upsert") }
+
+    it "raises an UpsertError with detail of the original error" do
+      error = nil
+      begin
+        save_user
+      rescue Terrestrial::UpsertError => error
+      end
+
+      expect(error.message).to eq(
+        [
+          "Error upserting record into `users` with data `#{unpersistable_record}`.",
+          "Got Error: #{original_error.class} #{original_error.message}",
+        ].join("\n")
+      )
+    end
+  end
+
+  class UnpersistableRecord
+    include Terrestrial::InspectionString
+
+    def initialize(error)
+      @error = error
+    end
+
+    def to_h
+      # This is used in error reporting
+      self
+    end
+
+    def method_missing(*_)
+      # Raising on anything else ensures a problem while persisting
+      raise_if_upserting
+      self
+    end
+
+    private
+
+    def raise_if_upserting
+      raise(@error) if caller.any? { |line| /if_upsert/ === line }
+    end
+  end
+
+  context "serializer returns an extra field not in the schema" do
+    before do
+      use_custom_serializer(extra_field_serializer)
+    end
+
+    let(:extra_field_serializer) {
+      ->(_x) {
+        {
+          extra_field_that_does_not_match_column: "some value",
+          id: "users/999",
+          first_name: "Hansel",
+          last_name: "Trickett",
+          email: "hansel@tricketts.org",
+        }
+      }
+    }
+
+    it "filters the serialization result and raises no error" do
+      expect { save_user }.not_to raise_error
+    end
+  end
+
+  context "serialization result omits required fields" do
+    before do
+      use_custom_serializer(missing_id_serializer)
+    end
+
+    let(:missing_id_serializer) {
+      ->(_x) { serialization_result }
+    }
+
+    let(:serialization_result) {
+      object_attributes.reject { |k,v| k == :id }
+    }
+
+    let(:object_attributes) {
+      {
+        id: "users/999",
+        first_name: "Hansel",
+        last_name: "Trickett",
+        email: "hansel@tricketts.org",
+      }
+    }
+
+    it "raises an UpsertError with detail of the original error", backend: "sequel" do
+      error = nil
+      begin
+        save_user
+      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")
+      )
+    end
+  end
+
+  def save_user
+    @object_store[:users].save(user)
+  end
+
+  def use_custom_serializer(serializer)
+    config = Terrestrial.config(datastore)
+      .setup_mapping(:users) { |users|
+        users.serializer(serializer)
+      }
+
+    @object_store = Terrestrial.object_store(
+      mappings: config,
+      datastore: datastore,
+    )
+  end
+end