arachni 0.4.7 → 1.0

data/spec/arachni/option_groups/session_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Arachni::OptionGroups::Session do
+    include_examples 'option_group'
+
+    subject { described_class.new }
+    let(:valid) do
+        options = described_class.new
+        options.check_url     = 'http://test.com/'
+        options.check_pattern = /test/
+        options
+    end
+
+    %w(check_url check_pattern).each do |method|
+        it { should respond_to method }
+        it { should respond_to "#{method}=" }
+    end
+
+    describe '#validate' do
+        context 'when valid' do
+            it 'returns nil' do
+                valid.validate.should be_empty
+            end
+        end
+
+        context 'when invalid' do
+            context 'due to' do
+                context 'missing' do
+                    %w(check_url check_pattern).each do |attribute|
+                        context attribute do
+                            it 'returns errors' do
+                                valid.send( "#{attribute}=", nil )
+                                valid.validate.should ==
+                                    { attribute.to_sym => 'Option is missing.'}
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+
+    describe '#to_rpc_data' do
+        let(:data) { subject.to_rpc_data }
+
+        it "converts 'check_pattern' to strings" do
+            subject.check_pattern = /test/
+            data['check_pattern'].should == subject.check_pattern.to_s
+        end
+    end
+end

data/spec/arachni/option_groups/snapshot_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Arachni::OptionGroups::Snapshot do
+    include_examples 'option_group'
+    subject { described_class.new }
+
+    %w(save_path).each do |method|
+        it { should respond_to method }
+        it { should respond_to "#{method}=" }
+    end
+end

data/spec/arachni/options_spec.rb

@@ -2,785 +2,212 @@ require 'spec_helper'
 
 describe Arachni::Options do
     before( :each ) do
-        ENV['ARACHNI_FRAMEWORK_LOGDIR'] = nil
-        @opts = Arachni::Options.instance.reset
-        @utils = Arachni::Module::Utilities
+        @utils = Arachni::Utilities
     end
 
+    subject { reset_options; described_class.instance }
+    groups = [:audit, :datastore, :dispatcher, :http, :session, :output, :paths,
+              :rpc, :scope, :input]
+
     it 'proxies missing class methods to instance methods' do
         url = 'http://test.com/'
