datasource 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 714357b54441eac8f8eb1c209dad82fa8c588743
-  data.tar.gz: 90cb1f1ca000d6683b234c6ccff41425b208be2c
+  metadata.gz: 2a9fb1c2535e9067063259742826afd3e588a6ed
+  data.tar.gz: a99f6cf865ea1075a2e26165c58c03483e45e93c
 SHA512:
-  metadata.gz: 0414aa6f0f18bdb882d9f54e558ed5301e4c52d77d417cdfd62d51fad0a51f5ebc5191d9ab86a56b6ee69d6c7c489f0c2395c10082b27381e04bfbc70152d3b9
-  data.tar.gz: 94f30d58cd6cd8cef946e87f039445910dd924638d00c40a95599d35e473e6eb840a14d4543c4dd405b953633257c3defafb33c777b0581dc2cb724bd05fa4d1
+  metadata.gz: 6b5a9a5c5a9b4af51e1115a152a58b1b2187ffcf4adaa912e9921824d3fbbf96c12b21df77461347ca0569eb6943542bea1dc50b7bbfa0cc57f583a5017c431d
+  data.tar.gz: 5742b0fe11b8bd4a61accb93ca762b4c42cdd4a95cc7044d76b1d7ee124ccc9df9ed3911b36ac8861ac57343c1757557eaa7ddc3ce03af036287e3c578ce58f8

data/lib/datasource/adapters/active_record.rb

@@ -20,18 +20,20 @@ module Datasource
           self
         end
 
-        def to_a
+      private
+        def exec_queries
           if @datasource
             datasource = @datasource.new(self)
             datasource.select(*Array(@datasource_select))
             if @datasource_serializer
               select = []
-              Datasource::Base.consumer_adapter.to_datasource_select(select, @datasource.orm_klass, @datasource_serializer)
+              Datasource::Base.consumer_adapter.to_datasource_select(select, @datasource.orm_klass, @datasource_serializer, nil, datasource.adapter)
 
               datasource.select(*select)
             end
 
-            datasource.results
+            @loaded = true
+            @records = datasource.results
           else
             super
           end
@@ -74,7 +76,8 @@ module Datasource
         end
       end
 
-      def self.association_reflection(klass, name)
+    module_function
+      def association_reflection(klass, name)
         if reflection = klass.reflections[name]
           {
             klass: reflection.klass,
@@ -84,19 +87,23 @@ module Datasource
         end
       end
 
-      def self.get_table_name(klass)
+      def get_table_name(klass)
         klass.table_name.to_sym
       end
 
-      def self.is_scope?(obj)
+      def is_scope?(obj)
         obj.kind_of?(::ActiveRecord::Relation)
       end
 
-      def self.scope_to_class(scope)
+      def scope_to_class(scope)
         scope.klass
       end
 
-      def self.association_klass(reflection)
+      def scope_loaded?(scope)
+        scope.loaded?
+      end
+
+      def association_klass(reflection)
         if reflection.macro == :belongs_to && reflection.options[:polymorphic]
           fail Datasource::Error, "polymorphic belongs_to not supported, write custom loader"
         else
@@ -104,7 +111,7 @@ module Datasource
         end
       end
 
-      def self.preload_association(records, name)
+      def preload_association(records, name)
         return if records.empty?
         return if records.first.association(name.to_sym).loaded?
         klass = records.first.class
@@ -144,43 +151,43 @@ module Datasource
         end
       end
 
-      def to_query
+      def to_query(ds)
         ::ActiveRecord::Base.uncached do
-          @scope.select(*get_select_values).to_sql
+          ds.scope.select(*ds.get_select_values).to_sql
         end
       end
 
-      def select_scope
-        @scope.select(*get_select_values)
+      def select_scope(ds)
+        ds.scope.select(*ds.get_select_values)
       end
 
-      def get_rows
+      def get_rows(ds)
         append_select = []
-        @expose_associations.each_pair do |assoc_name, assoc_select|
-          if reflection = Adapters::ActiveRecord.association_reflection(self.class.orm_klass, assoc_name.to_sym)
+        ds.expose_associations.each_pair do |assoc_name, assoc_select|
+          if reflection = Adapters::ActiveRecord.association_reflection(ds.class.orm_klass, assoc_name.to_sym)
             Datasource::Base.reflection_select(reflection, append_select, [])
           end
         end
-        select(*append_select)
+        ds.select(*append_select)
 
-        scope = select_scope
+        scope = select_scope(ds)
         if scope.respond_to?(:use_datasource)
           scope = scope.spawn.use_datasource(nil)
         end
         scope.includes_values = []
         scope.to_a.tap do |records|
-          @expose_associations.each_pair do |assoc_name, assoc_select|
+          ds.expose_associations.each_pair do |assoc_name, assoc_select|
             Adapters::ActiveRecord.preload_association(records, assoc_name)
           end
         end
       end
 
-      def primary_scope_table(scope)
-        scope.klass.table_name
+      def primary_scope_table(ds)
+        ds.scope.klass.table_name
       end
 
-      def ensure_table_join!(name, att)
-        join_value = @scope.joins_values.find do |value|
+      def ensure_table_join!(ds, name, att)
+        join_value = ds.scope.joins_values.find do |value|
           if value.is_a?(Symbol)
             value.to_s == att[:name]
           elsif value.is_a?(String)
@@ -203,6 +210,10 @@ module Datasource
                 klass
               end
 
+              define_singleton_method(:default_adapter) do
+                Datasource::Adapters::ActiveRecord
+              end
+
               define_method(:primary_key) do
                 klass.primary_key.to_sym
               end

data/lib/datasource/adapters/sequel.rb

@@ -25,7 +25,7 @@ module Datasource
             datasource.select(*Array(@datasource_select))
             if @datasource_serializer
               select = []
-              Datasource::Base.consumer_adapter.to_datasource_select(select, @datasource.orm_klass, @datasource_serializer)
+              Datasource::Base.consumer_adapter.to_datasource_select(select, @datasource.orm_klass, @datasource_serializer, nil, datasource.adapter)
 
               datasource.select(*select)
             end
@@ -75,7 +75,8 @@ module Datasource
         end
       end
 
-      def self.association_reflection(klass, name)
+    module_function
+      def association_reflection(klass, name)
         reflection = klass.association_reflections[name]
 
         macro = case reflection[:type]
@@ -92,15 +93,15 @@ module Datasource
         }
       end
 
