sequel_mapper 0.0.1 → 0.0.3

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,234 @@
+require "sequel_mapper"
+require "sequel_mapper/mapper_facade"
+require "sequel_mapper/relation_mapping"
+require "sequel_mapper/queryable_lazy_dataset_loader"
+require "sequel_mapper/collection_mutability_proxy"
+require "sequel_mapper/lazy_object_proxy"
+require "sequel_mapper/dataset"
+require "sequel_mapper/query_order"
+require "sequel_mapper/one_to_many_association"
+require "sequel_mapper/many_to_one_association"
+require "sequel_mapper/many_to_many_association"
+require "sequel_mapper/subset_queries_proxy"
+require "support/object_graph_setup"
+
+RSpec.shared_context "mapper setup" do
+  include_context "object graph setup"
+
+  let(:mappers) {
+    {
+      users: user_mapper,
+    }
+  }
+
+  let(:user_mapper) {
+    SequelMapper.mapper(
+      config: mappings,
+      name: :users,
+      datastore: datastore,
+    )
+  }
+
+  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
+              SequelMapper::OneToManyAssociation.new(
+                **assoc_defaults.merge(
+                  assoc_config.dup.tap { |h| h.delete(:type) }
+                )
+              )
+            when :many_to_one
+              SequelMapper::ManyToOneAssociation.new(
+                assoc_config.dup.tap { |h| h.delete(:type) }
+              )
+            when :many_to_many
+              SequelMapper::ManyToManyAssociation.new(
+                **assoc_defaults
+                  .merge(
+                    join_mapping_name: assoc_config.fetch(:join_mapping_name),
+                    join_dataset: datastore[
+                      configs
+                        .fetch(assoc_config.fetch(:join_mapping_name))
+                        .fetch(:namespace)
+                    ],
+                  )
+                  .merge(
+                    assoc_config.dup.tap { |h|
+                      h.delete(:type)
+                      h.delete(:join_namespace)
+                    }
+                  )
+              )
+            else
+              raise "Association type not supported"
+            end
+          ]
+        }
+
+        [
+          name,
+          SequelMapper::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: SequelMapper::SubsetQueriesProxy.new(config.fetch(:subsets, {}))
+          )
+        ]
+      }
+    ]
+  }
+
+  def assoc_defaults
+    {
+      order: SequelMapper::QueryOrder.new(fields: [], direction: "ASC")
+    }
+  end
+
+  let(:has_many_proxy_factory) {
+    ->(query:, loader:, mapping_name:) {
+      SequelMapper::CollectionMutabilityProxy.new(
+        SequelMapper::QueryableLazyDatasetLoader.new(
+          query,
+          loader,
+          mappings.fetch(mapping_name).subsets,
+        )
+      )
+    }
+  }
+
+  let(:many_to_one_proxy_factory) {
+    ->(query:, loader:, preloaded_data:) {
+      SequelMapper::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

@@ -113,7 +113,6 @@ class SequelMapper::MockSequel
     end
 
     def each(&block)
-      puts "iterating over #{matching_rows}"
       database.log_read
 
       matching_rows.each(&block)

data/spec/support/object_graph_setup.rb

@@ -0,0 +1,106 @@
+require "sequel_mapper/serializer"
+require "sequel_mapper/struct_factory"
+
+RSpec.shared_context "object graph setup" do
+
+  before do
+    setup_circular_references_avoiding_stack_overflow
+  end
+
+  def setup_circular_references_avoiding_stack_overflow
+    biscuits_post_comment.commenter = hansel
+    cat_biscuits_category.posts = [ biscuits_post ]
+  end
+
+  User ||= Struct.new(:id, :first_name, :last_name, :email, :posts, :comments)
+  Post ||= Struct.new(:id, :author, :subject, :body, :comments, :categories, :created_at)
+  Comment ||= Struct.new(:id, :post, :commenter, :body)
+  Category ||= Struct.new(:id, :name, :posts)
+
+  let(:factories) {
+    {
+      users: SequelMapper::StructFactory.new(User),
+      posts: SequelMapper::StructFactory.new(Post),
+      comments: SequelMapper::StructFactory.new(Comment),
+      categories: SequelMapper::StructFactory.new(Category),
+      categories_to_posts: ->(x){x},
+      noop: ->(x){x},
+    }
+  }
+
+  let(:default_serializer) {
+    ->(fields) {
+      ->(object) {
+        SequelMapper::Serializer.new(fields, object).to_h
+      }
+    }
+  }
+
+  let(:null_serializer) {
+    ->(_fields) {
+      ->(x){x}
+    }
+  }
+
+  let(:hansel) {
+    factories.fetch(:users).call(
+      id: "users/1",
+      first_name: "Hansel",
+      last_name: "Trickett",
+      email: "hansel@tricketts.org",
+      posts: [
+        biscuits_post,
+        sleep_post,
+      ],
+    )
+  }
+
+  let(:biscuits_post) {
+    factories.fetch(:posts).call(
+      id: "posts/1",
+      subject: "Biscuits",
+      body: "I like them",
+      comments: [
+        biscuits_post_comment,
+      ],
+      categories: [
+        cat_biscuits_category,
+      ],
+      created_at: Time.parse("2015-09-05T15:00:00+01:00"),
+    )
+  }
+
+  let(:sleep_post) {
+    factories.fetch(:posts).call(
+      id: "posts/2",
+      subject: "Sleeping",
+      body: "I do it three times purrr day",
+      comments: [],
+      categories: [
+        chilling_category,
+      ],
+      created_at: Time.parse("2015-09-02T15:00:00+01:00"),
+    )
+  }
+
+  let(:biscuits_post_comment) {
+    factories.fetch(:comments).call(
+      id: "comments/1",
+      body: "oh noes",
+    )
+  }
+
+  let(:cat_biscuits_category) {
+    factories.fetch(:categories).call(
+      id: "categories/1",
+      name: "Cat biscuits",
+    )
+  }
+
+  let(:chilling_category) {
+    factories.fetch(:categories).call(
+      id: "categories/2",
+      name: "Chillaxing",
+    )
+  }
+end

data/spec/support/seed_data_setup.rb

@@ -0,0 +1,122 @@
+require "support/object_graph_setup"
+RSpec.shared_context "seed data setup" do
+  include_context "object graph setup"
+
+  before {
+    insert_records(datastore, seeded_records)
+  }
+
+  let(:seeded_records) {
+    [
+      [ :users, hansel_record ],
+      [ :users, jasper_record ],
+      [ :users, poppy_record ],
+      [ :posts, biscuits_post_record ],
+      [ :posts, sleep_post_record ],
+      [ :posts, catch_frogs_post_record ],
+      [ :comments, biscuits_post_comment_record ],
+      [ :categories, cat_biscuits_category_record ],
+      [ :categories, eating_and_sleeping_category_record ],
+      *categories_to_posts_records.map { |record|
+        [ :categories_to_posts, record ]
+      },
+    ]
+  }
+
+  let(:hansel_record) {
+    {
+      id: "users/1",
+      first_name: "Hansel",
+      last_name: "Trickett",
+      email: "hansel@tricketts.org",
+    }
+  }
+
+  let(:jasper_record) {
+    {
+      id: "users/2",
+      first_name: "Jasper",
+      last_name: "Trickett",
+      email: "jasper@tricketts.org",
+    }
+  }
+
+  let(:poppy_record) {
+    {
+      id: "users/3",
+      first_name: "Poppy",
+      last_name: "Herzog",
+      email: "poppy@herzog.info",
+    }
+  }
+
+  let(:biscuits_post_record) {
+    {
+      id: "posts/1",
+      subject: "Biscuits",
+      body: "I like them",
+      author_id: "users/1",
+      created_at: Time.parse("2015-09-05T15:00:00+01:00"),
+    }
+  }
+
+  let(:sleep_post_record) {
+    {
+      id: "posts/2",
+      subject: "Sleeping",
+      body: "I do it three times purrr day",
+      author_id: "users/1",
+      created_at: Time.parse("2015-09-02T15:00:00+01:00"),
+    }
+  }
+
+  let(:catch_frogs_post_record) {
+    {
+      id: "posts/3",
+      subject: "Catching frongs",
+      body: "I love them while at the same time I hate them",
+      author_id: "users/2",
+      created_at: Time.parse("2015-09-03T15:00:00+01:00"),
+    }
+  }
+
+  let(:biscuits_post_comment_record) {
+    {
+      id: "comments/1",
+      body: "oh noes",
+      post_id: "posts/1",
+      commenter_id: "users/1",
+    }
+  }
+
+  let(:cat_biscuits_category_record) {
+    {
+      id: "categories/1",
+      name: "Cat biscuits",
+    }
+  }
+
+  let(:eating_and_sleeping_category_record) {
+    {
+      id: "categories/2",
+      name: "Eating and sleeping",
+    }
+  }
+
+  let(:categories_to_posts_records) {
+    [
+      {
+        post_id: "posts/1",
+        category_id: "categories/1",
+      },
+      {
+        post_id: "posts/1",
+        category_id: "categories/2",
+      },
+      {
+        post_id: "posts/2",
+        category_id: "categories/2",
+      },
+    ]
+  }
+end