populate-me 0.12.0

data/test/test_document_schema.rb

@@ -0,0 +1,280 @@
+require 'helper'
+require 'populate_me/document'
+
+describe PopulateMe::Document, 'Schema' do
+
+  parallelize_me!
+
+  describe "Relationships" do
+
+    class Relative < PopulateMe::Document
+      relationship :siblings
+      relationship :home_remedies
+      relationship :friends, label: 'Budies', class_name: 'Budy', foreign_key: :budy_id, dependent: false
+    end
+
+    class Relative::Sibling < PopulateMe::Document
+      field :size
+      field :relative_id, type: :parent
+    end
+
+    before do
+      Relative.documents = []
+      Relative::Sibling.documents = []
+    end
+
+    it "Defaults class name" do
+      assert_equal "Relative::Sibling", Relative.relationships[:siblings][:class_name]
+      assert_equal "Relative::HomeRemedy", Relative.relationships[:home_remedies][:class_name]
+    end
+
+    it "Defaults label" do
+      assert_equal "Siblings", Relative.relationships[:siblings][:label]
+      assert_equal "Home remedies", Relative.relationships[:home_remedies][:label]
+    end
+
+    it "Defaults foreign key" do
+      assert_equal :relative_id, Relative.relationships[:siblings][:foreign_key]
+      assert_equal :relative_id, Relative.relationships[:home_remedies][:foreign_key]
+    end
+
+    it "Defaults :dependent to true" do
+      assert Relative.relationships[:siblings][:dependent]
+    end
+
+    it "Has everything editable" do
+      assert_equal "Budies", Relative.relationships[:friends][:label]
+      assert_equal "Budy", Relative.relationships[:friends][:class_name]
+      assert_equal :budy_id, Relative.relationships[:friends][:foreign_key]
+      refute Relative.relationships[:friends][:dependent]
+    end
+
+    it "Creates a getter for cached items" do
+      relative = Relative.new(id: 10)
+      relative.save
+      Relative::Sibling.new(relative_id: 10, size: 'S').save
+      Relative::Sibling.new(relative_id: 10, size: 'M').save
+      Relative::Sibling.new(relative_id: 10, size: 'L').save
+      assert relative.respond_to? :siblings
+      assert_nil relative.instance_variable_get('@cached_siblings')
+      siblings = relative.siblings
+      assert_equal 3, siblings.size
+      assert_equal siblings, relative.instance_variable_get('@cached_siblings')
+    end
+
+    it "Creates a getter for cached first item" do
+      relative = Relative.new(id: 10)
+      relative.save
+      Relative::Sibling.new(relative_id: 10, size: 'S').save
+      Relative::Sibling.new(relative_id: 10, size: 'M').save
+      Relative::Sibling.new(relative_id: 10, size: 'L').save
+      assert relative.respond_to? :siblings_first
+      assert_nil relative.instance_variable_get('@cached_siblings_first')
+      sibling = relative.siblings_first
+      assert_equal 'S', sibling.size
+      assert_equal sibling, relative.instance_variable_get('@cached_siblings_first')
+    end
+
+  end
+
+  describe '::to_select_options' do
+
+    class Selectoptionable < PopulateMe::Document
+      field :name
+      field :slug
+      label :slug
+    end
+
+    class Selectpreviewable < PopulateMe::Document
+      set :default_attachment_class, PopulateMe::Attachment
+      field :name
+      field :img, type: :attachment, variations: [
+        PopulateMe::Variation.default
+      ]
+    end
+
+    before do
+      Selectoptionable.documents = []
+      Selectoptionable.new(id: '1', name: 'Joe', slug: 'joe').save
+      Selectoptionable.new(id: '2', name: 'William', slug: 'william').save
+      Selectoptionable.new(id: '3', name: 'Jack', slug: 'jack').save
+      Selectoptionable.new(id: '4', name: 'Averell', slug: 'averell').save
+      Selectpreviewable.documents = []
+      Selectpreviewable.new(id: '1', name: 'Project', img: 'project.jpg').save
+    end
+
+    after do
+      Selectoptionable.documents = []
+    end
+
+    it 'Formats all items for a select_options' do
+      output_proc = Selectoptionable.to_select_options
+      assert output_proc.is_a?(Proc)
+      output = output_proc.call
+      assert_equal 4, output.size
+      assert output.all?{|o| o.is_a?(Hash) and o.size==2}
+      assert_equal '1', output.find{|o|o.fetch(:description)=='joe'}.fetch(:value)
+    end
+
+    it 'Puts items in alphabetical order of their label' do
+      output= Selectoptionable.to_select_options.call
+      assert_equal({description: 'averell', value: '4'}, output[0])
+    end
+
+    it 'Has an option for prepending empty choice' do
+      output= Selectoptionable.to_select_options(allow_empty: true).call
+      assert_equal({description: '?', value: ''}, output[0])
+      assert_equal({description: 'averell', value: '4'}, output[1])
+    end
+
+    it 'Adds a :preview_uri when there is a thumbnail' do
+      output= Selectpreviewable.to_select_options.call
+      assert output[0].key?(:preview_uri)
+      assert_equal 'Project', output[0][:description]
+      assert_equal '1', output[0][:value]
+      assert_equal '/attachment/selectpreviewable/project.populate_me_thumb.jpg', output[0][:preview_uri]
+    end
+
+  end
+
+  describe 'Polymorphism' do
+
+    class PolyBox < PopulateMe::Document
+      field :first_name
+      field :last_name
+      field :middle_name, only_for: ['Middle', 'Long name']
+      field :nick_name, only_for: 'Funny'
+      field :third_name, only_for: 'Long name'
+    end
+
+    class NotPoly < PopulateMe::Document
+      field :name
+      relationship :images
+    end
+
+    class JustPoly < PopulateMe::Document
+      polymorphic
+    end
+
+    class PolyCustom < PopulateMe::Document
+      polymorphic type: :text, custom_option: 'Custom'
+    end
+
+    class PolyApplicable < PopulateMe::Document
+      field :name_1, only_for: 'Shape 1'
+      field :name_2, only_for: 'Shape 2'
+      field :position
+    end
+
+    class PolyLabel < PopulateMe::Document
+      polymorphic
+      field :name
+    end
+
+    class PolyRelationship < PopulateMe::Document
+      field :name
+      field :short_description, only_for: 'Chapter'
+      relationship :images, only_for: 'Slider'
+      relationship :paragraphs, only_for: 'Chapter'
+    end
+
+    class PolyGroup < PopulateMe::Document
+      only_for 'Slider' do
+        field :name
+        relationship :images
+      end
+      field :no_only_for
+      only_for ['Try','This'] do
+        field :crazy
+      end
+      field :position
+    end
+
+    it 'Creates a field for polymorphic type if it does not exist yet' do
+      assert_equal :polymorphic_type, PolyBox.fields[:polymorphic_type][:type]
+      assert_equal :polymorphic_type, JustPoly.fields[:polymorphic_type][:type]
+      assert_equal :polymorphic_type, PolyRelationship.fields[:polymorphic_type][:type]
+    end
+
+    it 'By default polymorphic_type is hidden and not wrapped' do
+      assert_equal :hidden, PolyBox.fields[:polymorphic_type][:input_attributes][:type]
+      refute PolyBox.fields[:polymorphic_type][:wrap]
+    end
+
+    it 'Does not create polymorphic type field if not required' do
+      assert_nil NotPoly.fields[:polymorphic_type]
+    end
+
+    it 'Gathers all polymorphic type unique values' do
+      assert_equal ['Middle', 'Long name', 'Funny'], PolyBox.fields[:polymorphic_type][:values]
+      assert_equal [], JustPoly.fields[:polymorphic_type][:values]
+      assert_equal ['Chapter', 'Slider'], PolyRelationship.fields[:polymorphic_type][:values]
+    end
+
+    it 'Adds or update field options for polymorphic type passed as arguments' do
+      assert_equal :text, PolyCustom.fields[:polymorphic_type][:type]
+      assert_equal 'Custom', PolyCustom.fields[:polymorphic_type][:custom_option]
+    end
+
+    it 'Forces only_for field option to be an Array if String' do
+      assert_nil PolyBox.fields[:first_name][:only_for]
+      assert_equal ['Middle', 'Long name'], PolyBox.fields[:middle_name][:only_for]
+      assert_equal ['Funny'], PolyBox.fields[:nick_name][:only_for]
+      assert_equal ['Slider'], PolyRelationship.relationships[:images][:only_for]
+    end
+
+    it 'Has a polymorphic? predicate' do
+      assert PolyBox.polymorphic?
+      refute NotPoly.polymorphic?
+    end
+
+    it 'Knows when a field is applicable to a polymorphic_type' do
+      assert NotPoly.field_applicable?(:name, nil) # Not polymorphic
+      assert NotPoly.field_applicable?(:name, 'Fake') # Not polymorphic
+      refute NotPoly.field_applicable?(:non_existing_field, nil) # Not polymorphic
+      assert PolyApplicable.field_applicable?(:polymorphic_type, 'Shape 1') # no only_for
+      assert PolyApplicable.field_applicable?(:position, 'Shape 1') # no only_for
+      refute PolyApplicable.field_applicable?(:name_2, 'Shape 1') # not included
+      assert PolyApplicable.field_applicable?(:name_2, nil) # no type set yet
+
+      assert NotPoly.new.field_applicable?(:name) # Not polymorphic
+      refute NotPoly.new.field_applicable?(:non_existing_field) # Not polymorphic
+      assert PolyApplicable.new(polymorphic_type: 'Shape 2').field_applicable?(:name_2)
+      refute PolyApplicable.new(polymorphic_type: 'Shape 2').field_applicable?(:name_1)
+      assert PolyApplicable.new.field_applicable?(:name_2) # No type set yet
+      assert PolyApplicable.new.field_applicable?(:name_1) # No type set yes
+    end
+
+    it 'Knows when a relationship is applicable to a polymorphic_type' do
+      assert PolyRelationship.relationship_applicable?(:images, 'Slider')
+      refute PolyRelationship.relationship_applicable?(:images, 'Chapter')
+      assert PolyRelationship.new(polymorphic_type: 'Slider').relationship_applicable?(:images)
+      refute PolyRelationship.new(polymorphic_type: 'Chapter').relationship_applicable?(:images)
+    end
+
+    it 'Ignores polymorphic_type when picking the default label_field' do
+      assert_equal :name, PolyLabel.label_field
+    end
+
+    it 'Uses groups to define only_for option for all included fields and relationships' do
+      assert_equal :polymorphic_type, PolyGroup.fields[:polymorphic_type][:type]
+      assert_equal ['Slider', 'Try', 'This'], PolyGroup.fields[:polymorphic_type][:values]
+      assert_equal ['Slider'], PolyGroup.fields[:name][:only_for]
+      assert_equal ['Slider'], PolyGroup.relationships[:images][:only_for]
+      assert_equal ['Try','This'], PolyGroup.fields[:crazy][:only_for]
+    end
+
+    it 'Group only_for option does not leak on special fields' do
+      refute PolyGroup.fields[:id].key?(:only_for)
+      refute PolyGroup.fields[:polymorphic_type].key?(:only_for)
+    end
+
+    it 'Group only_for option does not leak outside of their scope' do
+      refute PolyGroup.fields[:no_only_for].key?(:only_for)
+      refute PolyGroup.fields[:position].key?(:only_for)
+    end
+
+  end
+
+end
+