-      def self.get_table_name(klass)
+      def get_table_name(klass)
         klass.table_name
       end
 
-      def self.is_scope?(obj)
+      def is_scope?(obj)
         obj.kind_of?(::Sequel::Dataset)
       end
 
-      def self.scope_to_class(scope)
+      def scope_to_class(scope)
         if scope.row_proc && scope.row_proc.ancestors.include?(::Sequel::Model)
           scope.row_proc
         else
@@ -108,29 +109,8 @@ module Datasource
         end
       end
 
-      def to_query(scope)
-        scope.sql
-      end
-
-      def select_scope
-        @scope.select(*get_sequel_select_values)
-      end
-
-      def get_rows
-        eager = {}
-        append_select = []
-        @expose_associations.each_pair do |assoc_name, assoc_select|
-          eager.merge!(
-            get_assoc_eager_options(self.class.orm_klass, assoc_name.to_sym, assoc_select, append_select))
-        end
-        # TODO: remove/disable datasource on scope if present
-        scope = select_scope
-        if scope.respond_to?(:use_datasource)
-          scope = scope.clone.use_datasource(nil)
-        end
-        scope
-        .select_append(*get_sequel_select_values(append_select.map { |v| primary_scope_table(@scope) + ".#{v}" }))
-        .eager(eager).all
+      def scope_loaded?(scope)
+        false
       end
 
       def get_assoc_eager_options(klass, name, assoc_select, append_select)
@@ -153,15 +133,40 @@ module Datasource
       end
 
       def get_sequel_select_values(values = nil)
-        (values || get_select_values).map { |str| ::Sequel.lit(str) }
+        values.map { |str| ::Sequel.lit(str) }
+      end
+
+      def to_query(ds)
+        ds.scope.sql
       end
 
-      def primary_scope_table(scope)
-        scope.first_source_alias.to_s
+      def select_scope(ds)
+        ds.scope.select(*get_sequel_select_values(ds.get_select_values))
       end
 
