Simplify serialization

Author: aguspe

rb/lib/selenium/webdriver/bidi/network/cookies.rb

@@ -20,31 +20,14 @@
 module Selenium
   module WebDriver
     class BiDi
-      class Cookies
+      class Cookies < Hash
         def initialize(cookies = {})
-          @cookies = cookies
-        end
-
-        def all
-          @cookies
-        end
-
-        def []=(key, value)
-          @cookies[key] = value
-        end
-
-        def [](key)
-          @cookies[key]
-        end
-
-        def delete(key)
-          @cookies.delete(key)
+          super()
+          merge!(cookies)
         end
 
         def serialize
-          return [] unless @cookies
-
-          @cookies.map do |name, value|
+          map do |name, value|
             {
               name: name.to_s,
               value: {
@@ -55,8 +38,6 @@ def serialize
           end
         end
       end
-    end
-
-    # BiDi
+    end # BiDi
   end # WebDriver
 end # Selenium

rb/lib/selenium/webdriver/bidi/network/headers.rb

@@ -20,29 +20,9 @@
 module Selenium
   module WebDriver
     class BiDi
-      class Headers
-        def initialize
-          @headers = {}
-        end
-
-        def all
-          @headers
-        end
-
-        def []=(key, value)
-          @headers[key] = value
-        end
-
-        def [](key)
-          @headers[key]
-        end
-
-        def delete(key)
-          @headers.delete(key)
-        end
-
+      class Headers < Hash
         def serialize
-          @headers.map do |name, val|
+          map do |name, val|
             {
               name: name.to_s,
               value: {

rb/lib/selenium/webdriver/bidi/network/set_cookie_headers.rb

@@ -20,31 +20,14 @@
 module Selenium
   module WebDriver
     class BiDi
-      class SetCookieHeaders
+      class SetCookieHeaders < Hash
         def initialize(set_cookie_headers = {})
-          @set_cookie_headers = set_cookie_headers
-        end
-
-        def all
-          @set_cookie_headers
-        end
-
-        def []=(key, value)
-          @set_cookie_headers[key] = {value: value}
-        end
-
-        def [](key)
-          @set_cookie_headers[key]
-        end
-
-        def delete(key)
-          @set_cookie_headers.delete(key)
+          super()
+          merge!(set_cookie_headers)
         end
 
         def serialize
-          return [] unless @set_cookie_headers
-
-          @set_cookie_headers.map do |name, data|
+          map do |name, data|
             data = {value: data} unless data.is_a?(Hash)
 
             {

rb/sig/lib/selenium/webdriver/bidi/network/cookies.rbs

@@ -2,18 +2,8 @@ module Selenium
   module WebDriver
     class BiDi
       class Cookies
-        @cookies: untyped
-
         def initialize: (untyped cookies) -> void
 
-        def all: () -> untyped
-
-        def []=: (untyped key, untyped value) -> untyped
-
-        def []: (untyped key) -> untyped
-
-        def delete: (untyped key) -> untyped
-
         def serialize: () -> untyped
       end
     end

rb/sig/lib/selenium/webdriver/bidi/network/headers.rbs

@@ -2,18 +2,8 @@ module Selenium
   module WebDriver
     class BiDi
       class Headers
-        @headers: untyped
-
         def initialize: () -> void
 
-        def all: () -> untyped
-
-        def []=: (untyped key, untyped value) -> untyped
-
-        def []: (untyped key) -> untyped
-
-        def delete: (untyped key) -> untyped
-
         def serialize: () -> untyped
       end
     end

rb/sig/lib/selenium/webdriver/bidi/network/set_cookie_headers.rbs

@@ -2,21 +2,9 @@ module Selenium
   module WebDriver
     class BiDi
       class SetCookieHeaders
-        @set_cookie_headers: untyped
-
         def initialize: (untyped set_cookie_headers) -> void
 
-        def all: () -> untyped
-
-        def set_cookie_header: (**untyped args) -> untyped
-
-        def []=: (untyped key, untyped value) -> untyped
-
-        def []: (untyped key) -> untyped
-
-        def delete: (untyped key) -> untyped
-
-        def serialize: () -> (::Array[untyped] | untyped)
+        def serialize: () -> (Array[untyped] | untyped)
       end
     end
   end

rb/spec/unit/selenium/webdriver/bidi/cookies_spec.rb

@@ -26,98 +26,22 @@ class BiDi
       describe Cookies do
         let(:cookies) { described_class.new }
 
-        describe '#initialize' do
-          it 'initializes with an empty hash by default' do
-            expect(cookies.all).to eq({})
-          end
-
-          it 'stores the passed cookie hash internally' do
-            my_hash = {'foo' => {value: 'bar'}}
-            cookie_headers = described_class.new(my_hash)
-            expect(cookie_headers.all).to eq(my_hash)
-          end
-        end
-
-        describe '#all' do
-          it 'returns the underlying cookies hash' do
-            cookies['session_id'] = 'abc123'
-            expect(cookies.all).to eq({'session_id' => 'abc123'})
-          end
-        end
-
-        describe '#add_cookie' do
-          it 'adds a cookie to the internal store' do
-            cookies['foo'] = 'bar'
-            expect(cookies['foo']).to eq('bar')
-          end
-
-          it 'updates an existing cookie if the name already exists' do
-            cookies['foo'] = 'bar'
-            cookies['foo'] = 'baz'
-            expect(cookies['foo']).to eq('baz')
-          end
-        end
-
-        describe '#remove_cookie' do
-          it 'removes a cookie by name' do
-            cookies['foo'] = 'bar'
-            cookies.delete('foo')
-            expect(cookies['foo']).to be_nil
-          end
-
-          it 'does not raise an error if cookie does not exist' do
-            expect { cookies.delete('non_existent') }.not_to raise_error
-          end
-        end
-
-        describe '#[]=' do
-          it 'adds a cookie using bracket assignment' do
-            cookies['key1'] = 'value1'
-            expect(cookies['key1']).to eq('value1')
-          end
-        end
-
-        describe '#[]' do
-          it 'retrieves the value of a cookie by name' do
-            cookies['key2'] = 'value2'
-            expect(cookies['key2']).to eq('value2')
-          end
-
-          it 'returns nil for unknown cookies' do
-            expect(cookies['does_not_exist']).to be_nil
-          end
-        end
-
-        describe '#delete' do
-          it 'removes a cookie via bracket-based delete' do
-            cookies['key3'] = 'value3'
-            cookies.delete('key3')
-            expect(cookies['key3']).to be_nil
-          end
-        end
-
-        describe '#serialize' do
-          it 'returns an array of cookie hashes in the minimal format' do
-            cookies['key4'] = 'value4'
-            cookies['session_id'] = 'xyz123'
-
-            serialized = cookies.serialize
-            expect(serialized).to be_an(Array)
-            expect(serialized.size).to eq(2)
-
-            key4_item = serialized.find { |h| h[:name] == 'key4' }
-            expect(key4_item).not_to be_nil
-            expect(key4_item[:value][:type]).to eq('string')
-            expect(key4_item[:value][:value]).to eq('value4')
-
-            session_item = serialized.find { |h| h[:name] == 'session_id' }
-            expect(session_item).not_to be_nil
-            expect(session_item[:value][:value]).to eq('xyz123')
-          end
-
-          it 'returns an empty array if no cookies are set' do
-            expect(cookies.serialize).to eq([])
-          end
+        it 'returns a serialized array of cookie hashes' do
+          cookies['key4'] = 'value4'
+          cookies['session_id'] = 'xyz123'
+
+          serialized = cookies.serialize
+          expect(serialized).to be_an(Array)
+          expect(serialized.size).to eq(2)
+
+          key4_item = serialized.find { |h| h[:name] == 'key4' }
+          expect(key4_item).not_to be_nil
+          expect(key4_item[:value][:type]).to eq('string')
+          expect(key4_item[:value][:value]).to eq('value4')
+
+          session_item = serialized.find { |h| h[:name] == 'session_id' }
+          expect(session_item).not_to be_nil
+          expect(session_item[:value][:value]).to eq('xyz123')
         end
       end
     end

rb/spec/unit/selenium/webdriver/bidi/headers_spec.rb

@@ -26,94 +26,21 @@ class BiDi
       describe Headers do
         let(:headers) { described_class.new }
 
-        describe '#initialize' do
-          it 'initializes an empty headers hash' do
-            expect(headers.all).to eq({})
-          end
-        end
-
-        describe '#all' do
-          it 'returns the underlying headers hash' do
-            headers['Authorization'] = 'Bearer abc123'
-            expect(headers.all).to eq({'Authorization' => 'Bearer abc123'})
-          end
-        end
-
-        describe '#add_header' do
-          it 'adds a header to the internal store' do
-            headers['Content-Type'] = 'application/json'
-            expect(headers['Content-Type']).to eq('application/json')
-          end
-
-          it 'updates an existing header if the name already exists' do
-            headers['Content-Type'] = 'text/html'
-            headers['Content-Type'] = 'application/json'
-            expect(headers['Content-Type']).to eq('application/json')
-          end
-        end
-
-        describe '#remove_header' do
-          it 'removes a header by name' do
-            headers['X-Custom-Header'] = 'foo'
-            headers.delete('X-Custom-Header')
-            expect(headers['X-Custom-Header']).to be_nil
-          end
-
-          it 'does not raise an error if header does not exist' do
-            expect { headers.delete('Non-Existent') }.not_to raise_error
-          end
-        end
-
-        describe '#[]=' do
-          it 'adds or updates a header using bracket assignment' do
-            headers['Cache-Control'] = 'no-cache'
-            expect(headers['Cache-Control']).to eq('no-cache')
-
-            headers['Cache-Control'] = 'private'
-            expect(headers['Cache-Control']).to eq('private')
-          end
-        end
-
-        describe '#[]' do
-          it 'retrieves the value of a header by name' do
-            headers['Host'] = 'example.com'
-            expect(headers['Host']).to eq('example.com')
-          end
-
-          it 'returns nil for unknown headers' do
-            expect(headers['Does-Not-Exist']).to be_nil
-          end
-        end
-
-        describe '#delete' do
-          it 'removes a header via bracket-based delete' do
-            headers['Accept'] = 'text/html'
-            headers.delete('Accept')
-            expect(headers['Accept']).to be_nil
-          end
-        end
-
-        describe '#serialize' do
-          it 'returns an array of header hashes in the correct format' do
-            headers['Accept'] = 'application/json'
-            headers['User-Agent'] = 'MyAgent/1.0'
-
-            serialized = headers.serialize
-            expect(serialized).to be_an(Array)
-            expect(serialized.size).to eq(2)
+        it 'returns an array of serialized array of header hashes' do
+          headers['Accept'] = 'application/json'
+          headers['User-Agent'] = 'MyAgent/1.0'
 
-            accept_item = serialized.find { |h| h[:name] == 'Accept' }
-            expect(accept_item).not_to be_nil
-            expect(accept_item[:value]).to eq({type: 'string', value: 'application/json'})
+          serialized = headers.serialize
+          expect(serialized).to be_an(Array)
+          expect(serialized.size).to eq(2)
 
-            ua_item = serialized.find { |h| h[:name] == 'User-Agent' }
-            expect(ua_item).not_to be_nil
-            expect(ua_item[:value]).to eq({type: 'string', value: 'MyAgent/1.0'})
-          end
+          accept_item = serialized.find { |h| h[:name] == 'Accept' }
+          expect(accept_item).not_to be_nil
+          expect(accept_item[:value]).to eq({ type: 'string', value: 'application/json' })
 
-          it 'returns an empty array if no headers are set' do
-            expect(headers.serialize).to eq([])
-          end
+          ua_item = serialized.find { |h| h[:name] == 'User-Agent' }
+          expect(ua_item).not_to be_nil
+          expect(ua_item[:value]).to eq({ type: 'string', value: 'MyAgent/1.0' })
         end
       end
     end