copycopter_client 1.0.0.beta1

data/spec/copycopter_client/helper_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'copycopter_client/helper'
+
+describe CopycopterClient::Helper do
+  subject { Object.new }
+
+  before do
+    class << subject
+      include CopycopterClient::Helper
+      def warn(*args); end # these are annoying in test output
+    end
+    I18n.stubs(:translate)
+  end
+
+  Spec::Matchers.define :have_translated do |key, default|
+    match do |ignored_subject|
+      extend Mocha::API
+      I18n.should have_received(:translate).with(key, :default => default)
+    end
+  end
+
+  it "translates keys on CopycopterClient.s" do
+    CopycopterClient.s('test.key', 'default')
+    should have_translated("test.key", 'default')
+  end
+
+  it "translates keys on CopycopterClient.copy_for" do
+    CopycopterClient.copy_for('test.key', 'default')
+    should have_translated("test.key", 'default')
+  end
+
+  it "uses existing scope by partial key when present" do
+    subject.stubs(:scope_key_by_partial => "controller.action.key")
+    class << subject
+      private :scope_key_by_partial
+    end
+
+    subject.s(".key")
+
+    subject.should have_received(:scope_key_by_partial).with(".key")
+    should have_translated("controller.action.key", nil)
+  end
+
+  it "should prepend current partial when key starts with . and inside a view" do
+    template = stub(:path_without_format_and_extension => "controller/action")
+    subject.stubs(:template => template)
+
+    subject.s(".key")
+
+    should have_translated("controller.action.key", nil)
+  end
+
+  it "should prepend controller and action when key starts with . and inside a controller" do
+    subject.stubs(:controller_name => "controller", :action_name => "action")
+
+    subject.s(".key")
+
+    should have_translated("controller.action.key", nil)
+  end
+
+  describe "default assignment" do
+    before do
+      subject.stubs(:scope_copycopter_key_by_partial => '.key')
+    end
+
+    it "should allow a hash with key default" do
+      subject.s(@key, :default => "Default string")
+      should have_translated('.key', "Default string")
+    end
+
+    it "should not allow a hash with stringed key default" do
+      subject.s(@key, "default" => "Default string")
+      should have_translated('.key', nil)
+    end
+
+    it "should not allow a hash with key other than default" do
+      subject.s(@key, :junk => "Default string")
+      should have_translated('.key', nil)
+    end
+
+    it "should allow a string" do
+      subject.s(@key, "Default string")
+      should have_translated('.key', "Default string")
+    end
+  end
+end

