carrierwave-neo4j 2.0.0 → 3.0.0

data/lib/carrierwave/neo4j/version.rb

@@ -1,5 +1,5 @@
 module CarrierWave
   module Neo4j
-    VERSION = "2.0.0"
+    VERSION = '3.0.0'
   end
 end

data/spec/helpers/database_cleaner.rb

@@ -0,0 +1,29 @@
+
+require "neo4j"
+
+class DatabaseCleaner
+  include Neo4j::Migrations::Helpers
+
+  def self.clean
+    DatabaseCleaner.new.clean_db
+  end
+  
+  def self.avoid_validation
+    # migrations and db cleanup have to happen outside of validations
+    # or they never succeed
+    Neo4j::Migrations.currently_running_migrations = true
+    yield
+    Neo4j::Migrations.currently_running_migrations = false
+  end
+
+  def clean_db
+    execute("match (n) detach delete n;")
+    execute("call db.constraints").each do |constraint|
+      execute "drop #{constraint[:description]}"
+    end
+    execute("call db.indexes").each do |index|
+      execute "drop #{index[:description]}"
+    end
+  end
+
+end

data/spec/helpers/fake_book_migration.rb

@@ -0,0 +1,13 @@
+
+require "neo4j"
+
+class FakeBookMigration < Neo4j::Migrations::Base
+
+  def self.create
+    FakeBookMigration.new(:fake_book_migration)
+  end
+
+  def up
+    add_constraint :Book, :uuid, force: true
+  end
+end

data/spec/helpers/fake_migrations.rb

@@ -0,0 +1,12 @@
+
+require 'helpers/fake_schema_migration'
+require 'helpers/fake_user_migration'
+require 'helpers/fake_book_migration'
+
+class FakeMigrations
+  def self.migrate(direction)
+    FakeSchemaMigration.create.migrate(direction)
+    FakeUserMigration.create.migrate(direction)
+    FakeBookMigration.create.migrate(direction)
+  end
+end

data/spec/helpers/fake_schema_migration.rb

@@ -0,0 +1,13 @@
+
+require "neo4j"
+
+class FakeSchemaMigration < Neo4j::Migrations::Base
+
+  def self.create
+    FakeSchemaMigration.new(:fake_schema_migration)
+  end
+
+  def up
+    add_constraint :"Neo4j::Migrations::SchemaMigration", :migration_id, force: true
+  end
+end

data/spec/helpers/fake_user_migration.rb

@@ -0,0 +1,13 @@
+
+require "neo4j"
+
+class FakeUserMigration < Neo4j::Migrations::Base
+
+  def self.create
+    FakeUserMigration.new(:fake_user_migration)
+  end
+
+  def up
+    add_constraint :User, :uuid, force: true
+  end
+end

data/spec/helpers/filesystem_cleaner.rb

@@ -0,0 +1,12 @@
+
+require "neo4j"
+
+class FilesystemCleaner
+  def self.clean
+    FilesystemCleaner.new.clean_fs
+  end
+
+  def clean_fs
+    FileUtils.rm_rf("spec/public/uploads")
+  end
+end

