copy_tuner_client 2.2.0 → 2.3.0

data/skills/copy-tuner-to-locales-migrate-prefix/scripts/migrate_prefix.rb

@@ -8,6 +8,10 @@
 #   bin/rails runner .claude/skills/copy-tuner-to-locales-migrate-prefix/scripts/migrate_prefix.rb \
 #     -- --prefix date --export tmp/copy_tuner_all.yml --out config/locales/0010_date.yml
 #
+# このスクリプト自身の自己検証（gem メンテナ向け。Rails も bundler も不要）:
+#
+#   ruby skills/copy-tuner-to-locales-migrate-prefix/scripts/migrate_prefix.rb --self-test
+#
 # What it does, in one pass:
 #   (1) Place : extract the target prefix subtree from the 0000_original_*.yml
 #       originals (load-order deep_merge), deep_merge the export subtree on top
@@ -29,6 +33,127 @@
 require 'optparse'
 require 'yaml'
 
+# ---- self-test ----
+# 引数パースより前に分岐する。このスクリプトはトップレベルで即実行する造りなので、`--self-test` の
+# ときは本体へ進ませずテストだけ走らせてトップレベル return で抜ける。
+if ARGV.delete('--self-test')
+  require 'minitest/autorun'
+  require 'tmpdir'
+  require 'fileutils'
+  require 'rbconfig'
+
+  # 本体はトップレベルで exit するため load では検証できない。fixture を tmpdir に作り、i18n だけを
+  # 直接設定する薄いランナー経由でサブプロセス実行する（スクリプトが触るのは I18n.load_path と
+  # Backend::Simple だけなので Rails は不要）。
+  class MigratePrefixSelfTest < Minitest::Test
+    SCRIPT = File.expand_path(__FILE__)
+    # 対象 prefix（date）を持つファイル。これだけが書き戻し対象になるのが期待挙動。
+    WITH_PREFIX = "ja:\n  date:\n    formats:\n      default: \"%Y\"\n"
+    WITHOUT_PREFIX = "ja:\n  greeting: \"hello\"\n"
+    # 片方だけが対象 prefix を持つ 2 ファイル構成。「1 ファイルだけ書き戻る」ことの検証に使う。
+    MIXED_FILES = { '0000_original_a.yml' => WITH_PREFIX, '0000_original_b.yml' => WITHOUT_PREFIX }.freeze
+    EXPORT_JA = "ja:\n  date:\n    formats:\n      default: \"%Y/%m/%d\"\n"
+    EXPORT_JA_EN = "#{EXPORT_JA}en:\n  date:\n    formats:\n      default: \"%m/%d/%Y\"\n".freeze
+    # to_yaml の既定 line_width（80）を確実に超える長さにして折り返しを誘発する。
+    LONG_VALUE = (['word'] * 60).join(' ').freeze
+
+    def test_untouched_file_keeps_bytes
+      # コメント・空行・ダブルクォートが 1 バイトも変わらないことを見る。
+      untouched = <<~YAML
+        ja:
+          # これは greeting のコメント
+          greeting: "hello"
+
+          farewell: "bye"
+      YAML
+      migrate({ '0000_original_a.yml' => WITH_PREFIX, '0000_original_b.yml' => untouched }) do |out, dir|
+        # binread は ASCII-8BIT を返すため、UTF-8 の期待値を b で揃えてバイト列として比較する。
+        assert_equal(untouched.b, read(dir, '0000_original_b.yml'), "無関係なファイルが書き換わった:\n#{out}")
+      end
+    end
+
+    def test_missing_locale_root_is_not_added
+      migrate(MIXED_FILES, locales: %w[ja en], export: EXPORT_JA_EN) do |_out, dir|
+        MIXED_FILES.each_key do |name|
+          refute_includes(read(dir, name), 'en:', "#{name} に元ファイルに無い en ルートが新設された")
+        end
+      end
+    end
+
+    def test_prefix_is_pruned_from_matching_file
+      migrate({ '0000_original_a.yml' => "#{WITH_PREFIX}  greeting: \"hello\"\n" }) do |_out, dir|
+        assert_equal({ 'ja' => { 'greeting' => 'hello' } }, load_yaml(dir, '0000_original_a.yml'))
+        assert_equal(
+          { 'ja' => { 'date' => { 'formats' => { 'default' => '%Y/%m/%d' } } } },
+          load_yaml(dir, '0010_migrated.yml')
+        )
+      end
+    end
+
+    def test_long_value_is_not_wrapped
+      migrate({ '0000_original_a.yml' => "#{WITH_PREFIX}  greeting: \"#{LONG_VALUE}\"\n" }) do |_out, dir|
+        body = read(dir, '0000_original_a.yml')
+        assert_includes(body, "greeting: #{LONG_VALUE}\n", "長い値が折り返された:\n#{body}")
+      end
+    end
+
+    def test_summary_counts_changed_files
+      migrate(MIXED_FILES) do |out, _dir|
+        assert_includes(out, 'オリジナル 2 ファイル中 1 ファイル')
+      end
+    end
+
+    private
+
+    # fixture を tmpdir に配置してサブプロセス実行し、標準出力と locales ディレクトリを yield する。
+    def migrate(files, locales: %w[ja], export: EXPORT_JA)
+      Dir.mktmpdir do |dir|
+        locales_dir = File.join(dir, 'config/locales')
+        FileUtils.mkdir_p(locales_dir)
+        FileUtils.mkdir_p(File.join(dir, 'tmp'))
+        files.each { |name, body| File.write(File.join(locales_dir, name), body) }
+        File.write(File.join(dir, 'tmp/export.yml'), export)
+        write_runner(dir, locales)
+
+        ok, out = spawn_script(dir, locales)
+        assert(ok, "スクリプトが異常終了した:\n#{out}")
+        yield(out, locales_dir)
+      end
+    end
+
+    def write_runner(dir, locales)
+      File.write(File.join(dir, 'runner.rb'), <<~RUBY)
+        require 'i18n'
+        I18n.load_path = Dir['config/locales/*.yml']
+        I18n.available_locales = #{locales.map(&:to_sym).inspect}
+        I18n.default_locale = #{locales.first.to_sym.inspect}
+        load #{SCRIPT.inspect}
+      RUBY
+    end
+
+    def spawn_script(dir, locales)
+      args = [
+        '--prefix', 'date', '--locales', locales.join(','),
+        '--export', 'tmp/export.yml', '--out', 'config/locales/0010_migrated.yml'
+      ]
+      Dir.chdir(dir) do
+        read_io, write_io = IO.pipe
+        pid = spawn(RbConfig.ruby, File.join(dir, 'runner.rb'), '--', *args, out: write_io, err: write_io)
+        write_io.close
+        out = read_io.read
+        _, status = Process.waitpid2(pid)
+        [status.success?, out]
+      end
+    end
+
+    def read(dir, name) = File.binread(File.join(dir, name))
+
+    def load_yaml(dir, name) = YAML.safe_load_file(File.join(dir, name))
+  end
+
+  return
+end
+
 # NOTE: `bin/rails runner` は Kernel#abort が投げる SystemExit を握りつぶし終了コードが 0 になる
 # （実機確認済み）。中断を呼び出し側へ確実に伝えるため、abort ではなく warn + exit(1) を使う。
 def die(message)
