RubyGems - clavem - Versions diffs - 1.4.0 → 2.0.0 - Mend

clavem 1.4.0 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

checksums.yaml +7 -0
data/.travis-gemfile +2 -1
data/.travis.yml +1 -2
data/Gemfile +3 -2
data/README.md +13 -6
data/Rakefile +1 -1
data/bin/clavem +29 -18
data/clavem.gemspec +5 -4
data/doc/Clavem.html +6 -6
data/doc/Clavem/Authorizer.html +1141 -2216
data/doc/Clavem/Exceptions.html +4 -4
data/doc/Clavem/Exceptions/Failure.html +5 -5
data/doc/Clavem/Server.html +370 -0
data/doc/Clavem/Version.html +5 -5
data/doc/_index.html +8 -15
data/doc/class_list.html +1 -1
data/doc/file.README.html +21 -14
data/doc/frames.html +1 -1
data/doc/index.html +21 -14
data/doc/method_list.html +32 -14
data/doc/top-level-namespace.html +3 -3
data/lib/clavem.rb +4 -3
data/lib/clavem/authorizer.rb +75 -121
data/lib/clavem/server.rb +52 -0
data/lib/clavem/version.rb +3 -3
data/locales/en.yml +15 -6
data/locales/it.yml +15 -6
data/spec/clavem/authorizer_spec.rb +86 -244
data/spec/clavem/server_spec.rb +40 -0
data/spec/coverage_helper.rb +2 -2
data/spec/spec_helper.rb +2 -1
data/test_server.rb +28 -10
metadata +32 -27
data/doc/Clavem/Exceptions/AuthorizationDenied.html +0 -133
data/doc/Clavem/Exceptions/Timeout.html +0 -133
data/doc/index.html.save +0 -133
data/lib/clavem/template.html.erb +0 -25

data/lib/clavem/server.rb ADDED

@@ -0,0 +1,52 @@
+# encoding: utf-8
+#
+# This file is part of the clavem gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+module Clavem
+  # A class to handle oAuth callbacks on the browser via HTTP.
+  class Server < EM::Connection
+    include EM::HttpServer
+    # The template to send to the browser.
+    TEMPLATE = <<-EOTEMPLATE
+<html>
+  <head>
+    <title>Clavem</title>
+    <script type="text/javascript"> close_window = (function(){ window.open("", "_self", ""); window.close(); })(); </script>
+  </head>
+  <body><h4>%s</h4></body>
+</html>
+    EOTEMPLATE
+    # Creates a new server.
+    #
+    # @param authorizer [Authorizer] The authorizer of this server.
+    def initialize(authorizer)
+      @authorizer = authorizer
+    end
+    # Save the token and sends a response back to the user.
+    def process_http_request
+      # Handle the token
+      token = @authorizer.response_handler.call(CGI::parse(@http_query_string))
+      if token then
+        @authorizer.token = token
+        @authorizer.status = :succeeded
+      else
+        @authorizer.status = :denied
+      end
+      # Build the request
+      response = EM::DelegatedHttpResponse.new(self)
+      response.status = 200
+      response.content_type("text/html")
+      response.content = TEMPLATE % [@authorizer.i18n.template]
+      response.send_response
+      # Stop after serving the request.
+      EM.add_timer(0.1) { EM.stop }
+    end
+  end
+end

data/lib/clavem/version.rb CHANGED

@@ -1,6 +1,6 @@
 # encoding: utf-8
 #
-# This file is part of the clavem gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# This file is part of the clavem gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
 #
@@ -10,10 +10,10 @@ module Clavem
   # @see http://semver.org
   module Version
     # The major version.
-    MAJOR = 1
+    MAJOR = 2
     # The minor version.
-    MINOR = 4
+    MINOR = 0
     # The patch version.
     PATCH = 0

data/locales/en.yml CHANGED

@@ -1,16 +1,25 @@
 # encoding: utf-8
 #
-# This file is part of the clavem gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# This file is part of the clavem gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
 #
 ---
   clavem:
-    default_title: "Clavem Authorization"
     errors:
       response_failure: "Cannot handle response: %1"
       open_failure: "Cannot open URL %1: %2"
