carrierwave-neo4j 2.0.4 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 91d3e9f15343156db10c1a79b7e94d5767a3c4b4
-  data.tar.gz: 2092abf2bd8f474e25bdd6d6ff9acb2959353eb7
+SHA256:
+  metadata.gz: ee1ece089b8cbd55532f4c0cba7a7a19054b24edc86f81a077c5497c49f4c801
+  data.tar.gz: a8a1b8fb5355129bfb9fd41839b59bbeee38e5808d59cac0a21fcc7ee6291a55
 SHA512:
-  metadata.gz: f2a94567dbb5049112b24f41b4f728d56cd55722ae43f011bb877cdc729a739888460d5171eac7550c8d89e31a7e457c348a0ff074d0878236ada9a38b01a1d6
-  data.tar.gz: 3932cac7fea54e9076f23b60f4bd489ba5e1e92f9eceac46198a87c396219832587e484a91bbebeddcc18e27ed1349392f75f335f118cfff4237bf99f2beeb5e
+  metadata.gz: f2adb7d1d88b7f225d2d89c4bdcae75ada1f4fa3edfc5679cbd0aa034c80d6738bc2990dc9a2527555ae92837edbf9f447fb0ed811c9da133d2613c88019dd45
+  data.tar.gz: e9168769c2f8e656c3e8e1046e5c7d5fbaaec1d53269525557fe50b3f4a77ba08aa0966529cd5835750b4fe57b7b7a85b5e58aea3ac145b151f93e6c451b9a97

data/.gitignore

