mongo 2.12.4 → 2.14.0.rc1

data/spec/mongo/semaphore_spec.rb

@@ -0,0 +1,51 @@
+require 'lite_spec_helper'
+
+describe Mongo::Semaphore do
+  let(:semaphore) do
+    described_class.new
+  end
+
+  it 'waits until signaled' do
+    consumer = Thread.new do
+      semaphore.wait(3)
+    end
+
+    # Context switch to start the thread
+    sleep 0.1
+
+    start_time = Time.now
+    semaphore.signal
+    consumer.join
+
+    (Time.now - start_time).should < 1
+  end
+
+  it 'waits until broadcast' do
+    consumer = Thread.new do
+      semaphore.wait(3)
+    end
+
+    # Context switch to start the thread
+    sleep 0.1
+
+    start_time = Time.now
+    semaphore.broadcast
+    consumer.join
+
+    (Time.now - start_time).should < 1
+  end
+
+  it 'times out' do
+    consumer = Thread.new do
+      semaphore.wait(2)
+    end
+
+    # Context switch to start the thread
+    sleep 0.1
+
+    start_time = Time.now
+    consumer.join
+
+    (Time.now - start_time).should > 1
+  end
+end

data/spec/mongo/server/app_metadata_shared.rb

@@ -0,0 +1,136 @@
+shared_examples 'app metadata document' do
+  let(:app_metadata) do
+    described_class.new({})
+  end
+
+  it 'includes Ruby driver identification' do
+    document[:client][:driver][:name].should == 'mongo-ruby-driver'
+    document[:client][:driver][:version].should == Mongo::VERSION
+  end
+
+  it 'includes operating system information' do
+    document[:client][:os][:type].should == 'linux'
+    if BSON::Environment.jruby?
+      document[:client][:os][:name].should == 'linux'
+    else
+      document[:client][:os][:name].should == 'linux-gnu'
+    end
+    document[:client][:os][:architecture].should == 'x86_64'
+  end
+
+  context 'mri' do
+    only_mri
+
+    it 'includes Ruby version' do
+      document[:client][:platform].should start_with("Ruby #{RUBY_VERSION}")
+    end
+
+    context 'when custom platform is specified' do
+      let(:app_metadata) do
+        described_class.new(platform: 'foowidgets')
+      end
+
+      it 'starts with custom platform' do
+        document[:client][:platform].should start_with("foowidgets, Ruby #{RUBY_VERSION}")
+      end
+    end
+  end
+
+  context 'jruby' do
+    require_jruby
+
+    it 'includes JRuby and Ruby compatibility versions' do
+      document[:client][:platform].should start_with("JRuby #{JRUBY_VERSION}, like Ruby #{RUBY_VERSION}")
+    end
+
+    context 'when custom platform is specified' do
+      let(:app_metadata) do
+        described_class.new(platform: 'foowidgets')
+      end
+
+      it 'starts with custom platform' do
+        document[:client][:platform].should start_with("foowidgets, JRuby #{JRUBY_VERSION}")
+      end
+    end
+  end
+
+  context 'when wrapping libraries are specified' do
+    let(:app_metadata) do
+      described_class.new(wrapping_libraries: wrapping_libraries)
+    end
+
+    context 'one' do
+      let(:wrapping_libraries) { [wrapping_library] }
+
+      context 'no fields' do
+        let(:wrapping_library) do
+          {}
+        end
+
+        it 'adds empty strings' do
+          document[:client][:driver][:name].should == 'mongo-ruby-driver|'
+          document[:client][:driver][:version].should == "#{Mongo::VERSION}|"
+          document[:client][:platform].should =~ /\AJ?Ruby[^|]+\|\z/
+        end
+      end
+
+      context 'some fields' do
+        let(:wrapping_library) do
+          {name: 'Mongoid'}
+        end
+
+        it 'adds the fields' do
+          document[:client][:driver][:name].should == 'mongo-ruby-driver|Mongoid'
+          document[:client][:driver][:version].should == "#{Mongo::VERSION}|"
+          document[:client][:platform].should =~ /\AJ?Ruby[^|]+\|\z/
+        end
+      end
+
+      context 'all fields' do
+        let(:wrapping_library) do
+          {name: 'Mongoid', version: '7.1.2', platform: 'OS9000'}
+        end
+
+        it 'adds the fields' do
+          document[:client][:driver][:name].should == 'mongo-ruby-driver|Mongoid'
+          document[:client][:driver][:version].should == "#{Mongo::VERSION}|7.1.2"
+          document[:client][:platform].should =~ /\AJ?Ruby[^|]+\|OS9000\z/
+        end
+      end
+    end
+
+    context 'two' do
+      context 'some fields' do
+        let(:wrapping_libraries) do
+          [
+            {name: 'Mongoid', version: '42'},
+            # All libraries should be specifying their versions, in theory,
+            # but test not specifying a version.
+            {version: '4.0', platform: 'OS9000'},
+          ]
+        end
+
+        it 'adds the fields' do
+          document[:client][:driver][:name].should == 'mongo-ruby-driver|Mongoid|'
+          document[:client][:driver][:version].should == "#{Mongo::VERSION}|42|4.0"
+          document[:client][:platform].should =~ /\AJ?Ruby[^|]+\|\|OS9000\z/
+        end
+      end
+
+      context 'a realistic Mongoid & Rails wrapping' do
+        let(:wrapping_libraries) do
+          [
+            {name: 'Mongoid', version: '7.1.2'},
+            {name: 'Rails', version: '6.0.3'},
+          ]
+        end
+
+        it 'adds the fields' do
+          document[:client][:driver][:name].should == 'mongo-ruby-driver|Mongoid|Rails'
+          document[:client][:driver][:version].should == "#{Mongo::VERSION}|7.1.2|6.0.3"
+          document[:client][:platform].should =~ /\AJ?Ruby[^|]+\|\|\z/
+        end
+      end
+    end
+  end
+end