@@ -160,7 +285,12 @@ end
 # locale ルートを持つ raw Hash（`{ "ja" => {...}, "en" => {...} }`）から、対象 prefix を全 locale で刈った
 # 新しい Hash を返す（非破壊）。移行漏れ検証のシミュレーションと実削除の両方で使う。
 def prune_prefix_all_locales(raw, locales, keys)
-  locales.reduce(raw) { |acc, locale| acc.merge(locale => prune_prefix(acc[locale] || {}, keys)) }
+  locales.reduce(raw) do |acc, locale|
+    # 元ファイルに無い locale ルートを新設すると、ja だけのファイルに `en: {}` が追記されてしまう。
+    next acc unless acc.key?(locale)
+
+    acc.merge(locale => prune_prefix(acc[locale], keys))
+  end
 end
 
 # ---- (1) 配置 ----
@@ -277,10 +407,18 @@ unless leaks.empty?
   die('中断。--out の内容・採番・regexp を確認すること。')
 end
 
-original_files.each do |f|
-  raw = YAML.safe_load_file(f, permitted_classes: [Symbol], aliases: true) || {}
-  File.write(f, prune_prefix_all_locales(raw, LOCALES, prefix_keys).to_yaml)
-end
+changed =
+  original_files.count do |f|
+    raw = YAML.safe_load_file(f, permitted_classes: [Symbol], aliases: true) || {}
+    pruned = prune_prefix_all_locales(raw, LOCALES, prefix_keys)
+    # 対象 prefix を含まないファイルを to_yaml で書き戻すと、クォート・アンカー名・折り返し・コメントの
+    # 無関係な整形差分が出る。実質的な変更があるファイルだけ書き戻す。
+    next false if pruned == raw
+
+    # 折り返しだけは line_width で無効化できる（アンカー名・クォートは Psych の仕様で制御できない）。
+    File.write(f, pruned.to_yaml(line_width: -1))
+    true
+  end
 
