copy_tuner_client 0.3.4 → 0.3.5

data/spec/copy_tuner_client/client_spec.rb

@@ -31,29 +31,29 @@ describe CopyTunerClient do
       project = add_project
       client = build_client(:api_key => project.api_key, :http_open_timeout => 4)
       client.download { |ignore| }
-      http.open_timeout.should == 4
+      expect(http.open_timeout).to eq(4)
     end
 
     it 'should timeout when reading' do
       project = add_project
       client = build_client(:api_key => project.api_key, :http_read_timeout => 4)
       client.download { |ignore| }
-      http.read_timeout.should == 4
+      expect(http.read_timeout).to eq(4)
     end
 
     it 'uses verified ssl when secure' do
       project = add_project
       client = build_client(:api_key => project.api_key, :secure => true)
       client.download { |ignore| }
-      http.use_ssl?.should == true
-      http.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+      expect(http.use_ssl?).to eq(true)
+      expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
     end
 
     it 'does not use ssl when insecure' do
       project = add_project
       client = build_client(:api_key => project.api_key, :secure => false)
       client.download { |ignore| }
-      http.use_ssl?.should == false
+      expect(http.use_ssl?).to eq(false)
     end
 
     it 'wraps HTTP errors with ConnectionError' do
@@ -75,8 +75,8 @@ describe CopyTunerClient do
         client = build_client_with_project
         expect { client.download { |ignore| } }.
           to raise_error(CopyTunerClient::ConnectionError) { |error|
-            error.message.
-              should == "#{original_error.class.name}: #{original_error.message}"
+            expect(error.message).
+              to eq("#{original_error.class.name}: #{original_error.message}")
           }
       end
     end
@@ -121,17 +121,17 @@ describe CopyTunerClient do
 
     client.download { |yielded| blurbs = yielded }
 
-    blurbs.should == {
+    expect(blurbs).to eq({
       'key.one' => 'expected one',
       'key.two' => 'expected two'
-    }
+    })
   end
 
   it 'logs that it performed a download' do
     logger = FakeLogger.new
     client = build_client_with_project(:logger => logger)
     client.download { |ignore| }
-    logger.should have_entry(:info, 'Downloaded translations')
+    expect(logger).to have_entry(:info, 'Downloaded translations')
   end
 
   it 'downloads draft blurbs for an existing project' do
@@ -151,10 +151,10 @@ describe CopyTunerClient do
 
     client.download { |yielded| blurbs = yielded }
 
-    blurbs.should == {
+    expect(blurbs).to eq({
       'key.one' => 'expected one',
       'key.two' => 'expected two'
-    }
+    })
   end
 
   it "handles a 304 response when downloading" do
@@ -170,8 +170,8 @@ describe CopyTunerClient do
       client.download { |ignore| yields += 1 }
     end
 
-    yields.should == 1
-    logger.should have_entry(:info, "No new translations")
+    expect(yields).to eq(1)
+    expect(logger).to have_entry(:info, "No new translations")
   end
 
   it "uploads defaults for missing blurbs in an existing project" do
@@ -185,14 +185,14 @@ describe CopyTunerClient do
     client = build_client(:api_key => project.api_key, :public => true)
     client.upload(blurbs)
 
-    project.reload.draft.should == blurbs
+    expect(project.reload.draft).to eq(blurbs)
   end
 
   it "logs that it performed an upload" do
     logger = FakeLogger.new
     client = build_client_with_project(:logger => logger)
     client.upload({})
-    logger.should have_entry(:info, "Uploaded missing translations")
+    expect(logger).to have_entry(:info, "Uploaded missing translations")
   end
 
   it "deploys from the top-level constant" do
@@ -204,7 +204,7 @@ describe CopyTunerClient do
 
     CopyTunerClient.deploy
 
-    client.should have_received(:deploy)
+    expect(client).to have_received(:deploy)
   end
 
   it "deploys" do
@@ -224,11 +224,11 @@ describe CopyTunerClient do
 
     client.deploy
 
-    project.reload.published.should == {
+    expect(project.reload.published).to eq({
       'key.one'   => "expected one",
       'key.two'   => "expected two"
-    }
-    logger.should have_entry(:info, "Deployed")
+    })
+    expect(logger).to have_entry(:info, "Deployed")
   end
 
   it "handles deploy errors" do

data/spec/copy_tuner_client/configuration_spec.rb

@@ -3,16 +3,16 @@ require 'spec_helper'
 describe CopyTunerClient::Configuration do
   RSpec::Matchers.define :have_config_option do |option|
     match do |config|
-      config.should respond_to(option)
+      expect(config).to respond_to(option)
 
       if instance_variables.include?(:'@default')
