cuboid 0.0.0 → 0.0.1alpha

data/spec/cuboid/rest/server_spec.rb

@@ -0,0 +1,1205 @@
+require 'spec_helper'
+require "#{Cuboid::Options.paths.lib}/rest/server"
+
+describe Cuboid::Rest::Server do
+    include RequestHelpers
+
+    before(:each) do
+        app.reset
+        Cuboid::Options.system.max_slots = 10
+        Cuboid::Options.paths.application = "#{fixtures_path}/mock_app.rb"
+    end
+
+    let(:options) {{}}
+    let(:url) { tpl_url % id }
+    let(:id) { @id }
+    let(:non_existent_id) { 'stuff' }
+
+    let(:dispatcher) { Cuboid::Processes::Dispatchers.spawn }
+    let(:scheduler) { Cuboid::Processes::Schedulers.spawn }
+
+    def create_instance
+        post '/instances', options
+        response_data['id']
+    end
+
+    context 'supports compressing as' do
+        ['gzip'].each do |compression_method|
+
+            it compression_method do
+                get '/', {}, { 'HTTP_ACCEPT_ENCODING' => compression_method }
+                expect( response.headers['Content-Encoding'] ).to eq compression_method.split( ',' ).first
+            end
+
+        end
+    end
+
+    context 'when the client does not support compression' do
+        it 'does not compress the response' do
+            get '/'
+            expect(response.headers['Content-Encoding']).to be_nil
+        end
+    end
+
+    context 'when authentication' do
+        let(:username) { nil }
+        let(:password) { nil }
+        let(:userpwd) { "#{username}:#{password}" }
+        let(:url) { "http://localhost:#{Cuboid::Options.rpc.server_port}/instances" }
+
+        before do
+            Cuboid::Options.datastore['username'] = username
+            Cuboid::Options.datastore['password'] = password
+
+            Cuboid::Options.rpc.server_port = Cuboid::Utilities.available_port
+            Cuboid::Processes::Manager.spawn( :rest_service )
+
+            sleep 0.1 while Typhoeus.get( url ).code == 0
+        end
+
+        after do
+            Cuboid::Processes::Manager.killall
+        end
+
+        context 'username' do
+            let(:username) { 'username' }
+
+            context 'is configured' do
+                it 'requires authentication' do
+                    expect(Typhoeus.get( url ).code).to eq 401
+                    expect(Typhoeus.get( url, userpwd: userpwd ).code).to eq 200
+                end
+            end
+        end
+
+        context 'password' do
+            let(:password) { 'password' }
+
+            context 'is configured' do
+                it 'requires authentication' do
+                    expect(Typhoeus.get( url ).code).to eq 401
+                    expect(Typhoeus.get( url, userpwd: userpwd ).code).to eq 200
+                end
+            end
+        end
+    end
+
+    describe 'SSL options', if: !Cuboid.windows? do
+        let(:ssl_key) { nil }
+        let(:ssl_cert) { nil }
+        let(:ssl_ca) { nil }
+        let(:url) { "http://localhost:#{Cuboid::Options.rpc.server_port}/instances" }
+        let(:https_url) { "https://localhost:#{Cuboid::Options.rpc.server_port}/instances" }
+
+        before do
+            Cuboid::Options.rpc.ssl_ca                 = ssl_ca
+            Cuboid::Options.rpc.server_ssl_private_key = ssl_key
+            Cuboid::Options.rpc.server_ssl_certificate = ssl_cert
+
+            Cuboid::Options.rpc.server_port = Cuboid::Utilities.available_port
+            Cuboid::Processes::Manager.spawn( :rest_service )
+
+            sleep 0.1 while Typhoeus.get( url ).return_code == :couldnt_connect
+        end
+
+        after do
+            Cuboid::Processes::Manager.killall
+        end
+
+        describe 'when key and certificate is given' do
+            let(:ssl_key) { "#{support_path}/pems/server/key.pem" }
+            let(:ssl_cert) { "#{support_path}/pems/server/cert.pem" }
+
+            describe 'when no CA is given' do
+                it 'disables peer verification' do
+                    expect(Typhoeus.get( https_url, ssl_verifypeer: false ).code).to eq 200
+                end
+            end
+
+            describe 'a CA is given' do
+                let(:ssl_ca) { "#{support_path}/pems/cacert.pem" }
+
+                it 'enables peer verification' do
+                    expect(Typhoeus.get( https_url, ssl_verifypeer: false ).code).to eq 0
+
+                    expect(Typhoeus.get(
+                        https_url,
+                        ssl_verifypeer: true,
+                        sslcert:        "#{support_path}/pems/client/cert.pem",
+                        sslkey:         "#{support_path}/pems/client/key.pem",
+                        cainfo:         ssl_ca
+                    ).code).to eq 200
+                end
+            end
+        end
+
+        describe 'when only key is given' do
+            let(:ssl_key) { "#{support_path}/pems/server/key.pem" }
+
+            it 'does not enable SSL' do
+                expect(Typhoeus.get( url ).code).to eq 200
+            end
+        end
+
+        describe 'when only cert is given' do
+            let(:ssl_cert) { "#{support_path}/pems/server/cert.pem" }
+
+            it 'does not enable SSL' do
+                expect(Typhoeus.get( url ).code).to eq 200
+            end
+        end
+    end
+
+    describe 'GET /instances' do
+        let(:tpl_url) { '/instances' }
+
+        it 'lists ids for all instances' do
+            ids = []
+            2.times do
+                ids << create_instance
+            end
+
+            get url
+
+            ids.each do |id|
+                expect(response_data[id]).to eq({})
+            end
+        end
+
+        context 'when there is a Scheduler' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'includes its running instances' do
+                id = scheduler.push( options )
+                sleep 0.1 while scheduler.running.empty?
+
+                get url
+                expect(response_data).to include id
+            end
+
+            context 'when a running instance completes' do
+                it 'is removed' do
+                    scheduler.push( options )
+                    sleep 0.1 while scheduler.completed.empty?
+
+                    get url
+                    expect(response_data).to be_empty
+                end
+            end
+        end
+    end
+
+    describe 'POST /instances' do
+        let(:tpl_url) { '/instances' }
+
+        it 'creates an instance' do
+            post url, options
+            expect(response_code).to eq 200
+        end
+
+        context 'when given invalid options' do
+            it 'returns a 500' do
+                post url, invalid: 'blah'
+
+                expect(response_code).to eq 500
+                expect(response_data['error']).to eq 'Arachni::RPC::Exceptions::RemoteException'
+                expect(response_data).to include 'backtrace'
+            end
+
+            it 'does not list the instance on the index' do
+                get '/instances'
+                ids = response_data.keys
+
+                post url, invalid: 'blah'
+
+                get '/instances'
+                expect(response_data.keys - ids).to be_empty
+            end
+        end
+
+        context 'when the system is at max utilization' do
+            it 'returns a 503' do
+                Cuboid::Options.system.max_slots = 1
+
+                post url, options
+                expect(response_code).to eq 200
+
+                sleep 1
+
+                post url, options
+                expect(response_code).to eq 503
+                expect(response_data['error']).to eq 'Service unavailable: System is at maximum ' +
+                                                         'utilization, slot limit reached.'
+            end
+        end
+
+        context 'when a Dispatcher has been set' do
+
+            it 'uses it' do
+                put '/dispatcher/url', dispatcher.url
+
+                get "/grid/#{dispatcher.url}"
+                expect(response_data['running_instances']).to be_empty
+
+                create_instance
+
+                get "/grid/#{dispatcher.url}"
+                expect(response_data['running_instances'].size).to eq 1
+            end
+        end
+    end
+
+    describe 'GET /instances/:instance' do
+        let(:tpl_url) { '/instances/%s' }
+
+        before do
+            @id = create_instance
+        end
+
+        it 'gets progress info' do
+            loop do
+                get url
+                break if !response_data['busy']
+                sleep 0.5
+            end
+
+            %w(errors status busy messages statistics).each do |key|
+                expect(response_data).to include key
+            end
+
+            %w(statistics).each do |key|
+                expect(response_data.any?).to be_truthy
+            end
+        end
+
+        context 'when a session is maintained' do
+            it 'only returns new errors'
+        end
+
+        context 'when a session is not maintained' do
+            it 'always returns all errors'
+        end
+
+        context 'when passed a non-existent id' do
+            let(:id) { non_existent_id }
+
+            it 'returns 404' do
+                get url
+                expect(response_code).to eq 404
+            end
+        end
+
+        context 'when the instance is from the Scheduler' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'includes it' do
+                @id = scheduler.push( options )
+                sleep 0.1 while scheduler.running.empty?
+
+                get url
+                expect(response_data).to include 'busy'
+            end
+
+            context 'when the instance completes' do
+                it 'is removed' do
+                    @id = scheduler.push( options )
+                    sleep 0.1 while scheduler.completed.empty?
+
+                    get url
+                    expect(response_code).to be 404
+                end
+            end
+        end
+    end
+
+    describe 'PUT /instances/:instance/scheduler' do
+        let(:tpl_url) { '/instances/%s/scheduler' }
+
+        before do
+            @id = create_instance
+        end
+
+        context 'when there is a Scheduler' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'moves the instance to the Scheduler' do
+                expect(scheduler.running).to be_empty
+
+                put url
+                expect(response_code).to be 200
+                expect(scheduler.running).to include @id
+            end
+
+            context 'but the instance could not be found' do
+                it 'returns 404' do
+                    @id = 'ss'
+
+                    put url
+                    expect(response_code).to be 404
+                end
+            end
+        end
+
+        context 'when there is no Scheduler' do
+            it 'returns 501' do
+                put url
+                expect(response_code).to be 501
+            end
+        end
+    end
+
+    describe 'GET /instances/:instance/summary' do
+        let(:tpl_url) { '/instances/%s/summary' }
+
+        before do
+            @id = create_instance
+        end
+
+        context 'when passed a non-existent id' do
+            let(:id) { non_existent_id }
+
+            it 'returns 404' do
+                get url
+                expect(response_code).to eq 404
+            end
+        end
+
+        context 'when the instance is from the Scheduler' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'includes it' do
+                @id = scheduler.push( options )
+                sleep 0.1 while scheduler.running.empty?
+
+                get url
+                expect(response_data).to include 'busy'
+            end
+
+            context 'when the instance completes' do
+                it 'is removed' do
+                    @id = scheduler.push( options )
+                    sleep 0.1 while scheduler.completed.empty?
+
+                    get url
+                    expect(response_code).to be 404
+                end
+            end
+        end
+    end
+
+    describe 'GET /instances/:instance/report.crf' do
+        let(:tpl_url) { "/instances/%s/report.crf" }
+
+        before do
+            @id = create_instance
+        end
+
+        it 'returns instance report' do
+            get url
+
+            file = Tempfile.new( "#{Dir.tmpdir}/report-#{Process.pid}.crf" )
+            file.write last_response.body
+            file.close
+
+            expect(Cuboid::Report.load( file.path ).data).to eq 'My results.'
+        end
+
+        it 'has content-type application/octet-stream' do
+            get url
+            expect(last_response.headers['content-type']).to eq 'application/octet-stream'
+        end
+
+        context 'when passed a non-existent id' do
+            let(:id) { non_existent_id }
+
+            it 'returns 404' do
+                get url
+                expect(response_code).to eq 404
+            end
+        end
+    end
+
+    describe 'GET /instances/:instance/report.json' do
+        let(:tpl_url) { "/instances/%s/report.json" }
+
+        before do
+            @id = create_instance
+        end
+
+        it 'returns instance report' do
+            get url
+
+            report = JSON.load( last_response.body )
+            expect(MockApp.serializer.load report['data']).to eq 'My results.'
+        end
+
+        it 'has content-type application/json' do
+            get url
+            expect(last_response.headers['content-type']).to eq 'application/json'
+        end
+
+        context 'when passed a non-existent id' do
+            let(:id) { non_existent_id }
+
+            it 'returns 404' do
+                get url
+                expect(response_code).to eq 404
+            end
+        end
+    end
+
+    describe 'PUT /instances/:instance/pause' do
+        let(:tpl_url) { '/instances/%s/pause' }
+
+        before do
+            @id = create_instance
+        end
+
+        it 'pauses the instance' do
+            put url
+            expect(response_code).to eq 200
+
+            get "/instances/#{id}"
+            expect(['pausing', 'paused']).to include response_data['status']
+        end
+
+        context 'when passed a non-existent id' do
+            let(:id) { non_existent_id }
+
+            it 'returns 404' do
+                put url
+                expect(response_code).to eq 404
+            end
+        end
+
+        context 'when the instance is from the Scheduler' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'includes it' do
+                @id = scheduler.push( options )
+                sleep 0.1 while scheduler.running.empty?
+
+                put url
+                expect(response_code).to eq 200
+
+                get "/instances/#{id}"
+                expect(['pausing', 'paused']).to include response_data['status']
+            end
+
+            context 'when the instance completes' do
+                it 'is removed' do
+                    @id = scheduler.push( options )
+                    sleep 0.1 while scheduler.completed.empty?
+
+                    put url
+                    expect(response_code).to be 404
+                end
+            end
+        end
+    end
+
+    describe 'PUT /instances/:instance/resume' do
+        let(:tpl_url) { '/instances/%s/resume' }
+
+        before do
+            @id = create_instance
+        end
+
+        it 'resumes the instance' do
+            put "/instances/#{id}/pause"
+            get "/instances/#{id}"
+
+            expect(['pausing', 'paused']).to include response_data['status']
+
+            put url
+            get "/instances/#{id}"
+
+            expect(['pausing', 'paused']).to_not include response_data['status']
+        end
+
+        context 'when passed a non-existent id' do
+            let(:id) { non_existent_id }
+
+            it 'returns 404' do
+                put url
+                expect(response_code).to eq 404
+            end
+        end
+
+        context 'when the instance is from the Scheduler' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'includes it' do
+                @id = scheduler.push( options )
+                sleep 0.1 while scheduler.running.empty?
+
+                put "/instances/#{id}/pause"
+                get "/instances/#{id}"
+
+                expect(['pausing', 'paused']).to include response_data['status']
+
+                put url
+                get "/instances/#{id}"
+
+                expect(['running', 'done']).to include response_data['status']
+            end
+
+            context 'when the instance completes' do
+                it 'is removed' do
+                    @id = scheduler.push( options )
+                    sleep 0.1 while scheduler.completed.empty?
+
+                    put url
+                    expect(response_code).to be 404
+                end
+            end
+        end
+    end
+    
+    describe 'DELETE /instances/:instance' do
+        let(:tpl_url) { '/instances/%s' }
+
+        before do
+            @id = create_instance
+        end
+
+        it 'aborts the instance' do
+            get url
+            expect(response_code).to eq 200
+
+            delete url
+
+            get "/instances/#{id}"
+            expect(response_code).to eq 404
+        end
+
+        context 'when passed a non-existent id' do
+            let(:id) { non_existent_id }
+
+            it 'returns 404' do
+                delete url
+                expect(response_code).to eq 404
+            end
+        end
+
+        context 'when the instance is from the Scheduler' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'includes it' do
+                @id = scheduler.push( options )
+                sleep 0.1 while scheduler.running.empty?
+
+                delete url
+                expect(response_code).to eq 200
+
+                sleep 0.1 while scheduler.failed.empty?
+
+                expect(scheduler.failed).to include @id
+            end
+
+            context 'when the instance completes' do
+                it 'is removed' do
+                    @id = scheduler.push( options )
+                    sleep 0.1 while scheduler.completed.empty?
+
+                    delete url
+                    expect(response_code).to be 404
+                end
+            end
+        end
+    end
+
+    describe 'GET /dispatcher/url' do
+        let(:tpl_url) { '/dispatcher/url' }
+
+        it 'returns the Dispatcher' do
+            put url, dispatcher.url
+            expect(response_code).to eq 200
+
+            get url
+            expect(response_code).to eq 200
+            expect(response_data).to eq dispatcher.url
+        end
+
+        context 'when no Dispatcher has been set' do
+            it 'returns 501' do
+                get url
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Dispatcher has been set.'
+            end
+        end
+    end
+
+    describe 'PUT /dispatcher/url' do
+        let(:tpl_url) { '/dispatcher/url' }
+
+        it 'sets the Dispatcher' do
+            put url, dispatcher.url
+            expect(response_code).to eq 200
+        end
+
+        context 'when passed a non-existent URL' do
+            let(:id) { non_existent_id }
+
+            it 'returns 500' do
+                put url, 'localhost:383838'
+                expect(response_code).to eq 500
+                expect(response_data['error']).to eq 'Arachni::RPC::Exceptions::ConnectionError'
+            end
+        end
+    end
+
+    describe 'DELETE /dispatcher/url' do
+        let(:tpl_url) { '/dispatcher/url' }
+
+        it 'removes the the Dispatcher' do
+            put url, dispatcher.url
+            expect(response_code).to eq 200
+
+            delete url
+            expect(response_code).to eq 200
+
+            get url, dispatcher.url
+            expect(response_code).to eq 501
+        end
+
+        context 'when no Dispatcher has been set' do
+            it 'returns 501' do
+                delete url
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Dispatcher has been set.'
+            end
+        end
+    end
+
+    describe 'GET /grid' do
+        let(:dispatcher) { Cuboid::Processes::Dispatchers.grid_spawn }
+        let(:tpl_url) { '/grid' }
+
+        it 'returns Grid info' do
+            put '/dispatcher/url', dispatcher.url
+            expect(response_code).to eq 200
+
+            get url
+            expect(response_code).to eq 200
+            expect(response_data.sort).to eq ([dispatcher.url] + dispatcher.node.neighbours).sort
+        end
+
+        context 'when no Dispatcher has been set' do
+            it 'returns 501' do
+                get url
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Dispatcher has been set.'
+            end
+        end
+    end
+
+    describe 'GET /grid/:dispatcher' do
+        let(:dispatcher) { Cuboid::Processes::Dispatchers.grid_spawn }
+        let(:tpl_url) { '/grid/%s' }
+
+        it 'returns Dispatcher info' do
+            put '/dispatcher/url', dispatcher.url
+            expect(response_code).to eq 200
+
+            @id = dispatcher.url
+
+            get url
+            expect(response_code).to eq 200
+            expect(response_data).to eq dispatcher.statistics
+        end
+
+        context 'when no Dispatcher has been set' do
+            it 'returns 501' do
+                @id = 'localhost:2222'
+
+                get url
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Dispatcher has been set.'
+            end
+        end
+    end
+
+    describe 'DELETE /grid/:dispatcher' do
+        let(:dispatcher) { Cuboid::Processes::Dispatchers.grid_spawn }
+        let(:tpl_url) { '/grid/%s' }
+
+        it 'unplugs the Dispatcher from the Grid' do
+            put '/dispatcher/url', dispatcher.url
+            expect(response_code).to eq 200
+
+            @id = dispatcher.url
+
+            expect(dispatcher.node.grid_member?).to be_truthy
+
+            delete url
+            expect(response_code).to eq 200
+            expect(dispatcher.node.grid_member?).to be_falsey
+        end
+
+        context 'when no Dispatcher has been set' do
+            it 'returns 501' do
+                @id = 'localhost:2222'
+
+                delete url
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Dispatcher has been set.'
+            end
+        end
+    end
+
+    describe 'GET /scheduler' do
+        let(:tpl_url) { '/scheduler' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'lists schedulerd instances grouped by priority' do
+                low    = scheduler.push( options, priority: -1 )
+                high   = scheduler.push( options, priority: 1 )
+                medium = scheduler.push( options, priority: 0 )
+
+                get url
+                expect(response_code).to eq 200
+                expect(response_data.to_a).to eq({
+                    '1'  => [high],
+                    '0'  => [medium],
+                    '-1' => [low]
+                }.to_a)
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            it 'returns 501' do
+                get url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'POST /scheduler' do
+        let(:tpl_url) { '/scheduler' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'pushes the instance to the Scheduler' do
+                post url, [options, priority: 9]
+
+                expect(response_code).to eq 200
+
+                id = response_data['id']
+
+                expect(scheduler.get(id)).to eq(
+                    'options' => options,
+                    'priority' => 9
+                )
+            end
+
+            context 'when given invalid options' do
+                it 'returns a 500' do
+                    post url, invalid: 'blah'
+
+                    expect(response_code).to eq 500
+                    expect(response_data['error']).to eq 'Arachni::RPC::Exceptions::RemoteException'
+                    expect(response_data).to include 'backtrace'
+                end
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            it 'returns 501' do
+                get url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'GET /scheduler/url' do
+        let(:tpl_url) { '/scheduler/url' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'returns its URL' do
+                get url
+                expect(response_code).to eq 200
+                expect(response_data).to eq scheduler.url
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            it 'returns 501' do
+                get url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'PUT /scheduler/url' do
+        let(:tpl_url) { '/scheduler/url' }
+
+
+        it 'sets the Scheduler URL' do
+            put url, scheduler.url
+            expect(response_code).to eq 200
+        end
+
+        context 'when given an invalid URL' do
+            it 'returns 500' do
+                put url, 'localhost:393939'
+
+                expect(response_code).to eq 500
+                expect(response_data['error']).to eq 'Arachni::RPC::Exceptions::ConnectionError'
+                expect(response_data['description']).to include 'Connection closed'
+            end
+        end
+    end
+
+    describe 'DELETE /scheduler/url' do
+        let(:tpl_url) { '/scheduler/url' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'removes it' do
+                delete url
+                expect(response_code).to eq 200
+
+                get '/scheduler/url'
+                expect(response_code).to eq 501
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            it 'returns 501' do
+                get url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'GET /scheduler/running' do
+        let(:tpl_url) { '/scheduler/running' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'returns running instances' do
+                get url
+                expect(response_data.empty?).to be_truthy
+
+                @id = scheduler.push( options )
+                sleep 0.1 while scheduler.running.empty?
+
+                get url
+                expect(response_data.size).to be 1
+                expect(response_data[@id]).to include 'url'
+                expect(response_data[@id]).to include 'token'
+                expect(response_data[@id]).to include 'pid'
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            it 'returns 501' do
+                get url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'GET /scheduler/completed' do
+        let(:tpl_url) { '/scheduler/completed' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'returns completed instances' do
+                get url
+                expect(response_data.empty?).to be_truthy
+
+                @id = scheduler.push( options )
+                sleep 0.1 while scheduler.completed.empty?
+
+                get url
+                expect(response_data.size).to be 1
+                expect(File.exists? response_data[@id]).to be true
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            it 'returns 501' do
+                get url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'GET /scheduler/failed' do
+        let(:tpl_url) { '/scheduler/failed' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'returns failed instances' do
+                get url
+                expect(response_data.empty?).to be_truthy
+
+                @id = scheduler.push( options )
+                sleep 0.1 while scheduler.running.empty?
+                Cuboid::Processes::Manager.kill scheduler.running.values.first['pid']
+                sleep 0.1 while scheduler.failed.empty?
+
+                get url
+                expect(response_data.size).to be 1
+                expect(response_data[@id]['error']).to eq 'Arachni::RPC::Exceptions::ConnectionError'
+                expect(response_data[@id]['description']).to include 'Connection closed [Connection refused - connect(2) for'
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            it 'returns 501' do
+                get url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'GET /scheduler/size' do
+        let(:tpl_url) { '/scheduler/size' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'returns the scheduler size' do
+                get url
+                expect(response_data).to eq 0
+
+                10.times do
+                    scheduler.push( options )
+                end
+
+                get url
+                expect(response_data).to be 10
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            it 'returns 501' do
+                get url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'DELETE /scheduler' do
+        let(:tpl_url) { '/scheduler' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'empties the scheduler' do
+                expect(scheduler.empty?).to be_truthy
+
+                10.times do
+                    scheduler.push( options )
+                end
+
+                expect(scheduler.any?).to be_truthy
+
+                delete url
+                expect(scheduler.empty?).to be_truthy
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            it 'returns 501' do
+                get url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'GET /scheduler/:instance' do
+        let(:tpl_url) { '/scheduler/%s' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'returns info for the Queued instance' do
+                @id = scheduler.push( options )
+
+                get url
+                expect(response_code).to be 200
+                expect(response_data).to eq({
+                    'options' => options,
+                    'priority' => 0
+                })
+            end
+
+            context 'when the instance could not be found' do
+                let(:id) { non_existent_id }
+
+                it 'returns 404' do
+                    get url
+
+                    expect(response_code).to eq 404
+                    expect(response_data).to eq 'Instance not in Scheduler.'
+                end
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            let(:id) { non_existent_id }
+
+            it 'returns 501' do
+                get url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'PUT /scheduler/:instance/detach' do
+        let(:tpl_url) { '/scheduler/%s/detach' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'detaches the instance from the Scheduler' do
+                @id = scheduler.push( options )
+                sleep 0.1 while scheduler.running.empty?
+
+                put url
+                expect(response_code).to be 200
+                expect(scheduler.running).to be_empty
+                expect(scheduler.completed).to be_empty
+                expect(scheduler.failed).to be_empty
+
+                get '/instances'
+                expect(response_code).to be 200
+                expect(response_data.keys).to eq [@id]
+            end
+
+            context 'when the instance could not be found' do
+                let(:id) { non_existent_id }
+
+                it 'returns 404' do
+                    put url
+
+                    expect(response_code).to eq 404
+                    expect(response_data).to eq 'Instance not in Scheduler.'
+                end
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            let(:id) { non_existent_id }
+
+            it 'returns 501' do
+                put url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+
+    describe 'DELETE /scheduler/:instance' do
+        let(:tpl_url) { '/scheduler/%s' }
+
+        context 'when a Scheduler has been set' do
+            before do
+                put '/scheduler/url', scheduler.url
+            end
+
+            it 'removes the instance from the Scheduler' do
+                @id = scheduler.push( options )
+
+                expect(scheduler.any?).to be_truthy
+
+                delete url
+
+                expect(response_code).to be 200
+                expect(scheduler.empty?).to be_truthy
+            end
+
+            context 'when the instance could not be found' do
+                let(:id) { non_existent_id }
+
+                it 'returns 404' do
+                    delete url
+
+                    expect(response_code).to eq 404
+                    expect(response_data).to eq 'Instance not in Scheduler.'
+                end
+            end
+        end
+
+        context 'when no Scheduler has been set' do
+            let(:id) { non_existent_id }
+
+            it 'returns 501' do
+                delete url
+
+                expect(response_code).to eq 501
+                expect(response_data).to eq 'No Scheduler has been set.'
+            end
+        end
+    end
+end