terrestrial 0.1.0 → 0.1.1

data/spec/sequel_mapper/public_conveniencies_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+require "terrestrial/public_conveniencies"
+
+RSpec.describe Terrestrial::PublicConveniencies do
+  subject(:conveniences) {
+    Module.new.extend(Terrestrial::PublicConveniencies)
+  }
+
+  class MockDatastore < DelegateClass(Hash)
+    def transaction(&block)
+      block.call
+    end
+  end
+
+  describe "#mappers" do
+    let(:datastore) {
+      MockDatastore.new(
+        {
+          things: [ thing_record ],
+        }
+      )
+    }
+
+    let(:mapper_config) {
+      {
+        things: double(
+          :thing_config,
+          name: mapping_name,
+          namespace: :things,
+          fields: [:id],
+          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
+      mappers = conveniences.mappers(
+        mappings: mapper_config,
+        datastore: datastore,
+      )
+
+      expect(
+        mappers[:things].all.first.fetch(:id)
+      ).to eq("THE THING")
+    end
+  end
+end

data/spec/sequel_mapper/upserted_record_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+require "terrestrial/upserted_record"
+
+RSpec.describe Terrestrial::UpsertedRecord do
+  subject(:record) {
+    Terrestrial::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(Terrestrial::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

@@ -0,0 +1,36 @@
+require "pry"
+require "support/sequel_test_support"
+require "support/blog_schema"
+
+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
+
+  config.before(:suite) do
+    Terrestrial::SequelTestSupport.drop_tables
+    Terrestrial::SequelTestSupport.create_tables(BLOG_SCHEMA)
+  end
+end

data/spec/support/blog_schema.rb

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

data/spec/support/have_persisted_matcher.rb

@@ -0,0 +1,19 @@
+RSpec::Matchers.define :have_persisted do |relation_name, data|
+  match do |datastore|
+    datastore[relation_name].find { |record|
+      if data.respond_to?(:===)
+        data === record
+      else
+        data == record
+      end
+    }
+  end
+
+  failure_message do |datastore|
+    "expected #{datastore[relation_name]} to have persisted #{data.inspect} in #{relation_name}"
+  end
+
+  failure_message_when_negated do |datastore|
+    failure_message.gsub("to have", "not to have")
+  end
+end

data/spec/support/mapper_setup.rb

@@ -0,0 +1,221 @@
+require "terrestrial"
+require "terrestrial/mapper_facade"
+require "terrestrial/relation_mapping"
+require "terrestrial/lazy_collection"
+require "terrestrial/collection_mutability_proxy"
+require "terrestrial/lazy_object_proxy"
+require "terrestrial/dataset"
+require "terrestrial/query_order"
+require "terrestrial/one_to_many_association"
+require "terrestrial/many_to_one_association"
+require "terrestrial/many_to_many_association"
+require "terrestrial/subset_queries_proxy"
+require "support/object_graph_setup"
+
+RSpec.shared_context "mapper setup" do
+  include_context "object graph setup"
+
+  let(:mappers) {
+    Terrestrial.mappers(mappings: mappings, datastore: datastore)
+  }
+
+  let(:user_mapper) { mappers[:users] }
+
+  let(:mappings) {
+    Hash[
+      configs.map { |name, config|
+        fields = config.fetch(:fields) + config.fetch(:associations).keys
+
+        associations = config.fetch(:associations).map { |assoc_name, assoc_config|
+          [
+            assoc_name,
+            case assoc_config.fetch(:type)
+            when :one_to_many
+              Terrestrial::OneToManyAssociation.new(
+                **assoc_defaults.merge(
+                  assoc_config.dup.tap { |h| h.delete(:type) }
+                )
+              )
+            when :many_to_one
+              Terrestrial::ManyToOneAssociation.new(
+                assoc_config.dup.tap { |h| h.delete(:type) }
+              )
+            when :many_to_many
+              Terrestrial::ManyToManyAssociation.new(
+                **assoc_defaults
+                  .merge(
+                    join_mapping_name: assoc_config.fetch(:join_mapping_name),
+                  )
+                  .merge(
+                    assoc_config.dup.tap { |h|
+                      h.delete(:type)
+                      h.delete(:join_namespace)
+                    }
+                  )
+              )
+            else
+              raise "Association type not supported"
+            end
+          ]
+        }
+
+        [
+          name,
+          Terrestrial::RelationMapping.new(
+            name: name,
+            namespace: config.fetch(:namespace),
+            fields: config.fetch(:fields),
+            primary_key: config.fetch(:primary_key),
+            serializer: serializers.fetch(config.fetch(:serializer)).call(fields),
+            associations: Hash[associations],
+            factory: factories.fetch(name),
+            subsets: Terrestrial::SubsetQueriesProxy.new(config.fetch(:subsets, {}))
+          )
+        ]
+      }
+    ]
+  }
+
+  def assoc_defaults
+    {
+      order: Terrestrial::QueryOrder.new(fields: [], direction: "ASC")
+    }
+  end
+
+  let(:has_many_proxy_factory) {
+    ->(query:, loader:, mapping_name:) {
+      Terrestrial::CollectionMutabilityProxy.new(
+        Terrestrial::LazyCollection.new(
+          query,
+          loader,
+          mappings.fetch(mapping_name).subsets,
+        )
+      )
+    }
+  }
+
+  let(:many_to_one_proxy_factory) {
+    ->(query:, loader:, preloaded_data:) {
+      Terrestrial::LazyObjectProxy.new(
+        ->{ loader.call(query.first) },
+        preloaded_data,
+      )
+    }
+  }
+
+  let(:serializers) {
+    {
+      default: default_serializer,
+      null: null_serializer,
+    }
+  }
+
+  let(:configs) {
+    {
+      users: {
+        namespace: :users,
+        primary_key: [:id],
+        fields: [
+          :id,
+          :first_name,
+          :last_name,
+          :email,
+        ],
+        factory: :user,
+        serializer: :default,
+        associations: {
+          posts: {
+            type: :one_to_many,
+            mapping_name: :posts,
+            foreign_key: :author_id,
+            key: :id,
+            proxy_factory: has_many_proxy_factory,
+          }
+        },
+      },
+
+      posts: {
+        namespace: :posts,
+        primary_key: [:id],
+        fields: [
+          :id,
+          :subject,
+          :body,
+          :created_at,
+        ],
+        factory: :post,
+        serializer: :default,
+        associations: {
+          comments: {
+            type: :one_to_many,
+            mapping_name: :comments,
+            foreign_key: :post_id,
+            key: :id,
+            proxy_factory: has_many_proxy_factory,
+          },
+          categories: {
+            type: :many_to_many,
+            mapping_name: :categories,
+            key: :id,
+            foreign_key: :post_id,
+            association_foreign_key: :category_id,
+            association_key: :id,
+            join_mapping_name: :categories_to_posts,
+            proxy_factory: has_many_proxy_factory,
+          },
+        },
+      },
+
+      comments: {
+        namespace: :comments,
+        primary_key: [:id],
+        fields: [
+          :id,
+          :body,
+        ],
+        factory: :comment,
+        serializer: :default,
+        associations: {
+          commenter: {
+            type: :many_to_one,
+            mapping_name: :users,
+            key: :id,
+            foreign_key: :commenter_id,
+            proxy_factory: many_to_one_proxy_factory,
+          },
+        },
+      },
+
+      categories: {
+        namespace: :categories,
+        primary_key: [:id],
+        fields: [
+          :id,
+          :name,
+        ],
+        factory: :comment,
+        serializer: :default,
+        associations: {
+          posts: {
+            type: :many_to_many,
+            mapping_name: :posts,
+            key: :id,
+            foreign_key: :category_id,
+            association_foreign_key: :post_id,
+            association_key: :id,
+            join_mapping_name: :categories_to_posts,
+            proxy_factory: has_many_proxy_factory,
+          },
+        },
+      },
+
+      categories_to_posts: {
+        namespace: :categories_to_posts,
+        primary_key: [:category_id, :post_id],
+        fields: [],
+        serializer: :null,
+        associations: {},
+      }
+    }
+  }
+end

data/spec/support/mock_sequel.rb

@@ -0,0 +1,193 @@
+class Terrestrial::MockSequel
+  def initialize(relations)
+    @relations = {}
+
+    relations.each do |table_name|
+      @relations[table_name] = Relation.new(self, [])
+    end
+
+    @reads, @writes, @deletes = 0, 0, 0
+  end
+
+  attr_reader :relations
+  private     :relations
+
+  def [](table_name)
+    @relations.fetch(table_name)
+  end
+
+  def log_read
+    @reads += 1
+  end
+
+  def log_write
+    @writes += 1
+  end
+
+  def log_delete
+    @deletes += 1
+  end
+
+  def read_count
+    @reads
+  end
+
+  def write_count
+    @writes
+  end
+
+  def delete_count
+    @deletes
+  end
+
+  class Query
+    def initialize(criteria: {}, order: [], reverse: false, &block)
+      if block
+        raise NotImplementedError.new("Block filtering not implemented")
+      end
+
+      @criteria = criteria
+      @order_columns = order
+      @reverse_order = reverse
+    end
+
+    attr_reader :criteria, :order_columns
+
+    def where(new_criteria, &block)
+      self.class.new(
+        criteria: criteria.merge(new_criteria),
+        order: order,
+        reverse: reverse,
+        &block
+      )
+    end
+
+    def order(columns)
+      self.class.new(
+        criteria: criteria,
+        order: columns,
+      )
+    end
+
+    def reverse
+      self.class.new(
+        criteria: criteria,
+        order: order_columns,
+        reverse: true,
+      )
+    end
+
+    def reverse_order?
+      !!@reverse_order
+    end
+  end
+
+  class Relation
+    include Enumerable
+
+    def initialize(database, all_rows, applied_query: Query.new)
+      @database = database
+      @all_rows = all_rows
+      @applied_query = applied_query
+    end
+
+    attr_reader :database, :all_rows, :applied_query
+    private     :database, :all_rows, :applied_query
+
+    def where(criteria, &block)
+      new_with_query(Query.new(criteria: criteria, &block))
+    end
+
+    def order(columns)
+      new_with_query(applied_query.order(columns))
+    end
+
+    def reverse
+      @applied_query = @applied_query.reverse
+    end
+
+    def to_a
+      database.log_read
+
+      matching_rows
+    end
+
+    def each(&block)
+      database.log_read
+
+      matching_rows.each(&block)
+    end
+
+    def delete
+      database.log_delete
+
+      matching_rows.each do |row_to_delete|
+        all_rows.delete(row_to_delete)
+      end
+    end
+
+    def insert(new_row)
+      database.log_write
+
+      all_rows.push(new_row)
+    end
+
+    def update(attrs)
+      database.log_write
+
+      # No need to get the rows from the canonical relation as the hashes can
+      # just be mutated in plaace.
+      matching_rows.each do |row|
+        attrs.each do |k, v|
+          row[k] = v
+        end
+      end
+    end
+
+    def empty?
+      database.log_read
+
+      matching_rows.empty?
+    end
+
+    private
+
+    def matching_rows
+      apply_sort(
+        equality_filter(all_rows, applied_query.criteria),
+        applied_query.order_columns,
+        applied_query.reverse_order?,
+      )
+    end
+
+    def apply_sort(rows, order_columns, reverse_order)
+      sorted_rows = rows.sort_by{ |row|
+        order_columns.map { |col| row.fetch(col) }
+      }
+
+      if reverse_order
+        sorted_rows.reverse
+      else
+        sorted_rows
+      end
+    end
+
+    def equality_filter(rows, criteria)
+      rows.select { |row|
+        criteria.all? { |k, v|
+          if v.is_a?(Enumerable)
+            v.include?(row.fetch(k))
+          else
+            row.fetch(k) == v
+          end
+        }
+      }
+    end
+
+    private
+
+    def new_with_query(query)
+      self.class.new(database, all_rows, applied_query: query)
+    end
+  end
+end