hipchat 0.14.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a076583ac9843df4a79672f0efb27a3e54855dc7
-  data.tar.gz: 286a673b9d8f4413a4ef5d5d0b5d3dc933f39859
+  metadata.gz: bb8eb196374b9fb0af86c10fd90d72cf2f394918
+  data.tar.gz: da191a66ed2c5773b72c4be049f466615f141e26
 SHA512:
-  metadata.gz: abd43e5029fc567c3b2168c0280e46e71a138f4f8c68aab21cdbb09b33b95fceec7b67263f4a4443685ebd85337f1f21d0a8f7364489829d1c152cebc4d58ddd
-  data.tar.gz: 8b53a6201400e0e6362f7f63ffc9efacdbd082a4e8e39390e0a6f39ce83c5513c7e4967be22e2065f91dad15c42a8a469a18b3f87dfa0f4a66849e9df73dceb4
+  metadata.gz: ea2874650ffa2ebde7d816fe43fe83cecc1c8c91cef18046009aefc300eac473e375fbef4c888d085a1d9d0bc7f61d88e176db50ed711453efd4b7923756ce4f
+  data.tar.gz: ca023bf579d6c705e25d429672fc27230ac6c3c23c2a4e197bd649c5a81951e0835b34a6801bd5b25e06839a82aba3ad344dcd4c4e21bffb1578152daf783717

data/README.textile

@@ -2,22 +2,25 @@ h1. HipChat Wrapper
 
 A very basic wrapper for the HipChat HTTP API.
 
-h2. Build Status
+h2. CI Status
 
 "!https://travis-ci.org/hipchat/hipchat-rb.png!":https://travis-ci.org/hipchat/hipchat-rb
+!https://coveralls.io/repos/hipchat/hipchat-rb/badge.png(Coverage Status)!:https://coveralls.io/r/hipchat/hipchat-rb
 
 h2. Requirements
 * Ruby 1.9.3 or higher
-* HipChat Account, signed up "here!":https://hipchat.com/
+* HipChat Account, sign up "here!":https://hipchat.com/
 
-h2. Usage
+h1. Usage
+
+h2. "API v1":https://www.hipchat.com/docs/api
 
 bc.. client = HipChat::Client.new(api_token)
 # 'username' is the name for which the message will be presented as from
 client['my room'].send('username', 'I talk')
 
 # Send notifications to users (default false)
-client['my room'].send('username', 'I quit!', :notify => true)
+client['my room'].send('username', 'I quit!', :notify => 1)
 
 # Color it red. or "yellow", "green", "purple", "random" (default "yellow")
 client['my room'].send('username', 'Build failed!', :color => 'red')
@@ -37,18 +40,52 @@ client['my room'].history()
 # Get history for a date in time with a particular timezone (default is latest 75 messages, timezone default is 'UTC')
 client['my room'].history(:date => '2010-11-19', :timezone => 'PST')
 
+h2. "API v2":https://www.hipchat.com/docs/apiv2
+
+bc.. client = HipChat::Client.new(api_token, :api_version => 'v2')
+# 'username' is the name for which the message will be presented as from
+client['my room'].send('username', 'I talk')
+
+# Send notifications to users (default false)
+client['my room'].send('username', 'I quit!', :notify => true)
+
+# Color it red. or "yellow", "green", "purple", "random" (default "yellow")
+client['my room'].send('username', 'Build failed!', :color => 'red')
+
+# Have your message rendered as text in HipChat (see https://www.hipchat.com/docs/apiv2/method/send_room_notification)
+client['my room'].send('username', '@coworker Build faild!', :message_format => 'text')
+
+# Update the topic of a room in HipChat (see https://www.hipchat.com/docs/apiv2/method/set_topic)
+client['my room'].topic('Free Ice Cream in the kitchen')
+
+# Change the from field for a topic update (default "API")
+client['my room'].topic('Weekely sales: $10,000', :from => 'Sales Team')
+
+# Get history from a room
+client['my room'].history()
+
+# Get history for a date in time with a particular timezone (default is latest 75 messages, timezone default is 'UTC')
+client['my room'].history(:date => '2010-11-19', :timezone => 'PST')
 
 h2. Capistrano
 
-bc.. require 'hipchat/capistrano'
+*APIv1 ONLY, use APIv1 Key*
+
+Capfile
+
+bc. require 'hipchat/capistrano'
 
+deploy.rb
+
+bc.. # Required
 set :hipchat_token, "<your token>"
 set :hipchat_room_name, "Your room" # If you pass an array such as ["room_a", "room_b"] you can send announcements to multiple rooms.
+# Optional
 set :hipchat_announce, false # notify users
 set :hipchat_color, 'yellow' #normal message color
 set :hipchat_success_color, 'green' #finished deployment message color
 set :hipchat_failed_color, 'red' #cancelled deployment message color
