sequel_mapper 0.0.1

data/spec/ordered_association_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+require "sequel_mapper"
+require "support/graph_fixture"
+
+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,
+      )
+    }
+
+    let(:user) {
+      graph.where(id: "user/1").first
+    }
+
+    it "enumerates the objects in order specified in the config" do
+      user.toots.to_a
+
+      expect(user.toots.map(&:id).to_a)
+        .to eq(user.toots.to_a.sort_by { |t| t.tooted_at }.map(&:id).reverse)
+    end
+  end
+end

data/spec/proxying_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+require "sequel_mapper"
+require "support/graph_fixture"
+
+RSpec.describe "Proxying 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,
+      )
+    }
+
+    let(:user) {
+      graph.where(id: "user/1").first
+    }
+
+    let(:posts) { user.posts }
+
+    def identity
+      ->(x){x}
+    end
+
+    describe "limiting datastore reads" do
+      context "when loading the root node" do
+        it "only performs one read" do
+          user
+
+          expect(query_counter.read_count).to eq(1)
+        end
+      end
+
+      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 assocation collection" do
+          expect {
+            user.posts.map(&identity)
+          }.to change { query_counter.read_count }.by(1)
+        end
+      end
+
+      context "when getting a reference to a many to many assocation" 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 assocation" do
+        let(:category_count) { 3 }
+
+        it "does 1 read" do
+          post = user.posts.first
+
+          expect {
+            post.categories.map(&:name).to_a
+          }.to change { query_counter.read_count }.by(1)
+        end
+      end
+    end
+  end
+end

data/spec/querying_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+require "sequel_mapper"
+require "support/graph_fixture"
+
+RSpec.describe "Querying" do
+  include SequelMapper::GraphFixture
+
+  subject(:graph) {
+    SequelMapper::Graph.new(
+      top_level_namespace: :users,
+      datastore: datastore,
+      relation_mappings: relation_mappings,
+    )
+  }
+
+  let(:user) {
+    graph.where(id: "user/1").first
+  }
+
+  let(:query_criteria) {
+    {
+      body: "Lazy load all the things!",
+    }
+  }
+
+  describe "arbitrary where query" do
+    it "returns a filtered version of the association" do
+      expect(
+        user.posts
+          .where(query_criteria)
+          .map(&:id)
+      ).to eq(["post/2"])
+    end
+
+    it "sends the query directly to the datastore" do
+      expect {
+        user.posts
+          .where(query_criteria)
+          .map(&:id)
+      }.to change { query_counter.read_count }.by(2)
+
+      # TODO: this is a quick hack to assert that no superfluous records where
+      #       loaded. Figure out a better way to check efficiency
+      expect(graph.send(:identity_map).values.map(&:id)).to match_array([
+        "user/1",
+        "post/2",
+      ])
+    end
+  end
+end

data/spec/sequel_mapper/association_proxy_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+require "sequel_mapper/association_proxy"
+
+RSpec.describe SequelMapper::AssociationProxy do
+  let(:proxy) {
+    SequelMapper::AssociationProxy.new(lazy_enum)
+  }
+
+  let(:lazy_enum) { data_set.each.lazy }
+  let(:data_set) { (0..9) }
+
+  def id
+    ->(x) { x }
+  end
+
+  it "is Enumerable" do
+    expect(proxy).to be_a(Enumerable)
+  end
+
+  describe "#to_a" do
+    it "is equivalent to the original enumeration" do
+      expect(proxy.map(&id)).to eq(data_set.to_a)
+    end
+  end
+
+  describe "#each" do
+    context "when called with a block" do
+      it "returns self" do
+        expect(proxy.each(&id)).to eq(proxy)
+      end
+
+      it "yields each element to the block" do
+        yielded = []
+
+        proxy.each do |element|
+          yielded.push(element)
+        end
+
+        expect(yielded).to eq(data_set.to_a)
+      end
+
+      context "when calling each more than once" do
+        before do
+          proxy.each { |x| nil }
+          proxy.each { |x| nil }
+        end
+
+        it "rewinds the enumeration on each call" do
+          expect(proxy.map(&id)).to eq(data_set.to_a)
+        end
+      end
+    end
+
+    context "when called without a block" do
+      it "returns an enumerator" do
+        expect(proxy.each).to be_a(Enumerator)
+      end
+    end
+  end
+
+  describe "#remove" do
+    it "returns self" do
+      expect(proxy.remove(3)).to be(proxy)
+    end
+
+    context "after removing a element from the enumeration" do
+      before do
+        proxy.remove(3)
+      end
+
+      it "skips that element in the enumeration" do
+        expect(proxy.map(&id)).to eq([0,1,2,4,5,6,7,8,9])
+      end
+    end
+  end
+
+  describe "#push" do
+    context "after pushing another element into the enumeration" do
+      before do
+        proxy.push(new_value)
+      end
+
+      let(:new_value) { double(:new_value) }
+
+      it "does not alter the other elements" do
+        expect(proxy.map(&id)[0..-2]).to eq([0,1,2,3,4,5,6,7,8,9])
+      end
+
+      it "appends the element to the enumeration" do
+        expect(proxy.map(&id).last).to eq(new_value)
+      end
+    end
+  end
+end

