copy_tuner_client 0.4.9 → 0.4.10

data/package.json

@@ -4,24 +4,27 @@
   "repository": "https://github.com/SonicGarden/copy-tuner-ruby-client",
   "author": "SonicGarden",
   "license": "MIT",
+  "engines": {
+    "node": "8.x"
+  },
   "scripts": {
     "build": "rollup -c",
     "watch": "rollup -c -w"
   },
-  "dependencies": {
-    "keycode-js": "0.0.4",
-    "lodash.debounce": "^4.0.8"
-  },
+  "dependencies": {},
   "devDependencies": {
+    "babel-core": "^6.26.3",
     "babel-plugin-external-helpers": "^6.22.0",
-    "babel-preset-env": "^1.6.0",
-    "eslint": "^3.19.0",
-    "eslint-config-airbnb-base": "^11.2.0",
-    "eslint-plugin-import": "^2.7.0",
-    "rollup": "^0.45.2",
-    "rollup-plugin-babel": "^2.7.1",
-    "rollup-plugin-commonjs": "^8.0.2",
-    "rollup-plugin-node-resolve": "^3.0.0",
+    "babel-preset-env": "^1.7.0",
+    "eslint": "^4.19.1",
+    "eslint-config-airbnb-base": "^13.0.0",
+    "eslint-plugin-import": "^2.13.0",
+    "keycode-js": "^1.0.0",
+    "lodash.debounce": "^4.0.8",
+    "rollup": "^0.62.0",
+    "rollup-plugin-babel": "^3.0.7",
+    "rollup-plugin-commonjs": "^9.1.3",
+    "rollup-plugin-node-resolve": "^3.3.0",
     "rollup-watch": "^4.3.1"
   }
 }

data/rollup.config.js