data/test/test_document_typecasting.rb

@@ -0,0 +1,128 @@
+require 'helper'
+require 'populate_me/document'
+
+class Person < PopulateMe::Document
+  field :name
+  field :shared, type: :boolean
+  field :age, type: :integer
+  field :salary, type: :price
+  field :size, type: :select, select_option: ['S','M','L'] 
+  field :categories, type: :select, select_option: ['A','B','C'], multiple: true 
+  field :dob, type: :date
+  field :when, type: :datetime
+end
+
+describe PopulateMe::Document, 'Typecasting' do
+
+  parallelize_me!
+
+  let(:subject_class) { Person }
+  subject { subject_class.new }
+
+  describe "Value is blank or nil" do
+    it "Returns nil" do
+      assert_nil subject.typecast(:name,nil)
+      assert_nil subject.typecast(:name,'')
+      assert_nil subject.typecast(:salary,'')
+      assert_nil subject.typecast(:dob,'')
+      assert_nil subject.typecast(:when,'')
+    end
+  end
+
+  describe "Field has type :string" do
+    it "Returns it as-is" do
+      assert_equal 'Bob', subject.typecast(:name,'Bob')
+      assert_equal 'true', subject.typecast(:name,'true')
+      assert_equal '5', subject.typecast(:name,'5')
+    end
+  end
+
+  describe "Field has type :boolean" do
+    it "Casts as a boolean" do
+      assert_equal true, subject.typecast(:shared,'true')
+      assert_equal false, subject.typecast(:shared,'false')
+    end
+  end
+
+  describe "Field has type :integer" do
+    describe "Value is just an integer" do
+      it "Casts it as integer" do
+        assert_equal 42, subject.typecast(:age,'42')
+      end
+    end
+    describe "Value has something written at the end" do
+      it "Ignores it" do
+        assert_equal 42, subject.typecast(:age,'42 yo')
+      end
+    end
+    describe "Value is a float" do
+      it "Rounds it" do
+        assert_equal 42, subject.typecast(:age,'42.50')
+      end
+    end
+  end
+
+  describe "Field has type :price" do
+    describe "Value is an integer" do
+      it "Casts it in cents/pence (x100)" do
+        assert_equal 4200, subject.typecast(:salary,'42')
+      end
+    end
+    describe "Value is a float with 2 decimals" do
+      it "Casts it in cents/pence" do
+        assert_equal 4250, subject.typecast(:salary,'42.50')
+      end
+    end
+    describe "Value is a float with irregular decimals for a price" do
+      it "Assumes 2 digits after comma" do
+        assert_equal 4250, subject.typecast(:salary,'42.5')
+      end
+    end
+    describe "Value is prefixed or suffixed" do
+      it "Ignores what is not part of the price" do
+        assert_equal 4250, subject.typecast(:salary,'$42.5')
+        assert_equal 4250, subject.typecast(:salary,'42.5 Dollars')
+      end
+    end
+  end
+
+  describe "Field has type :select" do
+    it "Removes 'nil' string if multiple/array" do
+      assert_equal 'M', subject.typecast(:size, 'M')
+      assert_equal ['A','B'], subject.typecast(:categories, ['A','B'])
+      assert_equal ['A','B'], subject.typecast(:categories, ['nil','A','B'])
+    end
+  end
+
+  describe "Field has type :date" do
+    it "Parses the date with Date.parse" do
+      assert_equal Date.parse('10/11/1979'), subject.typecast(:dob,'10/11/1979')
+    end
+    it "Works with yyyy-mm-dd date html input format" do
+      assert_equal Date.parse('10/11/1979'), subject.typecast(:dob,'1979-11-10')
+    end
+    describe "Value is malformed" do
+      it "Returns nil" do
+        assert_nil subject.typecast(:dob,'10/11')
+      end
+    end
+  end
+
+  describe "Field has type :datetime" do
+    it "Splits the numbers and feed them to Time.utc" do
+      assert_equal Time.utc(1979,11,10,12,30,4), subject.typecast(:when,'10/11/1979 12:30:4')
+    end
+    describe "Delimiter is a dash" do
+      it "Replaces them with forward slash before parsing" do
+        assert_equal Time.utc(1979,11,10,12,30,4), subject.typecast(:when,'10-11-1979 12:30:4')
+      end
+    end
+    describe "Value is malformed" do
+      it "Returns nil" do
+        assert_nil subject.typecast(:when,'10/11')
+        assert_nil subject.typecast(:when,'10/11/1979')
+      end
+    end
+  end
+
+end

