ghost_reader 1.1.2 → 1.1.3

data/lib/ghost_reader/backend.rb

@@ -9,6 +9,9 @@ module GhostReader
 
       attr_accessor :config, :missings
 
+      # exposed for testing & debugging
+      attr_reader :retriever, :reporter
+
       # for options see code of default_config
       def initialize(conf={})
         self.config = OpenStruct.new(default_config.merge(conf))
@@ -16,7 +19,7 @@ module GhostReader
         config.logger = Logger.new(config.logfile || STDOUT)
         config.logger.level = config.log_level || Logger::WARN
         config.service[:logger] ||= config.logger
-        config.client = Client.new(config.service)
+        config.client ||= Client.new(config.service)
         unless config.no_auto_spawn
           config.logger.debug "GhostReader spawning agents."
           spawn_retriever
@@ -35,17 +38,26 @@ module GhostReader
       # this won't be called if memoize kicks in
       def lookup(locale, key, scope = [], options = {})
         raise 'no fallback given' if config.fallback.nil?
-        config.fallback.translate(locale, key, options).tap do |result|
-          # TODO results which are hashes need to be tracked disaggregated
-          track({ key => { locale => { 'default' => result } } }) unless result.is_a?(Hash)
-        end
+        config.logger.debug "lookup: #{locale} #{key} #{scope.inspect} #{options.inspect}"
+        
+        result = config.fallback.translate(locale, key, options)
+        config.logger.debug "fallback result: #{result.inspect}"
+        return result
+      rescue Exception => ex
+        config.logger.debug "fallback.translate raised exception: #{ex}"
+      ensure # make sure everything is tracked
+        # TODO results which are hashes need to be tracked disaggregated
+        track({ key => { locale.to_s => { 'default' => result } } }) unless result.is_a?(Hash)
+        ex.nil? ? result : raise(ex)
       end
 
       def track(missings)
         return if self.missings.nil? # not yet initialized
+        config.logger.debug "tracking: #{missings.inspect}"
         self.missings.deep_merge!(missings)
       end
 
+      # data, e.g. {'en' => {'this' => {'is' => {'a' => {'test' => 'This is a test.'}}}}}
       def memoize_merge!(data, options={ :method => :merge! })
         flattend = flatten_translations_for_all_locales(data)
         symbolized_flattend = symbolize_keys(flattend)
@@ -55,7 +67,7 @@ module GhostReader
       # performs initial and incremental requests
       def spawn_retriever
         config.logger.debug "Spawning retriever."
-        Thread.new do
+        @retriever = Thread.new do
           begin
             config.logger.debug "Performing initial request."
             response = config.client.initial_request
@@ -88,7 +100,7 @@ module GhostReader
       # performs reporting requests
       def spawn_reporter
         config.logger.debug "Spawning reporter."
-        Thread.new do
+        @reporter = Thread.new do
           until false
             begin
               sleep config.report_interval

data/lib/ghost_reader/version.rb

@@ -1,3 +1,3 @@
 module GhostReader
-  VERSION = "1.1.2"
+  VERSION = "1.1.3"
 end

data/spec/ghost_reader/backend_spec.rb

@@ -2,88 +2,143 @@ require 'spec_helper'
 
 describe GhostReader::Backend do
 
+  let(:dev_null) { File.new('/dev/null', 'w') }
+
+  let(:client) do
+    mock("Client").tap do |client|
+      response = {'en' => {'this' => {'is' => {'a' => {'test' => 'This is a test.'}}}}}
+      client.stub!(:initial_request).and_return(:data => response)
+      client.stub!(:incremental_request).and_return(:data => response)
+      client.stub!(:reporting_request)
+    end
+  end
+
   context 'on class level' do
     it 'should nicely initialize' do
-      backend = GhostReader::Backend.new
+      GhostReader::Backend.new( :logfile => dev_null ).should be_instance_of(GhostReader::Backend)
     end
   end
 
   context 'Backend set up with fallback' do
 
-    before(:each) do
-      @translation = 'This is a test.'
-      @fallback = mock "FallbackBackend"
-      @fallback.stub!(:translate).and_return(@translation)
-      @backend = GhostReader::Backend.new(:fallback => @fallback)
+    let(:translation) { 'This is a test.' }
+
+    let(:fallback) do
+      mock("FallbackBackend").tap do |fallback|
+        fallback.stub!(:translate).and_return(translation)
+      end
+    end
+
+    let(:backend) do
+      GhostReader::Backend.new( :logfile => dev_null,
+                                :log_level => Logger::DEBUG,
+                                :fallback => fallback )
     end
 
     it 'should use the given fallback' do
-      @backend.config.fallback.should be(@fallback)
-      @fallback.should_receive(:translate)
-      @backend.translate(:en, 'this.is.a.test').should eq(@translation)
+      backend.config.fallback.should be(fallback)
+      fallback.should_receive(:translate)
+      backend.translate(:en, 'this.is.a.test').should eq(translation)
     end
 
     it 'should track missings' do
-      @backend.missings = {} # fake init
-      @backend.translate(:en, 'this.is.a.test')
-      @backend.missings.keys.should eq(['this.is.a.test'])
+      backend.missings = {} # fake init
+      backend.translate(:en, 'this.is.a.test')
+      backend.missings.keys.should eq(['this.is.a.test'])
     end
 
     it 'should use memoization' do
-      @fallback.should_receive(:translate).exactly(1)
-      2.times { @backend.translate(:en, 'this.is.a.test').should eq(@translation) }
+      fallback.should_receive(:translate).exactly(1)
+      2.times { backend.translate(:en, 'this.is.a.test').should eq(translation) }
     end
 
     it 'should symbolize keys' do
       test_data = { "one" => "1", "two" => "2"}
