activestorage-memory 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 768576d7f8ddab4a37c7d7926ff3ac799328f45030481cede0b0a58ea2e53d95
-  data.tar.gz: 0af1f72600a0f6ba8b72448f5e2375d6439b5398235d9f9f4a0a9ec9d86cbdf6
+  metadata.gz: 83bd480b89220732381633492509732f10f905c5861e76078c4c6e6daba5538c
+  data.tar.gz: 16d37bbbe47843e3681d58145a0d994ea4aa7691084b4fba430d8dbe8dee3a98
 SHA512:
-  metadata.gz: 0bc9b5759bf76f16ecb8d52f29b8a1daacdb32464030d1e9529d49629f6ef7a1ba177172608738d578df792a99027ac24cf657994e44c2b45df557f8fd4451e3
-  data.tar.gz: afdccf65c826b80d12b322aafc364b602afd702e5527d6aa14be40628f81fc109bbf676dd8293bdcc16309e83366b723fb3fc1e7d2b70b580a545af522493063
+  metadata.gz: d1054af1c3c162d07abba56c9cfd3ff6a6ad1338873647171bd4361148563615d56780e2a76ee35d1bca8dee686c0c7f2c871310dca59c8ebfe3bdad4228e13d
+  data.tar.gz: fe03e7402ead1314a7666b4eb15622547cebda2a3103c774b6a3ca2d8655337d1d628c112c2b465a6ca7275088cf5d7f2a96f3c55e7326c00f794d47b4bd6ae7

data/README.md

@@ -34,11 +34,20 @@ To use the Memory service in test, you add the following to config/environments/
 config.active_storage.service = :memory
 ```
 
-In Active Storage's analyzer feature, asynchronous jobs are executed. So it is recommended to set the queue adapter to async for test.
+In Active Storage's analyzer feature, asynchronous jobs are executed. So you should set the queue adapter to inline at config/environments/test.
 ```
