sequel_mapper 0.0.1 → 0.0.3

data/spec/graph_traversal_spec.rb

@@ -1,45 +1,46 @@
 require "spec_helper"
 
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
 require "sequel_mapper"
-require "support/graph_fixture"
 
 RSpec.describe "Graph traversal" do
-  include SequelMapper::GraphFixture
-
-  describe "assocaitions" do
-    subject(:graph) {
-      SequelMapper::Graph.new(
-        top_level_namespace: :users,
-        datastore: datastore,
-        relation_mappings: relation_mappings,
-      )
-    }
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  describe "associations" do
+    subject(:mapper) { user_mapper }
 
     let(:user_query) {
-      graph.where(id: "user/1")
+      mapper.where(id: "users/1")
     }
 
+    let(:user) { user_query.first }
+
     it "finds data via the storage adapter" do
-      expect(user_query.count).to be 1
+      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("user/1")
-      expect(user_query.first.first_name).to eq("Stephen")
+      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
-      expect(user_query.first.posts.first.subject)
-        .to eq("Object mapping")
+      post = user.posts.first
+
+      expect(post.subject).to eq("Biscuits")
     end
 
     it "handles nested has_many associations" do
       expect(
-        user_query.first
+        user
           .posts.first
           .comments.first
           .body
-      ).to eq("Trololol")
+      ).to eq("oh noes")
     end
 
     describe "lazy loading" do
@@ -53,33 +54,33 @@ RSpec.describe "Graph traversal" do
     end
 
     it "maps belongs to assocations" do
-      expect(user_query.first.posts.first.author.id)
-        .to eq("user/1")
+      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
-        expect(user_query.first.posts.first.author.__getobj__)
-          .to be(user_query.first)
+        post = user.posts.first
+        comment = post.comments.first
+
+        expect(comment.commenter.__getobj__)
+          .to be(user)
       end
     end
 
     it "maps deeply nested belongs to assocations" do
       expect(user_query.first.posts.first.comments.first.commenter.id)
-        .to eq("user/2")
+        .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(["category/1", "category/2"])
+        .to match_array(["categories/1", "categories/2"])
 
       expect(user_query.first.posts.first.categories.to_a.last.posts.map(&:id))
-        .to match_array(["post/1", "post/2"])
-    end
-
-    xit "combines has many through associations" do
-      expect(user_query.first.categories_posted_in.map(&:id))
-        .to match_array(["category/1", "category/2"])
+        .to match_array(["posts/1", "posts/2"])
     end
   end
 end

data/spec/new_graph_persistence_spec.rb

@@ -0,0 +1,69 @@
+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
+
+    it "persists one to many related nodes 2 levels deep" 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
+
+    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 "sequel_mapper"
+
+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

@@ -1,29 +1,59 @@
 require "spec_helper"
 
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
 require "sequel_mapper"
-require "support/graph_fixture"
+require "sequel_mapper/configurations/conventional_configuration"
 
 RSpec.describe "Ordered associations" do
-  include SequelMapper::GraphFixture
-
-  context "of type `has_many`" do
-    subject(:graph) {
-      SequelMapper::Graph.new(
-        top_level_namespace: :users,
-        datastore: datastore,
-        relation_mappings: relation_mappings,
-      )
-    }
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  subject(:user_mapper) {
+    SequelMapper.mapper(
+      config: mapper_config,
+      name: :users,
+      datastore: datastore,
+    )
+  }
+
 
