queue_it 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80302e4595250a93745ae5cdde295cc1ef9c4dfe
-  data.tar.gz: 98f55674bca1f8d64ea1ea35b3cc0f9f14096cd5
+  metadata.gz: 8150d61b7d0ab15e25a4f0fab5c03c467971e3d2
+  data.tar.gz: 973591f75fa2065da623ffdde2ba528988d6c6c3
 SHA512:
-  metadata.gz: 734e01bc853574e3e963c60212debdc7ce9ea33e87cdb2d6b9619d7aecef8de31994a8aa7c2559935478ee0bae6a8825ecdcce1b3cc0ea90169ede943c798535
-  data.tar.gz: f86d410b4b320462e8aaa82c702ac1c1ef6eb700ec00117f212e9b2a132ef51d825cc734d52445544e7ccb4e9b21eb6c6766c806d2ba1e22e8696d4bb4c1755e
+  metadata.gz: 64388a8c6c1491f80164f130450363fe307145857cef71fb4980c5ea9e7b6d378364649d149ad0d3d24706fae84b9ef2732039c14ac66213e106758da9eefb8f
+  data.tar.gz: caf23fffccda918e9f8c0f1dad37cd48b714c507d24afb43dc136d58830848bac51686a704820b888856b31d7e426197df28ce9114c20550d41ab6eca65a47d5

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+### 1.1.0 - 2015-05-07
+
+* Basic Api 2.0.beta integration
+  * https://api2.queue-it.net
+* `QueueIt::Api::Client`
+  * Allows to perform request with `JSON` encoded data to proper endpoint
+  * Debugging mode present
+* `QueueIt::Api::Event`
+    * Creates or updates queue with some basic setup which fits our current needs
+    * Sets queue speed
+
+### 1.0.0 - 2014-11-06
+
+* Provides `#protect_with_queue!` method
+  * renders page which allows to redirect users to Queue-It
+  * handles KnowUserSecretKey verification
+* Provides `#destroy_all_queue_it_sessions` method
+  * clears queue which pushes client from queue after successful purchase

data/README.md

@@ -24,7 +24,7 @@ $ gem install queue_it
 
 ## Usage
 
-We are using Queue-it on http://billetto.co.ok, and we create our queued events like this:
+We are using Queue-it on http://billetto.co.uk, and we create our queued events like this:
 
 ```ruby
 event  = create(:event,
@@ -74,6 +74,92 @@ class EventsController < ApplicationController
 end
 ```
 
+### API
+#### Client
+
+Initialize client to pass it as a dependency to `Event` instance.
+
+``` ruby
+client = QueueIt::Api::Client.new(api_key: "SECRET_API_KEY")
+```
+
+#### Event
+##### #create_or_update
+Handles: https://api2.queue-it.net/Help/Api/PUT-2_0_beta-event-eventId
+
+Basic usage
+``` ruby
+event = QueueIt::Api::Event.new(client)
+
+event.create_or_update(event_id:     'justatestevent',
+                       display_name: "Test event",
+                       start_time:   Time.now,
+                       redirect_url: 'https://example.com/en/events/not-so-fancy-event/tickets')
+# produces
+{
+  "QueueUrl"=>"http://justatestevent-examplecom.queue-it.net/?c=examplecom&e=justatestevent",
+  "EventId"=>"justatestevent",
+  "PreQueueStartLocalTime"=>"2015-05-07T13:29:00.0000000Z",
+  "EventStartLocalTime"=>"2015-05-07T14:29:00.0000000Z",
+  "EventEndLocalTime"=>"2016-05-06T19:29:00.0000000Z",
+  "QueueStatus"=>"Running",
+  "LastPassedAutoTestRun"=>"",
+  "DisplayName"=>"Test event",
+  "RedirectUrl"=>"https://example.com/en/events/not-so-fancy-event/tickets",
+  "Description"=>"",
+  "TimeZone"=>"UTC",
+  "PreQueueStartTime"=>"2015-05-07T13:29:00.0000000Z",
+  "EventStartTime"=>"2015-05-07T14:29:00.0000000Z",
+  "EventEndTime"=>"2016-05-06T20:29:00.0000000Z",
+  "EventCulture"=>"en-US",
+  "MaxNoOfRedirectsPrQueueId"=>"1",
+  "QueueNumberValidityInMinutes"=>"15",
+  "AfterEventLogic"=>"RedirectUsersToTargetPage",
+  "AfterEventRedirectPage"=>"",
+  "UseSSL"=>"Auto",
+  "JavaScriptSupportEnabled"=>"False",
+  "TargetUrlSupportEnabled"=>"False",
+  "SafetyNetMode"=>"Disabled",
+  "KnowUserSecurity"=>"MD5Hash",
+  "KnowUserSecretKey"=>"SECRET",
+  "CustomLayout"=>"Default layout by Queue-it",
+  "XUsersInFrontOfYou"=>"0",
+  "TargetUrlValidationRegex"=>"",
+  "DomainAlias"=>"justatestevent-examplecom.queue-it.net",
+  "AllowedCustomLayouts"=>[],
+  "BrowserCultureEnabled"=>"True",
+  "IdleQueueLogic"=>"UseBeforePage",
+  "IdleQueueRedirectPage"=>""
+}
+```
+
+Available named attributes
+``` ruby
+event_id:
+display_name:
+start_time:
+end_time:
+know_user_secret_key:
+redirect_url:
+description:
+max_redirects_per_minute:
+event_culture_name:
+time_zone:
+queue_number_validity_in_minutes:
+```
+
+##### #set_speed
+
+Set redirect speed on an event queue.
+
+See: https://api2.queue-it.net/Help/Api/PUT-2_0_beta-event-eventId-queue-speed
+
+``` ruby
+event = QueueIt::Api::Event.new(client)
+
+event.set_speed(event_id: "justatestevent", max_redirects_per_minute: 15)
+```
+
 ## Contributing
 
 1. Fork it

data/lib/faraday/raise_http_exception.rb

@@ -0,0 +1,48 @@
+require 'faraday'
+require 'json'
+
+module FaradayMiddleware
+  class RaiseHttpException < Faraday::Middleware
+    def call(env)
+      @app.call(env).on_complete do |response|
+        case response[:status].to_i
+        when 400
+          raise QueueIt::Api::BadRequest.new(response.body, error_details(response))
+        when 403
+          raise QueueIt::Api::Forbidden.new(response.body, error_details(response))
+        when 404
+          raise QueueIt::Api::NotFound.new(response.body, error_details(response))
+        when 500
+          raise QueueIt::Api::InternalServerError.new(response.body, error_details(response))
+        when 503
+          raise QueueIt::Api::ServiceUnavailable.new(response.body, error_details(response))
+        end
+      end
+    end
+
+    private
+
+    def error_response_body(code, text)
+      { "ErrorCode" => code, "ErrorText" => text }
+    end
+
+    def acts_like_json?(response_body)
+      !response_body.nil? && !response_body.empty? && response_body.kind_of?(String)
+    end
+
+    def parse_json(body)
+      JSON.parse(body)
+    rescue JSON::ParserError
+      error_response_body(nil, body)
+    end
+
+    def parse_body(response_body)
+      acts_like_json?(response_body) ? parse_json(response_body) : error_response_body(nil, nil)
+    end
+
+    def error_details(response)
+      response_body = parse_body(response.body)
+      { status: response[:status].to_i, code: response_body["ErrorCode"], text: response_body["ErrorText"] }
+    end
+  end
+end

data/lib/queue_it/api/client.rb

@@ -0,0 +1,53 @@
+require 'uri'
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday/raise_http_exception'
+require 'queue_it/api/error'
+
+module QueueIt
+  module Api
+    class Client
+      JSON_FORMAT  = "application/json".freeze
+      ENDPOINT_URL = URI("https://api2.queue-it.net/2_0_beta/event").freeze
+
+      def initialize(api_key: api_key, debug: false)
+        self.api_key = api_key
+        self.debug   = debug
+      end
+
+      def put(path, body)
+        connection.put(path, body)
+      end
+
+      private
+
+      attr_accessor :api_key, :debug
+
+      def options
+        {
+          url: ENDPOINT_URL.dup,
+          headers: {
+            accept: JSON_FORMAT,
+            content_type: JSON_FORMAT,
+            "Api-Key" => api_key,
+          },
+        }
+      end
+
+      def debug?
+        debug
+      end
+
+      def connection
+        @connection ||= Faraday.new(options) do |builder|
+          builder.request  :json
+          builder.response :logger, nil, { bodies: true } if debug?
+          builder.response :json, content_type: /\bjson$/
+
+          builder.adapter  Faraday.default_adapter
+          builder.use      FaradayMiddleware::RaiseHttpException
+        end
+      end
+    end
+  end
+end

