copy_tuner_client 2.1.2 → 2.2.1

data/spec/copy_tuner_client/poller_spec.rb

@@ -1,33 +1,32 @@
 require 'spec_helper'
 
 describe CopyTunerClient::Poller do
-  POLLING_DELAY = 0.5
-
   let(:client) { FakeClient.new }
-  let(:cache) { CopyTunerClient::Cache.new(client, :logger => FakeLogger.new) }
+  let(:cache) { CopyTunerClient::Cache.new(client, logger: FakeLogger.new) }
+  let!(:pollers) { [] }
+
+  def polling_delay
+    0.5
+  end
 
   def build_poller(config = {})
     config[:logger] ||= FakeLogger.new
-    config[:polling_delay] = POLLING_DELAY
+    config[:polling_delay] = polling_delay
     default_config = CopyTunerClient::Configuration.new.to_hash
     poller = CopyTunerClient::Poller.new(cache, default_config.update(config))
-    @pollers << poller
+    pollers << poller
     poller
   end
 
   def wait_for_next_sync
-    sleep(POLLING_DELAY * 3)
-  end
-
-  before do
-    @pollers = []
+    sleep(polling_delay * 3)
   end
 
   after do
-    @pollers.each { |poller| poller.stop }
+    pollers.each(&:stop)
   end
 
-  it "it polls after being started" do
+  it 'polls after being started' do
     poller = build_poller
     poller.start
 
@@ -37,8 +36,8 @@ describe CopyTunerClient::Poller do
     expect(cache['test.key']).to eq('value')
   end
 
-  it "it doesn't poll before being started" do
-    poller = build_poller
+  it "doesn't poll before being started" do
+    build_poller
     client['test.key'] = 'value'
 
     wait_for_next_sync
@@ -46,7 +45,7 @@ describe CopyTunerClient::Poller do
     expect(cache['test.key']).to be_nil
   end
 
-  it "stops polling when stopped" do
+  it 'stops polling when stopped' do
     poller = build_poller
 
     poller.start
@@ -58,12 +57,12 @@ describe CopyTunerClient::Poller do
     expect(cache['test.key']).to be_nil
   end
 
-  it "stops polling with an invalid api key" do
-    failure = "server is napping"
+  it 'stops polling with an invalid api key' do
+    failure = 'server is napping'
     logger = FakeLogger.new
 
-    expect(cache).to receive(:download).and_raise(CopyTunerClient::InvalidApiKey.new(failure))
-    poller = build_poller(:logger => logger)
+    allow(cache).to receive(:download).and_raise(CopyTunerClient::InvalidApiKey.new(failure))
+    poller = build_poller(logger:)
 
     cache['upload.key'] = 'upload'
     poller.start
@@ -78,20 +77,22 @@ describe CopyTunerClient::Poller do
   end
 
   it "logs an error if the background thread can't start" do
-    expect(Thread).to receive(:new).and_return(nil)
+    allow(Thread).to receive(:new).and_return(nil)
     logger = FakeLogger.new
 
-    build_poller(:logger => logger).start
+    build_poller(logger:).start
 
     expect(logger).to have_entry(:error, "Couldn't start poller thread")
   end
 
-  it "flushes the log when polling" do
+  it 'flushes the log when polling' do
     logger = FakeLogger.new
-    expect(logger).to receive(:flush).at_least(:once)
+    allow(logger).to receive(:flush)
 
-    build_poller(:logger => logger).start
+    build_poller(logger:).start
 
     wait_for_next_sync
+
+    expect(logger).to have_received(:flush).at_least(:once)
   end
 end

data/spec/copy_tuner_client/prefixed_logger_spec.rb

@@ -1,35 +1,38 @@
 require 'spec_helper'
 
 describe CopyTunerClient::PrefixedLogger do
+  subject(:prefixed_logger) { described_class.new(prefix, output_logger) }
+
   let(:output_logger) { FakeLogger.new }
-  let(:prefix) { "** NOTICE:" }
+  let(:prefix) { '** NOTICE:' }
   let(:thread_info) { "[P:#{Process.pid}] [T:#{Thread.current.object_id}]" }
-  subject { CopyTunerClient::PrefixedLogger.new(prefix, output_logger) }
 
-  it "provides the prefix" do
-    expect(subject.prefix).to eq(prefix)
+  it 'provides the prefix' do
+    expect(prefixed_logger.prefix).to eq(prefix)
   end
 
-  it "provides the logger" do
-    expect(subject.original_logger).to eq(output_logger)
+  it 'provides the logger' do
+    expect(prefixed_logger.original_logger).to eq(output_logger)
   end
 
-  [:debug, :info, :warn, :error, :fatal].each do |level|
+  %i[debug info warn error fatal].each do |level|
     it "prefixes #{level} log messages" do
       message = 'hello'
-      subject.send(level, message)
+      prefixed_logger.public_send(level, message)
 
       expect(output_logger).to have_entry(level, "#{prefix} #{thread_info} #{message}")
     end
   end
 
-  it "calls flush for a logger that responds to flush" do
-    expect(output_logger).to receive(:flush)
+  it 'calls flush for a logger that responds to flush' do
+    allow(output_logger).to receive(:flush)
+
+    prefixed_logger.flush
 
-    subject.flush
+    expect(output_logger).to have_received(:flush)
   end
 
   it "doesn't call flush for a logger that doesn't respond to flush" do
-    expect { subject.flush }.not_to raise_error
+    expect { prefixed_logger.flush }.not_to raise_error
   end
 end

data/spec/copy_tuner_client/process_guard_spec.rb

@@ -3,17 +3,14 @@ require 'spec_helper'
 describe CopyTunerClient::ProcessGuard do
   include DefinesConstants
 
-  before do
-    @original_process_name = $0
-  end
+  let!(:original_process_name) { $PROGRAM_NAME }
+  let(:cache) { instance_double(CopyTunerClient::Cache, flush: nil) }
+  let(:poller) { instance_double(CopyTunerClient::Poller, start: nil) }
 
   after do
-    $0 = @original_process_name
+    $0 = original_process_name
   end
 
-  let(:cache) { double('cache', flush: nil) }
-  let(:poller) { double('poller', start: nil) }
-
   def build_process_guard(options = {})
     preserve_exit_hook = options.delete(:preserve_exit_hook)
     options[:logger] ||= FakeLogger.new
@@ -23,67 +20,70 @@ describe CopyTunerClient::ProcessGuard do
     process_guard
   end
 
-  it "starts polling from a worker process" do
-    expect(poller).to receive(:start)
+  it 'starts polling from a worker process' do
     process_guard = build_process_guard
     process_guard.start
+
+    expect(poller).to have_received(:start)
   end
 
-  it "registers passenger hooks from the passenger master" do
-    expect(poller).not_to receive(:start)
+  it 'registers passenger hooks from the passenger master' do
     logger = FakeLogger.new
     passenger = define_constant('PhusionPassenger', FakePassenger.new)
     passenger.become_master
 
-    process_guard = build_process_guard(:logger => logger)
+    process_guard = build_process_guard(logger:)
     process_guard.start
 
-    expect(logger).to have_entry(:info, "Registered Phusion Passenger fork hook")
+    expect(poller).not_to have_received(:start)
+    expect(logger).to have_entry(:info, 'Registered Phusion Passenger fork hook')
   end
 
-  it "starts polling from a passenger worker" do
-    expect(poller).to receive(:start)
+  it 'starts polling from a passenger worker' do
     logger = FakeLogger.new
     passenger = define_constant('PhusionPassenger', FakePassenger.new)
     passenger.become_master
-    process_guard = build_process_guard(:logger => logger)
+    process_guard = build_process_guard(logger:)
 
     process_guard.start
     passenger.spawn
+
+    expect(poller).to have_received(:start)
   end
 
-  it "registers unicorn hooks from the unicorn master" do
-    expect(poller).not_to receive(:start)
+  it 'registers unicorn hooks from the unicorn master' do
     logger = FakeLogger.new
     define_constant('Unicorn', Module.new)
     http_server = Class.new(FakeUnicornServer)
     unicorn = define_constant('Unicorn::HttpServer', http_server).new
     unicorn.become_master
 
