sequel_mapper 0.0.1 → 0.0.3

data/spec/predefined_queries_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "sequel_mapper"
+require "sequel_mapper/configurations/conventional_configuration"
+
+RSpec.describe "Predefined subset queries" do
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
+
+  subject(:users) { user_mapper }
+
+  subject(:user_mapper) {
+    SequelMapper.mapper(
+      config: mapper_config,
+      name: :users,
+      datastore: datastore,
+    )
+  }
+
+  let(:mapper_config) {
+    SequelMapper::Configurations::ConventionalConfiguration.new(datastore)
+      .setup_mapping(:users) { |users|
+        users.has_many :posts, foreign_key: :author_id
+      }
+  }
+
+  context "on the top level mapper" do
+    context "subset is defined with a block" do
+      before do
+        mapper_config.setup_mapping(:users) do |config|
+          config.subset(:tricketts) do |dataset|
+            dataset
+              .where(last_name: "Trickett")
+              .order(:first_name)
+          end
+        end
+      end
+
+      it "maps the result of the subset" do
+        expect(users.subset(:tricketts).map(&:first_name)).to eq([
+          "Hansel",
+          "Jasper",
+        ])
+      end
+    end
+  end
+
+  context "on a has many association" do
+    before do
+      mapper_config.setup_mapping(:posts) do |config|
+        config.subset(:body_contains) do |dataset, search_string|
+          dataset.where("body like '%#{search_string}%'")
+        end
+      end
+    end
+
+    let(:user) { users.first }
+
+    it "maps the datastore subset" do
+      expect(user.posts.subset(:body_contains, "purrr").map(&:id))
+        .to eq(["posts/2"])
+    end
+
+    it "returns an immutable collection" do
+      expect(user.posts.subset(:body_contains, "purrr").public_methods)
+        .not_to include(:push, :<<, :delete)
+    end
+  end
+end

data/spec/proxying_spec.rb

@@ -1,36 +1,30 @@
 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 "Proxying associations" do
-  include SequelMapper::GraphFixture
+  include_context "mapper setup"
+  include_context "sequel persistence setup"
+  include_context "seed data setup"
 
   context "of type `has_many`" do
