terrestrial 0.1.1 → 0.3.0

data/spec/querying_spec.rb

@@ -1,19 +1,17 @@
 require "spec_helper"
 
-require "support/mapper_setup"
-require "support/sequel_persistence_setup"
+require "support/object_store_setup"
 require "support/seed_data_setup"
 require "terrestrial"
 
 RSpec.describe "Querying" 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(:query_criteria) {
@@ -31,12 +29,6 @@ RSpec.describe "Querying" do
       expect(filtered_posts.map(&:id)).to eq(["posts/2"])
     end
 
-    it "delegates the query to the datastore, performs two additiona reads" do
-      expect {
-        filtered_posts.map(&:id)
-      }.to change { query_counter.read_count }.by(2)
-    end
-
     it "returns another collection" do
       expect(filtered_posts).not_to be(user.posts)
     end

data/spec/readme_examples_spec.rb

@@ -1,20 +1,16 @@
 require "spec_helper"
 
-require "support/mapper_setup"
-require "support/sequel_persistence_setup"
+require "support/object_store_setup"
 require "support/seed_data_setup"
 require "terrestrial"
 
 require "spec_helper"
 
-require "support/mapper_setup"
-require "support/sequel_persistence_setup"
+require "support/object_store_setup"
 require "support/seed_data_setup"
 require "terrestrial"
 
 RSpec.describe "README examples" do
-  include_context "sequel persistence setup"
-
   readme_contents = File.read("README.md")
 
   code_samples = readme_contents
@@ -29,6 +25,7 @@ RSpec.describe "README examples" do
       rescue => e
         File.open("./example#{i}.rb", "w") { |f| f.puts(code_sample) }
         binding.pry if ENV["DEBUG"]
+        raise e
       end
     end
   end

data/spec/{persistence_efficiency_spec.rb → sequel_query_efficiency_spec.rb}

@@ -1,19 +1,86 @@
 require "spec_helper"
 
-require "support/mapper_setup"
-require "support/sequel_persistence_setup"
+require "support/object_store_setup"
 require "support/seed_data_setup"
 require "terrestrial"
 
-RSpec.describe "Graph persistence efficiency" do
-  include_context "mapper setup"
-  include_context "sequel persistence setup"
+RSpec.describe "Sequel query efficiency", backend: "sequel" do
+  include_context "object store setup"
   include_context "seed data setup"
 
-  let(:mapper) { user_mapper }
-  let(:user_query) { mapper.where(id: "users/1") }
+  let(:user_store) { object_store[:users] }
+  let(:user_query) { user_store.where(id: "users/1") }
   let(:user) { user_query.first }
 
+  context "when loading the root node" do
+    it "only performs one read" do
+      expect {
+        user
+      }.to change { query_counter.read_count }.by(1)
+    end
+  end
+
+  context "when traversing associations (lazily)" do
+    let(:user) { object_store[:users].where(id: "users/1").first }
+    let(:posts) { user.posts }
+
+    context "when getting a reference to an association proxy" do
+      before { user }
+
+      it "does no additional reads" do
+        expect{
+          user.posts
+        }.to change { query_counter.read_count }.by(0)
+      end
+    end
+
+    context "when iteratiing over a has many association" do
+      before { posts }
+
+      it "does a single additional read for the association collection" do
+        expect {
+          user.posts.each { |x| x }
+        }.to change { query_counter.read_count }.by(1)
+      end
+
+      context "when doing this more than once" do
+        before do
+          posts.each { |x| x }
+        end
+
+        it "performs no additional reads" do
+          expect {
+            user.posts.each { |x| x }
+          }.not_to change { query_counter.read_count }
+        end
+      end
+    end
+
+    context "when getting a reference to a many to many association" do
+      before { post }
+
+      let(:post) { user.posts.first }
+
+      it "does no additional reads" do
+        expect {
+          post.categories
+        }.to change { query_counter.read_count }.by(0)
+      end
+    end
+
+    context "when iterating over a many to many association" do
+      let(:category_count) { 3 }
+
+      it "does 1 read" do
+        post = user.posts.first
+
+        expect {
+          post.categories.each { |x| x }
+        }.to change { query_counter.read_count }.by(1)
+      end
+    end
+  end
+
   context "when modifying the root node" do
     let(:modified_email) { "modified@example.com" }
 
@@ -24,14 +91,15 @@ RSpec.describe "Graph persistence efficiency" do
 
       it "performs 1 update" do
         expect {
-          mapper.save(user)
+          user_store.save(user)
         }.to change { query_counter.update_count }.by(1)
       end
 
       it "sends only the updated fields to the datastore" do
-        mapper.save(user)
+        user_store.save(user)
         update_sql = query_counter.updates.last
 
+        # TODO: SQL parser?
         expect(update_sql).to eq(
           %{UPDATE "users" SET "email" = '#{modified_email}' WHERE ("id" = '#{user.id}')}
         )
@@ -48,19 +116,19 @@ RSpec.describe "Graph persistence efficiency" do
 
     it "performs 1 update" do
       expect {
-        mapper.save(user)
+        user_store.save(user)
       }.to change { query_counter.update_count }.by(1)
     end
 
     it "performs 0 deletes" do
       expect {
-        mapper.save(user)
+        user_store.save(user)
       }.to change { query_counter.delete_count }.by(0)
     end
 
     it "performs 0 additional reads" do
       expect {
-        mapper.save(user)
+        user_store.save(user)
       }.to change { query_counter.read_count }.by(0)
     end
   end
@@ -77,7 +145,7 @@ RSpec.describe "Graph persistence efficiency" do
 
       it "performs 1 write" do
         expect {
-          mapper.save(user)
+          user_store.save(user)
         }.to change { query_counter.update_count }.by(1)
       end
     end
@@ -91,7 +159,7 @@ RSpec.describe "Graph persistence efficiency" do
 
       it "performs 1 update" do
         expect {
-          mapper.save(user)
+          user_store.save(user)
         }.to change { query_counter.update_count }.by(1)
       end
     end
@@ -106,7 +174,7 @@ RSpec.describe "Graph persistence efficiency" do
 
       it "performs 2 updates" do
         expect {
-          mapper.save(user)
+          user_store.save(user)
         }.to change { query_counter.update_count }.by(2)
       end
     end
@@ -122,16 +190,16 @@ RSpec.describe "Graph persistence efficiency" do
 
     it "performs 1 write" do
         expect {
-          mapper.save(user)
+          user_store.save(user)
         }.to change { query_counter.update_count }.by(1)
     end
   end
 
-  context "eager loading" do
-    context "on root node" do
+  context "when traversing assocations (eagerly)" do
+    context "laoding `#all` from the object store with one assocation" do
       it "performs 1 read per table rather than n + 1" do
         expect {
-          mapper.eager_load(:posts => []).all.map { |user|
+          user_store.eager_load(:posts => []).all.map { |user|
             [user.id, user.posts.map(&:id)]
           }
         }.to change { query_counter.read_count }.by(2)
@@ -218,6 +286,20 @@ RSpec.describe "Graph persistence efficiency" do
     end
   end
 
+  context "when double saving a new object" do
+    context "when the first time is successful" do
+      before do
+        object_store[:users].save(hansel)
+      end
+
+      it "does not double write to the database" do
+        expect {
+          object_store[:users].save(hansel)
+        }.not_to change { query_counter.write_count }
+      end
+    end
+  end
+
   after do |example|
     query_counter.show_queries if example.exception
   end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require "pry"
 require "support/sequel_test_support"
+require "support/memory_adapter_test_support"
 require "support/blog_schema"
 
 RSpec.configure do |config|
@@ -29,8 +30,29 @@ RSpec.configure do |config|
 
   # Kernel.srand config.seed
 
+  adapter_support = case ENV.fetch("ADAPTER", "sequel")
+  when "memory"
+    Terrestrial::MemoryAdapterTestSupport
+  when "sequel"
+    Terrestrial::SequelTestSupport
+  else
+    raise "Adapter `#{ENV["ADAPTER"]}` not found"
+  end
+
+  def schema
+    BLOG_SCHEMA
+  end
+
+  RSpec.shared_context "adapter setup" do
+    let(:datastore) { adapter_support.build_datastore(schema) }
+    let(:query_counter) { adapter_support.query_counter }
+  end
+
+  config.include_context "adapter setup"
+
   config.before(:suite) do
-    Terrestrial::SequelTestSupport.drop_tables
-    Terrestrial::SequelTestSupport.create_tables(BLOG_SCHEMA)
+    adapter_support.before_suite(schema)
   end
+
+  config.filter_run_excluding(backend: adapter_support.excluded_adapters)
 end

data/spec/support/memory_adapter_test_support.rb

@@ -0,0 +1,21 @@
+require "terrestrial/adapters/memory_adapter"
+
+module Terrestrial
+  module MemoryAdapterTestSupport
+    module_function def build_datastore(schema, raw_storage = {})
+      Adapters::MemoryAdapter.build_from_schema(schema.fetch(:tables), raw_storage)
+    end
+
+    module_function def excluded_adapters
+      "sequel"
+    end
+
+    module_function def before_suite(_schema)
+      # NOOP
+    end
+
+    module_function def query_counter
+      # NOOP
+    end
+  end
+end

data/spec/support/{mapper_setup.rb → object_store_setup.rb}

@@ -1,5 +1,5 @@
 require "terrestrial"
-require "terrestrial/mapper_facade"
+require "terrestrial/relational_store"
 require "terrestrial/relation_mapping"
 require "terrestrial/lazy_collection"
 require "terrestrial/collection_mutability_proxy"
@@ -12,14 +12,14 @@ require "terrestrial/many_to_many_association"
 require "terrestrial/subset_queries_proxy"
 require "support/object_graph_setup"
 
-RSpec.shared_context "mapper setup" do
+RSpec.shared_context "object store setup" do
   include_context "object graph setup"
 
-  let(:mappers) {
-    Terrestrial.mappers(mappings: mappings, datastore: datastore)
+  let(:object_store) {
+    Terrestrial.object_store(mappings: mappings, datastore: datastore)
   }
 
-  let(:user_mapper) { mappers[:users] }
+  let(:user_store) { object_store[:users] }
 
   let(:mappings) {
     Hash[

data/spec/support/seed_data_setup.rb

@@ -3,7 +3,9 @@ RSpec.shared_context "seed data setup" do
   include_context "object graph setup"
 
   before {
-    insert_records(datastore, seeded_records)
+    seeded_records.each do |(namespace, record)|
+      datastore[namespace].insert(record)
+    end
   }
 
   let(:seeded_records) {

data/spec/support/sequel_test_support.rb

@@ -2,42 +2,66 @@ require "sequel"
 
 module Terrestrial
   module SequelTestSupport
-    def create_database
+    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
+
+        # The query_counter will let us make assertions about how efficiently
+        # the database is being used
+        reset_query_counter
+        db.loggers << query_counter
+      }
+    end
+
+    module_function def query_counter
+      @@query_counter ||= QueryCounter.new
+    end
+
+    module_function def before_suite(schema)
+      drop_tables
+      create_tables(schema.fetch(:tables))
+      add_foreign_keys(schema.fetch(:foreign_keys))
+    end
+
+    module_function def excluded_adapters
+      "memory"
+    end
+
+    module_function def reset_query_counter
+      @@query_counter = nil
+    end
+
+    module_function def create_database
       `psql postgres --command "CREATE DATABASE $PGDATABASE;"`
     end
-    module_function :create_database
 
-    def drop_database
+    module_function def drop_database
       `psql postgres --command "DROP DATABASE $PGDATABASE;"`
     end
-    module_function :drop_database
 
-    def drop_tables(tables = db_connection.tables)
+    module_function def drop_tables(tables = db_connection.tables)
       tables.each do |table_name|
         db_connection.drop_table(table_name, cascade: true)
       end
     end
-    module_function :drop_tables
 
-    def truncate_tables(tables = db_connection.tables)
+    module_function def truncate_tables(tables = db_connection.tables)
       tables.each do |table_name|
         db_connection[table_name].truncate(cascade: true)
       end
     end
-    module_function :truncate_tables
 
-    def db_connection
-      Sequel.default_timezone = :utc
-      @db_connection ||= Sequel.postgres(
+    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 }
     end
-    module_function :db_connection
 
-    def create_tables(schema)
-      schema.fetch(:tables).each do |table_name, fields|
+    module_function def create_tables(tables)
+      tables.each do |table_name, fields|
         db_connection.create_table(table_name) do
           fields.each do |field|
             type = field.fetch(:type)
@@ -49,20 +73,15 @@ module Terrestrial
         end
       end
 
-      schema.fetch(:foreign_keys).each do |(table, fk_col, foreign_table, key_col)|
+      tables.keys
+    end
+
+    module_function def add_foreign_keys(foreign_keys)
+      foreign_keys.each do |(table, fk_col, foreign_table, key_col)|
         db_connection.alter_table(table) do
           add_foreign_key([fk_col], foreign_table, key: key_col, deferrable: false, on_delete: :set_null)
         end
       end
-
-      schema.fetch(:tables).keys
-    end
-    module_function :create_tables
-
-    def insert_records(datastore, records)
-      records.each { |(namespace, record)|
-        datastore[namespace].insert(record)
-      }
     end
 
     class QueryCounter
@@ -88,16 +107,30 @@ module Terrestrial
         }
       end
 
+      def write_count
+        insert_count + update_count
+      end
+
       def update_count
         updates.count
       end
 
+      def insert_count
+        inserts.count
+      end
+
       def updates
         @info
           .map { |query| query.gsub(/\A\([0-9\.]+s\) /, "") }
           .select { |query| query.start_with?("UPDATE") }
       end
 
+      def inserts
+        @info
+          .map { |query| query.gsub(/\A\([0-9\.]+s\) /, "") }
+          .select { |query| query.start_with?("INSERT") }
+      end
+
       def show_queries
         puts @info.join("\n")
       end