data/lib/queue_it/api/error.rb

@@ -0,0 +1,20 @@
+module QueueIt
+  module Api
+    class Error < StandardError
+      attr_accessor :status, :code, :text
+
+      def initialize(msg = nil, status: nil, code: nil, text: nil)
+        self.code   = code
+        self.text   = text
+        self.status = status
+        super(msg)
+      end
+    end
+
+    BadRequest          = Class.new(Error)
+    Forbidden           = Class.new(Error)
+    NotFound            = Class.new(Error)
+    InternalServerError = Class.new(Error)
+    ServiceUnavailable  = Class.new(Error)
+  end
+end

data/lib/queue_it/api/event.rb

@@ -0,0 +1,121 @@
+require 'json'
+require 'uri'
+require 'time'
+
+module QueueIt
+  module Api
+    class Event
+      InvalidEventIdFormat = Class.new(StandardError)
+
+      def initialize(client)
+        self.client = client
+      end
+
+      def create_or_update(event_id:, display_name:, start_time:, know_user_secret_key: nil, redirect_url:, end_time: nil, description: "", event_culture_name: "en-US", time_zone: "UTC", queue_number_validity_in_minutes: 15)
+        raise InvalidEventIdFormat unless valid_event_id_format?(event_id)
+
+        attributes = queue_attributes(
+          start_time:                       start_time,
+          end_time:                         end_time,
+          know_user_secret_key:             know_user_secret_key,
+          redirect_url:                     redirect_url,
+          description:                      description,
+          display_name:                     display_name,
+          event_culture_name:               event_culture_name,
+          queue_number_validity_in_minutes: queue_number_validity_in_minutes,
+          time_zone:                        time_zone)
+
+        perform_request(:put, event_id, attributes)
+      end
+
+      def set_speed(event_id:, max_redirects_per_minute:)
+        raise InvalidEventIdFormat unless valid_event_id_format?(event_id)
+
+        number_of_redirects = [max_redirects_per_minute.to_i, QUEUE_IT_MINIMAL_NUMBER_OF_REDIRECTS_PER_MINUTE].max
+        attributes          = { "MaxRedirectsPerMinute" => "#{number_of_redirects}" }
+
+        perform_request(:put, "#{event_id}/queue/speed", attributes)
+      end
+
+      private
+
+      attr_accessor :client
+
+      ONE_YEAR = 31557600
+      ONE_HOUR = 3600
+
+      MICROSOFT_TIME_ZONE_INDEX_VALUES = {
+        "Europe/Copenhagen" => "Romance Standard Time",
+        "Europe/Helsinki"   => "FLE Standard Time",
+        "Europe/London"     => "GMT Standard Time",
+        "Europe/Paris"      => "GMT Standard Time",
+        "Paris"             => "Romance Standard Time",
+        "Stockholm"         => "W. Europe Standard Time",
+      }.freeze
+
+      EVENT_ID_FORMAT = /\A[a-zA-z0-9]{1,20}\z/.freeze
+      QUEUE_IT_ISO8601_TIME_PRECISION = 7
+      QUEUE_IT_MINIMAL_NUMBER_OF_REDIRECTS_PER_MINUTE = 5
+
+      def valid_event_id_format?(event_id)
+        "#{event_id}".match(EVENT_ID_FORMAT)
+      end
+
+      def utc_start_time(start_time)
+        start_time.utc
+      end
+
+      def utc_end_time(start_time, end_time)
+        end_time && end_time.utc || utc_start_time(start_time) + ONE_YEAR
+      end
+
+      def pre_queue_start_time(start_time)
+        start_time.utc - ONE_HOUR
+      end
+
+      def format_time(time)
+        time.iso8601(QUEUE_IT_ISO8601_TIME_PRECISION)
+      end
+
+      def translate_time_zone(time_zone)
+        MICROSOFT_TIME_ZONE_INDEX_VALUES.fetch(time_zone, time_zone)
+      end
+
+      def queue_attributes(start_time:, end_time:, know_user_secret_key:, redirect_url:, description:, display_name:, event_culture_name:, queue_number_validity_in_minutes:, time_zone:)
+        {
+          "DisplayName"                  => display_name,
+          "RedirectUrl"                  => URI(redirect_url).to_s,
+          "Description"                  => description,
+          "TimeZone"                     => translate_time_zone(time_zone),
+          "PreQueueStartTime"            => format_time( pre_queue_start_time(start_time) ),
+          "EventStartTime"               => format_time( utc_start_time(start_time) ),
+          "EventEndTime"                 => format_time( utc_end_time(start_time, end_time) ),
+          "EventCulture"                 => event_culture_name,
+          "MaxNoOfRedirectsPrQueueId"    => "1",
+          "QueueNumberValidityInMinutes" => "#{queue_number_validity_in_minutes}",
+          "AfterEventLogic"              => "RedirectUsersToTargetPage",
+          "AfterEventRedirectPage"       => "",
+          "UseSSL"                       => "Auto",
+          "JavaScriptSupportEnabled"     => "False",
+          "TargetUrlSupportEnabled"      => "False",
+          "SafetyNetMode"                => "Disabled",
+          "KnowUserSecurity"             => "MD5Hash",
+          "KnowUserSecretKey"            => know_user_secret_key,
+          "CustomLayout"                 => "Default layout by Queue-it",
+          "XUsersInFrontOfYou"           => nil,
+          "TargetUrlValidationRegex"     => "",
+          "DomainAlias"                  => "",
+          "AllowedCustomLayouts"         => [],
+          "BrowserCultureEnabled"        => "True",
+          "IdleQueueLogic"               => "UseBeforePage",
+          "IdleQueueRedirectPage"        => ""
+        }
+      end
+
+      def perform_request(method, path, body = {})
+        json_response = client.public_send(method, path, body)
+        json_response.body
+      end
+    end
+  end
+end

