localeapp 0.9.3 → 1.0.0

data/spec/localeapp/cli/install_spec.rb

@@ -8,14 +8,14 @@ describe Localeapp::CLI::Install, '.execute(key = nil)' do
 
   it "creates the installer based on the config type" do
     command.config_type = :heroku
-    command.should_receive(:installer).with("HerokuInstaller").and_return(double.as_null_object)
+    expect(command).to receive(:installer).with("HerokuInstaller").and_return(double.as_null_object)
     command.execute(key)
   end
 
   it "executes the installer with the given key" do
     installer = double(:installer)
-    installer.should_receive(:execute).with(key)
-    command.stub(:installer).and_return(installer)
+    expect(installer).to receive(:execute).with(key)
+    allow(command).to receive(:installer).and_return(installer)
     command.execute(key)
   end
 end
@@ -26,58 +26,58 @@ describe Localeapp::CLI::Install::DefaultInstaller, '#execute(key = nil)' do
   let(:installer) { Localeapp::CLI::Install::DefaultInstaller.new(output) }
 
   before do
-    installer.stub(:print_header)
-    installer.stub(:validate_key).and_return(false)
+    allow(installer).to receive(:print_header)
+    allow(installer).to receive(:validate_key).and_return(false)
   end
 
   it "prints the header" do
-    installer.should_receive(:print_header)
+    expect(installer).to receive(:print_header)
     installer.execute
   end
 
   it "validates the key" do
-    installer.should_receive(:key=).with(key)
-    installer.should_receive(:validate_key)
+    expect(installer).to receive(:key=).with(key)
+    expect(installer).to receive(:validate_key)
     installer.execute(key)
   end
 
   context "When key validation fails" do
     it "returns false" do
-      installer.execute(key).should == false
+      expect(installer.execute(key)).to eq(false)
     end
   end
 
   context "When key validation is successful" do
     before do
-      installer.stub(:validate_key).and_return(true)
-      installer.stub(:check_default_locale)
-      installer.stub(:set_config_paths)
-      installer.stub(:write_config_file)
-      installer.stub(:check_data_directory_exists)
+      allow(installer).to receive(:validate_key).and_return(true)
+      allow(installer).to receive(:check_default_locale)
+      allow(installer).to receive(:set_config_paths)
+      allow(installer).to receive(:write_config_file)
+      allow(installer).to receive(:check_data_directory_exists)
     end
 
     it "checks the default locale" do
-      installer.should_receive(:check_default_locale)
+      expect(installer).to receive(:check_default_locale)
       installer.execute(key)
     end
 
     it "sets the configuration paths" do
-      installer.should_receive(:set_config_paths)
+      expect(installer).to receive(:set_config_paths)
       installer.execute(key)
     end
 
     it "writes the configuration file" do
-      installer.should_receive(:write_config_file)
+      expect(installer).to receive(:write_config_file)
       installer.execute(key)
     end
 
     it "checks the data directory exists" do
-      installer.should_receive(:check_data_directory_exists)
+      expect(installer).to receive(:check_data_directory_exists)
       installer.execute(key)
     end
 
     it "returns true" do
-      installer.execute(key).should == true
+      expect(installer.execute(key)).to eq(true)
     end
   end
 end
@@ -94,19 +94,19 @@ describe Localeapp::CLI::Install::DefaultInstaller, '#validate_key(key)' do
   it "displays error if key is nil" do
     installer.key = nil
     installer.validate_key
-    output.string.should match(/You must supply an API key/)
+    expect(output.string).to match(/You must supply an API key/)
   end
 
   it "displays error if the key is there but isn't valid on localeapp.com" do
-    installer.stub(:check_key).and_return([false, {}])
+    allow(installer).to receive(:check_key).and_return([false, {}])
     installer.validate_key
-    output.string.should match(/Project not found/)
+    expect(output.string).to match(/Project not found/)
   end
 
   it "displays project name if the key is there and valid on localeapp.com" do
-    installer.stub(:check_key).and_return([true, valid_project_data])
+    allow(installer).to receive(:check_key).and_return([true, valid_project_data])
     installer.validate_key
