txgh 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2fdd0fc2aef582a990ec6d4e3ba910272c983b5c
-  data.tar.gz: a23ff4651a74b4d83fa8aa6568000651e77092b0
+  metadata.gz: 500294b033cfebc1c6c9c52a28b75cc5e564bd13
+  data.tar.gz: 5a3b866c7976246ec5e0c5532c69d044ff7b7dc2
 SHA512:
-  metadata.gz: 742668090fc7458a79091b64d4c1ddfc4cf83c8de2a70579b970639a3145c55f2fdff056951ccf1a9626086c28b96faed39cca8ba6f1e16c0aece5835bd13c2b
-  data.tar.gz: 2cda6f1fe1938a253585beef2e806e8c7cf9ddada727735bbfd568c754e337d1cfd1cd16a2838c0ca0e604ae3a9fbf6832ed2dd9cc0723ab2cf24944ef198065
+  metadata.gz: 56e81d08e7020c5c9aa292d5eb7801da5afab2d28509cffbe8b261c0248d0e48c9dea7aeb694b7694f6a8e689efa480454d325e6570caaeb1a4a386086d9ade2
+  data.tar.gz: c2b1b2ff73af79c5aa0bfd0acc29e7fbfba37ef839c30ef7c4c7c90241fc9024e280f33fc1bb2eba007368fb47cf323cb65e37297dd04276c920c9796ef022aa

data/lib/txgh/handlers/github/delete_handler.rb

@@ -15,7 +15,7 @@ module Txgh
         def delete_resources
           tx_resources.each do |tx_resource|
             logger.info("Deleting #{tx_resource.resource_slug}")
-            project.api.delete(tx_resource)
+            project.api.delete_resource(tx_resource)
           end
         end
 

data/lib/txgh/transifex_api.rb

@@ -65,93 +65,105 @@ module Txgh
       }
 
       url = "#{API_ROOT}/project/#{tx_resource.project_slug}/resources/"
-      response = connection.post(url, payload)
-      raise_error!(response)
+      post(url, payload)
     end
 
-    def delete(tx_resource)
+    def delete_resource(tx_resource)
       url = "#{API_ROOT}/project/#{tx_resource.project_slug}/resource/#{tx_resource.resource_slug}/"
-      connection.delete(url)
+      delete(url)
     end
 
     def update_content(tx_resource, content)
       content_io = get_content_io(tx_resource, content)
       payload = { content: content_io }
       url = "#{API_ROOT}/project/#{tx_resource.project_slug}/resource/#{tx_resource.resource_slug}/content/"
-      response = connection.put(url, payload)
-      raise_error!(response)
+      put(url, payload)
     end
 
     def update_details(tx_resource, details = {})
       url = "#{API_ROOT}/project/#{tx_resource.project_slug}/resource/#{tx_resource.resource_slug}/"
-      response = connection.put(url, details)
-      raise_error!(response)
+      put(url, details)
     end
 
     def resource_exists?(tx_resource)
       project = tx_resource.project_slug
       slug = tx_resource.resource_slug
-      response = connection.get("#{API_ROOT}/project/#{project}/resource/#{slug}/")
+      response = get("#{API_ROOT}/project/#{project}/resource/#{slug}/")
       response.status == 200
+    rescue TransifexNotFoundError
+      false
     end
 
     def download(tx_resource, lang)
       project_slug = tx_resource.project_slug
       resource_slug = tx_resource.resource_slug