data/spec/mongo/server/app_metadata_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require_relative './app_metadata_shared'
 
 describe Mongo::Server::AppMetadata do
 
@@ -125,14 +126,20 @@ describe Mongo::Server::AppMetadata do
   end
 
   describe '#document' do
+    let(:document) do
+      app_metadata.send(:document)
+    end
+
     context 'when user is given and auth_mech is not given' do
       let(:app_metadata) do
         described_class.new(user: 'foo')
       end
 
       it 'includes saslSupportedMechs' do
-        expect(app_metadata.send(:document)[:saslSupportedMechs]).to eq('admin.foo')
+        expect(document[:saslSupportedMechs]).to eq('admin.foo')
       end
     end
+
+    it_behaves_like 'app metadata document'
   end
 end

data/spec/mongo/server/connection_auth_spec.rb

@@ -46,7 +46,7 @@ describe Mongo::Server::Connection, retry: 3 do
   end
 
   describe '#auth_mechanism' do
-    require_no_x509_auth
+    require_no_external_user
 
     let(:connection) do
       described_class.new(server, server.options)
@@ -65,7 +65,7 @@ describe Mongo::Server::Connection, retry: 3 do
         SpecConfig.instance.test_options.merge(
           user: SpecConfig.instance.test_user.name,
           password: SpecConfig.instance.test_user.password,
-          auth_source: SpecConfig.instance.test_db,
+          auth_source: 'admin',
         )
       end
 
@@ -74,7 +74,7 @@ describe Mongo::Server::Connection, retry: 3 do
       end
 
       before do
-        client = authorized_client.with(database: SpecConfig.instance.test_db)
+        client = authorized_client.with(database: 'admin')
         info = client.database.users.info(SpecConfig.instance.test_user.name)
         expect(info.length).to eq(1)
         # this before block may have made 2 or 3 clients
@@ -82,13 +82,20 @@ describe Mongo::Server::Connection, retry: 3 do
       end
 
       it 'uses scram256' do
-        connection.connect!
-        expect(connection.send(:default_mechanism)).to eq(:scram256)
+        connection
+        RSpec::Mocks.with_temporary_scope do
+          pending_conn = nil
+          Mongo::Server::PendingConnection.should receive(:new).and_wrap_original do |m, *args|
+            pending_conn = m.call(*args)
+          end
+          connection.connect!
+          expect(pending_conn.send(:default_mechanism)).to eq(:scram256)
+        end
       end
     end
 
     context 'when the ismaster response indicates the auth mechanism is :scram' do