-    output.string.should match(/Test Project/)
+    expect(output.string).to match(/Test Project/)
   end
 end
 
@@ -115,18 +115,18 @@ describe Localeapp::CLI::Install::DefaultInstaller, '#check_default_locale' do
   let(:installer) { Localeapp::CLI::Install::DefaultInstaller.new(output) }
 
   before do
-    installer.stub(:project_data).and_return(valid_project_data)
+    allow(installer).to receive(:project_data).and_return(valid_project_data)
   end
 
   it "displays project base locale" do
     installer.check_default_locale
-    output.string.should match(/en \(English\)/)
+    expect(output.string).to match(/en \(English\)/)
   end
 
   it "displays warning if I18n.default_locale doesn't match what's configured on localeapp.com" do
-    I18n.stub(:default_locale).and_return(:es)
+    allow(I18n).to receive(:default_locale).and_return(:es)
     installer.check_default_locale
-    output.string.should match(%r{WARNING: I18n.default_locale is es, change in config/environment.rb \(Rails 2\) or config/application.rb \(Rails 3\)})
+    expect(output.string).to match(%r{WARNING: I18n.default_locale is es, change in config/environment.rb \(Rails 2\) or config/application.rb \(Rails 3\)})
   end
 end
 
@@ -139,11 +139,11 @@ describe Localeapp::CLI::Install::DefaultInstaller, '#set_config_paths' do
   end
 
   it "sets the initializer config_file_path for a rails app" do
-    installer.config_file_path.should == "config/initializers/localeapp.rb"
+    expect(installer.config_file_path).to eq("config/initializers/localeapp.rb")
   end
 
   it "sets the data directory for a rails app" do
-    installer.data_directory.should == "config/locales"
+    expect(installer.data_directory).to eq("config/locales")
   end
 end
 
@@ -157,14 +157,14 @@ describe Localeapp::CLI::Install::DefaultInstaller, '#write_config_file' do
     installer.key = key
     installer.config_file_path = config_file_path
     file = double('file')
-    file.should_receive(:write).with <<-CONTENT
+    expect(file).to receive(:write).with <<-CONTENT
 require 'localeapp/rails'
 
 Localeapp.configure do |config|
   config.api_key = 'APIKEY'
 end
 CONTENT
-    File.should_receive(:open).with(config_file_path, 'w+').and_yield(file)
+    expect(File).to receive(:open).with(config_file_path, 'w+').and_yield(file)
     installer.write_config_file
   end
 end
@@ -179,15 +179,15 @@ describe Localeapp::CLI::Install::DefaultInstaller, '#check_data_directory_exist
   end
 
   it "displays warning if config.translation_data_directory doesn't exist" do
-    File.stub(:directory?).with(data_directory).and_return(false)
+    allow(File).to receive(:directory?).with(data_directory).and_return(false)
     installer.check_data_directory_exists
-    output.string.should match(/Your translation data will be stored there./)
+    expect(output.string).to match(/Your translation data will be stored there./)
   end
 
   it "doesn't display a warning if translation_data_directory exists" do
-    File.stub(:directory?).with(data_directory).and_return(true)
+    allow(File).to receive(:directory?).with(data_directory).and_return(true)
     installer.check_data_directory_exists
-    output.string.should == ''
+    expect(output.string).to eq('')
   end
 end
 
@@ -201,7 +201,7 @@ describe Localeapp::CLI::Install::HerokuInstaller, '#write_config_file' do
     installer.key = key
     installer.config_file_path = config_file_path
     file = double('file')
-    file.should_receive(:write).with <<-CONTENT
+    expect(file).to receive(:write).with <<-CONTENT
 require 'localeapp/rails'
 
 Localeapp.configure do |config|
@@ -217,7 +217,7 @@ if defined?(Rails) && Rails.env.staging?
   Localeapp::CLI::Pull.new.execute
 end
 CONTENT
-    File.should_receive(:open).with(config_file_path, 'w+').and_yield(file)
+    expect(File).to receive(:open).with(config_file_path, 'w+').and_yield(file)
     installer.write_config_file
   end
 end