-set :hipchat_message_format, 'text' # Sets the deployment message format, see https://www.hipchat.com/docs/api/method/rooms/message
+set :hipchat_message_format, 'html' # Sets the deployment message format, see https://www.hipchat.com/docs/api/method/rooms/message
 
 h3. Who did it?
 
@@ -61,6 +98,8 @@ To determine the user that is currently running the deploy, the capistrano tasks
 
 h2. Rails 3 Rake Task
 
+*APIv1 ONLY, use APIv1 Key*
+
 Send a message using a rake task:
 
 bc. rake hipchat:send["hello world"]
@@ -93,6 +132,23 @@ bc.. on_app_master do
   run "cd #{release_path} && bundle exec rake hipchat:send MESSAGE='#{message}'"
 end
 
+h2. Chef Handler
+
+*APIv1 ONLY, use APIv1 Key*
+
+Report on Chef runs. Within a Recipe:
+
+bc.. include_recipe 'chef_handler'
+  
+gem_package 'hipchat'
+
+chef_handler 'HipChat::NotifyRoom' do
+  action :enable
+  arguments ['API_KEY', 'HIPCHAT_ROOM']
+  source File.join(Gem.all_load_paths.grep(/hipchat/).first,
+                   'hipchat', 'chef.rb')
+end
+
 h2. Copyright
 
 Copyright (c) 2012 Atlassian. See LICENSE for details.

data/hipchat.gemspec

@@ -28,4 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "webmock"
   spec.add_development_dependency 'rdoc', '> 2.4.2'
+  spec.add_development_dependency 'coveralls'
 end

data/lib/hipchat.rb

@@ -3,6 +3,7 @@ require 'ostruct'
 
 require 'hipchat/railtie' if defined?(Rails::Railtie)
 require "hipchat/version"
+require 'hipchat/api_version'
 
 module HipChat
   class UnknownRoom         < StandardError; end
@@ -13,23 +14,23 @@ module HipChat
   class Client
     include HTTParty
 
-    base_uri 'https://api.hipchat.com/v1/rooms'
     format :json
 
     def initialize(token, options={})
       @token = token
-
+      @api_version = options[:api_version]
+      @api = HipChat::ApiVersion::Client.new(@api_version)
+      self.class.base_uri(@api.base_uri)
       http_proxy = options[:http_proxy] || ENV['http_proxy']
       setup_proxy(http_proxy) if http_proxy
     end
 
     def rooms
-      @rooms ||= self.class.get("/list", :query => {:auth_token => @token})['rooms'].
-        map { |r| Room.new(@token, r) }
+      @rooms ||= _rooms
     end
 
     def [](name)
-      Room.new(@token, :room_id => name)
+      Room.new(@token, :room_id => name, :api_version => @api_version)
     end
 
     private
@@ -41,16 +42,35 @@ module HipChat
       HipChat::Room.http_proxy(proxy_url.host, proxy_url.port,
                                proxy_url.user, proxy_url.password)
     end
+
+    def _rooms
+      response = self.class.get(@api.rooms_config[:url],
+        :query => {
+          :auth_token => @token
+        }, 
+        :headers => @api.headers
+      )
+      case response.code
+      when 200
+        response[@api.rooms_config[:data_key]].map do |r|
+          Room.new(@token, r.merge(:api_version => @api_version))
+        end
+      else
+        raise UnknownResponseCode, "Unexpected #{response.code} for room `#{room_id}'"
+      end
+    end
   end
 
   class Room < OpenStruct
     include HTTParty
 
-    base_uri 'https://api.hipchat.com/v1/rooms'
+    format   :json
 
     def initialize(token, params)
       @token = token
-
+      @api = HipChat::ApiVersion::Room.new(params[:room_id],
+                                           params.delete(:api_version))
+      self.class.base_uri(@api.base_uri)
       super(params)
     end
 
@@ -86,7 +106,7 @@ module HipChat
 
       options = { :color => 'yellow', :notify => false }.merge options
 
-      response = self.class.post('/message',
+      response = self.class.post(@api.send_config[:url],
         :query => { :auth_token => @token },
         :body  => {
           :room_id        => room_id,
@@ -94,12 +114,13 @@ module HipChat
           :message        => message,
           :message_format => options[:message_format] || 'html',
           :color          => options[:color],
-          :notify         => options[:notify] ? 1 : 0
-        }
+          :notify         => @api.bool_val(options[:notify])
+        }.send(@api.send_config[:body_format]),
+        :headers => @api.headers
       )
 
       case response.code
-      when 200; true
+      when 200, 204; true
       when 404
         raise UnknownRoom,  "Unknown room: `#{room_id}'"
       when 401
@@ -124,17 +145,18 @@ module HipChat
 
       options = { :from => 'API' }.merge options
 