data/spec/sequel_mapper/belongs_to_association_proxy_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+require "sequel_mapper/belongs_to_association_proxy"
+
+RSpec.describe BelongsToAssociationProxy do
+  subject(:proxy) { BelongsToAssociationProxy.new(object_loader) }
+
+  let(:object_loader)   { double(:object_loader, call: proxied_object) }
+  let(:proxied_object)  { double(:proxied_object, name: name) }
+  let(:name)            { double(:name) }
+
+  describe "#__getobj__" do
+    it "loads the object" do
+      proxy.__getobj__
+
+      expect(object_loader).to have_received(:call)
+    end
+
+    it "returns the proxied object" do
+      expect(proxy.__getobj__).to be(proxied_object)
+    end
+  end
+
+  context "when no method is called on it" do
+    it "does not call the loader" do
+      proxy
+
+      expect(object_loader).not_to have_received(:call)
+    end
+  end
+
+  context "when a missing method is called on the proxy" do
+    it "is a true decorator" do
+      expect(proxied_object).to receive(:arbitrary_message)
+
+      proxy.arbitrary_message
+    end
+
+    it "loads the object" do
+      proxy.name
+
+      expect(object_loader).to have_received(:call)
+    end
+
+    it "returns delegates the message to the object" do
+      args = [ double, double ]
+      proxy.name(*args)
+
+      expect(proxied_object).to have_received(:name).with(*args)
+    end
+
+    it "returns the objects return value" do
+      expect(proxy.name).to eq(name)
+    end
+
+    context "when calling a method twice" do
+      it "loads the object once" do
+        proxy.name
+        proxy.name
+
+        expect(object_loader).to have_received(:call)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require "pry"
+require "sequel"
+require "logger"
+
+`psql postgres --command "CREATE DATABASE $PGDATABASE;"`
+
+DB = Sequel.postgres(
+  host: ENV.fetch("PGHOST"),
+  user: ENV.fetch("PGUSER"),
+  database: ENV.fetch("PGDATABASE"),
+)
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.disable_monkey_patching!
+
+  # TODO: get everything running without warnings
+  config.warnings = false
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  # config.profile_examples = 10
+
+  # config.order = :random
+
+  # Kernel.srand config.seed
+end

data/spec/support/graph_fixture.rb

@@ -0,0 +1,331 @@
+require "support/mock_sequel"
+require "sequel_mapper/struct_factory"
+require "support/query_counter"
+
+module SequelMapper
+  module GraphFixture
+
+    # A little hack so these let blocks from an RSpec example don't have
+    # to change
+    def self.let(name, &block)
+      define_method(name) {
+        instance_variable_get("@#{name}") or
+          instance_variable_set("@#{name}", instance_eval(&block))
+      }
+    end
+
+    User = Struct.new(:id, :first_name, :last_name, :email, :posts, :toots)
+    Post = Struct.new(:id, :author, :subject, :body, :comments, :categories)
+    Comment = Struct.new(:id, :post, :commenter, :body)
+    Category = Struct.new(:id, :name, :posts)
+    Toot = Struct.new(:id, :tooter, :body, :tooted_at)
+
+    let(:query_counter) {
+      QueryCounter.new
+    }
+
+    let(:datastore) {
+      DB.tap { |db|
+        load_fixture_data(db)
+        db.loggers << query_counter
+      }
+    }
+
+    def load_fixture_data(datastore)
+      tables.each do |table, rows|
+
+        datastore.drop_table?(table)
+
+        datastore.create_table(table) do
+          rows.first.keys.each do |column|
+            String column
+          end
+        end
+
+        rows.each do |row|
+          datastore[table].insert(row)
+        end
+      end
+    end
+
+    let(:tables) {
+      {
+        users: [
+          user_1_data,
+          user_2_data,
+          user_3_data,
+        ],
+        posts: [
+          post_1_data,
+          post_2_data,
+        ],
+        comments: [
+          comment_1_data,
+          comment_2_data,
+        ],
+        categories: [
+          category_1_data,
+          category_2_data,
+        ],
+        categories_to_posts: [
+          {
+            post_id: post_1_data.fetch(:id),
+            category_id: category_1_data.fetch(:id),
+          },
+          {
+            post_id: post_1_data.fetch(:id),
+            category_id: category_2_data.fetch(:id),
+          },
+          {
+            post_id: post_2_data.fetch(:id),
+            category_id: category_2_data.fetch(:id),
+          },
+        ],
+        toots: [
+          # Toot ordering is inconsistent for scope testing.
+          toot_2_data,
+          toot_1_data,
+          toot_3_data,
+        ],
+      }
+    }
+
+    let(:relation_mappings) {
+      {
+        users: {
+          columns: [
+            :id,
+            :first_name,
+            :last_name,
+            :email,
+          ],
+          factory: user_factory,
+          has_many: {
+            posts: {
+              relation_name: :posts,
+              foreign_key: :author_id,
+            },
+            toots: {
+              relation_name: :toots,
+              foreign_key: :tooter_id,
+              order_by: {
+                columns: [:tooted_at],
+                direction: :desc,
+              },
+            },
+          },
+          # TODO: maybe combine associations like this
+          # has_many_through: {
+          #   categories_posted_in: {
+          #     through_association: [ :posts, :categories ]
+          #   }
+          # }
+        },
+        posts: {
+          columns: [
+            :id,
+            :author_id,
+            :subject,
+            :body,
+          ],
+          factory: post_factory,
+          has_many: {
+            comments: {
+              relation_name: :comments,
+              foreign_key: :post_id,
+            },
+          },
+          has_many_through: {
+            categories: {
+              through_relation_name: :categories_to_posts,
+              relation_name: :categories,
+              foreign_key: :post_id,
+              association_foreign_key: :category_id,
+            }
+          },
+          belongs_to: {
+            author: {
+              relation_name: :users,
+              foreign_key: :author_id,
+            },
+          },
+        },
+        comments: {
+          columns: [
+            :id,
+            :post_id,
+            :commenter_id,
+            :body,
+          ],
+          factory: comment_factory,
+          belongs_to: {
+            commenter: {
+              relation_name: :users,
+              foreign_key: :commenter_id,
+            },
+          },
+        },
+        categories: {
+          columns: [
+            :id,
+            :name,
+          ],
+          factory: category_factory,
+          has_many_through: {
+            posts: {
+              through_relation_name: :categories_to_posts,
+              relation_name: :posts,
+              foreign_key: :category_id,
+              association_foreign_key: :post_id,
+            }
+          },
+        },
+        toots: {
+          columns: [
+            :id,
+            :tooter_id,
+            :body,
+            :tooted_at,
+          ],
+          factory: toot_factory,
+          belongs_to: {
+            tooter: {
+              relation_name: :users,
+              foreign_key: :tooter_id,
+            },
+          },
+        },
+      }
+    }
+
+    let(:user_factory){
+      SequelMapper::StructFactory.new(User)
+    }
+
+    let(:post_factory){
+      SequelMapper::StructFactory.new(Post)
+    }
+
+    let(:comment_factory){
+      SequelMapper::StructFactory.new(Comment)
+    }
+
+    let(:category_factory){
+      SequelMapper::StructFactory.new(Category)
+    }
+
+    let(:toot_factory){
+      SequelMapper::StructFactory.new(Toot)
+    }
+
+    let(:user_1_data) {
+      {
+        id: "user/1",
+        first_name: "Stephen",
+        last_name: "Best",
+        email: "bestie@gmail.com",
+      }
+    }
+
+    let(:user_2_data) {
+      {
+        id: "user/2",
+        first_name: "Hansel",
+        last_name: "Trickett",
+        email: "hansel@gmail.com",
+      }
+    }
+
+    let(:user_3_data) {
+      {
+        id: "user/3",
+        first_name: "Jasper",
+        last_name: "Trickett",
+        email: "jasper@gmail.com",
+      }
+    }
+
+    let(:post_1_data) {
+      {
+        id: "post/1",
+        author_id: "user/1",
+        subject: "Object mapping",
+        body: "It is often tricky",
+      }
+    }
+
+    let(:post_2_data) {
+      {
+        id: "post/2",
+        author_id: "user/1",
+        subject: "Object mapping part 2",
+        body: "Lazy load all the things!",
+      }
+    }
+
+    let(:comment_1_data) {
+      {
+        id: "comment/1",
+        post_id: "post/1",
+        commenter_id: "user/2",
+        body: "Trololol",
+      }
+    }
+
+    let(:comment_2_data) {
+      {
+        id: "comment/2",
+        post_id: "post/1",
+        commenter_id: "user/1",
+        body: "You are so LOL",
+      }
+    }
+
+    let(:category_1_data) {
+      {
+        id: "category/1",
+        name: "good",
+      }
+    }
+
+    let(:category_2_data) {
+      {
+        id: "category/2",
+        name: "bad",
+      }
+    }
+
+    let(:category_3_data) {
+      {
+        id: "category/3",
+        name: "ugly",
+      }
+    }
+
+    let(:toot_1_data) {
+      {
+        id: "toot/1",
+        tooter_id: "user/1",
+        body: "Armistice toots",
+        tooted_at: Time.parse("2014-11-11 11:11:00 UTC").iso8601,
+      }
+    }
+    let(:toot_2_data) {
+      {
+        id: "toot/2",
+        tooter_id: "user/1",
+        body: "Tooting every second",
+        tooted_at: Time.parse("2014-11-11 11:11:01 UTC").iso8601,
+      }
+    }
+
+    let(:toot_3_data) {
+      {
+        id: "toot/3",
+        tooter_id: "user/1",
+        body: "Join me in a minutes' toots",
+        tooted_at: Time.parse("2014-11-11 11:11:02 UTC").iso8601,
+      }
+    }
+  end
+end