-        Arachni::Options.url.should_not == url
-        Arachni::Options.url = url
-        Arachni::Options.url.should == url
-    end
-
-    describe "#dir['logs']" do
-        context 'when the ARACHNI_FRAMEWORK_LOGDIR environment variable' do
-            context 'has been set' do
-                it 'returns its value' do
-                    ENV['ARACHNI_FRAMEWORK_LOGDIR'] = 'test'
-                    described_class.reset
-                    described_class.dir['logs'].should == 'test/'
-                end
-            end
-            context 'has not been set' do
-                it 'returns the default location' do
-                    described_class.dir['logs'].should == "#{described_class.dir['root']}logs/"
-                end
-            end
-        end
-    end
-
-    describe '#grid?' do
-        describe 'when the option has been enabled' do
-            context 'via #grid=' do
-                it 'returns true' do
-                    Arachni::Options.grid = true
-                    Arachni::Options.grid?.should be_true
-                end
-            end
-
-            context 'via #grid_mode=' do
-                it 'returns true' do
-                    Arachni::Options.grid_mode = :balance
-                    Arachni::Options.grid?.should be_true
-                end
-            end
-        end
-        describe 'when the option has been disabled' do
-            context 'via #grid=' do
-                it 'returns false' do
-                    Arachni::Options.grid = false
-                    Arachni::Options.grid?.should be_false
-                end
-            end
-
-            context 'via #grid_mode=' do
-                it 'returns false' do
-                    Arachni::Options.grid_mode = false
-                    Arachni::Options.grid?.should be_false
-                end
-            end
-        end
-        describe 'by default' do
-            it 'returns false' do
-                Arachni::Options.grid?.should be_false
-            end
-        end
-    end
-
-    describe '#grid=' do
-        context true do
-            it 'is a shorthand for #grid_mode = :balance' do
-                Arachni::Options.grid = true
-                Arachni::Options.grid_mode.should == :balance
-            end
-        end
-    end
-
-    describe '#grid_mode=' do
-        context 'when given' do
-            context String do
-                it 'converts it to Symbol and sets the option' do
-                    Arachni::Options.grid_mode = 'balance'
-                    Arachni::Options.grid_mode.should == :balance
-                end
-            end
-
-            context Symbol do
-                it 'sets the option' do
-                    Arachni::Options.grid_mode = :aggregate
-                    Arachni::Options.grid_mode.should == :aggregate
-                end
-            end
-
-            context 'an invalid option' do
-                it 'raises ArgumentError' do
-                    expect { Arachni::Options.grid_mode = :stuff }.to raise_error ArgumentError
-                end
-            end
-        end
-    end
-
-    describe '#grid_aggregate?' do
-        context 'when in :aggregate mode' do
-            it 'returns true' do
-                Arachni::Options.grid_aggregate?.should be_false
-                Arachni::Options.grid_mode = :aggregate
-                Arachni::Options.grid_aggregate?.should be_true
-            end
-        end
-        context 'when in :balance mode' do
-            it 'returns false' do
-                Arachni::Options.grid_aggregate?.should be_false
-                Arachni::Options.grid_mode = :balance
-                Arachni::Options.grid_aggregate?.should be_false
-            end
-        end
-    end
-
-    describe '#grid_balance?' do
-        context 'when in :balance mode' do
-            it 'returns true' do
-                Arachni::Options.grid_balance?.should be_false
-                Arachni::Options.grid_mode = :balance
-                Arachni::Options.grid_balance?.should be_true
-            end
-        end
-        context 'when in :balance mode' do
-            it 'returns false' do
-                Arachni::Options.grid_balance?.should be_false
-                Arachni::Options.grid_mode = :aggregate
-                Arachni::Options.grid_balance?.should be_false
-            end
-        end
-    end
-
-    describe '#no_protocol_for_url' do
-        it 'allows URLs without a protocol' do
-            trigger = proc { Arachni::Options.url = 'stuff:80' }
-
-            raised = false
-            begin
-                trigger.call
-            rescue Arachni::Error
-                raised = true
-            end
-            raised.should be_true
-
-            raised = false
-            begin
-                trigger.call
-            rescue Arachni::Options::Error
-                raised = true
-            end
-            raised.should be_true
-
-            raised = false
-            begin
-                trigger.call
-            rescue Arachni::Options::Error::InvalidURL
-                raised = true
-            end
-            raised.should be_true
-
-            Arachni::Options.no_protocol_for_url
-            Arachni::Options.url = 'stuff:80'
-            Arachni::Options.url.should == 'stuff:80'
-        end
-    end
-
-    describe '#min_pages_per_instance=' do
-        it 'forces its argument to an Integer' do
-            Arachni::Options.min_pages_per_instance = '55'
-            Arachni::Options.min_pages_per_instance.should == 55
-        end
-    end
-
-    describe '#max_slaves=' do
-        it 'forces its argument to an Integer' do
-            Arachni::Options.max_slaves = '56'
-            Arachni::Options.max_slaves.should == 56
-        end
+        subject.url.should_not == url
+        subject.url = url
+        subject.url.should == url
     end
 
-    describe '#user_agent' do
-        it "defaults to Arachni/v#{Arachni::VERSION}" do
-            Arachni::Options.user_agent.should == 'Arachni/v' + Arachni::VERSION.to_s
-        end
-    end
-
-    describe '#http_timeout' do
-        it "defaults to 50000" do
-            Arachni::Options.http_timeout.should == 50000
-        end
+    %w(checks platforms plugins authorized_by no_fingerprinting spawns).each do |method|
+        it { should respond_to method }
+        it { should respond_to "#{method}=" }
     end
 
-    describe '#https_only?' do
-        describe 'when the option has been enabled' do
-            it 'returns true' do
-                Arachni::Options.https_only = true
-                Arachni::Options.https_only?.should be_true
-            end
-        end
-        describe 'when the option has been disabled' do
-            it 'returns false' do
-                Arachni::Options.https_only = false
-                Arachni::Options.https_only?.should be_false
-            end
-        end
-        describe 'by default' do
-            it 'returns false' do
-                Arachni::Options.https_only?.should be_false
+    groups.each do |group|
+        describe "##{group}" do
+            it 'is an OptionGroup' do
+                subject.send( group ).should be_kind_of Arachni::OptionGroup
+                subject.send( group ).class.to_s.downcase.should ==
+                    "arachni::optiongroups::#{group}"
             end
         end
     end
 
-    describe '#auto_redundant?' do
-        describe 'when the option has been enabled' do
-            it 'returns true' do
-                Arachni::Options.auto_redundant = 10
-                Arachni::Options.auto_redundant?.should be_true
-            end
-        end
-        describe 'when the option has been disabled' do
-            it 'returns false' do
-                Arachni::Options.auto_redundant = nil
-                Arachni::Options.auto_redundant?.should be_false
-            end
-        end
-        describe 'by default' do
-            it 'returns false' do
-                Arachni::Options.auto_redundant?.should be_false
-            end
+    describe '#spawns' do
+        it 'defaults to 0' do
+            subject.spawns.should == 0
         end