-      result = @backend.send(:symbolize_keys, test_data)
+      result = backend.send(:symbolize_keys, test_data)
       result.has_key?(:one).should be_true
     end
 
     it 'should nicely respond to available_locales' do
-      @backend.should respond_to(:available_locales)
+      backend.should respond_to(:available_locales)
 
       expected = [:en, :de]
-      @fallback.stub!(:available_locales).and_return(expected)
-      @backend.available_locales.should eq(expected)
+      fallback.stub!(:available_locales).and_return(expected)
+      backend.available_locales.should eq(expected)
 
       # FIXME
-      # @backend.send(:memoize_merge!, :it => {'dummay' => 'Dummy'})
-      # @backend.translate(:it, 'this.is.a.test')
-      # @backend.available_locales.should eq([:it, :en, :de])
+      # backend.send(:memoize_merge!, :it => {'dummay' => 'Dummy'})
+      # backend.translate(:it, 'this.is.a.test')
+      # backend.available_locales.should eq([:it, :en, :de])
     end
 
     context 'nicely merge data into memoized_hash' do
 
       it 'should work with valid data' do
         data = {'en' => {'this' => {'is' => {'a' => {'test' => 'This is a test.'}}}}}
-        @backend.send(:memoize_merge!, data)
-        @backend.send(:memoized_lookup).should have_key(:en)
+        backend.send(:memoize_merge!, data)
+        backend.send(:memoized_lookup).should have_key(:en)
         # flattend and symbolized
-        @backend.send(:memoized_lookup)[:en].should have_key(:'this.is.a.test')
+        backend.send(:memoized_lookup)[:en].should have_key(:'this.is.a.test')
       end
 
       it 'should handle weird data gracefully' do
         expect do
           data = {'en' => {'value_is_an_hash' => {'1st' => 'bla', '2nd' => 'blub'}}}
-          @backend.send(:memoize_merge!, data)
+          backend.send(:memoize_merge!, data)
           data = {'en' => {'empty_value' => ''}}
-          @backend.send(:memoize_merge!, data)
+          backend.send(:memoize_merge!, data)
           data = {'en' => {'' => 'Empty key.'}} 
-          @backend.send(:memoize_merge!, data) # 'interning empty string'
+          backend.send(:memoize_merge!, data) # 'interning empty string'
           data = {'en' => {'value_is_an_array' => %w(what the fuck)}}
-          @backend.send(:memoize_merge!, data)
+          backend.send(:memoize_merge!, data)
         end.to_not raise_error
       end
       
       # key should not be empty but if it is...
       it 'should not raise error when key is empty' do
         data = {'en' => {'' => 'Empty key.'}} 
-        @backend.send(:memoize_merge!, data) # 'interning empty string'
-        @backend.send(:memoized_lookup).should be_empty
+        backend.send(:memoize_merge!, data) # 'interning empty string'
+        backend.send(:memoized_lookup).should be_empty
+      end
+
+    end
+
+  end
+
+  context 'GhostReader set up without fallback' do
+    let(:backend) { GhostReader::Backend.new(:logfile => dev_null) }
+    
+    it 'should raise an error' do
+      expect { backend.translate(:de, :asdf) }.to raise_error('no fallback given')
+    end
+  end
+  
+  context 'GhostReader set up with raising fallback' do
+    let(:fallback) do
+      mock("FallbackBackend").tap do |fallback|
+        fallback.stub!(:translate) do
+          raise 'missing translation'
+        end
       end
+    end
+
+    let(:backend) do
+      GhostReader::Backend.new( :logfile => dev_null,
+                                :log_level => Logger::DEBUG,
+                                :fallback => fallback,
+                                :client => client )
+    end
 
+    it 'should behave nicely' do
+      expect { backend.translate(:de, :asdf) }.to raise_error('missing translation') 
     end
 
+    it 'should track lookups which raise exceptions' do
+      backend.retriever.should be_alive
+      backend.missings.should_not be_nil
+      expect { backend.translate(:de, :asdf) }.to raise_error('missing translation')
+      backend.missings.should_not be_empty
+    end
   end
+
 end

data/spec/ghost_reader/client_spec.rb

@@ -1,6 +1,4 @@
 require 'spec_helper'
-require File.expand_path(File.join(%w(.. .. .. lib ghost_reader)), __FILE__)
-
 
 Excon.mock = true
 
@@ -12,6 +10,8 @@ end
 
 describe GhostReader::Client do
 
+  let(:dev_null) { File.new('/dev/null', 'w') }
+
   context 'on class level' do
     it 'should nicely initialize' do
       GhostReader::Client.new.should be_an_instance_of(GhostReader::Client)
@@ -20,7 +20,10 @@ describe GhostReader::Client do
 
   context 'a initialized client' do
 
-    let(:client) { GhostReader::Client.new(:api_key => 'some+api_key') }
+    let(:client) do
+      GhostReader::Client.new( :logfile => dev_null,
+                               :api_key => 'some+api_key' )
+    end
 
     before(:each) { Excon.kill_stubs! }
 

data/spec/spec_helper.rb

@@ -1 +1,2 @@
 require 'rubygems'
+require File.expand_path(File.join(%w(.. .. lib ghost_reader)), __FILE__)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ghost_reader
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 1
   - 1
-  - 2
-  version: 1.1.2
+  - 3
+  version: 1.1.3
 platform: ruby
 authors: 
 - Phil Hofmann
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-11 00:00:00 +02:00
+date: 2012-01-17 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency