mark_mapper 0.0.1

data/spec/unit/inspect_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Inspect" do
+  context "#inspect" do
+    before do
+      @document = Doc('User') do
+        key :name,  String
+        key :age,   Integer
+        key :email, String
+      end
+
+      @doc = @document.new(:name => 'John', :age => 29)
+    end
+
+    it "should print out non-nil attributes in alpha sorted order" do
+      @doc.inspect.should =~ /_id:.*, age: 29, name: "John"/
+    end
+
+    it "should print out all attributes when (optional) include_super argument is true" do
+      @doc.inspect(true).should =~ /_id:.*, age: 29, email: nil, name: "John"/
+    end
+
+    it "should include class name" do
+      @doc.inspect.should =~ /^#<User/
+    end
+
+    it "should include embedded documents" do
+      klass = Doc()
+      pets = EDoc()
+
+      klass.many :pets, :class => pets
+
+      doc = klass.new(:pets => [{:name => "Kitten"}])
+      doc.inspect.should =~ /_id:.*, pets: \[.*_id.*, name: "Kitten".*\]/
+    end
+
+    it "should include embedded document" do
+      klass = Doc()
+      pet = EDoc()
+
+      klass.one :pet, :class => pet
+
+      doc = klass.new(:pet => {:name => "Kitten"})
+      doc.inspect.should =~ /_id:.*, pet: .*_id.*, name: "Kitten".*/
+    end
+  end
+end

data/spec/unit/key_spec.rb