-    end
 
-    describe '#exclude_binaries?' do
-        describe 'when the option has been enabled' do
-            it 'returns true' do
-                Arachni::Options.exclude_binaries = true
-                Arachni::Options.exclude_binaries?.should be_true
-            end
-        end
-        describe 'when the option has been disabled' do
-            it 'returns false' do
-                Arachni::Options.exclude_binaries = false
-                Arachni::Options.exclude_binaries?.should be_false
-            end
-        end
-        describe 'by default' do
-            it 'returns false' do
-                Arachni::Options.exclude_binaries?.should be_false
-            end
+        it 'converts its argument to Integer' do
+            subject.spawns = '5'
+            subject.spawns.should == 5
         end
     end
 
     describe '#do_not_fingerprint' do
-        it 'sets #no_fingerprinting to true' do
-            Arachni::Options.fingerprint?.should be_true
-            Arachni::Options.no_fingerprinting.should be_false
-
-            Arachni::Options.do_not_fingerprint
-            Arachni::Options.fingerprint?.should be_false
-            Arachni::Options.no_fingerprinting.should be_true
+        it 'disables fingerprinting' do
+            subject.no_fingerprinting.should be_false
+            subject.do_not_fingerprint
+            subject.no_fingerprinting.should be_true
         end
     end
 
     describe '#fingerprint' do
-        it 'sets #no_fingerprinting to false' do
-            Arachni::Options.do_not_fingerprint
-            Arachni::Options.fingerprint?.should be_false
-            Arachni::Options.no_fingerprinting.should be_true
+        it 'enables fingerprinting' do
+            subject.do_not_fingerprint
+            subject.no_fingerprinting.should be_true
 
-            Arachni::Options.fingerprint
-
-            Arachni::Options.fingerprint?.should be_true
-            Arachni::Options.no_fingerprinting.should be_false
+            subject.fingerprint
+            subject.no_fingerprinting.should be_false
         end
     end
 
     describe '#fingerprint?' do
-        context 'by default' do
+        context 'when fingerprinting is enabled' do
             it 'returns true' do
-                Arachni::Options.fingerprint?.should be_true
-            end
-        end
-        context 'when crawling is enabled' do
-            it 'returns true' do
-                Arachni::Options.do_not_fingerprint
-                Arachni::Options.fingerprint?.should be_false
-                Arachni::Options.fingerprint
-                Arachni::Options.fingerprint?.should be_true
-            end
-        end
-        context 'when crawling is disabled' do
-            it 'returns false' do
-                Arachni::Options.fingerprint?.should be_true
-                Arachni::Options.do_not_fingerprint
-                Arachni::Options.fingerprint?.should be_false
+                subject.no_fingerprinting = false
+                subject.fingerprint?.should be_true
             end
         end
-    end
-
-    describe '#do_not_crawl' do
-        it 'sets the link_count_limit to 0' do
-            Arachni::Options.do_not_crawl
-            Arachni::Options.link_count_limit.should == 0
-        end
-    end
 
-    describe '#crawl' do
-        it 'sets the link_count_limit to < 0' do
-            Arachni::Options.crawl
-            Arachni::Options.crawl?.should be_true
-            !Arachni::Options.link_count_limit.should be_nil
-        end
-    end
-
-    describe '#crawl?' do
-        context 'by default' do
-            it 'returns true' do
-                Arachni::Options.crawl?.should be_true
-            end
-        end
-        context 'when crawling is enabled' do
-            it 'returns true' do
-                Arachni::Options.do_not_crawl
-                Arachni::Options.crawl?.should be_false
-                Arachni::Options.crawl
-                Arachni::Options.crawl?.should be_true
-            end
-        end
-        context 'when crawling is disabled' do
+        context 'when fingerprinting is disabled' do
             it 'returns false' do
-                Arachni::Options.crawl?.should be_true
-                Arachni::Options.do_not_crawl
-                Arachni::Options.crawl?.should be_false
+                subject.no_fingerprinting = true
+                subject.fingerprint?.should be_false
             end
         end
     end
 
-    describe '#link_count_limit_reached?' do
-        context 'when the link count limit has' do
-
-            context 'not been set' do
-                it 'returns false' do
-                    Arachni::Options.link_count_limit_reached?( 44 ).should be_false
-                end
-            end
-
-            context 'not been reached' do
-                it 'returns false' do
-                    Arachni::Options.link_count_limit = 5
-                    Arachni::Options.link_count_limit_reached?( 2 ).should be_false
-                end
+    describe '#validate' do
+        context 'when valid' do
+            it 'returns nil' do
+                subject.validate.should be_empty
             end
+        end
 