data/spec/copycopter_client/i18n_backend_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe CopycopterClient::I18nBackend do
+  let(:sync) { {} }
+
+  def build_backend(config = {})
+    default_config = CopycopterClient::Configuration.new.to_hash
+    backend = CopycopterClient::I18nBackend.new(sync, default_config.update(config))
+    I18n.backend = backend
+    backend
+  end
+
+  before { @default_backend = I18n.backend }
+  after { I18n.backend = @default_backend }
+
+  subject { build_backend }
+
+  it "waits until the first download when reloaded" do
+    sync.stubs(:wait_for_download)
+
+    subject.reload!
+
+    sync.should have_received(:wait_for_download)
+  end
+
+  it "includes the base i18n backend" do
+    should be_kind_of(I18n::Backend::Base)
+  end
+
+  it "looks up a key in sync" do
+    value = 'hello'
+    sync['en.prefix.test.key'] = value
+
+    backend = build_backend
+
+    backend.translate('en', 'test.key', :scope => 'prefix').should == value
+  end
+
+  it "finds available locales" do
+    sync['en.key'] = ''
+    sync['fr.key'] = ''
+
+    subject.available_locales.should =~ %w(en fr)
+  end
+
+  it "queues missing keys with default" do
+    default = 'default value'
+
+    subject.translate('en', 'test.key', :default => default).should == default
+
+    sync['en.test.key'].should == default
+  end
+
+  it "queues missing keys without default" do
+    expect { subject.translate('en', 'test.key') }.
+      to raise_error(I18n::MissingTranslationData)
+
+    sync['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
+
+    sync['en.test.key'].should == default
+  end
+
+  it "marks strings as html safe" do
+    sync['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
+    sync['en.key.one'] = "Expected"
+    backend = build_backend
+    backend.translate('en', 'key.three', :default => [:"key.two", :"key.one"]).
+      should == 'Expected'
+  end
+
+  describe "with a fallback" do
+    let(:fallback) { I18n::Backend::Simple.new }
+    subject { build_backend(:fallback_backend => fallback) }
+
+    it "uses the fallback as a default" do
+      fallback.store_translations('en', 'test' => { 'key' => 'Expected' })
+      subject.translate('en', 'test.key', :default => 'Unexpected').
+        should include('Expected')
+      sync['en.test.key'].should == 'Expected'
+    end
+
+    it "preserves interpolation markers in the fallback" do
+      fallback.store_translations('en', 'test' => { 'key' => '%{interpolate}' })
+      subject.translate('en', 'test.key', :interpolate => 'interpolated').
+        should include('interpolated')
+      sync['en.test.key'].should == '%{interpolate}'
+    end
+
+    it "uses the default if the fallback doesn't have the key" do
+      subject.translate('en', 'test.key', :default => 'Expected').
+        should include('Expected')
+    end
+
+    it "uses the syncd key when present" do
+      fallback.store_translations('en', 'test' => { 'key' => 'Unexpected' })
+      sync['en.test.key'] = 'Expected'
+      subject.translate('en', 'test.key', :default => 'default').
+        should include('Expected')
+    end
+
+    it "returns a hash directly without storing" do
+      nested = { :nested => 'value' }
+      fallback.store_translations('en', 'key' => nested)
+      subject.translate('en', 'key', :default => 'Unexpected').should == nested
+      sync['en.key'].should be_nil
+    end
+
+    it "returns an array directly without storing" do
+      array = ['value']
+      fallback.store_translations('en', 'key' => array)
+      subject.translate('en', 'key', :default => 'Unexpected').should == array
+      sync['en.key'].should be_nil
+    end
+
+    it "looks up an array of defaults" do
+      fallback.store_translations('en', 'key' => { 'one' => 'Expected' })
+      subject.translate('en', 'key.three', :default => [:"key.two", :"key.one"]).
+        should include('Expected')
+    end
+  end
+end

data/spec/copycopter_client/prefixed_logger_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe CopycopterClient::PrefixedLogger do
+  let(:output_logger) { FakeLogger.new }
+  let(:prefix) { "** NOTICE:" }
+  let(:thread_info) { "[P:#{Process.pid}] [T:#{Thread.current.object_id}]" }
+  subject { CopycopterClient::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
+end

data/spec/copycopter_client/sync_spec.rb

@@ -0,0 +1,295 @@
+require 'spec_helper'
+
+describe CopycopterClient::Sync do
+  include DefinesConstants
+
+  let(:client) { FakeClient.new }
+
+  def build_sync(config = {})
+    config[:logger] ||= FakeLogger.new
+    default_config = CopycopterClient::Configuration.new.to_hash
+    sync = CopycopterClient::Sync.new(client, default_config.update(config))
+    @syncs << sync
+    sync
+  end
+
+  before do
+    @syncs = []
+  end
+
+  after { @syncs.each { |sync| sync.stop } }
+
+  it "syncs when the process terminates" do
+    api_key = "12345"
+    FakeCopycopterApp.add_project api_key
+    pid = fork do
+      config = { :logger => FakeLogger.new, :polling_delay => 86400, :api_key => api_key }
+      default_config = CopycopterClient::Configuration.new.to_hash.update(config)
+      real_client = CopycopterClient::Client.new(default_config)
+      sync = CopycopterClient::Sync.new(real_client, default_config)
+      sync.start
+      sleep 2
+      sync['test.key'] = 'value'
+      Signal.trap("INT") { exit }
+      sleep
+    end
+    sleep 3
+    Process.kill("INT", pid)
+    Process.wait
+    project = FakeCopycopterApp.project(api_key)
+    project.draft['test.key'].should == 'value'
+  end
+
+  it "provides access to downloaded data" do
+    client['en.test.key']       = 'expected'
+    client['en.test.other_key'] = 'expected'
+
+    sync = build_sync
+
+    sync.start
+
+    sync['en.test.key'].should == 'expected'
+    sync.keys.should =~ %w(en.test.key en.test.other_key)
+  end
+
+  it "it polls after being started" do
+    sync = build_sync(:polling_delay => 1)
+    sync.start
+
+    sync['test.key'].should be_nil
+
+    client['test.key'] = 'value'
+    sleep(2)
+
+    sync['test.key'].should == 'value'
+  end
+
+  it "stops polling when stopped" do
+    sync = build_sync(:polling_delay => 1)
+    sync.start
+
+    sync['test.key'].should be_nil
+
+    sync.stop
+
+    client['test.key'] = 'value'
+    sleep(2)
+
+    sync['test.key'].should be_nil
+  end
+
+  it "doesn't upload without changes" do
+    sync = build_sync(:polling_delay => 1)
+    sync.start
+    sleep(2)
+    client.should_not be_uploaded
+  end
+
+  it "uploads changes when polling" do
+    sync = build_sync(:polling_delay => 1)
+    sync.start
+
+    sync['test.key'] = 'test value'
+    sleep(2)
+
+    client.uploaded.should == { 'test.key' => 'test value' }
+  end
+
+  it "handles connection errors when polling" do
+    failure = "server is napping"
+    logger = FakeLogger.new
+    client.stubs(:upload).raises(CopycopterClient::ConnectionError.new(failure))
+    sync = build_sync(:polling_delay => 1, :logger => logger)
+
+    sync['upload.key'] = 'upload'
+    sync.start
+    sleep(2)
+
+    logger.should have_entry(:error, failure),
+                  logger.entries.inspect
+
+    client['test.key'] = 'test value'
+    sleep(2)
+
+    sync['test.key'].should == 'test value'
+  end
+
+  it "handles an invalid api key" do
+    failure = "server is napping"
+    logger = FakeLogger.new
+    client.stubs(:upload).raises(CopycopterClient::InvalidApiKey.new(failure))
+    sync = build_sync(:polling_delay => 1, :logger => logger)
+
+    sync['upload.key'] = 'upload'
+    sync.start
+    sleep(2)
+
+    logger.should have_entry(:error, failure),
+                  logger.entries.inspect
+
+    client['test.key'] = 'test value'
+    sleep(2)
+
+    sync['test.key'].should be_nil
+  end
+
+  it "starts after spawning when using passenger" do
+    logger = FakeLogger.new
+    passenger = define_constant('PhusionPassenger', FakePassenger.new)
+    passenger.become_master
+    sync = build_sync(:polling_delay => 1, :logger => logger)
+
+    sync.start
+    sleep(2)
+
+    client.should_not be_downloaded
+    logger.should have_entry(:info, "Registered Phusion Passenger fork hook")
+
+    passenger.spawn
+    sleep(2)
+
+    client.should be_downloaded
+    logger.should have_entry(:info, "Starting poller"),
+                  "Got entries: #{logger.entries.inspect}"
+  end
+
+  it "starts after spawning when using unicorn" do
+    logger = FakeLogger.new
+    define_constant('Unicorn', Module.new)
+    unicorn = define_constant('Unicorn::HttpServer', FakeUnicornServer).new
+    unicorn.become_master
+    sync = build_sync(:polling_delay => 1, :logger => logger)
+    CopycopterClient.sync = sync
+
+    sync.start
+    sleep(2)
+
+    client.should_not be_downloaded
+    logger.should have_entry(:info, "Registered Unicorn fork hook")
+
+    unicorn.spawn
+    sleep(2)
+
+    client.should be_downloaded
+    logger.should have_entry(:info, "Starting poller")
+  end
+
+  it "blocks until the first download is complete" do
+    logger = FakeLogger.new
+    client.delay = 1
+    sync = build_sync(:logger => logger)
+
+    sync.start
+
+    finished = false
+    Thread.new do
+      sync.wait_for_download
+      finished = true
+    end
+
+    logger.should have_entry(:info, "Waiting for first sync")
+    finished.should == false
+
+    sleep(3)
+
+    finished.should == true
+  end
+
+  it "doesn't block if the first download fails" do
+    client.delay = 1
+    client.stubs(:upload).raises(StandardError.new("Failure"))
+    sync = build_sync
+
+    sync['test.key'] = 'value'
+    sync.start
+
+    finished = false
+    Thread.new do
+      sync.wait_for_download
+      finished = true
+    end
+
+    finished.should == false
+
+    sleep(4)
+
+    finished.should == true
+  end
+
+  it "doesn't block before starting" do
+    logger = FakeLogger.new
+    sync = build_sync(:polling_delay => 3, :logger => logger)
+
+    finished = false
+    Thread.new do
+      sync.wait_for_download
+      finished = true
+    end
+
+    sleep(1)
+
+    finished.should == true
+    logger.should_not have_entry(:info, "Waiting for first sync")
+  end
+
+  describe "given locked mutex" do
+    Spec::Matchers.define :finish_after_unlocking do |mutex|
+      match do |thread|
+        sleep(0.1)
+
+        if thread.status === false
+          violated("finished before unlocking")
+        else
+          mutex.unlock
+          sleep(0.1)
+
+          if thread.status === false
+            true
+          else
+            violated("still running after unlocking")
+          end
+        end
+      end
+
+      def violated(failure)
+        @failure_message = failure
+        false
+      end
+
+      failure_message_for_should do
+        @failure_message
+      end
+    end
+
+    let(:mutex) { Mutex.new }
+    let(:sync) { build_sync(:polling_delay => 0.1) }
+
+    before do
+      mutex.lock
+      Mutex.stubs(:new => mutex)
+    end
+
+    it "synchronizes read access to keys between threads" do
+      Thread.new { sync['test.key'] }.should finish_after_unlocking(mutex)
+    end
+
+    it "synchronizes read access to the key list between threads" do
+      Thread.new { sync.keys }.should finish_after_unlocking(mutex)
+    end
+
+    it "synchronizes write access to keys between threads" do
+      Thread.new { sync['test.key'] = 'value' }.should finish_after_unlocking(mutex)
+    end
+  end
+
+  it "starts from the top-level constant" do
+    sync = build_sync
+    CopycopterClient.sync = sync
+    sync.stubs(:start)
+
+    CopycopterClient.start_sync
+
+    sync.should have_received(:start)
+  end
+end
+

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--format progress
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'spec'
+require 'spec/autorun'
+require 'bourne'
+require 'sham_rack'
+require 'webmock/rspec'
+
+PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+$LOAD_PATH << File.join(PROJECT_ROOT, "lib")
+
+require "copycopter_client"
+
+Dir.glob(File.join(PROJECT_ROOT, "spec", "support", "**", "*.rb")).each do |file|
+  require(file)
+end
+
+WebMock.disable_net_connect!
+ShamRack.mount(FakeCopycopterApp.new, "copycopter.com")
+
+Spec::Runner.configure do |config|
+  config.include ClientSpecHelpers
+  config.include WebMock
+  config.mock_with :mocha
+  config.before do
+    FakeCopycopterApp.reset
+    reset_config
+  end
+end
+

data/spec/support/client_spec_helpers.rb

@@ -0,0 +1,9 @@
+module ClientSpecHelpers
+  def reset_config
+    CopycopterClient.configuration = nil
+    CopycopterClient.configure(false) do |config|
+      config.api_key = 'abc123'
+    end
+  end
+end
+

data/spec/support/defines_constants.rb

@@ -0,0 +1,38 @@
+share_as :DefinesConstants do
+  def define_class(class_name, base = Object, &block)
+    class_name = class_name.to_s.camelize
+    klass = Class.new(base)
+    define_constant(class_name, klass)
+    klass.class_eval(&block) 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
+
+  before { @defined_constants = [] }
+
+  after do
+    @defined_constants.reverse.each do |path|
+      parse_constant(path) do |parent, name|
+        parent.send(:remove_const, name)
+      end
+    end
+  end
+end
+

data/spec/support/fake_client.rb

@@ -0,0 +1,42 @@
+class FakeClient
+  def initialize
+    @data = {}
+    @uploaded = {}
+    @uploads = 0
+    @downloads = 0
+  end
+
+  attr_reader :uploaded, :uploads, :downloads
+  attr_accessor :delay
+
+  def []=(key, value)
+    @data[key] = value
+  end
+
+  def download
+    wait_for_delay
+    @downloads += 1
+    @data.dup
+  end
+
+  def upload(data)
+    wait_for_delay
+    @uploaded.update(data)
+    @uploads += 1
+  end
+
+  def uploaded?
+    @uploads > 0
+  end
+
+  def downloaded?
+    @downloads > 0
+  end
+
+  private
+
+  def wait_for_delay
+    sleep(delay) if delay
+  end
+end
+