-puts "削除: prefix '#{PREFIX}' をオリジナル #{original_files.size} ファイルから刈り取った。"
+puts "削除: prefix '#{PREFIX}' をオリジナル #{original_files.size} ファイル中 #{changed} ファイルから刈り取った。"
 puts '完了。手順7（local_first_key_regexp 追加）が未済なら次に実施すること。'

data/spec/copy_tuner_client/configuration_spec.rb

@@ -398,6 +398,179 @@ describe CopyTunerClient::Configuration do
     end
   end
 
+  describe 'middleware_position の初期値' do
+    let(:config) { described_class.new }
+
+    context 'Warden::Manager と Devise がどちらも定義済みのとき' do
+      before do
+        stub_const('Warden::Manager', Class.new)
+        stub_const('Devise', Module.new)
+      end
+
+      it '{ before: Warden::Manager } になる' do
+        expect(config.middleware_position).to eq({ before: Warden::Manager })
+      end
+    end
+
+    context 'Warden::Manager が未定義のとき' do
+      before { hide_const('Warden::Manager') }
+
+      it 'nil のままになる' do
+        expect(config.middleware_position).to be_nil
+      end
+    end
+
+    # NOTE: authtrail のように warden を require するだけで Warden::Manager をスタックへ積まない
+    # gem があるため、Warden 単独では既定位置にしない（insert_before が起動時例外になる）。
+    context 'Warden::Manager は定義済みだが Devise が未定義のとき' do
+      before do
+        stub_const('Warden::Manager', Class.new)
+        hide_const('Devise')
+      end
+
+      it 'nil のままになる' do
+        expect(config.middleware_position).to be_nil
+      end
+    end
+
+    context 'configure ブロック内で明示指定したとき' do
+      before do
+        stub_const('Warden::Manager', Class.new)
+        stub_const('Devise', Module.new)
+      end
+
+      it '明示指定した値が優先される' do
+        other = Class.new
+        CopyTunerClient.configure(apply: false) do |c|
+          c.middleware_position = { before: other }
+        end
+        expect(CopyTunerClient.configuration.middleware_position).to eq({ before: other })
+      end
+    end
+  end
+
+  context 'Warden::Manager がスタックにある状態で apply したとき' do
+    it_behaves_like 'applied configuration' do
+      it 'デフォルト値経由で Warden::Manager の直前に RequestSync → CopyrayMiddleware の順で入る' do
+        expect(middleware.classes).to eq(
+          [
+            Rack::ETag, Rack::TempfileReaper, CopyTunerClient::RequestSync, CopyTunerClient::CopyrayMiddleware,
+            Warden::Manager, Rack::Static
+          ]
+        )
+      end
+
+      it 'Warden::Manager より外側に配置される' do
+        expect(middleware.index(CopyTunerClient::RequestSync)).to be < middleware.index(Warden::Manager)
+        expect(middleware.index(CopyTunerClient::CopyrayMiddleware)).to be < middleware.index(Warden::Manager)
+      end
+
+      it 'RequestSync に poller / cache / interval / ignore_regex が渡る' do
+        args = middleware.args_for(CopyTunerClient::RequestSync)
+        expect(args.first).to include(
+          poller:, # rubocop:disable Sgcop/Rspec/NoMethodCallInExpectation
+          cache:,
+          interval: configuration.sync_interval,
+          ignore_regex: configuration.sync_ignore_path_regex
+        )
+      end
+    end
+
+    # NOTE: 実アプリの bin/rails middleware 出力を模した標準スタック。Warden::Manager / Devise は
+    # gem の依存にないため stub_const で fake の定数として定義する。
+    before do
+      stub_const('Warden::Manager', Class.new)
+      stub_const('Devise', Module.new)
+    end
+
+    let(:middleware) do
+      MiddlewareStack.new([Rack::ETag, Rack::TempfileReaper, Warden::Manager, Rack::Static])
+    end
+
+    def apply
+      configuration.middleware = middleware
+      configuration.environment_name = 'development'
+      configuration.apply
+    end
+  end
+
+  context 'Warden::Manager が未定義の状態で apply したとき' do
+    it_behaves_like 'applied configuration' do
+      it 'Warden::Manager 未定義時は従来どおりスタック末尾へ use される' do
+        expect(middleware.classes).to eq([CopyTunerClient::RequestSync, CopyTunerClient::CopyrayMiddleware])
+      end
+    end
+
+    before { hide_const('Warden::Manager') }
+
+    let(:middleware) { MiddlewareStack.new }
+
+    def apply
+      configuration.middleware = middleware
+      configuration.environment_name = 'development'
+      configuration.apply
+    end
+  end
+
+  context 'middleware_position に after を明示指定して apply したとき' do
+    it_behaves_like 'applied configuration' do
+      it '{after: X} 指定時は X の直後に RequestSync → CopyrayMiddleware の順で入る' do
+        expect(middleware.classes).to eq(
+          [:a, :x, CopyTunerClient::RequestSync, CopyTunerClient::CopyrayMiddleware, :b]
+        )
+      end
+    end
+
+    let(:middleware) { MiddlewareStack.new(%i[a x b]) }
+
+    def apply
+      configuration.middleware = middleware
+      configuration.middleware_position = { after: :x }
+      configuration.environment_name = 'development'
+      configuration.apply
+    end
+  end
+
+  context 'middleware_position に before を明示指定して apply したとき' do
+    it_behaves_like 'applied configuration' do
+      it '{before: X} 指定時は X の直前に RequestSync → CopyrayMiddleware の順で入る' do
+        expect(middleware.classes).to eq(
+          [:a, CopyTunerClient::RequestSync, CopyTunerClient::CopyrayMiddleware, :x, :b]
+        )
+      end
+    end
+
+    let(:middleware) { MiddlewareStack.new(%i[a x b]) }
+
+    def apply
+      configuration.middleware = middleware
+      configuration.middleware_position = { before: :x }
+      configuration.environment_name = 'development'
+      configuration.apply
+    end
+  end
+
+  # NOTE: { before: SomeClass if cond } のように条件次第で値が nil になる書き方を想定する。
+  # キーの有無だけで分岐すると insert_before(nil) が対象を見つけられず例外になる。
+  context 'middleware_position の値が nil のとき' do
+    it_behaves_like 'applied configuration' do
+      it '例外を投げずスタック末尾へ use する' do
+        expect(middleware.classes).to eq(
+          [:a, :x, :b, CopyTunerClient::RequestSync, CopyTunerClient::CopyrayMiddleware]
+        )
+      end
+    end
+
+    let(:middleware) { MiddlewareStack.new(%i[a x b]) }
+
+    def apply
+      configuration.middleware = middleware
+      configuration.middleware_position = { before: nil }
+      configuration.environment_name = 'development'
+      configuration.apply
+    end
+  end
+
   context 'applied without locale filter' do
     include_context 'stubbed configuration'
 