@@ -0,0 +1,276 @@
+require 'spec_helper'
+
+
+class FooType < Struct.new(:bar)
+  def self.to_marklogic(value)
+    'to_marklogic'
+  end
+
+  def self.from_marklogic(value)
+    'from_marklogic'
+  end
+end
+
+describe "Key" do
+  Key = MarkMapper::Plugins::Keys::Key
+
+  context "Initializing a new key" do
+    it "should allow setting the name" do
+      Key.new(:foo, String).name.should == 'foo'
+    end
+
+    it "should allow setting the type" do
+      Key.new(:foo, Integer).type.should be(Integer)
+    end
+
+    it "should allow setting options" do
+      Key.new(:foo, Integer, :required => true).options[:required].should be(true)
+    end
+
+    it "should default options to {}" do
+      Key.new(:foo, Integer, nil).options.should == {}
+    end
+
+    it "should symbolize option keys" do
+      Key.new(:foo, Integer, 'required' => true).options[:required].should be(true)
+    end
+
+    it "should work with just name" do
+      key = Key.new(:foo)
+      key.name.should == 'foo'
+    end
+
+    it "should work with name and type" do
+      key = Key.new(:foo, String)
+      key.name.should == 'foo'
+      key.type.should == String
+    end
+
+    it "should work with name, type, and options" do
+      key = Key.new(:foo, String, :required => true)
+      key.name.should == 'foo'
+      key.type.should == String
+      key.options[:required].should be_truthy
+    end
+
+    it "should work with name and options" do
+      key = Key.new(:foo, :required => true)
+      key.name.should == 'foo'
+      key.options[:required].should be_truthy
+    end
+
+    it "should not permit reserved names" do
+      expect { Key.new(:id) }.to raise_error(/reserved/)
+    end
+
+    it "should not permit bad names" do
+      expect { Key.new(:"id.bar") }.to raise_error(/must match/)
+    end
+
+    it "should permit bad names if __dynamic" do
+      expect { Key.new(:"id.bar", :__dynamic => true) }.to_not raise_error
+    end
+
+    it "should permit bad names if it is not to create accessors" do
+      expect { Key.new(:"id.bar", :accessors => :skip) }.to_not raise_error
+    end
+  end
+
+  context "A key" do
+    it "should be equal to another key with same name and type" do
+      Key.new(:name, String).should == Key.new(:name, String)
+    end
+
+    it "should not be equal to another key with different name" do
+      Key.new(:name, String).should_not == Key.new(:foo, String)
+    end
+
+    it "should not be equal to another key with different type" do
+      Key.new(:name, String).should_not == Key.new(:name, Integer)
+    end
+
+    it "should know if it is a embedded_document" do
+      Key.new(:name, EDoc()).embeddable?.should be_truthy
+    end
+
+    it "should know if it is not a embedded_document" do
+      Key.new(:name, String).embeddable?.should be_falsey
+    end
+
+    it "should know if it is a number" do
+      Key.new(:age, Integer).number?.should be_truthy
+      Key.new(:age, Float).number?.should be_truthy
+    end
+
+    it "should know if it is not a number" do
+      Key.new(:age, String).number?.should be_falsey
+    end
+  end
+
+  context "for an array with :typecast option" do
+    before  { @key = Key.new(:user_ids, Array, :typecast => 'ObjectId') }
+    subject { @key }
+
+    it "should cast each element correctly" do
+      ids = [MarkLogic::ObjectId.new, MarkLogic::ObjectId.new, MarkLogic::ObjectId.new.to_s, MarkLogic::ObjectId.new.to_s]
+      subject.set(ids).should == ids.map { |id| ObjectId.to_marklogic(id) }
+    end
+  end
+
+  context "for an array with :typecast option of Date" do
+    before  { @key = Key.new(:dates, Array, :typecast => 'Date') }
+    subject { @key }
+
+    it "should cast each element correctly when get" do
+      dates = [Date.yesterday, Date.today, Date.tomorrow.to_s]
+      subject.get(dates).should == dates.map { |date| Date.from_marklogic(date) }
+    end
+
+    it "should cast each element correctly when set" do
+      dates = [Date.yesterday, Date.today, Date.tomorrow.to_s]
+      subject.set(dates).should == dates.map { |date| Date.to_marklogic(date) }
+    end
+  end
+
+  context "for a set with :typecast option" do
+    before  { @key = Key.new(:user_ids, Set, :typecast => 'ObjectId') }
+    subject { @key }
+
+    it "should cast each element correctly" do
+      ids = [MarkLogic::ObjectId.new, MarkLogic::ObjectId.new, MarkLogic::ObjectId.new.to_s, MarkLogic::ObjectId.new.to_s]
+      subject.set(ids).should == ids.map { |id| ObjectId.to_marklogic(id) }
+    end
+  end
+
+  context "with the :attributes option" do
+    subject { @key }
+    before { @key = Key.new(:test, String, :accessors => accessor) }
+
+    context "with :read" do
+      let(:accessor) { :read }
+
+      it { expect( subject.read_accessor? ).to be_truthy }
+      it { expect( subject.write_accessor? ).to be_falsey }
+      it { expect( subject.predicate_accessor? ).to be_falsey }
+    end
+
+    context "with :write" do
+      let(:accessor) { :write }
+
+      it { expect( subject.read_accessor? ).to be_falsey }
+      it { expect( subject.write_accessor? ).to be_truthy }
+      it { expect( subject.predicate_accessor? ).to be_falsey }
+    end
+
+    context "with :predicate" do
+      let(:accessor) { :predicate }
+
+      it { expect( subject.read_accessor? ).to be_falsey }
+      it { expect( subject.write_accessor? ).to be_falsey }
+      it { expect( subject.predicate_accessor? ).to be_truthy }
+    end
+
+    context "with an array of options" do
+      let(:accessor) { [:read, :write] }
+
+      it { expect( subject.read_accessor? ).to be_truthy }
+      it { expect( subject.write_accessor? ).to be_truthy }
+      it { expect( subject.predicate_accessor? ).to be_falsey }
+    end
+  end
+
+  context "setting a value with a custom type" do
+    it "should correctly typecast" do
+      key = Key.new(:foo, FooType)
+      key.set("something").should == 'to_marklogic'
+    end
+
+    it "should correctly typecast if object of that type is given" do
+      key = Key.new(:foo, FooType)
+      key.set(FooType.new('something')).should == 'to_marklogic'
+    end
+  end
+
+  context "getting a value with a custom type" do
+    it "should use #from_marklogic to convert back to custom type" do
+      key = Key.new(:foo, FooType)
+      key.get('something').should == 'from_marklogic'
+    end
+  end
+
+  context "getting a value" do
+    it "should work with a type" do
+      key = Key.new(:foo, String)
+      key.get('bar').should == 'bar'
+    end
+
+    it "should work without type" do
+      key = Key.new(:foo)
+      key.get([1, '2']).should == [1, '2']
+      key.get(false).should == false
+      key.get({}).should == {}
+    end
+
+    context "for a embedded_document" do
+      it "should default to nil" do
+        key = Key.new(:foo, Address)
+        key.get(nil).should be_nil
+      end
+
+      it "should return instance if instance" do
+        address = Address.new(:city => 'South Bend', :state => 'IN', :zip => 46544)
+        key = Key.new(:foo, Address)
+        key.get(address).should == address
+      end
+    end
+  end
+
+  context "with a default set" do
+    before do
+      @key = Key.new(:foo, String, :default => 'baz')
+    end
+
+    context "#get" do
+      it "should return nil" do
+        @key.get(nil).should == nil
+      end
+
+      it "should return value if not blank" do
+        @key.get('foobar').should == 'foobar'
+      end
+
+      it "should return default value if name is _id and value nil" do
+        id = MarkLogic::ObjectId.new
+        key = Key.new(:_id, ObjectId, :default => lambda { id })
+        key.get(nil).should == id
+      end
+    end
+
+    context "#default_value" do
+      it "should return default value" do
+        @key.default_value.should == 'baz'
+      end
+
+      it "should return a dup of the default value" do
+        @key.default_value.replace('bar')
+        @key.default_value.should == 'baz'
+      end
+
+      it "should work with Boolean type and false value" do
+        Key.new(:active, Boolean, :default => false).default_value.should be_falsey
+      end
+
+      it "should work with Boolean type and true value" do
+        Key.new(:active, Boolean, :default => true).default_value.should be_truthy
+      end
+
+      it "should work with Array values" do
+        Key.new(:active, Array, :default => []).default_value.should == []
+      end
+
+      it "should work with procs" do
+         Key.new(:foo, String, :default => lambda { return 'hello world' }).default_value.should == "hello world"
+      end
+    end
+  end
+end # KeyTest

