ably-rest 0.9.3 → 1.0.0

data/lib/submodules/ably-ruby/spec/acceptance/rest/auth_spec.rb

@@ -182,7 +182,7 @@ describe Ably::Auth do
       context 'with :query_time option' do
         let(:options) { { query_time: true } }
 
-        it 'queries the server for the time' do
+        it 'queries the server for the time (#RSA10k)' do
           expect(client).to receive(:time).and_call_original
           auth.request_token({}, options)
         end
@@ -404,7 +404,7 @@ describe Ably::Auth do
             end
 
             it 'raises ServerError' do
-              expect { auth.request_token({}, auth_options) }.to raise_error(Ably::Exceptions::ServerError)
+              expect { auth.request_token({}, auth_options) }.to raise_error(Ably::Exceptions::AuthenticationFailed)
             end
           end
 
@@ -415,7 +415,7 @@ describe Ably::Auth do
             end
 
             it 'raises InvalidResponseBody' do
-              expect { auth.request_token({}, auth_options) }.to raise_error(Ably::Exceptions::InvalidResponseBody)
+              expect { auth.request_token({}, auth_options) }.to raise_error(Ably::Exceptions::AuthenticationFailed, /Content Type.*not supported/)
             end
           end
         end
@@ -612,7 +612,7 @@ describe Ably::Auth do
         end
       end
 
-      context 'query_time: true' do
+      context 'query_time: true with authorize' do
         let(:local_time)  { @now - 60 }
         let(:server_time) { @now }
 
@@ -621,7 +621,7 @@ describe Ably::Auth do
           allow(Time).to receive(:now).and_return(local_time)
         end
 
-        it 'only queries the server time once and then works out the offset, query_time option is never persisted' do
+        it 'only queries the server time once and then works out the offset, query_time option is never persisted (#RSA10k)' do
           expect(client).to receive(:time).once.and_return(server_time)
 
           auth.authorize({}, query_time: true)
@@ -630,6 +630,27 @@ describe Ably::Auth do
         end
       end
 
+      context 'query_time: true ClientOption when instanced' do
+        let(:local_time)  { @now - 60 }
+        let(:server_time) { @now }
+
+        let(:client_options)  { default_options.merge(key: api_key, query_time: true) }
+
+        before do
+          @now = Time.now
+          allow(Time).to receive(:now).and_return(local_time)
+        end
+
+        it 'only queries the server time once and then works out the offset, query_time option is never persisted (#RSA10k)' do
+          expect(client).to receive(:time).once.and_return(server_time)
+
+          auth.authorize({})
+          auth.authorize({})
+          auth.authorize({})
+          expect(auth.auth_options).to_not have_key(:query_time)
+        end
+      end
+
       context 'TokenParams argument' do
         let(:default_token_params) { { ttl: 23 } }
 
@@ -644,11 +665,11 @@ describe Ably::Auth do
           expect(auth.token_params[:ttl]).to eql(23)
         end
 
-        it 'updates defaults when present and all previous configured TokenParams are discarded' do
+        it 'updates defaults when present and all previous configured TokenParams are discarded (#RSA10g)' do
           old_token = auth.current_token_details
           auth.authorize({ client_id: 'bob' })
           expect(old_token).to_not eql(auth.current_token_details)
-          expect(auth.token_params[:ttl]).to_not eql(23)
+          expect(auth.token_params[:ttl]).to_not eq(23)
           expect(auth.token_params[:client_id]).to eql('bob')
         end
 
