populate-me 0.12.0

data/test/test_mongo.rb

@@ -0,0 +1,324 @@
+require 'helper'
+require 'populate_me/mongo'
+# require 'mongo'
+
+Mongo::Logger.logger.level = Logger::ERROR
+
+MONGO = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'populate-me-test')
+DB = MONGO.database
+DB.drop
+OTHER_MONGO = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'populate-me-test-other')
+OTHER_DB = OTHER_MONGO.database
+OTHER_DB.drop
+PopulateMe::Mongo.set :db, DB
+
+
+describe 'PopulateMe::Mongo' do
+  # PopulateMe::Mongo is the Mongo specific extention for 
+  # Document.
+  #
+  # It contains what is specific to a Mongo
+  # database.
+
+  # parallelize_me!
+
+  class CatFish < PopulateMe::Mongo
+    field :name
+  end
+  module Paradise
+    class CatFish < PopulateMe::Mongo
+      field :name
+    end
+  end
+
+  it 'Includes Document Module' do 
+    assert_equal "Cat Fish", CatFish.to_s
+    assert_equal "Fred", CatFish.new(name: "Fred").to_s
+  end
+
+  it "Has _id as persistent variable if set" do 
+    assert_equal [:@name], CatFish.new(name: "hank").persistent_instance_variables
+    cf = CatFish.new(id: "bbbbb", name: "honk")
+    assert cf.persistent_instance_variables.include?(:@_id)
+    assert cf.persistent_instance_variables.include?(:@name)
+  end
+
+  describe 'Database connection' do 
+
+    class NoMongoDB < PopulateMe::Mongo; set :db, nil; end
+
+    it 'Should raise if db is not set' do 
+      assert_raises(PopulateMe::MissingMongoDBError) do
+        NoMongoDB.collection
+      end
+    end
+
+    it 'Should have db set by the parent class' do
+      assert_equal DB, CatFish.settings.db
+    end
+
+    it 'Can override db' do 
+      CatFish.set :db, OTHER_DB
+      assert_equal OTHER_DB, CatFish.settings.db
+      CatFish.set :db, DB
+      assert_equal DB, CatFish.settings.db
+    end
+
+    it 'Should set DB collection to dasherized full class name by default' do 
+      assert_equal "cat-fish", CatFish.collection_name
+      assert_equal "paradise--cat-fish", Paradise::CatFish.collection_name
+    end
+
+    it 'Finds collection in DB' do 
+      assert_equal DB['cat-fish'].name, CatFish.collection.name
+    end
+
+    it 'Should set DB and collection name even for dynamically created classes' do
+      # Happens when an included module automatically happens a class.
+      # e.g. Slides for a Slideshow
+      CatFish.const_set("Item", Class.new(CatFish.superclass))
+      assert_equal "cat-fish--item", CatFish::Item.collection.name
+    end
+
+  end
+
+  describe 'Low level CRUD' do 
+
+    class LowFish < PopulateMe::Mongo
+      field :name
+      field :lastname
+    end
+
+    before do
+      LowFish.collection.drop
+    end
+
+    it 'Should create' do
+      fred = LowFish.new(name: "Fred")
+      id = fred.perform_create
+      assert_equal id, fred.id 
+      refute_nil LowFish.collection.find({'name'=>"Fred"}).first
+      LowFish.collection.delete_one({'name'=>'Fred'})
+    end
+
+    it 'Should create with custom id' do 
+      dddd = LowFish.new(id: "dddd", name: "tom")
+      id = dddd.perform_create
+      assert_equal "dddd", id
+    end
+
+    it 'Should update' do 
+      jason = LowFish.new(name: "jason")
+      jason.perform_create
+      jason.name = "billy"
+      jason.perform_update
+      assert_equal  "billy", LowFish.collection.find({'_id'=> jason.id}).first['name']
+    end
+
+    it "Should get correct item" do 
+      jackson_id = LowFish.new(name: "jackson").perform_create
+      assert_equal "jackson", LowFish.admin_get(jackson_id).name
+      assert_equal "jackson", LowFish.admin_get(jackson_id.to_s).name
+      assert_nil LowFish.admin_get("nonexistentid")
+
+      regular_fish_id = LowFish.new(id: 87, name: "regular").perform_create
+      # need to test with .to_s
+      assert_equal "regular", LowFish.admin_get(regular_fish_id).name
+    end
+
+    it "Should get multiple items" do
+      # Order is not respected
+      alpha_id = LowFish.new(name: "alpha").perform_create
+      beta_id = LowFish.new(name: "beta").perform_create
+      gamma_id = LowFish.new(name: "gamma").perform_create
+      items = LowFish.admin_get([alpha_id, beta_id, nil, alpha_id])
+      assert items.is_a?(Array)
+      assert_equal 2, items.count
+      refute_nil items.find{|i| i.id == alpha_id}
+      refute_nil items.find{|i| i.id == beta_id}
+      assert_nil items.find{|i| i.id == gamma_id}
+    end
+
+    it 'Should have the [] shortcut for admin_get' do
+      LowFish.collection.insert_one(_id: 42, name: "H2G2")
+      assert_equal LowFish[42], LowFish.admin_get(42)
+    end
+
+    it 'Should admin_find correctly' do
+      LowFish.collection.insert_one(_id: 10, name: "Arya")
+      LowFish.collection.insert_one(_id: 20, name: "Bran")
+      LowFish.collection.insert_one(_id: 30, name: "Arya")
+      LowFish.collection.insert_one(_id: 40, name: "Bran")
+      items = LowFish.admin_find
+      assert items.is_a?(Array)
+      assert_equal 4, items.count
+      assert_equal 10, items[0].id
+      items = LowFish.admin_find query: {name: 'Bran'}
+      assert items.is_a?(Array)
+      assert 2, items.count
+      assert_equal 20, items[0].id
+    end
+
+    it 'Should admin_find_first correctly' do
+      LowFish.collection.insert_one(_id: 10, name: "Arya")
+      LowFish.collection.insert_one(_id: 20, name: "Bran")
+      LowFish.collection.insert_one(_id: 30, name: "Arya")
+      LowFish.collection.insert_one(_id: 40, name: "Bran")
+      item = LowFish.admin_find_first
+      assert_equal 10, item.id
+      item = LowFish.admin_find_first query: {name: "Bran"}
+      assert_equal 20, item.id
+    end
+
+    it 'Should admin_find while turning fields option into a projection option' do
+      LowFish.collection.insert_one(_id: 42, name: "John", lastname: "Doe")
+      found = LowFish.admin_find(query: {lastname: "Doe"}, fields: ['_id', 'lastname'])[0]
+      assert_equal 42, found.id
+      assert_nil found.name
+    end
+
+    it 'Should delete' do
+      herbert = LowFish.new(name: "herbert")
+      herbert.perform_create
+      refute_nil LowFish.collection.find({"_id"=> herbert.id}).first
+      herbert.perform_delete
+      assert_nil LowFish.collection.find({"_id"=> herbert.id}).first
+    end
+
+    it 'Should not save to the @@documents class variable' do 
+      LowFish.collection.insert_one(_id: 42, name: "H2G2")
+      assert_equal [], LowFish.documents
+    end
+
+  end
+
+  describe 'High level CRUD' do 
+
+    it 'Should use callbacks' do 
+      danny = CatFish.new(name: "danny")
+      assert_nil danny.id
+      assert danny.new?
+      danny.save
+      refute_nil danny.id
+      refute danny.new?
+    end
+
+  end
+
+  describe 'Default Sorting' do
+
+    class MongoSoldier < PopulateMe::Mongo
+      field :name
+      field :position
+    end
+
+    before do
+      MongoSoldier.collection.drop
+      MongoSoldier.new(name: 'Bob', position: 2).perform_create
+      MongoSoldier.new(name: 'Albert', position: 3).perform_create
+      MongoSoldier.new(name: 'Tony', position: 1).perform_create
+    end
+
+    it 'Uses Doc::sort_by to determine the order' do
+      assert_equal 'Albert', MongoSoldier.sort_by(:name).admin_find[0].name
+      assert_equal 'Tony', MongoSoldier.sort_by(:name,:desc).admin_find[0].name
+      assert_equal 1, MongoSoldier.sort_by(:position).admin_find[0].position
+      assert_raises(ArgumentError) do
+        MongoSoldier.sort_by(:name,0)
+      end
+      assert_raises(ArgumentError) do
+        MongoSoldier.sort_by(:namespace)
+      end
+    end
+
+    it 'Can write Mongo-specific sort if a Hash or an Array is passed' do
+      assert_equal 'Tony', MongoSoldier.sort_by([[:name, -1]]).admin_find[0].name
+      assert_equal 'Tony', MongoSoldier.sort_by({name: -1}).admin_find[0].name
+    end
+
+  end
+
+  describe 'Manual Sorting' do
+
+    class MongoChampion < PopulateMe::Mongo
+      field :position
+      field :reversed, direction: :desc
+    end
+
+    before do
+      MongoChampion.collection.drop
+      MongoChampion.new(id: 'a').perform_create
+      MongoChampion.new(id: 'b').perform_create
+      MongoChampion.new(id: 'c').perform_create
+    end
+
+    it 'Sets the indexes on the provided field' do
+      MongoChampion.set_indexes(:position,['b','a','c'])
+      assert_equal 1, MongoChampion.admin_get('a').position
+      assert_equal 0, MongoChampion.admin_get('b').position
+      assert_equal 2, MongoChampion.admin_get('c').position
+    end
+
+    it 'Sets the indexes taking direction into account' do
+      MongoChampion.set_indexes(:reversed,['b','a','c'])
+      assert_equal 1, MongoChampion.admin_get('a').reversed
+      assert_equal 2, MongoChampion.admin_get('b').reversed
+      assert_equal 0, MongoChampion.admin_get('c').reversed
+    end
+
+    it 'Sets the indexes correctly even if some ids are not string' do
+      MongoChampion.collection.drop
+      MongoChampion.new(id: 'a').perform_create
+      MongoChampion.new(id: BSON::ObjectId.from_string("507f1f77bcf86cd799439011")).perform_create
+      MongoChampion.new(id: BSON::ObjectId.from_string("507f191e810c19729de860ea")).perform_create
+      MongoChampion.set_indexes(:position,["507f1f77bcf86cd799439011",'a',"507f191e810c19729de860ea"])
+      assert_equal 0, MongoChampion.admin_get("507f1f77bcf86cd799439011").position
+      assert_equal 1, MongoChampion.admin_get('a').position
+      assert_equal 2, MongoChampion.admin_get("507f191e810c19729de860ea").position
+    end
+  end
+
+  describe '::admin_distinct' do
+
+    class MongoDistinction < PopulateMe::Mongo
+      attr_accessor :title, :age
+    end
+
+    before do
+      MongoDistinction.collection.drop
+    end
+
+    it 'Can list all distinct values' do
+      MongoDistinction.new(title: 'Lord').save
+      MongoDistinction.new(title: 'Lord').save
+      MongoDistinction.new.save
+      MongoDistinction.new(title: 'Chevalier').save
+      MongoDistinction.new(title: 'Baron').save
+      MongoDistinction.new(title: 'Baron').save
+      result = MongoDistinction.admin_distinct :title
+      assert_instance_of Array, result
+      assert_equal 3, result.size
+      assert_includes result, 'Lord'
+      assert_includes result, 'Chevalier'
+      assert_includes result, 'Baron'
+    end
+
+    it 'Can list all distinct values for a specific selector' do
+      MongoDistinction.new(title: 'Chevalier', age: 33).save
+      MongoDistinction.new(title: 'Chevalier', age: 34).save
+      MongoDistinction.new(title: 'Baron', age: 35).save
+      MongoDistinction.new(title: 'Baron', age: 36).save
+      result = MongoDistinction.admin_distinct :age, query: {title: 'Baron'}
+      assert_instance_of Array, result
+      assert_equal 2, result.size
+      assert_includes result, 35
+      assert_includes result, 36
+    end
+
+  end
+
+end
+
+DB.drop
+OTHER_DB.drop
+

