hipchat 1.0.1 → 1.1.0

data/lib/hipchat/client.rb

@@ -0,0 +1,111 @@
+require 'hipchat/api_version'
+
+module HipChat
+
+  class Client
+    include HTTParty
+
+    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 ||= _rooms
+    end
+
+    def [](name)
+      Room.new(@token, :room_id => name, :api_version => @api_version)
+    end
+
+    def create_room(name, options={})
+      if @api.version == 'v1' && options[:owner_user_id].nil?
+        raise RoomMissingOwnerUserId, "V1 API Requres owner_user_id"
+      end
+
+      if name.length > 50
+        raise RoomNameTooLong, "Room name #{name} is #{name.length} characters long. Limit is 50."
+      end
+      unless options[:guest_access].nil?
+        options[:guest_access] = @api.bool_val(options[:guest_access])
+      end
+      
+      response = self.class.post(@api.create_room_config[:url],
+        :query => { :auth_token => @token },
+        :body => {
+          :name => name
+          }.merge(options).send(@api.create_room_config[:body_format]),
+        :headers => @api.headers
+      )
+
+      case response.code
+      when 201, 200 #CREATED
+        response.parsed_response
+      when 400
+        raise UnknownRoom,  "Error: #{response.message}"
+      when 401
+        raise Unauthorized, "Access denied"
+      else
+        raise UnknownResponseCode, "Unexpected error #{response.code}"
+      end
+    end
+
+    def user(name)
+      User.new(@token, :user_id => name, :api_version => @api_version)
+    end
+
+    def users
+      @users ||= _users
+    end
+
+    private
+    def setup_proxy(proxy_url)
+      proxy_url = URI.parse(proxy_url)
+
+      self.class.http_proxy(proxy_url.host, proxy_url.port,
+                            proxy_url.user, proxy_url.password)
+      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, :room_id => r['id']))
+        end
+      else
+        raise UnknownResponseCode, "Unexpected #{response.code} for room"
+      end
+    end
+
+    def _users
+      response = self.class.get(@api.users_config[:url],
+        :query => {
+          :auth_token => @token
+        },
+        :headers => @api.headers
+      )
+      case response.code
+      when 200
+        response[@api.users_config[:data_key]].map do |r|
+          Room.new(@token, r.merge(:api_version => @api_version, :user_id => r['id']))
+        end
+      else
+        raise UnknownResponseCode, "Unexpected #{response.code} for room"
+      end
+    end    
+  end
+end

data/lib/hipchat/errors.rb

@@ -0,0 +1,10 @@
+module HipChat
+  class UnknownRoom         < StandardError; end
+  class RoomNameTooLong     < StandardError; end
+  class RoomMissingOwnerUserId < StandardError; end
+  class Unauthorized        < StandardError; end
+  class UsernameTooLong     < StandardError; end
+  class UnknownResponseCode < StandardError; end
+  class UnknownUser         < StandardError; end
+  class InvalidApiVersion   < StandardError; end
+end

data/lib/hipchat/rails3_tasks.rb

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

data/lib/hipchat/room.rb

@@ -0,0 +1,193 @@
+require 'httparty'
+require 'ostruct'
+
+module HipChat
+
+  class Room < OpenStruct
+    include HTTParty
+
+    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
+
+    # Retrieve data for this room
+    def get_room
+      response = self.class.get(@api.get_room_config[:url],
+        :query => {:auth_token => @token },
+        :headers => @api.headers
+      )
+
+      case response.code
+      when 200
+        response.parsed_response
+      when 404
+        raise UnknownRoom,  "Unknown room: `#{room_id}'"
+      when 401
+        raise Unauthorized, "Access denied to room `#{room_id}'"
+      else
+        raise UnknownResponseCode, "Unexpected #{response.code} for room `#{room_id}'"
+      end
+    end
+
+    # Invite user to this room
+    def invite(user, reason="")
+      response = self.class.post(@api.invite_config[:url]+"/#{user}",
+        :query => { :auth_token => @token },
+        :body => {
+          :reason => reason
+        }.to_json,
+        :headers => @api.headers)
+
+      case response.code
+      when 200, 204; true
+      when 404
+        raise UnknownRoom,  "Unknown room: `#{room_id}'"
+      when 401
+        raise Unauthorized, "Access denied to room `#{room_id}'"
+      else
+        raise UnknownResponseCode, "Unexpected #{response.code} for room `#{room_id}'"
+      end
+    end
+
+
+    # Send a message to this room.
+    #
+    # Usage:
+    #
+    #   # Default
+    #   send 'nickname', 'some message'
+    #
+    #   # Notify users and color the message red
+    #   send 'nickname', 'some message', :notify => true, :color => 'red'
+    #
+    #   # Notify users (deprecated)
+    #   send 'nickname', 'some message', true
+    #
+    # Options:
+    #
+    # +color+::  "yellow", "red", "green", "purple", or "random"
+    #            (default "yellow")
+    # +notify+:: true or false
+    #            (default false)
+    def send(from, message, options_or_notify = {})
+      if from.length > 15
+        raise UsernameTooLong, "Username #{from} is `#{from.length} characters long. Limit is 15'"
+      end
+      options = if options_or_notify == true or options_or_notify == false
+        warn "DEPRECATED: Specify notify flag as an option (e.g., :notify => true)"
+        { :notify => options_or_notify }
+      else
+        options_or_notify || {}
+      end
+
+      options = { :color => 'yellow', :notify => false }.merge options
+
+      response = self.class.post(@api.send_config[:url],
+        :query => { :auth_token => @token },
+        :body  => {
+          :room_id        => room_id,
+          :from           => from,
+          :message        => message,
+          :message_format => options[:message_format] || 'html',
+          :color          => options[:color],
+          :notify         => @api.bool_val(options[:notify])
+        }.send(@api.send_config[:body_format]),
+        :headers => @api.headers
+      )
+
+      case response.code
+      when 200, 204; true
+      when 404
+        raise UnknownRoom,  "Unknown room: `#{room_id}'"
+      when 401
+        raise Unauthorized, "Access denied to room `#{room_id}'"
+      else
+        raise UnknownResponseCode, "Unexpected #{response.code} for room `#{room_id}'"
+      end
+    end
+
+    # Change this room's topic
+    #
+    # Usage:
+    #
+    #   # Default
+    #   topic 'my awesome topic'
+    #
+    # Options:
+    #
+    # +from+::  the name of the person changing the topic
+    #            (default "API")
+    def topic(new_topic, options = {})
+
+      options = { :from => 'API' }.merge options
+
+      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 204,200; true
+      when 404
+        raise UnknownRoom,  "Unknown room: `#{room_id}'"
+      when 401
+        raise Unauthorized, "Access denied to room `#{room_id}'"
+      else
+        raise UnknownResponseCode, "Unexpected #{response.code} for room `#{room_id}'"
+      end
+    end
+
+    # Pull this room's history
+    #
+    # Usage
+    #
+    #   # Default
+    #
+    #
+    # Options
+    #
+    # +date+::     Whether to return a specific day (YYYY-MM-DD format) or recent
+    #                (default "recent")
+    # +timezone+:: Your timezone.  Supported timezones are at: https://www.hipchat.com/docs/api/timezones
+    #                (default "UTC")
+    # +format+::   Format to retrieve the history in.  Valid options are JSON and XML
+    #                (default "JSON")
+    def history(options = {})
+
+      options = { :date => 'recent', :timezone => 'UTC', :format => 'JSON' }.merge options
+
+      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
+      when 200
+        response.body
+      when 404
+        raise UnknownRoom,  "Unknown room: `#{room_id}'"
+      when 401
+        raise Unauthorized, "Access denied to room `#{room_id}'"
+      else
+        raise UnknownResponseCode, "Unexpected #{response.code} for room `#{room_id}'"
+      end
+    end
+  end
+end