@@ -656,6 +677,14 @@ describe Ably::Auth do
           auth.authorize({ client_id: 'bob' })
           expect { auth.token_params['key_name'] = 'new_name' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
         end
+
+        it 'uses TokenParams#timestamp for this request but obtains a new timestamp for subsequence requests (#RSA10g)' do
+          timestamp = Time.now.to_i
+          expect(auth).to receive(:create_token_request).with({ timestamp: Time.now.to_i }, {}).once.and_call_original
+          expect(auth).to receive(:create_token_request).with({}, {}).once.and_call_original
+          auth.authorize(timestamp: Time.now.to_i)
+          auth.authorize
+        end
       end
 
       context 'AuthOptions argument' do
@@ -680,7 +709,7 @@ describe Ably::Auth do
           expect(auth.options[:auth_callback]).to eql(auth_callback)
         end
 
-        it 'updates defaults when present and all previous configured AuthOptions are discarded' do
+        it 'updates defaults when present and all previous configured AuthOptions are discarded (#RSA10g)' do
           auth.authorize(nil, auth_method: :post)
           expect(@old_token).to_not eql(auth.current_token_details)
           expect(auth.options[:auth_callback]).to be_nil
@@ -691,6 +720,18 @@ describe Ably::Auth do
           auth.authorize(nil, auth_callback: Proc.new { '1231232.12321:12321312' })
           expect { auth.options['key_name'] = 'new_name' }.to raise_error RuntimeError, /can't modify frozen.*Hash/
         end
+
+        it 'uses AuthOptions#query_time for this request and will not query_time for subsequent requests (#RSA10g)' do
+          expect(client).to receive(:time).once.and_call_original
+          auth.authorize({}, query_time: true)
+          auth.authorize
+        end
+
+        it 'uses AuthOptions#query_time for this request and will query_time again if provided subsequently' do
+          expect(client).to receive(:time).twice.and_call_original
+          auth.authorize({}, query_time: true)
+          auth.authorize({}, query_time: true)
+        end
       end
 
       context 'with previous authorisation' do
@@ -768,7 +809,7 @@ describe Ably::Auth do
             @block_called = 0
           end
 
-          let(:token_client)   { Ably::Rest::Client.new(default_options.merge(key: api_key, token_params: { ttl: 3 })) }
+          let(:token_client)   { Ably::Rest::Client.new(default_options.merge(key: api_key, default_token_params: { ttl: 3 })) }
           let(:client_options) {
             default_options.merge(token: token_client.auth.request_token.token, auth_callback: Proc.new do
               @block_called += 1
@@ -840,21 +881,22 @@ describe Ably::Auth do
         expect(subject['keyName']).to eql(key_name)
       end
 
-      it 'uses the default TTL' do
-        expect(subject['ttl']).to eql(Ably::Auth::TOKEN_DEFAULTS.fetch(:ttl) * 1000)
+      it 'specifies no TTL (#RSA5)' do
+        expect(subject['ttl']).to be_nil
       end
 
       context 'with a :ttl option below the Token expiry buffer that ensures tokens are renewed 15s before they expire as they are considered expired' do
-        let(:ttl)        { 1 }
+        let(:ttl) { 1 }
+        let(:token_params) { { ttl: ttl } }
 
         it 'uses the Token expiry buffer default + 10s to allow for a token request in flight' do
-          expect(subject.ttl).to be > 1
-          expect(subject.ttl).to be > Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER
+          expect(subject['ttl']).to be > 1
+          expect(subject['ttl']).to be > Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER
         end
       end
 
-      it 'uses the default capability' do
-        expect(subject['capability']).to eql(Ably::Auth::TOKEN_DEFAULTS.fetch(:capability).to_json)
+      it 'specifies no capability (#RSA6)' do
+        expect(subject['capability']).to be_nil
       end
 
       context 'the nonce' do
@@ -1048,6 +1090,42 @@ describe Ably::Auth do
         it 'cannot be renewed automatically' do
           expect(token_auth_client.auth).to_not be_token_renewable
         end
+
+        context 'and the token expires' do
+          let(:ttl) { 1 }
+
+          before do
+            stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', 0 # allow token to be used even if about to expire
+            stub_const 'Ably::Auth::TOKEN_DEFAULTS', Ably::Auth::TOKEN_DEFAULTS.merge(renew_token_buffer: 0) # Ensure tokens issued expire immediately after issue
+
+            @token = auth.request_token(ttl: ttl)
+            WebMock.enable!
+            WebMock.disable_net_connect!
+
+            token_expired = {
+              "error" => {
+                "statusCode" => 401,
+                "code" => 40140,
+                "message" => "Token expired"
+              }
+            }
+
+            stub_request(:post, "https://#{environment}-rest.ably.io/channels/foo/publish").
+              to_return(status: 401, body: token_expired.to_json, headers: { 'Content-Type' => 'application/json' })
+          end
+
+          after do
+            WebMock.allow_net_connect!
+            WebMock.disable!
+          end
+
+          let(:token) { @token.token }
+
+          it 'should indicate an error and not retry the request (#RSA4a)' do
+            sleep ttl + 1
+            expect { token_auth_client.channels.get('foo').publish 'event' }.to raise_error(Ably::Exceptions::TokenExpired)
+          end
+        end
       end
 
       context 'when implicit as a result of using :client_id' do
@@ -1090,14 +1168,14 @@ describe Ably::Auth do
             expect(client.channel('foo').publish('event', 'data')).to be_truthy
           end
 
-          it 'with capability and TTL defaults' do
+          it 'with capability and TTL defaults (#TK2a, #TK2b)' do
             client.channel('foo').publish('event', 'data')
 
             expect(token).to be_a(Ably::Models::TokenDetails)
-            capability_with_str_key = Ably::Auth::TOKEN_DEFAULTS.fetch(:capability)
+            capability_with_str_key = { "*" => ["*"] } # Ably default is all capabilities
             capability = Hash[capability_with_str_key.keys.map(&:to_s).zip(capability_with_str_key.values)]
             expect(token.capability).to eq(capability)
-            expect(token.expires.to_i).to be_within(2).of(Time.now.to_i + Ably::Auth::TOKEN_DEFAULTS.fetch(:ttl))
+            expect(token.expires.to_i).to be_within(2).of(Time.now.to_i + 60 * 60) # Ably default is 1hr
             expect(token.client_id).to eq(client_id)
           end
 
@@ -1107,6 +1185,54 @@ describe Ably::Auth do
         end
       end
 
+      context 'when token expires' do
+        before do
+          stub_const 'Ably::Models::TokenDetails::TOKEN_EXPIRY_BUFFER', 0 # allow token to be used even if about to expire
+          stub_const 'Ably::Auth::TOKEN_DEFAULTS', Ably::Auth::TOKEN_DEFAULTS.merge(renew_token_buffer: 0) # Ensure tokens issued expire immediately after issue
+        end
+
+        after do
+          WebMock.allow_net_connect!
+          WebMock.disable!
+        end
+
+        let(:client_options) { default_options.merge(use_token_auth: true, key: api_key, query_time: true, default_token_params: { ttl: 2 }) }
+        let(:channel) { client.channels.get(random_str) }
+        let(:token_expired_response) do
+          {
+            "error" => {
+              "statusCode" => 401,
+              "code" => 40140,
+              "message" => "Token expired"
+            }
+          }
+        end
+
+        it 'automatically renews the token (#RSA4b)' do
+          expect(auth.current_token_details).to be_nil
+          channel.publish 'event'
+          token = auth.current_token_details
+          expect(token).to_not be_nil
+          sleep 2.5
+          channel.publish 'event'
+          expect(auth.current_token_details).to_not eql(token)
+        end
+
+        it 'fails if the token renewal fails (#RSA4b)' do
+          expect(auth.current_token_details).to be_nil
+          channel.publish 'event'
+          token = auth.current_token_details
+          expect(token).to_not be_nil
+          sleep 2.5
+          WebMock.enable!
+          WebMock.disable_net_connect!
+          stub_request(:post, "https://#{environment}-rest.ably.io/keys/#{TestApp.instance.key_name}/requestToken").
+              to_return(status: 401, body: token_expired_response.to_json, headers: { 'Content-Type' => 'application/json' })
+          expect { channel.publish 'event' }.to raise_error Ably::Exceptions::TokenExpired
+          expect(auth.current_token_details).to eql(token)
+        end
+      end
+
       context 'when :client_id is provided in a token' do
         let(:client_id) { '123' }
         let(:token) do
@@ -1199,7 +1325,7 @@ describe Ably::Auth do
     end
 
     context 'deprecated #authorise' do
-      let(:client_options)  { default_options.merge(key: api_key, logger: custom_logger_object) }
+      let(:client_options)  { default_options.merge(key: api_key, logger: custom_logger_object, use_token_auth: true) }
       let(:custom_logger) do
         Class.new do
           def initialize
@@ -1207,8 +1333,11 @@ describe Ably::Auth do
           end
 
           [:fatal, :error, :warn, :info, :debug].each do |severity|
-            define_method severity do |message|
-              @messages << [severity, message]
+            define_method severity do |message, &block|
+              message_val = [message]
+              message_val << block.call if block
+
+              @messages << [severity, message_val.compact.join(' ')]
             end
           end
 

data/lib/submodules/ably-ruby/spec/acceptance/rest/channel_spec.rb

@@ -84,7 +84,7 @@ describe Ably::Rest::Channel do
 
       context 'without adequate permissions on the channel' do
         let(:capability)     { { onlyChannel: ['subscribe'] } }
-        let(:client_options) { default_options.merge(use_token_auth: true, token_params: { capability: capability }) }
+        let(:client_options) { default_options.merge(use_token_auth: true, default_token_params: { capability: capability }) }
 
         it 'raises a permission error when publishing' do
           expect { channel.publish(name, data) }.to raise_error(Ably::Exceptions::UnauthorizedRequest, /not permitted/)

data/lib/submodules/ably-ruby/spec/acceptance/rest/client_spec.rb

@@ -51,6 +51,14 @@ describe Ably::Rest::Client do
         end
       end
 
+      context 'with a non string :client_id' do
+        let(:client) { Ably::Rest::Client.new(client_options.merge(key: api_key, client_id: 1)) }
+
+        it 'raises an ArgumentError' do
+          expect { client.auth }.to raise_error ArgumentError, /client_id.*String/
+        end
+      end
+
       context 'with an invalid wildcard "*" :client_id' do
         it 'raises an exception' do
           expect { Ably::Rest::Client.new(client_options.merge(key: api_key, client_id: '*')) }.to raise_error ArgumentError
@@ -70,6 +78,21 @@ describe Ably::Rest::Client do
         end
       end
 
+      context 'with :default_token_params' do
+        let(:client) do
+          Ably::Rest::Client.new(client_options.merge(
+            default_token_params: { client_id: 'bob' },
+            use_token_auth: true,
+            key: api_key
+          ))
+        end
+
+        it 'overides the default token params (#TO3j11)' do
+          client.auth.authorize
+          expect(client.auth.client_id).to eql('bob')
+        end
+      end
+
       context 'with an :auth_callback Proc (clientId provided in library options instead of as a token_request param)' do
         let(:client) { Ably::Rest::Client.new(client_options.merge(client_id: client_id, auth_callback: Proc.new { token_request })) }
         let(:token_request) { client.auth.create_token_request({}, key_name: key_name, key_secret: key_secret) }
@@ -272,7 +295,7 @@ describe Ably::Rest::Client do
       context 'configured' do
         let(:client_options) { default_options.merge(key: api_key, environment: 'production') }
 
-        it 'should make connection attempts to A.ably-realtime.com, B.ably-realtime.com, C.ably-realtime.com, D.ably-realtime.com, E.ably-realtime.com' do
+        it 'should make connection attempts to A.ably-realtime.com, B.ably-realtime.com, C.ably-realtime.com, D.ably-realtime.com, E.ably-realtime.com (#RSC15a)' do
           hosts = []
           5.times do
             hosts << client.fallback_connection.host
@@ -281,7 +304,7 @@ describe Ably::Rest::Client do
         end
       end
 
-      context 'when environment is NOT production' do
+      context 'when environment is NOT production (#RSC15b)' do
         let(:client_options) { default_options.merge(environment: 'sandbox', key: api_key) }
         let!(:default_host_request_stub) do
           stub_request(:post, "https://#{environment}-#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
@@ -304,7 +327,8 @@ describe Ably::Rest::Client do
             environment: nil,
             key: api_key,
             http_max_retry_duration: max_retry_duration,
-            http_max_retry_count: max_retry_count
+            http_max_retry_count: max_retry_count,
+            log_level: :error
           )
         end
 
@@ -327,7 +351,7 @@ describe Ably::Rest::Client do
             end
           end
 
-          it "tries fallback hosts #{http_defaults.fetch(:max_retry_count)} times" do
+          it "tries fallback hosts #{http_defaults.fetch(:max_retry_count)} times (#RSC15b, #RSC15b)" do
             expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionError, /ssl error message/
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to have_been_requested
@@ -366,6 +390,43 @@ describe Ably::Rest::Client do
           end
         end
 
+        context 'and first request to primary endpoint fails' do
+          let(:client_options) do
+            default_options.merge(
+              environment: nil,
+              key: api_key,
+              http_max_retry_duration: max_retry_duration,
+              http_max_retry_count: max_retry_count,
+              log_level: :error
+            )
+          end
+          let(:requests) { [] }
+          let!(:default_host_request_stub) do
+            stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").to_return do
+              requests << true
+              if requests.count == 1
+                raise Faraday::ConnectionFailed.new('connection failure error message')
+              else
+                {
+                  headers: { 'Content-Type' => 'application/json' },
+                  status: 200,
+                  body: {}.to_json
+                }
+              end
+            end
+          end
+
+          it "tries a fallback host, and for the next request tries the primary endpoint again (#RSC15e)" do
+            expect { publish_block.call }.to raise_error Ably::Exceptions::ConnectionError, /ssl error message/
+            expect(default_host_request_stub).to have_been_requested
+            expect(first_fallback_request_stub).to have_been_requested
+            expect(requests.count).to eql(1)
+
+            publish_block.call
+            expect(requests.count).to eql(2)
+          end
+        end
+
         context 'and basic authentication fails' do
           let(:status) { 401 }
           let!(:default_host_request_stub) do
@@ -404,7 +465,7 @@ describe Ably::Rest::Client do
             stub_request(:post, "https://#{Ably::Rest::Client::DOMAIN}#{path}").to_return(&fallback_block)
           end
 
-          it 'attempts the fallback hosts as this is an authentication failure' do
+          it 'attempts the fallback hosts as this is an authentication failure (#RSC15d)' do
             expect { publish_block.call }.to raise_error(Ably::Exceptions::ServerError)
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to have_been_requested
@@ -450,10 +511,10 @@ describe Ably::Rest::Client do
           end
 
           let(:client_options) {
-            production_options.merge(fallback_hosts: custom_hosts)
+            production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
           }
 
-          it 'attempts the fallback hosts as this is an authentication failure (#RSC15b, #TO3k6)' do
+          it 'attempts the fallback hosts as this is an authentication failure (#RSC15b, #RSC15a, #TO3k6)' do
             expect { publish_block.call }.to raise_error(Ably::Exceptions::ServerError)
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to have_been_requested
@@ -461,7 +522,7 @@ describe Ably::Rest::Client do
           end
         end
 
-        context 'with an empty array of fallback hosts provided (#RSC15b, #TO3k6)' do
+        context 'with an empty array of fallback hosts provided (#RSC15b, #RSC15a, #TO3k6)' do
           let(:client_options) {
             production_options.merge(fallback_hosts: [])
           }
@@ -485,7 +546,7 @@ describe Ably::Rest::Client do
 
           context 'and timing out the primary host' do
             before do
-              @web_server = WEBrick::HTTPServer.new(:Port => port, :SSLEnable => false)
+              @web_server = WEBrick::HTTPServer.new(:Port => port, :SSLEnable => false, :AccessLog => [], Logger: WEBrick::Log.new("/dev/null"))
               @web_server.mount_proc "/channels/#{channel_name}/publish" do |req, res|
                 if req.header["host"].first.include?(primary_host)
                   @primary_host_requested = true
@@ -516,12 +577,13 @@ describe Ably::Rest::Client do
                   port: port,
                   tls: false,
                   http_request_timeout: request_timeout,
-                  max_retry_duration: request_timeout * 3
+                  max_retry_duration: request_timeout * 3,
+                  log_level: :error
                 )
               end
               let(:fail_fallback_request_count) { 1 }
 
-              it 'tries one of the fallback hosts' do
+              it 'tries one of the fallback hosts (#RSC15d)' do
                 client.channel(channel_name).publish('event', 'data')
                 expect(@primary_host_requested).to be_truthy
                 expect(@fallback_request_count).to eql(2)
@@ -537,12 +599,13 @@ describe Ably::Rest::Client do
                   port: port,
                   tls: false,
                   http_request_timeout: request_timeout,
-                  max_retry_duration: request_timeout / 2
+                  max_retry_duration: request_timeout / 2,
+                  log_level: :error
                 )
               end
               let(:fail_fallback_request_count) { 0 }
 
-              it 'tries one of the fallback hosts' do
+              it 'tries one of the fallback hosts (#RSC15d)' do
                 client.channel(channel_name).publish('event', 'data')
                 expect(@primary_host_requested).to be_truthy
                 expect(@fallback_request_count).to eql(1)
@@ -552,7 +615,7 @@ describe Ably::Rest::Client do
 
           context 'and failing the primary host' do
             before do
-              @web_server = WEBrick::HTTPServer.new(:Port => port, :SSLEnable => false)
+              @web_server = WEBrick::HTTPServer.new(:Port => port, :SSLEnable => false, :AccessLog => [], Logger: WEBrick::Log.new("/dev/null"))
               @web_server.mount_proc "/channels/#{channel_name}/publish" do |req, res|
                 if req.header["host"].first.include?(primary_host)
                   @primary_host_requested = true
@@ -580,7 +643,8 @@ describe Ably::Rest::Client do
                 fallback_hosts: fallbacks,
                 token: 'fake.token',
                 port: port,
-                tls: false
+                tls: false,
+                log_level: :error
               )
             end
             let(:fail_fallback_request_count) { 1 }
@@ -632,10 +696,10 @@ describe Ably::Rest::Client do
           end
 
           let(:client_options) {
-            production_options.merge(fallback_hosts: custom_hosts)
+            production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
           }
 
-          it 'attempts the fallback hosts as this is an authentication failure' do
+          it 'attempts the fallback hosts as this is not an authentication failure' do
             expect { publish_block.call }.to raise_error(Ably::Exceptions::ServerError)
             expect(default_host_request_stub).to have_been_requested
             expect(first_fallback_request_stub).to have_been_requested
@@ -661,10 +725,6 @@ describe Ably::Rest::Client do
             stub_const 'Ably::FALLBACK_HOSTS', custom_hosts
           end
 
-          let(:client_options) {
-            production_options.merge(fallback_hosts_use_default: true)
-          }
-
           let!(:first_fallback_request_stub) do
             stub_request(:post, "https://#{Ably::FALLBACK_HOSTS[0]}#{path}").to_return(&fallback_block)
           end
@@ -674,7 +734,7 @@ describe Ably::Rest::Client do
           end
 
           let(:client_options) {
-            production_options.merge(fallback_hosts: custom_hosts)
+            production_options.merge(fallback_hosts: custom_hosts, log_level: :error)
           }
 
           it 'attempts the default fallback hosts as this is an authentication failure' do