-            context 'been reached' do
-                it 'returns true' do
-                    Arachni::Options.link_count_limit = 5
-                    Arachni::Options.link_count_limit_reached?( 5 ).should be_true
-                    Arachni::Options.link_count_limit_reached?( 6 ).should be_true
-                end
+        context 'when invalid' do
+            it 'returns errors by group' do
+                subject.session.check_pattern = /test/
+                subject.validate.should == {
+                    session: {
+                        check_url: "Option is missing."
+                    }
+                }
             end
         end
-
     end
 
-    describe '#audit' do
-        it 'enables auditing of the given element types' do
-            Arachni::Options.audit_links.should be_false
-            Arachni::Options.audit_forms.should be_false
-            Arachni::Options.audit_cookies.should be_false
-            Arachni::Options.audit_headers.should be_false
-
-            Arachni::Options.audit :links, :forms, :cookies, :headers
-
-            Arachni::Options.audit_links.should be_true
-            Arachni::Options.audit_forms.should be_true
-            Arachni::Options.audit_cookies.should be_true
-            Arachni::Options.audit_headers.should be_true
+    describe '#url=' do
+        it 'normalizes its argument' do
+            subject.url = 'http://test.com/my path'
+            subject.url.should == @utils.normalize_url( subject.url )
         end
-    end
 
-    describe '#audit=' do
-        it 'enables auditing of the given element types' do
-            Arachni::Options.audit_links.should be_false
-            Arachni::Options.audit_forms.should be_false
-            Arachni::Options.audit_cookies.should be_false
-            Arachni::Options.audit_headers.should be_false
-
-            Arachni::Options.audit = :links, :forms, :cookies, :headers
-
-            Arachni::Options.audit_links.should be_true
-            Arachni::Options.audit_forms.should be_true
-            Arachni::Options.audit_cookies.should be_true
-            Arachni::Options.audit_headers.should be_true
+        it 'accepts the HTTP scheme' do
+            subject.url = 'http://test.com'
+            subject.url.should == 'http://test.com/'
         end
-    end
-
-    describe '#dont_audit' do
-        it 'enables auditing of the given element types' do
-            Arachni::Options.audit :links, :forms, :cookies, :headers
-
-            Arachni::Options.audit_links.should be_true
-            Arachni::Options.audit_forms.should be_true
-            Arachni::Options.audit_cookies.should be_true
-            Arachni::Options.audit_headers.should be_true
 
-            Arachni::Options.dont_audit :links, :forms, :cookies, :headers
-
-            Arachni::Options.audit_links.should be_false
-            Arachni::Options.audit_forms.should be_false
-            Arachni::Options.audit_cookies.should be_false
-            Arachni::Options.audit_headers.should be_false
+        it 'accepts the HTTPS scheme' do
+            subject.url = 'https://test.com'
+            subject.url.should == 'https://test.com/'
         end
-    end
 
-    describe '#audit?' do
-        it 'returns a boolean value if he given element is to be audited' do
-            Arachni::Options.audit_links.should be_false
-            Arachni::Options.audit?( :links ).should be_false
-            Arachni::Options.audit?( :link ).should be_false
-            Arachni::Options.audit?( 'links' ).should be_false
-            Arachni::Options.audit?( 'link' ).should be_false
-
-            Arachni::Options.audit_forms.should be_false
-            Arachni::Options.audit?( :forms ).should be_false
-            Arachni::Options.audit?( :form ).should be_false
-            Arachni::Options.audit?( 'forms' ).should be_false
-            Arachni::Options.audit?( 'form' ).should be_false
-
-            Arachni::Options.audit_cookies.should be_false
-            Arachni::Options.audit?( :cookies ).should be_false
-            Arachni::Options.audit?( :cookie ).should be_false
-            Arachni::Options.audit?( 'cookies' ).should be_false
-            Arachni::Options.audit?( 'cookie' ).should be_false
-
-            Arachni::Options.audit_headers.should be_false
-            Arachni::Options.audit?( :headers ).should be_false
-            Arachni::Options.audit?( :header ).should be_false
-            Arachni::Options.audit?( 'headers' ).should be_false
-            Arachni::Options.audit?( 'header' ).should be_false
-
-            Arachni::Options.audit?( :header, :link, :form, :cookie ).should be_false
-            Arachni::Options.audit?( [:header, :link, :form, :cookie] ).should be_false
-
-            Arachni::Options.audit :links, :forms, :cookies, :headers
-
-            Arachni::Options.audit_links.should be_true
-            Arachni::Options.audit?( :links ).should be_true
-            Arachni::Options.audit?( :link ).should be_true
-            Arachni::Options.audit?( 'links' ).should be_true
-            Arachni::Options.audit?( 'link' ).should be_true
-
-            Arachni::Options.audit_forms.should be_true
-            Arachni::Options.audit?( :forms ).should be_true
-            Arachni::Options.audit?( :form ).should be_true
-            Arachni::Options.audit?( 'forms' ).should be_true
-            Arachni::Options.audit?( 'form' ).should be_true
-
-            Arachni::Options.audit_cookies.should be_true
-            Arachni::Options.audit?( :cookies ).should be_true
-            Arachni::Options.audit?( :cookie ).should be_true
-            Arachni::Options.audit?( 'cookies' ).should be_true
-            Arachni::Options.audit?( 'cookie' ).should be_true
-
-            Arachni::Options.audit_headers.should be_true
-            Arachni::Options.audit?( :headers ).should be_true
-            Arachni::Options.audit?( :header ).should be_true
-            Arachni::Options.audit?( 'headers' ).should be_true
-            Arachni::Options.audit?( 'header' ).should be_true
-
-            Arachni::Options.audit?( :header, :link, :form, :cookie ).should be_true
-            Arachni::Options.audit?( [:header, :link, :form, :cookie] ).should be_true
+        context 'when passed reserved host' do
+            %w(localhost 127.0.0.1).each do |hostname|
+                context hostname do
+                    it "raises #{described_class::Error::ReservedHostname}" do
+                        expect { subject.url = "http://#{hostname}" }.to raise_error
+                            described_class::Error::ReservedHostname
+                    end
+                end
+            end
         end
-    end
-
 
-    describe '#url' do
-        it 'normalizes its param and set it as the target URL' do
-            @opts.url = 'http://test.com/my path'
-            @opts.url.should == @utils.normalize_url( @opts.url )
+        context 'when nil is passed' do
+            it "raises #{described_class::Error::InvalidURL}" do
+                expect { subject.url = '/my path' }.to raise_error
+                    described_class::Error::InvalidURL
+            end
         end
 
         context 'when a relative URL is passed' do
-            it 'throws an exception' do
-                raised = false
-                begin
-                    @opts.url = '/my path'
-                rescue
-                    raised = true
-                end
-                raised.should be_true
+            it "raises #{described_class::Error::InvalidURL}" do
+                expect { subject.url = '/my path' }.to raise_error
+                    described_class::Error::InvalidURL
             end
         end
 
         context 'when a URL with invalid scheme is passed' do
-            it 'throws an exception' do
-                raised = false
-                begin
-                    @opts.url = 'httpss://test.com/my path'
-                rescue
-                    raised = true
-                end
-                raised.should be_true
+            it "raises #{described_class::Error::InvalidURL}" do
+                expect { subject.url = 'httpss://test.com/my path' }.to raise_error
+                    described_class::Error::InvalidURL
             end
         end
-    end
-
-    describe '#set' do
-        context 'when keys are strings' do
-            it 'sets options by hash' do
-                opts = {
-                    'url'       => 'http://blah.com',
-                    'exclude'   => [ 'exclude me' ],
-                    'include'   => [ 'include me' ],
-                    'redundant' => { 'regexp' => 'redundant', 'count' => 3 },
-                    'datastore' => { key: 'val' }
-                }
-                @opts.set( opts )
 
-                @opts.url.to_s.should == @utils.normalize_url( opts['url'] )
-                @opts.exclude.should == [/exclude me/]
-                @opts.include.should == [/include me/]
-                @opts.datastore.should == opts['datastore']
+        context 'when a URL with no scheme is passed' do
+            it "raises #{described_class::Error::InvalidURL}" do
+                expect { subject.url = 'test.com/my path' }.to raise_error
+                    described_class::Error::InvalidURL
             end
         end
 
-        context 'when keys are symbols' do
-            it 'sets options by hash' do
-                opts = {
-                    url:       'http://blah2.com',
-                    exclude:   ['exclude me2'],
-                    include:   ['include me2'],
-                    redundant: { 'regexp' => 'redundant2', 'count' => 4 },
-                    datastore: { key2: 'val2' }
-                }
-                @opts.set( opts )
-
-                @opts.url.to_s.should == @utils.normalize_url( opts[:url] )
-                @opts.exclude.should == [/exclude me2/]
-                @opts.include.should == [/include me2/]
-                @opts.datastore.should == opts[:datastore]
+        context "when #{Arachni::OptionGroups::Scope}#https_only?" do
+            before :each do
+                subject.scope.https_only = true
             end