-    subject(:graph) {
-      SequelMapper::Graph.new(
-        top_level_namespace: :users,
-        datastore: datastore,
-        relation_mappings: relation_mappings,
-      )
-    }
+    subject(:mapper) { user_mapper }
 
     let(:user) {
-      graph.where(id: "user/1").first
+      mapper.where(id: "users/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)
+          expect {
+            user
+          }.to change { query_counter.read_count }.by(1)
         end
       end
 
@@ -49,9 +43,21 @@ RSpec.describe "Proxying associations" do
 
         it "does a single additional read for the assocation collection" do
           expect {
-            user.posts.map(&identity)
+            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 assocation" do
@@ -73,7 +79,7 @@ RSpec.describe "Proxying associations" do
           post = user.posts.first
 
           expect {
-            post.categories.map(&:name).to_a
+            post.categories.each { |x| x }
           }.to change { query_counter.read_count }.by(1)
         end
       end

data/spec/querying_spec.rb

@@ -1,51 +1,48 @@
 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 "Querying" do
-  include SequelMapper::GraphFixture
-
-  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(:mapper) { user_mapper }
 
   let(:user) {
-    graph.where(id: "user/1").first
+    mapper.where(id: "users/1").first
   }
 
   let(:query_criteria) {
     {
-      body: "Lazy load all the things!",
+      body: "I do it three times purrr day",
     }
   }
 
+  let(:filtered_posts) {
+    user.posts.where(query_criteria)
+  }
+
   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"])
+      expect(filtered_posts.map(&:id)).to eq(["posts/2"])
     end
 
-    it "sends the query directly to the datastore" do
+    it "delegates the query to the datastore, performs two additiona reads" do
       expect {
-        user.posts
-          .where(query_criteria)
-          .map(&:id)
+        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
 
-      # 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",
-      ])
+    it "returns an immutable collection" do
+      expect(filtered_posts.public_methods).not_to include(:push, :<<, :delete)
     end
   end
 end

data/spec/readme_examples_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "sequel_mapper"
+
+require "spec_helper"
+
+require "support/mapper_setup"
+require "support/sequel_persistence_setup"
+require "support/seed_data_setup"
+require "sequel_mapper"
+
+RSpec.describe "README examples" do
+  include_context "sequel persistence setup"
+
+  readme_contents = File.read("README.md")
+
+  code_samples = readme_contents
+    .split("```ruby")
+    .drop(1)
+    .map { |s| s.split("```").first }
+
+  code_samples.each_with_index do |code_sample, i|
+    it "executes without error" do
+      begin
+        Module.new.module_eval(code_sample)
+      rescue => e
+        File.open("./example#{i}.rb", "w") { |f| f.puts(code_sample) }
+        binding.pry if ENV["DEBUG"]
+      end
+    end
+  end
+end

data/spec/sequel_mapper/abstract_record_spec.rb

@@ -0,0 +1,179 @@
+require "spec_helper"
+
+require "sequel_mapper/abstract_record"
+
+RSpec.describe SequelMapper::AbstractRecord do
+  subject(:record) {
+    SequelMapper::AbstractRecord.new(namespace, identity, raw_data)
+  }
+
+  let(:namespace) { double(:namespace) }
+
+  let(:identity) {
+    { id: id }
+  }
+
+  let(:raw_data) {
+    {
+      name: name,
+    }
+  }
+
+  let(:id) { double(:id) }
+  let(:name) { double(:name) }
+
+  describe "#namespace" do
+    it "returns the namespace" do
+      expect(record.namespace).to eq(namespace)
+    end
+  end
+
+  describe "#identity" do
+    it "returns the identity" do
+      expect(record.identity).to eq(identity)
+    end
+  end
+
+  describe "#fetch" do
+    it "delegates to the underlying Hash representation" do
+      expect(record.fetch(:id)).to eq(id)
+      expect(record.fetch(:name)).to eq(name)
+      expect(record.fetch(:not_there, "nope")).to eq("nope")
+      expect(record.fetch(:not_there) { "lord no" }).to eq("lord no")
+    end
+  end
+
+  describe "#to_h" do
+    it "returns a raw_data merged with identity" do
+      expect(record.to_h).to eq(
+        id: id,
+        name: name,
+      )
+    end
+  end
+
+  describe "#if_upsert" do
+    it "returns self" do
+      expect(
+        record.if_upsert { |_| }
+      ).to be(record)
+    end
+  end
+
+  describe "#if_delete" do
+    it "returns self" do
+      expect(
+        record.if_delete { |_| }
+      ).to be(record)
+    end
+  end
+
+  describe "#merge" do
+    let(:extra_data) {
+      {
+        location: location,
+      }
+    }
+
+    let(:location) { double(:location) }
+
+    it "returns a new record with same identity" do
+      expect(
+        record.merge(extra_data).identity
+      ).to eq(identity)
+    end
+
+    it "returns a new record with same namespace" do
+      expect(
+        record.merge(extra_data).namespace
+      ).to eq(namespace)
+    end
+
+    it "returns a new record with merged data" do
+      merged_record = record.merge(extra_data)
+
+      expect(merged_record.to_h).to eq(
+        id: id,
+        name: name,
+        location: location,
+      )
+    end
+
+    it "does not mutate the original record" do
+      expect {
+        record.merge(extra_data)
+      }.not_to change { record.to_h }
+    end
+  end
+
+  describe "#==" do
+    context "super class contract" do
+      let(:comparitor) { record.merge({}) }
+
+      it "raises NotImplementedError" do
+        expect{ 
+          record == comparitor
+        }.to raise_error(NotImplementedError)
+      end
+
+      context "when subclassed" do
+        subject(:record) {
+          record_subclass.new(namespace, identity, raw_data)
+        }
+
+        let(:record_subclass) {
+          Class.new(SequelMapper::AbstractRecord) {
+            protected
+
+            def operation
+              :do_a_thing
+            end
+          }
+        }
+
+        context "when comparitor is of the wrong type" do
+          it "is not equal" do
+            expect(record.==(Object.new)).to be(false)
+          end
+        end
+
+        context "when the operation type is equal" do
+          context "when the combined `raw_data` and `identity` are equal" do
+            let(:comparitor) { record.merge({}) }
+
+            it "is equal" do
+              expect(record.==(comparitor)).to be(true)
+            end
+          end
+
+          context "when the combined `raw_data` and `identity` are not equal" do
+            let(:comparitor) { record.merge(something_else: "i'm different") }
+
+            it "is not equal" do
+              expect(record.==(comparitor)).to be(false)
+            end
+          end
+        end
+
+        context "when the operation name differs" do
+          let(:comparitor) {
+            record_class_with_different_operation.new(namespace, identity, raw_data)
+          }
+
+          let(:record_class_with_different_operation) {
+            Class.new(SequelMapper::AbstractRecord) {
+              protected
+              def operation
+                :do_a_different_thing
+              end
+            }
+          }
+
+          it "is not equal" do
+            expect(record.==(comparitor)).to be(false)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/sequel_mapper/{association_proxy_spec.rb → collection_mutability_proxy_spec.rb}

@@ -1,10 +1,10 @@
 require "spec_helper"
 
-require "sequel_mapper/association_proxy"
+require "sequel_mapper/collection_mutability_proxy"
 
-RSpec.describe SequelMapper::AssociationProxy do
+RSpec.describe SequelMapper::CollectionMutabilityProxy do
   let(:proxy) {
-    SequelMapper::AssociationProxy.new(lazy_enum)
+    SequelMapper::CollectionMutabilityProxy.new(lazy_enum)
   }
 
   let(:lazy_enum) { data_set.each.lazy }
@@ -59,14 +59,14 @@ RSpec.describe SequelMapper::AssociationProxy do
     end
   end
 
-  describe "#remove" do
+  describe "#delete" do
     it "returns self" do
-      expect(proxy.remove(3)).to be(proxy)
+      expect(proxy.delete(3)).to be(proxy)
     end
 
     context "after removing a element from the enumeration" do
       before do
-        proxy.remove(3)
+        proxy.delete(3)
       end
 
       it "skips that element in the enumeration" do