-    process_guard = build_process_guard(:logger => logger)
+    process_guard = build_process_guard(logger:)
     process_guard.start
 
-    expect(logger).to have_entry(:info, "Registered Unicorn fork hook")
+    expect(poller).not_to have_received(:start)
+    expect(logger).to have_entry(:info, 'Registered Unicorn fork hook')
   end
 
-  it "starts polling from a unicorn worker" do
-    expect(poller).to receive(:start)
+  it 'starts polling from a unicorn worker' do
     logger = FakeLogger.new
     define_constant('Unicorn', Module.new)
     http_server = Class.new(FakeUnicornServer)
     unicorn = define_constant('Unicorn::HttpServer', http_server).new
     unicorn.become_master
-    process_guard = build_process_guard(:logger => logger)
+    process_guard = build_process_guard(logger:)
 
     process_guard.start
     unicorn.spawn
+
+    expect(poller).to have_received(:start)
   end
 
-  # FIXME: ruby@2.7以降で失敗するようになっているがテストコードの問題っぽいのでスキップしている
-  xit "flushes when the process terminates" do
+  it 'flushes when the process terminates' do
     cache = WritingCache.new
-    pid = fork do
-      process_guard = build_process_guard(cache: cache, preserve_exit_hook: true)
+    FileUtils.rm_f(File.join(PROJECT_ROOT, 'tmp', 'written_cache'))
+    fork do
+      process_guard = build_process_guard(cache:, preserve_exit_hook: true)
       process_guard.start
       exit
     end

data/spec/copy_tuner_client/request_sync_spec.rb

@@ -4,80 +4,73 @@ describe CopyTunerClient::RequestSync do
   let(:poller) { {} }
   let(:cache) { {} }
   let(:response) { 'response' }
-  let(:env) { 'env' }
-  let(:app) { double('app', :call => response) }
+  let(:app) { double('app', call: response) }
+
   before do
-    allow(cache).to receive_messages(:flush => nil, :download => nil)
+    allow(cache).to receive_messages(flush: nil, download: nil)
     allow(poller).to receive(:start_sync).and_return(nil)
   end
-  subject { CopyTunerClient::RequestSync.new(app, :poller => poller, :cache => cache, :interval => 0) }
 
-  it "invokes the upstream app" do
-    expect(app).to receive(:call).with(env)
-    result = subject.call(env)
-    expect(result).to eq(response)
-  end
-end
+  context 'interval が 0 の場合' do
+    subject(:request_sync) { described_class.new(app, poller:, cache:, interval: 0) }
 
-describe CopyTunerClient::RequestSync, 'serving assets' do
-  let(:env) do
-    { "PATH_INFO" => '/assets/choper.png' }
-  end
-  let(:poller) { {} }
-  let(:cache) { {} }
-  let(:response) { 'response' }
-  let(:app) { double('app', :call => response) }
-  before do
-    allow(cache).to receive_messages(:flush => nil, :download => nil)
-    allow(poller).to receive(:start_sync).and_return(nil)
-  end
-  subject { CopyTunerClient::RequestSync.new(app, :poller => poller, :cache => cache, :interval => 0) }
+    let(:env) { 'env' }
 
-  it "don't start sync" do
-    expect(cache).to receive(:download).once
-    subject.call(env)
-    expect(poller).not_to receive(:start_sync)
-    subject.call(env)
+    it 'invokes the upstream app' do
+      result = request_sync.call(env)
+      expect(app).to have_received(:call).with(env)
+      expect(result).to eq(response)
+    end
   end
-end
 
-describe CopyTunerClient::RequestSync do
-  let(:poller) { {} }
-  let(:cache) { {} }
-  let(:response) { 'response' }
-  let(:env) { 'env' }
-  let(:app) { double('app', :call => response) }
-  subject { CopyTunerClient::RequestSync.new(app, :poller => poller, :cache => cache, :interval => 10) }
-  before do
-    allow(cache).to receive_messages(:flush => nil, :download => nil)
-    allow(poller).to receive(:start_sync).and_return(nil)
-  end
+  context 'when serving assets' do
+    subject(:request_sync) { described_class.new(app, poller:, cache:, interval: 0) }
 