@@ -227,7 +227,7 @@ describe Localeapp::CLI::Install::StandaloneInstaller, '#check_default_locale' d
 
   it "does nothing" do
     installer.check_default_locale
-    output.string.should == ''
+    expect(output.string).to eq('')
   end
 end
 
@@ -240,11 +240,11 @@ describe Localeapp::CLI::Install::StandaloneInstaller, '#set_config_paths' do
   end
 
   it "sets the initializer config_file_path for a standalone app" do
-    installer.config_file_path.should == ".localeapp/config.rb"
+    expect(installer.config_file_path).to eq(".localeapp/config.rb")
   end
 
   it "sets the data directory for a standalone app" do
-    installer.data_directory.should == "locales"
+    expect(installer.data_directory).to eq("locales")
   end
 end
 
@@ -256,12 +256,12 @@ describe Localeapp::CLI::Install::StandaloneInstaller, '#write_config_file' do
   let(:installer) { Localeapp::CLI::Install::StandaloneInstaller.new(output) }
 
   it "creates a configuration file containing the dot file configuration at the given config_file_path" do
-    installer.stub(:create_config_dir).and_return(File.dirname(config_file_path))
+    allow(installer).to receive(:create_config_dir).and_return(File.dirname(config_file_path))
     installer.key = key
     installer.config_file_path = config_file_path
     installer.data_directory = data_directory
     file = double('file')
-    file.should_receive(:write).with <<-CONTENT
+    expect(file).to receive(:write).with <<-CONTENT
 Localeapp.configure do |config|
   config.api_key                    = 'APIKEY'
   config.translation_data_directory = 'locales'
@@ -269,7 +269,7 @@ Localeapp.configure do |config|
   config.daemon_pid_file            = '.localeapp/localeapp.pid'
 end
 CONTENT
-    File.should_receive(:open).with(config_file_path, 'w+').and_yield(file)
+    expect(File).to receive(:open).with(config_file_path, 'w+').and_yield(file)
     installer.write_config_file
   end
 end
@@ -285,30 +285,30 @@ describe Localeapp::CLI::Install::GithubInstaller, '#write_config_file' do
     installer.key = key
     installer.config_file_path = config_file_path
     installer.data_directory = data_directory
-    installer.stub(:create_config_dir).and_return(File.dirname(config_file_path))
-    installer.stub(:write_standalone_config)
-    installer.stub(:create_data_directory)
-    installer.stub(:create_gitignore)
-    installer.stub(:create_readme)
+    allow(installer).to receive(:create_config_dir).and_return(File.dirname(config_file_path))
+    allow(installer).to receive(:write_standalone_config)
+    allow(installer).to receive(:create_data_directory)
+    allow(installer).to receive(:create_gitignore)
+    allow(installer).to receive(:create_readme)
   end
 
   it "creates a standalone configuration file" do
-    installer.should_receive(:write_standalone_config)
+    expect(installer).to receive(:write_standalone_config)
     installer.write_config_file
   end
 
   it "creates the data_directory" do
-    installer.should_receive(:create_data_directory)
+    expect(installer).to receive(:create_data_directory)
     installer.write_config_file
   end
 
   it "creates the .gitignore file" do
-    installer.should_receive(:create_gitignore)
+    expect(installer).to receive(:create_gitignore)
     installer.write_config_file
   end
 
   it "creates the READMI file" do
-    installer.should_receive(:create_readme)
+    expect(installer).to receive(:create_readme)
     installer.write_config_file
   end
 end

data/spec/localeapp/cli/pull_spec.rb

@@ -9,7 +9,7 @@ describe Localeapp::CLI::Pull, "#execute" do
 
   it "makes the api call to the translations endpoint" do
     with_configuration do
