mollom_rest_api 0.1.0

data/spec/mollom_rest_api/v1/blacklist_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe MollomRestApi::V1::Blacklist do
+  describe :create do
+    context "when providing a valid url and email", vcr: {cassette_name: "blacklist/create"} do
+      let(:request_parameters) { {context: 'allFields'} }
+      let(:response) {{"context"=>"allFields", "created"=>"1409677772829", "id"=>"41a0e033-3d6a-465b-87d5-1ef60476da62", "match"=>"contains", "note"=>"", "reason"=>"unwanted", "status"=>"1", "value"=>"text"}}
+
+      it "should return a json response containing the blacklist entry" do
+        expect(MollomRestApi::V1::Blacklist.create('1lgj17lzuezlu1bn9ry4k3qz4k8nr42n', 'text', request_parameters)).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Blacklist, method_under_test: :create, method_args: ['ABC', 'DEF']
+  end
+
+  describe :update do
+    context "when providing a public key and blacklist entry id", vcr: {cassette_name: "blacklist/update"} do
+      let(:request_parameters) { {value: 'patate', reason: 'profanity'} }
+      let(:response) {{"context"=>"allFields", "created"=>"1409677772829", "id"=>"41a0e033-3d6a-465b-87d5-1ef60476da62", "match"=>"contains", "note"=>"", "reason"=>"profanity", "status"=>"1", "value"=>"patate"}}
+
+      it "should return a json response containing the updated blacklist entry" do
+        expect(MollomRestApi::V1::Blacklist.update('1lgj17lzuezlu1bn9ry4k3qz4k8nr42n', '42a51362-bab6-4256-8e28-60d5df568250', request_parameters)).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Blacklist, method_under_test: :update, method_args: %w(public_key blacklist_entry_id)
+  end
+
+  describe :delete do
+    context "when providing a public key and blacklist entry id", vcr: {cassette_name: "blacklist/delete"} do
+      it "should return a json response containing the deleted blacklist entry" do
+        expect{MollomRestApi::V1::Blacklist.delete('1lgj17lzuezlu1bn9ry4k3qz4k8nr42n', '42a51362-bab6-4256-8e28-60d5df568250')}.not_to raise_error
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Blacklist, method_under_test: :delete, method_args: %w(public_key blacklist_entry_id)
+  end
+
+  describe :list do
+    context "when providing a public key", vcr: {cassette_name: "blacklist/list"} do
+      let(:request_parameters) {{count: 5}}
+      let(:response) {{"entry"=>[{"context"=>"allFields", "created"=>"1410369319158", "id"=>"eafc878d-94f7-462d-bb67-49d5170a9a71", "match"=>"contains", "note"=>"", "reason"=>"unwanted", "status"=>"1", "value"=>"patate-chaude"}, {"context"=>"allFields", "created"=>"1410369319342", "id"=>"975805c8-ee06-4750-8cda-ec5626712c50", "match"=>"contains", "note"=>"", "reason"=>"unwanted", "status"=>"1", "value"=>"system_32"}]}}
+
+      it "should return a json response containing the list of blacklisted entries" do
+        expect(MollomRestApi::V1::Blacklist.list('1lgj17lzuezlu1bn9ry4k3qz4k8nr42n', request_parameters)).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Blacklist, method_under_test: :list, method_args: %w(public_key)
+  end
+
+  describe :read do
+    context "when providing a public key and blacklist entry id", vcr: {cassette_name: "blacklist/read"} do
+      let(:response) {{"context"=>"allFields", "created"=>"1410452568617", "id"=>"68172853-2a81-4899-b09a-ff1f1bad88aa", "match"=>"contains", "note"=>"", "reason"=>"unwanted", "status"=>"1", "value"=>"text"}}
+
+      it "should return a json response containing the blacklist entry" do
+        expect(MollomRestApi::V1::Blacklist.read('1lgj17lzuezlu1bn9ry4k3qz4k8nr42n', '68172853-2a81-4899-b09a-ff1f1bad88aa')).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Blacklist, method_under_test: :read, method_args: %w(public_key blacklist_entry_id)
+  end
+end