data/lib/hipchat/user.rb

@@ -0,0 +1,62 @@
+require 'httparty'
+require 'ostruct'
+
+module HipChat
+
+  class User < OpenStruct
+    include HTTParty
+
+    format   :json
+
+    def initialize(token, params)
+      @token = token
+      @api = HipChat::ApiVersion::User.new(params[:user_id],
+                                           params.delete(:api_version))
+      self.class.base_uri(@api.base_uri)
+      super(params)
+    end
+
+    #
+    # Send a private message to user.
+    #
+    def send(message)
+      response = self.class.post(@api.send_config[:url],
+        :query => { :auth_token => @token },
+        :body  => {
+          :message => message
+        }.send(@api.send_config[:body_format]),
+        :headers => @api.headers
+      )
+
+      case response.code
+      when 200, 204; true
+      when 404
+        raise UnknownUser,  "Unknown user: `#{user_id}'"
+      when 401
+        raise Unauthorized, "Access denied to user `#{user_id}'"
+      else
+        raise UnknownResponseCode, "Unexpected #{response.code} for private message to `#{user_id}'"
+      end
+    end
+    
+    #
+    # Get a user's details.
+    #
+    def view
+      puts "#{@api.base_uri}#{@api.view_config[:url]}"
+      response = self.class.post(@api.view_config[:url],
+        :query => { :auth_token => @token },
+        :headers => @api.headers
+      )
+
+      case response.code
+      when 200
+        response[@api.users_config[:data_key]].map do |r|
+          User.new(@token, r.merge(:api_version => @api_version))
+        end
+      else
+        raise UnknownResponseCode, "Unexpected #{response.code} for view message to `#{user_id}'"
+      end
+    end
+  end
+end

data/lib/hipchat/version.rb

@@ -1,3 +1,3 @@
 module HipChat
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/spec/hipchat_api_v1_spec.rb

@@ -0,0 +1,172 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "HipChat (API V1)" do
+
+  subject { HipChat::Client.new("blah", :api_version => @api_version) }
+
+  let(:room) { subject["Hipchat"] }
+
+  describe "#history" do
+    include_context "HipChatV1"
+    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" do
+    include_context "HipChatV1"
+    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).post(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).post(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).post(anything, anything) {
+        OpenStruct.new(:code => 403)
+      }
+
+      lambda { room.topic "" }.
+        should raise_error(HipChat::UnknownResponseCode)
+    end
+  end
+
+  describe "#send" do
+    include_context "HipChatV1"
+    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 => 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 "#create" do
+    include_context "HipChatV1"
+
+    it "successfully with room name" do
+      mock_successful_room_creation("A Room", :owner_user_id => "123456")
+
+      subject.create_room("A Room", {:owner_user_id => "123456"}).should be_true
+    end
+
+    it "successfully with custom parameters" do
+      mock_successful_room_creation("A Room", {:owner_user_id => "123456", :privacy => "private", :guest_access => "1"})
+
+      subject.create_room("A Room", {:owner_user_id => "123456", :privacy => "private", :guest_access =>true}).should be_true
+    end
+
+    it "but fails if we dont pass owner_user_id" do
+      lambda { subject.create_room("A Room", {:privacy => "private", :guest_access =>true}) }.
+        should raise_error(HipChat::RoomMissingOwnerUserId)
+    end
+  end
+
+  describe "#send user message" do
+    it "fails because API V1 doesn't support user operations" do
+
+      lambda { HipChat::Client.new("blah", :api_version => @api_version).user('12345678') }.
+        should raise_error(HipChat::InvalidApiVersion)
+    end
+  end
+end