mr 0.35.2

data/test/unit/fake_record_tests.rb

@@ -0,0 +1,106 @@
+require 'assert'
+require 'mr/fake_record'
+
+require 'much-plugin'
+
+module MR::FakeRecord
+
+  class UnitTests < Assert::Context
+    desc "MR::FakeRecord"
+    setup do
+      @module = MR::FakeRecord
+    end
+    subject{ @module }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+    should "extend the persistence transaction methods mixin" do
+      metaclass = class << subject; self; end
+      assert_includes MR::FakeRecord::Persistence::TransactionMethods, metaclass
+    end
+
+  end
+
+  class MixedInTests < UnitTests
+    desc "when mixed in"
+    setup do
+      @fake_record_class = Class.new do
+        include MR::FakeRecord
+        attribute :name,   :string
+        attribute :active, :boolean
+      end
+    end
+    subject{ @fake_record_class }
+
+    should have_imeths :model_class
+
+    should "be an MR record" do
+      assert_includes MR::Record, subject
+    end
+
+    should "include the associations, attributes and persistence mixins" do
+      assert_includes MR::FakeRecord::Associations, subject
+      assert_includes MR::FakeRecord::Attributes,   subject
+      assert_includes MR::FakeRecord::Persistence,  subject
+    end
+
+    should "allow reading and writing it's model class using `model_class`" do
+      assert_nil subject.model_class
+      model_class = Class.new
+      subject.model_class(model_class)
+      assert_equal model_class, subject.model_class
+    end
+
+    should "allow passing attributes to it's initialize" do
+      fake_record = subject.new(:name => 'test')
+      assert_equal 'test', fake_record.name
+    end
+
+  end
+
+  class InitTests < MixedInTests
+    desc "and init"
+    setup do
+      @fake_record = @fake_record_class.new({
+        :name   => 'test',
+        :active => true
+      })
+      @fake_record.save!
+    end
+    subject{ @fake_record }
+
+    should have_imeths :==, :eql?, :hash, :inspect
+
+    should "return a readable inspect" do
+      object_hex = (subject.object_id << 1).to_s(16)
+      expected = "#<#{subject.class}:0x#{object_hex} @active=true " \
+                 "@id=#{subject.id} @name=\"test\">"
+      assert_equal expected, subject.inspect
+    end
+
+    should "be comparable" do
+      same_fake_record  = @fake_record_class.new(:id => @fake_record.id)
+      assert_equal same_fake_record, subject
+      other_fake_record = @fake_record_class.new.tap(&:save!)
+      assert_not_equal other_fake_record, subject
+    end
+
+    should "demeter its fixnum hash value to its id" do
+      assert_equal subject.id.hash, subject.hash
+    end
+
+    should "ensure it's attribute changed methods work after an empty save" do
+      assert_not_nil subject.name
+      assert_true subject.active
+      subject.save! # empty save, nothing was changed
+      subject.name = nil # set a previously set attribute to `nil`
+      subject.active = true # set it to what it previous was
+      assert subject.name_changed?
+      assert_not subject.active_changed?
+    end
+
+  end
+
+end

data/test/unit/json_field/fake_record_tests.rb

@@ -0,0 +1,75 @@
+ require 'assert'
+require 'mr/json_field/fake_record'
+
+require 'much-plugin'
+require 'mr/json_field'
+require 'mr/model'
+
+module MR::JsonField::FakeRecord
+
+  class UnitTests < Assert::Context
+    desc "MR::JsonField::FakeRecord"
+    subject{ MR::JsonField::FakeRecord }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    desc "when mixed in"
+    setup do
+      @fake_record_class = Class.new do
+        include MR::JsonField::FakeRecord
+        attribute :hash_data_json,  :text
+        attribute :array_data_json, :text
+      end
+    end
+    subject{ @fake_record_class }
+
+  end
+
+  class InitTests < MixinTests
+    desc "and init"
+    setup do
+      @model_class = Class.new do
+        include MR::Model
+        field_accessor :hash_data_json, :array_data_json
+
+        include MR::JsonField
+        json_field :hash_data
+        json_field :array_data
+      end
+      @fake_record_class.model_class(@model_class)
+
+      @fake_record = @fake_record_class.new
+      @model       = @fake_record.model
+    end
+    subject{ @fake_record }
+
+    should "sync all of its json fields on save" do
+      @model.hash_data  = { Factory.string => Factory.string }
+      @model.array_data = Factory.integer(3).times.map{ Factory.string }
+
+      # since we used the writer the fields and their source should be equal
+      assert_equal @model.hash_data,  MR::JsonField.decode(subject.hash_data_json)
+      assert_equal @model.array_data, MR::JsonField.decode(subject.array_data_json)
+
+      @model.hash_data[Factory.string] = Factory.string
+      @model.array_data << Factory.string
+      # since we modified the fields and didn't use the writer, their source
+      # should not be equal
+      assert_not_equal @model.hash_data,  MR::JsonField.decode(subject.hash_data_json)
+      assert_not_equal @model.array_data, MR::JsonField.decode(subject.array_data_json)
+
+      subject.save!
+
+      # now that the callback has been run they should be equal once again
+      assert_equal @model.hash_data,  MR::JsonField.decode(subject.hash_data_json)
+      assert_equal @model.array_data, MR::JsonField.decode(subject.array_data_json)
+    end
+
+  end
+
+end