-      def ensure_table_join!(name, att)
-        join_value = Hash(@scope.opts[:join]).find do |value|
+      def get_rows(ds)
+        eager = {}
+        append_select = []
+        ds.expose_associations.each_pair do |assoc_name, assoc_select|
+          eager.merge!(
+            get_assoc_eager_options(ds.class.orm_klass, assoc_name.to_sym, assoc_select, append_select))
+        end
+        # TODO: remove/disable datasource on scope if present
+        scope = select_scope(ds)
+        if scope.respond_to?(:use_datasource)
+          scope = scope.clone.use_datasource(nil)
+        end
+        scope
+        .select_append(*get_sequel_select_values(append_select.map { |v| primary_scope_table(ds) + ".#{v}" }))
+        .eager(eager).all
+      end
+
+      def primary_scope_table(ds)
+        ds.scope.first_source_alias.to_s
+      end
+
+      def ensure_table_join!(ds, name, att)
+        join_value = Hash(ds.scope.opts[:join]).find do |value|
           (value.table_alias || value.table).to_s == att[:name]
         end
         fail Datasource::Error, "given scope does not join on #{name}, but it is required by #{att[:name]}" unless join_value
@@ -178,6 +183,10 @@ module Datasource
                 klass
               end
 
+              define_singleton_method(:default_adapter) do
+                Datasource::Adapters::Sequel
+              end
+
               define_method(:primary_key) do
                 klass.primary_key
               end

data/lib/datasource/base.rb

@@ -8,10 +8,9 @@ module Datasource
         base._attributes = (_attributes || {}).dup
         base._associations = (_associations || {}).dup
         base._loaders = (_loaders || {}).dup
-        self.send :include, adapter
       end
 
-      def adapter
+      def default_adapter
         @adapter ||= begin
           Datasource::Adapters.const_get(Datasource::Adapters.constants.first)
         end
@@ -68,7 +67,10 @@ module Datasource
       end
     end
 
-    def initialize(scope)
+    attr_reader :scope, :expose_attributes, :expose_associations, :adapter
+
+    def initialize(scope, adapter = nil)
+      @adapter = adapter || self.class.default_adapter
       @scope =
         if self.class._update_scope
           self.class._update_scope.call(scope)
@@ -115,7 +117,7 @@ module Datasource
     end
 
     def get_select_values
-      scope_table = primary_scope_table(@scope)
+      scope_table = adapter.primary_scope_table(self)
       select_values = Set.new
       select_values.add("#{scope_table}.#{primary_key}")
 
@@ -127,7 +129,7 @@ module Datasource
             att[:klass]._depends.keys.map(&:to_s).each do |name|
               next if name == scope_table
               next if name == "loaders"
-              ensure_table_join!(name, att)
+              adapter.ensure_table_join!(self, name, att)
             end
             att[:klass]._depends.each_pair do |table, names|
               next if table.to_sym == :loaders
@@ -140,7 +142,7 @@ module Datasource
             select_values.add("(#{att[:klass].select_value}) as #{att[:name]}")
             att[:klass]._depends.each do |name|
               next if name == scope_table
-              ensure_table_join!(name, att)
+              adapter.ensure_table_join!(self, name, att)
             end
           end
         end
@@ -153,11 +155,11 @@ module Datasource
     end
 
     def results(rows = nil)
-      rows ||= get_rows
+      rows ||= adapter.get_rows(self)
 
       @expose_attributes.each do |name|
         att = self.class._attributes[name]
-        fail Datasource::Error, "attribute #{name} doesn't exist for #{self.class.orm_klass.name}, did you forget to call \"computed :#{name}, <dependencies>\" in your datasource_module?" unless att
+        fail Datasource::Error, "attribute #{name} doesn't exist for #{self.class.orm_klass.name}, did you forget to call \"computed :#{name}, :db_column_dependency\" in your datasource_module? See https://github.com/mrbrdo/datasource#model-methods--virtual-attributes" unless att
         klass = att[:klass]
         next unless klass
 

data/lib/datasource/consumer_adapters/active_model_serializers.rb

@@ -3,25 +3,20 @@ require "active_model/serializer"
 module Datasource
   module ConsumerAdapters
     module ActiveModelSerializers
-      superclass = if defined?(ActiveModel::Serializer::ArraySerializer)
-        ActiveModel::Serializer::ArraySerializer
-      else
-        ActiveModel::ArraySerializer
-      end
-      class ArraySerializer < superclass
-        def initialize(objects, options = {})
+      module ArraySerializer
+        def initialize_with_datasource(objects, options = {})
           datasource_class = options.delete(:datasource)
