mr 0.35.2

data/test/support/read_model/querying.rb

@@ -0,0 +1,150 @@
+require 'mr/read_model/query_expression'
+
+module MR; end
+module MR::ReadModel; end
+module MR::ReadModel::Querying
+
+  module TestHelpers
+    module_function
+
+    def assert_static_expression_added(relation, type, *args)
+      with_backtrace(caller) do
+        assert_equal 1, relation.query_expressions.size
+        expression = relation.query_expressions.first
+        assert_static_expression expression, type, args
+      end
+    end
+
+    def assert_dynamic_expression_added(relation, type, block)
+      with_backtrace(caller) do
+        assert_equal 1, relation.query_expressions.size
+        expression = relation.query_expressions.first
+        assert_dynamic_expression expression, type, block
+      end
+    end
+
+    def assert_static_merge_expression_added(relation, type, *args)
+      with_backtrace(caller) do
+        assert_equal 1, relation.query_expressions.size
+        expression = relation.query_expressions.first
+        assert_static_merge_expression expression, type, args
+      end
+    end
+
+    def assert_dynamic_merge_expression_added(relation, type, block)
+      with_backtrace(caller) do
+        assert_equal 1, relation.query_expressions.size
+        expression = relation.query_expressions.first
+        assert_dynamic_merge_expression expression, type, block
+      end
+    end
+
+    def assert_inner_join_subquery_added(relation, block)
+      with_backtrace(caller) do
+        assert_join_subquery_added(relation, :inner, block)
+      end
+    end
+
+    def assert_left_outer_join_subquery_added(relation, block)
+      with_backtrace(caller) do
+        assert_join_subquery_added(relation, :left, block)
+      end
+    end
+
+    def assert_right_outer_join_subquery_added(relation, block)
+      with_backtrace(caller) do
+        assert_join_subquery_added(relation, :right, block)
+      end
+    end
+
+    def assert_full_outer_join_subquery_added(relation, block)
+      with_backtrace(caller) do
+        assert_join_subquery_added(relation, :full, block)
+      end
+    end
+
+    def assert_join_subquery_added(relation, type, block)
+      assert_equal 1, relation.query_expressions.size
+      expression = relation.query_expressions.first
+      expected_class = MR::ReadModel::SubqueryExpression
+      assert_instance_of expected_class, expression
+      assert_join_subquery_expression expression, type, block
+    end
+
+    def assert_set_expression_added(relation, operator, block)
+      with_backtrace(caller) do
+        assert_equal 1, relation.set_expressions.size
+        expression = relation.set_expressions.first
+        expression_class = MR::ReadModel::SetExpression
+        assert_instance_of expression_class, expression
+        exp = expression_class::OPERATOR_SQL[operator]
+        assert_equal exp,   expression.operator_sql
+        assert_equal block, expression.read_model_block
+      end
+    end
+
+    def assert_static_expression(expression, type, args)
+      expected_class = MR::ReadModel::StaticQueryExpression
+      assert_instance_of expected_class, expression
+      assert_equal type, expression.type
+      assert_equal [*args], expression.args
+    end
+
+    def assert_dynamic_expression(expression, type, block)
+      expected_class = MR::ReadModel::DynamicQueryExpression
+      assert_instance_of expected_class, expression
+      assert_equal type,  expression.type
+      assert_equal block, expression.block
+    end
+
+    def assert_merge_expression(expression, type)
+      expected_class = MR::ReadModel::MergeQueryExpression
+      assert_instance_of expected_class, expression
+      assert_equal expression.type, type
+    end
+
+    def assert_static_merge_expression(expression, type, args)
+      assert_merge_expression expression, type
+      assert_static_expression expression.query_expression, :merge, args
+    end
+
+    def assert_dynamic_merge_expression(expression, type, block)
+      assert_merge_expression expression, type
+      assert_dynamic_expression expression.query_expression, :merge, block
+    end
+
+    def assert_subquery_expression(expression, type)
+      expected_class = MR::ReadModel::SubqueryExpression
+      assert_kind_of expected_class, expression
+      assert_equal type, expression.subquery_type
+    end
+
+    def assert_join_subquery_expression(expression, type, block)
+      assert_subquery_expression expression, :joins
+      assert_includes type, expression.subquery_args
+      assert_equal block, expression.subquery_block
+    end
+
+    def assert_expression_applied(relation_spy, type, *args)
+      with_backtrace(caller) do
+        message = "couldn't find an applied #{type} expression " \
+                  "with #{args.inspect} args"
+        assert_not_nil find_applied(relation_spy, type, args), message
+      end
+    end
+
+    def assert_not_expression_applied(relation_spy, type, *args)
+      with_backtrace(caller) do
+        message = "found an applied #{type} expression " \
+                  "with #{args.inspect} args"
+        assert_nil find_applied(relation_spy, type, args), message
+      end
+    end
+
+    def find_applied(relation_spy, type, args)
+      relation_spy.applied.find{ |e| e.type == type && e.args == args }
+    end
+
+  end
+
+end

