terrestrial 0.3.0 → 0.5.0

data/spec/changes_api_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+require "support/object_store_setup"
+require "support/seed_data_setup"
+require "support/have_persisted_matcher"
+require "terrestrial"
+
+RSpec.describe "Changes API", backend: "sequel" do
+  include_context "object store setup"
+  include_context "seed data setup"
+
+  subject(:user_store) { object_store.fetch(:users) }
+
+  let(:user) {
+    user_store.where(id: "users/1").first
+  }
+
+  describe "#changes" do
+    context "when there are no changes" do
+      it "returns an empty change set" do
+        expect(user_store.changes(user)).to be_empty
+      end
+    end
+
+    context "when loading and modifying only the root node" do
+      let(:modified_email) { "hasel+modified@gmail.com" }
+
+      it "returns changes to only that node" do
+        user.email = modified_email
+
+        expect(user_store.changes(user).map(&:to_h)).to eq(
+          [
+            {
+              id: "users/1",
+              email: modified_email,
+            }
+          ]
+        )
+      end
+
+      it "does not persist the changes" do
+        user.email = modified_email
+
+        user_store.changes(user)
+
+        expect(datastore).not_to have_persisted(
+          :users,
+          hash_including(
+            id: user.id,
+            email: modified_email,
+          )
+        )
+      end
+    end
+  end
+
+  describe "#changes_sql" do
+    context "when there are no changes" do
+      it "returns an empty list" do
+        expect(user_store.changes_sql(user)).to be_empty
+      end
+    end
+
+    context "when loading and modifying only the root node" do
+      let(:modified_email) { "hasel+modified@gmail.com" }
+
+      it "returns the upsert statement for just that change" do
+        user.email = modified_email
+
+        expect(user_store.changes_sql(user)).to eq(
+          [
+            "INSERT INTO \"users\" (\"email\", \"id\") VALUES " \
+              "('hasel+modified@gmail.com', 'users/1') ON CONFLICT (\"id\") " \
+              "DO UPDATE SET \"email\" = 'hasel+modified@gmail.com' " \
+              "RETURNING *",
+          ]
+        )
+      end
+    end
+  end
+end

data/spec/config_override_spec.rb

@@ -12,19 +12,16 @@ RSpec.describe "Configuration override" do
   include_context "seed data setup"
 
   let(:object_store) {
-    Terrestrial.object_store(mappings: override_config, datastore: datastore)
+    Terrestrial.object_store(config: override_config)
   }
 
   let(:override_config) {
-    Terrestrial::Configurations::ConventionalConfiguration.new(datastore)
+    Terrestrial::config(datastore)
       .setup_mapping(:users) { |users|
         users.has_many :posts, foreign_key: :author_id
         users.fields([:id, :first_name, :last_name, :email])
       }
-  }
-
-  let(:user) {
-    object_store[:users].where(id: "users/1").first
+      .setup_mapping(:posts)
   }
 
   context "override the root mapper factory" do
@@ -38,6 +35,8 @@ RSpec.describe "Configuration override" do
       let(:user_struct) { Struct.new(*User.members) }
 
       it "uses the class from the override" do
+        user = object_store[:users].where(id: "users/1").first
+
         expect(user.class).to be(user_struct)
       end
     end
@@ -58,11 +57,10 @@ RSpec.describe "Configuration override" do
         post_class.method(:new)
       }
 
-      let(:posts) {
-        user.posts
-      }
-
       it "uses the specified factory" do
+        user = object_store[:users].where(id: "users/1").first
+        posts = user.posts
+
         expect(posts.first.class).to be(post_class)
       end
     end
@@ -79,12 +77,11 @@ RSpec.describe "Configuration override" do
       end
 
       let(:override_config) {
-        Terrestrial::Configurations::ConventionalConfiguration
-        .new(datastore)
-        .setup_mapping(:users) do |config|
-          config.relation_name unconventional_table_name
-          config.class(OpenStruct)
-        end
+        Terrestrial.config(datastore)
+          .setup_mapping(:users) do |config|
+            config.relation_name unconventional_table_name
+            config.class(OpenStruct)
+          end
       }
 
       let(:unconventional_table_name) {
@@ -131,12 +128,12 @@ RSpec.describe "Configuration override" do
             config.class(OpenStruct)
             config.relation_name strange_table_name_map.fetch(:posts)
             config.belongs_to(:author, mapping_name: :users)
-            config.has_many_through(:categories, through_mapping_name: strange_table_name_map.fetch(:categories_to_posts))
+            config.has_many_through(:categories, through_table_name: strange_table_name_map.fetch(:categories_to_posts))
           end
           .setup_mapping(:categories) do |config|
             config.class(OpenStruct)
             config.relation_name strange_table_name_map.fetch(:categories)
-            config.has_many_through(:posts, through_mapping_name: strange_table_name_map.fetch(:categories_to_posts))
+            config.has_many_through(:posts, through_table_name: strange_table_name_map.fetch(:categories_to_posts))
           end
       end
 
@@ -150,12 +147,24 @@ RSpec.describe "Configuration override" do
       }
 
       it "maps data from the specified relation into a has many collection" do
+        user = object_store[:users].where(id: "users/1").first
+
         expect(
           user.posts.map(&:id)
         ).to eq(["posts/1", "posts/2"])
       end
 
+      it "maps data from the specified relation into a has many through collection" do
+        user = object_store[:users].where(id: "users/1").first
+
+        expect(
+          user.posts.flat_map(&:categories).map(&:id).uniq
+        ).to eq(["categories/1", "categories/2"])
+      end
+
       it "maps data from the specified relation into a `belongs_to` field" do
+        user = object_store[:users].where(id: "users/1").first
+
         expect(
           user.posts.first.author.__getobj__.object_id
         ).to eq(user.object_id)
@@ -168,7 +177,7 @@ RSpec.describe "Configuration override" do
     TypeTwoUser = Class.new(OpenStruct)
 
     let(:override_config) {
-      Terrestrial::Configurations::ConventionalConfiguration.new(datastore)
+      Terrestrial.config(datastore)
         .setup_mapping(:t1_users) { |c|
           c.class(TypeOneUser)
           c.table_name(:users)

data/spec/custom_serializers_spec.rb

@@ -25,8 +25,9 @@ RSpec.describe "Config override" do
 
     before do
       mappings
-        .fetch(:users)
-        .instance_variable_set(:@serializer, user_serializer)
+        .setup_mapping(:users) { |users|
+          users.serializer(user_serializer)
+        }
     end
 
     context "when saving the object" do

data/spec/database_default_fields_spec.rb

@@ -0,0 +1,213 @@
+require "spec_helper"
+
+require "support/have_persisted_matcher"
+require "support/object_store_setup"
+require "support/seed_data_setup"
+
+RSpec.describe "Database default 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
+
+  before do
+    clean_db_timestamp_tables
+  end
+
+  let(:user_store) {
+    object_store[:users]
+  }
+
+  let(:object_store) {
+    Terrestrial.object_store(config: with_db_default_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(:party_time) { Time.parse("1999-01-01 00:00:00 UTC") }
+
+  let(:with_db_default_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_default_field(:created_at)
+        posts.database_default_field(:updated_at)
+      }
+  }
+
+  context "new objects" do
+    context "when the object's value is nil" do
+      before do
+        post.created_at = nil
+      end
+
+      it "updates the object with the new default value" do
+        expect(post).to receive(:created_at=).with(an_instance_of(Time))
+
+        user_store.save(user_with_post)
+      end
+    end
+
+    context "when the object's value has been set to something" do
+      before do
+        post.created_at = party_time
+      end
+
+      it "does not set a value on the object" do
+        expect(post).not_to receive(:created_at=).with(party_time)
+
+        user_store.save(user_with_post)
+      end
+
+      it "persists the user-defined value" do
+        user_store.save(user_with_post)
+
+        expect(datastore).to have_persisted(
+          :timestamped_posts,
+          hash_including(
+            id: post.id,
+            created_at: party_time,
+          )
+        )
+      end
+    end
+  end
+
+  context "updating existing objects" do
+    before do
+      user_store.save(user_with_post)
+      post.body = "new body"
+    end
+
+    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
+
+    context "when the value changes in the database (e.g. a trigger)" do
+      before do
+        datastore[:timestamped_posts]
+          .where(id: post.id)
+          .update("created_at" => party_time)
+      end
+
+      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 object's value is modified by the application"  do
+      it "does not modify the object" do
+        original_time = post.created_at
+        post.created_at = party_time
+
+        expect(post).not_to receive(:created_at=)
+
+        user_store.save(user_with_post)
+        expect(post.created_at).to eq(party_time)
+      end
+
+      it "persists the object's new value" do
+        post.created_at = party_time
+
+        user_store.save(user_with_post)
+
+        expect(datastore).to have_persisted(
+          :timestamped_posts,
+          hash_including(
+            id: post.id,
+            created_at: party_time,
+          )
+        )
+      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 clean_db_timestamp_tables
+    Terrestrial::SequelTestSupport.clean_tables(schema.fetch(:tables).keys)
+  end
+
+  def drop_db_timestamp_tables
+    Terrestrial::SequelTestSupport.drop_tables(schema.fetch(:tables).keys)
+  end
+end

data/spec/database_generated_id_spec.rb

@@ -0,0 +1,291 @@
+require "spec_helper"
+
+require "support/have_persisted_matcher"
+require "support/object_store_setup"
+require "support/seed_data_setup"
+
+RSpec.describe "Database generated IDs", backend: "sequel" do
+  include_context "object store setup"
+
+  before(:all) do
+    create_serial_id_tables
+  end
+
+  after(:all) do
+    drop_serial_id_tables
+  end
+
+  before(:each) do
+    clean_serial_id_tables
+  end
+
+  let(:user_store) {
+    object_store[:users]
+  }
+
+  let(:object_store) {
+    Terrestrial.object_store(config: serial_id_config)
+  }
+
+  let(:user) {
+    User.new(user_attrs)
+  }
+
+  let(:user_attrs) {
+    {
+      id: nil,
+      first_name: "Hansel",
+      last_name: "Trickett",
+      email: "hansel@tricketts.org",
+      posts: [],
+    }
+  }
+
+  let(:serial_id_config) {
+    Terrestrial.config(datastore)
+      .setup_mapping(:users) { |users|
+        users.use_database_id
+        users.relation_name(:serial_id_users)
+        users.has_many(:posts, foreign_key: :author_id)
+      }
+      .setup_mapping(:posts) { |posts|
+        posts.use_database_id
+        posts.relation_name(:serial_id_posts)
+      }
+  }
+
+  it "persists the root node" do
+    expected_sequence_id = get_next_sequence_value("serial_id_users")
+
+    user_store.save(user)
+
+    expect(datastore).to have_persisted(
+      :serial_id_users,
+      hash_including(
+        id: expected_sequence_id,
+        first_name: hansel.first_name,
+        last_name: hansel.last_name,
+        email: hansel.email,
+      )
+    )
+  end
+
+  it "updates the object with serial database ID" do
+    expected_sequence_id = get_next_sequence_value("serial_id_users")
+
+    user_store.save(user)
+
+    expect(user.id).to eq(expected_sequence_id)
+  end
+
+  context "when persisting two associated objects" do
+    before { user.posts.push(post) }
+
+    let(:post) { Post.new(post_attrs) }
+
+    let(:post_attrs) {
+      {
+        id: nil,
+        author: nil,
+        subject: "Biscuits",
+        body: "I like them",
+        comments: [],
+        categories: [],
+        created_at: Time.parse("2015-09-05T15:00:00+01:00"),
+        updated_at: Time.parse("2015-09-05T15:00:00+01:00"),
+      }
+    }
+
+    it "persists both objects" do
+      expected_user_sequence_id = get_next_sequence_value("serial_id_users")
+      expected_post_sequence_id = get_next_sequence_value("serial_id_posts")
+
+      user_store.save(user)
+
+      expect(datastore).to have_persisted(
+        :serial_id_users,
+        hash_including(
+          id: expected_user_sequence_id,
+          first_name: hansel.first_name,
+          last_name: hansel.last_name,
+          email: hansel.email,
+        )
+      )
+
+      expect(datastore).to have_persisted(
+        :serial_id_posts,
+        hash_including(
+          id: expected_post_sequence_id,
+          subject: "Biscuits",
+          body: "I like them",
+          created_at: Time.parse("2015-09-05T15:00:00+01:00"),
+        )
+      )
+    end
+
+    it "writes the foreign key" do
+      user_store.save(user)
+
+      expect(datastore[:serial_id_posts].first.fetch(:author_id)).to eq(user.id)
+    end
+  end
+
+  context "after an initial successful save of the object graph" do
+    before do
+      user_store.save(user)
+    end
+
+    context "when saving again without modifications" do
+      it "does not perform any more database writes" do
+        expect {
+          user_store.save(user)
+        }.not_to change { query_counter.write_count }
+      end
+
+      it "does not produce any change records" do
+        expect(user_store.changes(user)).to be_empty
+      end
+    end
+  end
+
+  context "when updating an existing record" do
+    before do
+      user_store.save(user)
+    end
+
+    it "performs an update" do
+      new_email = "hansel+alternate@gmail.com"
+      user.email = new_email
+
+      user_store.save(user)
+
+      expect(datastore).to have_persisted(
+        :serial_id_users,
+        hash_including(
+          id: user.id,
+          email: new_email,
+        )
+      )
+    end
+  end
+
+  context "when the user id must be set by an unconventional method" do
+    before do
+      change_objects_id_setter_method(user)
+    end
+
+    let(:serial_id_config) {
+      Terrestrial.config(datastore)
+        .setup_mapping(:users) { |users|
+          users.use_database_id { |object, new_id| object.unusual_id_setter(new_id) }
+          users.relation_name(:serial_id_users)
+        }
+    }
+
+    it "calls the user-defined config block which should update the ID" do
+      next_id = get_next_sequence_value(:serial_id_users)
+      expect(user).to receive(:unusual_id_setter).with(next_id)
+      expect(user).not_to receive(:id=)
+
+      user_store.save(user)
+    end
+
+    def change_objects_id_setter_method(user)
+      def user.id=(*args)
+        raise "This method should not be called"
+      end
+
+      def user.unusual_id_setter(value)
+        @id = value
+      end
+    end
+  end
+
+  def serial_id_schema
+    {
+      :tables => {
+        :serial_id_users => [
+          {
+            :name => :id,
+            :type => Integer,
+            :options => {
+              :primary_key => true,
+              :serial => true,
+            },
+          },
+          {
+            :name => :first_name,
+            :type => String,
+          },
+          {
+            :name => :last_name,
+            :type => String,
+          },
+          {
+            :name => :email,
+            :type => String,
+          },
+        ],
+        :serial_id_posts => [
+          {
+            :name => :id,
+            :type => Integer,
+            :options => {
+              :primary_key => true,
+              :serial => true,
+            },
+          },
+          {
+            :name => :subject,
+            :type => String,
+          },
+          {
+            :name => :body,
+            :type => String,
+          },
+          {
+            :name => :author_id,
+            :type => Integer,
+          },
+          {
+            :name => :created_at,
+            :type => DateTime,
+          },
+        ],
+      },
+      :foreign_keys => [
+        [
+          :posts,
+          :author_id,
+          :users,
+          :id,
+        ],
+      ],
+    }
+  end
+
+  def create_serial_id_tables
+    Terrestrial::SequelTestSupport.create_tables(serial_id_schema.fetch(:tables))
+  end
+
+  def drop_serial_id_tables
+    Terrestrial::SequelTestSupport.drop_tables(serial_id_schema.fetch(:tables).keys)
+  end
+
+  def clean_serial_id_tables
+    Terrestrial::SequelTestSupport.clean_tables(serial_id_schema.fetch(:tables).keys)
+  end
+
+  def get_next_sequence_value(table_name)
+    datastore["select currval(pg_get_serial_sequence('#{table_name}', 'id'))"]
+      .to_a
+      .fetch(0)
+      .fetch(:currval) + 1
+  rescue Sequel::DatabaseError => e
+    if /PG::ObjectNotInPrerequisiteState/.match?(e.message)
+      1
+    else
+      raise e
+    end
+  end
+end