data/test/unit/json_field/record_tests.rb

@@ -0,0 +1,80 @@
+require 'assert'
+require 'mr/json_field/record'
+
+require 'ardb/record_spy'
+require 'much-plugin'
+require 'mr/json_field'
+require 'mr/model'
+
+module MR::JsonField::Record
+
+  class UnitTests < Assert::Context
+    desc "MR::JsonField::Record"
+    subject{ MR::JsonField::Record }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    desc "when mixed in"
+    setup do
+      @record_class = Ardb::RecordSpy.new do
+        include MR::JsonField::Record
+        attr_accessor :hash_data_json, :array_data_json
+      end
+    end
+    subject{ @record_class }
+
+    should "add a before save callback" do
+      callback = subject.callbacks.find{ |c| c.type == :before_save }
+      assert_equal :json_field_sync_all_json_fields_on_save, callback.args.first
+    end
+
+  end
+
+  class InitTests < MixinTests
+    desc "and init"
+    setup do
+      @model_class = Class.new do
+        include MR::Model
+        field_accessor :hash_data_json, :array_data_json
+
+        include MR::JsonField
+        json_field :hash_data
+        json_field :array_data
+      end
+      @record_class.model_class = @model_class
+
+      @record = @record_class.new
+      @model  = @record.model
+    end
+    subject{ @record }
+
+    should "sync all of its json fields on save" do
+      @model.hash_data  = { Factory.string => Factory.string }
+      @model.array_data = Factory.integer(3).times.map{ Factory.string }
+
+      # since we used the writer the fields and their source should be equal
+      assert_equal @model.hash_data,  MR::JsonField.decode(subject.hash_data_json)
+      assert_equal @model.array_data, MR::JsonField.decode(subject.array_data_json)
+
+      @model.hash_data[Factory.string] = Factory.string
+      @model.array_data << Factory.string
+      # since we modified the fields and didn't use the writer, their source
+      # should not be equal
+      assert_not_equal @model.hash_data,  MR::JsonField.decode(subject.hash_data_json)
+      assert_not_equal @model.array_data, MR::JsonField.decode(subject.array_data_json)
+
+      subject.instance_eval{ json_field_sync_all_json_fields_on_save }
+
+      # now that the callback has been run they should be equal once again
+      assert_equal @model.hash_data,  MR::JsonField.decode(subject.hash_data_json)
+      assert_equal @model.array_data, MR::JsonField.decode(subject.array_data_json)
+    end
+
+  end
+
+end

data/test/unit/json_field_tests.rb