@@ -758,16 +818,16 @@ describe Ably::Rest::Client do
           expect(client.http_defaults[:open_timeout]).to eql(4)
         end
 
-        specify '#http_request_timeout is 15s' do
-          expect(client.http_defaults[:request_timeout]).to eql(15)
+        specify '#http_request_timeout is 10s' do
+          expect(client.http_defaults[:request_timeout]).to eql(10)
         end
 
         specify '#http_max_retry_count is 3' do
           expect(client.http_defaults[:max_retry_count]).to eql(3)
         end
 
-        specify '#http_max_retry_duration is 10s' do
-          expect(client.http_defaults[:max_retry_duration]).to eql(10)
+        specify '#http_max_retry_duration is 15s' do
+          expect(client.http_defaults[:max_retry_duration]).to eql(15)
         end
       end
 
@@ -848,9 +908,10 @@ describe Ably::Rest::Client do
               to_return(status: 201, body: '{}', headers: { 'Content-Type' => 'application/json' })
           end
 
-          it 'sends a protocol version and lib version header' do
+          it 'sends a protocol version and lib version header (#G4, #RSC7a, #RSC7b)' do
             client.channels.get('foo').publish("event")
             expect(publish_message_stub).to have_been_requested
+            expect(Ably::PROTOCOL_VERSION).to eql('1.0')
           end
         end
       end