data/lib/queue_it/version.rb

@@ -1,3 +1,3 @@
 module QueueIt
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/queue_it.rb

@@ -1,5 +1,7 @@
 require "queue_it/version"
 require "queue_it/known_user_checker"
+require "queue_it/api/client"
+require "queue_it/api/event"
 
 module QueueIt
   class NotAuthorized    < StandardError; end

data/queue_it.gemspec

@@ -6,8 +6,8 @@ require 'queue_it/version'
 Gem::Specification.new do |spec|
   spec.name          = "queue_it"
   spec.version       = QueueIt::VERSION
-  spec.authors       = ["Kasper Grubbe"]
-  spec.email         = ["kawsper@gmail.com"]
+  spec.authors       = ["Billetto"]
+  spec.email         = ["development@billetto.dk"]
   spec.description   = %q{Gem to handle the implementation of http://queue-it.net!}
   spec.summary       = %q{Gem to handle the implementation of http://queue-it.net}
   spec.homepage      = "https://github.com/gfish/queue_it"
@@ -18,8 +18,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency 'addressable'
+  spec.add_runtime_dependency "addressable", "~> 2.3"
+  spec.add_runtime_dependency "faraday", "~> 0.9"
+  spec.add_runtime_dependency "faraday_middleware", "~> 0.9"
 
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "webmock", "~> 1.21"
 end

data/spec/queue_it/api/client_spec.rb

@@ -0,0 +1,121 @@
+require 'json'
+require 'webmock/rspec'
+require 'queue_it/api/client'
+
+module QueueIt
+  module Api
+    describe Client do
+      subject(:client) { described_class.new(api_key: "SECURE_KEY") }
+
+      specify "PUT data under given endpoint & path in JSON format" do
+        request_hash  = { "Request" => true }
+        response_hash = { "Response" => true }
+
+        stub_successful_put(request_hash, response_hash)
+
+        expect( client.put("fancy_event", request_hash).body ).to eq(response_hash)
+      end
+
+      specify "authentication error handling" do
+        stub_unauthorized
+
+        expect{ client.put("fancy_event", {}) }.to raise_error(Forbidden)
+      end
+
+      specify "error details are being parsed" do
+        stub_unauthorized
+
+        begin
+          client.put("fancy_event", {})
+        rescue Forbidden => e
+          expect(e.status).to eq(403)
+          expect(e.code).to   eq(4000)
+          expect(e.text).to   eq("Authentication failed. Supply valid API key to access this operation")
+        end
+      end
+
+      specify "server error with html body" do
+        stub_internal_server_error
+
+        expect{ client.put("fancy_event", "{}") }.to raise_error(InternalServerError)
+      end
+
+      specify "error without a body" do
+        stub_internal_server_error
+
+        begin
+          client.put("fancy_event", "{}")
+        rescue InternalServerError => e
+          expect(e.status).to eq(500)
+          expect(e.code).to   be_nil
+          expect(e.text).to   eq("<html>Internal Server Error<\/html>")
+        end
+      end
+
+      specify "bad request error handling" do
+        stub_bad_request
+
+        expect{ client.put("fancy_event", "{}") }.to raise_error(BadRequest)
+      end
+
+      specify "not found error handling" do
+        stub_not_found
+
+        expect{ client.put("fancy_event", "{}") }.to raise_error(NotFound)
+      end
+
+      specify "service unavailable error handling" do
+        stub_service_unavailable
+
+        expect{ client.put("fancy_event", "{}") }.to raise_error(ServiceUnavailable)
+      end
+
+      specify "debugging mode puts to STDOUT" do
+        client = Client.new(api_key: "SECURE_KEY", debug: true)
+
+        request_hash  = { "Request"  => true }
+
+        stub_successful_put(request_hash, {})
+
+        expect { client.put("fancy_event", request_hash) }.to output(/request: {"Request":true}/).to_stdout_from_any_process
+      end
+
+      private
+
+      def endpoint_url
+        Client::ENDPOINT_URL.to_s + "/fancy_event"
+      end
+
+      def stub_request_factory(method: :put, status: 200, request_body: "{}", response_body: "{}", content_type: "application/json")
+        stub_request(method, endpoint_url)
+          .with(:body => request_body, :headers => {'Accept'=>'application/json', 'Api-Key'=>'SECURE_KEY', 'Content-Type'=>'application/json'})
+          .to_return(:status => status, :body => response_body, :headers => { 'Content-Type' => content_type })
+      end
+
+      def stub_unauthorized
+        body = "{\"ErrorCode\":4000,\"ErrorText\":\"Authentication failed. Supply valid API key to access this operation\"}"
+        stub_request_factory(status: 403, response_body: body)
+      end
+
+      def stub_internal_server_error
+        stub_request_factory(status: 500, response_body: "<html>Internal Server Error</html>", content_type: "text/html")
+      end
+
+      def stub_successful_put(request_body, response_body)
+        stub_request_factory(request_body: JSON.generate(request_body), response_body: JSON.generate(response_body))
+      end
+
+      def stub_bad_request
+        stub_request_factory(status: 400)
+      end
+
+      def stub_not_found
+        stub_request_factory(status: 404)
+      end
+
+      def stub_service_unavailable
+        stub_request_factory(status: 503)
+      end
+    end
+  end
+end

data/spec/queue_it/api/event_spec.rb

@@ -0,0 +1,198 @@
+require 'queue_it/api/event'
+require 'queue_it/api/client'
+require 'webmock/rspec'
+
+module QueueIt
+  module Api
+    describe Event do
+      let(:event_id) { "fancyevent" }
+
+      subject(:event_adapter) { Event.new(client) }
+
+      context "#create_or_update" do
+        let(:client)                   { double(:api_client) }
+        let(:know_user_secret_key)     { "930f42ca-d9e7-4202-bff4-606e127b1c103980c131-cd8a-4e35-a945-50f7b5102ad6" }
+        let(:display_name)             { "Fancy Event 2015" }
+        let(:description)              { "Foo" }
+        let(:redirect_url)             { "https://example.com/en/events/fancy_event/tickets" }
+        let(:time_zone)                { "Europe/Copenhagen" }
+        let(:event_culture_name)       { "en-US" }
+        let(:queue_number_validity_in_minutes) { 15 }
+
+        specify "Submits proper request" do
+          expect(client).to receive(:put).with(event_id, valid_create_body).and_return(double(body:{}))
+
+          event_adapter.create_or_update(event_id:                         event_id,
+                                         display_name:                     display_name,
+                                         description:                      description,
+                                         redirect_url:                     redirect_url,
+                                         start_time:                       Time.new(2015,04,28,17,25,46, "+02:00"),
+                                         end_time:                         Time.new(2015,04,28,21,25,46, "+02:00"),
+                                         event_culture_name:               event_culture_name,
+                                         know_user_secret_key:             know_user_secret_key,
+                                         queue_number_validity_in_minutes: queue_number_validity_in_minutes)
+        end
+
+        specify "Minimum viable attributes for creating event" do
+          body = valid_create_body.merge({
+            "Description"       => "",
+            "EventEndTime"      => "2016-04-27T21:25:46.0000000Z",
+            "EventCulture"      => event_culture_name,
+            "KnowUserSecretKey" => nil,
+          })
+
+          expect(client).to receive(:put).with(event_id, body).and_return(double(body:{}))
+
+          event_adapter.create_or_update(event_id:             event_id,
+                                         display_name:         display_name,
+                                         redirect_url:         redirect_url,
+                                         start_time:           Time.utc(2015,04,28,15,25,46),)
+        end
+
+        specify "Set custom time zone in the ruby way" do
+          body = valid_create_body.merge({
+            "TimeZone"  => "Romance Standard Time",
+          })
+
+          expect(client).to receive(:put).with(event_id, body).and_return(double(body:{}))
+
+          event_adapter.create_or_update(event_id:                          event_id,
+                                         display_name:                      display_name,
+                                         description:                       description,
+                                         redirect_url:                      redirect_url,
+                                         start_time:                        Time.new(2015,04,28,17,25,46, "+02:00"),
+                                         end_time:                          Time.new(2015,04,28,21,25,46, "+02:00"),
+                                         know_user_secret_key:              know_user_secret_key,
+                                         queue_number_validity_in_minutes:  queue_number_validity_in_minutes,
+                                         time_zone:                         time_zone,)
+        end
+
+        specify "Event id must have proper format" do
+          invalid_event_id = "/fancyevent"
+
+          expect do
+            event_adapter.create_or_update(event_id:                          invalid_event_id,
+                                           display_name:                      display_name,
+                                           description:                       description,
+                                           redirect_url:                      redirect_url,
+                                           start_time:                        Time.new(2015,04,28,17,25,46, "+02:00"),
+                                           end_time:                          Time.new(2015,04,28,21,25,46, "+02:00"),
+                                           know_user_secret_key:              know_user_secret_key,
+                                           queue_number_validity_in_minutes:  queue_number_validity_in_minutes,
+                                           time_zone:                         time_zone,)
+          end.to raise_error(Event::InvalidEventIdFormat)
+        end
+
+        specify "Event id has to be no longer than 20 characters" do
+          too_long_event_id = "fancyeventnametoolong"
+
+          expect do
+            event_adapter.create_or_update(event_id:                          too_long_event_id,
+                                           display_name:                      display_name,
+                                           description:                       description,
+                                           redirect_url:                      redirect_url,
+                                           start_time:                        Time.new(2015,04,28,17,25,46, "+02:00"),
+                                           end_time:                          Time.new(2015,04,28,21,25,46, "+02:00"),
+                                           know_user_secret_key:              know_user_secret_key,
+                                           queue_number_validity_in_minutes:  queue_number_validity_in_minutes,
+                                           time_zone:                         time_zone,)
+          end.to raise_error(Event::InvalidEventIdFormat)
+        end
+
+        specify "Request hits proper endpoint" do
+          client        = Client.new(api_key: "SECURE_KEY")
+          event_adapter = Event.new(client)
+
+          body = JSON.generate(valid_create_body)
+
+          stub = stub_request(:put, "https://api2.queue-it.net/2_0_beta/event/fancyevent")
+            .with(body: body, headers: headers)
+
+          event_adapter.create_or_update(event_id:                         event_id,
+                                         display_name:                     display_name,
+                                         description:                      description,
+                                         redirect_url:                     redirect_url,
+                                         start_time:                       Time.new(2015,04,28,17,25,46, "+02:00"),
+                                         end_time:                         Time.new(2015,04,28,21,25,46, "+02:00"),
+                                         event_culture_name:               event_culture_name,
+                                         know_user_secret_key:             know_user_secret_key,
+                                         queue_number_validity_in_minutes: queue_number_validity_in_minutes)
+
+          expect(stub).to have_been_requested
+        end
+
+        private
+
+        let(:valid_create_body) do
+          {
+            "DisplayName"                  => display_name,
+            "RedirectUrl"                  => redirect_url,
+            "Description"                  => description,
+            "TimeZone"                     => "UTC",
+            "PreQueueStartTime"            => "2015-04-28T14:25:46.0000000Z",
+            "EventStartTime"               => "2015-04-28T15:25:46.0000000Z",
+            "EventEndTime"                 => "2015-04-28T19:25:46.0000000Z",
+            "EventCulture"                 => event_culture_name,
+            "MaxNoOfRedirectsPrQueueId"    => "1",
+            "QueueNumberValidityInMinutes" => "#{queue_number_validity_in_minutes}",
+            "AfterEventLogic"              => "RedirectUsersToTargetPage",
+            "AfterEventRedirectPage"       => "",
+            "UseSSL"                       => "Auto",
+            "JavaScriptSupportEnabled"     => "False",
+            "TargetUrlSupportEnabled"      => "False",
+            "SafetyNetMode"                => "Disabled",
+            "KnowUserSecurity"             => "MD5Hash",
+            "KnowUserSecretKey"            => know_user_secret_key,
+            "CustomLayout"                 => "Default layout by Queue-it",
+            "XUsersInFrontOfYou"           => nil,
+            "TargetUrlValidationRegex"     => "",
+            "DomainAlias"                  => "",
+            "AllowedCustomLayouts"         => [],
+            "BrowserCultureEnabled"        => "True",
+            "IdleQueueLogic"               => "UseBeforePage",
+            "IdleQueueRedirectPage"        => ""
+          }
+        end
+      end
+
+      context "#set_speed" do
+        let(:client)                   { Client.new(api_key: "SECURE_KEY") }
+        let(:max_redirects_per_minute) { 15 }
+
+        specify "Proper speed value is set" do
+          body = { "MaxRedirectsPerMinute" => "15" }
+
+          stub = stub_request(:put, "https://api2.queue-it.net/2_0_beta/event/fancyevent/queue/speed")
+            .with(body: body, headers: headers)
+
+          event_adapter.set_speed(event_id: event_id, max_redirects_per_minute: max_redirects_per_minute)
+
+          expect(stub).to have_been_requested
+        end
+
+        specify "Speed must be greater than 5 so we send at least 5" do
+          expected_body = { "MaxRedirectsPerMinute" => "5" }
+
+          stub = stub_request(:put, "https://api2.queue-it.net/2_0_beta/event/fancyevent/queue/speed")
+            .with(body: expected_body, headers: headers)
+
+          event_adapter.set_speed(event_id: event_id, max_redirects_per_minute: 1)
+
+          expect(stub).to have_been_requested
+        end
+
+        specify "Event id must have proper format" do
+          invalid_event_id = "/fancyevent"
+
+          expect do
+            event_adapter.set_speed(event_id: invalid_event_id, max_redirects_per_minute: max_redirects_per_minute)
+          end.to raise_error(Event::InvalidEventIdFormat)
+        end
+      end
+
+      private
+
+      let(:headers) { {'Accept' =>'application/json', 'Content-Type' =>'application/json', 'Api-Key' =>'SECURE_KEY'} }
+    end
+  end
+end

metadata

@@ -1,78 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: queue_it
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
-- Kasper Grubbe
+- Billetto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-06 00:00:00.000000000 Z
+date: 2015-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.21'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.21'
 description: Gem to handle the implementation of http://queue-it.net!
 email:
-- kawsper@gmail.com
+- development@billetto.dk
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - app/views/queue_it/cheating_queue.html.erb
 - app/views/queue_it/enter_queue.html.erb
+- lib/faraday/raise_http_exception.rb
 - lib/queue_it.rb
+- lib/queue_it/api/client.rb
+- lib/queue_it/api/error.rb
+- lib/queue_it/api/event.rb
 - lib/queue_it/known_user_checker.rb
 - lib/queue_it/queueable.rb
 - lib/queue_it/railtie.rb
 - lib/queue_it/url_builder.rb
 - lib/queue_it/version.rb
 - queue_it.gemspec
+- spec/queue_it/api/client_spec.rb
+- spec/queue_it/api/event_spec.rb
 homepage: https://github.com/gfish/queue_it
 licenses:
 - GNU/GPLv3
@@ -83,18 +132,20 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Gem to handle the implementation of http://queue-it.net
-test_files: []
+test_files:
+- spec/queue_it/api/client_spec.rb
+- spec/queue_it/api/event_spec.rb