data/spec/mollom_rest_api/v1/captcha_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe MollomRestApi::V1::Captcha do
+  describe :create do
+    context "when no type is passed", vcr: {cassette_name: "captcha/create/default_request"} do
+      let(:response) {{"id"=>"TEST1wquvxygw6nkom", "url"=>"http://dev.mollom.com/v1/captcha/TEST1wquvxygw6nkom.png"}}
+
+      it "should return the json response for an image captcha" do
+        expect(MollomRestApi::V1::Captcha.create).to eq(response)
+      end
+    end
+
+    context "when an invalid type is passed", vcr: {cassette_name: "captcha/create/invalid_type"} do
+      let(:response) {{"id"=>"TEST1ddgajo9ldvw11", "url"=>"http://dev.mollom.com/v1/captcha/TEST1ddgajo9ldvw11.mp3"}}
+
+      it "should return the json response for a mp3 captcha" do
+        expect(MollomRestApi::V1::Captcha.create("foobar")).to eq(response)
+      end
+    end
+
+    context "when an valid type is passed", vcr: {cassette_name: "captcha/create/valid_request"} do
+      let(:response) {{"id"=>"TEST190gkt2utz449q", "url"=>"https://dev.mollom.com/v1/captcha/TEST190gkt2utz449q.mp3"}}
+
+      it "should return the json response for that type of captcha" do
+        expect(MollomRestApi::V1::Captcha.create("audio", ssl: 1)).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Captcha, method_under_test: :create
+  end
+
+  describe :verify do
+    context "when an invalid captcha id is passed", vcr: {cassette_name: "captcha/verify/invalid_captcha_id"} do
+      it "should raise an exception" do
+        expect{MollomRestApi::V1::Captcha.verify('inexistent_id', 'solution')}.to raise_exception do |exception|
+          expect(exception).to be_a(MollomRestApi::ApiException)
+          expect(exception.message).to eq("{\"code\":\"404\",\"message\":\"Captcha not found.\"}")
+          expect(exception.error_code).to eq(404)
+        end
+      end
+    end
+
+    context "when an valid captcha id is passed" do
+      context "when an invalid solution is passed", vcr: {cassette_name: "captcha/verify/invalid_solution"} do
+        let(:response) {{"id"=>"TEST15yj59df1pwv01", "solved"=>"0", "reason"=>"invalid_solution is not the correct solution."}}
+
+        it "should return the json response with an invalid captcha solution" do
+          expect(MollomRestApi::V1::Captcha.verify("TEST15yj59df1pwv01", "invalid_solution")).to eq(response)
+        end
+      end
+
+      context "when a valid solution is passed", vcr: {cassette_name: "captcha/verify/valid_solution"} do
+        let(:response) {{"id"=>"TEST1qravn2ikcz0k1", "solved"=>"1", "reason"=>"Correct response to image captcha."}}
+
+        it "should return the json response with a valid captcha solution" do
+          expect(MollomRestApi::V1::Captcha.verify("TEST1qravn2ikcz0k1", "correct")).to eq(response)
+        end
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Captcha, method_under_test: :verify, method_args: [9000, 'a_solution']
+  end
+end

data/spec/mollom_rest_api/v1/content_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe MollomRestApi::V1::Content do
+  [:create, :check].each do |action|
+    describe action do
+      context "when the api responded correctly", vcr: {cassette_name: "content/create"} do
+        let(:request_parameters) {{postTitle: "My Title", postBody: "Some text right over here!", authorName: "Jean-Luc Picard"}}
+        let(:response) {{"id"=>"TEST1up51ut7qyu2b1", "spamScore"=>"0.5", "reason"=>"some secret reason", "postTitle"=>"My Title", "postBody"=>"Some text right over here!", "spamClassification"=>"unsure"}}
+
+        it "should return a json response classifying the content" do
+          expect(MollomRestApi::V1::Content.send(action, request_parameters)).to eq(response)
+        end
+      end
+
+      include_examples "api error handling", class_under_test: MollomRestApi::V1::Content, method_under_test: action
+    end
+  end
+
+  describe :update do
+    context "when the content id doesn't exist", vcr: {cassette_name: "content/update/invalid_content_id"} do
+      it "should raise an exception" do
+        expect{MollomRestApi::V1::Content.update('inexistent_content_id')}.to raise_exception do |exception|
+          expect(exception).to be_a(MollomRestApi::ApiException)
+          expect(exception.message).to eq("{\"code\":\"404\",\"message\":\"Content not found.\"}")
+          expect(exception.error_code).to eq(404)
+        end
+      end
+    end
+
+    context "when the content id does exist", vcr: {cassette_name: "content/update/valid_request"} do
+      let(:request_parameters) {{checks: "spam", postBody: "My modified body!"}}
+      let(:response) {{"id"=>"TESTmh3q39o9ktwj13", "spamScore"=>"0.5", "reason"=>"some secret reason", "postBody"=>"My modified body!", "spamClassification"=>"unsure"}}
+
+      it "should return a json response classifying the updated content" do
+        expect(MollomRestApi::V1::Content.update("TESTmh3q39o9ktwj13", request_parameters)).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Content, method_under_test: :update, method_args: ["some_id"]
+  end
+end