-      response = self.class.post('/topic',
+      response = self.class.send(@api.topic_config[:method], @api.topic_config[:url],
         :query => { :auth_token => @token },
         :body  => {
           :room_id        => room_id,
           :from           => options[:from],
           :topic          => new_topic
-        }
+        }.send(@api.topic_config[:body_format]),
+        :headers => @api.headers
       )
 
       case response.code
-      when 200; true
+      when 204,200; true
       when 404
         raise UnknownRoom,  "Unknown room: `#{room_id}'"
       when 401
@@ -163,14 +185,15 @@ module HipChat
 
       options = { :date => 'recent', :timezone => 'UTC', :format => 'JSON' }.merge options
 
-      response = self.class.get('/history',
+      response = self.class.get(@api.history_config[:url],
         :query => {
           :room_id    => room_id,
           :date       => options[:date],
           :timezone   => options[:timezone],
           :format     => options[:format],
           :auth_token => @token,
-        }
+        },
+        :headers => @api.headers
       )
 
       case response.code

data/lib/hipchat/api_version.rb

@@ -0,0 +1,102 @@
+module HipChat
+  class ApiVersion
+
+    class Client
+
+      def initialize(version = 'v1')
+        @version = !version.nil? ? version : 'v1'
+        if @version.eql?('v1')
+          @base_uri = "https://api.hipchat.com/v1/rooms"
+          @headers = {'Accept' => 'application/json',
+             'Content-Type' => 'application/x-www-form-urlencoded'}
+        else
+          @base_uri = "https://api.hipchat.com/v2/room"
+          @headers = {'Accept' => 'application/json',
+             'Content-Type' => 'application/json'}
+        end
+      end
+
+      attr_reader :version, :base_uri, :headers
+
+      def rooms_config
+        {
+          'v1' => {
+            :url => '/list',
+            :data_key => 'rooms'
+          },
+          'v2' => {
+            :url => '/room',
+            :data_key => 'items'
+          }
+        }[version]
+      end
+    end
+
+    class Room
+
+      def initialize(room_id, version = 'v1')
+        @room_id = room_id
+        @version = !version.nil? ? version : 'v1'
+        if @version.eql?('v1')
+          @base_uri = "https://api.hipchat.com/v1/rooms"
+          @headers = {'Accept' => 'application/json',
+             'Content-Type' => 'application/x-www-form-urlencoded'}
+        else
+          @base_uri = "https://api.hipchat.com/v2/room"
+          @headers = {'Accept' => 'application/json',
+             'Content-Type' => 'application/json'}
+        end
+      end
+
+      attr_reader :version, :base_uri, :room_id, :headers
+
+      def send_config
+        {
+          'v1' => {
+            :url => "/message",
+            :body_format => :to_hash
+          },
+          'v2' => {
+            :url => "/#{room_id}/notification",
+            :body_format => :to_json
+          }
+        }[version]
+      end
+
+      def topic_config
+        {
+          'v1' => {
+            :url => '/topic',
+            :method => :post,
+            :body_format => :to_hash
+          },
+          'v2' => {
+            :url => "/#{room_id}/topic",
+            :method => :put,
+            :body_format => :to_json
+          }
+        }[version]
+      end
+
+      def history_config
+        {
+          'v1' => {
+            :url => '/history'
+          },
+          'v2' => {
+            :url => "/#{room_id}/history"
+          }
+        }[version]
+      end
+
+      def bool_val(opt)
+        if version.eql?('v1')
+          opt ? 1 : 0
+        else
+          opt
+        end
+      end
+
+    end
+  end
+end

data/lib/hipchat/capistrano.rb