-          adapter = Datasource::Base.adapter
-          if adapter.is_scope?(objects)
+          adapter = Datasource.orm_adapters.find { |a| a.is_scope?(objects) }
+          if adapter && !adapter.scope_loaded?(objects)
             datasource_class ||= adapter.scope_to_class(objects).default_datasource
 
             records = objects
               .with_datasource(datasource_class)
               .for_serializer(options[:serializer]).all.to_a # all needed for Sequel eager loading
 
-            super(records, options)
+            initialize_without_datasource(records, options)
           else
-            super
+            initialize_without_datasource(objects, options)
           end
         end
       end
@@ -38,7 +33,8 @@ module Datasource
         serializer || "#{klass.name}Serializer".constantize
       end
 
-      def to_datasource_select(result, klass, serializer = nil, serializer_assoc = nil)
+      def to_datasource_select(result, klass, serializer = nil, serializer_assoc = nil, adapter = nil)
+        adapter ||= Datasource::Base.default_adapter
         serializer ||= get_serializer_for(klass, serializer_assoc)
         result.concat(serializer._attributes)
         result_assocs = {}
@@ -46,12 +42,12 @@ module Datasource
 
         serializer._associations.each_pair do |name, serializer_assoc|
           # TODO: what if assoc is renamed in serializer?
-          reflection = Datasource::Base.adapter.association_reflection(klass, name.to_sym)
+          reflection = adapter.association_reflection(klass, name.to_sym)
           assoc_class = reflection[:klass]
 
           name = name.to_s
           result_assocs[name] = []
-          to_datasource_select(result_assocs[name], assoc_class, nil, serializer_assoc)
+          to_datasource_select(result_assocs[name], assoc_class, nil, serializer_assoc, adapter)
         end
       rescue Exception => ex
         if ex.is_a?(SystemStackError) || ex.is_a?(Datasource::RecursionError)
@@ -62,5 +58,18 @@ module Datasource
       end
     end
   end
-  ArrayAMS = ConsumerAdapters::ActiveModelSerializers::ArraySerializer
+end
+
+array_serializer_class = if defined?(ActiveModel::Serializer::ArraySerializer)
+  ActiveModel::Serializer::ArraySerializer
+else
+  ActiveModel::ArraySerializer
+end
+
+array_serializer_class.class_exec do
+  alias_method :initialize_without_datasource, :initialize
+  include Datasource::ConsumerAdapters::ActiveModelSerializers::ArraySerializer
+  def initialize(*args)
+    initialize_with_datasource(*args)
+  end
 end

data/lib/datasource.rb

@@ -2,18 +2,39 @@ module Datasource
   Error = Class.new(StandardError)
   RecursionError = Class.new(StandardError)
 
-  def self.load(adapter = nil)
-    unless adapter
-      adapter = if defined? ActiveRecord
-        :activerecord
+  AdapterPaths = {
+    activerecord: 'datasource/adapters/active_record',
+    active_record: :activerecord,
+    sequel: 'datasource/adapters/sequel',
+    ams: 'datasource/consumer_adapters/active_model_serializers',
+    active_model_serializers: :ams
+  }
+
+module_function
+  def load(*adapters)
+    if adapters.empty?
+      adapters = []
+      if defined? ActiveRecord
+        adapters.push(:activerecord)
       elsif defined? Sequel
-        :sequel
+        adapters.push(:sequel)
+      end
+      if defined? ActiveModel::Serializer
+        adapters.push(:ams)
       end
     end
 
-    require 'datasource/adapters/active_record' if [:activerecord, :active_record].include?(adapter)
-    require 'datasource/adapters/sequel' if adapter == :sequel
-    require 'datasource/consumer_adapters/active_model_serializers' if defined? ActiveModel::Serializer
+    adapters.each do |adapter|
+      adapter = AdapterPaths[adapter]
+      adapter = AdapterPaths[adapter] if adapter.is_a?(Symbol)
+      require adapter
+    end
+  end
+
+  def orm_adapters
+    @orm_adapters ||= begin
+      Datasource::Adapters.constants.map { |name| Datasource::Adapters.const_get(name) }
+    end
   end
 end
 

data/lib/generators/datasource/templates/initializer.rb

@@ -1,11 +1 @@
-Datasource.load(:activerecord)
-
-if defined? ActiveModel::Serializer
-  if ActiveModel::Serializer.respond_to?(:config)
-    ActiveModel::Serializer.config.array_serializer = Datasource::ArrayAMS
-  else
-    ActiveModel::Serializer.setup do |config|
-      config.array_serializer = Datasource::ArrayAMS
-    end
-  end
-end
+Datasource.load(:activerecord, :active_model_serializers)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datasource
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Jan Berdajs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2014-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +94,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.17'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: 
 email:
 - mrbrdo@gmail.com