-        config.send(option).should == @default
+        expect(config.send(option)).to eq(@default)
       end
 
       if @overridable
         value = 'a value'
         config.send(:"#{option}=", value)
-        config.send(option).should == value
+        expect(config.send(option)).to eq(value)
       end
     end
 
@@ -25,39 +25,39 @@ describe CopyTunerClient::Configuration do
     end
   end
 
-  it { should have_config_option(:proxy_host).overridable.default(nil) }
-  it { should have_config_option(:proxy_port).overridable.default(nil) }
-  it { should have_config_option(:proxy_user).overridable.default(nil) }
-  it { should have_config_option(:proxy_pass).overridable.default(nil) }
-  it { should have_config_option(:environment_name).overridable.default(nil) }
-  it { should have_config_option(:client_version).overridable.default(CopyTunerClient::VERSION) }
-  it { should have_config_option(:client_name).overridable.default('CopyTuner Client') }
-  it { should have_config_option(:client_url).overridable.default('https://rubygems.org/gems/copy_tuner_client') }
-  it { should have_config_option(:secure).overridable.default(true) }
-  it { should have_config_option(:host).overridable.default('copy-tuner.com') }
-  it { should have_config_option(:http_open_timeout).overridable.default(5) }
-  it { should have_config_option(:http_read_timeout).overridable.default(5) }
-  it { should have_config_option(:port).overridable }
-  it { should have_config_option(:development_environments).overridable }
-  it { should have_config_option(:api_key).overridable }
-  it { should have_config_option(:polling_delay).overridable.default(300) }
-  it { should have_config_option(:framework).overridable }
-  it { should have_config_option(:middleware).overridable }
-  it { should have_config_option(:client).overridable }
-  it { should have_config_option(:cache).overridable }
+  it { is_expected.to have_config_option(:proxy_host).overridable.default(nil) }
+  it { is_expected.to have_config_option(:proxy_port).overridable.default(nil) }
+  it { is_expected.to have_config_option(:proxy_user).overridable.default(nil) }
+  it { is_expected.to have_config_option(:proxy_pass).overridable.default(nil) }
+  it { is_expected.to have_config_option(:environment_name).overridable.default(nil) }
+  it { is_expected.to have_config_option(:client_version).overridable.default(CopyTunerClient::VERSION) }
+  it { is_expected.to have_config_option(:client_name).overridable.default('CopyTuner Client') }
+  it { is_expected.to have_config_option(:client_url).overridable.default('https://rubygems.org/gems/copy_tuner_client') }
+  it { is_expected.to have_config_option(:secure).overridable.default(true) }
+  it { is_expected.to have_config_option(:host).overridable.default('copy-tuner.com') }
+  it { is_expected.to have_config_option(:http_open_timeout).overridable.default(5) }
+  it { is_expected.to have_config_option(:http_read_timeout).overridable.default(5) }
+  it { is_expected.to have_config_option(:port).overridable }
+  it { is_expected.to have_config_option(:development_environments).overridable }
+  it { is_expected.to have_config_option(:api_key).overridable }
+  it { is_expected.to have_config_option(:polling_delay).overridable.default(300) }
+  it { is_expected.to have_config_option(:framework).overridable }
+  it { is_expected.to have_config_option(:middleware).overridable }
+  it { is_expected.to have_config_option(:client).overridable }
+  it { is_expected.to have_config_option(:cache).overridable }
 
   it 'should provide default values for secure connections' do
     config = CopyTunerClient::Configuration.new
     config.secure = true
-    config.port.should == 443
-    config.protocol.should == 'https'
+    expect(config.port).to eq(443)
+    expect(config.protocol).to eq('https')
   end
 
   it 'should provide default values for insecure connections' do
     config = CopyTunerClient::Configuration.new
     config.secure = false
-    config.port.should == 80
-    config.protocol.should == 'http'
+    expect(config.port).to eq(80)
+    expect(config.protocol).to eq('http')
   end
 
   it 'should not cache inferred ports' do
@@ -65,7 +65,7 @@ describe CopyTunerClient::Configuration do
     config.secure = false
     config.port
     config.secure = true
-    config.port.should == 443
+    expect(config.port).to eq(443)
   end
 
   it 'should act like a hash' do
@@ -76,54 +76,54 @@ describe CopyTunerClient::Configuration do
       :http_read_timeout, :client_name, :client_url, :client_version, :port,
       :protocol, :proxy_host, :proxy_pass, :proxy_port, :proxy_user, :secure,
       :development_environments, :logger, :framework, :ca_file].each do |option|