data/spec/copy_tuner_client/fork_hook_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe CopyTunerClient::ForkHook do
+  let(:client) { FakeClient.new }
+  let(:cache) { CopyTunerClient::Cache.new(client, logger: FakeLogger.new) }
+  let(:poller) do
+    config = CopyTunerClient::Configuration.new.to_hash
+    CopyTunerClient::Poller.new(cache, config.update(logger: FakeLogger.new, polling_delay:))
+  end
+
+  def polling_delay
+    0.5
+  end
+
+  before do
+    described_class.install
+    # フックは CopyTunerClient.configuration&.poller を見るので、実際の設定に載せる
+    CopyTunerClient.configuration.poller = poller
+  end
+
+  after do
+    poller.stop
+  end
+
+  describe '停止と再開の順序' do
+    # 実際に fork してしまうと「fork の瞬間にスレッドが止まっているか」を観測できないため、
+    # _fork の代わりに記録だけするオブジェクトに prepend して順序を見る
+    def build_forkable(events, &fork_body)
+      forkable = Object.new
+      forkable.define_singleton_method(:_fork) do
+        events << :fork
+        fork_body ? fork_body.call : 0
+      end
+      forkable.singleton_class.prepend(described_class)
+      forkable
+    end
+
+    def stub_poller(events, stopped:)
+      allow(poller).to receive(:stop) do
+        events << :stop
+        stopped
+      end
+      allow(poller).to receive(:start) { events << :start }
+    end
+
+    it 'fork の前に poller を停止し、fork の後に再開する' do
+      events = []
+      stub_poller(events, stopped: true)
+
+      build_forkable(events)._fork
+
+      expect(events).to eq(%i[stop fork start])
+    end
+
+    it 'fork 前に poller が動いていなければ再開しない' do
+      events = []
+      stub_poller(events, stopped: false)
+
+      build_forkable(events)._fork
+
+      expect(events).to eq(%i[stop fork])
+    end
+
+    it 'fork が失敗しても poller を再開する' do
+      events = []
+      stub_poller(events, stopped: true)
+
+      forkable = build_forkable(events) { raise Errno::EAGAIN }
+
+      expect { forkable._fork }.to raise_error(Errno::EAGAIN)
+      expect(events).to eq(%i[stop fork start])
+    end
+  end
+
+  describe 'poller を取得できないとき' do
+    it 'configuration が nil でも fork を壊さない' do
+      # Process._fork への prepend は外せないので、ここで例外を漏らすとアプリの
+      # すべての fork が失敗する
+      CopyTunerClient.configuration = nil
+
+      expect { Process.waitpid(fork { exit!(0) }) }.not_to raise_error
+    end
+
+    it 'ログ出力自体が失敗しても fork は成立する' do
+      allow(poller).to receive(:stop).and_return(true)
+      allow(poller).to receive(:start).and_raise(ThreadError, 'cannot create thread')
+      allow(CopyTunerClient.configuration.logger).to receive(:error).and_raise('logger is broken')
+
+      expect { Process.waitpid(fork { exit!(0) }) }.not_to raise_error
+    end
+
+    it 'fork 後の poller 起動に失敗しても fork 自体は成立する' do
+      allow(poller).to receive(:stop).and_return(true)
+      allow(poller).to receive(:start).and_raise(ThreadError, 'cannot create thread')
+
+      expect { Process.waitpid(fork { exit!(0) }) }.not_to raise_error
+    end
+  end
+
+  describe '実際に fork したとき' do
+    it 'fork 前に poller が例外で死んでいても親子とも張り直す' do
+      # rails server の cluster では ForkHook が唯一の再開経路なので、ここで張り直さないと
+      # 親子とも poller を失う
+      fail_once = true
+      allow(cache).to receive(:sync).and_wrap_original do |original, *args|
+        if fail_once
+          fail_once = false
+          raise 'boom'
+        end
+        original.call(*args)
+      end
+
+      poller.start
+      sleep(polling_delay * 0.4) # スレッドが例外で終わる
+
+      reader, writer = IO.pipe
+      pid =
+        fork do
+          reader.close
+          client['child.key'] = 'value'
+          sleep(polling_delay * 3)
+          writer.write(cache['child.key'].to_s)
+          writer.close
+          exit!(0)
+        end
+
+      writer.close
+      child_result = reader.read
+      Process.waitpid(pid)
+
+      client['parent.key'] = 'value'
+      sleep(polling_delay * 3)
+
+      expect(child_result).to eq('value')
+      expect(cache['parent.key']).to eq('value')
+    end
+
+    it '子プロセスでも poller がポーリングを続ける' do
+      poller.start
+      reader, writer = IO.pipe
+
+      pid =
+        fork do
+          reader.close
+          client['test.key'] = 'value'
+          sleep(polling_delay * 3)
+          writer.write(cache['test.key'].to_s)
+          writer.close
+          exit!(0)
+        end
+
+      writer.close
+      result = reader.read
+      Process.waitpid(pid)
+
+      expect(result).to eq('value')
+    end
+
+    it '親プロセスでも poller がポーリングを続ける' do
+      poller.start
+      sleep(polling_delay * 0.2)
+
+      Process.waitpid(fork { exit!(0) })
+
+      client['test.key'] = 'value'
+      sleep(polling_delay * 3)
+
+      expect(cache['test.key']).to eq('value')
+    end
+  end
+end

