copy_tuner_client 0.0.1

data/spec/copy_tuner_client/i18n_backend_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe CopyTunerClient::I18nBackend do
+  let(:cache) { {} }
+
+  def build_backend
+    backend = CopyTunerClient::I18nBackend.new(cache)
+    I18n.backend = backend
+    backend
+  end
+
+  before do
+    @default_backend = I18n.backend
+    cache.stubs(:wait_for_download)
+  end
+
+  after { I18n.backend = @default_backend }
+
+  subject { build_backend }
+
+  it "reloads locale files and waits for the download to complete" do
+    I18n.stubs(:load_path => [])
+    subject.reload!
+    subject.translate('en', 'test.key', :default => 'something')
+
+    cache.should have_received(:wait_for_download)
+    I18n.should have_received(:load_path)
+  end
+
+  it "includes the base i18n backend" do
+    should be_kind_of(I18n::Backend::Base)
+  end
+
+  it "looks up a key in cache" do
+    value = 'hello'
+    cache['en.prefix.test.key'] = value
+
+    backend = build_backend
+
+    backend.translate('en', 'test.key', :scope => 'prefix').should == value
+  end
+
+  it "finds available locales from locale files and cache" do
+    YAML.stubs(:load_file => { 'es' => { 'key' => 'value' } })
+    I18n.stubs(:load_path => ["test.yml"])
+
+    cache['en.key'] = ''
+    cache['fr.key'] = ''
+
+    subject.available_locales.should =~ [:en, :es, :fr]
+  end
+
+  it "queues missing keys with default" do
+    default = 'default value'
+
+    subject.translate('en', 'test.key', :default => default).should == default
+
+    cache['en.test.key'].should == default
+  end
+
+  it "queues missing keys without default" do
+    expect { subject.translate('en', 'test.key') }.
+      to throw_symbol(:exception)
+
+    cache['en.test.key'].should == ""
+  end
+
+  it "queues missing keys with scope" do
+    default = 'default value'
+
+    subject.translate('en', 'key', :default => default, :scope => ['test']).
+      should == default
+
+    cache['en.test.key'].should == default
+  end
+
+  it "marks strings as html safe" do
+    cache['en.test.key'] = FakeHtmlSafeString.new("Hello")
+    backend = build_backend
+    backend.translate('en', 'test.key').should be_html_safe
+  end
+
+  it "looks up an array of defaults" do
+    cache['en.key.one'] = "Expected"
+    backend = build_backend
+    backend.translate('en', 'key.three', :default => [:"key.two", :"key.one"]).
+      should == 'Expected'
+  end
+
+  describe "with stored translations" do
+    subject { build_backend }
+
+    it "uses stored translations as a default" do
+      subject.store_translations('en', 'test' => { 'key' => 'Expected' })
+      subject.translate('en', 'test.key', :default => 'Unexpected').
+        should include('Expected')
+      cache['en.test.key'].should == 'Expected'
+    end
+
+    it "preserves interpolation markers in the stored translation" do
+      subject.store_translations('en', 'test' => { 'key' => '%{interpolate}' })
+      subject.translate('en', 'test.key', :interpolate => 'interpolated').
+        should include('interpolated')
+      cache['en.test.key'].should == '%{interpolate}'
+    end
+
+    it "uses the default if the stored translations don't have the key" do
+      subject.translate('en', 'test.key', :default => 'Expected').
+        should include('Expected')
+    end
+
+    it "uses the cached key when present" do
+      subject.store_translations('en', 'test' => { 'key' => 'Unexpected' })
+      cache['en.test.key'] = 'Expected'
+      subject.translate('en', 'test.key', :default => 'default').
+        should include('Expected')
+    end
+
+    it "stores a nested hash" do
+      nested = { :nested => 'value' }
+      subject.store_translations('en', 'key' => nested)
+      subject.translate('en', 'key', :default => 'Unexpected').should == nested
+      cache['en.key.nested'].should == 'value'
+    end
+
+    it "returns an array directly without storing" do
+      array = ['value']
+      subject.store_translations('en', 'key' => array)
+      subject.translate('en', 'key', :default => 'Unexpected').should == array
+      cache['en.key'].should be_nil
+    end
+
+    it "looks up an array of defaults" do
+      subject.store_translations('en', 'key' => { 'one' => 'Expected' })
+      subject.translate('en', 'key.three', :default => [:"key.two", :"key.one"]).
+        should include('Expected')
+    end
+  end
+
+  describe "with a backend using fallbacks" do
+    subject { build_backend }
+
+    before do
+      CopyTunerClient::I18nBackend.class_eval do
+        include I18n::Backend::Fallbacks
+      end
+    end
+
+    it "queues missing keys with default" do
+      default = 'default value'
+
+      subject.translate('en', 'test.key', :default => default).should == default
+
+      cache['en.test.key'].should == default
+    end
+  end
+end