@@ -0,0 +1,302 @@
+require 'assert'
+require 'mr/json_field'
+
+require 'much-plugin'
+
+module MR::JsonField
+
+  class UnitTests < Assert::Context
+    desc "MR::JsonField"
+    setup do
+      @module = MR::JsonField
+
+      @orig_encoder = @module.encoder
+      @orig_decoder = @module.decoder
+    end
+    teardown do
+      @module.encoder = @orig_encoder
+      @module.decoder = @orig_decoder
+    end
+    subject{ @module }
+
+    should have_imeths :encoder, :encoder=
+    should have_imeths :decoder, :decoder=
+    should have_imeths :encode, :decode
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+    should "know its default encoder and decoder" do
+      value = { Factory.string => Factory.string }
+
+      exp = JSON.dump(value)
+      assert_equal exp, DEFAULT_ENCODER.call(value)
+
+      encoded_value = exp
+      exp = JSON.load(encoded_value)
+      assert_equal exp, DEFAULT_DECODER.call(encoded_value)
+    end
+
+    should "default its encoder and decoder" do
+      assert_equal DEFAULT_ENCODER, subject.encoder
+      assert_equal DEFAULT_DECODER, subject.decoder
+    end
+
+    should "use its encoder/decoder when encoding/decoding" do
+      value = { Factory.string => Factory.string }
+
+      exp = subject.encoder.call(value)
+      assert_equal exp, subject.encode(value)
+
+      encoded_value = exp
+      exp = subject.decoder.call(encoded_value)
+      assert_equal exp, subject.decode(encoded_value)
+    end
+
+    should "allow specifying a custom encoder/decoder" do
+      subject.encoder = proc{ |v| v.to_s }
+      subject.decoder = proc{ |v| v.to_i }
+
+      value = Factory.integer
+      assert_equal value.to_s, subject.encode(value)
+
+      value = Factory.integer.to_s
+      assert_equal value.to_i, subject.decode(value)
+    end
+
+  end
+
+  class MixedInSetupTests < UnitTests
+    setup do
+      @json_field_class = Class.new do
+        include MR::JsonField
+        attr_accessor :test_data_json, :custom_data_source
+      end
+    end
+
+  end
+
+  class MixedInTests < MixedInSetupTests
+    desc "when mixed in"
+    subject{ @json_field_class }
+
+    should have_imeths :json_field, :json_field_reader, :json_field_writer
+    should have_imeths :json_field_readers, :json_field_writers
+    should have_imeths :json_field_accessors, :json_field_source_fields
+
+    should "not have any json field accessors or source fields by default" do
+      assert_equal [], subject.json_field_readers
+      assert_equal [], subject.json_field_writers
+      assert_equal [], subject.json_field_accessors
+      assert_equal [], subject.json_field_source_fields
+    end
+
+    should "allow adding a json field reader" do
+      subject.json_field_reader 'test_data'
+      instance = subject.new
+
+      assert_respond_to 'test_data', instance
+      assert_equal ['test_data'],      subject.json_field_readers
+      assert_equal ['test_data_json'], subject.json_field_source_fields
+      assert_equal [], subject.json_field_writers
+      assert_equal [], subject.json_field_accessors
+    end
+
+    should "allow adding a json field reader with a custom source" do
+      subject.json_field_reader 'custom_data', :source => 'custom_data_source'
+      instance = subject.new
+
+      assert_respond_to 'custom_data', instance
+      assert_equal ['custom_data'],        subject.json_field_readers
+      assert_equal ['custom_data_source'], subject.json_field_source_fields
+      assert_equal [], subject.json_field_writers
+      assert_equal [], subject.json_field_accessors
+    end
+
+    should "allow adding a json field writer" do
+      subject.json_field_writer 'test_data'
+      instance = subject.new
+
+      assert_respond_to 'test_data=', instance
+      assert_equal ['test_data'],      subject.json_field_writers
+      assert_equal ['test_data_json'], subject.json_field_source_fields
+      assert_equal [], subject.json_field_readers
+      assert_equal [], subject.json_field_accessors
+    end
+
+    should "allow adding a json field writer with a custom source" do
+      subject.json_field_writer 'custom_data', :source => 'custom_data_source'
+      instance = subject.new
+
+      assert_respond_to 'custom_data=', instance
+      assert_equal ['custom_data'],        subject.json_field_writers
+      assert_equal ['custom_data_source'], subject.json_field_source_fields
+      assert_equal [], subject.json_field_readers
+      assert_equal [], subject.json_field_accessors
+    end
+
+    should "allow adding a json field accessor" do
+      subject.json_field 'test_data'
+      instance = subject.new
+
+      assert_respond_to 'test_data',  instance
+      assert_respond_to 'test_data=', instance
+      exp = ['test_data']
+      assert_equal exp, subject.json_field_readers
+      assert_equal exp, subject.json_field_writers
+      assert_equal exp, subject.json_field_accessors
+      assert_equal ['test_data_json'], subject.json_field_source_fields
+    end
+
+    should "allow adding a json field accessor with a custom source" do
+      subject.json_field 'custom_data', :source => 'custom_data_source'
+      instance = subject.new
+
+      assert_respond_to 'custom_data',  instance
+      assert_respond_to 'custom_data=', instance
+      exp = ['custom_data']
+      assert_equal exp, subject.json_field_readers
+      assert_equal exp, subject.json_field_writers
+      assert_equal exp, subject.json_field_accessors
+      assert_equal ['custom_data_source'], subject.json_field_source_fields
+    end
+
+    should "know it has an accessor if a reader and writer are added separately" do
+      subject.json_field_reader 'test_data'
+      subject.json_field_writer 'test_data'
+      instance = subject.new
+
+      assert_equal ['test_data'],      subject.json_field_accessors
+      assert_equal ['test_data_json'], subject.json_field_source_fields
+    end
+
+    should "allow using symbols when adding json fields" do
+      subject.json_field :test_data
+      subject.json_field_reader :custom_data, :source => :custom_data_source
+      subject.json_field_writer :custom_data, :source => :custom_data_source
+      instance = subject.new
+
+      assert_respond_to :test_data,    instance
+      assert_respond_to :test_data=,   instance
+      assert_respond_to :custom_data,  instance
+      assert_respond_to :custom_data=, instance
+      exp = ['test_data', 'custom_data']
+      assert_equal exp, subject.json_field_readers
+      assert_equal exp, subject.json_field_writers
+      assert_equal exp, subject.json_field_accessors
+      exp = ['test_data_json', 'custom_data_source']
+      assert_equal exp, subject.json_field_source_fields
+    end
+
+    should "error if the source matches the field name" do
+      name = Factory.string
+      assert_raises(ArgumentError) do
+        subject.json_field_reader(name, :source => name)
+      end
+      assert_raises(ArgumentError) do
+        subject.json_field_writer(name, :source => name)
+      end
+      assert_raises(ArgumentError) do
+        subject.json_field(name, :source => name)
+      end
+    end
+
+  end
+
+  class InitTests < MixedInTests
+    desc "and init"
+    setup do
+      @value = [
+        Factory.string,
+        Factory.integer,
+        Factory.boolean,
+        Factory.integer(3).times{ Factory.integer },
+        { Factory.string => Factory.string }
+      ].sample
+
+      @json_field_class.json_field :test_data
+      @json_field_class.json_field :custom_data, :source => :custom_data_source
+
+      @instance = @json_field_class.new
+    end
+    subject{ @instance }
+
+    should "allow reading/writing json fields" do
+      assert_nil subject.test_data
+      assert_nil subject.test_data_json
+      assert_nil subject.custom_data
+      assert_nil subject.custom_data_source
+
+      subject.test_data   = @value
+      subject.custom_data = @value
+
+      exp = MR::JsonField.encode(@value)
+      assert_equal exp, subject.test_data_json
+      assert_equal exp, subject.custom_data_source
+      assert_equal @value, subject.test_data
+      assert_equal @value, subject.custom_data
+    end
+
+    should "cache read/written values" do
+      subject.test_data   = @value
+      subject.custom_data = @value
+
+      result = subject.test_data
+      assert_same result, subject.test_data
+      result = subject.custom_data
+      assert_same result, subject.custom_data
+    end
+
+    should "allow reading/writing `nil` values" do
+      subject.test_data   = @value
+      subject.custom_data = @value
+
+      assert_nothing_raised{ subject.test_data = nil }
+      assert_nil subject.test_data
+      assert_nothing_raised{ subject.custom_data = nil }
+      assert_nil subject.custom_data
+    end
+
+    should "raise an invalid json error when reading invalid JSON" do
+      subject.test_data_json     = Factory.string
+      subject.custom_data_source = Factory.string
+
+      assert_raises(InvalidJSONError){ subject.test_data }
+      assert_raises(InvalidJSONError){ subject.custom_data }
+    end
+
+    should "raise an invalid json error when writing invalid JSON" do
+      Assert.stub(MR::JsonField.encoder, :call){ raise RuntimeError }
+
+      assert_raises(InvalidJSONError){ subject.test_data   = Factory.string }
+      assert_raises(InvalidJSONError){ subject.custom_data = Factory.string }
+    end
+
+  end
+
+  class TestHelpersTests < MixedInSetupTests
+    include MR::JsonField::TestHelpers
+
+    desc "TestHelpers"
+    setup do
+      @json_field_class.json_field :test_data
+      @json_field_class.json_field :custom_data, :source => :custom_data_source
+
+      @instance = @json_field_class.new
+    end
+    subject{ @instance }
+
+    should "provide helpers for testing that a class has json fields" do
+      assert_json_field subject, :test_data
+      assert_json_field_reader subject, :test_data
+      assert_json_field_writer subject, :test_data
+
+      assert_json_field subject, :custom_data, :source => :custom_data_source
+      assert_json_field_reader subject, :custom_data, :source => :custom_data_source
+      assert_json_field_writer subject, :custom_data, :source => :custom_data_source
+    end
+
+  end
+
+end