-  context "first request" do
-    it "download" do
-      expect(cache).to receive(:download).once
-      subject.call(env)
+    let(:env) do
+      { 'PATH_INFO' => '/assets/choper.png' }
     end
-  end
 
-  context 'in interval request' do
-    it "does not start sync for the second time" do
-      expect(cache).to receive(:download).once
-      subject.call(env)
+    it "don't start sync" do
+      request_sync.call(env)
+      request_sync.call(env)
 
-      expect(poller).not_to receive(:start_sync)
-      subject.call(env)
+      expect(cache).to have_received(:download).once
+      expect(poller).not_to have_received(:start_sync)
     end
   end
 
-  context 'over interval request' do
-    it "start sync for the second time" do
-      expect(cache).to receive(:download).once
-      subject.call(env)
+  context 'interval が 10 の場合' do
+    subject(:request_sync) { described_class.new(app, poller:, cache:, interval: 10) }
+
+    let(:env) { 'env' }
+
+    context 'first request' do
+      it 'download' do
+        request_sync.call(env)
+        expect(cache).to have_received(:download).once
+      end
+    end
+
+    context 'in interval request' do
+      it 'does not start sync for the second time' do
+        request_sync.call(env)
+        request_sync.call(env)
+
+        expect(cache).to have_received(:download).once
+        expect(poller).not_to have_received(:start_sync)
+      end
+    end
+
+    context 'over interval request' do
+      it 'start sync for the second time' do
+        request_sync.call(env)
+
+        request_sync.last_synced = Time.now - 60
+        request_sync.call(env)
 
-      expect(poller).to receive(:start_sync).once
-      subject.last_synced = Time.now - 60
-      subject.call(env)
+        expect(cache).to have_received(:download).once
+        expect(poller).to have_received(:start_sync).once
+      end
     end
   end
 end

data/spec/copy_tuner_client/translation_log_spec.rb

@@ -5,46 +5,60 @@ describe CopyTunerClient::TranslationLog do
   before { described_class.clear }
 
   describe '.add' do
-    context 'when initialized' do
-      it 'records the key' do
+    context '初期化済みかつキーが local_first_key_regexp にマッチする場合' do
+      before { CopyTunerClient.configuration.local_first_key_regexp = /\Aviews\./ }
+
+      it 'マッチしたキーを記録しないこと' do
+        described_class.add('views.foo', 'Hello')
+        expect(described_class.translations).to be_empty
+      end
+
+      it 'マッチしないキーは記録すること' do
+        described_class.add('messages.greeting', 'Hi')
+        expect(described_class.translations).to eq('messages.greeting' => 'Hi')
+      end
+    end
+
+    context '初期化済みかつ local_first_key_regexp が未設定の場合' do
+      it 'キーを記録すること' do
         described_class.add('views.foo', 'Hello')
         expect(described_class.translations).to eq('views.foo' => 'Hello')
       end
 
-      it 'does not overwrite an existing key' do
+      it '既存のキーを上書きしないこと' do
         described_class.add('views.foo', 'Hello')
         described_class.add('views.foo', 'World')
         expect(described_class.translations['views.foo']).to eq 'Hello'
       end
+    end
 
-      context 'when the key matches local_first_key_regexp' do
-        before { CopyTunerClient.configuration.local_first_key_regexp = /\Aviews\./ }
-
-        it 'does not record the matching key' do
-          described_class.add('views.foo', 'Hello')
-          expect(described_class.translations).to be_empty
-        end
+    context '未初期化の場合' do
+      before { Thread.current[:translations] = nil }
 
-        it 'records keys that do not match' do
-          described_class.add('messages.greeting', 'Hi')
-          expect(described_class.translations).to eq('messages.greeting' => 'Hi')
-        end
+      it 'キーを無視すること' do
+        described_class.add('views.foo', 'Hello')
+        expect(described_class.initialized?).to be false
       end