data/spec/mollom_rest_api/v1/feedback_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe MollomRestApi::V1::Feedback do
+  describe :create do
+    context "when no contentId or captchaId is specified" do
+      it "should raise an argument error" do
+        expect{MollomRestApi::V1::Feedback.create("spam")}.to raise_exception do |exception|
+          expect(exception).to be_a(ArgumentError)
+          expect(exception.message).to eq("Specify one of two parameters: contentId or captchaId.")
+        end
+      end
+    end
+
+    context "when any contentId is specified (valid or invalid)", vcr: {cassette_name: "feedback/add/content_request"} do
+      it "should have silently passed" do
+        expect(MollomRestApi::V1::Feedback.create("spam", contentId: "some_id")).to be_nil
+      end
+    end
+
+    context "when any captchaId is specified (valid or invalid)", vcr: {cassette_name: "feedback/add/captcha_request"} do
+      it "should have silently passed" do
+        expect(MollomRestApi::V1::Feedback.create("spam", captchaId: "some_id")).to be_nil
+      end
+    end
+
+    context "when a contentId and a captchaId are passed" do
+      it "should raise an argument error" do
+        expect{MollomRestApi::V1::Feedback.create("spam", captchaId: "one", contentId: "two")}.to raise_exception do |exception|
+          expect(exception).to be_a(ArgumentError)
+          expect(exception.message).to eq("Specify one of two parameters: contentId or captchaId.")
+        end
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Feedback, method_under_test: :create, method_args: ['a_reason', {contentId: 'one'}]
+  end
+end