-      require_no_x509_auth
+      require_no_external_user
 
       let(:features) do
         Mongo::Server::Description::Features.new(0..7)
@@ -96,10 +103,16 @@ describe Mongo::Server::Connection, retry: 3 do
 
       it 'uses scram' do
         connection
-        # the second Features instantiation is for SDAM event publication
-        expect(Mongo::Server::Description::Features).to receive(:new).twice.and_return(features)
-        connection.connect!
-        expect(connection.send(:default_mechanism)).to eq(:scram)
+        RSpec::Mocks.with_temporary_scope do
+          expect(Mongo::Server::Description::Features).to receive(:new).and_return(features)
+
+          pending_conn = nil
+          Mongo::Server::PendingConnection.should receive(:new).and_wrap_original do |m, *args|
+            pending_conn = m.call(*args)
+          end
+          connection.connect!
+          expect(pending_conn.send(:default_mechanism)).to eq(:scram)
+        end
       end
     end
 
@@ -110,10 +123,16 @@ describe Mongo::Server::Connection, retry: 3 do
 
       it 'uses mongodb_cr' do
         connection
-        # the second Features instantiation is for SDAM event publication
-        expect(Mongo::Server::Description::Features).to receive(:new).twice.and_return(features)
-        connection.connect!
-        expect(connection.send(:default_mechanism)).to eq(:mongodb_cr)
+        RSpec::Mocks.with_temporary_scope do
+          expect(Mongo::Server::Description::Features).to receive(:new).and_return(features)
+
+          pending_conn = nil
+          Mongo::Server::PendingConnection.should receive(:new).and_wrap_original do |m, *args|
+            pending_conn = m.call(*args)
+          end
+          connection.connect!
+          expect(pending_conn.send(:default_mechanism)).to eq(:mongodb_cr)
+        end
       end
     end
   end

data/spec/mongo/server/connection_pool_spec.rb

@@ -5,9 +5,13 @@ describe Mongo::Server::ConnectionPool do
   let(:options) { {} }
 
   let(:server_options) do
-    SpecConfig.instance.ssl_options.merge(SpecConfig.instance.compressor_options)
-      .merge(SpecConfig.instance.retry_writes_options).merge(SpecConfig.instance.auth_options)
-      .merge(options)
+    Mongo::Utils.shallow_symbolize_keys(Mongo::Client.canonicalize_ruby_options(
+      SpecConfig.instance.all_test_options,
+    )).tap do |opts|
+      opts.delete(:min_pool_size)
+      opts.delete(:max_pool_size)
+      opts.delete(:wait_queue_timeout)
+    end.update(options)
   end
 
   let(:address) do
@@ -735,37 +739,6 @@ describe Mongo::Server::ConnectionPool do
     end
   end
 
-  context 'when the connection does not finish authenticating before the thread is killed' do
-    let!(:pool) do
-      server.pool
-    end
-
-    let(:options) do
-      { min_pool_size:0, max_pool_size: 1 }
-    end
-
-    before do
-      pool
-      ClientRegistry.instance.close_all_clients
-    end
-
-    it 'creates a new connection' do
-      t = Thread.new do
-        expect {
-          pool.with_connection do |c|
-            expect(c).to receive(:connect!).and_raise(Mongo::Error)
-            c.send(:ensure_connected) { |socket| socket}
-          end
-        }.to raise_error(Mongo::Error)
-        expect(pool.size).to be(0)
-      end
-      t.join
-
-      expect(pool.check_out).to be_a(Mongo::Server::Connection)
-      expect(pool.size).to be(1)
-    end
-  end
-
   describe '#close_idle_sockets' do
     let!(:pool) do
       server.pool

data/spec/mongo/server/connection_spec.rb

@@ -1,12 +1,10 @@
 require 'spec_helper'
 
 # fails intermittently in evergreen
-describe Mongo::Server::Connection, retry: 3 do
+describe Mongo::Server::Connection do
   class ConnectionSpecTestException < Exception; end
 
-  before(:all) do
-    ClientRegistry.instance.close_all_clients
-  end
+  clean_slate_for_all
 
   let!(:address) do
     default_address