data/test/test_grid_fs_attachment.rb

@@ -0,0 +1,239 @@
+require 'helper'
+require 'populate_me/mongo'
+require 'populate_me/grid_fs_attachment'
+
+Mongo::Logger.logger.level = Logger::ERROR
+
+GRIDMONGO = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'populate-me-grid-test')
+GRIDDB = GRIDMONGO.database
+GRIDDB.drop
+PopulateMe::Mongo.set :db, GRIDDB
+PopulateMe::Mongo.set :default_attachment_class, PopulateMe::GridFS
+PopulateMe::GridFS.set :db, GRIDDB
+
+describe 'PopulateMe::GridFS' do
+  # parallelize_me!
+
+  class GridBook < PopulateMe::Mongo
+    field :cover, type: :attachment, variations: [
+      PopulateMe::Variation.new_image_magick_job(:thumb, :gif, "-resize '300x'")
+    ]
+    field :content, type: :attachment, variations: [
+      PopulateMe::Variation.new(:upcase, :txt, lambda{ |src,dst|
+        Kernel.system "cat \"#{src}\" | tr 'a-z' 'A-Z' > \"#{dst}\""
+      })
+    ]
+  end
+
+  before do
+    GRIDDB.drop
+  end
+
+  # Utils
+
+  it 'Returns URL with url_prefix' do
+    book = GridBook.new cover: "candy.jpg"
+    assert_equal '/attachment/candy.jpg', book.attachment(:cover).url
+    assert_equal '/attachment/candy.thumb.gif', book.attachment(:cover).url(:thumb)
+  end
+
+  it 'Has nil URL when field is blank' do
+    book = GridBook.new
+    assert_nil book.attachment(:cover).url
+  end
+
+  it 'Has location root without attachee prefix' do
+    book = GridBook.new
+    refute_match book.attachment(:cover).attachee_prefix, book.attachment(:cover).location_root
+  end
+
+  # Create
+
+  it "Saves attachments on create with variations" do
+    book = GridBook.new
+
+    file = Tempfile.new('foo')
+    file.write('hello')
+    file.rewind
+
+    assert_equal 0, GRIDDB['fs.files'].count
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+    assert_equal 2, GRIDDB['fs.files'].count
+    assert_equal 'grid-book/story.txt', field_value
+
+    gridfile = GRIDDB.fs.find(filename: 'grid-book/story.txt').first
+    assert_equal 'text/plain', gridfile['contentType']
+    assert_equal 'grid-book', gridfile['metadata']['parent_collection']
+    GRIDDB.fs.open_download_stream(gridfile['_id']) do |stream|
+      assert_equal 'hello', stream.read
+    end
+
+    vargridfile = GRIDDB.fs.find(filename: 'grid-book/story.upcase.txt').first
+    assert_equal 'text/plain', vargridfile['contentType']
+    assert_equal 'grid-book', vargridfile['metadata']['parent_collection']
+    GRIDDB.fs.open_download_stream(vargridfile['_id']) do |stream|
+      assert_equal 'HELLO', stream.read
+    end
+
+    file.close
+    file.unlink
+  end
+
+  it 'Does not create 2 files with the same name' do
+    file = Tempfile.new('foo')
+
+    book = GridBook.new
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+
+    assert_equal 'grid-book/story.txt', field_value
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+
+    assert_equal 'grid-book/story-1.txt', field_value
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+
+    assert_equal 'grid-book/story-2.txt', field_value
+
+    file.close
+    file.unlink
+  end
+
+  # Delete
+
+  it 'Is deletable when field is not blank' do
+    book = GridBook.new cover: "candy.jpg"
+    assert book.attachment(:cover).deletable?
+  end
+
+  it 'Is not deletable when field is blank' do
+    book = GridBook.new
+    refute book.attachment(:cover).deletable?
+  end
+
+  it 'Deletes all attachments' do
+    file = Tempfile.new('foo')
+
+    book = GridBook.new
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+    book.content = field_value
+
+    refute_nil GRIDDB.fs.find(filename: 'grid-book/story.txt').first
+    refute_nil GRIDDB.fs.find(filename: 'grid-book/story.upcase.txt').first
+
+    book.attachment(:content).delete_all
+
+    assert_nil GRIDDB.fs.find(filename: 'grid-book/story.txt').first
+    assert_nil GRIDDB.fs.find(filename: 'grid-book/story.upcase.txt').first
+
+    file.close
+    file.unlink
+  end
+
+  it 'Deletes one attachment at a time' do
+    file = Tempfile.new('foo')
+
+    book = GridBook.new
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+    book.content = field_value
+
+    refute_nil GRIDDB.fs.find(filename: 'grid-book/story.txt').first
+    refute_nil GRIDDB.fs.find(filename: 'grid-book/story.upcase.txt').first
+
+    book.attachment(:content).delete
+
+    assert_nil GRIDDB.fs.find(filename: 'grid-book/story.txt').first
+    refute_nil GRIDDB.fs.find(filename: 'grid-book/story.upcase.txt').first
+
+    book.attachment(:content).delete :upcase
+
+    assert_nil GRIDDB.fs.find(filename: 'grid-book/story.upcase.txt').first
+
+    file.close
+    file.unlink
+  end
+
+  # Update
+
+  it 'Deletes previous attachment when saving a new one' do
+    file = Tempfile.new('foo')
+    file.write('hello')
+    file.rewind
+
+    book = GridBook.new
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+    book.content = field_value
+
+    refute_nil GRIDDB.fs.find(filename: 'grid-book/story.txt').first
+    refute_nil GRIDDB.fs.find(filename: 'grid-book/story.upcase.txt').first
+
+    file.rewind
+    file.write('world')
+    file.rewind
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'history.md',
+      type: 'text/markdown'
+    })
+    book.content = field_value
+
+    assert_nil GRIDDB.fs.find(filename: 'grid-book/story.txt').first
+    assert_nil GRIDDB.fs.find(filename: 'grid-book/story.upcase.txt').first
+    refute_nil GRIDDB.fs.find(filename: 'grid-book/history.md').first
+    refute_nil GRIDDB.fs.find(filename: 'grid-book/history.upcase.txt').first
+
+    gridfile = GRIDDB.fs.find(filename: 'grid-book/history.md').first
+    assert_equal 'text/markdown', gridfile['contentType']
+    assert_equal 'grid-book', gridfile['metadata']['parent_collection']
+    GRIDDB.fs.open_download_stream(gridfile['_id']) do |stream|
+      assert_equal 'world', stream.read
+    end
+
+    gridfile = GRIDDB.fs.find(filename: 'grid-book/history.upcase.txt').first
+    assert_equal 'text/plain', gridfile['contentType']
+    assert_equal 'grid-book', gridfile['metadata']['parent_collection']
+    GRIDDB.fs.open_download_stream(gridfile['_id']) do |stream|
+      assert_equal 'WORLD', stream.read
+    end
+
+    file.close
+    file.unlink
+  end
+
+end
+
+GRIDDB.drop
+