populate-me 0.12.0

data/test/test_document_callbacks.rb

@@ -0,0 +1,151 @@
+require 'helper'
+require 'populate_me/document'
+
+class Hamburger < PopulateMe::Document
+  attr_accessor :taste
+
+  register_callback :layers, :bread
+  register_callback :layers, :cheese
+  register_callback :layers do
+    self.taste
+  end
+
+  register_callback :after_cook, :add_salad
+  register_callback :after_cook do
+    taste << ' with more cheese'
+  end
+  def add_salad
+    taste << ' with salad'
+  end
+
+  register_callback :after_eat do
+    taste << ' stomach'
+  end
+  register_callback :after_eat, prepend: true do
+    taste << ' my'
+  end
+  register_callback :after_eat, :prepend_for, prepend: true
+  def prepend_for
+    taste << ' for'
+  end
+
+  before :digest do
+    taste << ' taste'
+  end
+  before :digest, :add_dot
+  before :digest, prepend: true do
+    taste << ' the'
+  end
+  before :digest, :prepend_was, prepend: true
+  after :digest do
+    taste << ' taste'
+  end
+  after :digest, :add_dot
+  after :digest, prepend: true do
+    taste << ' the'
+  end
+  after :digest, :prepend_was, prepend: true
+  def add_dot; taste << '.'; end
+  def prepend_was; taste << ' was'; end
+
+  before :argument do |name|
+    taste << " #{name}"
+  end
+  after :argument, :after_with_arg
+  def after_with_arg(name)
+    taste << " #{name}"
+  end
+end
+
+describe PopulateMe::Document, 'Callbacks' do
+
+  parallelize_me!
+
+  let(:subject_class) { Hamburger }
+  subject { subject_class.new taste: 'good' }
+  let(:layers_callbacks) { subject_class.callbacks[:layers] }
+
+  it 'Registers callbacks as symbols or blocks' do
+    assert_equal 3, layers_callbacks.size
+    assert_equal :bread, layers_callbacks[0]
+    assert_equal :cheese, layers_callbacks[1]
+    assert_equal 'good', subject.instance_eval(&layers_callbacks[2])
+  end
+
+  it 'Executes symbol or block callbacks' do
+    subject.exec_callback('after_cook')
+    assert_equal 'good with salad with more cheese', subject.taste
+  end
+
+  it 'Does not raise if executing a callback which does not exist' do
+    subject.exec_callback(:after_burn)
+    assert_equal 'good', subject.taste
+  end
+
+  it 'Has an option to prepend when registering callbacks' do
+    subject.exec_callback(:after_eat)
+    assert_equal 'good for my stomach', subject.taste
+  end
+
+  it 'Has callbacks shortcut for before_ prefix' do
+    subject.exec_callback(:before_digest)
+    assert_equal 'good was the taste.', subject.taste
+  end
+  it 'Has callbacks shortcut for after_ prefix' do
+    subject.exec_callback(:after_digest)
+    assert_equal 'good was the taste.', subject.taste
+  end
+
+  it 'Can pass the callback name as an argument to the callback method' do
+    subject.exec_callback(:before_argument)
+    assert_equal 'good before_argument', subject.taste
+    subject.exec_callback(:after_argument)
+    assert_equal 'good before_argument after_argument', subject.taste
+  end
+
+  describe '#ensure_position' do
+
+    class RaceCar < PopulateMe::Document
+      field :name
+      field :team
+      field :position_by_team, type: :position, scope: :team 
+      position_field
+    end
+
+    before do
+      RaceCar.documents = []
+    end
+
+    it 'Does not change position if already set' do
+      RaceCar.new(name: 'racer3', position: 3, team: 'A', position_by_team: 14).save
+      car = RaceCar.new(name: 'racer1', position: 12, team: 'A', position_by_team: 41)
+      car.ensure_position
+      assert_equal 12, car.position
+      assert_equal 41, car.position_by_team
+    end
+
+    it 'Sets position fields to last position' do
+      RaceCar.new(name: 'racer1', position: 1, team: 'A', position_by_team: 41).save
+      RaceCar.new(name: 'racer2', position: 2, team: 'B', position_by_team: 12).save
+      RaceCar.new(name: 'racer3', position: 3, team: 'B', position_by_team: 14).save
+      car = RaceCar.new(team: 'B').ensure_position
+      assert_equal 4, car.position
+      assert_equal 15, car.position_by_team
+    end
+
+    it 'Returns 0 when first document in scope' do
+      assert_equal 0, RaceCar.new.ensure_position.position
+      RaceCar.new(name: 'racer1', position: 1, team: 'A', position_by_team: 41).save
+      assert_equal 0, RaceCar.new(team: 'B').ensure_position.position_by_team
+    end
+
+    it "Ensures position before creating new document" do
+      car = RaceCar.new
+      car.save
+      assert_equal 0, car.position
+    end
+
+  end
+
+end
+