-      hash[option].should == config[option]
+      expect(hash[option]).to eq(config[option])
     end
 
-    hash[:public].should == config.public?
+    expect(hash[:public]).to eq(config.public?)
   end
 
   it 'should be mergable' do
     config = CopyTunerClient::Configuration.new
     hash = config.to_hash
-    config.merge(:key => 'value').should == hash.merge(:key => 'value')
+    expect(config.merge(:key => 'value')).to eq(hash.merge(:key => 'value'))
   end
 
   it 'should use development and staging as development environments by default' do
     config = CopyTunerClient::Configuration.new
-    config.development_environments.should match_array(%w(development staging))
+    expect(config.development_environments).to match_array(%w(development staging))
   end
 
   it 'should use test and cucumber as test environments by default' do
     config = CopyTunerClient::Configuration.new
-    config.test_environments.should match_array(%w(test cucumber))
+    expect(config.test_environments).to match_array(%w(test cucumber))
   end
 
   it 'should be test in a test environment' do
     config = CopyTunerClient::Configuration.new
     config.test_environments = %w(test)
     config.environment_name = 'test'
-    config.should be_test
+    expect(config).to be_test
   end
 
   it 'should be public in a public environment' do
     config = CopyTunerClient::Configuration.new
     config.development_environments = %w(development)
     config.environment_name = 'production'
-    config.should be_public
-    config.should_not be_development
+    expect(config).to be_public
+    expect(config).not_to be_development
   end
 
   it 'should be development in a development environment' do
     config = CopyTunerClient::Configuration.new
     config.development_environments = %w(staging)
     config.environment_name = 'staging'
-    config.should be_development
-    config.should_not be_public
+    expect(config).to be_development
+    expect(config).not_to be_public
   end
 
   it 'should be public without an environment name' do
     config = CopyTunerClient::Configuration.new
-    config.should be_public
+    expect(config).to be_public
   end
 
   it 'should yield and save a configuration when configuring' do
@@ -133,15 +133,15 @@ describe CopyTunerClient::Configuration do
       yielded_configuration = config
     end
 
-    yielded_configuration.should be_kind_of(CopyTunerClient::Configuration)
-    CopyTunerClient.configuration.should == yielded_configuration
+    expect(yielded_configuration).to be_kind_of(CopyTunerClient::Configuration)
+    expect(CopyTunerClient.configuration).to eq(yielded_configuration)
   end
 
   it 'does not apply the configuration when asked not to' do
     logger = FakeLogger.new
     CopyTunerClient.configure(false) { |config| config.logger = logger }
-    CopyTunerClient.configuration.should_not be_applied
-    logger.entries[:info].should be_empty
+    expect(CopyTunerClient.configuration).not_to be_applied
+    expect(logger.entries[:info]).to be_empty
   end
 
   it 'should not remove existing config options when configuring twice' do
@@ -152,32 +152,32 @@ describe CopyTunerClient::Configuration do
     end
 
     CopyTunerClient.configure(false) do |config|
-      config.should == first_config
+      expect(config).to eq(first_config)
     end
   end
 
   it 'starts out unapplied' do
-    CopyTunerClient::Configuration.new.should_not be_applied
+    expect(CopyTunerClient::Configuration.new).not_to be_applied
   end
 
   it 'logs to $stdout by default' do
     logger = FakeLogger.new
     Logger.stubs :new => logger
     config = CopyTunerClient::Configuration.new
-    Logger.should have_received(:new).with($stdout)
-    config.logger.original_logger.should == logger
+    expect(Logger).to have_received(:new).with($stdout)
+    expect(config.logger.original_logger).to eq(logger)
   end
 
   it 'generates environment info without a framework' do
     subject.environment_name = 'production'
-    subject.environment_info.should == "[Ruby: #{RUBY_VERSION}] [Env: production]"
+    expect(subject.environment_info).to eq("[Ruby: #{RUBY_VERSION}] [Env: production]")
   end
 
   it 'generates environment info with a framework' do
     subject.environment_name = 'production'
     subject.framework = 'Sinatra: 1.0.0'
-    subject.environment_info.
-      should == "[Ruby: #{RUBY_VERSION}] [Sinatra: 1.0.0] [Env: production]"
+    expect(subject.environment_info).
+      to eq("[Ruby: #{RUBY_VERSION}] [Sinatra: 1.0.0] [Env: production]")
   end
 
   it 'prefixes log entries' do
@@ -187,8 +187,8 @@ describe CopyTunerClient::Configuration do
     config.logger = logger
 
     prefixed_logger = config.logger
