sequel_mapper 0.0.1 → 0.0.3

data/spec/sequel_mapper/deleted_record_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+require "sequel_mapper/deleted_record"
+
+RSpec.describe SequelMapper::DeletedRecord do
+  subject(:record) {
+    SequelMapper::DeletedRecord.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 "#if_delete" do
+    it "invokes the callback" do
+      expect { |callback|
+        record.if_delete(&callback)
+      }.to yield_with_args(record)
+    end
+  end
+
+  describe "#==" do
+    context "with another record that deletes" do
+      let(:comparitor) {
+        record.merge({})
+      }
+
+      it "is equal" do
+        expect(record.==(comparitor)).to be(true)
+      end
+    end
+
+    context "with another record that does not delete" do
+      let(:comparitor) {
+        Class.new(SequelMapper::AbstractRecord) do
+          protected
+          def operation
+            :something_else
+          end
+        end
+      }
+
+      it "is not equal" do
+        expect(record.==(comparitor)).to be(false)
+      end
+    end
+  end
+end

data/spec/sequel_mapper/lazy_object_proxy_spec.rb

@@ -0,0 +1,140 @@
+require "spec_helper"
+
+require "sequel_mapper/lazy_object_proxy"
+
+RSpec.describe SequelMapper::LazyObjectProxy do
+  subject(:proxy) {
+    SequelMapper::LazyObjectProxy.new(
+      object_loader,
+      known_fields,
+    )
+  }
+
+  let(:id) { double(:id) }
+  let(:known_fields) { { id: id } }
+  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
+
+  describe "#loaded?" do
+    context "before the object is loaded" do
+      it "returns false" do
+        expect(proxy).not_to be_loaded
+      end
+    end
+
+    context "after the object is loaded" do
+      def force_object_load(object)
+        object.__getobj__
+      end
+
+      before { force_object_load(proxy) }
+
+      it "returns true" do
+        expect(proxy).to be_loaded
+      end
+    end
+  end
+
+  describe "known fields" do
+    context "when fields are known before load (such as from foreign key)" do
+      it "does not load the object when that field is accessed" do
+        proxy.id
+
+        expect(proxy).not_to be_loaded
+      end
+
+      it "returns the given value" do
+        expect(proxy.id).to be(id)
+      end
+    end
+  end
+
+  describe "#respond_to?" do
+    context "when method corresponds to a known field" do
+      it "does not the load the object" do
+        proxy.respond_to?(:id)
+
+        expect(proxy).not_to be_loaded
+      end
+
+      it "repsonds to the method" do
+        expect(proxy).to respond_to(:id)
+      end
+    end
+
+    context "when the method is not a known field" do
+      it "loads the object" do
+        proxy.respond_to?(:something_arbitrary)
+
+        expect(proxy).to be_loaded
+      end
+
+      context "when lazy proxied object does respond to the method" do
+        it "responds to the method" do
+          expect(proxy).to respond_to(:name)
+        end
+      end
+
+      context "when lazy proxied object does not respond to the method" do
+        it "does not respond to the method" do
+          expect(proxy).not_to respond_to(:something_arbitrary)
+        end
+      end
+    end
+  end
+end

data/spec/sequel_mapper/public_conveniencies_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+require "sequel_mapper/public_conveniencies"
+
+RSpec.describe SequelMapper::PublicConveniencies do
+  subject(:conveniences) {
+    Module.new.extend(SequelMapper::PublicConveniencies)
+  }
+
+  describe "#mapper" do
+    let(:datastore) {
+      {
+        things: [ thing_record ],
+      }
+    }
+
+    let(:mapper_config) {
+      {
+        things: double(
+          :thing_config,
+          namespace: :things,
+          associations: [],
+          primary_key: [],
+          factory: ->(x){x}
+        )
+      }
+    }
+
+    let(:mapping_name) { :things }
+
+    let(:thing_record) {
+      {
+        id: "THE THING",
+      }
+    }
+
+    it "returns a mapper for the specified mapping" do
+      expect(
+        conveniences
+          .mapper(
+            config: mapper_config,
+            datastore: datastore,
+            name: mapping_name,
+          )
+          .all.first.fetch(:id)
+      ).to eq("THE THING")
+    end
+  end
+end

data/spec/sequel_mapper/queryable_lazy_dataset_loader_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+require "sequel_mapper/queryable_lazy_dataset_loader"
+
+RSpec.describe SequelMapper::QueryableLazyDatasetLoader do
+  let(:proxy) {
+    SequelMapper::QueryableLazyDatasetLoader.new(
+      database_enum,
+      loader,
+      mapper,
+    )
+  }
+
+  let(:row1) { double(:row1) }
+  let(:row2) { double(:row2) }
+  let(:object1) { double(:object1) }
+  let(:object2) { double(:object2) }
+  let(:row_object_map) {
+    {
+      row1 => object1,
+      row2 => object2,
+    }
+  }
+  let(:collection_size) { row_object_map.size }
+
+  let(:database_enum) { [row1, row2].each.lazy }
+
+  let(:mapper) { double(:mapper) }
+
+  let(:loader_count) { @loader_count }
+  let(:loader) {
+    @loader_count = 0
+
+    ->(row) {
+      @loader_count = @loader_count + 1
+      row_object_map.fetch(row)
+    }
+  }
+
+  describe "#each" do
+    it "iterates over all elements of the database_enum" do
+      elements = []
+      proxy.each { |x| elements.push(x) }
+
+      expect(elements).to eq([object1, object2])
+    end
+
+    context "when the collection is not loaded" do
+      it "loads the collection on first call" do
+        proxy.each { |x| x }
+
+        expect(loader_count).to eq(collection_size)
+      end
+    end
+
+    context "when the collection has already loaded (second call to #each)" do
+      before do
+        proxy.each { |x| x }
+      end
+
+      it "does not load a second time" do
+        expect {
+          proxy.each { |x| x }
+        }.not_to change { loader_count }
+      end
+    end
+
+    context "when #first has been called beforehand" do
+      before do
+        proxy.first
+      end
+
+      it "does not reload the first element of the collection" do
+        proxy.each { |x| x }
+
+        expect(loader_count).to eq(collection_size)
+      end
+
+      it "iterates over all elements" do
+        elements = []
+        proxy.each { |x| elements.push(x) }
+
+        expect(elements).to eq([object1, object2])
+      end
+    end
+
+    context "when drop has been called beforehand" do
+      it "loads each object just once" do
+        proxy.drop(1).each { |x| x }
+
+        expect(loader_count).to eq(collection_size)
+      end
+    end
+  end
+
+  describe "#first" do
+    it "loads only the first object" do
+      proxy.first
+
+      expect(loader_count).to eq(1)
+    end
+  end
+end

data/spec/sequel_mapper/upserted_record_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+require "sequel_mapper/upserted_record"
+
+RSpec.describe SequelMapper::UpsertedRecord do
+  subject(:record) {
+    SequelMapper::UpsertedRecord.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 "#if_upsert" do
+    it "invokes the callback" do
+      expect { |callback|
+        record.if_upsert(&callback)
+      }.to yield_with_args(record)
+    end
+  end
+
+  describe "#==" do
+    context "with another record that upserts" do
+      let(:comparitor) {
+        record.merge({})
+      }
+
+      it "is equal" do
+        expect(record.==(comparitor)).to be(true)
+      end
+    end
+
+    context "with another record that does not upsert" do
+      let(:comparitor) {
+        Class.new(SequelMapper::AbstractRecord) do
+          protected
+          def operation
+            :something_else
+          end
+        end
+      }
+
+      it "is not equal" do
+        expect(record.==(comparitor)).to be(false)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,14 +1,6 @@
 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"),
-)
+require "support/sequel_test_support"
+require "support/blog_schema"
 
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
@@ -36,4 +28,9 @@ RSpec.configure do |config|
   # config.order = :random
 
   # Kernel.srand config.seed
+
+  config.before(:suite) do
+    SequelMapper::SequelTestSupport.drop_tables
+    SequelMapper::SequelTestSupport.create_tables(BLOG_SCHEMA)
+  end
 end

data/spec/support/blog_schema.rb

@@ -0,0 +1,29 @@
+BLOG_SCHEMA = {
+  users: [
+    { name: :id, type: :String },
+    { name: :first_name, type: :String },
+    { name: :last_name, type: :String },
+    { name: :email, type: :String },
+  ],
+  posts: [
+    { name: :id, type: :String },
+    { name: :subject, type: :String },
+    { name: :body, type: :String },
+    { name: :author_id, type: :String },
+    { name: :created_at, type: :DateTime },
+  ],
+  comments: [
+    { name: :id, type: :String },
+    { name: :body, type: :String },
+    { name: :post_id, type: :String },
+    { name: :commenter_id, type: :String },
+  ],
+  categories: [
+    { name: :id, type: :String },
+    { name: :name, type: :String },
+  ],
+  categories_to_posts: [
+    { name: :post_id, type: :String },
+    { name: :category_id, type: :String },
+  ],
+}