@@ -115,25 +113,52 @@ describe Mongo::Server::Connection, retry: 3 do
           expect(connection.send(:socket)).to be nil
         end
 
-        it 'attempts to reconnect after failure when asked' do
-          # for some reason referencing error here instead of
-          # copy pasting it like this doesn't work
-          expect(connection).to receive(:authenticate!).and_raise(exception)
-          expect do
-            connection.connect!
-          end.to raise_error(exception)
+        context 'when connection fails' do
+          let(:description) do
+            double('description').tap do |description|
+              allow(description).to receive(:arbiter?).and_return(false)
+            end
+          end
 
-          expect(connection).to receive(:authenticate!).and_raise(ConnectionSpecTestException)
-          expect do
-            connection.connect!
-          end.to raise_error(ConnectionSpecTestException)
+          let(:first_pending_connection) do
+            double('pending connection 1').tap do |conn|
+              conn.should receive(:handshake_and_authenticate!).and_raise(exception)
+            end
+          end
+
+          let(:second_pending_connection) do
+            double('pending connection 2').tap do |conn|
+              conn.should receive(:handshake_and_authenticate!).and_raise(ConnectionSpecTestException)
+            end
+          end
+
+          it 'attempts to reconnect if asked to connect again' do
+            RSpec::Mocks.with_temporary_scope do
+              Mongo::Server::PendingConnection.should receive(:new).ordered.and_return(first_pending_connection)
+              Mongo::Server::PendingConnection.should receive(:new).ordered.and_return(second_pending_connection)
+
+              expect do
+                connection.connect!
+              end.to raise_error(exception)
+
+              expect do
+                connection.connect!
+              end.to raise_error(ConnectionSpecTestException)
+            end
+          end
         end
       end
 
-      shared_examples_for 'logs a warning' do
-        let(:expected_message) do
-          "MONGODB | Failed to handshake with #{address}: #{error.class}: #{error}"
+      shared_examples_for 'failing connection with server diagnostics' do
+        it_behaves_like 'failing connection'
+
+        it 'adds server diagnostics' do
+          error.message.should =~ /on #{connection.address}/
         end
+      end
+
+      shared_examples_for 'logs a warning' do
+        require_warning_clean
 
         it 'logs a warning' do
           messages = []
@@ -148,6 +173,22 @@ describe Mongo::Server::Connection, retry: 3 do
 
       end
 
+      shared_examples_for 'adds server diagnostics' do
+        require_warning_clean
+
+        it 'adds server diagnostics' do
+          messages = []
+          expect(Mongo::Logger.logger).to receive(:warn) do |msg|
+            messages << msg
+          end
+
+          expect(error).not_to be nil
+
+          messages.any? { |msg| msg =~ /on #{connection.address}/ }.should be true
+        end
+
+      end
+
       context 'when #handshake! dependency raises a non-network exception' do
 
         let(:exception) do
@@ -155,7 +196,8 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         let(:error) do
-          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+          # The exception is mutated when notes are added to it
+          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception.dup)
           begin
             connection.connect!
           rescue Exception => e
@@ -165,8 +207,18 @@ describe Mongo::Server::Connection, retry: 3 do
           end
         end
 
+        let(:expected_message) do
+          "MONGODB | Failed to handshake with #{address}: #{error.class}: #{error}"
+        end
+
+        # The server diagnostics only apply to network exceptions.
+        # If non-network exceptions can be legitimately raised during
+        # handshake, and it makes sense to indicate which server the
+        # corresponding request was sent to, we should apply server
+        # diagnostics to non-network errors also.
         it_behaves_like 'failing connection'
         it_behaves_like 'keeps server type and topology'
+        it_behaves_like 'logs a warning'
       end
 
       context 'when #handshake! dependency raises a network exception' do
@@ -175,7 +227,8 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         let(:error) do
-          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception)
+          # The exception is mutated when notes are added to it
+          expect_any_instance_of(Mongo::Socket).to receive(:write).and_raise(exception.dup)
           begin
             connection.connect!
           rescue Exception => e
@@ -185,17 +238,23 @@ describe Mongo::Server::Connection, retry: 3 do
           end
         end
 