data/spec/mollom_rest_api/v1/site_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe MollomRestApi::V1::Site do
+  describe :create do
+    context "when providing a valid url and email", vcr: {cassette_name: "site/create"} do
+      let(:request_parameters) { {platformName: "Drupal", platformVersion: "6.20"} }
+      let(:response) { {"publicKey" => "44wvtjchwxaj1h90cqi1hxscwcpceylx", "privateKey" => "ton7cjeu271j15l94ip777uvv1pcgua3", "url" => "http://url", "email" => "an-email@gmail.com", "platformName" => "Drupal", "platformVersion" => "6.20", "expectedLanguages" => nil} }
+
+      it "should return a json response classifying the content" do
+        expect(MollomRestApi::V1::Site.create("http://url", "an-email@gmail.com", request_parameters)).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Site, method_under_test: :create, method_args: ['http://url', 'an-email-address@gmail.com']
+  end
+
+  describe :update do
+    context 'when providing a valid public key', vcr: {cassette_name: 'site/update'} do
+      let(:request_parameters) { {platformName: "Drupal", platformVersion: "6.20"} }
+      let(:response) { {"publicKey"=>"1mkno2c8bsepo12ewu7v0mmpxro77o3u", "privateKey"=>"z2urchz11o21b9m76l0x51iz1ize75g0", "expectedLanguages"=>nil} }
+
+      it 'should return the updated site ' do
+        expect(MollomRestApi::V1::Site.update('1mkno2c8bsepo12ewu7v0mmpxro77o3u')).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Site, method_under_test: :update, method_args: ['a_public_key']
+  end
+
+  describe :list do
+    context 'when listing the first 5 sites', vcr: {cassette_name: 'site/list'} do
+      let(:request_parameters) { {count: 5} }
+      let(:response) { {"site"=>[{"publicKey"=>"1cu4vdx7a6m9c1jc2425k1o9r8me2mrz", "privateKey"=>"1khj0vgpcqtjfwbbl5fr3wiykmr2ajro", "url"=>"http://url", "email"=>"an-email@gmail.com", "platformName"=>"Drupal", "platformVersion"=>"6.20", "expectedLanguages"=>nil}, {"publicKey"=>"geu7chlny71m18ve7inn41kuap9ztyja", "privateKey"=>"16o5626oykcsophjt31p1lim986rm5cq", "url"=>"http://url", "email"=>"an-email@gmail.com", "platformName"=>"Drupal", "platformVersion"=>"6.20", "expectedLanguages"=>nil}, {"publicKey"=>"44wvtjchwxaj1h90cqi1hxscwcpceylx", "privateKey"=>"ton7cjeu271j15l94ip777uvv1pcgua3", "url"=>"http://url", "email"=>"an-email@gmail.com", "platformName"=>"Drupal", "platformVersion"=>"6.20", "expectedLanguages"=>nil}]} }
+      it 'should return the list of sites' do
+        expect(MollomRestApi::V1::Site.list(request_parameters)).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Site, method_under_test: :list
+  end
+
+  describe :read do
+    context 'when fetching a specific site', vcr: {cassette_name: 'site/read'} do
+      let(:response) { {"publicKey"=>"1cu4vdx7a6m9c1jc2425k1o9r8me2mrz", "privateKey"=>"1khj0vgpcqtjfwbbl5fr3wiykmr2ajro", "url"=>"http://url", "email"=>"an-email@gmail.com", "platformName"=>"Drupal", "platformVersion"=>"6.20", "expectedLanguages"=>nil} }
+
+      it 'should return the site' do
+        expect(MollomRestApi::V1::Site.read('1cu4vdx7a6m9c1jc2425k1o9r8me2mrz')).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Site, method_under_test: :read, method_args: ['a_public_key']
+  end
+
+  describe :delete do
+    context 'when deleting a specific site', vcr: {cassette_name: 'site/delete'} do
+      it 'should delete a site' do
+        expect{MollomRestApi::V1::Site.delete('1cu4vdx7a6m9c1jc2425k1o9r8me2mrz')}.not_to raise_error
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Site, method_under_test: :delete, method_args: ['a_public_key']
+  end
+end

data/spec/mollom_rest_api/v1/whitelist_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe MollomRestApi::V1::Whitelist do
+  describe :create do
+    context "when providing a valid url and email", vcr: {cassette_name: "whitelist/create"} do
+      let(:request_parameters) { {note: 'patate'} }
+      let(:response) {{"context"=>"authorIp", "created"=>"1412787909465", "id"=>"76747", "lastMatch"=>"0", "matchCount"=>"0", "status"=>"1", "value"=>"123.123.80.22"}}
+
+      it "should return a json response containing the whitelist entry" do
+        expect(MollomRestApi::V1::Whitelist.create('1lgj17lzuezlu1bn9ry4k3qz4k8nr42n', '123.123.80.22', 'authorIp', request_parameters)).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Whitelist, method_under_test: :create, method_args: %w(public_key value context)
+  end
+
+  describe :update do
+    context "when providing a public key and a value for an author name", vcr: {cassette_name: "whitelist/update"} do
+      let(:request_parameters) { {value: 'patate', context: 'authorName'} }
+      let(:response) {{"context"=>"authorName", "created"=>"1412787909465", "id"=>"76747", "lastMatch"=>"0", "matchCount"=>"0", "status"=>"0", "value"=>"patate"}}
+
+      it "should return a json response containing the updated whitelist entry" do
+        expect(MollomRestApi::V1::Whitelist.update('1lgj17lzuezlu1bn9ry4k3qz4k8nr42n', '76747', request_parameters)).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Whitelist, method_under_test: :update, method_args: %w(public_key whitelist_entry_id)
+  end
+
+  describe :delete do
+    context "when providing a public key and whitelist entry id", vcr: {cassette_name: "whitelist/delete"} do
+      it "should return a json response containing the deleted whitelist entry" do
+        expect{MollomRestApi::V1::Whitelist.delete('1lgj17lzuezlu1bn9ry4k3qz4k8nr42n', '79552')}.not_to raise_error
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Whitelist, method_under_test: :delete, method_args: %w(public_key whitelist_entry_id)
+  end
+
+  describe :list do
+    context "when providing a public key", vcr: {cassette_name: "whitelist/list"} do
+      let(:request_parameters) { {count: 5} }
+      let(:response) {{"entry"=>{"context"=>"authorName", "created"=>"1412787909465", "id"=>"76747", "lastMatch"=>"0", "matchCount"=>"0", "status"=>"0", "value"=>"patate"}}}
+
+      it "should return a json response containing the list of whitelist entries" do
+        expect(MollomRestApi::V1::Whitelist.list('1lgj17lzuezlu1bn9ry4k3qz4k8nr42n', request_parameters)).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Whitelist, method_under_test: :list, method_args: %w(a_public_key)
+  end
+
+  describe :read do
+    context "when providing a public key and whitelist entry id", vcr: {cassette_name: "whitelist/read"} do
+      let(:response) {{"context"=>"authorName", "created"=>"1413826721455", "id"=>"79557", "lastMatch"=>"0", "matchCount"=>"0", "status"=>"1", "value"=>"patate"}}
+
+      it "should return a json response containing the whitelist entry" do
+        expect(MollomRestApi::V1::Whitelist.read('1lgj17lzuezlu1bn9ry4k3qz4k8nr42n', '79557')).to eq(response)
+      end
+    end
+
+    include_examples "api error handling", class_under_test: MollomRestApi::V1::Whitelist, method_under_test: :read, method_args: %w(public_key whitelist_entry_id)
+  end
+end