data/spec/neo4j_realistic_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+
+# RealisticUploader and Book exist to provide a basic test harness with
+# standard Ruby code and no metaprogramming of any sort. Because that 
+# stuff is really hard to trust, even when you're sure you got it right.
+
+class RealisticUploader < CarrierWave::Uploader::Base
+  include CarrierWave::MiniMagick
+
+  storage :file
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  def extension_whitelist
+    %w(jpg jpeg gif png)
+  end
+end
+
+class Book
+  include Neo4j::ActiveNode
+  property :cover, type: String
+  mount_uploader :cover, RealisticUploader
+end
+
+describe CarrierWave::Neo4j do
+  after do
+    Book.destroy_all
+  end
+
+  describe "#uploader" do 
+    let(:book) { Book.new }
+    subject { book.cover }
+
+    context "when nothing is assigned" do
+      it { should be_blank }
+    end
+
+    context "when a file is stored to a store_dir" do
+      before do
+        book.cover = File.open(file_path("ong.jpg"))
+        book.save
+        book.reload
+      end
+
+      it { should be_an_instance_of RealisticUploader }
+      its(:current_path) { should == public_path("uploads/book/cover/#{book.id}/ong.jpg") }
+    end
+
+    context "when a db lookup uses `#find`" do
+      before do
+        book.cover = File.open(file_path("ong.jpg"))
+        book.save
+        @found = Book.find(book.id)
+      end
+
+      it "has a basic identifier" do
+        expect(@found.cover_identifier).to eq "ong.jpg"
+      end
+
+      subject { @found.cover }
+
+      it { should be_an_instance_of RealisticUploader }
+      its(:url) { should == "/uploads/book/cover/#{book.id}/ong.jpg"}
+      its(:current_path) { should == public_path("uploads/book/cover/#{book.id}/ong.jpg") }
+    end
+
+    context "when a db look up does not use `#find`" do
+      before do
+        book.cover = File.open(file_path("ong.jpg"))
+        book.save
+        @found = Book.find_by_id(book.id)
+      end
+
+      it "has a basic identifier" do
+        expect(@found.cover_identifier).to eq "ong.jpg"
+      end
+
+      subject { @found.cover }
+
+      # There is no way around this. `#url` and `#current_path` depend on the 
+      # retrieval of the file from the store but there the only callback 
+      # available is `:after_find` which does not fire on `#find_by` queries.
+      it { should be_an_instance_of RealisticUploader }
+      its(:url) { should be_nil }
+      its(:current_path) { should be_nil }
+
+      it "is retrieved with `#reload_from_database!`" do
+        @found.reload_from_database!
+        expect(@found.cover.url).to eq("/uploads/book/cover/#{@found.id}/ong.jpg")
+        expect(@found.cover.current_path).to eq(public_path("uploads/book/cover/#{@found.id}/ong.jpg"))
+      end
+    end
+
+    context "with CarrierWave::MiniMagick" do
+      it "has width and height" do
+        book.cover = File.open(file_path("ong.jpg"))
+        expect(book.cover.width).to eq 273
+        expect(book.cover.height).to eq 273
+      end
+    end
+  end
+end

data/spec/neo4j_sanity_spec.rb

@@ -0,0 +1,137 @@
+require "spec_helper"
+
+# This spec mirrors the specs found in the CarrierWave::Orm::ActiveRecord spec:
+# https://github.com/carrierwaveuploader/carrierwave/blob/master/spec/orm/activerecord_spec.rb
+# 
+# Use it to sanity-check behaviour since ActiveGraph and ActiveRecord are
+# NOT symmetrical.
+
+class DefaultUploader < CarrierWave::Uploader::Base ; end
+
+def reset_class
+  Object.send(:remove_const, "User") rescue nil
+  Object.const_set("User", Class.new())
+  User.class_eval do
+    include Neo4j::ActiveNode
+    property :image, type: String
+    mount_uploader :image, DefaultUploader
+  end
+  User
+end
+
+describe CarrierWave::Neo4j do
+  before do
+    reset_class
+    @user = User.new
+  end
+
+  after do
+    User.destroy_all
+  end
+
+  describe "sanity checks" do
+
+    describe "#mount_uploader" do
+      before do
+        User.mount_uploader(:image, DefaultUploader)
+        @user = User.new
+      end
+
+      it "returns valid JSON when to_json is called when image is nil" do
+        expect(@user[:image]).to be_blank
+        hash = JSON.parse(@user.to_json)
+        expect(hash.keys).to include("user")
+        # ActiveRecord returns the user hash directly but Neo4j's `.to_json`
+        # requires that we select the user hash explicitly
+        user_hash = hash["user"]
+        expect(user_hash.keys).to include("image")
+        expect(user_hash["image"].keys).to include("url")
+        expect(user_hash["image"]["url"]).to be_nil
+      end
+
+      it "returns valid JSON when to_json is called when image is present" do
+        @user.image = File.open(file_path("ong.jpg"))
+        @user.save!
+        @user.reload
+        # again, ActiveRecord does not require the sub-select with `["user"]`
+        expect(JSON.parse(@user.to_json)["user"]["image"]).to eq({"url" => "/uploads/ong.jpg"})
+      end
+
+      it "does not return anything when a stub image is assigned" do
+        # ActiveRecord does permit square bracket assignment to a column
+        # Neo4j does not
+        @user[:image] = 'ong.jpg'
+        @user.save!
+        @user.reload
+        expect(@user.image).to be_blank
+      end
+    end
+
+    describe "#image" do
+    end
+
+    describe "#save" do
+      it "should do nothing when no file has been assigned" do
+        expect(@user.save).to be_truthy
+        expect(@user.image).to be_blank
+      end
+
+      it "should assign the filename to the database" do
+        @user.image = File.open(file_path("ong.jpg"))
+        expect(@user.save).to be_truthy
+        @user.reload
+        # under ActiveRecord these would be equal
+        expect(@user[:image]).not_to eq('ong.jpg')
+        expect(@user[:image].identifier).to eq('ong.jpg')
+        expect(@user.image_identifier).to eq('ong.jpg')
+      end
+    end
+
+    describe "#update" do
+      it "resets cached value on record reload" do
+        @user.image = File.open(file_path("ong.jpg"))
+        @user.save!
+
+        expect(@user.reload.image).to be_present
+
+        other = User.find(@user.id)
+        other.image = nil
+        other.save!
+
+        expect(@user.reload.image).to be_blank
+      end
+
+      it "does not respect `update_column`" do
+        @user.image = File.open(file_path("ong.jpg"))
+        @user.save!
+
+        # ActiveRecord would respect `update_column`
+        User.find(@user.id).update_column(:image, nil)
+
+        expect(@user.reload.image).to be_present
+        other = User.find(@user.id)
+        expect(other.image).to be_present 
+      end
+    end
+
+    describe "#destroy" do
+    end
+
+    describe "#remote_image_url=" do
+      before do
+        stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("ong.jpg")))
+      end
+
+      it "marks image as changed when setting remote_image_url" do
+        expect(@user.image_changed?).to be_falsey
+        @user.remote_image_url = 'http://www.example.com/test.jpg'
+        expect(@user.image_changed?).to be_truthy
+        expect(File.exist?(public_path('uploads/test.jpg'))).to be_falsey
+        @user.save!
+        @user.reload
+        expect(File.exist?(public_path('uploads/test.jpg'))).to be_truthy
+        expect(@user.image_changed?).to be_falsey
+      end
+    end
+  end
+end

data/spec/neo4j_spec.rb

@@ -12,10 +12,10 @@ class User
   property :image, type: String
 end
 
-class DefaultUploader < CarrierWave::Uploader::Base; end
+class DefaultUploader < CarrierWave::Uploader::Base ; end
 
 class PngUploader < CarrierWave::Uploader::Base
-  def extension_white_list
+  def extension_whitelist
     %w(png)
   end
 end
@@ -24,14 +24,21 @@ class ProcessingErrorUploader < CarrierWave::Uploader::Base
   process :end_on_an_era
 
   def end_on_an_era
-    raise CarrierWave::ProcessingError, "Bye Tarja"
+    raise CarrierWave::ProcessingError, "Bye OngDB"
+  end
+end
+
+class DownloadErrorUploader < CarrierWave::Uploader::Base
+  def download!(file, headers = {})
+    raise CarrierWave::DownloadError
   end
 end
 
 describe CarrierWave::Neo4j do
-  let(:user_class)       { reset_class }
-  let(:user_class_png)   { reset_class(PngUploader) }
-  let(:user_class_error) { reset_class(ProcessingErrorUploader) }
+  let(:user_class)          { reset_class }
+  let(:user_class_png)      { reset_class(PngUploader) }
+  let(:user_class_error)    { reset_class(ProcessingErrorUploader) }
+  let(:user_download_error) { reset_class(DownloadErrorUploader) }
   let(:user) { user_class.new }
 
   after do
@@ -39,8 +46,8 @@ describe CarrierWave::Neo4j do
   end
 
   describe "#image" do
-    let(:record) { user_class.new }
-    subject { record.image }
+    let(:user) { user_class.new }
+    subject { user.image }
 
     context "when nothing is assigned" do
       it { should be_blank }
@@ -48,9 +55,9 @@ describe CarrierWave::Neo4j do
 
     context "when an empty string is assigned" do
       before do
-        record.image = ""
-        record.save
-        record.reload
+        user.image = ""
+        user.save
+        user.reload
       end
 
       it { should be_blank }
@@ -58,30 +65,61 @@ describe CarrierWave::Neo4j do
 
     context "when a filename is stored" do
       before do
-        record.image = File.open(file_path("tarja.jpg"))
-        record.save
-        record.reload
+        user.image = File.open(file_path("ong.jpg"))
+        user.save
+        user.reload
       end
 
       it { should be_an_instance_of DefaultUploader }
-      its(:current_path) { should == public_path("uploads/tarja.jpg") }
+      its(:current_path) { should == public_path("uploads/ong.jpg") }
+    end
+
+    context "when a model is retrieved from the db" do
+      before do
+        user.image = File.open(file_path("ong.jpg"))
+        user.save
+        @found = user_class.find(user.uuid)
+      end
+
+      subject { @found.image }
+
+      it "has a basic identifier" do
+        expect(@found.image_identifier).to eq "ong.jpg"
+      end
+
+      it { should be_an_instance_of DefaultUploader }
+      its(:url) { should == "/uploads/ong.jpg"}
+      its(:current_path) { should == public_path("uploads/ong.jpg") }
     end
   end
 
   describe "#save" do
+    context "when image= is assigned and the user is saved" do
+      let(:user) { user_class.new }
+
+      before do
+        user.image = File.open(file_path("ong.jpg"))
+        user.save
+      end
+
+      it "writes the file to disk" do
+        expect(File.exist?(public_path('uploads/ong.jpg'))).to be_truthy
+      end
+    end
+
     context "when remove_image? is true" do
-      let(:record) { user_class.new }
+      let(:user) { user_class.new }
 
       before do
-        record.image = File.open(file_path("tarja.jpg"))
-        record.save
+        user.image = File.open(file_path("ong.jpg"))
+        user.save
 
-        record.remove_image = true
-        record.save
-        record.reload
+        user.remove_image = true
+        user.save
+        user.reload
       end
 
-      subject { record }
+      subject { user }
 
       its(:image) { should be_blank }
     end
@@ -89,7 +127,7 @@ describe CarrierWave::Neo4j do
     context "when validating integrity" do
       subject do
         user = user_class_png.new
-        user.image = File.open(file_path("tarja.jpg"))
+        user.image = File.open(file_path("ong.jpg"))
         user
       end
 
@@ -99,7 +137,17 @@ describe CarrierWave::Neo4j do
     context "when validating processing" do
       subject do
         user = user_class_error.new
-        user.image = File.open(file_path("tarja.jpg"))
+        user.image = File.open(file_path("ong.jpg"))
+        user
+      end
+
+      it { should_not be_valid }
+    end
+
+    context 'when validating download' do
+      subject do
+        user = user_download_error.new
+        user.remote_image_url = 'http://www.example.com/missing.jpg'
         user
       end
 
@@ -107,18 +155,89 @@ describe CarrierWave::Neo4j do
     end
   end
 
+  describe "#update" do
+    let(:user) { user_class.new }
+
+    before do
+      user.image = File.open(file_path("ong.jpg"))
+      user.save
+    end
+
+    it "does not flag the uploader for removal" do
+      user.image = File.open(file_path("neo4j.png"))
+      user.save
+      expect(user.remove_image?).to be_falsey
+    end
+
+    it "stores the updated file" do
+      user.image = File.open(file_path("neo4j.png"))
+      user.save
+      expect(user.image.current_path).to eq public_path('uploads/neo4j.png')
+      expect(user.image.url).to eq '/uploads/neo4j.png'
+    end
+
+    it "writes the updated file to disk" do
+      user.image = File.open(file_path("neo4j.png"))
+      user.save
+      expect(File.exist?(public_path('uploads/neo4j.png'))).to be_truthy
+    end
+  end
+
   describe "#destroy" do
-    let(:record) { user_class.new }
+    let(:user) { user_class.new }
 
     before do
-      record.image = File.open(file_path("tarja.jpg"))
-      record.save
+      user.image = File.open(file_path("ong.jpg"))
+      user.save
     end
 
     it "also destroys the image" do
-      expect { record.destroy }.to change {
-        File.exist? public_path("uploads/tarja.jpg")
+      file_path = user.image.path
+      expect(user.image.current_path).to eq public_path('uploads/ong.jpg')
+      expect { user.destroy }.to change {
+        File.exist? file_path
       }.from(true).to(false)
     end
   end
+
+  describe "#reload_from_database" do
+    context "when used without mutation" do
+      before do
+        user.image = File.open(file_path("ong.jpg"))
+        user.save
+        @reloaded = user.reload_from_database
+      end
+
+      subject { @reloaded.image }
+
+      it "has an id and image identifier" do
+        expect(@reloaded.id).to eq user.id
+        expect(@reloaded.image_identifier).to eq "ong.jpg"
+      end
+
+      it { should be_an_instance_of DefaultUploader }
+      its(:url) { should == "/uploads/ong.jpg"}
+      its(:current_path) { should == public_path("uploads/ong.jpg") }
+    end
+  end
+
+  describe "#reload_from_database!" do
+    context "when used with mutation" do
+      before do
+        user.image = File.open(file_path("ong.jpg"))
+        user.save
+        user.reload_from_database!
+      end
+
+      subject { user.image }
+
+      it "has an image identifier" do
+        expect(user.image_identifier).to eq "ong.jpg"
+      end
+
+      it { should be_an_instance_of DefaultUploader }
+      its(:url) { should == "/uploads/ong.jpg"}
+      its(:current_path) { should == public_path("uploads/ong.jpg") }
+    end
+  end
 end