@@ -87,12 +143,6 @@ files:
 - lib/datasource/serializer.rb
 - lib/generators/datasource/install_generator.rb
 - lib/generators/datasource/templates/initializer.rb
-- test/active_record_helper.rb
-- test/schema.rb
-- test/test_helper.rb
-- test/test_loader.rb
-- test/test_scope.rb
-- test/test_serializer.rb
 homepage: https://github.com/mrbrdo/datasource
 licenses:
 - MIT
@@ -116,12 +166,5 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Ruby library for creating data source objects from database data
-test_files:
-- test/active_record_helper.rb
-- test/schema.rb
-- test/test_helper.rb
-- test/test_loader.rb
-- test/test_scope.rb
-- test/test_serializer.rb
-has_rdoc: 
+summary: Ruby library to automatically preload records for your serializers
+test_files: []

data/test/active_record_helper.rb

@@ -1,23 +0,0 @@
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
-ActiveRecord::Migration.verbose = false
-load "schema.rb"
-
-def clean_db
-  ActiveRecord::Base.connection.execute("DELETE FROM comments")
-  ActiveRecord::Base.connection.execute("DELETE FROM posts")
-  ActiveRecord::Base.connection.execute("DELETE FROM blogs")
-  ActiveRecord::Base.connection.execute("DELETE FROM sqlite_sequence")
-end
-
-def assert_query_count(count)
-  old_logger = ActiveRecord::Base.logger
-  logger = StringIO.new
-  ActiveRecord::Base.logger = Logger.new(logger)
-  begin
-    yield
-  ensure
-    ActiveRecord::Base.logger = old_logger
-    # puts logger.string
-  end
-  assert_equal count, logger.string.lines.count
-end

data/test/schema.rb

@@ -1,19 +0,0 @@
-ActiveRecord::Schema.define(:version => 0) do
-  create_table :blogs, :force => true do |t|
-    t.string :title
-  end
-
-  create_table :posts, :force => true do |t|
-    t.integer :blog_id
-    t.string :title
-    t.string :author_first_name
-    t.string :author_last_name
-  end
-
-  create_table :comments, :force => true do |t|
-    t.integer :post_id
-    t.text :comment
-  end
-end
-
-ActiveRecord::Base.send :include, Datasource::Adapters::ActiveRecord::Model

data/test/test_helper.rb

@@ -1,14 +0,0 @@
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
-
-require 'minitest/autorun'
-require 'active_support/all'
-require 'active_record'
-require 'datasource'
-require 'active_model_serializers'
-require 'pry'
-
-Datasource.load(:activerecord)
-
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/test/test_loader.rb

@@ -1,79 +0,0 @@
-require 'test_helper'
-require 'active_record_helper'
-
-class LoaderTest < ActiveSupport::TestCase
-  class Comment < ActiveRecord::Base
-    self.table_name = "comments"
-    belongs_to :post
-  end
-
-  class Post < ActiveRecord::Base
-    self.table_name = "posts"
-    has_many :comments
-
-    datasource_module do
-      loader :newest_comment, group_by: :post_id, one: true do |post_ids|
-        Comment.for_serializer.where(post_id: post_ids)
-          .group("post_id")
-          .having("id = MAX(id)")
-          .datasource_select(:post_id)
-      end
-
-      loader :newest_comment_text, array_to_hash: true do |post_ids|
-        Comment.where(post_id: post_ids)
-          .group("post_id")
-          .having("id = MAX(id)")
-          .pluck("post_id, comment")
-      end
-
-      loader :ordered_comments, group_by: :post_id do |post_ids|
-        Comment.for_serializer(CommentSerializer).where(post_id: post_ids)
-          .order("post_id, id desc")
-          .datasource_select(:post_id)
-      end
-
-      computed :newest_comment, loaders: :newest_comment
-      computed :newest_comment_text, loaders: :newest_comment_text
-      computed :ordered_comments, loaders: :ordered_comments
-    end
-
-    def name_initials
-      return unless author_first_name && author_last_name
-      author_first_name[0].upcase + author_last_name[0].upcase
-    end
-  end
-
-  class CommentSerializer < ActiveModel::Serializer
-    attributes :id, :comment
-  end
-
-  class PostSerializer < ActiveModel::Serializer
-    attributes :id, :title, :newest_comment, :newest_comment_text, :ordered_comments
-
-    def newest_comment
-      CommentSerializer.new(object.loaded_values[:newest_comment]).as_json
-    end
-
-    def newest_comment_text
-      object.loaded_values[:newest_comment_text]
-    end
-
-    def ordered_comments
-      Datasource::ArrayAMS.new(object.loaded_values[:ordered_comments]).as_json
-    end
-  end
-
-  def test_loader
-    post = Post.create! title: "First Post"
-    2.times { |i| post.comments.create! comment: "Comment #{i+1}" }
-
-    assert_query_count(4) do
-      assert_equal Datasource::ArrayAMS.new(Post.all).as_json,
-        [{:id=>1, :title=>"First Post", :newest_comment=>{"comment"=>{:id=>2, :comment=>"Comment 2"}}, :newest_comment_text=>"Comment 2", :ordered_comments=>[{:id=>2, :comment=>"Comment 2"}, {:id=>1, :comment=>"Comment 1"}]}]
-    end
-  end
-
-  def teardown
-    clean_db
-  end
-end

data/test/test_scope.rb

@@ -1,50 +0,0 @@
-require 'test_helper'
-require 'active_record_helper'
-
-class ScopeTest < ActiveSupport::TestCase
-  class Post < ActiveRecord::Base
-    belongs_to :blog
-
-    datasource_module do
-      query :author_name do
-        "posts.author_first_name || ' ' || posts.author_last_name"
-      end
-    end
-  end
-
-  class PostSerializer < ActiveModel::Serializer
-    attributes :id, :title, :author_name
-  end
-
-  def test_first
-    Post.create! title: "The Post", author_first_name: "John", author_last_name: "Doe", blog_id: 10
-    post = Post.for_serializer.first
-
-    assert_equal("The Post", post.title)
-    assert_equal("John Doe", post.author_name)
-    assert_raises(ActiveModel::MissingAttributeError) { post.blog_id }
-  end
-
-  def test_find
-    post = Post.create! title: "The Post", author_first_name: "John", author_last_name: "Doe", blog_id: 10
-    post = Post.for_serializer.find(post.id)
-
-    assert_equal("The Post", post.title)
-    assert_equal("John Doe", post.author_name)
-    assert_raises(ActiveModel::MissingAttributeError) { post.blog_id }
-  end
-
-  def test_each
-    post = Post.create! title: "The Post", author_first_name: "John", author_last_name: "Doe", blog_id: 10
-
-    Post.for_serializer.each do |post|
-      assert_equal("The Post", post.title)
-      assert_equal("John Doe", post.author_name)
-      assert_raises(ActiveModel::MissingAttributeError) { post.blog_id }
-    end
-  end
-
-  def teardown
-    clean_db
-  end
-end

data/test/test_serializer.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-require 'active_record_helper'
-
-class SerializerTest < ActiveSupport::TestCase
-  class Post < ActiveRecord::Base
-    belongs_to :blog
-
-    datasource_module do
-      query :author_name do
-        "posts.author_first_name || ' ' || posts.author_last_name"
-      end
-    end
-  end
-
-  class Blog < ActiveRecord::Base
-    has_many :posts
-  end
-
-  class BlogSerializer < ActiveModel::Serializer
-    attributes :id, :title
-
-    has_many :posts
-  end
-
-  class PostSerializer < ActiveModel::Serializer
-    attributes :id, :title, :author_name
-  end
-
-  def test_blogs_and_posts_serializer
-    blog = Blog.create! title: "Blog 1"
-    blog.posts.create! title: "Post 1", author_first_name: "John", author_last_name: "Doe"
-    blog.posts.create! title: "Post 2", author_first_name: "Maria", author_last_name: "Doe"
-    blog = Blog.create! title: "Blog 2"
-
-    expected_result = [
-      {:id =>1, :title =>"Blog 1", :posts =>[
-        {:id =>1, :title =>"Post 1", :author_name =>"John Doe"},
-        {:id =>2, :title =>"Post 2", :author_name =>"Maria Doe"}
-      ]},
-      {:id =>2, :title =>"Blog 2", :posts =>[]}
-    ]
-
-    assert_query_count(2) do
-      serializer = Datasource::ArrayAMS.new(Blog.all)
-      assert_equal(expected_result, serializer.as_json)
-    end
-  end
-
-  def teardown
-    clean_db
-  end
-end