@@ -6,3 +6,6 @@ db/*
 .idea
 
 .ruby-version
+spec/public/uploads/*
+bin/
+

data/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/) 
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [3.0.0] - 2020-07-15
+
+### Fixed
+
+- Updated and fixed all tests to work with neo4j.rb 9.x and CarrierWave 2.x
+- Updated the overall format of the plugin to mirror CarrierWave::Orm::ActiveRecord as much as possible
+- Files are now deleted correctly on `#destroy`
+- File information is now correctly reloaded on `#find`
+- Thanks @deobald for all the fixes.
+
 ## [2.0.4] - 2018-04-03
 
 ### Fixed

data/Gemfile

@@ -2,10 +2,3 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in carrierwave_neo4j.gemspec
 gemspec
-
-gem 'neo4j',      github: 'neo4jrb/neo4j'
-gem 'neo4j-core', github: 'neo4jrb/neo4j-core'
-#gem 'carrierwave', '0.10.0'
-gem 'pry'
-gem 'rspec-its'
-gem 'database_cleaner', github: 'dpisarewski/database_cleaner', branch: 'neo4j'

data/README.md

@@ -1,21 +1,81 @@
 ## CarrierWave for Neo4j
 
-This gem adds support for Neo4j 3.0+ to CarrierWave, see the CarrierWave documentation for more detailed usage instructions.
+This gem adds support for Neo4j 3.0+ (neo4j.rb 9.6.0+) to CarrierWave 2.1.0+, see the CarrierWave documentation for more detailed usage instructions.
 
 ### Installation Instructions
 
 Add to your Gemfile:
 
 ```ruby
-gem 'carrierwave-neo4j', require: 'carrierwave/neo4j'
+gem 'carrierwave-neo4j', '~> 3.0', require: 'carrierwave/neo4j'
 ```
-Use it like this:
+
+You can see example usage in `spec/neo4j_realistic_spec.rb` but in brief, you can use it like this:
 
 ```ruby
+class AttachmentUploader < CarrierWave::Uploader::Base
+  storage :file
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+end
+
 class Asset
   include Neo4j::ActiveNode
 
   property :attachment, type: String
   mount_uploader :attachment, AttachmentUploader
 end
-```
+```
+
+If you want image manipulation, you will need to install ImageMagick
+
+On Ubuntu:
+
+```sh
+sudo apt-get install imagemagick --fix-missing
+```
+
+On macOS:
+
+```sh
+brew install imagemagick
+```
+
+### Development
+
+```sh
+bundle install
+rake neo4j:install[community-latest,test]
+rake neo4j:start[test]
+rake spec
+```
+
+### Troubleshooting
+
+#### Files are nil
+
+If you aren't getting your files back after querying a record from Neo4j, be aware that this will only happen automatically for the `Model#find` method. For all other finders (`#all`, `#first`, `#find_by`, `#find_by_*`, `#find_by_*!`, `#last`) you will need to force a reload so the model sees the file. For example:
+
+```ruby
+users = User.all
+users.each(&:reload_from_database!)
+```
+
+Sorry, this sucks. But this is a limitation of Neo4j.rb as these other finders don't fire any callbacks.
+
+#### binstubs (particularly `bin/rspec`) seem broken
+
+If you're getting some infinite recursion when you run the specs that ultimately results in an error like:
+
+```
+`ensure in require': CRITICAL: RUBYGEMS_ACTIVATION_MONITOR.owned?: before false -> after true (RuntimeError)
+```
+
+You may want to try:
+
+```sh
+rm .bundle/config
+bundle install
+```

data/Rakefile

@@ -1 +1,12 @@
 require 'bundler/gem_tasks'
+require 'neo4j/rake_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+  puts "RSpec not installed...?"
+end

data/carrierwave-neo4j.gemspec

@@ -7,19 +7,21 @@ Gem::Specification.new do |s|
   s.version     = CarrierWave::Neo4j::VERSION
   s.authors     = ["Rodrigo Navarro"]
   s.email       = ["navarro@manapot.com.br"]
-  s.homepage    = "https://github.com/reu/carrierwave-neo4j"
+  s.homepage    = "https://github.com/neo4jrb/carrierwave-neo4j"
   s.summary     = %q{Neo4j support for Carrierwave}
   s.description = %q{Neo4j support for Carrierwave}
 
-  s.rubyforge_project = "carrierwave_neo4j"
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {spec}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency("activesupport", ">= 3.0" )
-  s.add_dependency("neo4j", ">= 3.0.0")
-  s.add_dependency("carrierwave", ">= 0.5")
-  s.add_development_dependency("rspec", "~> 2.0")
+  s.add_dependency("activesupport", ">= 6.0" )
+  s.add_dependency("neo4j", "~> 9.6.0")
+  s.add_dependency("carrierwave", ">= 2.1")
+  s.add_development_dependency("rspec", "~> 3.0")
+  s.add_development_dependency("rspec-its")
+  s.add_development_dependency("webmock")
+  s.add_development_dependency("neo4j-rake_tasks")
+  s.add_development_dependency("rake")
 end

data/lib/carrierwave/neo4j.rb

@@ -5,69 +5,143 @@ require "carrierwave/validations/active_model"
 require "carrierwave/neo4j/uploader_converter"
 require "active_support/concern"
 
+######
+# This file attempts to maintain symmetry with:
+# https://github.com/carrierwaveuploader/carrierwave/blob/master/lib/carrierwave/orm/activerecord.rb
+# 
+# Behaviours linked to callbacks (ex. `after_save :"store_#{column}!"`) belong to:
+# https://github.com/carrierwaveuploader/carrierwave/blob/master/lib/carrierwave/mount.rb
+# ...which is mixed into Model classes.
+######
 module CarrierWave
   module Neo4j
-    extend ActiveSupport::Concern
 
+    # this class methods junk is necessary because ActiveNode is implemented as
+    # a model instead of a class for god-knows-what-reason.
+    extend ActiveSupport::Concern
     module ClassMethods
+
       include CarrierWave::Mount
+
       ##
       # See +CarrierWave::Mount#mount_uploader+ for documentation
       #
-      def mount_uploader(column, uploader = nil, options = {}, &block)
+      def mount_uploader(column, uploader=nil, options={}, &block)
         super
 
+        mod = Module.new
+        prepend mod
+        mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+          def remote_#{column}_url=(url)
+            column = _mounter(:#{column}).serialization_column
+            __send__(:"\#{column}_will_change!")
+            super
+          end
+        RUBY
+      end
+
+      ##
+      # See +CarrierWave::Mount#mount_uploaders+ for documentation
+      #
+      def mount_uploaders(column, uploader=nil, options={}, &block)
+        super
+
+        mod = Module.new
+        prepend mod
+        mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+          def remote_#{column}_urls=(url)
+            column = _mounter(:#{column}).serialization_column
+            __send__(:"\#{column}_will_change!")
+            super
+          end
+        RUBY
+      end
+
+      def add_reload_callback(method)
+        @_reload_callbacks = [] unless @_reload_callbacks
+        @_reload_callbacks << method unless @_reload_callbacks.include?(method)
+      end
+
+      def reload_callbacks
+        @_reload_callbacks
+      end
+
+    private
+
+      def mount_base(column, uploader=nil, options={}, &block)
+        super
+
+        # this seems necessary to prevent the _identifier from including
+        # the entire path ('img.jpg' vs. '/uploads/user/image/img.jpg')
         serialize column, ::CarrierWave::Uploader::Base
 
         include CarrierWave::Validations::ActiveModel
 
-        validates_integrity_of  column if uploader_option(column.to_sym, :validate_integrity)
+        validates_integrity_of column if uploader_option(column.to_sym, :validate_integrity)
         validates_processing_of column if uploader_option(column.to_sym, :validate_processing)
+        validates_download_of column if uploader_option(column.to_sym, :validate_download)
+
+        # carrierwave keeps a instance variable of @uploaders, cached at init time
+        # but at init time, the value of the column is not yet available
+        # so after init, the empty @uploaders cache must be invalidated
+        # it will reinitialized with the processed column value on first access
+        after_initialize :_set_uploaders_nil
 
-        after_save :"store_#{column}!"
         before_save :"write_#{column}_identifier"
-        before_destroy :"clear_#{column}"
+        after_save :"store_#{column}!"
+        # this 'after_update' hook doesn't seem necessary, but please 
+        # don't remove it just in case it ever becomes necessary:
+        after_update :"mark_remove_#{column}_false"
         after_destroy :"remove_#{column}!"
+        after_find :"force_retrieve_#{column}"
+
+        add_reload_callback :"force_retrieve_#{column}"
+
+        # TRYING THIS OUT FROM MONGOID:
+        # TODO: copy the other mongoid adapter code over
+        # https://github.com/carrierwaveuploader/carrierwave-mongoid/blob/master/lib/carrierwave/mongoid.rb
+        before_update :"store_previous_changes_for_#{column}"
+        after_save :"remove_previously_stored_#{column}"
 
         class_eval <<-RUBY, __FILE__, __LINE__+1
-        def #{column}=(new_file)
-          column = _mounter(:#{column}).serialization_column
-          send(:attribute_will_change!, :#{column})
-          super
-        end
-
-        def remote_#{column}_url=(url)
-          column = _mounter(:#{column}).serialization_column
-          send(:attribute_will_change!, :#{column})
-          super
-        end
-
-        def clear_#{column}
-          write_uploader(_mounter(:#{column}).serialization_column, nil)
-        end
-
-        def read_uploader(name)
-          send(:attribute, name.to_s)
-        end
-
-        def write_uploader(name, value)
-          send(:attribute=, name.to_s, value)
-        end
-
-        def reload_from_database
-          if reloaded = self.class.load_entity(neo_id)
-            send(:attributes=, reloaded.attributes.reject{ |k,v| v.is_a?(::CarrierWave::Uploader::Base) })
+
+          # def remote_#{column}_url=(url) is defined in 'mount_uploader'
+
+          def #{column}=(new_file)
+            column = _mounter(:#{column}).serialization_column
+            if !(new_file.blank? && __send__(:#{column}).blank?)
+              __send__(:"\#{column}_will_change!")
+            end
+            super
           end
-          reloaded
-        end
 
-        # carrierwave keeps a instance variable of @uploaders, cached at init time
-        # but at init time, the value of the column is not yet available
-        # so after init, the empty @uploaders cache must be invalidated
-        # it will reinitialized with the processed column value on first access
-        unless method_defined?(:_set_uploaders_nil)
+          def remove_#{column}=(value)
+            column = _mounter(:#{column}).serialization_column
+            result = super
+            __send__(:"\#{column}_will_change!") if _mounter(:#{column}).remove?
+            result
+          end
 
-          after_initialize :_set_uploaders_nil
+          def remove_#{column}!
+            self.remove_#{column} = true
+            write_#{column}_identifier
+            self.remove_#{column} = false
+            super
+          end
+
+          # Reset cached mounter on record reload
+          def reload(*)
+            _set_uploaders_nil
+            @_mounters = nil
+            super
+          end
+
+          # Reset cached mounter on record dup
+          def initialize_dup(other)
+            _set_uploaders_nil
+            @_mounters = nil
+            super
+          end
 
           def _set_uploaders_nil
             if @_mounters
@@ -76,12 +150,62 @@ module CarrierWave
               end
             end
           end
-        end
+
+          def _force_uploaders_reload
+            @_mounters.each do |_, mounter|
+              mounter.send(:uploaders)
+            end
+          end
+
+          # okay, this actually works:
+          def force_retrieve_#{column}
+            send(:#{column}).send(:retrieve_from_store!, #{column}_identifier)
+          end
+
+          # these produce an infinite loop, so... don't reintroduce them:
+          # alias_method :read_uploader, :read_attribute
+          # alias_method :write_uploader, :write_attribute
+          # public :read_uploader
+          # public :write_uploader
+          
+          def read_uploader(name)
+            send(:attribute, name.to_s)
+          end
+
+          def write_uploader(name, value)
+            send(:attribute=, name.to_s, value)
+          end
+
+          def reload_from_database
+            if reloaded = self.class.load_entity(neo_id)
+              self.class.reload_callbacks.each { |m| reloaded.send(m) }
+            end
+            reloaded
+          end
+
+          def reload_from_database!
+            if reloaded = self.class.load_entity(neo_id)
+              send(:attributes=, reloaded.attributes)
+              self.class.reload_callbacks.each { |m| send(m) }
+            end
+            self
+          end
+
+          # MONGOID:
+          # CarrierWave 1.1 references ::ActiveRecord constant directly which
+          # will fail in projects without ActiveRecord. We need to overwrite this
+          # method to avoid it.
+          # See https://github.com/carrierwaveuploader/carrierwave/blob/07dc4d7bd7806ab4b963cf8acbad73d97cdfe74e/lib/carrierwave/mount.rb#L189
+          def store_previous_changes_for_#{column}
+            @_previous_changes_for_#{column} = changes[_mounter(:#{column}).serialization_column]
+          end
+
         RUBY
       end
-    end
 
+
+    end
   end
 end
 
-Neo4j::ActiveNode.send :include, CarrierWave::Neo4j
+Neo4j::ActiveNode.include CarrierWave::Neo4j

data/lib/carrierwave/neo4j/uploader_converter.rb

@@ -7,7 +7,11 @@ module CarrierWave::Neo4j
         end
 
         def to_db(value)
-          value.identifier
+          if value.is_a?(Array)
+            value.map(&:identifier)
+          else
+            value.identifier
+          end
         end
 
         def to_ruby(value)

data/lib/carrierwave/neo4j/version.rb

@@ -1,5 +1,5 @@
 module CarrierWave
   module Neo4j
-    VERSION = '2.0.4'
+    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,19 +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
-      file_path = record.image.path
-      expect { record.destroy }.to change {
+      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

data/spec/spec_helper.rb

@@ -1,11 +1,18 @@
 require "rubygems"
 require "bundler/setup"
+require "rake"
 require "rspec"
 require "rspec/its"
+require "webmock/rspec"
+
+require "neo4j"
+require "neo4j/core/cypher_session/adaptors/bolt"
+require "helpers/database_cleaner"
+require "helpers/filesystem_cleaner"
+require "helpers/fake_migrations"
 
 require "carrierwave"
 require "carrierwave/neo4j"
-require "database_cleaner"
 
 def file_path(*paths)
   File.expand_path(File.join(File.dirname(__FILE__), "fixtures", *paths))
@@ -15,16 +22,26 @@ def public_path(*paths)
   File.expand_path(File.join(File.dirname(__FILE__), "public", *paths))
 end
 
+def tmp_path( *paths )
+  File.expand_path(File.join(File.dirname(__FILE__), 'public/uploads/tmp', *paths))
+end
+
 CarrierWave.root = public_path
-DatabaseCleaner[:neo4j, connection: {type: :server_db, path: 'http://localhost:7475'}].strategy = :transaction
+# DatabaseCleaner[:neo4j, connection: {type: :bolt, path: 'bolt://localhost:7006'}].strategy = :transaction
+
+neo4j_adaptor = Neo4j::Core::CypherSession::Adaptors::Bolt.new('bolt://localhost:7472', {ssl: false})
+Neo4j::ActiveBase.on_establish_session { Neo4j::Core::CypherSession.new(neo4j_adaptor) }
 
 RSpec.configure do |config|
   config.before(:each) do
-    DatabaseCleaner.start
+    DatabaseCleaner.avoid_validation do 
+      DatabaseCleaner.clean
+      FilesystemCleaner.clean
+      FakeMigrations.migrate(:up)
+    end
   end
 
   config.after(:each) do
-    DatabaseCleaner.clean
+    DatabaseCleaner.avoid_validation { DatabaseCleaner.clean }
   end
 end
-

metadata

@@ -1,71 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: carrierwave-neo4j
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 3.0.0
 platform: ruby
 authors:
 - Rodrigo Navarro
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-04-04 00:00:00.000000000 Z
+date: 2020-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
+        version: '6.0'
+  name: activesupport
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.6.0
   name: neo4j
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.6.0
+- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '2.1'
+  name: carrierwave
+  prerelease: false
   type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec-its
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: carrierwave
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :runtime
+        version: '0'
+  name: webmock
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
+  name: neo4j-rake_tasks
+  prerelease: false
   type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rake
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
 description: Neo4j support for Carrierwave
 email:
 - navarro@manapot.com.br
@@ -85,13 +141,22 @@ files:
 - lib/carrierwave/neo4j.rb
 - lib/carrierwave/neo4j/uploader_converter.rb
 - lib/carrierwave/neo4j/version.rb
-- spec/fixtures/tarja.jpg
+- spec/fixtures/neo4j.png
+- spec/fixtures/ong.jpg
+- spec/helpers/database_cleaner.rb
+- spec/helpers/fake_book_migration.rb
+- spec/helpers/fake_migrations.rb
+- spec/helpers/fake_schema_migration.rb
+- spec/helpers/fake_user_migration.rb
+- spec/helpers/filesystem_cleaner.rb
+- spec/neo4j_realistic_spec.rb
+- spec/neo4j_sanity_spec.rb
 - spec/neo4j_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/reu/carrierwave-neo4j
+homepage: https://github.com/neo4jrb/carrierwave-neo4j
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -106,9 +171,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: carrierwave_neo4j
-rubygems_version: 2.6.13
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.7.10
+signing_key:
 specification_version: 4
 summary: Neo4j support for Carrierwave
 test_files: []