-    let(:user) {
-      graph.where(id: "user/1").first
+  context "one to many association ordered by `created_at DESC`" do
+    let(:posts) { user_mapper.first.posts }
+
+    let(:mapper_config) {
+      SequelMapper::Configurations::ConventionalConfiguration.new(datastore)
+        .setup_mapping(:users) { |users|
+          users.has_many(:posts, foreign_key: :author_id, order_fields: [:created_at], order_direction: "DESC")
+        }
     }
 
     it "enumerates the objects in order specified in the config" do
-      user.toots.to_a
+      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
+    let(:mapper_config) {
+      SequelMapper::Configurations::ConventionalConfiguration.new(datastore)
+        .setup_mapping(:users) { |users|
+          users.has_many(:posts, foreign_key: :author_id)
+        }
+        .setup_mapping(:posts) { |posts|
+          posts.has_many_through(:categories, order_fields: [:name], order_direction: "DESC")
+        }
+    }
 
-      expect(user.toots.map(&:id).to_a)
-        .to eq(user.toots.to_a.sort_by { |t| t.tooted_at }.map(&:id).reverse)
+    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

data/spec/persistence_efficiency_spec.rb

@@ -0,0 +1,186 @@
+require "spec_helper"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "sequel_mapper"
+
+RSpec.describe "Graph persistence efficiency" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  let(:mapper) { user_mapper }
+  let(:user_query) { mapper.where(id: "users/1") }
+  let(:user) { user_query.first }
+
+  context "when modifying the root node" do
+    let(:modified_email) { "modified@example.com" }
+
+    context "and only the root node" do
+      before do
+        user.email = modified_email
+      end
+
+      it "performs 1 update" do
+        expect {
+          mapper.save(user)
+        }.to change { query_counter.update_count }.by(1)
+      end
+    end
+  end
+
+  context "when modifying a directly associated (has many) object" do
+    let(:modified_post_subject) { "modified post subject" }
+
+    before do
+      user.posts.first.subject = modified_post_subject
+    end
+
+    it "performs 1 update" do
+      expect {
+        mapper.save(user)
+      }.to change { query_counter.update_count }.by(1)
+    end
+
+    it "performs 0 deletes" do
+      expect {
+        mapper.save(user)
+      }.to change { query_counter.delete_count }.by(0)
+    end
+
+    it "performs 0 additional reads" do
+      expect {
+        mapper.save(user)
+      }.to change { query_counter.read_count }.by(0)
+    end
+  end
+
+  context "when loading many nodes of the graph" do
+    let(:post) {
+      user.posts.first
+    }
+
+    context "and modifying an intermediate node" do
+      before do
+        post.subject = "MODIFIED"
+      end
+
+      it "performs 1 write" do
+        expect {
+          mapper.save(user)
+        }.to change { query_counter.update_count }.by(1)
+      end
+    end
+
+    context "and modifying a leaf node" do
+      let(:comment) { post.comments.first }
+
+      before do
+        comment.body = "UPDATED!"
+      end
+
+      it "performs 1 update" do
+        expect {
+          mapper.save(user)
+        }.to change { query_counter.update_count }.by(1)
+      end
+    end
+
+    context "and modifying both a leaf and intermediate node" do
+      let(:comment) { post.comments.first }
+
+      before do
+        comment.body = "UPDATED!"
+        post.subject = "MODIFIED"
+      end
+
+      it "performs 2 updates" do
+        expect {
+          mapper.save(user)
+        }.to change { query_counter.update_count }.by(2)
+      end
+    end
+  end
+
+  context "when modifying a many to many association" do
+    let(:post) { user.posts.first }
+    let(:category) { post.categories.first }
+
+    before do
+      category.name = "UPDATED"
+    end
+
+    it "performs 1 write" do
+        expect {
+          mapper.save(user)
+        }.to change { query_counter.update_count }.by(1)
+    end
+  end
+
+  context "eager loading" do
+    context "on root node" do
+      it "performs 1 read per table rather than n + 1" do
+        expect {
+          mapper.eager_load(:posts => []).all.map { |user|
+            [user.id, user.posts.map(&:id)]
+          }
+        }.to change { query_counter.read_count }.by(2)
+      end
+    end
+
+    # mapper.eager_load([:posts, [:comments, [:author]]])
+
+    context "with nested has many" do
+      it "performs 1 read per table rather than n + 1" do
+        expect {
+          user_query
+            .eager_load(:posts => { :comments => [] })
+            .first
+            .posts
+            .map { |post| post.comments.map(&:id) }
+        }.to change { query_counter.read_count }.by(3)
+      end
+    end
+
+    context "with has many and belongs to" do
+      it "performs 1 read per table rather than n + 1" do
+        expect {
+          user_query
+            .eager_load(:posts => { :comments => { :commenter => [] }})
+            .flat_map { |u| u.posts.to_a }
+            .flat_map { |p| p.comments.to_a }
+            .flat_map { |c| c.commenter.id }
+        }.to change { query_counter.read_count }.by(4)
+      end
+    end
+
+    context "for has many to has many through" do
+      it "performs 1 read per table (including join table) rather than n + 1" do
+        expect {
+          user_query
+            .eager_load(:posts => { :categories => [] })
+            .flat_map { |u| u.posts.to_a }
+            .flat_map { |p| p.categories.to_a }
+            .flat_map { |c| c.id }
+        }.to change { query_counter.read_count }.by(4)
+      end
+    end
+
+    context "for has many through to has many" do
+      it "performs 1 read per table (includiing join table) rather than n + 1" do
+        expect {
+          user_query
+            .eager_load(:posts => { :categories => { :posts => [] }})
+            .flat_map { |u| u.posts.to_a }
+            .flat_map { |p| p.categories.to_a }
+            .flat_map { |c| c.posts.to_a }
+        }.to change { query_counter.read_count }.by(6)
+      end
+    end
+  end
+
+  after do |example|
+    query_counter.show_queries if example.exception
+  end
+end