-        it_behaves_like 'failing connection'
+        let(:expected_message) do
+          "MONGODB | Failed to handshake with #{address}: #{error.class}: #{error}"
+        end
+
+        it_behaves_like 'failing connection with server diagnostics'
         it_behaves_like 'marks server unknown'
         it_behaves_like 'logs a warning'
+        it_behaves_like 'adds server diagnostics'
       end
 
       context 'when #authenticate! raises an exception' do
         require_auth
 
         let(:server_options) do
-          SpecConfig.instance.test_options.merge(monitoring_io: false).
-            merge(SpecConfig.instance.auth_options)
+          Mongo::Client.canonicalize_ruby_options(
+            SpecConfig.instance.all_test_options,
+          ).update(monitoring_io: false)
         end
 
         let(:exception) do
@@ -203,7 +262,10 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         let(:error) do
-          expect(Mongo::Auth).to receive(:get).and_raise(exception)
+          # Speculative auth - would be reported as handshake failure
+          expect(Mongo::Auth).to receive(:get).ordered.and_call_original
+          # The actual authentication call
+          expect(Mongo::Auth).to receive(:get).ordered.and_raise(exception)
           expect(connection.send(:socket)).to be nil
           begin
             connection.connect!
@@ -214,6 +276,10 @@ describe Mongo::Server::Connection, retry: 3 do
           end
         end
 
+        let(:expected_message) do
+          "MONGODB | Failed to authenticate to #{address}: #{error.class}: #{error}"
+        end
+
         it_behaves_like 'failing connection'
         it_behaves_like 'logs a warning'
       end
@@ -224,7 +290,7 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         let(:error) do
-          expect(connection).to receive(:authenticate!).and_raise(exception)
+          expect_any_instance_of(Mongo::Server::PendingConnection).to receive(:authenticate!).and_raise(exception)
           begin
             connection.connect!
           rescue Exception => e
@@ -283,14 +349,14 @@ describe Mongo::Server::Connection, retry: 3 do
 
     let(:auth_mechanism) do
       if ClusterConfig.instance.server_version >= '3'
-        Mongo::Auth::SCRAM
+        Mongo::Auth::Scram
       else
         Mongo::Auth::CR
       end
     end
 
     context 'when user credentials exist' do
-      require_no_x509_auth
+      require_no_external_user
 
       let(:server) { monitored_server }
 
@@ -528,10 +594,12 @@ describe Mongo::Server::Connection, retry: 3 do
         server,
         SpecConfig.instance.test_options.merge(
           :database => SpecConfig.instance.test_user.database,
-        ).merge(SpecConfig.instance.credentials_or_x509(
-          user: SpecConfig.instance.test_user.name,
-          password: SpecConfig.instance.test_user.password,
-        ))
+        ).merge(Mongo::Utils.shallow_symbolize_keys(Mongo::Client.canonicalize_ruby_options(
+          SpecConfig.instance.credentials_or_external_user(
+            user: SpecConfig.instance.test_user.name,
+            password: SpecConfig.instance.test_user.password,
+          ),
+        )))
       ).tap do |connection|
         connection.connect!
       end
@@ -626,44 +694,22 @@ describe Mongo::Server::Connection, retry: 3 do
           /Got response for request ID \d+ but expected response for request ID \d+/)
       end
 
-      context 'linting' do
-        require_linting
-
-        it 'does not permit sending over the connection' do
-          expect {
-            connection.dispatch([ query_alice ])
-          }.to raise_error(Mongo::Error::UnexpectedResponse)
-
-          expect do
-            connection.dispatch([ query_alice ]).documents
-          end.to raise_error(Mongo::Error::LintError, /Trying to deliver a message over a disconnected connection/)
-        end
-
-        it 'marks the connection no longer usable' do
-          expect {
-            connection.dispatch([ query_alice ])
-          }.to raise_error(Mongo::Error::UnexpectedResponse)
+      it 'marks connection perished' do
+        expect {
+          connection.dispatch([ query_alice ])
+        }.to raise_error(Mongo::Error::UnexpectedResponse)
 
-          expect do
-            connection.connect!
-          end.to raise_error(Mongo::Error::LintError, /Reconnecting closed connections is no longer supported/)
-        end
+        connection.should be_error
       end
 
