mr 0.35.2

data/test/unit/read_model/set_querying_tests.rb

@@ -0,0 +1,149 @@
+require 'assert'
+require 'mr/read_model/set_querying'
+
+require 'ardb/relation_spy'
+require 'much-plugin'
+require 'mr/fake_record'
+require 'mr/read_model/query_expression'
+require 'test/support/read_model/querying'
+
+module MR::ReadModel::SetQuerying
+
+  class UnitTests < Assert::Context
+    include MR::ReadModel::Querying::TestHelpers
+
+    desc "MR::ReadModel::SetQuerying"
+    setup do
+      @read_model_class = Class.new do
+        include MR::ReadModel::SetQuerying
+      end
+    end
+    subject{ @read_model_class }
+
+    should have_imeths :relation
+    should have_imeths :union, :union_all
+    should have_imeths :intersect, :intersect_all
+    should have_imeths :except, :except_all
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, MR::ReadModel::SetQuerying
+    end
+
+    should "mixin read model querying mixin" do
+      assert_includes MR::ReadModel::Querying, subject
+    end
+
+    should "return a set querying relation using `relation`" do
+      relation = subject.relation
+      assert_instance_of MR::ReadModel::SetQuerying::Relation, relation
+      assert_same relation, subject.relation
+    end
+
+  end
+
+  class WithFromRecordClassTests < UnitTests
+    setup do
+      @ar_relation_spy = Ardb::RelationSpy.new
+      Assert.stub(FakeTestRecord, :scoped){ @ar_relation_spy }
+      @read_model_class.from FakeTestRecord
+      @relation = @read_model_class.relation
+    end
+
+    should "add a union to the relation using `union`" do
+      union_proc = proc{ read_model FakeTestRecord }
+      subject.union(&union_proc)
+      assert_set_expression_added @relation, :union, union_proc
+    end
+
+    should "add a union all to the relation using `union_all`" do
+      union_all_proc = proc{ read_model FakeTestRecord }
+      subject.union_all(&union_all_proc)
+      assert_set_expression_added @relation, :union_all, union_all_proc
+    end
+
+    should "add a intersect to the relation using `intersect`" do
+      intersect_proc = proc{ read_model FakeTestRecord }
+      subject.intersect(&intersect_proc)
+      assert_set_expression_added @relation, :intersect, intersect_proc
+    end
+
+    should "add a intersect all to the relation using `intersect_all`" do
+      intersect_all_proc = proc{ read_model FakeTestRecord }
+      subject.intersect_all(&intersect_all_proc)
+      assert_set_expression_added @relation, :intersect_all, intersect_all_proc
+    end
+
+    should "add a except to the relation using `except`" do
+      except_proc = proc{ read_model FakeTestRecord }
+      subject.except(&except_proc)
+      assert_set_expression_added @relation, :except, except_proc
+    end
+
+    should "add a except all to the relation using `except_all`" do
+      except_all_proc = proc{ read_model FakeTestRecord }
+      subject.except_all(&except_all_proc)
+      assert_set_expression_added @relation, :except_all, except_all_proc
+    end
+
+    should "raise an argument error when any set method isn't provided a block" do
+      assert_raises(ArgumentError){ subject.union }
+      assert_raises(ArgumentError){ subject.union_all }
+      assert_raises(ArgumentError){ subject.intersect }
+      assert_raises(ArgumentError){ subject.intersect_all }
+      assert_raises(ArgumentError){ subject.except }
+      assert_raises(ArgumentError){ subject.except_all }
+    end
+
+  end
+
+  class RelationTests < UnitTests
+    desc "Relation"
+    setup do
+      @relation_class = Relation
+      @relation       = @relation_class.new
+    end
+    subject{ @relation }
+
+    should have_readers :set_expressions
+    should have_imeths :build_sql
+
+    should "not have any set expressions by default" do
+      assert_equal [], subject.set_expressions
+    end
+
+    should "know how to build its sql" do
+      Factory.integer(3).times.each do
+        column = Factory.string
+
+        @relation.set_expressions << Factory.read_model_set_expression do
+          select{ |p| p ? p['column'] : column }
+          from FakeTestRecord
+        end
+      end
+
+      built_sql    = Factory.text
+      relation_spy = Ardb::RelationSpy.new
+      Assert.stub(relation_spy, :to_sql){ built_sql }
+      Assert.stub(subject, :build_for_all){ relation_spy }
+
+      exp = @relation.set_expressions.inject(built_sql){ |s, e| e.combine_sql(s) }
+      assert_equal exp, subject.build_sql
+
+      params = { Factory.string => Factory.string }
+      exp = @relation.set_expressions.inject(built_sql) do |s, e|
+        e.combine_sql(s, params)
+      end
+      assert_equal exp, subject.build_sql(params)
+    end
+
+  end
+
+  class FakeTestRecord
+    include MR::FakeRecord
+
+    def self.scoped
+      Ardb::RelationSpy.new
+    end
+  end
+
+end