data/spec/copy_tuner_client/poller_spec.rb

@@ -11,7 +11,7 @@ describe CopyTunerClient::Poller do
 
   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
@@ -95,4 +95,151 @@ describe CopyTunerClient::Poller do
 
     expect(logger).to have_received(:flush).at_least(:once)
   end
+
+  describe '#stop' do
+    it 'スレッドを停止したときは true を返す' do
+      poller = build_poller
+      poller.start
+
+      expect(poller.stop).to be true
+    end
+
+    it 'スレッドが動いていないときは false を返す' do
+      poller = build_poller
+
+      expect(poller.stop).to be false
+    end
+
+    it 'スレッドが例外で終わっていても例外を再送出しない' do
+      # stop は fork の直前にも呼ばれる。ここで join が poller の例外を再送出すると
+      # アプリ側の fork まで巻き添えになる
+      logger = FakeLogger.new
+      allow(cache).to receive(:sync).and_raise('boom')
+      poller = build_poller(logger:)
+      poller.start
+      sleep(polling_delay * 0.2)
+
+      expect { poller.stop }.not_to raise_error
+      expect(logger).to have_entry(:error, 'boom')
+    end
+
+    it 'start していないときに stop してもキューに :stop を残さない' do
+      poller = build_poller
+      poller.stop
+
+      poller.start
+
+      # 1 周目の sync だけでは「:stop がキューに残っている」状態と区別できないため、
+      # 2 周目以降も同期が続くことを確かめる
+      wait_for_next_sync
+      client['test.key'] = 'value'
+      wait_for_next_sync
+
+      expect(cache['test.key']).to eq('value')
+    end
+  end
+
+  describe '世代をまたいだコマンドの混入' do
+    # :stop は pop されるまでキューに残る。前の世代のスレッド宛に積まれた :stop を
+    # 次の世代のスレッドが拾うと、起動直後に自分を止めてしまう
+    it 'スレッドが例外で死んだ後に stop → start してもポーリングが続く' do
+      poller = build_poller
+      allow(cache).to receive(:sync).and_raise('boom')
+      poller.start
+      sleep(polling_delay * 0.3) # スレッドが例外で終わるのを待つ
+
+      allow(cache).to receive(:sync).and_call_original
+      poller.stop
+      poller.start
+
+      wait_for_next_sync
+      client['test.key'] = 'value'
+      wait_for_next_sync
+
+      expect(cache['test.key']).to eq('value')
+    end
+
+    it 'stop の直後に sync が例外で終わっても、次の start でポーリングが続く' do
+      poller = build_poller
+      # stop が :stop を積んだ後にスレッドが例外で終わる順序を作る。
+      # sync に入ったところで stop を待たせ、:stop を積み終えてから例外にする
+      syncing = Queue.new
+      resume = Queue.new
+      allow(cache).to receive(:sync) do
+        syncing << true
+        resume.pop
+        raise 'boom'
+      end
+
+      poller.start
+      syncing.pop # スレッドが sync に入った
+
+      stopper = Thread.new { poller.stop }
+      sleep(0.1) # :stop がキューに積まれるのを待つ
+      resume << true # ここで sync が例外になり、:stop は消費されない
+      stopper.join
+
+      allow(cache).to receive(:sync).and_call_original
+      poller.start
+
+      wait_for_next_sync
+      client['test.key'] = 'value'
+      wait_for_next_sync
+
+      expect(cache['test.key']).to eq('value')
+    end
+
+    # stop の戻り値は ForkHook の「fork 後に張り直すか」の判断に使われる。スレッドの生死ではなく
+    # 「ポーリングを継続する意図があるか」を返す必要がある
+    it 'スレッドが例外で死んでいても、起動中だったなら stop は true を返す' do
+      poller = build_poller
+      allow(cache).to receive(:sync).and_raise('boom')
+      poller.start
+      sleep(polling_delay * 0.3)
+
+      expect(poller.stop).to be true
+    end
+
+    it '回復の見込みがない理由で終了した後の stop は false を返す' do
+      poller = build_poller
+      allow(cache).to receive(:sync).and_raise(CopyTunerClient::InvalidApiKey, 'Invalid API key')
+      poller.start
+      sleep(polling_delay * 0.3)
+
+      # API キーが不正なら fork のたびに張り直しても同じ理由で死ぬだけなので再開させない
+      expect(poller.stop).to be false
+    end
+  end
+
+  describe '再開時の sync 間隔' do
+    # 経過時間で判定するため、CI の負荷や GC で sleep が伸びても落ちないよう
+    # 他のテストより長い間隔を使ってマージンを稼ぐ
+    let(:slow_delay) { 2.0 }
+
+    it '初回の start では待たずに sync する' do
+      poller = build_poller(polling_delay: slow_delay)
+
+      poller.start
+      sleep(slow_delay * 0.2)
+
+      expect(client.downloads).to eq(1)
+    end
+
+    it '停止直後に再開したときは前回 sync からの残り時間を待ってから sync する' do
+      poller = build_poller(polling_delay: slow_delay)
+      poller.start
+      sleep(slow_delay * 0.2)
+      poller.stop
+
+      poller.start
+
+      # 前回 sync から polling_delay 経つまでは sync しない
+      sleep(slow_delay * 0.4)
+      expect(client.downloads).to eq(1)
+
+      # 残り時間が過ぎれば sync が再開する
+      sleep(slow_delay * 0.8)
+      expect(client.downloads).to eq(2)
+    end
+  end
 end