+    end
+  end
 
-      context 'when local_first_key_regexp is not set' do
-        it 'records all keys' do
-          described_class.add('views.foo', 'Hello')
-          expect(described_class.translations).to eq('views.foo' => 'Hello')
-        end
+  describe '.install_hook' do
+    # フック導入前後で I18n の特異クラスを復元し、他のテストへの副作用を防ぐ
+    around do |example|
+      original_singleton_methods = I18n.singleton_class.instance_methods(false)
+      example.run
+      (I18n.singleton_class.instance_methods(false) - original_singleton_methods).each do |method_name|
+        I18n.singleton_class.__send__(:remove_method, method_name)
       end
     end
 
-    context 'when not initialized' do
-      before { Thread.current[:translations] = nil }
+    context 'ミドルウェアが有効な場合' do
+      before { allow(CopyTunerClient.configuration).to receive(:enable_middleware?).and_return(true) }
 
-      it 'ignores the key' do
-        described_class.add('views.foo', 'Hello')
-        expect(described_class.initialized?).to be false
+      it 'エラーを発生させずに I18n.translate をフックすること' do
+        expect { described_class.install_hook }.not_to raise_error
+        expect(I18n.translate(:hello, default: 'Hello')).to eq 'Hello'
+        expect(described_class.translations).to have_key('hello')
       end
     end
   end

data/spec/copy_tuner_client/warden_integration_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require 'copy_tuner_client/copyray_middleware'
+require 'copy_tuner_client/copyray'
+require 'copy_tuner_client/copyray/marker'
+require 'copy_tuner_client/translation_log'
+
+# Warden::Manager の catch(:warden) と failure app 呼び出しだけを模した fake（warden gem に依存しないため）
+class FakeWarden
+  def initialize(app, failure_app)
+    @app = app
+    @failure_app = failure_app
+  end
+
+  def call(env)
+    result = catch(:warden) { @app.call(env) }
+    result.is_a?(Array) ? result : @failure_app.call(env)
+  end
+end
+
+# NOTE: CopyrayMiddleware 単体ではなく、Warden 相当の fake との組み合わせ位置を検証するため
+# describe の第一引数はクラスではなく説明文にしている
+describe 'throw :warden と CopyrayMiddleware の位置関係' do # rubocop:disable RSpec/DescribeClass
+  def marker(key)
+    CopyTunerClient::Copyray::Marker.encode(key)
+  end
+
+  # NOTE: authenticate_user! 失敗を模す。throw :warden するとこの @app.call(env) は正常リターンせず、
+  # CopyrayMiddleware が内側にあると Rewriter.rewrite が実行されない。
+  let(:throwing_app) { ->(_env) { throw :warden } }
+  let(:failure_status) { 200 }
+  let(:failure_app) do
+    ->(_env) do
+      [failure_status, { 'Content-Type' => 'text/html' }, [failure_body]]
+    end
+  end
+  let(:failure_body) { "<html><body><p>#{marker('devise.failure.unauthenticated')}Please sign in</p></body></html>" }
+
+  before do
+    CopyTunerClient.configure do |configuration|
+      configuration.project_id = 1
+      configuration.client = FakeClient.new
+    end
+  end
+
+  # NOTE: append_js は Rails の ActionController::Base.helpers に依存するため、
+  # copyray_middleware_spec.rb と同じ手法で no-op スタブに差し替え、Rewriter の効果だけを見る。
+  def stub_append_js(middleware)
+    allow(middleware).to receive(:append_js) { |html, *| html }
+  end
+
+  context '内側構成（CopyrayMiddleware が Warden より内側）のとき' do
+    it 'マーカー ⟦CT: がレスポンスに残る（不具合の記録）' do
+      copyray = CopyTunerClient::CopyrayMiddleware.new(throwing_app)
+      stub_append_js(copyray)
+      warden = FakeWarden.new(copyray, failure_app)
+
+      _status, _headers, response = warden.call({})
+      result = response.join
+
+      expect(result).to match(CopyTunerClient::Copyray::Marker::SCAN_REGEXP)
+    end
+  end
+
+  context '外側構成（CopyrayMiddleware が Warden より外側）のとき' do
+    it 'マーカーが消え data-copyray-key に変換される' do
+      warden = FakeWarden.new(throwing_app, failure_app)
+      copyray = CopyTunerClient::CopyrayMiddleware.new(warden)
+      stub_append_js(copyray)
+
+      _status, _headers, response = copyray.call({})
+      result = response.join
+
+      expect(result).to include('data-copyray-key="devise.failure.unauthenticated"')
+      expect(result).not_to match(CopyTunerClient::Copyray::Marker::SCAN_REGEXP)
+    end
+
+    context 'failure app が 422 を返すとき（Devise.responder.error_status = :unprocessable_entity 相当）' do
+      let(:unprocessable_failure_app) do
+        ->(_env) { [422, { 'Content-Type' => 'text/html' }, [failure_body]] }
+      end
+
+      it 'マーカーが消え data-copyray-key に変換される' do
+        warden = FakeWarden.new(throwing_app, unprocessable_failure_app)
+        copyray = CopyTunerClient::CopyrayMiddleware.new(warden)
+        stub_append_js(copyray)
+
+        _status, _headers, response = copyray.call({})
+        result = response.join
+
+        expect(result).to include('data-copyray-key="devise.failure.unauthenticated"')
+        expect(result).not_to match(CopyTunerClient::Copyray::Marker::SCAN_REGEXP)
+      end
+    end
+  end
+end