data/spec/copy_tuner_client/poller_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe CopyTunerClient::Poller do
+  POLLING_DELAY = 0.5
+
+  let(:client) { FakeClient.new }
+  let(:cache) { CopyTunerClient::Cache.new(client, :logger => FakeLogger.new) }
+
+  def build_poller(config = {})
+    config[:logger] ||= FakeLogger.new
+    config[:polling_delay] = POLLING_DELAY
+    default_config = CopyTunerClient::Configuration.new.to_hash
+    poller = CopyTunerClient::Poller.new(cache, default_config.update(config))
+    @pollers << poller
+    poller
+  end
+
+  def wait_for_next_sync
+    sleep(POLLING_DELAY * 3)
+  end
+
+  before do
+    @pollers = []
+  end
+
+  after do
+    @pollers.each { |poller| poller.stop }
+  end
+
+  it "it polls after being started" do
+    poller = build_poller
+    poller.start
+
+    client['test.key'] = 'value'
+    wait_for_next_sync
+
+    cache['test.key'].should == 'value'
+  end
+
+  it "it doesn't poll before being started" do
+    poller = build_poller
+    client['test.key'] = 'value'
+
+    wait_for_next_sync
+
+    cache['test.key'].should be_nil
+  end
+
+  it "stops polling when stopped" do
+    poller = build_poller
+
+    poller.start
+    poller.stop
+
+    client['test.key'] = 'value'
+    wait_for_next_sync
+
+    cache['test.key'].should be_nil
+  end
+
+  it "stops polling with an invalid api key" do
+    failure = "server is napping"
+    logger = FakeLogger.new
+    cache.stubs(:download).raises(CopyTunerClient::InvalidApiKey.new(failure))
+    poller = build_poller(:logger => logger)
+
+    cache['upload.key'] = 'upload'
+    poller.start
+    wait_for_next_sync
+
+    logger.should have_entry(:error, failure)
+
+    client['test.key'] = 'test value'
+    wait_for_next_sync
+
+    cache['test.key'].should be_nil
+  end
+
+  it "logs an error if the background thread can't start" do
+    Thread.stubs(:new => nil)
+    logger = FakeLogger.new
+
+    build_poller(:logger => logger).start
+
+    logger.should have_entry(:error, "Couldn't start poller thread")
+  end
+
+  it "flushes the log when polling" do
+    logger = FakeLogger.new
+    logger.stubs(:flush)
+
+    build_poller(:logger => logger).start
+
+    wait_for_next_sync
+
+    logger.should have_received(:flush).at_least_once
+  end
+
+  it "starts from the top-level constant" do
+    poller = build_poller
+    CopyTunerClient.poller = poller
+    poller.stubs(:start)
+
+    CopyTunerClient.start_poller
+
+    poller.should have_received(:start)
+  end
+end