-        end
-    end
-
-    describe '#exclude_cookies=' do
-        it 'converts its param to an array of strings' do
-            cookies = %w(my_cookie my_other_cookie)
-
-            @opts.exclude_cookies = cookies.first
-            @opts.exclude_cookies.should == [cookies.first]
-
-            @opts.exclude_cookies = cookies
-            @opts.exclude_cookies.should == cookies
-        end
-    end
-
-    describe '#exclude_vectors=' do
-        it 'converts its param to an array of strings' do
-            vectors = %w(my_vector my_other_vector)
-
-            @opts.exclude_vectors = vectors.first
-            @opts.exclude_vectors.should == [vectors.first]
 
-            @opts.exclude_vectors = vectors
-            @opts.exclude_vectors.should == vectors
-        end
-    end
-
-    describe '#mods=' do
-        it 'converts its param to an array of strings' do
-            mods = %w(my_mods my_other_mods)
-
-            @opts.mods = mods.first
-            @opts.mods.should == [mods.first]
-
-            @opts.mods = mods
-            @opts.mods.should == mods
-        end
-
-        it 'aliased to #modules=' do
-            mods = %w(my_mods my_other_mods)
-
-            @opts.mods = mods.first
-            @opts.modules.should == [mods.first]
-
-            @opts.modules = mods
-            @opts.mods.should == mods
-        end
-    end
-
-    describe '#restrict_paths=' do
-        it 'converts its param to an array of strings' do
-            restrict_paths = %w(my_restrict_paths my_other_restrict_paths)
-
-            @opts.restrict_paths = restrict_paths.first
-            @opts.restrict_paths.should == [restrict_paths.first]
-
-            @opts.restrict_paths = restrict_paths
-            @opts.restrict_paths.should == restrict_paths
-        end
-    end
-
-    describe '#extend_paths=' do
-        it 'converts its param to an array of strings' do
-            extend_paths = %w(my_extend_paths my_other_extend_paths)
-
-            @opts.extend_paths = extend_paths.first
-            @opts.extend_paths.should == [extend_paths.first]
-
-            @opts.extend_paths = extend_paths
-            @opts.extend_paths.should == extend_paths
-        end
-    end
-
-    describe '#include=' do
-        it 'converts its param to an array of strings' do
-            include = %w(my_include my_other_include)
-
-            @opts.include = /test/
-            @opts.include.should == [/test/]
-
-            @opts.include = include.first
-            @opts.include.should == [Regexp.new( include.first )]
-
-            @opts.include = include
-            @opts.include.should == include.map { |p| Regexp.new( p ) }
-        end
-    end
-
-    describe '#exclude=' do
-        it 'converts its param to an array of strings' do
-            exclude = %w(my_exclude my_other_exclude)
-
-            @opts.exclude = /test/
-            @opts.exclude.should == [/test/]
-
-            @opts.exclude = exclude.first
-            @opts.exclude.should == [Regexp.new( exclude.first )]
-
-            @opts.exclude = exclude
-            @opts.exclude.should == exclude.map { |p| Regexp.new( p ) }
-        end
-    end
-
-    describe '#exclude_pages=' do
-        it 'converts its param to an array of strings' do
-            exclude_pages = %w(my_ignore my_other_ignore)
-
-            @opts.exclude_pages = /test/
-            @opts.exclude_pages.should == [/test/]
-
-            @opts.exclude_pages = exclude_pages.first
-            @opts.exclude_pages.should == [Regexp.new( exclude_pages.first )]
-
-            @opts.exclude_pages = exclude_pages
-            @opts.exclude_pages.should == exclude_pages.map { |p| Regexp.new( p ) }
-        end
-    end
-
-    describe '#exclude_pages?' do
-        context 'when the string matches one of the #ignore patterns' do
-            it 'returns true' do
-                @opts.exclude_pages = /test/
-                @opts.exclude_page?( 'this is a test test test' ).should be_true
-            end
-        end
-        context 'when the string does not match one of the #ignore patterns' do
-            it 'returns false' do
-                @opts.exclude_pages = /test/
-                @opts.exclude_page?( 'this is a blah blah blah' ).should be_false
+            context 'and an HTTPS url is provided' do
+                it 'accepts the HTTPS scheme' do
+                    subject.url = 'https://test.com'
+                    subject.url.should == 'https://test.com/'
+                end
             end
-        end
-    end
-
-
-    describe '#lsmod=' do
-        it 'converts its param to an array of strings' do
-            lsmod = %w(my_lsmod my_other_lsmod)
-
-            @opts.lsmod = /test/
-            @opts.lsmod.should == [/test/]
 
-            @opts.lsmod = lsmod.first
-            @opts.lsmod.should == [Regexp.new( lsmod.first )]
-
-            @opts.lsmod = lsmod
-            @opts.lsmod.should == lsmod.map { |p| Regexp.new( p ) }
+            context 'and an HTTP url is provided' do
+                it "raises #{described_class::Error::InvalidURL}" do
+                    expect do
+                        subject.url = 'http://test.com/'
+                    end.to raise_error described_class::Error::InvalidURL
+                end
+            end
         end
     end
 