data/test/support/read_models/comment_with_user_data.rb

@@ -0,0 +1,27 @@
+require 'mr'
+require 'test/support/models/comment'
+require 'test/support/models/user'
+
+class CommentWithUserData
+  include MR::ReadModel
+
+  field :comment_id,         :primary_key, 'comments.id'
+  field :comment_created_at, :datetime,    'comments.created_at'
+  field :user_name,          :string,      'users.name'
+  field :user_number,        :integer,     'users.number'
+  field :user_salary,        :decimal,     'users.salary'
+  field :user_started_on,    :date,        'users.started_on'
+  field :user_dob,           :timestamp,   'users.dob'
+  field :image_data,         :binary,      'images.data'
+  field :area_active,        :boolean,     'areas.active'
+  field :area_meeting_time,  :time,        'areas.meeting_time'
+  field :area_description,   :text,        'areas.description'
+  field :area_percentage,    :float,       'areas.percentage'
+  from CommentRecord
+  joins "INNER JOIN users ON " \
+          "'#{UserRecord}' = comments.parent_type AND " \
+          "users.id = comments.parent_id " \
+        "INNER JOIN images ON images.user_id = users.id " \
+        "INNER JOIN areas ON areas.id = users.area_id"
+
+end

data/test/support/read_models/set_data.rb

@@ -0,0 +1,49 @@
+require 'mr'
+require 'test/support/models/area'
+
+class SetData
+  include MR::ReadModel
+
+  field :id,   :primary_key, 'filtered_areas.id'
+  field :name, :string,      'filtered_areas.name'
+
+  from_subquery do
+    read_model do
+
+      select 'areas.id, areas.name'
+      from AreaRecord
+      where do |params|
+        AreaRecord.where("areas.name LIKE ?", "#{params[:match_start]}%")
+      end
+
+      union do
+        select 'areas.id, areas.name'
+        from AreaRecord
+        where do |params|
+          AreaRecord.where("areas.name LIKE ?", "#{params[:other_match_start]}%")
+        end
+      end
+
+      intersect do
+        select 'areas.id, areas.name'
+        from AreaRecord
+        where do |params|
+          AreaRecord.where("areas.name LIKE ?", "%#{params[:match_end]}")
+        end
+      end
+
+      except do
+        select 'areas.id, areas.name'
+        from AreaRecord
+        where do |params|
+          AreaRecord.where("areas.name LIKE ?", "%#{params[:non_match]}%")
+        end
+      end
+
+    end
+    as 'filtered_areas'
+  end
+
+  find_attr 'filtered_areas.id'
+
+end

data/test/support/read_models/subquery_data.rb

@@ -0,0 +1,41 @@
+require 'mr'
+require 'test/support/models/area'
+require 'test/support/models/comment'
+require 'test/support/models/user'
+
+class SubqueryData
+  include MR::ReadModel
+
+  field :area_id,    :primary_key, 'my_areas.id'
+  field :user_id,    :primary_key, 'my_users.id'
+  field :comment_id, :primary_key, 'my_comments.id'
+
+  from_subquery do
+    read_model do
+      select '*'
+      from AreaRecord
+    end
+    as 'my_areas'
+  end
+
+  inner_join_subquery do
+    read_model do
+      from UserRecord
+      where{ |args| UserRecord.where(:started_on => args[:started_on]) }
+    end
+    as 'my_users'
+    on 'my_users.area_id = my_areas.id'
+  end
+  left_join_subquery do
+    read_model do
+      from CommentRecord
+      where CommentRecord.where(:parent_type => UserRecord.to_s)
+    end
+    as 'my_comments'
+    on "my_comments.parent_type = '#{UserRecord}' AND " \
+       "my_comments.parent_id = my_users.id"
+  end
+
+  find_attr 'my_areas.id'
+
+end

data/test/support/read_models/user_with_area_data.rb

@@ -0,0 +1,15 @@
+require 'mr'
+require 'test/support/models/user'
+
+class UserWithAreaData
+  include MR::ReadModel
+
+  field :user_id,   :primary_key, 'users.id'
+  field :user_name, :string,      'users.name'
+  field :area_id,   :primary_key, 'areas.id'
+  field :area_name, :string,      'areas.name'
+  from UserRecord
+  joins :area
+  where{ |area_id| UserRecord.where("areas.id = ?", area_id) }
+
+end

data/test/support/schema.rb