@@ -1,131 +1,5 @@
-require 'hipchat'
-
-Capistrano::Configuration.instance(:must_exist).load do
-  set :hipchat_send_notification, false
-  set :hipchat_with_migrations, ''
-
-  namespace :hipchat do
-    task :trigger_notification do
-      set :hipchat_send_notification, true if !dry_run
-    end
-
-    task :configure_for_migrations do
-      set :hipchat_with_migrations, ' (with migrations)'
-    end
-
-    task :notify_deploy_started do
-      if hipchat_send_notification
-
-        environment_string = env
-        if self.respond_to?(:stage)
-          environment_string = "#{stage} (#{env})"
-        end
-
-        on_rollback do
-          send_options.merge!(:color => failed_message_color)
-          send("#{human} cancelled deployment of #{deployment_name} to #{environment_string}.", send_options)
-        end
-
-        send("#{human} is deploying #{deployment_name} to #{environment_string}#{fetch(:hipchat_with_migrations, '')}.", send_options)
-      end
-    end
-
-    task :notify_deploy_finished do
-      if hipchat_send_notification
-        send_options.merge!(:color => success_message_color)
-
-        environment_string = env
-        if self.respond_to?(:stage)
-          environment_string = "#{stage} (#{env})"
-        end
-
-        send("#{human} finished deploying #{deployment_name} to #{environment_string}#{fetch(:hipchat_with_migrations, '')}.", send_options)
-      end
-    end
-
-    def send_options
-      return @send_options if defined?(@send_options)
-      @send_options = message_format ? {:message_format => message_format } : {}
-      @send_options.merge!(:notify => message_notification)
-      @send_options.merge!(:color => message_color)
-      @send_options
-    end
-
-    def send(message, options)
-      set :hipchat_client, HipChat::Client.new(hipchat_token) if fetch(:hipchat_client, nil).nil?
-
-      if hipchat_room_name.is_a?(String)
-        rooms = [hipchat_room_name]
-      elsif hipchat_room_name.is_a?(Symbol)
-        rooms = [hipchat_room_name.to_s]
-      else
-        rooms = hipchat_room_name
-      end
-
-      rooms.each { |room|
-        begin
-          hipchat_client[room].send(deploy_user, message, options)
-        rescue => e
-          puts e.message
-          puts e.backtrace
-        end
-      }
-    end
-
-    def deployment_name
-      if fetch(:branch, nil)
-        name = "#{application}/#{branch}"
-        name += " (revision #{real_revision[0..7]})" if real_revision
-        name
-      else
-        application
-      end
-    end
-
-    def message_color
-      fetch(:hipchat_color, nil)
-    end
-
-    def success_message_color
-      fetch(:hipchat_success_color, "green")
-    end
-
-    def failed_message_color
-      fetch(:hipchat_failed_color, "red")
-    end
-
-    def message_notification
-      fetch(:hipchat_announce, false)
-    end
-
-    def message_format
-      fetch(:hipchat_message_format, "html")
-    end
-
-    def deploy_user
-      fetch(:hipchat_deploy_user, "Deploy")
-    end
-
-    def human
-      ENV['HIPCHAT_USER'] ||
-        fetch(:hipchat_human,
-              if (u = %x{git config user.name}.strip) != ""
-                u
-              elsif (u = ENV['USER']) != ""
-                u
-              else
-                "Someone"
-              end)
-    end
-
-    def env
-      fetch(:hipchat_env, fetch(:rack_env, fetch(:rails_env, "production")))
-    end
-  end
-
-  before "deploy", "hipchat:trigger_notification"
-  before "deploy:migrations", "hipchat:trigger_notification", "hipchat:configure_for_migrations"
-  before "deploy:update_code", "hipchat:notify_deploy_started"
-  after  "deploy", "hipchat:notify_deploy_finished"
-  after  "deploy:migrations", "hipchat:notify_deploy_finished"
-end
+if defined?(Capistrano::VERSION) && Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+  load File.expand_path('capistrano/tasks/hipchat.rake', File.dirname(__FILE__))
+else
+  require_relative 'capistrano2'
+end

data/lib/hipchat/capistrano/tasks/hipchat.rake

@@ -0,0 +1,111 @@
+require 'hipchat'
+
+namespace :hipchat do
+
+  task :notify_deploy_started do
+    send_message("#{human} is deploying #{deployment_name} to #{environment_name}.", send_options)
+  end
+
+  task :notify_deploy_finished do
+    send_options.merge!(:color => success_message_color)
+    send_message("#{human} finished deploying #{deployment_name} to #{environment_name}.", send_options)
+  end
+
+  task :notify_deploy_reverted do
+    send_options.merge!(:color => failed_message_color)
+    send_message("#{human} cancelled deployment of #{deployment_name} to #{environment_name}.", send_options)
+  end
+
+  def send_options
+    return @send_options if defined?(@send_options)
+    @send_options = message_format ? {:message_format => message_format } : {}
+    @send_options.merge!(:notify => message_notification)
+    @send_options.merge!(:color => message_color)
+    @send_options
+  end
+
+  def send_message(message, options)
+    hipchat_token = fetch(:hipchat_token)
+    hipchat_room_name = fetch(:hipchat_room_name)
+
+    hipchat_client = fetch(:hipchat_client, HipChat::Client.new(hipchat_token))
+
+    if hipchat_room_name.is_a?(String)
+      rooms = [hipchat_room_name]
+    elsif hipchat_room_name.is_a?(Symbol)
+      rooms = [hipchat_room_name.to_s]
+    else
+      rooms = hipchat_room_name
+    end
+
+    rooms.each { |room|
+      begin
+        hipchat_client[room].send(deploy_user, message, options)
+      rescue => e
+        puts e.message
+        puts e.backtrace
+      end
+    }
+  end
+
+  def deployment_name
+    if fetch(:branch, nil)
+      application = fetch(:application)
+      branch = fetch(:branch)
+      real_revision = fetch(:real_revision)
+
+      name = "#{application}/#{branch}"
+      name += " (revision #{real_revision[0..7]})" if real_revision
+      name
+    else
+      application
+    end
+  end
+
+  def message_color
+    fetch(:hipchat_color)
+  end
+
+  def success_message_color
+    fetch(:hipchat_success_color, 'green')
+  end
+
+  def failed_message_color
+    fetch(:hipchat_failed_color, 'red')
+  end
+
+  def message_notification
+    fetch(:hipchat_announce, false)
+  end
+
+  def message_format
+    fetch(:hipchat_message_format, 'html')
+  end
+
+  def deploy_user
+    fetch(:hipchat_deploy_user, 'Deploy')
+  end
+
+  def human
+    user = ENV['HIPCHAT_USER'] || fetch(:hipchat_human)
+    user = user || if (u = %x{git config user.name}.strip) != ''
+                     u
+                   elsif (u = ENV['USER']) != ''
+                     u
+                   else
+                     'Someone'
+                   end
+    user
+  end
+
+  def environment_name
+    fetch(:hipchat_env, fetch(:rack_env, fetch(:rails_env, fetch(:stage))))
+  end
+
+  before 'deploy:starting', :notify_deploy_started
+  after 'deploy:finished', :notify_deploy_finished
+  if Rake::Task.task_defined? 'deploy:failed'
+    after 'deploy:failed', :notify_deploy_reverted
+  end
+
+end