data/test/unit/read_model/subquery_tests.rb

@@ -0,0 +1,242 @@
+require 'assert'
+require 'mr/read_model/subquery'
+
+require 'ardb/relation_spy'
+require 'mr/fake_record'
+require 'mr/read_model/set_querying'
+require 'test/support/read_model/querying'
+
+module MR::ReadModel
+
+  class UnitTests < Assert::Context
+    include Querying::TestHelpers
+    desc "MR::ReadModel"
+    setup do
+      @column = column = Factory.string
+      @subquery_block = proc do
+        read_model do
+          select column
+          from FakeTestRecord
+        end
+      end
+
+      @subquery_with_params_block = proc do
+        read_model do
+          select{ |params| params['column'] }
+          from FakeTestRecord
+        end
+      end
+    end
+
+  end
+
+  class SubqueryTests < UnitTests
+    desc "Subquery"
+    setup do
+      @subquery_class = Class.new{ include MR::ReadModel::Subquery }
+
+      @subquery = @subquery_class.new(&@subquery_block)
+    end
+    subject{ @subquery }
+
+    should have_readers :read_model_class
+    should have_imeths :read_model, :build_sql
+
+    should "know its read model class" do
+      read_model_class = subject.read_model_class
+      assert_includes MR::ReadModel,              read_model_class
+      assert_includes MR::ReadModel::SetQuerying, read_model_class
+      relation_spy = read_model_class.relation
+      assert_static_expression_added relation_spy, :select, @column
+    end
+
+    should "build the subquery's SQL using `build_sql`" do
+      exp = "(#{subject.read_model_class.relation.build_for_all.to_sql})"
+      assert_equal exp, subject.build_sql
+
+      subquery = @subquery_class.new(&@subquery_with_params_block)
+      params = { 'column' => Factory.string }
+      exp = "(#{subquery.read_model_class.build_sql(params)})"
+      assert_equal exp, subquery.build_sql(params)
+    end
+
+  end
+
+  class AliasSubqueryTests < UnitTests
+    desc "AliasSubquery"
+    setup do
+      @subquery_class = Class.new{ include MR::ReadModel::AliasSubquery }
+    end
+    subject{ @subquery_class }
+
+    should "be a MR subquery" do
+      assert_includes MR::ReadModel::Subquery, subject
+    end
+
+  end
+
+  class AliasSubqueryInitTests < AliasSubqueryTests
+    desc "when init"
+    setup do
+      @subquery = @subquery_class.new(&@subquery_block)
+    end
+    subject{ @subquery }
+
+    should have_imeths :alias_sql, :as, :build_sql
+
+    should "know its default alias sql" do
+      assert_equal "", subject.alias_sql
+    end
+
+    should "allow changing its alias sql using `as`" do
+      alias_name = Factory.string
+      subject.as(alias_name)
+      assert_equal "AS #{alias_name}", subject.alias_sql
+    end
+
+    should "raise an argument error if passing a blank alias" do
+      assert_raises(ArgumentError){ subject.as(nil) }
+      assert_raises(ArgumentError){ subject.as('') }
+      assert_raises(ArgumentError){ subject.as(' ') }
+    end
+
+    should "build the subquery's SQL using `build_sql`" do
+      alias_name = Factory.string
+      subject.as(alias_name)
+      exp = "(#{subject.read_model_class.build_sql}) #{subject.alias_sql}"
+      assert_equal exp, subject.build_sql
+
+      subquery = @subquery_class.new(&@subquery_with_params_block)
+      subquery.as(alias_name)
+      params = { 'column' => Factory.string }
+      exp = "(#{subquery.read_model_class.build_sql(params)}) #{subquery.alias_sql}"
+      assert_equal exp, subquery.build_sql(params)
+    end
+
+    should "raise an invalid subquery error if an alias hasn't been set" do
+      assert_raises(InvalidSubqueryError){ subject.build_sql }
+    end
+
+  end
+
+  class FromSubqueryTests < UnitTests
+    desc "FromSubquery"
+    setup do
+      @subquery_class = MR::ReadModel::FromSubquery
+    end
+    subject{ @subquery_class }
+
+    should "be a MR alias subquery" do
+      assert_includes MR::ReadModel::AliasSubquery, subject
+    end
+
+  end
+
+  class FromSubqueryInitTests < FromSubqueryTests
+    desc "when init"
+    setup do
+      @subquery = @subquery_class.new(&@subquery_block)
+    end
+    subject{ @subquery }
+
+    should have_imeths :record_class
+
+    should "know its record class" do
+      assert_equal FakeTestRecord, subject.record_class
+
+      subquery_block = @subquery_block
+      subquery = @subquery_class.new do
+        read_model{ from_subquery(&subquery_block) }
+      end
+      assert_equal FakeTestRecord, subquery.record_class
+    end
+
+  end
+
+  class JoinSubqueryTests < UnitTests
+    desc "JoinSubquery"
+    setup do
+      @subquery_class = MR::ReadModel::JoinSubquery
+    end
+    subject{ @subquery_class }
+
+    should "be a MR alias subquery" do
+      assert_includes MR::ReadModel::AliasSubquery, subject
+    end
+
+    should "know its join sql constants" do
+      assert_equal 'JOIN', subject::DEFAULT_JOIN_SQL
+
+      exp = {
+        :inner => "INNER JOIN",
+        :left  => "LEFT OUTER JOIN",
+        :right => "RIGHT OUTER JOIN",
+        :full  => "FULL OUTER JOIN"
+      }
+      assert_equal exp, subject::JOIN_SQL
+      assert_equal subject::DEFAULT_JOIN_SQL, subject::JOIN_SQL[Factory.string]
+    end
+
+  end
+
+  class JoinSubqueryInitTests < JoinSubqueryTests
+    desc "when init"
+    setup do
+      @type = if Factory.boolean
+        @subquery_class::JOIN_SQL.keys.sample
+      else
+        Factory.string
+      end
+
+      @subquery = @subquery_class.new(@type, &@subquery_block)
+    end
+    subject{ @subquery }
+
+    should have_readers :join_sql
+    should have_imeths :conditions_sql, :on, :build_sql
+
+    should "know its join sql" do
+      assert_equal @subquery_class::JOIN_SQL[@type], subject.join_sql
+    end
+
+    should "know its default conditions sql" do
+      assert_equal "", subject.conditions_sql
+    end
+
+    should "allow changing its conditions sql using `on`" do
+      conditions = Factory.string
+      subject.on(conditions)
+      assert_equal "ON #{conditions}", subject.conditions_sql
+    end
+
+    should "build the subquery's SQL using `build_sql`" do
+      alias_name = Factory.string
+      subject.as(alias_name)
+      conditions = Factory.string
+      subject.on(conditions)
+      exp = "#{subject.join_sql} " \
+            "(#{subject.read_model_class.relation.build_for_all.to_sql}) " \
+            "#{subject.alias_sql} #{subject.conditions_sql}"
+      assert_equal exp, subject.build_sql
+
+      subquery = @subquery_class.new(@type, &@subquery_with_params_block)
+      subquery.as(alias_name)
+      subquery.on(conditions)
+      params = { 'column' => Factory.string }
+      exp = "#{subquery.join_sql} " \
+            "(#{subquery.read_model_class.build_sql(params)}) " \
+            "#{subquery.alias_sql} #{subquery.conditions_sql}"
+      assert_equal exp, subquery.build_sql(params)
+    end
+
+  end
+
+  class FakeTestRecord
+    include MR::FakeRecord
+
+    def self.scoped
+      Ardb::RelationSpy.new
+    end
+  end
+
+end