data/test/test_document_outcasting.rb

@@ -0,0 +1,247 @@
+require 'helper'
+require 'populate_me/document'
+require 'populate_me/attachment'
+
+class Outcasted < PopulateMe::Document
+  set :default_attachment_class, PopulateMe::Attachment
+
+  field :name
+  field :size, type: :select, select_options: [
+    {description: 'small', value: 's'},
+    {description: 'medium', value: 'm'},
+    {description: 'large', value: 'l'}
+  ]
+  field :availability, type: :select, select_options: [
+    {description: 'Available', value: 'yes', preview_uri: 'http://www.example.org/yes.jpg' },
+    {description: 'On offer', value: 'almost', preview_uri: 'http://www.example.org/almost.jpg' },
+    {description: 'Sold', value: 'no', preview_uri: 'http://www.example.org/no.jpg' }
+  ]
+  field :tags, type: :select, select_options: ['art','sport','science'], multiple: true
+  field :related_properties, type: :select, select_options: ['prop1','prop2','prop3'], multiple: true
+  field :pdf, type: :attachment
+  field :authors, type: :list
+  field :weirdo, type: :strange
+  field :price, type: :price
+
+  def get_size_options
+    [
+      [:small, :s],
+      [:medium, :m],
+      [:large, :l]
+    ]
+  end
+
+end
+
+class Outcasted::Author < PopulateMe::Document
+  field :name
+end
+
+describe PopulateMe::Document, 'Outcasting' do
+
+  parallelize_me!
+
+  describe '#outcast' do
+
+    it 'Keeps the original info unchanged' do
+      original = Outcasted.fields[:name]
+      output = Outcasted.new.outcast(:name, original, {input_name_prefix: 'data'})
+      refute original.equal?(output)
+    end
+
+    it 'Adds input_name_prefix to input_name' do
+      original = Outcasted.fields[:name]
+      output = Outcasted.new.outcast(:name, original, {input_name_prefix: 'data'})
+      assert_equal 'data[name]', output[:input_name]
+    end
+
+    it 'Sets input_value to the field value' do
+      original = Outcasted.fields[:name]
+      outcasted = Outcasted.new
+      outcasted.name = 'Thomas'
+      output = outcasted.outcast(:name, original, {input_name_prefix: 'data'})
+      assert_equal 'Thomas', output[:input_value]
+    end
+
+  end
+
+  describe '#outcast_list' do
+
+    it 'Has no value and an empty list of items when list is empty' do
+      original = Outcasted.fields[:authors]
+      output = Outcasted.new.outcast(:authors, original, {input_name_prefix: 'data'})
+      assert_nil output[:input_value]
+      assert_equal [], output[:items]
+    end
+
+    it 'Nests the items in the list with their own nested prefix' do
+      original = Outcasted.fields[:authors]
+      outcasted = Outcasted.new
+      outcasted.authors.push(Outcasted::Author.new(name: 'Bob'))
+      outcasted.authors.push(Outcasted::Author.new(name: 'Mould'))
+      output = outcasted.outcast(:authors, original, {input_name_prefix: 'data'})
+      assert_nil output[:input_value]
+      assert_equal 2, output[:items].size
+      first_item = output[:items][0][:fields]
+      assert_equal 'data[authors][][name]', first_item[1][:input_name]
+      assert_equal 'Bob', first_item[1][:input_value]
+    end
+
+  end
+
+  describe '#outcast_select' do
+
+    def formated_options? original, output
+      assert_equal [ {description: 'small', value: 's'}, {description: 'medium', value: 'm'}, {description: 'large', value: 'l'} ], output[:select_options]
+      refute original[:select_options].equal?(output[:select_options])
+      assert output[:select_options].all?{|o|!o[:selected]}
+    end
+
+    it 'Leaves the options as they are when they are already formated' do
+      original = Outcasted.fields[:size]
+      output = Outcasted.new.outcast(:size, original, {input_name_prefix: 'data'})
+      formated_options?(original, output)
+    end
+
+    it 'Can have more fields when they are already formated' do
+      # Mainly for adding a preview_uri but also future tweaks
+      original = Outcasted.fields[:availability]
+      output = Outcasted.new.outcast(:availability, original, {input_name_prefix: 'data'})
+      assert(output[:select_options].all?{|o| o.key?(:preview_uri)})
+      last = output[:select_options].last
+      assert_equal 'Sold', last[:description]
+      assert_equal 'no', last[:value]
+      assert_equal 'http://www.example.org/no.jpg', last[:preview_uri]
+    end
+
+    it 'Formats the options when it is a 2 strings array' do
+      original = Outcasted.fields[:size].dup
+      original[:select_options] = [
+        [:small, :s],
+        [:medium, :m],
+        [:large, :l]
+      ]
+      output = Outcasted.new.outcast(:size, original, {input_name_prefix: 'data'})
+      formated_options?(original, output)
+    end
+
+    it 'Formats the options when they come from a proc' do
+      original = Outcasted.fields[:size].dup
+      original[:select_options] = proc{[
+        [:small, :s],
+        [:medium, :m],
+        [:large, :l]
+      ]}
+      output = Outcasted.new.outcast(:size, original, {input_name_prefix: 'data'})
+      formated_options?(original, output)
+    end
+
+    it 'Formats the options when they come from a symbol' do
+      original = Outcasted.fields[:size].dup
+      original[:select_options] = :get_size_options
+      output = Outcasted.new.outcast(:size, original, {input_name_prefix: 'data'})
+      formated_options?(original, output)
+    end
+
+    it 'Formats options when it comes from a simple string' do
+      original = Outcasted.fields[:size].dup
+      original[:select_options] = [:small,:medium,:large]
+      output = Outcasted.new.outcast(:size, original, {input_name_prefix: 'data'})
+      assert_equal [ {description: 'Small', value: 'small'}, {description: 'Medium', value: 'medium'}, {description: 'Large', value: 'large'} ], output[:select_options]
+    end
+
+    it 'Selects the input value' do
+      original = Outcasted.fields[:size]
+      outcasted = Outcasted.new size: 'm'
+      output = outcasted.outcast(:size, original, {input_name_prefix: 'data'})
+      assert_equal 1, output[:select_options].select{|o|o[:selected]}.size
+      assert output[:select_options].find{|o|o[:value]=='m'}[:selected]
+    end
+
+    it 'Adds [] at the end of input_name if multiple is true' do
+      original = Outcasted.fields[:tags]
+      output = Outcasted.new.outcast(:tags, original, {input_name_prefix: 'data'})
+      assert_equal 'data[tags][]', output[:input_name]
+    end
+
+    it 'Selects multiple options when input_value is an array' do
+      original = Outcasted.fields[:tags]
+      outcasted = Outcasted.new tags: ['art','science']
+      output = outcasted.outcast(:tags, original, {input_name_prefix: 'data'})
+      assert output[:select_options].find{|o|o[:value]=='art'}[:selected]
+      assert output[:select_options].find{|o|o[:value]=='science'}[:selected]
+      refute output[:select_options].find{|o|o[:value]=='sport'}[:selected]
+    end
+
+    it 'Orders input values at the begining when multiple options' do
+      original = Outcasted.fields[:related_properties]
+
+      # Normal
+      outcasted = Outcasted.new related_properties: ['prop3','prop1']
+      output = outcasted.outcast(:related_properties, original, {input_name_prefix: 'data'})
+      assert_equal 'prop3', output[:select_options][0][:value]
+      assert output[:select_options][0][:selected]
+      assert_equal 'prop1', output[:select_options][1][:value]
+      assert output[:select_options][1][:selected]
+      assert_equal 'prop2', output[:select_options][2][:value]
+      refute output[:select_options][2][:selected]
+
+      # When input_value is nil
+      outcasted = Outcasted.new
+      output = outcasted.outcast(:related_properties, original, {input_name_prefix: 'data'})
+      assert_equal 'prop1', output[:select_options][0][:value]
+      refute output[:select_options][0][:selected]
+      assert_equal 'prop2', output[:select_options][1][:value]
+      refute output[:select_options][1][:selected]
+      assert_equal 'prop3', output[:select_options][2][:value]
+      refute output[:select_options][2][:selected]
+
+      # When input_value has a non existing value
+      outcasted = Outcasted.new related_properties: ['stale','prop2']
+      output = outcasted.outcast(:related_properties, original, {input_name_prefix: 'data'})
+      assert_equal 'prop2', output[:select_options][0][:value]
+      assert output[:select_options][0][:selected]
+      assert_equal 'prop1', output[:select_options][1][:value]
+      refute output[:select_options][1][:selected]
+      assert_equal 'prop3', output[:select_options][2][:value]
+      refute output[:select_options][2][:selected]
+    end
+
+  end
+
+  describe '#outcast_price' do
+
+    it 'Displays the price in dollars/pounds' do
+      original = Outcasted.fields[:price]
+      outcasted = Outcasted.new price: 2999
+      output = outcasted.outcast(:price, original, {input_name_prefix: 'data'})
+      assert_equal '29.99', output[:input_value]
+    end
+
+    it 'Leaves the field alone when value not an integer' do
+      original = Outcasted.fields[:price]
+      outcasted = Outcasted.new
+      output = outcasted.outcast(:price, original, {input_name_prefix: 'data'})
+      assert_nil outcasted.price
+      assert_nil output[:input_value]
+    end
+
+  end
+
+  describe '#outcast_attachment' do
+
+    it 'Sets url' do
+      original = Outcasted.fields[:pdf]
+      outcasted = Outcasted.new
+      output = outcasted.outcast(:pdf, original, {input_name_prefix: 'data'})
+      assert_nil output[:url]
+
+      outcasted.pdf = 'guidelines.pdf'
+      output = outcasted.outcast(:pdf, original, {input_name_prefix: 'data'})
+      assert_equal outcasted.attachment(:pdf).url, output[:url]
+    end
+
+  end
+
+end
+