data/lib/hipchat/capistrano2.rb

@@ -0,0 +1,131 @@
+require 'hipchat'
+
+Capistrano::Configuration.instance(:must_exist).load do
+  set :hipchat_send_notification, false
+  set :hipchat_with_migrations, ''
+
+  namespace :hipchat do
+    task :trigger_notification do
+      set :hipchat_send_notification, true if !dry_run
+    end
+
+    task :configure_for_migrations do
+      set :hipchat_with_migrations, ' (with migrations)'
+    end
+
+    task :notify_deploy_started do
+      if hipchat_send_notification
+
+        environment_string = env
+        if self.respond_to?(:stage)
+          environment_string = "#{stage} (#{env})"
+        end
+
+        on_rollback do
+          send_options.merge!(:color => failed_message_color)
+          send("#{human} cancelled deployment of #{deployment_name} to #{environment_string}.", send_options)
+        end
+
+        send("#{human} is deploying #{deployment_name} to #{environment_string}#{fetch(:hipchat_with_migrations, '')}.", send_options)
+      end
+    end
+
+    task :notify_deploy_finished do
+      if hipchat_send_notification
+        send_options.merge!(:color => success_message_color)
+
+        environment_string = env
+        if self.respond_to?(:stage)
+          environment_string = "#{stage} (#{env})"
+        end
+
+        send("#{human} finished deploying #{deployment_name} to #{environment_string}#{fetch(:hipchat_with_migrations, '')}.", send_options)
+      end
+    end
+
+    def send_options
+      return @send_options if defined?(@send_options)
+      @send_options = message_format ? {:message_format => message_format } : {}
+      @send_options.merge!(:notify => message_notification)
+      @send_options.merge!(:color => message_color)
+      @send_options
+    end
+
+    def send(message, options)
+      set :hipchat_client, HipChat::Client.new(hipchat_token) if fetch(:hipchat_client, nil).nil?
+
+      if hipchat_room_name.is_a?(String)
+        rooms = [hipchat_room_name]
+      elsif hipchat_room_name.is_a?(Symbol)
+        rooms = [hipchat_room_name.to_s]
+      else
+        rooms = hipchat_room_name
+      end
+
+      rooms.each { |room|
+        begin
+          hipchat_client[room].send(deploy_user, message, options)
+        rescue => e
+          puts e.message
+          puts e.backtrace
+        end
+      }
+    end
+
+    def deployment_name
+      if fetch(:branch, nil)
+        name = "#{application}/#{branch}"
+        name += " (revision #{real_revision[0..7]})" if real_revision
+        name
+      else
+        application
+      end
+    end
+
+    def message_color
+      fetch(:hipchat_color, nil)
+    end
+
+    def success_message_color
+      fetch(:hipchat_success_color, "green")
+    end
+
+    def failed_message_color
+      fetch(:hipchat_failed_color, "red")
+    end
+
+    def message_notification
+      fetch(:hipchat_announce, false)
+    end
+
+    def message_format
+      fetch(:hipchat_message_format, "html")
+    end
+
+    def deploy_user
+      fetch(:hipchat_deploy_user, "Deploy")
+    end
+
+    def human
+      ENV['HIPCHAT_USER'] ||
+        fetch(:hipchat_human,
+              if (u = %x{git config user.name}.strip) != ""
+                u
+              elsif (u = ENV['USER']) != ""
+                u
+              else
+                "Someone"
+              end)
+    end
+
+    def env
+      fetch(:hipchat_env, fetch(:rack_env, fetch(:rails_env, "production")))
+    end
+  end
+
+  before "deploy", "hipchat:trigger_notification"
+  before "deploy:migrations", "hipchat:trigger_notification", "hipchat:configure_for_migrations"
+  before "deploy:update_code", "hipchat:notify_deploy_started"
+  after  "deploy", "hipchat:notify_deploy_finished"
+  after  "deploy:migrations", "hipchat:notify_deploy_finished"
+end