-      @puller.should_receive(:api_call).with(
+      expect(@puller).to receive(:api_call).with(
         :export,
         :success => :update_backend,
         :failure => :report_failure,
@@ -29,16 +29,16 @@ describe Localeapp::CLI::Pull, "#update_backend(response)" do
 
   it "calls the updater" do
     with_configuration do
-      Localeapp.poller.stub(:write_synchronization_data!)
-      Localeapp.updater.should_receive(:dump).with(['test data'])
+      allow(Localeapp.poller).to receive(:write_synchronization_data!)
+      expect(Localeapp.updater).to receive(:dump).with(['test data'])
       @puller.update_backend(@test_data)
     end
   end
 
   it "writes the synchronization data" do
     with_configuration do
-      Localeapp.updater.stub(:dump)
-      Localeapp.poller.should_receive(:write_synchronization_data!)
+      allow(Localeapp.updater).to receive(:dump)
+      expect(Localeapp.poller).to receive(:write_synchronization_data!)
       @puller.update_backend(@test_data)
     end
   end

data/spec/localeapp/cli/push_spec.rb

@@ -10,10 +10,10 @@ describe Localeapp::CLI::Push, "#execute(path)" do
         directory = double('directory')
         path = 'test_path'
         yaml_files = %w(en.yml es.yml)
-        pusher.stub(:path_is_directory?).and_return(true)
-        pusher.should_receive(:yaml_files_in_directory).with(path).and_return(yaml_files)
-        pusher.should_receive(:push_file).with('en.yml')
-        pusher.should_receive(:push_file).with('es.yml')
+        allow(pusher).to receive(:path_is_directory?).and_return(true)
+        expect(pusher).to receive(:yaml_files_in_directory).with(path).and_return(yaml_files)
+        expect(pusher).to receive(:push_file).with('en.yml')
+        expect(pusher).to receive(:push_file).with('es.yml')
         pusher.execute(path)
       end
     end
@@ -24,7 +24,7 @@ describe Localeapp::CLI::Push, "#execute(path)" do
       with_configuration do
         file = double('file')
         file_path = 'test_path'
-        pusher.should_receive(:push_file).with(file_path)
+        expect(pusher).to receive(:push_file).with(file_path)
         pusher.execute(file_path)
       end
     end
@@ -39,8 +39,8 @@ describe Localeapp::CLI::Push, "#push_file(file_path)" do
     with_configuration do
       file = double('file')
       file_path = 'test_path'
-      pusher.stub(:sanitize_file).and_return(file)
-      pusher.should_receive(:api_call).with(
+      allow(pusher).to receive(:sanitize_file).and_return(file)
+      expect(pusher).to receive(:api_call).with(
         :import,
         :payload => { :file => file },
         :success => :report_success,
@@ -52,8 +52,8 @@ describe Localeapp::CLI::Push, "#push_file(file_path)" do
   end
 
   it "doesn't make the api call when the file doesn't exist" do
-    pusher.stub(:sanitize_file).and_return(nil)
-    pusher.should_not_receive(:api_call)
+    allow(pusher).to receive(:sanitize_file).and_return(nil)
+    expect(pusher).not_to receive(:api_call)
     pusher.push_file('foo')
   end
 end

data/spec/localeapp/cli/rename_spec.rb

@@ -12,7 +12,7 @@ describe Localeapp::CLI::Add, "#execute(current_name, new_name, *rest)" do
 
   it "makes the api call to the translations endpoint with the new name as the post body" do
     with_configuration do
-      @command.should_receive(:api_call).with(
+      expect(@command).to receive(:api_call).with(
         :rename,
         :url_options => { :current_name => 'test.key' },
         :payload => { :new_name => 'test.new_name' },

data/spec/localeapp/cli/update_spec.rb

@@ -6,32 +6,35 @@ describe Localeapp::CLI::Update, "#execute" do
   let(:updater) { Localeapp::CLI::Update.new(:output => output) }
   let(:poller)  { Localeapp::Poller.new }
 
-  before(:each) { Localeapp::Poller.stub(:new => poller) }
+  before do
+    poller
+    allow(Localeapp::Poller).to receive(:new) { poller }
+  end
 
   context "when timestamp is recent" do
-    before(:each) { poller.stub(:updated_at => Time.now.to_i - 60) }
+    before { allow(poller).to receive(:updated_at) { Time.now.to_i - 60 } }
 
     it "creates a Poller and calls poll! on it" do
       with_configuration do
-        poller.should_receive(:poll!)
+        expect(poller).to receive(:poll!)
         updater.execute
       end
     end
   end
 
   context "when timestamp is too old" do
-    before(:each) { poller.stub(:updated_at => 0) }
+    before { allow(poller).to receive(:updated_at) { 0 } }
 
     it "warns the user" do
       with_configuration do
         updater.execute
-        output.string.should include("Timestamp is missing or too old.")
+        expect(output.string).to include("Timestamp is missing or too old.")
       end
     end
 
     it "does not even call the API" do
       with_configuration do
-        poller.should_not_receive(:poll!)
+        expect(poller).not_to receive(:poll!)
         updater.execute
       end
     end

data/spec/localeapp/configuration_spec.rb

@@ -4,7 +4,7 @@ describe Localeapp::Configuration do
   let(:configuration) { Localeapp::Configuration.new }
 
   it "sets the host by default" do
-    configuration.host.should == 'api.localeapp.com'
+    expect(configuration.host).to eq('api.localeapp.com')
   end
 
   it "allows the host to be overwritten" do
@@ -12,7 +12,7 @@ describe Localeapp::Configuration do
   end
 
   it "sets proxy to nil by default" do
-    configuration.proxy.should == nil
+    expect(configuration.proxy).to eq(nil)
   end
 
   it "allows proxy setting to be overridden" do
@@ -20,7 +20,7 @@ describe Localeapp::Configuration do
   end
 
   it "sets timeout to 60 by default" do
-    configuration.timeout.should == 60
+    expect(configuration.timeout).to eq(60)
   end
 
   it "allows timeout setting to be overridden" do
@@ -28,7 +28,7 @@ describe Localeapp::Configuration do
   end
 
   it "sets secure to true by default" do
-    configuration.secure.should == true
+    expect(configuration.secure).to eq(true)
   end
 
   it "allows secure setting to be overridden" do
@@ -36,11 +36,11 @@ describe Localeapp::Configuration do
   end
 
   it "sets ssl_verify to false by default" do
-    configuration.ssl_verify.should == false
+    expect(configuration.ssl_verify).to eq(false)
   end
 
   it "sets ssl_version to 'SSLv23' by default" do
-    configuration.ssl_version.should == 'SSLv23'
+    expect(configuration.ssl_version).to eq('SSLv23')
   end
 
   it "allows ssl_verify setting to be overridden" do
@@ -48,7 +48,7 @@ describe Localeapp::Configuration do
   end
 
   it "sets ssl_ca_file to nil by default" do
-    configuration.ssl_ca_file.should == nil
+    expect(configuration.ssl_ca_file).to eq(nil)
   end
 
   it "allows ssl_ca_file setting to be overridden" do
@@ -56,25 +56,25 @@ describe Localeapp::Configuration do
   end
 
   it "includes http_auth_username defaulting to nil" do
-    configuration.http_auth_username.should == nil
+    expect(configuration.http_auth_username).to eq(nil)
     configuration.http_auth_username = "test"
-    configuration.http_auth_username.should == "test"
+    expect(configuration.http_auth_username).to eq("test")
   end
 
   it "includes http_auth_password defaulting to nil" do
-    configuration.http_auth_password.should == nil
+    expect(configuration.http_auth_password).to eq(nil)
     configuration.http_auth_password = "test"
-    configuration.http_auth_password.should == "test"
+    expect(configuration.http_auth_password).to eq("test")
   end
 
   it "includes translation_data_directory defaulting to config/locales" do
-    configuration.translation_data_directory.should == File.join("config", "locales")
+    expect(configuration.translation_data_directory).to eq(File.join("config", "locales"))
     configuration.translation_data_directory = "test"
-    configuration.translation_data_directory.should == "test"
+    expect(configuration.translation_data_directory).to eq("test")
   end
 
   it "sets the daemon_pid_file by default" do
-    configuration.daemon_pid_file.should == 'tmp/pids/localeapp.pid'
+    expect(configuration.daemon_pid_file).to eq('tmp/pids/localeapp.pid')
   end
 
   it "allows the daemon_pid_file to be overwritten" do
@@ -82,7 +82,7 @@ describe Localeapp::Configuration do
   end
 
   it "sets the daemon_log_file by default" do
-    configuration.daemon_log_file.should == 'log/localeapp_daemon.log'
+    expect(configuration.daemon_log_file).to eq('log/localeapp_daemon.log')
   end
 
   it "allows the daemon_log_file to be overwritten" do
@@ -95,19 +95,19 @@ describe Localeapp::Configuration do
 
   context "enabled_sending_environments" do
     it "is only development by default" do
-      configuration.sending_environments.should == ['development']
+      expect(configuration.sending_environments).to eq(['development'])
     end
   end
 
   context "enabled_reloading_environments" do
     it "is only development by default" do
-      configuration.reloading_environments.should == ['development']
+      expect(configuration.reloading_environments).to eq(['development'])
     end
   end
 
   context "enabled_polling_environments" do
     it "is only development by default" do
-      configuration.polling_environments.should == ['development']
+      expect(configuration.polling_environments).to eq(['development'])
     end
   end
 
@@ -115,19 +115,19 @@ describe Localeapp::Configuration do
     it "is true when environment is not enabled" do
       configuration.polling_environments = %w(foo)
       configuration.environment_name = 'bar'
-      configuration.should be_polling_disabled
+      expect(configuration).to be_polling_disabled
     end
 
     it "is false when environment is enabled" do
       configuration.polling_environments = %w(foo)
       configuration.environment_name = 'foo'
-      configuration.should_not be_polling_disabled
+      expect(configuration).not_to be_polling_disabled
     end
 
     it "supports symbols in list of environments" do
       configuration.polling_environments = [:foo]
       configuration.environment_name = 'foo'
-      configuration.should_not be_polling_disabled
+      expect(configuration).not_to be_polling_disabled
     end
   end
 
@@ -135,19 +135,19 @@ describe Localeapp::Configuration do
     it "is true when environment is not enabled" do
       configuration.reloading_environments = %w(foo)
       configuration.environment_name = 'bar'
-      configuration.should be_reloading_disabled
+      expect(configuration).to be_reloading_disabled
     end
 
     it "is false when environment is enabled" do
       configuration.reloading_environments = %w(foo)
       configuration.environment_name = 'foo'
-      configuration.should_not be_reloading_disabled
+      expect(configuration).not_to be_reloading_disabled
     end
 
     it "supports symbols in list of environments" do
       configuration.reloading_environments = [:foo]
       configuration.environment_name = 'foo'
-      configuration.should_not be_reloading_disabled
+      expect(configuration).not_to be_reloading_disabled
     end
   end
 
@@ -155,19 +155,19 @@ describe Localeapp::Configuration do
     it "is true when environment is not enabled" do
       configuration.sending_environments = %w(foo)
       configuration.environment_name = 'bar'
-      configuration.should be_sending_disabled
+      expect(configuration).to be_sending_disabled
     end
 
     it "is false when environment is enabled" do
       configuration.sending_environments = %w(foo)
       configuration.environment_name = 'foo'
-      configuration.should_not be_sending_disabled
+      expect(configuration).not_to be_sending_disabled
     end
 
     it "supports symbols in the list of environments" do
       configuration.sending_environments = [:foo]
       configuration.environment_name = 'foo'
-      configuration.should_not be_sending_disabled
+      expect(configuration).not_to be_sending_disabled
     end
   end
 
@@ -176,13 +176,13 @@ describe Localeapp::Configuration do
     context "when an api_key is defined" do
       it "returns true" do
         configuration.api_key = '0123456789abcdef'
-        expect(configuration.has_api_key?).to be_true
+        expect(configuration.has_api_key?).to be true
       end
     end
 
     context "with no api_key provided" do
       it "returns false" do
-        expect(configuration.has_api_key?).to be_false
+        expect(configuration.has_api_key?).to be false
       end
     end