-    template:
-      header_success: "Authentication succeeded!"
-      header_failure: "Authentication failed!"
-      close_message: "This window should close immediately. Alternatively you can close it by <a href=\"javascript:close_window();\">clicking here</a>."
+    template: "This window will close in few moments. If this doesn't happens you can close it by yourself, this won't cause any problem."
+    application_description: "A local callback server for oAuth web-flow."
+    application_help_url: "The URL where to send the user to start authorization."
+    application_help_host: "The host address on which listening for the reply. Default is localhost."
+    application_help_port: "The port on which listening for the reply. Default is 777`."
+    application_help_command: "The command to open the URL. {{URL} is replaced with the specified URL. Default is 'open \"{{URL}}\"'."
+    application_help_timeout: "The amount of seconds to wait for response from the remote endpoint before returning a failure."
+    application_help_quiet: "Do not print anything but errors."
+    application_meta_port: "PORT"
+    application_meta_command: "COMMAND"
+    cli_running: "Clavem is waiting for a response at URL {mark=bright}%1{/mark} ..."
+    cli_obtaining: "Obtaining token from URL {mark=bright}%1{/mark}."
+    cli_succeeded: "Obtained access token is: {mark=bright}%1{/mark}"
+    cli_failed: "No access token obtained."

data/locales/it.yml CHANGED

@@ -1,16 +1,25 @@
 # encoding: utf-8
 #
-# This file is part of the clavem gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# This file is part of the clavem gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
 #
 ---
   clavem:
-    default_title: Autorizzazione Clavem
     errors:
       response_failure: "Impossibile gestire una risposta: %1"
       open_failure: "Impossible aprire l'URL %1: %2"
-    template:
-      header_success: "Autenticazione riuscita!"
-      header_failure: "Autenticazione fallita!"
-      close_message: "Questa finestra dovrebbe chiudersi immediatamente. Alternativamente puoi chiuderla <a href=\"javascript:close_window();\">cliccando qui</a>."
+    template: "Questa finestra si chiuderà in pochi momenti. Se non succede puoi chiuderla da solo, ciò non causerà alcun problema."
+    application_description: "Un server callback locale per il web-flow oAuth."
+    application_help_url: "L'URL dove mandare l'utente per iniziare l'autenticazione."
+    application_help_host: "L'indirizzo host dove rimanere in ascolto per la risposta. Il default è localhost."
+    application_help_port: "La porta dove rimanere in ascolto per la risposta. La porta di default è 7772."
+    application_help_command: "Il comando per aprire l'URL. {{URL}} è sostituito con l'URL specificato. Il default è 'open \"{{URL}}\"'."
+    application_help_timeout: "Il numero di secondi da attendere per la risposta dall'endpoint remoto prima di ritornare un fallimento."
+    application_help_quiet: "Non mostrare nulla tranne che gli errori."
+    application_meta_port: "PORTA"
+    application_meta_command: "COMANDO"
+    cli_running: "Clavem è in attesa di una risposta all'URL {mark=bright}%1{/mark} ..."
+    cli_obtaining: "Ottengo il token dall'URL {mark=bright}%1{/mark}."
+    cli_succeeded: "Il token di accesso ottenuto è: {mark=bright}%1{/mark}"
+    cli_failed: "Nessun token di accesso ottenuto."

data/spec/clavem/authorizer_spec.rb CHANGED

@@ -1,47 +1,18 @@
 # encoding: utf-8
 #
-# This file is part of the clavem gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# This file is part of the clavem gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
 #
 require "spec_helper"
 describe Clavem::Authorizer do
-  class ClavemDummyServer
-    attr_accessor :started
-    def start
-      self.started = true
-    end
-    def shutdown
-      self.started = false
-    end
-    def mount_proc(path, &handler)
-    end
-  end
-  class ClavemDummyRequest
-    attr_reader :query
-    def initialize(token = nil)
-      @query = {"oauth_token" => token}
-    end
-  end
-  class ClavemDummyResponse
-    attr_accessor :status
-    attr_accessor :body
-  end
-  let(:instance){::Clavem::Authorizer.new}
+  let(:subject){::Clavem::Authorizer.new}
   describe ".instance" do
     it "should call .new with the passed arguments" do
-      expect(::Clavem::Authorizer).to receive(:new).with("HOST", "PORT", "COMMAND", "TITLE", "TEMPLATE", "TIMEOUT")
-      ::Clavem::Authorizer.instance("HOST", "PORT", "COMMAND", "TITLE", "TEMPLATE", "TIMEOUT")
+      expect(::Clavem::Authorizer).to receive(:new).with("HOST", "PORT", "COMMAND", "TIMEOUT")
+      ::Clavem::Authorizer.instance("HOST", "PORT", "COMMAND", "TIMEOUT")
     end
     it "should return the same instance" do