data/spec/copy_tuner_client/prefixed_logger_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe CopyTunerClient::PrefixedLogger do
+  let(:output_logger) { FakeLogger.new }
+  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
+    subject.prefix.should == prefix
+  end
+
+  it "provides the logger" do
+    subject.original_logger.should == output_logger
+  end
+
+  [:debug, :info, :warn, :error, :fatal].each do |level|
+    it "prefixes #{level} log messages" do
+      message = 'hello'
+      subject.send(level, message)
+
+      output_logger.should have_entry(level, "#{prefix} #{thread_info} #{message}")
+    end
+  end
+
+  it "calls flush for a logger that responds to flush" do
+    output_logger.stubs(:flush)
+
+    subject.flush
+
+    output_logger.should have_received(:flush)
+  end
+
+  it "doesn't call flush for a logger that doesn't respond to flush" do
+    lambda { subject.flush }.should_not raise_error
+  end
+end

data/spec/copy_tuner_client/process_guard_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe CopyTunerClient::ProcessGuard do
+  include DefinesConstants
+
+  before do
+    @original_process_name = $0
+  end
+
+  after do
+    $0 = @original_process_name
+  end
+
+  let(:cache) { stub('cache', :flush => nil) }
+  let(:poller) { stub('poller', :start => nil) }
+
+  def build_process_guard(options = {})
+    options[:logger] ||= FakeLogger.new
+    options[:cache]  ||= cache
+    CopyTunerClient::ProcessGuard.new(options[:cache], poller, options)
+  end
+
+  it "starts polling from a worker process" do
+    process_guard = build_process_guard
+
+    process_guard.start
+
+    poller.should have_received(:start)
+  end
+
+  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.start
+
+    logger.should have_entry(:info, "Registered Phusion Passenger fork hook")
+    poller.should have_received(:start).never
+  end
+
+  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.start
+    passenger.spawn
+
+    poller.should have_received(:start)
+  end
+
+  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.start
+
+    logger.should have_entry(:info, "Registered Unicorn fork hook")
+    poller.should have_received(:start).never
+  end
+
+  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.start
+    unicorn.spawn
+
+    poller.should 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.start
+      exit
+    end
+    Process.wait
+
+    cache.should be_written
+  end
+
+  it "flushes after running a resque job" do
+    logger = FakeLogger.new
+    cache = WritingCache.new
+    define_constant('Resque', Module.new)
+    job_class = define_constant('Resque::Job', FakeResqueJob)
+    job = job_class.new
+    process_guard = build_process_guard(:cache => cache, :logger => logger)
+
+    process_guard.start
+    job.fork_and_perform
+
+    cache.should be_written
+    logger.should have_entry(:info, "Registered Resque after_perform hook")
+  end
+
+  it "doesn't fail if only Resque is defined and not Resque::Job" do
+    logger = FakeLogger.new
+    cache = WritingCache.new
+    define_constant('Resque', Module.new)
+    process_guard = build_process_guard(:cache => cache, :logger => logger)
+
+    process_guard.start
+  end
+end

data/spec/copy_tuner_client/request_sync_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe CopyTunerClient::RequestSync do
+
+  let(:cache) { {} }
+  let(:response) { 'response' }
+  let(:env) { 'env' }
+  let(:app) { stub('app', :call => response) }
+  before { cache.stubs(:flush => nil, :download => nil) }
+  subject { CopyTunerClient::RequestSync.new(app, :cache => cache) }
+
+  it "invokes the upstream app" do
+    result = subject.call(env)
+    app.should have_received(:call).with(env)
+    result.should == response
+  end
+
+  it "flushes defaults" do
+    subject.call(env)
+    cache.should have_received(:flush)
+  end
+
+  it "downloads new copy" do
+    subject.call(env)
+    cache.should have_received(:download)
+  end
+end
+
+describe CopyTunerClient::RequestSync, 'serving assets' do
+  let(:env) do
+    { "PATH_INFO" => '/assets/choper.png' }
+  end
+  let(:cache) { {} }
+  let(:response) { 'response' }
+  let(:app) { stub('app', :call => response) }
+  before { cache.stubs(:flush => nil, :download => nil) }
+  subject { CopyTunerClient::RequestSync.new(app, :cache => cache) }
+
+  it "does not flush defaults" do
+    subject.call(env)
+    cache.should_not have_received(:flush)
+  end
+  it "does not download new copy" do
+    subject.call(env)
+    cache.should_not have_received(:download)
+  end
+end