data/spec/copy_tuner_client_spec.rb

@@ -1,18 +1,17 @@
 require 'spec_helper'
 
 describe CopyTunerClient do
-
   before do
-    allow(CopyTunerClient.configuration).to receive_messages(cache: 'cache', client: 'client')
+    allow(described_class.configuration).to receive_messages(cache: 'cache', client: 'client')
   end
 
   it 'delegates cache to the configuration object' do
-    expect(CopyTunerClient.configuration).to receive(:cache).once
-    expect(CopyTunerClient.cache).to eq('cache')
+    expect(described_class.cache).to eq('cache')
+    expect(described_class.configuration).to have_received(:cache).once
   end
 
   it 'delegates client to the configuration object' do
-    expect(CopyTunerClient.configuration).to receive(:client).once
-    expect(CopyTunerClient.client).to eq('client')
+    expect(described_class.client).to eq('client')
+    expect(described_class.configuration).to have_received(:client).once
   end
 end

data/spec/support/client_spec_helpers.rb

@@ -1,7 +1,7 @@
 module ClientSpecHelpers
   def reset_config
     CopyTunerClient.configuration = nil
-    CopyTunerClient.configure(false) do |config|
+    CopyTunerClient.configure(apply: false) do |config|
       config.api_key = 'abc123'
       config.s3_host = 'copy-tuner.com'
     end

data/spec/support/defines_constants.rb

@@ -1,44 +1,13 @@
 module DefinesConstants
-  def self.included(example_group)
-    super
-    example_group.class_eval do
-      before { @defined_constants = [] }
-      after { undefine_constants }
-    end
-  end
-
-  def define_class(class_name, base = Object, &block)
+  def define_class(class_name, base = Object, &)
     class_name = class_name.to_s.camelize
     klass = Class.new(base)
     define_constant(class_name, klass)
-    klass.class_eval(&block) if block_given?
+    klass.class_eval(&) if block_given?
     klass
   end
 
   def define_constant(path, value)
-    parse_constant(path) do |parent, name|
-      parent.const_set(name, value)
-    end
-
-    @defined_constants << path
-    value
-  end
-
-  def parse_constant(path)
-    parent_names = path.split('::')
-    name = parent_names.pop
-    parent = parent_names.inject(Object) do |ref, child_name|
-      ref.const_get(child_name)
-    end
-    yield(parent, name)
-  end
-
-  def undefine_constants
-    @defined_constants.reverse.each do |path|
-      parse_constant(path) do |parent, name|
-        parent.send(:remove_const, name)
-      end
-    end
+    stub_const(path, value)
   end
 end
-