@@ -53,7 +24,7 @@ describe Clavem::Authorizer do
     it "should return a new instance if requested to" do
       allow(::Clavem::Authorizer).to receive(:new) { Time.now }
       authorizer = ::Clavem::Authorizer.instance("FIRST")
-      expect(::Clavem::Authorizer.instance("HOST", "PORT", "COMMAND", "TITLE", "TEMPLATE", "TIMEOUT", true)).not_to be(authorizer)
+      expect(::Clavem::Authorizer.instance("HOST", "PORT", "COMMAND", "TIMEOUT", true)).not_to be(authorizer)
     end
   end
@@ -61,28 +32,24 @@ describe Clavem::Authorizer do
     it "should handle default arguments" do
       authorizer = ::Clavem::Authorizer.new
       expect(authorizer.host).to eq("localhost")
-      expect(authorizer.port).to eq(2501)
+      expect(authorizer.port).to eq(7772)
       expect(authorizer.command).to eq("open \"{{URL}}\"")
-      expect(authorizer.title).to eq("Clavem Authorization")
-      expect(authorizer.template).to eq(File.read(File.dirname(__FILE__) + "/../../lib/clavem/template.html.erb"))
       expect(authorizer.timeout).to eq(0)
-      expect(authorizer.response_handler).to be_nil
+      expect(authorizer.instance_variable_get(:@response_handler)).to be_nil
     end
     it "should assign arguments" do
-      authorizer = ::Clavem::Authorizer.new("HOST", 2511, "COMMAND", "TITLE", "TEMPLATE", 2) do end
+      authorizer = ::Clavem::Authorizer.new("HOST", 7773, "COMMAND", 2) do end
       expect(authorizer.host).to eq("HOST")
-      expect(authorizer.port).to eq(2511)
+      expect(authorizer.port).to eq(7773)
       expect(authorizer.command).to eq("COMMAND")
-      expect(authorizer.title).to eq("TITLE")
-      expect(authorizer.template).to eq("TEMPLATE")
       expect(authorizer.timeout).to eq(2)
-      expect(authorizer.response_handler).to be_a(Proc)
+      expect(authorizer.instance_variable_get(:@response_handler)).to be_a(Proc)
     end
     it "should correct wrong arguments" do
-      authorizer = ::Clavem::Authorizer.new("IP", -10, nil, nil, "", -1)
-      expect(authorizer.port).to eq(2501)
+      authorizer = ::Clavem::Authorizer.new("IP", -10, "", -1)
+      expect(authorizer.port).to eq(7772)
       expect(authorizer.timeout).to eq(0)
     end
@@ -98,86 +65,82 @@ describe Clavem::Authorizer do
   end
   describe "#authorize" do
-    it "should call the correct authorize sequence and then return self" do
-      sequence = []
-      instance = ::Clavem::Authorizer.new
-      server = ::ClavemDummyServer.new
-      # Setup stuff
-      allow(instance).to receive(:setup_webserver) do sequence << 1 end
+    it "should set authorization as waiting" do
+      allow(subject).to receive(:perform_request)
+      allow(subject).to receive(:process_response)
+      subject.authorize("URL")
+      expect(subject.waiting?).to be_true
+    end
-      instance.instance_variable_set(:@server, server)
-      allow(instance).to receive(:setup_interruptions_handling) do sequence << 2 end
-      allow(instance).to receive(:setup_timeout_handling) do sequence << 3 end
-      allow(instance).to receive(:open_endpoint) do sequence << 4 end
+    it "should make a request" do
+      allow(subject).to receive(:process_response)
+      allow(subject).to receive(:callback_url).and_return("CALLBACK")
-      expect(server).to receive(:start)
-      expect(instance.authorize("URL")).to be(instance)
-      expect(sequence).to eq([1, 2, 3, 4])
+      expect(Kernel).to receive(:system).with("open \"URL?oauth_callback=CALLBACK\"")
+      subject.authorize("URL")
+      expect(Kernel).to receive(:system).with("open \"URL?&oauth_callback=CALLBACK\"")
+      subject.authorize("URL?")
+      subject.command = "browse {{URL}}"
+      expect(Kernel).to receive(:system).with("browse URL?oauth_callback=CALLBACK")
+      subject.authorize("URL")
     end
-    it "should raise an exception in case of timeout" do
-      instance = ::Clavem::Authorizer.new
-      allow(instance).to receive(:setup_webserver).and_raise(::Clavem::Exceptions::Timeout)
-      expect { instance.authorize("URL") }.to raise_error(::Clavem::Exceptions::Timeout)
-      expect(instance.status).to eq(:failure)
+    it "should start a server" do
+      allow(subject).to receive(:perform_request)
+      subject.timeout = 1
+      expect(EM).to receive(:start_server).with(subject.host, subject.port, Clavem::Server, subject)
+      subject.authorize("URL")
     end
-    it "should raise an exception in case of errors" do
-      instance = ::Clavem::Authorizer.new
-      allow(instance).to receive(:setup_webserver).and_raise(ArgumentError)
-      expect { instance.authorize("URL") }.to raise_error(::Clavem::Exceptions::Failure)
-      expect(instance.status).to eq(:failure)
-    end
+    it "should return the success" do
+      allow(subject).to receive(:perform_request)
+      allow(subject).to receive(:process_response) { subject.status = :succeeded }
+      expect(subject.authorize("URL")).to be_true
-    it "should always run #cleanup" do
-      cleaned = false
-      instance = ::Clavem::Authorizer.new
-      allow(instance).to receive(:cleanup) do cleaned = true end
-      allow(instance).to receive(:open_endpoint) do end
-      allow(instance).to receive(:setup_webserver) do
-        instance.instance_variable_set(:@server, ::ClavemDummyServer.new)
-      end
+      allow(subject).to receive(:process_response) { subject.status = :failed }
+      expect(subject.authorize("URL")).to be_false
+    end
-      cleaned = false
-      instance.authorize("URL")
-      expect(cleaned).to be_true
+    it "should handle errors" do
+      allow(Kernel).to receive(:system).and_raise(RuntimeError.new)
+      expect { subject.authorize("URL") }.to raise_error(Clavem::Exceptions::Failure)
+      expect(subject.failed?).to be_true
+    end
-      cleaned = false
-      allow(instance).to receive(:setup_webserver).and_raise(ArgumentError)
-      expect { instance.authorize("URL") }.to raise_error(::Clavem::Exceptions::Failure)
-      expect(cleaned).to be_true
+    it "should handle timeouts" do
+      allow(subject).to receive(:perform_request)
-      cleaned = false
-      allow(instance).to receive(:setup_webserver).and_raise(::Clavem::Exceptions::Timeout)
-      expect { instance.authorize("URL") }.to raise_error(::Clavem::Exceptions::Timeout)
-      expect(cleaned).to be_true
+      subject.timeout = 1
+      expect(EM).to receive(:stop).and_call_original
+      subject.authorize("URL")
     end
   end
   describe "#callback_url" do
     it "should return the correct callback" do
-      expect(::Clavem::Authorizer.new.callback_url).to eq("http://localhost:2501/")
+      expect(::Clavem::Authorizer.new.callback_url).to eq("http://localhost:7772/")
       expect(::Clavem::Authorizer.new("10.0.0.1", "80").callback_url).to eq("http://10.0.0.1:80/")
     end
   end
-  describe "#default_response_handler" do
-    it "should return the token" do
-      instance = ::Clavem::Authorizer.new
-      expect(instance.default_response_handler(instance, ::ClavemDummyRequest.new("TOKEN"), nil)).to eq("TOKEN")
+  describe "#response_handler" do
+    it "should return the token as default implementation" do
+      expect(subject.response_handler.call(nil)).to be_nil
+      expect(subject.response_handler.call({"oauth_token" => "TOKEN"})).to eq("TOKEN")
+      expect(subject.response_handler.call({"oauth_token" => ["TOKEN 1", "TOKEN 2"]})).to eq("TOKEN 1")
     end
-    it "should return an empty string by default" do
-      instance = ::Clavem::Authorizer.new
-      expect(instance.default_response_handler(instance, ::ClavemDummyRequest.new(nil), nil)).to eq("")
+    it "should work as a getter" do
+      subject.response_handler = "FOO"
+      expect(subject.response_handler).to eq("FOO")
     end
   end
   describe ".localize" do
     it "should set the right locale path" do
-      expect(instance.instance_variable_get(:@i18n_locales_path)).to eq(File.absolute_path(::Pathname.new(File.dirname(__FILE__)).to_s + "/../../locales/"))
-      instance.localize
+      expect(subject.instance_variable_get(:@i18n_locales_path)).to eq(File.absolute_path(::Pathname.new(File.dirname(__FILE__)).to_s + "/../../locales/"))
+      subject.localize
     end
     it "should set using English if called without arguments" do
@@ -193,160 +156,39 @@ describe Clavem::Authorizer do
     end
   end
-  # PRIVATE
-  describe "#open_endpoint" do
-    it "should call system with the right command" do
-      expect(Kernel).to receive(:system).with("open \"URL\"")
-      instance.instance_variable_set(:@url, "URL")
-      instance.send(:open_endpoint)
-      expect(Kernel).to receive(:system).with("COMMAND")
-      ::Clavem::Authorizer.new("HOST", "PORT", "COMMAND").send(:open_endpoint)
-    end
-    it "should raise exception in case of failures" do
-      allow(Kernel).to receive(:system).and_raise(RuntimeError)
-      expect { instance.send(:open_endpoint) }.to raise_error(::Clavem::Exceptions::Failure)
+  describe "#succeeded?" do
+    it "should return the correct status" do
+      subject.status = :other
+      expect(subject.succeeded?).to be_false
+      subject.status = :succeeded
+      expect(subject.succeeded?).to be_true
     end
   end
-  describe "#setup_interruptions_handling" do
-    it "should add handler for SIGINT, SIGTERM, SIGKILL" do
-      expect(Kernel).to receive(:trap).with("USR2")
-      expect(Kernel).to receive(:trap).with("INT")
-      expect(Kernel).to receive(:trap).with("TERM")
-      expect(Kernel).to receive(:trap).with("KILL")
-      instance.send(:setup_interruptions_handling)
+  describe "#denied?" do
+    it "should return the correct status" do
+      subject.status = :other
+      expect(subject.denied?).to be_false
+      subject.status = :denied
+      expect(subject.denied?).to be_true
     end
   end
-  describe "#setup_timeout_handling" do
-    it "should not set a timeout handler by default" do
-      authorizer = ::Clavem::Authorizer.new
-      allow(authorizer).to receive(:open_endpoint)
-      allow(authorizer).to receive(:setup_webserver) do authorizer.instance_variable_set(:@server, ::ClavemDummyServer.new) end
-      authorizer.authorize("URL")
-      expect(authorizer.instance_variable_get(:@timeout_handler)).to be_nil
-    end
-    it "should set and execute a timeout handler" do
-      expect(Process).to receive(:kill).with("USR2", 0)
-      expect(Kernel).to receive(:sleep).with(0.5)
-      server = ::ClavemDummyServer.new
-      allow(server).to receive(:start) do sleep(1) end
-      authorizer = ::Clavem::Authorizer.new("HOST", "PORT", "COMMAND", "TITLE", "TEMPLATE", 500)
-      allow(authorizer).to receive(:open_endpoint) do end
-      allow(authorizer).to receive(:setup_webserver) do authorizer.instance_variable_set(:@server, server) end
-      expect { authorizer.authorize("URL") }.to raise_error(::Clavem::Exceptions::Timeout)
-      thread = authorizer.instance_variable_get(:@timeout_thread)
-      expect(thread).to be_a(Thread)
-      expect(authorizer.instance_variable_get(:@timeout_expired)).to be_true
+  describe "#failed?" do
+    it "should return the correct status" do
+      subject.status = :other
+      expect(subject.failed?).to be_false
+      subject.status = :failed
+      expect(subject.failed?).to be_true
     end
   end
-  describe "#setup_webserver" do
-    it "should initialize a web server with correct arguments" do
-      logger = WEBrick::Log.new("/dev/null")
-      allow(WEBrick::Log).to receive(:new).and_return(logger)
-      expect(::WEBrick::HTTPServer).to receive(:new).with(BindAddress: "10.0.0.1", Port: 80, Logger: logger, AccessLog: [nil, nil]).and_return(::ClavemDummyServer.new)
-      authorizer = ::Clavem::Authorizer.new("10.0.0.1", 80)
-      authorizer.send(:setup_webserver)
-    end
-    it "should setup a single request handler on /" do
-      server = ::ClavemDummyServer.new
-      allow(::WEBrick::HTTPServer).to receive(:new).and_return(server)
-      authorizer = ::Clavem::Authorizer.new("HOST", "PORT")
-      expect(server).to receive(:mount_proc).with("/")
-      authorizer.send(:setup_webserver)
-    end
-  end
-  describe "#dispatch_request" do
-    let(:request) { ::ClavemDummyRequest.new }
-    let(:response) { ::ClavemDummyResponse.new }
-    let(:server) { ::ClavemDummyServer.new }
-    it "should call the correct handler" do
-      instance.instance_variable_set(:@server, ::ClavemDummyServer.new)
-      expect(instance).to receive(:default_response_handler).with(instance, request, response)
-      instance.send(:dispatch_request, request, response)
-      authorizer = ::Clavem::Authorizer.new do end
-      authorizer.instance_variable_set(:@server, ::ClavemDummyServer.new)
-      expect(authorizer.response_handler).to receive(:call).with(authorizer, request, response)
-      authorizer.send(:dispatch_request, request, response)
-    end
-    it "should handle request only if the status is still :waiting" do
-      authorizer = ::Clavem::Authorizer.new
-      authorizer.instance_variable_set(:@server, server)
-      authorizer.status = :waiting
-      expect(server).to receive(:shutdown)
-      authorizer.send(:dispatch_request, request, response)
-      authorizer = ::Clavem::Authorizer.new
-      authorizer.instance_variable_set(:@server, server)
-      authorizer.status = :success
-      expect(server).not_to receive(:shutdown)
-      authorizer.send(:dispatch_request, request, response)
-    end
-    it "should correctly set status" do
-      authorizer = ::Clavem::Authorizer.new
-      authorizer.instance_variable_set(:@server, server)
-      authorizer.send(:dispatch_request, ::ClavemDummyRequest.new("TOKEN"), response)
-      expect(authorizer.status).to eq(:success)
-      expect(response.status).to eq(200)
-      authorizer = ::Clavem::Authorizer.new
-      authorizer.instance_variable_set(:@server, server)
-      authorizer.send(:dispatch_request, request, response)
-      expect(authorizer.status).to eq(:denied)
-      expect(response.status).to eq(403)
-    end
-    it "should render the body of the response" do
-      authorizer = ::Clavem::Authorizer.new
-      authorizer.instance_variable_set(:@server, server)
-      expect(authorizer.instance_variable_get(:@compiled_template)).to receive(:result).and_return("TEMPLATE")
-      authorizer.send(:dispatch_request, request, response)
-      expect(response.body).to eq("TEMPLATE")
-    end
-  end
-  describe "#cleanup" do
-    it "should shutdown the server and cleanup signal handling" do
-      server = ::ClavemDummyServer.new
-      allow(server).to receive(:start) do sleep(1) end
-      authorizer = ::Clavem::Authorizer.new("HOST", "PORT", "COMMAND", "TITLE", "TEMPLATE")
-      allow(authorizer).to receive(:open_endpoint) do end
-      allow(authorizer).to receive(:setup_webserver) do authorizer.instance_variable_set(:@server, server) end
-      authorizer.authorize("URL")
-      expect(Kernel).to receive(:trap).with("USR2", "DEFAULT")
-      expect(Kernel).to receive(:trap).with("INT", "DEFAULT")
-      expect(Kernel).to receive(:trap).with("TERM", "DEFAULT")
-      expect(Kernel).to receive(:trap).with("KILL", "DEFAULT")
-      expect(server).to receive(:shutdown)
-      authorizer.send(:cleanup)
-    end
-    it "should exit timeout handling thread if active" do
-      thread = nil
-      server = ::ClavemDummyServer.new
-      allow(server).to receive(:start) do sleep(1) end
-      authorizer = ::Clavem::Authorizer.new("HOST", "PORT", "COMMAND", "TITLE", "TEMPLATE", 5000)
-      authorizer.send(:setup_timeout_handling)
-      thread = authorizer.instance_variable_get(:@timeout_thread)
-      expect(thread).to receive(:exit)
-      authorizer.send(:cleanup)
+  describe "#waiting?" do
+    it "should return the correct status" do
+      subject.status = :other
+      expect(subject.waiting?).to be_false
+      subject.status = :waiting
+      expect(subject.waiting?).to be_true
     end
   end
 end