data/test/test_document_persistence.rb

@@ -0,0 +1,83 @@
+require 'helper'
+require 'populate_me/document'
+
+class Stuborn < PopulateMe::Document
+  attr_accessor :age
+  field :position
+  field :reversed, direction: :desc
+end
+
+describe PopulateMe::Document, 'Persistence' do
+
+  parallelize_me!
+
+  let(:subject_class) { Stuborn }
+  subject { subject_class.new }
+
+  describe '::is_unique' do
+
+    before do
+      Stuborn.documents = []
+    end
+
+    # def doc_doesnt_exist
+    #   subject_class.stub(:admin_get, nil) do
+    #     yield
+    #   end
+    # end
+    # def doc_exists
+    #   subject_class.stub(:admin_get, subject) do
+    #     yield
+    #   end
+    # end
+
+    describe 'The document does not exist yet' do
+      it 'Saves an entry with the ID `unique` by default' do
+        Stuborn.is_unique
+        assert_equal 1, Stuborn.documents.count
+        assert_equal 'unique', Stuborn.documents[0]['id']
+      end
+      it 'Saves an entry with a provided ID' do
+        Stuborn.is_unique('provided_id')
+        assert_equal 1, Stuborn.documents.count
+        assert_equal 'provided_id', Stuborn.documents[0]['id']
+      end
+    end
+    describe 'The document already exist' do
+      it 'Does not create a new document and preserve the current one' do
+        doc = Stuborn.new({'id'=>'unique', 'age'=>4})
+        doc.save
+        Stuborn.is_unique
+        assert_equal 1, Stuborn.documents.count
+        assert_equal doc.to_h, Stuborn.documents[0]
+      end
+    end
+  end
+
+  describe '::set_indexes' do
+
+    before do
+      Stuborn.documents = []
+      Stuborn.new('id' => 'a').save
+      Stuborn.new('id' => 'b').save
+      Stuborn.new('id' => 'c').save
+    end
+
+    it 'Sets the indexes on the provided field' do
+      Stuborn.set_indexes(:position,['b','a','c'])
+      assert_equal 1, Stuborn.admin_get('a').position
+      assert_equal 0, Stuborn.admin_get('b').position
+      assert_equal 2, Stuborn.admin_get('c').position
+    end
+
+    it 'Sets the indexes taking direction into account' do
+      Stuborn.set_indexes(:reversed,['b','a','c'])
+      assert_equal 1, Stuborn.admin_get('a').reversed
+      assert_equal 2, Stuborn.admin_get('b').reversed
+      assert_equal 0, Stuborn.admin_get('c').reversed
+    end
+
+  end
+
+end
+