-    prefixed_logger.should be_a(CopyTunerClient::PrefixedLogger)
-    prefixed_logger.original_logger.should == logger
+    expect(prefixed_logger).to be_a(CopyTunerClient::PrefixedLogger)
+    expect(prefixed_logger.original_logger).to eq(logger)
   end
 
   describe 'copyray_js_injection_regexp_for_debug' do
@@ -227,35 +227,35 @@ end
 shared_examples_for 'applied configuration' do
   include_context 'stubbed configuration'
 
-  it { should be_applied }
+  it { is_expected.to be_applied }
 
   it 'builds and assigns an I18n backend' do
-    CopyTunerClient::I18nBackend.should have_received(:new).with(cache)
-    I18n.backend.should == backend
+    expect(CopyTunerClient::I18nBackend).to have_received(:new).with(cache)
+    expect(I18n.backend).to eq(backend)
   end
 
   it 'builds and assigns a poller' do
-    CopyTunerClient::Poller.should have_received(:new).with(cache, subject.to_hash)
+    expect(CopyTunerClient::Poller).to have_received(:new).with(cache, subject.to_hash)
   end
 
   it 'builds a process guard' do
-    CopyTunerClient::ProcessGuard.should have_received(:new).
+    expect(CopyTunerClient::ProcessGuard).to have_received(:new).
       with(cache, poller, subject.to_hash)
   end
 
   it 'logs that it is ready' do
-    logger.should have_entry(:info, "Client #{CopyTunerClient::VERSION} ready")
+    expect(logger).to have_entry(:info, "Client #{CopyTunerClient::VERSION} ready")
   end
 
   it 'logs environment info' do
-    logger.should have_entry(:info, "Environment Info: #{subject.environment_info}")
+    expect(logger).to have_entry(:info, "Environment Info: #{subject.environment_info}")
   end
 end
 
 describe CopyTunerClient::Configuration, 'applied when testing' do
   it_should_behave_like 'applied configuration' do
     it 'does not start the process guard' do
-      process_guard.should have_received(:start).never
+      expect(process_guard).to have_received(:start).never
     end
   end
 
@@ -268,7 +268,7 @@ end
 describe CopyTunerClient::Configuration, 'applied when not testing' do
   it_should_behave_like 'applied configuration' do
     it 'starts the process guard' do
-      process_guard.should have_received(:start)
+      expect(process_guard).to have_received(:start)
     end
   end
 
@@ -281,7 +281,7 @@ end
 describe CopyTunerClient::Configuration, 'applied when developing with middleware' do
   it_should_behave_like 'applied configuration' do
     it 'adds the sync middleware' do
-      middleware.should include(CopyTunerClient::RequestSync)
+      expect(middleware).to include(CopyTunerClient::RequestSync)
     end
   end
 
@@ -316,7 +316,7 @@ describe CopyTunerClient::Configuration, 'applied with middleware when not devel
   end
 
   it 'does not add the sync middleware' do
-    middleware.should_not include(CopyTunerClient::RequestSync)
+    expect(middleware).not_to include(CopyTunerClient::RequestSync)
   end
 end
 

data/spec/copy_tuner_client/i18n_backend_spec.rb

@@ -23,12 +23,12 @@ describe CopyTunerClient::I18nBackend do
     subject.reload!
     subject.translate('en', 'test.key', :default => 'something')
 
-    cache.should have_received(:wait_for_download)
-    I18n.should have_received(:load_path)
+    expect(cache).to have_received(:wait_for_download)
+    expect(I18n).to have_received(:load_path)
   end
 
   it "includes the base i18n backend" do
-    should be_kind_of(I18n::Backend::Base)
+    is_expected.to be_kind_of(I18n::Backend::Base)
   end
 
   it "looks up a key in cache" do
@@ -37,7 +37,7 @@ describe CopyTunerClient::I18nBackend do
 
     backend = build_backend
 
-    backend.translate('en', 'test.key', :scope => 'prefix').should == value
+    expect(backend.translate('en', 'test.key', :scope => 'prefix')).to eq(value)
   end
 
   it "finds available locales from locale files and cache" do
@@ -47,44 +47,44 @@ describe CopyTunerClient::I18nBackend do
     cache['en.key'] = ''
     cache['fr.key'] = ''
 
-    subject.available_locales.should match_array([:en, :es, :fr])
+    expect(subject.available_locales).to match_array([:en, :es, :fr])
   end
 
   it "queues missing keys with default" do
     default = 'default value'
 
-    subject.translate('en', 'test.key', :default => default).should == default
+    expect(subject.translate('en', 'test.key', :default => default)).to eq(default)
 