-      context 'not linting' do
-        skip_if_linting
-
-        it 'does not affect subsequent requests but warns' do
-          expect(Mongo::Logger.logger).to receive(:warn).once.and_call_original
-
-          expect {
-            connection.dispatch([ query_alice ])
-          }.to raise_error(Mongo::Error::UnexpectedResponse)
+      it 'makes the connection no longer usable' do
+        expect {
+          connection.dispatch([ query_alice ])
+        }.to raise_error(Mongo::Error::UnexpectedResponse)
 
-          docs = connection.dispatch([ query_alice ]).documents
-          expect(docs).to_not be_empty
-          expect(docs.first['name']).to eq('alice')
-        end
+        expect {
+          connection.dispatch([ query_alice ])
+        }.to raise_error(Mongo::Error::ConnectionPerished)
       end
     end
 
@@ -786,9 +832,9 @@ describe Mongo::Server::Connection, retry: 3 do
           end.to raise_error(Mongo::Error::SocketError)
         end
 
-        it 'disconnects and raises the exception' do
+        it 'marks connection perished' do
           result
-          expect(connection).to_not be_connected
+          expect(connection).to be_error
         end
 
         it 'disconnects connection pool' do
@@ -820,9 +866,9 @@ describe Mongo::Server::Connection, retry: 3 do
           end.to raise_error(Mongo::Error::SocketTimeoutError)
         end
 
-        it 'disconnects the used connection' do
+        it 'marks connection perished' do
           result
-          expect(connection).to_not be_connected
+          expect(connection).to be_error
         end
 
 =begin These assertions require a working cluster with working SDAM flow, which the tests do not configure
@@ -910,6 +956,7 @@ describe Mongo::Server::Connection, retry: 3 do
       end
     end
 
+=begin this is now handled by connection pool
     context 'when the process is forked' do
 
       let(:insert) do
@@ -928,9 +975,10 @@ describe Mongo::Server::Connection, retry: 3 do
 
       it 'sets a new pid' do
         connection.dispatch([ insert ])
-        expect(connection.pid).to eq(1)
+        expect(connection.send(:pid)).to eq(1)
       end
     end
+=end
   end
 
   describe '#initialize' do
@@ -979,8 +1027,14 @@ describe Mongo::Server::Connection, retry: 3 do
         expect(connection.send(:socket)).to be_nil
       end
 
-      it 'does not set the timeout to the default' do
-        expect(connection.timeout).to be_nil
+      context 'when timeout is not set in client options' do
+        let(:server_options) do
+          SpecConfig.instance.test_options.merge(monitoring_io: false, socket_timeout: nil)
+        end
+
+        it 'does not set the timeout to the default' do
+          expect(connection.timeout).to be_nil
+        end
       end
     end
 
@@ -1023,7 +1077,7 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         it 'does not set the ssl options' do
-          expect(connection.send(:ssl_options)).to be_empty
+          expect(connection.send(:ssl_options)).to eq(ssl: false)
         end
       end
 
@@ -1038,13 +1092,13 @@ describe Mongo::Server::Connection, retry: 3 do
         end
 
         it 'does not set the ssl options' do
-          expect(connection.send(:ssl_options)).to be_empty
+          expect(connection.send(:ssl_options)).to eq(ssl: false)
         end
       end
     end
 
     context 'when authentication options are provided' do
-      require_no_x509_auth
+      require_no_external_user
 
       let(:connection) do
         described_class.new(
@@ -1052,7 +1106,7 @@ describe Mongo::Server::Connection, retry: 3 do
           :user => SpecConfig.instance.test_user.name,
           :password => SpecConfig.instance.test_user.password,
           :database => SpecConfig.instance.test_db,
-          :auth_mech => :mongodb_cr
+          :auth_mech => :mongodb_cr,
         )
       end
 
@@ -1195,7 +1249,7 @@ describe Mongo::Server::Connection, retry: 3 do
     end
 
     context 'when auth options differ from server' do
-      require_no_x509_auth
+      require_no_external_user
 
       let(:connection) do
         described_class.new(server, server.options.merge(user: 'foo'))