data/spec/mollom_rest_api/v1_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe MollomRestApi::V1 do
+  include AlternateSyntaxMacro
+
+  describe 'when calling the alternate syntax' do
+    it_should_provide_an_alternate_syntax_to_api_calls
+  end
+end

data/spec/mollom_rest_api/version_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe MollomRestApi do
+  specify { expect(MollomRestApi::VERSION).to_not be_nil }
+end

data/spec/mollom_rest_api/versioned_api_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe MollomRestApi::VersionedApi do
+  describe 'when calling the alternate syntax' do
+    describe :create_ticket do
+      it "should call MollomRestApi::VTest01::Ticket.create" do
+        expect(MollomRestApi::VTest01::Ticket).to receive(:create).once
+        MollomRestApi::VTest01.create_ticket
+      end
+
+      it "should specify that it responds to that method" do
+        expect(MollomRestApi::VTest01).to respond_to(:create_ticket)
+      end
+    end
+
+    describe :delete_api do
+      it "should try to call MollomRestApi::VTest01::Api.delete" do
+        expect{MollomRestApi::VTest01.delete_api}.to raise_exception(NameError)
+      end
+
+      it "should not be able to respond to delete_api" do
+        expect(MollomRestApi::VTest01).not_to respond_to(:delete_api)
+      end
+    end
+  end
+end

data/spec/mollom_rest_api_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe MollomRestApi do
+  describe :attr_accessors do
+    %w(url public_key private_key oauth_options).each do |config|
+      describe config do
+        before(:each) { @old_config = MollomRestApi.send(config) }
+        after(:each) { MollomRestApi.send("#{config}=", @old_config) }
+
+        it "should have an attr_accessor for #{config}" do
+          MollomRestApi.send("#{config}=", 'test')
+          expect(MollomRestApi.send(config)).to eq('test')
+        end
+      end
+    end
+  end
+
+  describe :oauth_access_token do
+    let(:oauth_access_token) { MollomRestApi.oauth_access_token }
+
+    it "should return a oauth access token" do
+      expect(oauth_access_token).to be_a(OAuth::AccessToken)
+
+      expect(oauth_access_token.consumer).to be_a(OAuth::Consumer)
+      expect(oauth_access_token.consumer.key).to eq('my_public_key')
+      expect(oauth_access_token.consumer.secret).to eq('my_private_key')
+      expect(oauth_access_token.consumer.options).to include(proxy: 'http://proxy.com:8888')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'mollom_rest_api'
+require 'fixtures/v_test_01'
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f}
+
+require 'coveralls'
+Coveralls.wear!
+
+RSpec.configure do |c|
+  c.before(:all) do
+    MollomRestApi.url = 'http://dev.mollom.com'
+    MollomRestApi.public_key = 'my_public_key'
+    MollomRestApi.private_key = 'my_private_key'
+    MollomRestApi.oauth_options = {proxy: 'http://proxy.com:8888'}
+  end
+end