-      response = connection.get(
+
+      json_data = get_json(
         "#{API_ROOT}/project/#{project_slug}/resource/#{resource_slug}/translation/#{lang}/"
       )
 
-      raise_error!(response)
-
-      json_data = JSON.parse(response.body)
       json_data['content']
     end
 
     def get_resource(project_slug, resource_slug)
       url = "#{API_ROOT}/project/#{project_slug}/resource/#{resource_slug}/"
-      response = connection.get(url)
-      raise_error!(response)
-      JSON.parse(response.body)
+      get_json(url)
     end
 
     def get_resources(project_slug)
       url = "#{API_ROOT}/project/#{project_slug}/resources/"
-      response = connection.get(url)
-      raise_error!(response)
-      JSON.parse(response.body)
+      get_json(url)
     end
 
     def get_languages(project_slug)
       url = "#{API_ROOT}/project/#{project_slug}/languages/"
-      response = connection.get(url)
-      raise_error!(response)
-      JSON.parse(response.body)
+      get_json(url)
     end
 
     def get_project(project_slug)
       url = "#{API_ROOT}/project/#{project_slug}/"
-      response = connection.get(url)
-      raise_error!(response)
-      JSON.parse(response.body)
+      get_json(url)
     end
 
     def get_formats
       url = "#{API_ROOT}/formats/"
-      response = connection.get(url)
-      raise_error!(response)
-      JSON.parse(response.body)
+      get_json(url)
     end
 
     def get_stats(project_slug, resource_slug)
       url = "#{API_ROOT}/project/#{project_slug}/resource/#{resource_slug}/stats/"
-      response = connection.get(url)
-      raise_error!(response)
-      JSON.parse(response.body)
+      get_json(url)
     end
 
     private
 
+    def get(url)
+      act(:get, url)
+    end
+
+    def post(url, body)
+      act(:post, url, body)
+    end
+
+    def put(url, body)
+      act(:put, url, body)
+    end
+
+    def delete(url)
+      act(:delete, url)
+    end
+
+    def get_json(url)
+      response = get(url)
+      JSON.parse(response.body)
+    end
+
+    def act(verb, url, body = nil)
+      response = connection.send(verb, url, body)
+      raise_error!(response)
+      response
+    end
+
     def get_content_io(tx_resource, content)
       content_io = StringIO::new(content)
       content_io.set_encoding(Encoding::UTF_8.name)
@@ -163,16 +175,15 @@ module Txgh
     def raise_error!(response)
       case response.status
         when 401
-          raise TransifexUnauthorizedError
+          raise TransifexUnauthorizedError, "401 Unauthorized: #{response.env.url}"
         when 404
-          raise TransifexNotFoundError
+          raise TransifexNotFoundError, "404 Not Found: #{response.env.url}"
         else
           if (response.status / 100) != 2
             raise TransifexApiError,
-              "Failed Transifex API call - returned status code: #{response.status}, body: #{response.body}"
+              "HTTP #{response.status}: #{response.env.url}, body: #{response.body}"
           end
       end
     end
   end
 end
-

data/lib/txgh/version.rb

@@ -1,3 +1,3 @@
 module Txgh
-  VERSION = '3.0.0'
+  VERSION = '4.0.0'
 end

data/spec/handlers/github/delete_handler_spec.rb

@@ -39,7 +39,7 @@ describe DeleteHandler do
       receive(:get_resources).and_return(resource_api_response)
     )
 
-    expect(transifex_api).to receive(:delete) do |tx_resource|
+    expect(transifex_api).to receive(:delete_resource) do |tx_resource|
       expect(tx_resource.project_slug).to eq(project_name)
       expect(tx_resource.resource_slug).to eq(resource_slug_with_branch)
     end

data/spec/transifex_api_spec.rb

@@ -4,12 +4,37 @@ require 'helpers/standard_txgh_setup'
 include Txgh
 
 describe TransifexApi do
+  FakeEnv = Struct.new(:url)
+  FakeRequest = Struct.new(:body)
+  FakeResponse = Struct.new(:env, :status, :body)
+
+  class FakeConnection
+    %w(get post put delete).each do |verb|
+      define_method(:"on_#{verb}") do |&block|
+        callbacks[verb] = block
+      end
+
+      define_method(verb) do |url, body = nil|
+        env = FakeEnv.new(url)
+        request = FakeRequest.new(body)
+        response = FakeResponse.new(env)
+        callbacks[verb].call(request, response)
+        response
+      end
+    end
+
+    private
+
+    def callbacks
+      @callbacks ||= {}
+    end
+  end
+
   include StandardTxghSetup
 
-  let(:connection) { double(:connection) }
+  let(:connection) { FakeConnection.new }
   let(:api) { TransifexApi.create_from_connection(connection) }
   let(:resource) { tx_config.resource(resource_slug) }
-  let(:response) { double(:response) }
 
   describe '#create_or_update' do
     context 'with a preexisting resource' do
@@ -48,159 +73,188 @@ describe TransifexApi do
     context 'with a non-existent resource' do
       before(:each) do
         expect(api).to receive(:resource_exists?).and_return(false)
+        expect(connection).to receive(:post).and_call_original
       end
 
       it 'makes a request with the correct parameters' do
-        expect(connection).to receive(:post) do |url, payload|
-          expect(url).to(
+        connection.on_post do |request, response|
+          response.status = 200
+          response.body = '{}'
+
+          expect(response.env.url).to(
             end_with("project/#{project_name}/resources/")
           )
 
-          expect(payload[:slug]).to eq(resource_slug)
-          expect(payload[:name]).to eq(resource.source_file)
-          expect(payload[:i18n_type]).to eq('YML')
-
-          response
+          expect(request.body[:slug]).to eq(resource_slug)
+          expect(request.body[:name]).to eq(resource.source_file)
+          expect(request.body[:i18n_type]).to eq('YML')
         end
 
-        allow(response).to receive(:status).and_return(200)
-        allow(response).to receive(:body).and_return("{}")
         api.create_or_update(resource, 'new_content')
       end
     end
   end
 
   describe '#create' do
+    before(:each) do
+      expect(connection).to receive(:post).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:post) do |url, payload|
-        expect(url).to(
+      connection.on_post do |request, response|
+        response.status = 200
+
+        expect(response.env.url).to(
           end_with("project/#{project_name}/resources/")
         )
 
-        expect(payload[:name]).to eq('sample.yml')
-        expect(payload[:content].io.string).to eq('new_content')
-        expect(payload[:categories]).to eq('abc def')
-        response
+        expect(request.body[:name]).to eq('sample.yml')
+        expect(request.body[:content].io.string).to eq('new_content')
+        expect(request.body[:categories]).to eq('abc def')
       end
 
-      allow(response).to receive(:status).and_return(200)
       api.create(resource, 'new_content', ['abc', 'def'])
     end
 
     it 'submits de-duped categories' do
-      expect(connection).to receive(:post) do |url, payload|
-        expect(payload[:categories]).to eq('abc')
-        response
+      connection.on_post do |request, response|
+        response.status = 200
+        expect(request.body[:categories]).to eq('abc')
       end
 
-      allow(response).to receive(:status).and_return(200)
       api.create(resource, 'new_content', ['abc', 'abc'])
     end
 
     it 'raises an exception if the api responds with an error code' do
-      allow(connection).to receive(:post).and_return(response)
-      allow(response).to receive(:status).and_return(404)
-      allow(response).to receive(:body).and_return('{}')
-      expect { api.create(resource, 'new_content') }.to raise_error(TransifexApiError)
+      connection.on_post do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
+      expect { api.create(resource, 'new_content') }.to(
+        raise_error(TransifexApiError)
+      )
     end
 
     context 'with a branch-based resource' do
       let(:resource) { tx_config.resource(resource_slug, ref) }
 
       it "includes the branch in the resource's name" do
-        expect(connection).to receive(:post) do |url, payload|
-          expect(payload[:name]).to eq('sample.yml (heads/master)')
-          response
+        connection.on_post do |request, response|
+          response.status = 200
+          expect(request.body[:name]).to eq('sample.yml (heads/master)')
         end
 
-        allow(response).to receive(:status).and_return(200)
         api.create(resource, 'new_content')
       end
     end
   end
 
-  describe '#delete' do
+  describe '#delete_resource' do
+    before(:each) do
+      expect(connection).to receive(:delete).and_call_original
+    end
+
     it 'deletes the given resource' do
-      expect(connection).to receive(:delete) do |url|
-        expect(url).to(
+      connection.on_delete do |_, response|
+        response.status = 200
+
+        expect(response.env.url).to(
           end_with("project/#{project_name}/resource/#{resource_slug}/")
         )
       end
 
-      api.delete(resource)
+      api.delete_resource(resource)
     end
   end
 
   describe '#update_content' do
+    before(:each) do
+      expect(connection).to receive(:put).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:put) do |url, payload|
-        expect(url).to(
+      connection.on_put do |request, response|
+        response.status = 200
+
+        expect(response.env.url).to(
           end_with("project/#{project_name}/resource/#{resource_slug}/content/")
         )
 
-        expect(payload[:content].io.string).to eq('new_content')
-        response
+        expect(request.body[:content].io.string).to eq('new_content')
       end
 
-      allow(response).to receive(:status).and_return(200)
       api.update_content(resource, 'new_content')
     end
 
     it 'raises an exception if the api responds with an error code' do
-      allow(connection).to receive(:put).and_return(response)
-      allow(response).to receive(:status).and_return(404)
-      allow(response).to receive(:body).and_return('{}')
-      expect { api.update_content(resource, 'new_content') }.to raise_error(TransifexApiError)
+      connection.on_put do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
+      expect { api.update_content(resource, 'new_content') }.to(
+        raise_error(TransifexApiError)
+      )
     end
   end
 
   describe '#update_details' do
+    before(:each) do
+      expect(connection).to receive(:put).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:put) do |url, payload|
-        expect(url).to(
+      connection.on_put do |request, response|
+        response.status = 200
+
+        expect(response.env.url).to(
           end_with("project/#{project_name}/resource/#{resource_slug}/")
         )
 
-        expect(payload[:i18n_type]).to eq('FOO')
-        expect(payload[:categories]).to eq(['abc'])
-        response
+        expect(request.body[:i18n_type]).to eq('FOO')
+        expect(request.body[:categories]).to eq(['abc'])
       end
 
-      allow(response).to receive(:status).and_return(200)
       api.update_details(resource, i18n_type: 'FOO', categories: ['abc'])
     end
 
     it 'raises an exception if the api responds with an error code' do
-      allow(connection).to receive(:put).and_return(response)
-      allow(response).to receive(:status).and_return(404)
-      allow(response).to receive(:body).and_return('{}')
-      expect { api.update_details(resource, {}) }.to raise_error(TransifexApiError)
+      connection.on_put do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
+      expect { api.update_details(resource, {}) }.to(
+        raise_error(TransifexApiError)
+      )
     end
   end
 
   describe '#resource_exists?' do
+    before(:each) do
+      expect(connection).to receive(:get).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:get) do |url|
-        expect(url).to(
+      connection.on_get do |_, response|
+        response.status = 200
+
+        expect(response.env.url).to(
           end_with("project/#{project_name}/resource/#{resource_slug}/")
         )
-
-        response
       end
 
-      allow(response).to receive(:status).and_return(200)
       api.resource_exists?(resource)
     end
 
     it 'returns true if the api responds with a 200 status code' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(200)
+      connection.on_get { |_, response| response.status = 200 }
       expect(api.resource_exists?(resource)).to eq(true)
     end
 
     it 'returns false if the api does not respond with a 200 status code' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(404)
+      connection.on_get { |_, response| response.status = 404 }
       expect(api.resource_exists?(resource)).to eq(false)
     end
   end
@@ -208,38 +262,40 @@ describe TransifexApi do
   describe '#download' do
     let(:language) { 'pt-BR' }
 
+    before(:each) do
+      expect(connection).to receive(:get).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:get) do |url|
-        expect(url).to(
+      connection.on_get do |_, response|
+        response.status = 200
+        response.body = '{"content": "foobar"}'
+
+        expect(response.env.url).to(
           end_with("project/#{project_name}/resource/#{resource_slug}/translation/#{language}/")
         )
-
-        response
       end
 
-      allow(response).to receive(:status).and_return(200)
-      allow(response).to receive(:body).and_return('{}')
-      api.download(resource, language)
-    end
-
-    it 'parses and returns the response content' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(200)
-      allow(response).to receive(:body).and_return('{"content": "foobar"}')
       expect(api.download(resource, language)).to eq('foobar')
     end
 
     it 'raises an exception if the api responds with an error code' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(401)
-      allow(response).to receive(:body).and_return('{}')
-      expect { api.download(resource, language) }.to raise_error(TransifexApiError)
+      connection.on_get do |_, response|
+        response.status = 401
+        response.body = '{}'
+      end
+
+      expect { api.download(resource, language) }.to(
+        raise_error(TransifexApiError)
+      )
     end
 
     it 'raises a specific exception if the api responds with a 404 not found' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(404)
-      allow(response).to receive(:body).and_return('{}')
+      connection.on_get do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
       expect { api.download(resource, language) }.to raise_error(
         TransifexNotFoundError
       )
@@ -247,136 +303,218 @@ describe TransifexApi do
   end
 
   describe '#get_resource' do
+    before(:each) do
+      expect(connection).to receive(:get).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:get) do |url, payload|
-        expect(url).to(
+      connection.on_get do |_, response|
+        response.status = 200
+        response.body = '{"foo":"bar"}'
+
+        expect(response.env.url).to(
           end_with("project/#{project_name}/resource/#{resource_slug}/")
         )
-
-        response
       end
 
-      allow(response).to receive(:status).and_return(200)
-      allow(response).to receive(:body).and_return('{"foo":"bar"}')
       expect(api.get_resource(*resource.slugs)).to eq({ 'foo' => 'bar' })
     end
 
     it 'raises an exception if the api responds with an error code' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(404)
-      allow(response).to receive(:body).and_return('{}')
-      expect { api.get_resource(*resource.slugs) }.to raise_error(TransifexApiError)
+      connection.on_get do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
+      expect { api.get_resource(*resource.slugs) }.to(
+        raise_error(TransifexApiError)
+      )
     end
   end
 
   describe '#get_resources' do
+    before(:each) do
+      expect(connection).to receive(:get).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:get) do |url, payload|
-        expect(url).to(
+      connection.on_get do |_, response|
+        response.status = 200
+        response.body = '{"foo":"bar"}'
+
+        expect(response.env.url).to(
           end_with("project/#{project_name}/resources/")
         )
-
-        response
       end
 
-      allow(response).to receive(:status).and_return(200)
-      allow(response).to receive(:body).and_return('{"foo":"bar"}')
       expect(api.get_resources(project_name)).to eq({ 'foo' => 'bar' })
     end
 
     it 'raises an exception if the api responds with an error code' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(404)
-      allow(response).to receive(:body).and_return('{}')
-      expect { api.get_resources(project_name) }.to raise_error(TransifexApiError)
+      connection.on_get do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
+      expect { api.get_resources(project_name) }.to(
+        raise_error(TransifexApiError)
+      )
     end
   end
 
   describe '#get_languages' do
+    before(:each) do
+      expect(connection).to receive(:get).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:get) do |url, payload|
-        expect(url).to(
+      connection.on_get do |_, response|
+        response.status = 200
+        response.body = '[{"language_code":"de"}]'
+
+        expect(response.env.url).to(
           end_with("project/#{project_name}/languages/")
         )
-
-        response
       end
 
-      allow(response).to receive(:status).and_return(200)
-      allow(response).to receive(:body).and_return('[{"language_code":"de"}]')
       expect(api.get_languages(project_name)).to eq([{ 'language_code' => 'de' }])
     end
 
     it 'raises an exception if the api responds with an error code' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(404)
-      allow(response).to receive(:body).and_return('{}')
-      expect { api.get_languages(project_name) }.to raise_error(TransifexApiError)
+      connection.on_get do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
+      expect { api.get_languages(project_name) }.to(
+        raise_error(TransifexApiError)
+      )
     end
   end
 
   describe '#get_project' do
+    before(:each) do
+      expect(connection).to receive(:get).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:get) do |url, payload|
-        expect(url).to(
+      connection.on_get do |_, response|
+        response.status = 200
+        response.body = '{"slug":"projectslug"}'
+
+        expect(response.env.url).to(
           end_with("project/#{project_name}/")
         )
-
-        response
       end
 
-      allow(response).to receive(:status).and_return(200)
-      allow(response).to receive(:body).and_return('{"slug":"projectslug"}')
       expect(api.get_project(project_name)).to eq({ 'slug' => 'projectslug' })
     end
 
     it 'raises an exception if the api responds with an error code' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(404)
-      allow(response).to receive(:body).and_return('{}')
-      expect { api.get_project(project_name) }.to raise_error(TransifexApiError)
+      connection.on_get do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
+      expect { api.get_project(project_name) }.to(
+        raise_error(TransifexApiError)
+      )
     end
   end
 
   describe '#get_formats' do
+    before(:each) do
+      expect(connection).to receive(:get).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:get) do |url, payload|
-        expect(url).to end_with("formats/")
-        response
+      connection.on_get do |_, response|
+        response.status = 200
+        response.body = '{}'
+
+        expect(response.env.url).to(
+          end_with('formats/')
+        )
       end
 
-      allow(response).to receive(:status).and_return(200)
-      allow(response).to receive(:body).and_return('{}')
       expect(api.get_formats).to eq({})
     end
 
     it 'raises an exception if the api responds with an error code' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(404)
-      allow(response).to receive(:body).and_return('{}')
+      connection.on_get do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
       expect { api.get_formats }.to raise_error(TransifexApiError)
     end
   end
 
   describe '#get_stats' do
+    before(:each) do
+      expect(connection).to receive(:get).and_call_original
+    end
+
     it 'makes a request with the correct parameters' do
-      expect(connection).to receive(:get) do |url, payload|
-        expect(url).to end_with("stats/")
-        response
+      connection.on_get do |_, response|
+        response.status = 200
+        response.body = '{}'
+
+        expect(response.env.url).to(
+          end_with('stats/')
+        )
       end
 
-      allow(response).to receive(:status).and_return(200)
-      allow(response).to receive(:body).and_return('{}')
       expect(api.get_stats(project_name, resource_slug)).to eq({})
     end
 
     it 'raises an exception if the api responds with an error code' do
-      allow(connection).to receive(:get).and_return(response)
-      allow(response).to receive(:status).and_return(404)
-      allow(response).to receive(:body).and_return('{}')
+      connection.on_get do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
       expect { api.get_stats(project_name, resource_slug) }.to(
         raise_error(TransifexApiError)
       )
     end
   end
+
+  describe 'errors' do
+    it 'includes the URL in the error message on 401' do
+      connection.on_get do |_, response|
+        response.status = 401
+        response.body = '{}'
+      end
+
+      expect { api.get_formats }.to raise_error do |error|
+        expect(error).to be_a(TransifexUnauthorizedError)
+        expect(error.message).to eq('401 Unauthorized: /api/2/formats/')
+      end
+    end
+
+    it 'includes the URL in the error message on 404' do
+      connection.on_get do |_, response|
+        response.status = 404
+        response.body = '{}'
+      end
+
+      expect { api.get_formats }.to raise_error do |error|
+        expect(error).to be_a(TransifexNotFoundError)
+        expect(error.message).to eq('404 Not Found: /api/2/formats/')
+      end
+    end
+
+    it 'includes the URL in the error message on unexpected error' do
+      connection.on_get do |_, response|
+        response.status = 422
+        response.body = '{}'
+      end
+
+      expect { api.get_formats }.to raise_error do |error|
+        expect(error).to be_a(TransifexApiError)
+        expect(error.message).to eq('HTTP 422: /api/2/formats/, body: {}')
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: txgh
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Matthew Jackowski
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-23 00:00:00.000000000 Z
+date: 2016-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abroad