data/spec/unit/keys_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+
+describe "Key" do
+  context ".new with no id and _id of type integer" do
+    it "should not error" do
+      lambda {
+        klass = Doc() do
+          key :_id, Integer
+        end
+        # No sensible default id for integer, people better pass them in if they user this
+        silence_stderr { klass.new.id.should be_nil }
+      }.should_not raise_error
+    end
+  end
+
+  context ".key?(:symbol)" do
+    it "should be true if document has key" do
+      Address.key?(:city).should be_truthy
+    end
+
+    it "should be false if document does not have key" do
+      Address.key?(:foo).should be_falsey
+    end
+  end
+
+  context "#assign" do
+    it "should raise a deprecation warning" do
+      klass = Doc() do
+        key :_id, Integer
+      end
+      doc = klass.new
+      expect(doc).to receive(:warn).once
+      doc.assign({:x => :y})
+    end
+  end
+
+  # TODO: Are these methods deprecated?
+  context "#embedded and #non_embedded_keys" do
+    EmbeddableThingie = EDoc {
+      key :whiz, String
+    }
+
+    let(:klass) do
+      Doc do
+        key :foo, String
+        key :embeddable_thingie, EmbeddableThingie
+      end
+    end
+
+    it "should get non-embeddable keys" do
+      klass.new.non_embedded_keys.map(&:name).should =~ %w(_id foo)
+    end
+
+    it "should get embeddable keys" do
+      klass.new.embedded_keys.map(&:name).should == %w(embeddable_thingie)
+    end
+  end
+
+  context ".key?('string')" do
+    it "should be true if document has key" do
+      Address.key?('city').should be_truthy
+    end
+
+    it "should be false if document does not have key" do
+      Address.key?('foo').should be_falsey
+    end
+  end
+
+  context ".new (from database)" do
+    before do
+      @klass = Doc do
+        key :user, Hash
+
+        def user=(user)
+          super(:id => user.id, :name => user.name)
+        end
+      end
+
+      user_class = Struct.new(:id, :name)
+      @klass.create(:user => user_class.new(1, 'John Nunemaker'))
+    end
+
+    it "should use []= for keys instead of public writer" do
+      expect {
+        doc = @klass.first
+        doc.user['id'].should   == 1
+        doc.user['name'].should == 'John Nunemaker'
+      }.to_not raise_error
+    end
+  end
+
+  context ".load" do
+    it "should return nil if argument is nil" do
+      Doc().load(nil).should be_nil
+    end
+  end
+
+  context "default values" do
+    before do
+      @klass = Doc do
+        key :value, Integer, :default => 1
+      end
+    end
+
+    it "should initialize default value" do
+      @klass.new.value.should == 1
+    end
+
+    it "should allow overriding default value" do
+      @klass.new(:value => 2).value.should == 2
+    end
+
+    it "should allow re-setting a value that is defaulted" do
+      instance = @klass.new
+      instance.value = 2
+      instance.value.should == 2
+      instance.value = nil
+      instance.value.should == nil
+    end
+
+    context "for _id" do
+      before do
+        @klass.class_eval do
+          key :_id, Integer, :default => lambda { 12345 }
+        end
+      end
+
+      it "should work" do
+        @klass.new._id.should == 12345
+      end
+    end
+  end
+
+  context "when loading from the database" do
+    it "should not set default values for keys that already exist" do
+      counter = 0
+      instance = nil
+
+      klass = Doc do
+        key :value, Integer, :default => lambda { counter += 1 }
+      end
+
+      expect { instance = klass.create }.to change { counter }.by(1)
+      expect {
+        instance.reload.value.should == 1
+
+        instance.value = 10
+        instance.save
+
+        instance.reload.value.should == 10
+      }.to_not change { counter }
+    end
+  end
+end # KeyTest