-    cache['en.test.key'].should == default
+    expect(cache['en.test.key']).to eq(default)
   end
 
   it "queues missing keys without default" do
     expect { subject.translate('en', 'test.key') }.
       to throw_symbol(:exception)
 
-    cache['en.test.key'].should == ""
+    expect(cache['en.test.key']).to eq("")
   end
 
   it "queues missing keys with scope" do
     default = 'default value'
 
-    subject.translate('en', 'key', :default => default, :scope => ['test']).
-      should == default
+    expect(subject.translate('en', 'key', :default => default, :scope => ['test'])).
+      to eq(default)
 
-    cache['en.test.key'].should == default
+    expect(cache['en.test.key']).to eq(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
+    expect(backend.translate('en', 'test.key')).to 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'
+    expect(backend.translate('en', 'key.three', :default => [:"key.two", :"key.one"])).
+      to eq('Expected')
   end
 
   describe "with stored translations" do
@@ -92,48 +92,48 @@ describe CopyTunerClient::I18nBackend do
 
     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'
+      expect(subject.translate('en', 'test.key', :default => 'Unexpected')).
+        to include('Expected')
+      expect(cache['en.test.key']).to eq('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}'
+      expect(subject.translate('en', 'test.key', :interpolate => 'interpolated')).
+        to include('interpolated')
+      expect(cache['en.test.key']).to eq('%{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')
+      expect(subject.translate('en', 'test.key', :default => 'Expected')).
+        to 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')
+      expect(subject.translate('en', 'test.key', :default => 'default')).
+        to 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'
+      expect(subject.translate('en', 'key', :default => 'Unexpected')).to eq(nested)
+      expect(cache['en.key.nested']).to eq('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
+      expect(subject.translate('en', 'key', :default => 'Unexpected')).to eq(array)
+      expect(cache['en.key']).to 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')
+      expect(subject.translate('en', 'key.three', :default => [:"key.two", :"key.one"])).
+        to include('Expected')
     end
   end
 
@@ -148,11 +148,11 @@ describe CopyTunerClient::I18nBackend do
 
     it "queues missing keys with blank string" do
       default = 'default value'
-      subject.translate('en', 'test.key', :default => default).should == default
+      expect(subject.translate('en', 'test.key', :default => default)).to eq(default)
 
       # default と Fallbacks を併用した場合、キャッシュにデフォルト値は入らない仕様に変えた
       # その仕様にしないと、うまく Fallbacks の処理が動かないため
-      cache['en.test.key'].should == ''
+      expect(cache['en.test.key']).to eq('')
     end
   end
 end

data/spec/copy_tuner_client/poller_spec.rb

@@ -34,7 +34,7 @@ describe CopyTunerClient::Poller do
     client['test.key'] = 'value'
     wait_for_next_sync
 
-    cache['test.key'].should == 'value'
+    expect(cache['test.key']).to eq('value')
   end
 
   it "it doesn't poll before being started" do
@@ -43,7 +43,7 @@ describe CopyTunerClient::Poller do
 
     wait_for_next_sync
 
-    cache['test.key'].should be_nil
+    expect(cache['test.key']).to be_nil
   end
 
   it "stops polling when stopped" do
@@ -55,7 +55,7 @@ describe CopyTunerClient::Poller do
     client['test.key'] = 'value'
     wait_for_next_sync
 
-    cache['test.key'].should be_nil
+    expect(cache['test.key']).to be_nil
   end
 
   it "stops polling with an invalid api key" do
@@ -68,12 +68,12 @@ describe CopyTunerClient::Poller do
     poller.start
     wait_for_next_sync
 
-    logger.should have_entry(:error, failure)
+    expect(logger).to have_entry(:error, failure)
 
     client['test.key'] = 'test value'
     wait_for_next_sync
 
-    cache['test.key'].should be_nil
+    expect(cache['test.key']).to be_nil
   end
 
   it "logs an error if the background thread can't start" do
@@ -82,7 +82,7 @@ describe CopyTunerClient::Poller do
 
     build_poller(:logger => logger).start
 
-    logger.should have_entry(:error, "Couldn't start poller thread")
+    expect(logger).to have_entry(:error, "Couldn't start poller thread")
   end
 
   it "flushes the log when polling" do
@@ -93,7 +93,7 @@ describe CopyTunerClient::Poller do
 
     wait_for_next_sync
 
-    logger.should have_received(:flush).at_least_once
+    expect(logger).to have_received(:flush).at_least_once
   end
 
   it "starts from the top-level constant" do
@@ -103,6 +103,6 @@ describe CopyTunerClient::Poller do
 
     CopyTunerClient.start_poller
 
-    poller.should have_received(:start)
+    expect(poller).to have_received(:start)
   end
 end