@@ -0,0 +1,39 @@
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table :areas do |t|
+    t.string  :name
+    t.boolean :active
+    t.float   :ratio
+    t.text    :description
+    t.float   :percentage
+    t.time    :meeting_time
+  end
+
+  create_table :users do |t|
+    t.string    :name
+    t.integer   :number
+    t.decimal   :salary
+    t.date      :started_on
+    t.timestamp :dob
+    t.integer   :area_id, :null => false
+    t.integer   :benchmark_area_id
+  end
+
+  create_table :images do |t|
+    t.string  :file_path
+    t.binary  :data
+    t.integer :user_id, :null => false
+    t.integer :benchmark_user_id
+  end
+
+  create_table :comments do |t|
+    t.text     :body
+    t.string   :parent_type, :null => false
+    t.integer  :parent_id,   :null => false
+    t.datetime :created_at
+    t.integer  :created_by_id
+    t.string   :benchmark_parent_type
+    t.integer  :benchmark_parent_id
+  end
+
+end

data/test/support/setup_test_db.rb

@@ -0,0 +1,10 @@
+require 'ardb'
+ENV['ARDB_DB_FILE'] = 'test/support/db'
+Ardb.init
+
+require 'ardb/test_helpers'
+Ardb::TestHelpers.reset_db
+
+require 'ardb/db_tests'
+class DbTests < Ardb::DbTests
+end

data/test/system/factory/model_factory_tests.rb

@@ -0,0 +1,87 @@
+require 'assert'
+require 'mr/factory/model_factory'
+
+require 'mr/test_helpers'
+require 'test/support/setup_test_db'
+require 'test/support/models/area'
+require 'test/support/models/user'
+
+class MR::Factory::ModelFactory
+
+  class SystemTests < DbTests
+    include MR::TestHelpers
+
+    desc "MR::Factory::Model"
+    setup do
+      @factory_class = MR::Factory::ModelFactory
+    end
+
+  end
+
+  class BuildingRealModelTests < SystemTests
+    setup do
+      @factory = @factory_class.new(User, UserRecord)
+    end
+    subject{ @factory }
+
+    should "build a model with it's fields set using `model`" do
+      user = subject.model
+      assert_instance_of User, user
+      assert_instance_of UserRecord, user.record
+      assert_true user.new?
+      assert_kind_of String,  user.name
+      assert_kind_of Integer, user.number
+      assert_kind_of Date,    user.started_on
+      assert_kind_of Time,    user.dob
+      assert_true user.salary.kind_of?(Float) || user.salary.kind_of?(BigDecimal)
+      assert_nil user.area_id
+    end
+
+    should "build a model and save it using `saved_model`" do
+      area_factory = @factory_class.new(Area, AreaRecord)
+      area = area_factory.model.tap(&:save)
+
+      user = subject.saved_model(:area => area)
+      assert_instance_of User, user
+      assert_false user.new?
+    end
+
+    should "build a model stack using `stack`" do
+      assert_instance_of MR::Factory::ModelStack, subject.stack
+    end
+
+  end
+
+  class BuildingFakeModelTests < SystemTests
+    setup do
+      @factory = @factory_class.new(User, FakeUserRecord)
+    end
+    subject{ @factory }
+
+    should "build a model with it's fields set using `model`" do
+      user = subject.model
+      assert_instance_of User, user
+      assert_instance_of FakeUserRecord, user.record
+      assert_true user.new?
+      assert_kind_of String,     user.name
+      assert_kind_of Integer,    user.number
+      assert_kind_of Date,       user.started_on
+      assert_kind_of Time,       user.dob
+      assert_true user.salary.kind_of?(Float) || user.salary.kind_of?(BigDecimal)
+      assert_nil user.area_id
+    end
+
+    should "build a model and save it using `saved_model`" do
+      user = subject.saved_model
+      assert_instance_of User, user
+      assert_false user.new?
+      assert_not_model_saved user
+    end
+
+    should "build a model stack for an instance using `stack`" do
+      assert_instance_of MR::Factory::ModelStack, subject.stack
+    end
+
+  end
+
+end

data/test/system/factory/model_stack_tests.rb

@@ -0,0 +1,30 @@
+require 'assert'
+require 'mr/factory/model_stack'
+
+require 'test/support/setup_test_db'
+require 'test/support/models/comment'
+
+class MR::Factory::ModelStack
+
+  class SystemTests < DbTests
+    desc "MR::Factory::ModelStack"
+    setup do
+      @comment        = Comment.new(:parent_type => 'UserRecord')
+      @factory_config = MR::Factory::RecordFactory::Config.new(@comment.class)
+
+      @model_stack = MR::Factory::ModelStack.new(@comment, @factory_config)
+    end
+    subject{ @model_stack }
+
+    should "build an instance of the model with all belongs to associations set" do
+      assert_instance_of Comment, @comment
+      assert_true @comment.new?
+      assert_instance_of User, @comment.parent
+      assert_true @comment.parent.new?
+      assert_instance_of Area, @comment.parent.area
+      assert_true @comment.parent.area.new?
+    end
+
+  end
+
+end