data/test/test_s3_attachment.rb

@@ -0,0 +1,281 @@
+require 'helper'
+require 'populate_me/document'
+require 'populate_me/s3_attachment'
+
+s3_resource = Aws::S3::Resource.new
+s3_bucket = s3_resource.bucket(ENV['BUCKET'])
+PopulateMe::Document.set :default_attachment_class, PopulateMe::S3Attachment
+PopulateMe::S3Attachment.set :bucket, s3_bucket
+
+describe 'PopulateMe::S3Attachment' do
+  # parallelize_me!
+
+  def check_if_public_read(object)
+    grant = object.acl.grants.find do |g|
+      g.grantee.uri=="http://acs.amazonaws.com/groups/global/AllUsers"
+    end
+    raise "grant not found" if grant.nil?
+    ['READ','FULL_CONTROL'].include? grant.permission
+  end
+
+  class S3Book < PopulateMe::Document
+    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}\""
+      })
+    ]
+    field :open_content, type: :attachment, url_prefix: 'open', variations: [
+      PopulateMe::Variation.new(:upcase, :txt, lambda{ |src,dst|
+        Kernel.system "cat \"#{src}\" | tr 'a-z' 'A-Z' > \"#{dst}\""
+      })
+    ]
+  end
+
+  class S3BookNoPrefix < PopulateMe::Document
+    set :s3_url_prefix, ''
+    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
+    s3_bucket.clear!
+  end
+
+  # Utils
+
+  it 'Returns URL with bucket url' do
+    book = S3Book.new cover: "candy.jpg"
+    assert_equal "#{s3_bucket.url}/candy.jpg", book.attachment(:cover).url
+    assert_equal "#{s3_bucket.url}/candy.thumb.gif", book.attachment(:cover).url(:thumb)
+  end
+
+  it 'Has nil URL when field is blank' do
+    book = S3Book.new
+    assert_nil book.attachment(:cover).url
+  end
+
+  it 'Has location root without attachee prefix' do
+    book = S3Book.new
+    refute_match book.attachment(:cover).attachee_prefix, book.attachment(:cover).location_root
+  end
+
+  # Create
+
+  it "Saves attachments on create with variations" do
+    book = S3Book.new
+
+    file = Tempfile.new('foo')
+    file.write('hello')
+    file.rewind
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+    assert_equal 'public/s-3-book/story.txt', field_value
+    assert s3_bucket.object('public/s-3-book/story.txt').exists? 
+    assert s3_bucket.object('public/s-3-book/story.upcase.txt').exists? 
+
+    s3file = s3_bucket.object('public/s-3-book/story.txt')
+    assert_equal 'text/plain', s3file.content_type
+    assert check_if_public_read(s3file)
+    assert_equal 's-3-book', s3file.metadata['parent_collection']
+    assert_equal 'hello', s3file.get.body.read
+
+    vars3file = s3_bucket.object('public/s-3-book/story.upcase.txt')
+    assert_equal 'text/plain', vars3file.content_type
+    assert check_if_public_read(vars3file)
+    assert_equal 's-3-book', vars3file.metadata['parent_collection']
+    assert_equal 'HELLO', vars3file.get.body.read
+
+    file.close
+    file.unlink
+  end
+
+  it "Can override the url_prefix at document class level" do
+    file = Tempfile.new('foo')
+    book = S3BookNoPrefix.new
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+
+    assert_equal 's-3-book-no-prefix/story.txt', field_value
+    assert s3_bucket.object('s-3-book-no-prefix/story.txt').exists? 
+    assert s3_bucket.object('s-3-book-no-prefix/story.upcase.txt').exists? 
+  end
+
+  it "Can override the url_prefix at field level" do
+    file = Tempfile.new('foo')
+    book = S3Book.new
+
+    field_value = book.attachment(:open_content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+
+    assert_equal 'open/s-3-book/story.txt', field_value
+    assert s3_bucket.object('open/s-3-book/story.txt').exists? 
+    assert s3_bucket.object('open/s-3-book/story.upcase.txt').exists? 
+  end
+
+  it 'Does not create 2 files with the same name' do
+    file = Tempfile.new('foo')
+
+    book = S3Book.new
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+
+    assert_equal 'public/s-3-book/story.txt', field_value
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+
+    assert_equal 'public/s-3-book/story-1.txt', field_value
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+
+    assert_equal 'public/s-3-book/story-2.txt', field_value
+
+    file.close
+    file.unlink
+  end
+
+  # Delete
+
+  it 'Is deletable when field is not blank' do
+    book = S3Book.new cover: "candy.jpg"
+    assert book.attachment(:cover).deletable?
+  end
+
+  it 'Is not deletable when field is blank' do
+    book = S3Book.new
+    refute book.attachment(:cover).deletable?
+  end
+
+  it 'Deletes all attachments' do
+    file = Tempfile.new('foo')
+
+    book = S3Book.new
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+    book.content = field_value
+
+    assert s3_bucket.object('public/s-3-book/story.txt').exists? 
+    assert s3_bucket.object('public/s-3-book/story.upcase.txt').exists? 
+
+    book.attachment(:content).delete_all
+
+    refute s3_bucket.object('public/s-3-book/story.txt').exists? 
+    refute s3_bucket.object('public/s-3-book/story.upcase.txt').exists? 
+
+    file.close
+    file.unlink
+  end
+
+  it 'Deletes one attachment at a time' do
+    file = Tempfile.new('foo')
+
+    book = S3Book.new
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+    book.content = field_value
+
+    assert s3_bucket.object('public/s-3-book/story.txt').exists? 
+    assert s3_bucket.object('public/s-3-book/story.upcase.txt').exists? 
+
+    book.attachment(:content).delete
+
+    refute s3_bucket.object('public/s-3-book/story.txt').exists? 
+    assert s3_bucket.object('public/s-3-book/story.upcase.txt').exists? 
+
+    book.attachment(:content).delete :upcase
+
+    refute s3_bucket.object('public/s-3-book/story.upcase.txt').exists? 
+
+    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 = S3Book.new
+
+    field_value = book.attachment(:content).create({
+      tempfile: file,
+      filename: 'story.txt',
+      type: 'text/plain'
+    })
+    book.content = field_value
+
+    assert s3_bucket.object('public/s-3-book/story.txt').exists? 
+    assert s3_bucket.object('public/s-3-book/story.upcase.txt').exists? 
+
+    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
+
+    refute s3_bucket.object('public/s-3-book/story.txt').exists? 
+    refute s3_bucket.object('public/s-3-book/story.upcase.txt').exists? 
+    assert s3_bucket.object('public/s-3-book/history.md').exists? 
+    assert s3_bucket.object('public/s-3-book/history.upcase.txt').exists? 
+
+    s3file = s3_bucket.object('public/s-3-book/history.md')
+    assert_equal 'text/markdown', s3file.content_type
+    assert_equal 's-3-book', s3file.metadata['parent_collection']
+    assert_equal 'world', s3file.get.body.read
+
+    s3file = s3_bucket.object('public/s-3-book/history.upcase.txt')
+    assert_equal 'text/plain', s3file.content_type
+    assert_equal 's-3-book', s3file.metadata['parent_collection']
+    assert_equal 'WORLD', s3file.get.body.read
+
+    file.close
+    file.unlink
+  end
+
+end
+
+s3_bucket.clear!
+