flowdock 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: add821dc4a38cf06e2c3f714696a492b4d33c662
-  data.tar.gz: f7e1b06102bacda9ce5ae06d07e89780fca71091
+  metadata.gz: 2e8c2164455898ff017ff0cbe2a0fe9c0615de15
+  data.tar.gz: 67af9f77904b26d42864b709d1a8ed112bc4009c
 SHA512:
-  metadata.gz: c297de7187f02165ae0f3293b749b71e3950c4c3c7f51c0826c1508e864962e9fc46e368590f83d277c73ec8cef886bf0116b423474949a7369fad8ebffabf77
-  data.tar.gz: fa3bf91e94f7ae7f8367f18c9dee67e966e27d95548ed9670f51126ff2b13b6af299899b031154f8bb56b7808c688e9749ece4402436311222bbdde4487c3bb1
+  metadata.gz: 20cf692d3e6f09405972d71b9888fd60c3eac5e27978a63c545f4e9d2ac782e390a33cf8773be14d5592d498f079557b92d195178c8d078711cf56c3469723a7
+  data.tar.gz: fea63857c0f2130a68f79f634a9c17feba1b46022efe437adb383499d14136aad8cb421d5e2c71ca103f0e83b2a7a9b9b59606b16f9d8a89dc183be1ebc47681

data/.travis.yml

@@ -1,3 +1,5 @@
 rvm:
-  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
   - jruby

data/README.md

@@ -1,12 +1,12 @@
 # Flowdock
 