-    describe '#lsrep=' do
-        it 'converts its param to an array of strings' do
-            lsrep = %w(my_lsrep my_other_lsrep)
-
-            @opts.lsrep = /test/
-            @opts.lsrep.should == [/test/]
-
-            @opts.lsrep = lsrep.first
-            @opts.lsrep.should == [Regexp.new( lsrep.first )]
+    describe '#update' do
+        it 'sets options by hash' do
+            opts = { url: 'http://blah2.com' }
 
-            @opts.lsrep = lsrep
-            @opts.lsrep.should == lsrep.map { |p| Regexp.new( p ) }
+            subject.update( opts )
+            subject.url.to_s.should == @utils.normalize_url( opts[:url] )
         end
-    end
-
-    describe '#lsplug=' do
-        it 'converts its param to an array of strings' do
-            lsplug = %w(my_lsplug my_other_lsplug)
-
-            @opts.lsplug = /test/
-            @opts.lsplug.should == [/test/]
-
-            @opts.lsplug = lsplug.first
-            @opts.lsplug.should == [Regexp.new( lsplug.first )]
 
-            @opts.lsplug = lsplug
-            @opts.lsplug.should == lsplug.map { |p| Regexp.new( p ) }
-        end
-    end
-
-    describe '#redundant=' do
-        it 'converts its param to properly typed filters' do
-             redundants = [
-                {
-                    'regexp'    => /calendar\.php/,
-                    'count'     => 5
-                },
-                {
-                    'regexp'    => 'gallery\.php',
-                    'count'     => '3'
+        context 'when key refers to an OptionGroup' do
+            it 'updates that group' do
+                opts = {
+                    scope: {
+                        exclude_path_patterns:   [ 'exclude me2' ],
+                        include_path_patterns:   [ 'include me2' ],
+                        redundant_path_patterns: { 'redundant' => 4 },
+                    },
+                    datastore: {
+                        key2: 'val2'
+                    }
                 }
-            ]
-
-            @opts.redundant = redundants.first
-            @opts.redundant.should == { /calendar\.php/ => 5 }
-
-            new_format = { 'regexp' => 39 }
-            @opts.redundant = new_format
-            @opts.redundant.should == { /regexp/ => 39 }
-
-            @opts.redundant = redundants
-            @opts.redundant.should == {
-                /calendar\.php/ => 5,
-                /gallery\.php/ => 3
-            }
-        end
-    end
 
-    describe '#datastore=' do
-        it 'tries to cast its param to a Hash' do
-            @opts.datastore = [[ :k, 'val' ]]
-            @opts.datastore.should == { k: 'val' }
+                subject.update( opts )
 
-            @opts.datastore = { key: 'value' }
-            @opts.datastore.should == { key: 'value' }
-        end
-    end
-
-    describe '#serialize' do
-        it 'returns an one-line serialized version of self' do
-            s = @opts.serialize
-            s.is_a?( String ).should be_true
-            s.include?( "\n" ).should be_false
-        end
-    end
-
-    describe '#unserialize' do
-        it 'unserializes the return value of #serialize' do
-            s = @opts.serialize
-            @opts.unserialize( s ).should == @opts
+                subject.scope.exclude_path_patterns.should == [/exclude me2/]
+                subject.scope.include_path_patterns.should == [/include me2/]
+                subject.scope.redundant_path_patterns.should == { /redundant/ => 4 }
+                subject.datastore.to_h.should == opts[:datastore]
+            end
         end
     end
 
     describe '#save' do
-        it 'dumps a serialized version of self to a file' do
+        it 'dumps #to_h to a file' do
             f = 'options'
-            @opts.save( f )
+
+            subject.save( f )
 
             raised = false
             begin
@@ -790,15 +217,11 @@ describe Arachni::Options do
             end
             raised.should be_false
         end
-    end
 
-    describe '#load' do
-        it 'loads a serialized version of self' do
+        it 'returns the file location'do
             f = 'options'
-            @opts.save( f )
 
-            @opts.dir = nil
-            @opts.load( f ).should == @opts
+            f = subject.save( f )
 
             raised = false
             begin
@@ -808,14 +231,18 @@ describe Arachni::Options do
             end
             raised.should be_false
         end
+    end
 
-        it 'supports a serialized Hash' do
-            f = 'options'
+    describe '#load' do
+        it 'loads a file created by #save' do
+            f = "#{Dir.tmpdir}/options"
 
-            File.open( f, 'w' ) { |file| YAML.dump( @opts.to_hash, file ) }
+            subject.scope.restrict_paths = 'test'
+            subject.save( f )
 
-            @opts.dir = nil
-            @opts.load( f ).should == @opts
+            options = subject.load( f )
+            options.should == subject
+            options.scope.restrict_paths.should == ['test']
 
             raised = false
             begin
@@ -827,70 +254,89 @@ describe Arachni::Options do
         end
     end
 
-    describe '#to_hash' do
-        it 'converts self to a hash' do
-            h = @opts.to_hash
-            h.is_a?( Hash ).should be_true
+    describe '#to_rpc_data' do
+        let(:data) { subject.to_rpc_data }
+        ignore = [:instance, :rpc, :dispatcher, :paths, :spawns, :snapshot, :output]
 
-            h.each { |k, v| @opts.instance_variable_get( "@#{k}".to_sym ).should == v }
-        end
-    end
+        it 'converts self to a serializable hash' do
+            data.should be_kind_of Hash
 
-    describe '#to_h' do
-        it 'aliased to to_hash' do
-            @opts.to_hash.should == @opts.to_h
+            Arachni::RPC::Serializer.load(
+                Arachni::RPC::Serializer.dump( data )
+            ).should == data
         end
-    end
 
-    describe '#==' do
-        context 'when both objects are equal' do
-            it 'returns true' do
-                @opts.should == @opts
+        (groups - ignore).each do |k|
+            k = k.to_s
+
+            it "includes the '#{k}' group" do
+                data[k].should == subject.send(k).to_rpc_data
             end
         end
-        context 'when objects are not equal' do
-            it 'returns true' do
-                @opts.should_not == @opts.load( @opts.save( 'test_opts' ) )
-                File.delete( 'test_opts' )
+
+        ignore.each do |k|
+            k = k.to_s
+
+            it "does not include the '#{k}' group" do
+                subject.to_rpc_data.should_not include k
             end
         end
     end
 
-    describe '#merge!' do
-        context 'when the param is a' do
-            context Arachni::Options do
-                it 'merges self with the passed object' do
-                    opts = @opts.load( @opts.save( 'test_opts' ) )
-                    File.delete( 'test_opts' )
-
-                    opts.nickname = 'billybob'
-                    @opts.nickname.should be_nil
-                    @opts.merge!( opts )
-                    @opts.nickname.should == 'billybob'
-                end
-            end
-            context Hash do
-                it 'merges self with the passed object' do
-                    @opts.depth_limit = 20
-                    @opts.depth_limit.should == 20
+    describe '#to_hash' do
+        it 'converts self to a hash' do
+            subject.scope.restrict_paths = 'test'
+            subject.checks << 'stuff'
+            subject.datastore.stuff      = 'test2'
+
+            h = subject.to_hash
+            h.should be_kind_of Hash
+
+            h.each do |k, v|
+                next if k == :instance
+                subject_value = subject.send(k)
 
-                    @opts.merge!( { depth_limit: 10 } )
-                    @opts.depth_limit.should == 10
+                case v
+                    when nil
+                        v.should be_nil
+
+                    when Array
+                        subject_value.should == v
+
+                    else
+                        (subject_value.respond_to?( :to_h ) ? subject_value.to_h : v).should == v
                 end
             end
         end
+    end
 
-        it 'skips nils and empty Arrays or Hashes' do
-            @opts.exclude = 'test'
-            @opts.merge!( { 'exclude' => [] } )
-            @opts.exclude.should == [ /test/ ]
+    describe '#to_h' do
+        it 'aliased to to_hash' do
+            subject.to_hash.should == subject.to_h
+        end
+    end
+
+    describe '#rpc_data_to_hash' do
+        it 'normalizes the given hash into #to_hash format' do
+            normalized = subject.rpc_data_to_hash(
+                'http' => {
+                    'request_timeout' => 10_000
+                }
+            )
+
+            normalized[:http][:request_timeout].should == 10_000
+            subject.http.request_timeout.should_not == 10_000
+        end
+    end
 
-            @opts.datastore = { 'test' => :val }
-            @opts.merge!( { 'datastore' => {} } )
-            @opts.datastore.should == { 'test' => :val }
+    describe '#hash_to_rpc_data' do
+        it 'normalizes the given hash into #to_rpc_data format' do
+            normalized = subject.hash_to_rpc_data(
+                http: { request_timeout: 10_000 }
+            )
 
-            @opts.merge!( { 'datastore' => nil } )
-            @opts.datastore.should == { 'test' => :val }
+            normalized['http']['request_timeout'].should == 10_000
+            subject.http.request_timeout.should_not == 10_000
         end
     end