data/test/unit/read_model_tests.rb

@@ -0,0 +1,187 @@
+require 'assert'
+require 'mr/read_model'
+
+require 'much-plugin'
+require 'mr/read_model/data'
+require 'mr/read_model/fields'
+require 'mr/read_model/querying'
+
+module MR::ReadModel
+
+  class UnitTests < Assert::Context
+    desc "MR::ReadModel"
+    setup do
+      @read_model_class = Class.new do
+        include MR::ReadModel
+      end
+    end
+    subject{ MR::ReadModel }
+
+    should have_imeths :add_select_for_field
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, MR::ReadModel
+    end
+
+    should "know how to add a select for a field with column SQL" do
+      field_name = Factory.string
+      column_sql = Factory.string
+      MR::ReadModel.add_select_for_field(@read_model_class, field_name, column_sql)
+
+      assert_equal 1, @read_model_class.relation.query_expressions.size
+      expression = @read_model_class.relation.query_expressions.first
+      assert_equal :select, expression.type
+      exp = "#{column_sql} AS #{field_name}"
+      assert_equal exp, expression.args.first
+    end
+
+    should "know how to add a select for a field with a column SQL block" do
+      field_name = Factory.string
+      MR::ReadModel.add_select_for_field(@read_model_class, field_name){ |sql| sql }
+
+      assert_equal 1, @read_model_class.relation.query_expressions.size
+      expression = @read_model_class.relation.query_expressions.first
+      assert_equal :select, expression.type
+
+      column_sql = Factory.string
+      exp = "#{column_sql} AS #{field_name}"
+      assert_equal exp, expression.block.call(column_sql)
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    desc "mixed in"
+    setup do
+      @struct_class = Class.new{ include MR::ReadModelStruct }
+
+      @add_select_for_field_called_with = nil
+      Assert.stub(MR::ReadModel, :add_select_for_field) do |*args, &block|
+        @add_select_for_field_called_with = args + [block]
+        Assert.stub_send(MR::ReadModel, :add_select_for_field, *args, &block)
+      end
+    end
+    subject{ @read_model_class }
+
+    should have_imeths :field, :json_struct_list, :json_struct_obj
+
+    should "use the mr read model struct mixin" do
+      assert_includes MR::ReadModelStruct, subject
+    end
+
+    should "use the mr read model querying mixin" do
+      assert_includes MR::ReadModel::Querying, subject
+    end
+
+    should "know how to add fields with a select" do
+      field_name       = Factory.string
+      column_sql       = Factory.string
+      column_sql_block = proc{ |sql| sql }
+      subject.field(field_name, :string, column_sql, &column_sql_block)
+
+      field = subject.fields.find(field_name)
+      assert_instance_of MR::ReadModel::Field, field
+      assert_equal :string, field.type
+      assert_respond_to field.name, subject.new
+
+      exp = [subject, field_name, column_sql, column_sql_block]
+      assert_equal exp, @add_select_for_field_called_with
+    end
+
+    should "know how to add json struct lists with a select" do
+      field_name       = Factory.string
+      column_sql       = Factory.string
+      column_sql_block = proc{ |sql| sql }
+      subject.json_struct_list(field_name, @struct_class, column_sql, &column_sql_block)
+
+      field = subject.json_struct_lists.find{ |f| f.name == field_name }
+      assert_instance_of MR::ReadModel::JsonStructListField, field
+      assert_equal @struct_class, field.struct_class
+      assert_respond_to field.name, subject.new
+
+      exp = [subject, field_name, column_sql, column_sql_block]
+      assert_equal exp, @add_select_for_field_called_with
+    end
+
+    should "know how to add json struct objs with a select" do
+      field_name       = Factory.string
+      column_sql       = Factory.string
+      column_sql_block = proc{ |sql| sql }
+      subject.json_struct_obj(field_name, @struct_class, column_sql, &column_sql_block)
+
+      field = subject.json_struct_objs.find{ |f| f.name == field_name }
+      assert_instance_of MR::ReadModel::JsonStructObjField, field
+      assert_equal @struct_class, field.struct_class
+      assert_respond_to field.name, subject.new
+
+      exp = [subject, field_name, column_sql, column_sql_block]
+      assert_equal exp, @add_select_for_field_called_with
+    end
+
+  end
+
+  class ReadModelStructTests < Assert::Context
+    desc "MR::ReadModelStruct"
+    setup do
+      @read_model_struct_class = Class.new do
+        include MR::ReadModelStruct
+      end
+    end
+    subject{ @read_model_struct_class }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, MR::ReadModelStruct
+    end
+
+    should "use the mr read model data mixin" do
+      assert_includes MR::ReadModel::Data, subject
+    end
+
+    should "use the mr read model fields mixin" do
+      assert_includes MR::ReadModel::Fields, subject
+    end
+
+  end
+
+  class ReadModelStructInitTests < ReadModelStructTests
+    desc "when init"
+    setup do
+      @read_model_struct_class.class_eval do
+        field :name, :string
+      end
+
+      @data       = { 'name' => Factory.string }
+      @read_model = @read_model_struct_class.new(@data)
+    end
+    subject{ @read_model }
+
+    should "set its data" do
+      assert_equal @data['name'], subject.name
+    end
+
+    should "not error when initialized without data" do
+      read_model_struct = @read_model_struct_class.new
+      assert_nil read_model_struct.name
+    end
+
+    should "be comparable" do
+      matching_struct = @read_model_struct_class.new(@data)
+      assert_equal matching_struct, subject
+
+      data = Factory.boolean ? { 'name' => Factory.string } : {}
+      not_matching_struct = @read_model_struct_class.new(data)
+      assert_not_equal not_matching_struct, subject
+    end
+
+    should "know its inspect" do
+      object_hex     = (subject.object_id << 1).to_s(16)
+      values_inspect = @read_model_struct_class.fields.map do |field|
+        "#{field.ivar_name}=#{field.read(@data).inspect}"
+      end.join(' ')
+      exp = "#<#{@read_model_struct_class}:0x#{object_hex} #{values_inspect}>"
+      assert_equal exp, subject.inspect
+    end
+
+  end
+
+end