-Ruby Gem for using the Flowdock Push API. See [Push API documentation](http://www.flowdock.com/api/push) for details.
+Ruby gem for using the Flowdock Push API. See the [Push API documentation](http://www.flowdock.com/api/push) for details.
 
 ## Build Status
 
 [![Build Status](https://secure.travis-ci.org/flowdock/flowdock-api.png)](http://travis-ci.org/flowdock/flowdock-api)
 
-flowdock gem is tested on Ruby 1.9.3 and JRuby.
+The Flowdock gem is tested on Ruby 2.1 and JRuby.
 
 ## Dependencies
 
@@ -17,47 +17,78 @@ flowdock gem is tested on Ruby 1.9.3 and JRuby.
 
     gem install flowdock
 
-If you're using JRuby, you'll also need to install jruby-openssl gem.
+If you're using JRuby, you'll also need to install the `jruby-openssl` gem.
 
 ## Usage
 
-To post content to Chat or Team Inbox using `Flowdock::Flow`, you need to use the target flow's API token.
+To post content to a flow's chat or team inbox using `Flowdock::Flow`, you need to use the target flow's API token or a source's flow_token.
 
-Alternatively you can use your personal api token and the `Flowdock::Client`.
+Alternatively, you can use your personal API token and the `Flowdock::Client`.
 
-All tokens can be found in [tokens page](https://www.flowdock.com/account/tokens).
+Personal and flow's tokens can be found on the [tokens page](https://www.flowdock.com/account/tokens).
 
 ### REST API
 
-To create an api client you need your personal api token:
+To create an API client, you need your personal [API token](https://flowdock.com/account/tokens), an [OAuth token](https://www.flowdock.com/api/authentication) or a [source's flow_token](https://www.flowdock.com/api/sources).
+
+Note that a `flow_token` will only allow you to post [thread messages](https://www.flowdock.com/api/production-integrations#/post-inbox) to the flow that the source belongs to.
 
 ```ruby
 require 'rubygems'
 require 'flowdock'
 
-# Create a client that uses you api token to authenticate
-client = Flowdock::Client.new(api_token: '__MY_PERSONAL_API_TOKEN__')
+# Create a client that uses your personal API token to authenticate
+api_token_client = Flowdock::Client.new(api_token: '__MY_PERSONAL_API_TOKEN__')
+
+# Create a client that uses a source's flow_token to authenticate. Can only use post_to_thread
+flow_token_client = Flowdock::Client.new(flow_token: '__FLOW_TOKEN__')
 ```
 
 #### Posting to Chat
 
-To send a chat message or comment, you can use the client.chat_message:
+To send a chat message or comment, you can use `client.chat_message`:
 
 ```ruby
 flow_id = 'acdcabbacd0123456789'
 
 # Send a simple chat message
-client.chat_message(flow: flow_id, content: "I'm sending a message!", tags: ['foo', 'bar'])
+api_token_client.chat_message(flow: flow_id, content: "I'm sending a message!", tags: ['foo', 'bar'])
 
 # Send a comment to message 1234
-client.chat_message(flow: flow_id, content: "Now I'm commenting!", message: 1234)
+api_token_client.chat_message(flow: flow_id, content: "Now I'm commenting!", message: 1234)
 ```
 
 Both methods return the created message as a hash.
 
-#### Arbitary api access
+#### Post a threaded messages
+
+You can post `activity` and `discussion` events to a [threaded conversation](https://www.flowdock.com/api/integration-getting-started) in Flowdock.
+
+```
+flow_token_client.post_to_thread(
+    event: "activity",
+    author: {
+        name: "anttipitkanen",
+        avatar: "https://avatars.githubusercontent.com/u/946511?v=2",
+    },
+    title: "activity title",
+    external_thread_id: "your-id-here",
+    thread: {
+        title: "this is required if you provide a thread field at all",
+        body: "<p>some html content</p>",
+        external_url: "https://example.com/issue/123",
+        status: {
+            color: "green",
+            value: "open"
+        }
+    }
+}
+```
 
-You can use the client to access api in other ways too. See [REST API documentation](http://www.flowdock.com/api/rest) for all the resources.
+
+#### Arbitary API access
+
+You can use the client to access the Flowdock API in other ways, too. See the [REST API documentation](http://www.flowdock.com/api/rest) for all the resources.
 
 ```ruby
 
@@ -75,32 +106,34 @@ client.post('/flows/acme/my_flow/invitations', email: 'user@example.com', messag
 
 ```
 
-### Push api
+### Push API
 
-To use the push api, you need a flow token:
+**Note:** the Push API is in the process of being deprecated. [Creating a source](https://www.flowdock.com/api/integration-getting-started) along with a flow_token is recommended instead.
 
-#### Posting to Chat
+To use the Push API, you need the flow's API token:
+
+#### Posting to the chat
 
 ```ruby
 require 'rubygems'
 require 'flowdock'
 
-# create a new Flow object with target flow's api token and external user name (enough for posting to Chat)
-flow = Flowdock::Flow.new(:api_token => "__FLOW_TOKEN__", :external_user_name => "John")
+# create a new Flow object with target flow's API token and external user name (enough for posting to the chat)
+flow = Flowdock::Flow.new(:api_token => "__FLOW_API_TOKEN__", :external_user_name => "John")
 
 # send message to Chat
 flow.push_to_chat(:content => "Hello!", :tags => ["cool", "stuff"])
 ```
 
-#### Posting to Team Inbox
+#### Posting to the team inbox
 
 ```ruby
-# create a new Flow object with target flow's api token and sender information for Team Inbox posting
-flow = Flowdock::Flow.new(:api_token => "__FLOW_TOKEN__",
+# create a new Flow object with the target flow's API token and sender information
+flow = Flowdock::Flow.new(:api_token => "__FLOW_API_TOKEN__",
   :source => "myapp", :from => {:name => "John Doe", :address => "john.doe@example.com"})
 
 # send message to Team Inbox
-flow.push_to_team_inbox(:subject => "Greetings from Flowdock API Gem!",
+flow.push_to_team_inbox(:subject => "Greetings from the Flowdock API gem!",
   :content => "<h2>It works!</h2><p>Now you can start developing your awesome application for Flowdock.</p>",
   :tags => ["cool", "stuff"], :link => "http://www.flowdock.com/")
 ```
@@ -111,25 +144,27 @@ flow.push_to_team_inbox(:subject => "Greetings from Flowdock API Gem!",
 require 'rubygems'
 require 'flowdock'
 
-# create a new Flow object with the api tokens of the target flows
-flow = Flowdock::Flow.new(:api_token => ["__FLOW_TOKEN__", "__ANOTHER_FLOW_TOKEN__"], ... )
+# create a new Flow object with the API tokens of the target flows
+flow = Flowdock::Flow.new(:api_token => ["__FLOW_API_TOKEN__", "__ANOTHER_FLOW_API_TOKEN__"], ... )
 
-# see above examples of posting to Chat or Team Inbox
+# see the above examples of posting to the chat or team inbox
 ```
 
 ## API methods
 
 * `Flowdock::Flow` methods
 
-  `push_to_team_inbox` - Send message to Team Inbox. See [API documentation](http://www.flowdock.com/api/team-inbox) for details.
+  `push_to_team_inbox` - Send message to the team inbox. See [API documentation](http://www.flowdock.com/api/team-inbox) for details.
 
-  `push_to_chat` - Send message to Chat. See [API documentation](http://www.flowdock.com/api/chat) for details.
+  `push_to_chat` - Send message to the chat. See [API documentation](http://www.flowdock.com/api/chat) for details.
 
   `send_message(params)` - Deprecated. Please use `push_to_team_inbox` instead.
 
 * `Flowdock::Client` methods
 
-  `chat_message` - Send message to Chat.
+  `chat_message` - Send message to chat.
+
+  `post_to_thread` - Post messages to a team inbox thread.
 
   `post`, `get`, `put`, `delete` - Send arbitary api calls. First parameter is the path, second is data. See [REST API documentation](http://www.flowdock.com/api/rest).
 
@@ -142,7 +177,7 @@ There are separate gems for deployment notifications:
 
 ## Changelog
 
-* 0.5.0 - Added `Flowdock::Client` that authenticates using user credentials and can be used to interact with the api. Better threads support for both `Flow` and `Client` so that comments can be made.
+* 0.5.0 - Added `Flowdock::Client` that authenticates using user credentials and can be used to interact with the API. Better threads support for both `Flow` and `Client` so that comments can be made.
 
 ## Copyright
 

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.0

data/flowdock.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: flowdock 0.5.0 ruby lib
+# stub: flowdock 0.7.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "flowdock"
-  s.version = "0.5.0"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Antti Pitk\u{e4}nen"]
-  s.date = "2014-09-23"
+  s.date = "2015-07-21"
   s.email = "team@flowdock.com"
   s.extra_rdoc_files = [
     "LICENSE",
@@ -34,7 +34,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/flowdock/flowdock-api"
   s.licenses = ["MIT"]
-  s.rubygems_version = "2.2.1"
+  s.rubygems_version = "2.4.1"
   s.summary = "Ruby Gem for using Flowdock's API"
 
   if s.respond_to? :specification_version then

data/lib/flowdock.rb

@@ -132,10 +132,12 @@ module Flowdock
     attr_reader :api_token
     def initialize(options = {})
       @api_token = options[:api_token]
-      raise InvalidParameterError, "Client must have :api_token attribute" if blank?(@api_token)
+      @flow_token = options[:flow_token]
+      raise InvalidParameterError, "Client must have :api_token or an :flow_token" if blank?(@api_token) && blank?(@flow_token)
     end
 
     def chat_message(params)
+      raise InvalidParameterError, "missing api_token" if blank?(@api_token)
       raise InvalidParameterError, "Message must have :content" if blank?(params[:content])
       raise InvalidParameterError, "Message must have :flow" if blank?(params[:flow])
       params = params.clone
@@ -147,17 +149,26 @@ module Flowdock
     end
 
     def private_message(params)
+      raise InvalidParameterError, "missing api_token" if blank?(@api_token)
       raise InvalidParameterError, "Message must have :content" if blank?(params[:content])
       raise InvalidParameterError, "Message must have :user_id" if blank?(params[:user_id])
 
       user_id = params.delete(:user_id)
-      
+
       params = params.clone
       event = "message"
 
       post("private/#{user_id}/messages", params.merge(event: event))
     end
-    
+
+    def post_to_thread(thread)
+      raise InvalidParameterError, "missing flow_token" if blank?(@flow_token)
+      resp = self.class.post(api_url("/messages"),
+                             body: MultiJson.dump(thread.merge(flow_token: @flow_token)),
+                             headers: headers)
+      handle_response resp
+    end
+
     def post(path, data = {})
       resp = self.class.post(api_url(path), :body => MultiJson.dump(data), :basic_auth => {:username => @api_token, :password => ''}, :headers => headers)
       handle_response(resp)

data/spec/flowdock_spec.rb

@@ -73,9 +73,10 @@ describe Flowdock do
     end
 
     it "should send without reply_to address" do
-      lambda {
+      expect {
+        stub_request(:post, push_to_team_inbox_url(@token)).to_return(:body => "", :status => 200)
         @flow.push_to_team_inbox(@valid_attributes.merge(:reply_to => ""))
-      }.should_not raise_error(Flowdock::InvalidParameterError)
+      }.not_to raise_error
     end
 
     it "should succeed with correct token, source and sender information" do
@@ -180,7 +181,7 @@ describe Flowdock do
           to_return(:body => "", :status => 200)
 
         @flow.push_to_team_inbox(:subject => "Hello World", :content => @example_content,
-          :tags => ["cool", "stuff"], :link => "http://www.flowdock.com/").should be_true
+          :tags => ["cool", "stuff"], :link => "http://www.flowdock.com/").should be_truthy
       }.should_not raise_error
     end
 
@@ -201,7 +202,7 @@ describe Flowdock do
           to_return(:body => "", :status => 200)
 
         @flow.push_to_team_inbox(:subject => "Hello World", :content => @example_content, :tags => ["cool", "stuff"],
-          :from => {:name => "Test", :address => "invalid@nodeta.fi"}, :reply_to => "foobar@example.com").should be_true
+          :from => {:name => "Test", :address => "invalid@nodeta.fi"}, :reply_to => "foobar@example.com").should be_truthy
       }.should_not raise_error
     end
 
@@ -256,7 +257,7 @@ describe Flowdock do
           with(:body => @valid_parameters.merge(:tags => "cool,stuff")).
           to_return(:body => "", :status => 200)
 
-        @flow.push_to_chat(@valid_parameters).should be_true
+        @flow.push_to_chat(@valid_parameters).should be_truthy
       }.should_not raise_error
     end
 
@@ -335,111 +336,129 @@ end
 
 describe Flowdock::Client do
 
-  let(:token) { SecureRandom.hex(8) }
-  let(:client) { Flowdock::Client.new(api_token: token) }
-
-  describe 'initializing' do
-
-    it 'should initialize with access token' do
-      expect {
-        client = Flowdock::Client.new(api_token: token)
-        expect(client.api_token).to equal(token)
-      }.not_to raise_error
-    end
-    it 'should raise error if initialized without access token' do
-      expect {
-        client = Flowdock::Client.new(api_token: nil)
-      }.to raise_error(Flowdock::InvalidParameterError)
-    end
-  end
-
-  describe 'posting to chat' do
-
-    let(:flow) { SecureRandom.hex(8) }
-
-    it 'posts to /messages' do
-      expect {
-        stub_request(:post, "https://#{token}:@api.flowdock.com/v1/messages").
-          with(:body => MultiJson.dump(flow: flow, content: "foobar", tags: [], event: "message"), :headers => {"Accept" => "application/json", "Content-Type" => "application/json"}).
-          to_return(:status => 201, :body => '{"id":123}', :headers => {"Content-Type" => "application/json"})
-        res = client.chat_message(flow: flow, content: 'foobar')
+  context "with flow_token" do
+    let(:token) { SecureRandom.hex }
+    let(:client) { Flowdock::Client.new(flow_token: token) }
+    let(:flow) { SecureRandom.hex }
+
+    describe "post a threaded message" do
+      it "succeeds" do
+        stub_request(:post, "https://api.flowdock.com/v1/messages").
+          with(body: MultiJson.dump(flow: flow, flow_token: token),
+               headers: {"Accept" => "application/json", "Content-Type" => "application/json"}).
+          to_return(status: 201, body: '{"id":123}', headers: {"Content-Type" => "application/json"})
+        res = client.post_to_thread({flow: flow})
         expect(res).to eq({"id" => 123})
-      }.not_to raise_error
-    end
-    it 'posts to /comments' do
-      expect {
-        stub_request(:post, "https://#{token}:@api.flowdock.com/v1/comments").
-          with(:body => MultiJson.dump(flow: flow, content: "foobar", message: 12345, tags: [], event: "comment"), :headers => {"Accept" => "application/json", "Content-Type" => "application/json"}).
-          to_return(:status => 201, :body => '{"id":1234}', :headers => {"Content-Type" => "application/json"})
-        res = client.chat_message(flow: flow, content: 'foobar', message: 12345)
-        expect(res).to eq({"id" => 1234})
-      }.not_to raise_error
-    end
-    it 'posts to /private/:user_id/messages' do
-      expect {
-        stub_request(:post, "https://#{token}:@api.flowdock.com/v1/private/12345/messages").
-          with(:body => MultiJson.dump(content: "foobar", event: "message"), :headers => {"Accept" => "application/json", "Content-Type" => "application/json"}).
-          to_return(:status => 201, :body => '{"id":1234}', :headers => {"Content-Type" => "application/json"})
-        res = client.private_message(user_id: "12345", content: 'foobar')
-        expect(res).to eq({"id" => 1234})
-      }.not_to raise_error
+      end
     end
+  end
 
-    it 'raises without flow' do
-      expect {
-        client.chat_message(content: 'foobar')
-      }.to raise_error(Flowdock::InvalidParameterError)
-    end
-    it 'raises without content' do
-      expect {
-        client.chat_message(flow: flow)
-      }.to raise_error(Flowdock::InvalidParameterError)
-    end
-    it 'handles error responses' do
-      expect {
-        stub_request(:post, "https://#{token}:@api.flowdock.com/v1/messages").
-          to_return(:body => '{"message":"Validation error","errors":{"content":["can\'t be blank"],"external_user_name":["should not contain whitespace"]}}',
-            :status => 400)
+  context "with api_token" do
+    let(:token) { SecureRandom.hex(8) }
+    let(:client) { Flowdock::Client.new(api_token: token) }
+
+    describe 'initializing' do
+
+      it 'should initialize with access token' do
+        expect {
+          client = Flowdock::Client.new(api_token: token)
+          expect(client.api_token).to equal(token)
+        }.not_to raise_error
+      end
+      it 'should raise error if initialized without access token' do
+        expect {
+          client = Flowdock::Client.new(api_token: nil)
+        }.to raise_error(Flowdock::InvalidParameterError)
+      end
+    end
+
+    describe 'posting to chat' do
+
+      let(:flow) { SecureRandom.hex(8) }
+
+      it 'posts to /messages' do
+        expect {
+          stub_request(:post, "https://#{token}:@api.flowdock.com/v1/messages").
+            with(:body => MultiJson.dump(flow: flow, content: "foobar", tags: [], event: "message"), :headers => {"Accept" => "application/json", "Content-Type" => "application/json"}).
+            to_return(:status => 201, :body => '{"id":123}', :headers => {"Content-Type" => "application/json"})
+          res = client.chat_message(flow: flow, content: 'foobar')
+          expect(res).to eq({"id" => 123})
+        }.not_to raise_error
+      end
+      it 'posts to /comments' do
+        expect {
+          stub_request(:post, "https://#{token}:@api.flowdock.com/v1/comments").
+            with(:body => MultiJson.dump(flow: flow, content: "foobar", message: 12345, tags: [], event: "comment"), :headers => {"Accept" => "application/json", "Content-Type" => "application/json"}).
+            to_return(:status => 201, :body => '{"id":1234}', :headers => {"Content-Type" => "application/json"})
+          res = client.chat_message(flow: flow, content: 'foobar', message: 12345)
+          expect(res).to eq({"id" => 1234})
+        }.not_to raise_error
+      end
+      it 'posts to /private/:user_id/messages' do
+        expect {
+          stub_request(:post, "https://#{token}:@api.flowdock.com/v1/private/12345/messages").
+            with(:body => MultiJson.dump(content: "foobar", event: "message"), :headers => {"Accept" => "application/json", "Content-Type" => "application/json"}).
+            to_return(:status => 201, :body => '{"id":1234}', :headers => {"Content-Type" => "application/json"})
+          res = client.private_message(user_id: "12345", content: 'foobar')
+          expect(res).to eq({"id" => 1234})
+        }.not_to raise_error
+      end
+
+      it 'raises without flow' do
+        expect {
+          client.chat_message(content: 'foobar')
+        }.to raise_error(Flowdock::InvalidParameterError)
+      end
+      it 'raises without content' do
+        expect {
+          client.chat_message(flow: flow)
+        }.to raise_error(Flowdock::InvalidParameterError)
+      end
+      it 'handles error responses' do
+        expect {
+          stub_request(:post, "https://#{token}:@api.flowdock.com/v1/messages").
+            to_return(:body => '{"message":"Validation error","errors":{"content":["can\'t be blank"],"external_user_name":["should not contain whitespace"]}}',
+                      :status => 400)
           client.chat_message(flow: flow, content: 'foobar')
-      }.to raise_error(Flowdock::ApiError)
+        }.to raise_error(Flowdock::ApiError)
+      end
     end
-  end
 
-  describe 'GET' do
-    it 'does abstract get with params' do
-      stub_request(:get, "https://#{token}:@api.flowdock.com/v1/some_path?sort_by=date").
-         with(:headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}).
-         to_return(:status => 200, :body => '{"id": 123}', :headers => {"Content-Type" => "application/json"})
-      expect(client.get('/some_path', {sort_by: 'date'})).to eq({"id" => 123})
+    describe 'GET' do
+      it 'does abstract get with params' do
+        stub_request(:get, "https://#{token}:@api.flowdock.com/v1/some_path?sort_by=date").
+          with(:headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}).
+          to_return(:status => 200, :body => '{"id": 123}', :headers => {"Content-Type" => "application/json"})
+        expect(client.get('/some_path', {sort_by: 'date'})).to eq({"id" => 123})
+      end
     end
-  end
 
-  describe 'POST' do
-    it 'does abstract post with body' do
-      stub_request(:post, "https://#{token}:@api.flowdock.com/v1/other_path").
-         with(:headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}, :body => MultiJson.dump(name: 'foobar')).
-         to_return(:status => 200, :body => '{"id": 123,"name": "foobar"}', :headers => {"Content-Type" => "application/json"})
-      expect(client.post('other_path', {name: 'foobar'})).to eq({"id" => 123, "name" => "foobar"})
-    end
+    describe 'POST' do
+      it 'does abstract post with body' do
+        stub_request(:post, "https://#{token}:@api.flowdock.com/v1/other_path").
+          with(:headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}, :body => MultiJson.dump(name: 'foobar')).
+          to_return(:status => 200, :body => '{"id": 123,"name": "foobar"}', :headers => {"Content-Type" => "application/json"})
+        expect(client.post('other_path', {name: 'foobar'})).to eq({"id" => 123, "name" => "foobar"})
+      end
 
-  end
+    end
 
-  describe 'PUT' do
-    it 'does abstract put with body' do
-      stub_request(:put, "https://#{token}:@api.flowdock.com/v1/other_path").
-         with(:headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}, :body => MultiJson.dump(name: 'foobar')).
-         to_return(:status => 200, :body => '{"id": 123,"name": "foobar"}', :headers => {"Content-Type" => "application/json"})
-      expect(client.put('other_path', {name: 'foobar'})).to eq({"id" => 123, "name" => "foobar"})
+    describe 'PUT' do
+      it 'does abstract put with body' do
+        stub_request(:put, "https://#{token}:@api.flowdock.com/v1/other_path").
+          with(:headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}, :body => MultiJson.dump(name: 'foobar')).
+          to_return(:status => 200, :body => '{"id": 123,"name": "foobar"}', :headers => {"Content-Type" => "application/json"})
+        expect(client.put('other_path', {name: 'foobar'})).to eq({"id" => 123, "name" => "foobar"})
+      end
     end
-  end
 
-  describe 'DELETE' do
-    it 'does abstract delete with params' do
-      stub_request(:delete, "https://#{token}:@api.flowdock.com/v1/some_path").
-         with(:headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}).
-         to_return(:status => 200, :body => '', :headers => {"Content-Type" => "application/json"})
-      expect(client.delete('/some_path')).to eq({})
+    describe 'DELETE' do
+      it 'does abstract delete with params' do
+        stub_request(:delete, "https://#{token}:@api.flowdock.com/v1/some_path").
+          with(:headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}).
+          to_return(:status => 200, :body => '', :headers => {"Content-Type" => "application/json"})
+        expect(client.delete('/some_path')).to eq({})
+      end
     end
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flowdock
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Antti Pitkänen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-11 00:00:00.000000000 Z
+date: 2015-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -163,7 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: Ruby Gem for using Flowdock's API