-  config.active_job.queue_adapter = :async
+  config.active_job.queue_adapter = :inline
 ```
 
+If you are conducting file downloads and uploads during system testing or integration testing, please add the following to the routing.
+
+``` config/routes.rb
+
+  mount ActiveStorage::Memory::Engine => "/" if Rails.env.test?
+
+```
+
+
 You can read more about Active Storage in the Active Storage Overview guide.
 
 

data/app/controllers/activestorage/memory/memory_controller.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Activestorage::Memory
+  class MemoryController < ActiveStorage::BaseController
+    skip_forgery_protection
+
+    def show
+      key = decode_verified_key
+
+      unless key
+        head :not_found
+        return
+      end
+
+      service = named_memory_service(key[:service_name])
+      if service.exist?(key[:key])
+        send_data(service.store[key[:key]], content_type: key[:content_type], disposition: key[:disposition])
+      else
+        head :not_found
+      end
+    end
+
+    def update
+      token = decode_verified_token
+
+      unless token
+        head :not_found
+        return
+      end
+
+      unless acceptable_content?(token)
+        head :unprocessable_entity
+        return
+      end
+
+      named_memory_service(token[:service_name]).upload token[:key], request.body, checksum: token[:checksum]
+      head :no_content
+    end
+
+    private
+
+    def named_memory_service(name)
+      ActiveStorage::Blob.services.fetch(name) do
+        ActiveStorage::Blob.service
+      end
+    end
+
+    def decode_verified_key
+      ActiveStorage.verifier.verified(params[:encoded_key], purpose: :blob_key)&.deep_symbolize_keys
+    end
+
+    def decode_verified_token
+      ActiveStorage.verifier.verified(params[:encoded_token], purpose: :blob_token)&.deep_symbolize_keys
+    end
+
+    def acceptable_content?(token)
+      token[:content_type] == request.content_mime_type.to_s && token[:content_length] == request.content_length
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,6 @@
+Activestorage::Memory::Engine.routes.draw do
+  scope ActiveStorage.routes_prefix do
+    get '/memory/:encoded_key/*filename' => 'memory#show', as: :rails_memory_service
+    put '/memory/:encoded_token' => 'memory#update', as: :update_rails_memory_service
+  end
+end

data/lib/active_storage/service/memory_service.rb

@@ -11,9 +11,10 @@ module ActiveStorage
       @config = config
     end
 
-    def upload(key, io, **)
+    def upload(key, io, checksum: nil, **)
       instrument(:upload, key: key) do
         store[key] = io.read
+        ensure_integrity_of(key, checksum) if checksum
       end
     end
 
@@ -41,6 +42,14 @@ module ActiveStorage
       end
     end
 
+    def delete_prefixed(prefix)
+      instrument :delete_prefixed, prefix: prefix do
+        store.each_keys do |key|
+          store.delete(key) if key.start_with?(prefix)
+        end
+      end
+    end
+
     def exist?(key)
       instrument(:exist, key: key) do |payload|
         answer = store.key?(key)
@@ -49,13 +58,28 @@ module ActiveStorage
       end
     end
 
-    def url(key)
-      instrument(:url, key: key) do
-        # FIXME: - this should be a URL that can be used to directly download the file
-        "memory://#{key}"
+    def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:, **)
+      instrument :url, key: key do |payload|
+        verified_token_with_expiration = generate_verified_token(
+          key,
+          expires_in: expires_in,
+          content_type: content_type,
+          content_length: content_length,
+          checksum: checksum
+        )
+        url_helpers.update_rails_memory_service_url(
+          verified_token_with_expiration,
+          url_options
+        ).tap do |generated_url|
+          payload[:url] = generated_url
+        end
       end
     end
 
+    def headers_for_direct_upload(_key, content_type:, **)
+      { 'Content-Type' => content_type }
+    end
+
     private
 
     def stream(key)
@@ -66,5 +90,62 @@ module ActiveStorage
     rescue KeyError
       raise ActiveStorage::FileNotFoundError
     end
+
+    def url_helpers
+      @url_helpers ||= Activestorage::Memory::Engine.routes.url_helpers
+    end
+
+    def generate_verified_token(key, expires_in:, content_type:, content_length:, checksum:)
+      ActiveStorage.verifier.generate(
+        {
+          key: key,
+          content_type: content_type,
+          content_length: content_length,
+          checksum: checksum,
+          service_name: name
+        },
+        expires_in: expires_in,
+        purpose: :blob_token
+      )
+    end
+
+    def private_url(key, expires_in:, filename:, content_type:, disposition: :inline, **)
+      generate_url(key, expires_in: expires_in, filename: filename, content_type: content_type, disposition: disposition)
+    end
+
+    def public_url(key, filename:, content_type: nil, disposition: :attachment, **)
+      generate_url(key, expires_in: nil, filename: filename, content_type: content_type, disposition: disposition)
+    end
+
+    def generate_url(key, expires_in:, filename:, content_type:, disposition:)
+      content_disposition = content_disposition_with(type: disposition, filename: ActiveStorage::Filename.wrap(filename))
+      verified_key_with_expiration = ActiveStorage.verifier.generate(
+        {
+          key: key,
+          disposition: content_disposition,
+          content_type: content_type,
+          service_name: name
+        },
+        expires_in: expires_in,
+        purpose: :blob_key
+      )
+
+      if url_options.blank?
+        raise ArgumentError, "Cannot generate URL for #{filename} using Memory service, please set ActiveStorage::Current.url_options."
+      end
+
+      url_helpers.rails_memory_service_url(verified_key_with_expiration, filename: filename, **url_options)
+    end
+
+    def url_options
+      ActiveStorage::Current.url_options || Rails.application.default_url_options
+    end
+
+    def ensure_integrity_of(key, checksum)
+      return if OpenSSL::Digest.new('md5', store[key]).base64digest == checksum
+
+      delete key
+      raise ActiveStorage::IntegrityError
+    end
   end
 end

data/lib/activestorage/memory/engine.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Activestorage::Memory
+  class Engine < ::Rails::Engine
+    isolate_namespace Activestorage::Memory
+  end
+end

data/lib/{active_storage → activestorage}/memory/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module ActiveStorage
+module Activestorage
   module Memory
-    VERSION = '0.1.1'
+    VERSION = '0.2.1'
   end
 end

data/lib/{active_storage → activestorage}/memory.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "memory/version"
+require_relative 'memory/version'
+require_relative 'memory/engine'
 
 module Activestorage
   module Memory

data/spec/active_storage/service/memory_service_spec.rb

@@ -0,0 +1,99 @@
+require 'rails_helper'
+
+RSpec.describe ActiveStorage::Service::MemoryService do
+  let(:service) { ActiveStorage::Service::MemoryService.new }
+  let(:content) { 'content' }
+  let(:io) { StringIO.new(content) }
+  let(:key) { 'key' }
+  let(:host) { 'example.com' }
+
+  before do
+    ActiveStorage::Current.url_options = { host: host }
+  end
+
+  describe '#upload' do
+    it 'stores by key' do
+      service.upload(key, io)
+      expect(service.store[key]).to eq(content)
+    end
+  end
+
+  describe '#download' do
+    context 'when key does not exist' do
+      it 'raises ActiveStorage::FileNotFoundError' do
+        expect { service.download(key) }.to raise_error(ActiveStorage::FileNotFoundError)
+      end
+    end
+
+    context 'when key exists' do
+      before do
+        service.upload(key, io)
+      end
+      it 'retrieves by key' do
+        expect(service.download(key).read).to eq(content)
+      end
+    end
+  end
+
+  describe '#delete' do
+    context 'when key does not exist' do
+      it 'ignores key errors' do
+        expect { service.delete(key) }.not_to raise_error
+      end
+    end
+
+    context 'when key exists' do
+      before do
+        service.upload(key, io)
+      end
+
+      it 'deletes by key' do
+        service.delete(key)
+        expect(service.store).not_to have_key(key)
+      end
+    end
+  end
+
+  describe '#exist?' do
+    context 'when key does not exist' do
+      it 'returns false' do
+        expect(service.exist?(key)).to be false
+      end
+    end
+
+    context 'when key exists' do
+      before do
+        service.upload(key, io)
+      end
+
+      it 'checks by key' do
+        expect(service.exist?(key)).to be true
+      end
+    end
+  end
+
+  describe '#url_for_direct_upload' do
+    let(:filename) { 'filename' }
+    let(:content_type) { 'image/jpeg' }
+    let(:content_length) { content.size }
+    let(:checksum) { OpenSSL::Digest.new('md5', content).base64digest }
+    let(:service_name) { 'memory' }
+    let(:expires_in) { 5.minutes }
+
+    before do
+      service.upload(key, io)
+    end
+
+    it 'returns a memory url' do
+      expect(service.url(key, expires_in: expires_in, filename: filename, content_type: content_type)).to start_with("http://#{host}/")
+    end
+  end
+
+  describe '#headers_for_direct_upload' do
+    let(:content_type) { 'image/jpeg' }
+
+    it 'returns content type' do
+      expect(service.headers_for_direct_upload(key, content_type: content_type)).to eq('Content-Type' => content_type)
+    end
+  end
+end

data/spec/activestorage/memory_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Activestorage::Memory do
+  it "has a version number" do
+    expect(Activestorage::Memory::VERSION).not_to be nil
+  end
+end

data/spec/controllers/activestorage/memory/memory_controller_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Activestorage::Memory::MemoryController, type: :request do
+  let(:key) { 'file_key' }
+  let(:content) { 'content' }
+  let(:filename) { 'file.jpg' }
+  let(:content_type) { 'image/jpeg' }
+  let(:service_name) { :memory }
+  let(:disposition) { "inline; filename=\"file.jpg\"; filename*=UTF-8''file.jpg" }
+  let(:expires_in) { ActiveStorage.service_urls_expire_in }
+  let(:checksum) { OpenSSL::Digest.new('md5', content).base64digest }
+  let!(:blob) do
+    ActiveStorage::Blob.create_and_upload!(
+      key: key,
+      io: StringIO.new(content),
+      filename: filename,
+      content_type: content_type,
+      service_name: service_name
+    )
+  end
+
+  before do
+    ActiveStorage::Current.url_options = { only_path: true }
+  end
+
+  describe "GET #show" do
+    let(:valid_key) do
+      ActiveStorage.verifier.generate(
+        {
+          key: key,
+          service_name: service_name,
+          content_type: content_type,
+          disposition: disposition
+        },
+        expires_in: expires_in,
+        purpose: :blob_key
+      )
+    end
+    let(:invalid_key) { 'invalid_key' }
+
+    subject { get "/rails/active_storage/memory/#{valid_key}/#{filename}" }
+
+    context "when key is valid" do
+      it "returns http success if key is valid and file exists" do
+        subject
+        expect(response).to have_http_status(:success)
+        expect(response.body).to eq(content)
+      end
+
+      context "when file does not exist" do
+        before do
+          ActiveStorage::Blob.services.fetch(service_name).delete(key)
+        end
+
+        it "returns http not_found" do
+          subject
+          expect(response).to have_http_status(:not_found)
+        end
+      end
+    end
+
+    context "when key is invalid" do
+      subject { get "/rails/active_storage/memory/#{invalid_key}/#{filename}" }
+
+      it "returns http not_found" do
+        subject
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+  end
+
+  describe "PATCH #update" do
+    let(:valid_token) do
+      ActiveStorage.verifier.generate(
+        {
+          key: key,
+          service_name: service_name,
+          checksum: checksum,
+          content_type: content_type,
+          content_length: content.length
+        },
+        purpose: :blob_token
+      )
+    end
+    let(:invalid_token) { 'invalid_token' }
+
+    context "when token is valid" do
+      context "when content is acceptable" do
+        subject do
+          put(
+            "/rails/active_storage/memory/#{valid_token}",
+            params: content,
+            headers: { 'Content-Type' => content_type, 'Content-Length' => content.size }
+          )
+        end
+
+        it "returns http no_content if token is valid and content is acceptable" do
+          subject
+          expect(response).to have_http_status(:no_content)
+        end
+      end
+
+      context "when content is not acceptable" do
+        subject do
+          put(
+            "/rails/active_storage/memory/#{valid_token}",
+            params: content,
+            headers: { 'Content-Type' => "image/png", 'Content-Length' => content.size }
+          )
+        end
+
+        it "returns http unprocessable_entity" do
+          subject
+          expect(response).to have_http_status(:unprocessable_entity)
+        end
+      end
+    end
+
+    context "when token is invalid" do
+      subject do
+        put(
+          "/rails/active_storage/memory/#{invalid_token}",
+          params: content,
+          headers: { 'Content-Type' => content_type, 'Content-Length' => content.size }
+        )
+      end
+
+      it "returns http not_found" do
+        subject
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+  end
+end

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../stylesheets .css
+//= link my_engine_manifest.js

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/spec/dummy/app/channels/application_cable/channel.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

data/spec/dummy/app/channels/application_cable/connection.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/jobs/application_job.rb

@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/spec/dummy/app/mailers/application_mailer.rb

@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
+end

data/spec/dummy/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Dummy</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <%= stylesheet_link_tag "application" %>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/spec/dummy/app/views/layouts/mailer.html.erb

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/spec/dummy/app/views/layouts/mailer.text.erb

@@ -0,0 +1 @@
+<%= yield %>

data/spec/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"

data/spec/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run

data/spec/dummy/bin/setup

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require "fileutils"
+
+# path to your application root.
+APP_ROOT = File.expand_path("..", __dir__)
+
+def system!(*args)
+  system(*args, exception: true)
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts "== Installing dependencies =="
+  system! "gem install bundler --conservative"
+  system("bundle check") || system!("bundle install")
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   FileUtils.cp "config/database.yml.sample", "config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system! "bin/rails db:prepare"
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! "bin/rails log:clear tmp:clear"
+
+  puts "\n== Restarting application server =="
+  system! "bin/rails restart"
+end