data/spec/support/macros/alternate_syntax_macro.rb

@@ -0,0 +1,38 @@
+module AlternateSyntaxMacro
+  module ExampleGroupMethods
+    def it_should_provide_an_alternate_syntax_to_api_calls
+      available_apis = described_class.constants
+
+      available_apis.each do |api|
+        class_name = "#{described_class.name}::#{api}"
+        target_class = class_name.constantize
+        class_methods = receiver_public_methods_of(target_class)
+
+        class_methods.each do |action|
+          alternate_syntax = "#{action}_#{api.downcase}"
+
+          describe alternate_syntax do
+            it "should call #{class_name}.#{action}" do
+              expect(target_class).to receive(action).once
+              described_class.send(alternate_syntax)
+            end
+
+            it "should specify that it responds to that method" do
+              expect(described_class).to respond_to(alternate_syntax)
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def receiver_public_methods_of(klass)
+      klass.public_methods(false) & klass.methods(false)
+    end
+  end
+
+  def self.included(receiver)
+    receiver.extend ExampleGroupMethods
+  end
+end

data/spec/support/shared_examples/api_error_handling.rb

@@ -0,0 +1,33 @@
+shared_examples "api error handling" do |options = {}|
+  let(:class_under_test) { options.fetch(:class_under_test) }
+  let(:method_under_test) { options.fetch(:method_under_test) }
+
+  context "when there is a missing configuration" do
+    MollomRestApi::Interface::MANDATORY_CONFIGURATIONS.each do |config|
+      context "when there #{config} is missing" do
+        before(:each) do
+          @old_config = MollomRestApi.send(config)
+          MollomRestApi.send("#{config}=", nil)
+        end
+        after(:each) { MollomRestApi.send("#{config}=", @old_config) }
+
+        it "should raise an exception" do
+          expect{class_under_test.send(method_under_test, *options[:method_args])}.to raise_exception do |exception|
+            expect(exception).to be_a(MollomRestApi::MissingConfig)
+            expect(exception.message).to eq("Missing #{config}.")
+          end
+        end
+      end
+    end
+  end
+
+  context "when there is an error with the api response", vcr: {cassette_name: "invalid_request", match_requests_on: [:method, :base_uri]} do
+    it "should raise an exception" do
+      expect{class_under_test.send(method_under_test, *options[:method_args])}.to raise_exception do |exception|
+        expect(exception).to be_a(MollomRestApi::ApiException)
+        expect(exception.message).to eq("{\"code\":\"401\",\"message\":\"Error.\"}")
+        expect(exception.error_code).to eq(401)
+      end
+    end
+  end
+end

data/spec/support/vcr.rb

@@ -0,0 +1,37 @@
+require 'webmock/rspec'
+require 'vcr'
+
+module VCRHelper
+  PARAMS_TO_STRIP = %w(oauth_consumer_key oauth_nonce oauth_signature)
+
+  def strip_authorization(headers)
+    headers['Authorization'] = headers['Authorization'].collect do |header|
+      header.gsub(%r((#{params_to_strip})="(.*)")) { "#{$1}=\"\"" }
+    end
+  end
+
+  private
+
+  def params_to_strip
+    PARAMS_TO_STRIP.join('|')
+  end
+end
+
+VCR.configure do |c|
+  include VCRHelper
+
+  c.cassette_library_dir = 'spec/fixtures/cassette_library'
+  c.debug_logger = File.open('log/test.log', 'w')
+  c.hook_into :webmock
+  c.ignore_localhost = true
+  c.default_cassette_options = {record: :none, match_requests_on: [:method, :uri, :body, :headers_with_striped_auth]}
+  c.configure_rspec_metadata!
+
+  c.register_request_matcher :headers_with_striped_auth do |r1, r2|
+    strip_authorization(r1.headers.to_hash) == strip_authorization(r2.headers.to_hash)
+  end
+
+  c.register_request_matcher :base_uri do |r1, r2|
+    r1.uri.start_with?(r2.uri)
+  end
+end