data/lib/hipchat/rails3_tasks.rb

@@ -12,7 +12,8 @@ namespace :hipchat do
       :user           => ENV['HIPCHAT_USER'],
       :notify         => ENV['NOTIFY'],
       :room           => ENV['ROOM'],
-      :token          => ENV['TOKEN']
+      :token          => ENV['TOKEN'],
+      :api_version    => ENV['API_VERSION']
     }.reject { |k, v| v.blank? }
 
     system_options = {
@@ -37,7 +38,7 @@ namespace :hipchat do
       exit
     end
 
-    client = HipChat::Client.new(options[:token])
+    client = HipChat::Client.new(options[:token], options)
 
     client[options[:room]].send(options[:user], options[:message], :notify => options[:notify])
   end

data/lib/hipchat/version.rb

@@ -1,3 +1,3 @@
 module HipChat
-  VERSION = "0.14.0"
+  VERSION = "1.0.0"
 end

data/spec/hipchat_spec.rb

@@ -1,47 +1,10 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/shared_hipchat')
 
 describe HipChat do
-  subject { HipChat::Client.new("blah") }
-
-  let(:room) { subject["Hipchat"] }
-
-  # Helper for mocking room message post requests
-  def mock_successful_send(from, message, options={})
-    options = {:color => 'yellow', :notify => 0, :message_format => 'html'}.merge(options)
-    mock(HipChat::Room).post("/message",
-                             :query => {:auth_token => "blah"},
-                             :body  => {:room_id => "Hipchat",
-                                        :from    => "Dude",
-                                        :message => "Hello world",
-                                        :message_format => options[:message_format],
-                                        :color   => options[:color],
-                                        :notify  => options[:notify]}) {
-      OpenStruct.new(:code => 200)
-    }
-  end
-
-  def mock_successful_topic_change(topic, options={})
-    options = {:from => 'API'}.merge(options)
-    mock(HipChat::Room).post("/topic",
-                             :query => {:auth_token => "blah"},
-                             :body  => {:room_id => "Hipchat",
-                                        :from    => options[:from],
-                                        :topic   => "Nice topic" } ) {
-      OpenStruct.new(:code => 200)
-    }
-  end
-
-  def mock_successful_history(options={})
-    options = { :date => 'recent', :timezone => 'UTC', :format => 'JSON' }.merge(options)
-    canned_response = File.new File.expand_path(File.dirname(__FILE__) + '/example/history.json')
-    stub_request(:get, "https://api.hipchat.com/v1/rooms/history").with(:query => {:auth_token => "blah",
-                                   :room_id    => "Hipchat",
-                                   :date       => options[:date],
-                                   :timezone   => options[:timezone],
-                                   :format     => options[:format]}).to_return(canned_response)
-  end
 
-  describe "#history" do
+  describe "#history (API V1)" do
+    include_context "HipChatV1"
     it "is successful without custom options" do
       mock_successful_history()
 
@@ -79,7 +42,8 @@ describe HipChat do
     end
   end
 
-  describe "#topic" do
+  describe "#topic (API V1)" do
+    include_context "HipChatV1"
     it "is successful without custom options" do
       mock_successful_topic_change("Nice topic")
 
@@ -118,7 +82,8 @@ describe HipChat do
     end
   end
 
-  describe "sends a message to a room" do
+  describe "sends a message to a room (API V1)" do
+    include_context "HipChatV1"
     it "successfully without custom options" do
       mock_successful_send 'Dude', 'Hello world'
 
@@ -128,6 +93,141 @@ describe HipChat do
     it "successfully with notifications on as option" do
       mock_successful_send 'Dude', 'Hello world', :notify => 1
 
+      room.send("Dude", "Hello world", :notify => 1).should be_true
+    end
+
+    it "successfully with custom color" do
+      mock_successful_send 'Dude', 'Hello world', :color => 'red'
+
+      room.send("Dude", "Hello world", :color => 'red').should be_true
+    end
+
+    it "successfully with text message_format" do
+      mock_successful_send 'Dude', 'Hello world', :message_format => 'text'
+
+      room.send("Dude", "Hello world", :message_format => 'text').should be_true
+    end
+
+    it "but fails when the room doesn't exist" do
+      mock(HipChat::Room).post(anything, anything) {
+        OpenStruct.new(:code => 404)
+      }
+
+      lambda { room.send "", "" }.should raise_error(HipChat::UnknownRoom)
+    end
+
+    it "but fails when we're not allowed to do so" do
+      mock(HipChat::Room).post(anything, anything) {
+        OpenStruct.new(:code => 401)
+      }
+
+      lambda { room.send "", "" }.should raise_error(HipChat::Unauthorized)
+    end
+
+    it "but fails if the username is more than 15 chars" do
+      lambda { room.send "a very long username here", "a message" }.should raise_error(HipChat::UsernameTooLong)
+    end
+
+    it "but fails if we get an unknown response code" do
+      mock(HipChat::Room).post(anything, anything) {
+        OpenStruct.new(:code => 403)
+      }
+
+      lambda { room.send "", "" }.
+        should raise_error(HipChat::UnknownResponseCode)
+    end
+  end
+
+  describe "#history (API v2)" do
+    include_context "HipChatV2"
+    it "is successful without custom options" do
+      mock_successful_history()
+
+      room.history().should be_true
+    end
+
+    it "is successful with custom options" do
+      mock_successful_history(:timezone => 'America/Los_Angeles', :date => '2010-11-19')
+      room.history(:timezone => 'America/Los_Angeles', :date => '2010-11-19').should be_true
+    end
+
+    it "fails when the room doen't exist" do
+      mock(HipChat::Room).get(anything, anything) {
+        OpenStruct.new(:code => 404)
+      }
+
+      lambda { room.history }.should raise_error(HipChat::UnknownRoom)
+    end
+
+    it "fails when we're not allowed to do so" do
+      mock(HipChat::Room).get(anything, anything) {
+        OpenStruct.new(:code => 401)
+      }
+
+      lambda { room.history }.should raise_error(HipChat::Unauthorized)
+    end
+
+    it "fails if we get an unknown response code" do
+      mock(HipChat::Room).get(anything, anything) {
+        OpenStruct.new(:code => 403)
+      }
+
+      lambda { room.history }.
+        should raise_error(HipChat::UnknownResponseCode)
+    end
+  end
+
+  describe "#topic (API v2)" do
+    include_context "HipChatV2"
+    it "is successful without custom options" do
+      mock_successful_topic_change("Nice topic")
+
+      room.topic("Nice topic").should be_true
+    end
+
+    it "is successful with a custom from" do
+      mock_successful_topic_change("Nice topic", :from => "Me")
+
+      room.topic("Nice topic", :from => "Me").should be_true
+    end
+
+    it "fails when the room doesn't exist" do
+      mock(HipChat::Room).put(anything, anything) {
+        OpenStruct.new(:code => 404)
+      }
+
+      lambda { room.topic "" }.should raise_error(HipChat::UnknownRoom)
+    end
+
+    it "fails when we're not allowed to do so" do
+        mock(HipChat::Room).put(anything, anything) {
+          OpenStruct.new(:code => 401)
+        }
+
+      lambda { room.topic "" }.should raise_error(HipChat::Unauthorized)
+    end
+
+    it "fails if we get an unknown response code" do
+        mock(HipChat::Room).put(anything, anything) {
+          OpenStruct.new(:code => 403)
+        }
+
+      lambda { room.topic "" }.
+        should raise_error(HipChat::UnknownResponseCode)
+    end
+  end
+
+  describe "sends a message to a room (API V2)" do
+    include_context "HipChatV2"
+    it "successfully without custom options" do
+      mock_successful_send 'Dude', 'Hello world'
+
+      room.send("Dude", "Hello world").should be_true
+    end
+
+    it "successfully with notifications on as option" do
+      mock_successful_send 'Dude', 'Hello world', :notify => true
+
       room.send("Dude", "Hello world", :notify => true).should be_true
     end
 

data/spec/shared_hipchat.rb

@@ -0,0 +1,82 @@
+shared_context "HipChatV1" do
+  before { @api_version = 'v1'}
+  # Helper for mocking room message post requests
+  def mock_successful_send(from, message, options={})
+    options = {:color => 'yellow', :notify => 0, :message_format => 'html'}.merge(options)
+    stub_request(:post, "https://api.hipchat.com/v1/rooms/message").with(
+                             :query => {:auth_token => "blah"},
+                             :body  => {:room_id => "Hipchat",
+                                        :from    => "Dude",
+                                        :message => "Hello world",
+                                        :message_format => options[:message_format],
+                                        :color   => options[:color],
+                                        :notify  => "#{options[:notify]}"},
+                              :headers => {'Accept' => 'application/json',
+                                          'Content-Type' => 'application/x-www-form-urlencoded'}).to_return(:status => 200, :body => "", :headers => {})
+
+  end
+
+  def mock_successful_topic_change(topic, options={})
+    options = {:from => 'API'}.merge(options)
+    stub_request(:post, "https://api.hipchat.com/v1/rooms/topic").with(
+                             :query => {:auth_token => "blah"},
+                             :body  => {:room_id => "Hipchat",
+                                        :from    => options[:from],
+                                        :topic   => "Nice topic" },
+                              :headers => {'Accept' => 'application/json',
+                                          'Content-Type' => 'application/x-www-form-urlencoded'}).to_return(:status => 200, :body => "", :headers => {})
+  end
+
+  def mock_successful_history(options={})
+    options = { :date => 'recent', :timezone => 'UTC', :format => 'JSON' }.merge(options)
+    canned_response = File.new File.expand_path(File.dirname(__FILE__) + '/example/history.json')
+    stub_request(:get, "https://api.hipchat.com/v1/rooms/history").with(:query => {:auth_token => "blah",
+                                   :room_id    => "Hipchat",
+                                   :date       => options[:date],
+                                   :timezone   => options[:timezone],
+                                   :format     => options[:format]}).to_return(canned_response)
+  end
+  subject { HipChat::Client.new("blah", :api_version => @api_version) }
+  let(:room) { subject["Hipchat"] }
+end
+
+shared_context "HipChatV2" do
+  before { @api_version = 'v2'}
+  # Helper for mocking room message post requests
+  def mock_successful_send(from, message, options={})
+    options = {:color => 'yellow', :notify => false, :message_format => 'html'}.merge(options)
+    stub_request(:post, "https://api.hipchat.com/v2/room/Hipchat/notification").with(
+                             :query => {:auth_token => "blah"},
+                             :body  => {:room_id => "Hipchat",
+                                        :from    => "Dude",
+                                        :message => "Hello world",
+                                        :message_format => options[:message_format],
+                                        :color   => options[:color],
+                                        :notify  => options[:notify]}.to_json,
+                                        :headers => {'Accept' => 'application/json',
+                                                    'Content-Type' => 'application/json'}).to_return(:status => 200, :body => "", :headers => {}) 
+  end
+
+  def mock_successful_topic_change(topic, options={})
+    options = {:from => 'API'}.merge(options)
+    stub_request(:put, "https://api.hipchat.com/v2/room/Hipchat/topic").with(
+                             :query => {:auth_token => "blah"},
+                             :body  => {:room_id => "Hipchat",
+                                        :from    => options[:from],
+                                        :topic   => "Nice topic" }.to_json,
+                                        :headers => {'Accept' => 'application/json',
+                                                    'Content-Type' => 'application/json'}).to_return(:status => 200, :body => "", :headers => {})
+  end
+
+  def mock_successful_history(options={})
+    options = { :date => 'recent', :timezone => 'UTC', :format => 'JSON' }.merge(options)
+    canned_response = File.new File.expand_path(File.dirname(__FILE__) + '/example/history.json')
+    stub_request(:get, "https://api.hipchat.com/v2/room/Hipchat/history").with(:query => {:auth_token => "blah",
+                                   :room_id    => "Hipchat",
+                                   :date       => options[:date],
+                                   :timezone   => options[:timezone],
+                                   :format     => options[:format]}).to_return(canned_response)
+  end
+  subject { HipChat::Client.new("blah", :api_version => @api_version) }
+  let(:room) { subject["Hipchat"] }
+end

data/spec/spec_helper.rb

@@ -4,6 +4,9 @@ require 'hipchat'
 require 'rspec'
 require 'rspec/autorun'
 require 'webmock/rspec'
+require 'coveralls'
+
+Coveralls.wear!
 
 RSpec.configure do |config|
   config.mock_with :rr

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hipchat
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 1.0.0
 platform: ruby
 authors:
 - HipChat/Atlassian
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-24 00:00:00.000000000 Z
+date: 2013-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -108,6 +108,20 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: 2.4.2
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby library to interact with HipChat
 email:
 - support@hipchat.com
@@ -124,13 +138,17 @@ files:
 - Rakefile
 - hipchat.gemspec
 - lib/hipchat.rb
+- lib/hipchat/api_version.rb
 - lib/hipchat/capistrano.rb
+- lib/hipchat/capistrano/tasks/hipchat.rake
+- lib/hipchat/capistrano2.rb
 - lib/hipchat/chef.rb
 - lib/hipchat/rails3_tasks.rb
 - lib/hipchat/railtie.rb
 - lib/hipchat/version.rb
 - spec/example/history.json
 - spec/hipchat_spec.rb
+- spec/shared_hipchat.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 homepage: https://github.com/hipchat/hipchat-rb
@@ -160,6 +178,7 @@ summary: Ruby library to interact with HipChat
 test_files:
 - spec/example/history.json
 - spec/hipchat_spec.rb
+- spec/shared_hipchat.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: