terrestrial 0.1.0 → 0.1.1

data/spec/graph_persistence_spec.rb

@@ -0,0 +1,313 @@
+require "spec_helper"
+
+require "support/have_persisted_matcher"
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "terrestrial"
+
+RSpec.describe "Graph persistence" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  subject(:mapper) { mappers.fetch(:users) }
+
+  let(:user) {
+    mapper.where(id: "users/1").first
+  }
+
+  context "without associations" do
+    let(:modified_email) { "bestie+modified@gmail.com" }
+
+    it "saves the root object" do
+      user.email = modified_email
+      mapper.save(user)
+
+      expect(datastore).to have_persisted(
+        :users,
+        hash_including(
+          id: "users/1",
+          email: modified_email,
+        )
+      )
+    end
+
+    it "doesn't send associated objects to the database as columns" do
+      user.email = modified_email
+      mapper.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
+        user.email << "MUTATED"
+
+        mapper.save(user)
+
+        expect(datastore).to have_persisted(
+          :users,
+          hash_including(
+            id: "users/1",
+            email: /MUTATED$/,
+          )
+        )
+      end
+    end
+  end
+
+  context "modify shallow has many associated object" do
+    let(:post) { user.posts.first }
+    let(:modified_post_body) { "modified ur body" }
+
+    it "saves the associated object" do
+      post.body = modified_post_body
+      mapper.save(user)
+
+      expect(datastore).to have_persisted(
+        :posts,
+        hash_including(
+          id: post.id,
+          subject: post.subject,
+          author_id: user.id,
+          body: modified_post_body,
+        )
+      )
+    end
+  end
+
+  context "modify deeply nested has many associated object" do
+    let(:comment) {
+      user.posts.first.comments.first
+    }
+
+    let(:modified_comment_body) { "body moving, body moving" }
+
+    it "saves the associated object" do
+      comment.body = modified_comment_body
+      mapper.save(user)
+
+      expect(datastore).to have_persisted(
+        :comments,
+        hash_including(
+          {
+            id: "comments/1",
+            post_id: "posts/1",
+            commenter_id: "users/1",
+            body: modified_comment_body,
+          }
+        )
+      )
+    end
+  end
+
+  context "add a node to a has many association" do
+    let(:new_post_attrs) {
+      {
+        id: "posts/neu",
+        subject: "I am new",
+        body: "new body",
+        comments: [],
+        categories: [],
+        created_at: Time.now,
+      }
+    }
+
+    let(:new_post) {
+      Post.new(new_post_attrs)
+    }
+
+    it "adds the object to the graph" do
+      user.posts.push(new_post)
+
+      expect(user.posts).to include(new_post)
+    end
+
+    it "persists the object" do
+      user.posts.push(new_post)
+
+      mapper.save(user)
+
+      expect(datastore).to have_persisted(
+        :posts,
+        hash_including(
+          id: "posts/neu",
+          author_id: user.id,
+          subject: "I am new",
+        )
+      )
+    end
+  end
+
+  context "delete an object from a has many association" do
+    let(:post) { user.posts.first }
+
+    it "delete the object from the graph" do
+      user.posts.delete(post)
+
+      expect(user.posts.map(&:id)).not_to include(post.id)
+    end
+
+    it "delete the object from the datastore on save" do
+      user.posts.delete(post)
+      mapper.save(user)
+
+      expect(datastore).not_to have_persisted(
+        :posts,
+        hash_including(
+          id: post.id,
+        )
+      )
+    end
+  end
+
+  context "modify a many to many relationship" do
+    let(:post)     { user.posts.first }
+
+    context "delete a node" do
+      it "mutates the graph" do
+        category = post.categories.first
+        post.categories.delete(category)
+
+        expect(post.categories.map(&:id)).not_to include(category.id)
+      end
+
+      it "deletes the 'join table' record" do
+        category = post.categories.first
+        post.categories.delete(category)
+        mapper.save(user)
+
+        expect(datastore).not_to have_persisted(
+          :categories_to_posts,
+          {
+            post_id: post.id,
+            category_id: category.id,
+          }
+        )
+      end
+
+      it "does not delete the object" do
+        category = post.categories.first
+        post.categories.delete(category)
+        mapper.save(user)
+
+        expect(datastore).to have_persisted(
+          :categories,
+          hash_including(
+            id: category.id,
+          )
+        )
+      end
+    end
+
+    context "add a node" do
+      let(:post_with_one_category) { user.posts.to_a.last }
+      let(:new_category) { user.posts.first.categories.to_a.first }
+
+      it "mutates the graph" do
+        post_with_one_category.categories.push(new_category)
+
+        expect(post_with_one_category.categories.map(&:id))
+          .to match_array(["categories/1", "categories/2"])
+      end
+
+      it "persists the change" do
+        post_with_one_category.categories.push(new_category)
+        mapper.save(user)
+
+        expect(datastore).to have_persisted(
+          :categories_to_posts,
+          {
+            post_id: post_with_one_category.id,
+            category_id: new_category.id,
+          }
+        )
+      end
+    end
+
+    context "modify a node" do
+      let(:category) { user.posts.first.categories.first }
+      let(:modified_category_name) { "modified category" }
+
+      it "mutates the graph" do
+        category.name = modified_category_name
+
+        expect(post.categories.first.name)
+          .to eq(modified_category_name)
+      end
+
+      it "persists the change" do
+        category.name = modified_category_name
+        mapper.save(user)
+
+        expect(datastore).to have_persisted(
+          :categories,
+          {
+            id: category.id,
+            name: modified_category_name,
+          }
+        )
+      end
+    end
+
+    context "node loaded as root has undefined one to many association" do
+      let(:post_mapper) { mappers[:posts] }
+      let(:post) { post_mapper.where(id: "posts/1").first }
+
+      it "persists the changes to the root node" do
+        post.body = "modified body"
+
+        post_mapper.save(post)
+
+        expect(datastore).to have_persisted(
+          :posts,
+          hash_including(
+            id: "posts/1",
+            body: "modified body",
+          )
+        )
+      end
+
+      it "does not overwrite unused foreign key" do
+        post.body = "modified body"
+
+        post_mapper.save(post)
+
+        expect(datastore).to have_persisted(
+          :posts,
+          hash_including(
+            id: "posts/1",
+            author_id: "users/1",
+          )
+        )
+      end
+    end
+  end
+
+  context "when a save operation fails (some object is not persistable)" do
+    let(:unpersistable_object) { ->() { } }
+
+    it "rolls back the transaction" do
+      pre_change = datastore[:users].to_a.map(&:to_a).sort
+
+      begin
+        user.first_name = "this will be rolled back"
+        user.posts.first.subject = unpersistable_object
+
+        mapper.save(user)
+      rescue Sequel::Error
+      end
+
+      post_change = datastore[:users].to_a.map(&:to_a).sort
+
+      expect(pre_change).to eq(post_change)
+    end
+  end
+end

data/spec/graph_traversal_spec.rb

@@ -0,0 +1,121 @@
+require "spec_helper"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "terrestrial"
+
+RSpec.describe "Graph traversal" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  describe "associations" do
+    subject(:mapper) { user_mapper }
+
+    let(:user_query) {
+      mapper.where(id: "users/1")
+    }
+
+    let(:user) { user_query.first }
+
+    it "finds data via the storage adapter" do
+      expect(user_query.count).to eq(1)
+    end
+
+    it "maps the raw data from the store into domain objects" do
+      expect(user_query.first.id).to eq("users/1")
+      expect(user_query.first.first_name).to eq("Hansel")
+    end
+
+    it "handles has_many associations" do
+      post = user.posts.first
+
+      expect(post.subject).to eq("Biscuits")
+    end
+
+    it "handles nested has_many associations" do
+      expect(
+        user
+          .posts.first
+          .comments.first
+          .body
+      ).to eq("oh noes")
+    end
+
+    describe "lazy loading" do
+      let(:post_factory) { double(:post_factory, call: nil) }
+
+      it "loads has many associations lazily" do
+        posts = user_query.first.posts
+
+        expect(post_factory).not_to have_received(:call)
+      end
+    end
+
+    it "maps belongs to associations" do
+      post = user.posts.first
+      comment = post.comments.first
+
+      expect(comment.commenter.id).to eq("users/1")
+    end
+
+    describe "identity map" do
+      it "always returns (a proxy of) the same object for a given id" do
+        post = user.posts.first
+        comment = post.comments.first
+
+        expect(comment.commenter.__getobj__)
+          .to be(user)
+      end
+    end
+
+    it "maps deeply nested belongs to associations" do
+      expect(user_query.first.posts.first.comments.first.commenter.id)
+        .to eq("users/1")
+    end
+
+    it "maps has many to many associations as has many through" do
+      expect(user_query.first.posts.first.categories.map(&:id))
+        .to match_array(["categories/1", "categories/2"])
+
+      expect(user_query.first.posts.first.categories.to_a.last.posts.map(&:id))
+        .to match_array(["posts/1", "posts/2", "posts/3"])
+    end
+
+    describe "eager_loading" do
+      it "returns the expected objects" do
+        expect(
+          user_query
+            .eager_load(:posts => { :categories => { :posts => [] }})
+            .flat_map(&:posts)
+            .flat_map(&:categories)
+            .map(&:posts)
+            .map { |collection| collection.map(&:id) }
+        ).to eq([["posts/1"]] + [["posts/1", "posts/2", "posts/3"]] * 2)
+      end
+
+      context "when traversing beyond the eager loaded data" do
+        it "returns the expected objects" do
+          expect(
+            user_query
+              .eager_load(:posts => { :categories => { :posts => [] }})
+              .flat_map(&:posts)
+              .flat_map(&:categories)
+              .flat_map(&:posts)
+              .flat_map(&:categories)
+              .flat_map(&:posts)
+              .flat_map(&:categories)
+              .uniq
+              .map(&:id)
+          ).to eq([
+            "categories/1",
+            "categories/2",
+            "categories/3",
+            "categories/4",
+          ])
+        end
+      end
+    end
+  end
+end

data/spec/new_graph_persistence_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/have_persisted_matcher"
+
+RSpec.describe "Persist a new graph in empty datastore" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+
+  context "given a graph of new objects" do
+    it "persists the root node" do
+      user_mapper.save(hansel)
+
+      expect(datastore).to have_persisted(:users, {
+        id: hansel.id,
+        first_name: hansel.first_name,
+        last_name: hansel.last_name,
+        email: hansel.email,
+      })
+    end
+
+    it "persists one to many related nodes 1 level deep" do
+      user_mapper.save(hansel)
+
+      expect(datastore).to have_persisted(:posts, hash_including(
+        id: "posts/1",
+        subject: "Biscuits",
+        body: "I like them",
+        author_id: "users/1",
+      ))
+
+      expect(datastore).to have_persisted(:posts, hash_including(
+        id: "posts/2",
+        subject: "Sleeping",
+        body: "I do it three times purrr day",
+        author_id: "users/1",
+      ))
+    end
+
+    context "deep node with two foreign keys" do
+      it "persists the node with both foreign keys" do
+        user_mapper.save(hansel)
+
+        expect(datastore).to have_persisted(:comments, {
+          id: "comments/1",
+          body: "oh noes",
+          post_id: "posts/1",
+          commenter_id: "users/1",
+        })
+      end
+    end
+
+    it "persists many to many related nodes" do
+      user_mapper.save(hansel)
+
+      expect(datastore).to have_persisted(:categories, {
+        id: "categories/1",
+        name: "Cat biscuits",
+      })
+    end
+
+    it "persists a 'join table' to faciliate many to many" do
+      user_mapper.save(hansel)
+
+      expect(datastore).to have_persisted(:categories_to_posts, {
+        category_id: "categories/1",
+        post_id: "posts/1",
+      })
+    end
+  end
+end

data/spec/object_identity_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "terrestrial"
+
+RSpec.describe "Object identity" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  subject(:mapper) { mappers.fetch(:users) }
+
+  let(:user) { mapper.where(id: "users/1").first }
+  let(:post) { user.posts.first }
+
+  context "when using arbitrary where query" do
+    it "returns the same object for a row's primary key" do
+      expect(
+        user.posts.where(id: post.id).first
+      ).to be(post)
+    end
+  end
+
+  context "when traversing deep into the graph" do
+    context "via has many through" do
+      it "returns the same object for a row's primary key" do
+        expect(
+          user.posts.first.categories.first.posts
+            .find { |cat_post| cat_post.id == post.id }
+        ).to be(post)
+      end
+    end
+
+    context "via a belongs to" do
+      it "returns the same object for a row's primary once loaded" do
+        # TODO: Add another method to avoid using #__getobj__
+        expect(
+          user.posts.first.comments
+            .find { |comment| comment.commenter.id == user.id }
+            .commenter
+            .__getobj__
+        ).to be(user)
+      end
+    end
+
+    context "when eager loading" do
+      let(:user_query) { mapper.where(id: "users/1") }
+
+      let(:eager_category) {
+        user_query
+          .eager_load(:posts => { :categories => { :posts => [] }})
+          .first
+          .posts
+          .first
+          .categories
+          .first
+      }
+
+      it "returns the same object for a row's primary once loaded" do
+        expect(
+          eager_category
+            .posts
+            .find { |cat_post| cat_post.id == post.id }
+        ).to be(post)
+      end
+    end
+  end
+end

data/spec/ordered_association_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "terrestrial"
+require "terrestrial/configurations/conventional_configuration"
+
+RSpec.describe "Ordered associations" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  context "one to many association ordered by `created_at DESC`" do
+    let(:posts) { user_mapper.first.posts }
+
+    before do
+      configs.fetch(:users).fetch(:associations).fetch(:posts).merge!(
+        order: Terrestrial::QueryOrder.new(
+          fields: [:created_at],
+          direction: "DESC",
+        )
+      )
+    end
+
+    it "enumerates the objects in order specified in the config" do
+      expect(posts.map(&:id)).to eq(
+        posts.to_a.sort_by(&:created_at).reverse.map(&:id)
+      )
+    end
+  end
+
+  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",
+        )
+      )
+    end
+
+    let(:categories) { user_mapper.first.posts.first.categories }
+
+    it "enumerates the objects in order specified in the config" do
+      expect(categories.map(&:id)).to eq(
+        categories.to_a.sort_by(&:name).reverse.map(&:id)
+      )
+    end
+  end
+end