@@ -3,9 +3,11 @@ import resolve from 'rollup-plugin-node-resolve';
 import commonjs from 'rollup-plugin-commonjs';
 
 export default {
-  entry: 'src/main.js',
-  dest: 'app/assets/javascripts/copyray.js',
-  format: 'iife',
+  input: 'src/main.js',
+  output: {
+    file: 'app/assets/javascripts/copyray.js',
+    format: 'iife',
+  },
   plugins: [
     resolve({ jsnext: true, main: true }),
     commonjs(),

data/spec/copy_tuner_client/cache_spec.rb

@@ -98,7 +98,7 @@ describe CopyTunerClient::Cache do
   it "handles connection errors when flushing" do
     failure = "server is napping"
     logger = FakeLogger.new
-    client.stubs(:upload).raises(CopyTunerClient::ConnectionError.new(failure))
+    expect(client).to receive(:upload).and_raise(CopyTunerClient::ConnectionError.new(failure))
     cache = build_cache(:logger => logger)
     cache['upload.key'] = 'upload'
 
@@ -110,7 +110,7 @@ describe CopyTunerClient::Cache do
   it "handles connection errors when downloading" do
     failure = "server is napping"
     logger = FakeLogger.new
-    client.stubs(:download).raises(CopyTunerClient::ConnectionError.new(failure))
+    expect(client).to receive(:download).and_raise(CopyTunerClient::ConnectionError.new(failure))
     cache = build_cache(:logger => logger)
 
     cache.download
@@ -120,43 +120,46 @@ describe CopyTunerClient::Cache do
 
   it "blocks until the first download is complete" do
     logger = FakeLogger.new
-    logger.stubs(:flush)
-    client.delay = 0.5
+    expect(logger).to receive(:flush)
+    client.delay = true
     cache = build_cache(:logger => logger)
 
-    Thread.new { cache.download }
+    t_download = Thread.new { cache.download }
+    sleep 0.1 until cache.pending?
 
-    finished = false
-    Thread.new do
+    t_wait = Thread.new do
       cache.wait_for_download
-      finished = true
     end
-
-    sleep(1)
-
-    expect(finished).to eq(true)
-    # FIXME 成功したり、失敗していたりするので、一旦コメントアウト。後で直します。
-    # logger.should have_entry(:info, "Waiting for first download")
-    # logger.should have_received(:flush)
+    sleep 0.1 until logger.has_entry?(:info, "Waiting for first download")
+    client.go
+    expect(t_download.join(1)).not_to be_nil
+    expect(cache.pending?).to be_falsey
+    expect(t_wait.join(1)).not_to be_nil
   end
 
   it "doesn't block if the first download fails" do
-    client.delay = 0.5
+    client.delay = true
     client.error = StandardError.new("Failure")
     cache = build_cache
 
-    Thread.new { cache.download }
+    error = nil
+    t_download = Thread.new do
+      begin
+        cache.download
+      rescue StandardError => e
+        error = e
+      end
+    end
+    sleep 0.1 until cache.pending?
 
-    finished = false
-    Thread.new do
+    t_wait = Thread.new do
       cache.wait_for_download
-      finished = true
     end
-
-    sleep(1)
-
+    client.go
+    expect(t_download.join(1)).not_to be_nil
+    expect(error).to be_kind_of(StandardError)
+    expect(t_wait.join(1)).not_to be_nil
     expect { cache.download }.to raise_error(StandardError, "Failure")
-    expect(finished).to eq(true)
   end
 
   it "doesn't block before downloading" do
@@ -218,7 +221,7 @@ describe CopyTunerClient::Cache do
 
     before do
       mutex.lock
-      Mutex.stubs(:new => mutex)
+      allow(Mutex).to receive(:new).and_return(mutex)
     end
 
     it "synchronizes read access to keys between threads" do
@@ -239,12 +242,9 @@ describe CopyTunerClient::Cache do
     CopyTunerClient.configure do |config|
       config.cache = cache
     end
-    cache.stubs(:flush)
+    expect(cache).to receive(:flush).at_least(:once)
 
     CopyTunerClient.flush
-
-    # FIXME 不安定なので後ほど修正する。
-    # cache.should have_received(:flush)
   end
 
   describe "#export" do
@@ -260,11 +260,9 @@ describe CopyTunerClient::Cache do
       CopyTunerClient.configure do |config|
         config.cache = @cache
       end
-      @cache.stubs(:export)
+      expect(@cache).to receive(:export)
 
       CopyTunerClient.export
-
-      expect(@cache).to have_received(:export)
     end
 
     it "returns no yaml with no blurb keys" do

data/spec/copy_tuner_client/client_spec.rb

@@ -24,7 +24,7 @@ describe CopyTunerClient do
     let(:http) { Net::HTTP.new(config.host, config.port) }
 
     before do
-      Net::HTTP.stubs(:new => http)
+      allow(Net::HTTP).to receive(:new).and_return(http)
     end
 
     it 'should timeout when connecting' do
@@ -71,7 +71,7 @@ describe CopyTunerClient do
       ]
 
       errors.each do |original_error|
-        http.stubs(:request).raises(original_error)
+        allow(http).to receive(:request).and_raise(original_error)
         client = build_client_with_project
         expect { client.download { |ignore| } }.
           to raise_error(CopyTunerClient::ConnectionError) { |error|
@@ -200,11 +200,9 @@ describe CopyTunerClient do
     CopyTunerClient.configure do |config|
       config.client = client
     end
-    client.stubs(:deploy)
+    expect(client).to receive(:deploy)
 
     CopyTunerClient.deploy
-
-    expect(client).to have_received(:deploy)
   end
 
   it "deploys" do

data/spec/copy_tuner_client/configuration_spec.rb

@@ -162,9 +162,8 @@ describe CopyTunerClient::Configuration do
 
   it 'logs to $stdout by default' do
     logger = FakeLogger.new
-    Logger.stubs :new => logger
+    expect(Logger).to receive(:new).with($stdout).and_return(logger)
     config = CopyTunerClient::Configuration.new
-    expect(Logger).to have_received(:new).with($stdout)
     expect(config.logger.original_logger).to eq(logger)
   end
 
@@ -194,19 +193,19 @@ end
 
 shared_context 'stubbed configuration' do
   subject { CopyTunerClient::Configuration.new }
-  let(:backend) { stub('i18n-backend') }
-  let(:cache) { stub('cache', :download => "download") }
-  let(:client) { stub('client') }
+  let(:backend) { double('i18n-backend') }
+  let(:cache) { double('cache', download: "download") }
+  let(:client) { double('client') }
   let(:logger) { FakeLogger.new }
-  let(:poller) { stub('poller') }
-  let(:process_guard) { stub('process_guard', :start => nil) }
+  let(:poller) { double('poller') }
+  let(:process_guard) { double('process_guard', start: nil) }
 
   before do
-    CopyTunerClient::I18nBackend.stubs :new => backend
-    CopyTunerClient::Client.stubs :new => client
-    CopyTunerClient::Cache.stubs :new => cache
-    CopyTunerClient::Poller.stubs :new => poller
-    CopyTunerClient::ProcessGuard.stubs :new => process_guard
+    allow(CopyTunerClient::I18nBackend).to receive(:new).and_return(backend)
+    allow(CopyTunerClient::Client).to receive(:new).and_return(client)
+    allow(CopyTunerClient::Cache).to receive(:new).and_return(cache)
+    allow(CopyTunerClient::Poller).to receive(:new).and_return(poller)
+    allow(CopyTunerClient::ProcessGuard).to receive(:new).and_return(process_guard)
     subject.logger = logger
     apply
   end
@@ -243,7 +242,7 @@ end
 describe CopyTunerClient::Configuration, 'applied when testing' do
   it_should_behave_like 'applied configuration' do
     it 'does not start the process guard' do
-      expect(process_guard).to have_received(:start).never
+      expect(process_guard).not_to receive(:start)
     end
   end
 
@@ -334,13 +333,16 @@ describe CopyTunerClient::Configuration, 'applied with locale filter' do
 end
 
 describe CopyTunerClient::Configuration, 'applied with Rails i18n config' do
+  let!(:rails_defined) { Object.const_defined?(:Rails) }
+
   def self.with_config(i18n_options)
-    around do |ex|
-      rails_defined = Object.const_defined?(:Rails)
+    before do
       Object.const_set :Rails, Module.new unless rails_defined
-      i18n = stub(i18n_options)
-      Rails.stubs application: stub(config: stub(i18n: i18n))
-      ex.run
+      i18n = double('i18n', i18n_options)
+      allow(Rails).to receive_message_chain(:application, :config, :i18n) { i18n }
+    end
+
+    after do
       Object.send(:remove_const, :Rails) unless rails_defined
     end
   end

data/spec/copy_tuner_client/i18n_backend_spec.rb

@@ -11,7 +11,7 @@ describe CopyTunerClient::I18nBackend do
 
   before do
     @default_backend = I18n.backend
-    cache.stubs(:wait_for_download)
+    allow(cache).to receive(:wait_for_download)
   end
 
   after { I18n.backend = @default_backend }
@@ -19,12 +19,10 @@ describe CopyTunerClient::I18nBackend do
   subject { build_backend }
 
   it "reloads locale files and waits for the download to complete" do
-    I18n.stubs(:load_path => [])
+    expect(I18n).to receive(:load_path).and_return([])
+    expect(cache).to receive(:wait_for_download)
     subject.reload!
     subject.translate('en', 'test.key', :default => 'something')
-
-    expect(cache).to have_received(:wait_for_download)
-    expect(I18n).to have_received(:load_path)
   end
 
   it "includes the base i18n backend" do
@@ -41,8 +39,8 @@ describe CopyTunerClient::I18nBackend do
   end
 
   it "finds available locales from locale files and cache" do
-    YAML.stubs(:load_file => { 'es' => { 'key' => 'value' } })
-    I18n.stubs(:load_path => ["test.yml"])
+    allow(YAML).to receive(:load_file).and_return({ 'es' => { 'key' => 'value' } })
+    allow(I18n).to receive(:load_path).and_return(["test.yml"])
 
     cache['en.key'] = ''
     cache['fr.key'] = ''

data/spec/copy_tuner_client/poller_spec.rb

@@ -61,7 +61,8 @@ describe CopyTunerClient::Poller do
   it "stops polling with an invalid api key" do
     failure = "server is napping"
     logger = FakeLogger.new
-    cache.stubs(:download).raises(CopyTunerClient::InvalidApiKey.new(failure))
+
+    expect(cache).to receive(:download).and_raise(CopyTunerClient::InvalidApiKey.new(failure))
     poller = build_poller(:logger => logger)
 
     cache['upload.key'] = 'upload'
@@ -77,7 +78,7 @@ describe CopyTunerClient::Poller do
   end
 
   it "logs an error if the background thread can't start" do
-    Thread.stubs(:new => nil)
+    expect(Thread).to receive(:new).and_return(nil)
     logger = FakeLogger.new
 
     build_poller(:logger => logger).start
@@ -87,12 +88,10 @@ describe CopyTunerClient::Poller do
 
   it "flushes the log when polling" do
     logger = FakeLogger.new
-    logger.stubs(:flush)
+    expect(logger).to receive(:flush).at_least(:once)
 
     build_poller(:logger => 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

@@ -24,11 +24,9 @@ describe CopyTunerClient::PrefixedLogger do
   end
 
   it "calls flush for a logger that responds to flush" do
-    output_logger.stubs(:flush)
+    expect(output_logger).to receive(: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

data/spec/copy_tuner_client/process_guard_spec.rb

@@ -11,24 +11,26 @@ describe CopyTunerClient::ProcessGuard do
     $0 = @original_process_name
   end
 
-  let(:cache) { stub('cache', :flush => nil) }
-  let(:poller) { stub('poller', :start => nil) }
+  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
     options[:cache]  ||= cache
-    CopyTunerClient::ProcessGuard.new(options[:cache], poller, options)
+    process_guard = CopyTunerClient::ProcessGuard.new(options[:cache], poller, options)
+    allow(process_guard).to receive(:register_exit_hooks) unless preserve_exit_hook
+    process_guard
   end
 
   it "starts polling from a worker process" do
+    expect(poller).to receive(:start)
     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)
     logger = FakeLogger.new
     passenger = define_constant('PhusionPassenger', FakePassenger.new)
     passenger.become_master
@@ -37,10 +39,10 @@ describe CopyTunerClient::ProcessGuard do
     process_guard.start
 
     expect(logger).to have_entry(:info, "Registered Phusion Passenger fork hook")
-    expect(poller).to have_received(:start).never
   end
 
   it "starts polling from a passenger worker" do
+    expect(poller).to receive(:start)
     logger = FakeLogger.new
     passenger = define_constant('PhusionPassenger', FakePassenger.new)
     passenger.become_master
@@ -48,11 +50,10 @@ describe CopyTunerClient::ProcessGuard do
 
     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)
     logger = FakeLogger.new
     define_constant('Unicorn', Module.new)
     http_server = Class.new(FakeUnicornServer)
@@ -63,10 +64,10 @@ describe CopyTunerClient::ProcessGuard do
     process_guard.start
 
     expect(logger).to have_entry(:info, "Registered Unicorn fork hook")
-    expect(poller).to have_received(:start).never
   end
 
   it "starts polling from a unicorn worker" do
+    expect(poller).to receive(:start)
     logger = FakeLogger.new
     define_constant('Unicorn', Module.new)
     http_server = Class.new(FakeUnicornServer)
@@ -76,14 +77,12 @@ describe CopyTunerClient::ProcessGuard do
 
     process_guard.start
     unicorn.spawn
-
-    expect(poller).to have_received(:start)
   end
 
   it "flushes when the process terminates" do
     cache = WritingCache.new
     pid = fork do
-      process_guard = build_process_guard(:cache => cache)
+      process_guard = build_process_guard(cache: cache, preserve_exit_hook: true)
       process_guard.start
       exit
     end

data/spec/copy_tuner_client/request_sync_spec.rb

@@ -5,16 +5,16 @@ describe CopyTunerClient::RequestSync do
   let(:cache) { {} }
   let(:response) { 'response' }
   let(:env) { 'env' }
-  let(:app) { stub('app', :call => response) }
+  let(:app) { double('app', :call => response) }
   before do
-    cache.stubs(:flush => nil, :download => nil)
-    poller.stubs(:start_sync => 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(app).to have_received(:call).with(env)
     expect(result).to eq(response)
   end
 end
@@ -26,18 +26,18 @@ describe CopyTunerClient::RequestSync, 'serving assets' do
   let(:poller) { {} }
   let(:cache) { {} }
   let(:response) { 'response' }
-  let(:app) { stub('app', :call => response) }
+  let(:app) { double('app', :call => response) }
   before do
-    cache.stubs(:flush => nil, :download => nil)
-    poller.stubs(:start_sync => 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 "don't start sync" do
+    expect(cache).to receive(:download).once
     subject.call(env)
-    expect(cache).to have_received(:download).once
+    expect(poller).not_to receive(:start_sync)
     subject.call(env)
-    expect(poller).to have_received(:start_sync).never
   end
 end
 
@@ -46,36 +46,38 @@ describe CopyTunerClient::RequestSync do
   let(:cache) { {} }
   let(:response) { 'response' }
   let(:env) { 'env' }
-  let(:app) { stub('app', :call => response) }
+  let(:app) { double('app', :call => response) }
   subject { CopyTunerClient::RequestSync.new(app, :poller => poller, :cache => cache, :interval => 10) }
   before do
-    cache.stubs(:flush => nil, :download => nil)
-    poller.stubs(:start_sync => nil)
+    allow(cache).to receive_messages(:flush => nil, :download => nil)
+    allow(poller).to receive(:start_sync).and_return(nil)
   end
 
   context "first request" do
     it "download" do
+      expect(cache).to receive(:download).once
       subject.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
+      expect(cache).to receive(:download).once
       subject.call(env)
-      expect(cache).to have_received(:download).once
+
+      expect(poller).not_to receive(:start_sync)
       subject.call(env)
-      expect(poller).to have_received(:start_sync).never
     end
   end
 
   context 'over interval request' do
     it "start sync for the second time" do
+      expect(cache).to receive(:download).once
       subject.call(env)
-      expect(cache).to have_received(:download).once
+
+      expect(poller).to receive(:start_sync).once
       subject.last_synced = Time.now - 60
       subject.call(env)
-      expect(poller).to have_received(:start_sync).once
     end
   end
 end