bigbluebutton-api-ruby 1.3.0 → 1.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e8411f3d08298b647a2fa645f80aa7aa5c06ae60
+  data.tar.gz: 52acdabcf29a08606ff12125d7069210d05eaa72
+SHA512:
+  metadata.gz: a3f47f27947d7ae7e248bae4d5046bfcb6f1fb6e61302c595422574ca7f2b7a31fefc7950aaee8c3e5ff580172fb7dc8c7309a3c0c14e893b91d0ff429278a21
+  data.tar.gz: 2069dc248ece7867760884d34e2d703258c91897527a9f317edb0c0b57adf1a9b201bde4a186302c1ad42453011a1aba27b28e3298ac45c906de04655886f6ef

data/.ruby-version

@@ -1 +1 @@
-1.9.3-p484
+2.2.0

data/.travis.yml

@@ -1,6 +1,8 @@
+language: ruby
 script: "bundle exec rake spec"
 rvm:
-  - 1.8.7
+  - 2.2.0
+  - 2.1.2
+  - 2.0.0
+  - 1.9.3
   - 1.9.2
-  - ree
-  - jruby

data/CHANGELOG.rdoc

@@ -1,3 +1,10 @@
+=== 1.4.0
+
+* Updated default ruby version to 2.2.0.
+* Add support for BigBlueButton 0.9 (includes all 0.9.x). Consists only in accepting the version
+  "0.9", since this new API version doesn't break compatibility with the previous version and
+  also doesn't add new API calls.
+
 === 1.3.0
 
 * Drop support to BigBlueButton 0.7 and add BigBlueButton to 0.81. Includes support to the new API calls <tt>getDefaultConfigXML</tt> and <tt>setConfigXML</tt>.

data/Gemfile.lock

@@ -7,7 +7,7 @@ GIT
 PATH
   remote: .
   specs:
-    bigbluebutton-api-ruby (1.3.0)
+    bigbluebutton-api-ruby (1.4.0)
       xml-simple (>= 1.1.1)
 
 GEM
@@ -39,12 +39,14 @@ GEM
     forgery (0.5.0)
     gherkin (2.9.3)
       json (>= 1.4.6)
-    json (1.7.0)
+    json (1.8.3)
     libwebsocket (0.1.3)
       addressable
     mime-types (1.18)
+    mini_portile (0.6.2)
     multi_json (1.3.4)
-    nokogiri (1.5.2)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
     rack (1.4.1)
     rack-test (0.6.1)
       rack (>= 1.0)

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2013 Mconf (http://mconf.org)
+Copyright (c) 2011-2015 Mconf (http://mconf.org)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/README.rdoc

@@ -22,8 +22,9 @@ A few features it has:
 
 The current version of this gem supports <em>all</em> the following versions of BigBlueButton:
 
-* 0.8
+* 0.9 (includes all 0.9.x)
 * 0.81
+* 0.8
 
 Older versions:
 
@@ -34,8 +35,10 @@ Older versions:
 
 Tested in rubies:
 
+* ruby-2.2.0 *recommended*
+* ruby-2.1.2
 * ruby-2.0.0 (p353)
-* ruby-1.9.3 (p484) *recommended*
+* ruby-1.9.3 (p484)
 * ruby-1.9.2 (p290)
 
 Use these versions to be sure it will work. Other patches of these rubies (e.g. ruby 1.9.3-p194) should work as well.

data/Rakefile

@@ -11,13 +11,16 @@ RSpec::Core::RakeTask.new(:spec)
 
 Cucumber::Rake::Task.new do |t|
 
+  # Disable all features that need the bot. It isn't working since BigBlueButton 0.81.
+  prepend = "--tags ~@need-bot"
+
   # in jruby the class BigBlueButtonBot doesn't work (it uses fork)
   if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'jruby'
     puts "Jruby detected, ignoring features with @need-bot"
     prepend = "--tags ~@need-bot"
   end
 
-  # defaults to BBB 0.81, that runs all tests
+  # defaults to the latest version, that runs all tests
   # if set to 0.8 only, won't run tests for newer versions
   if ENV["V"] == "0.8" or ENV["VERSION"] == "0.8"
     t.cucumber_opts = "--format pretty --tags ~@wip --tags @version-all #{prepend}"

data/bigbluebutton-api-ruby.gemspec

@@ -1,17 +1,18 @@
 $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
-  s.name = 'bigbluebutton-api-ruby'
-  s.version = '1.3.0'
+  s.name             = 'bigbluebutton-api-ruby'
+  s.version          = '1.4.0'
+  s.licenses         = ['MIT']
   s.extra_rdoc_files = ['README.rdoc', 'LICENSE', 'LICENSE_003', 'CHANGELOG.rdoc']
-  s.summary = 'Provides an interface to the BigBlueButton web meeting API (https://github.com/mconf/bigbluebutton-api-ruby)'
-  s.description = s.summary
-  s.authors = ['Leonardo Crauss Daronco', 'Joe Kinsella']
-  s.email = ['leonardodaronco@gmail.com', 'joe.kinsella@gmail.com']
-  s.homepage = "https://github.com/mconf/bigbluebutton-api-ruby/"
-  s.bindir = "bin"
-  s.files = `git ls-files`.split("\n")
-  s.require_paths = ["lib"]
+  s.summary          = 'Provides an interface to the BigBlueButton web meeting API (https://github.com/mconf/bigbluebutton-api-ruby)'
+  s.description      = s.summary
+  s.authors          = ['Leonardo Crauss Daronco', 'Joe Kinsella']
+  s.email            = ['leonardodaronco@gmail.com', 'joe.kinsella@gmail.com']
+  s.homepage         = "https://github.com/mconf/bigbluebutton-api-ruby/"
+  s.bindir           = "bin"
+  s.files            = `git ls-files`.split("\n")
+  s.require_paths    = ["lib"]
 
   s.add_runtime_dependency('xml-simple', '>= 1.1.1')
 end

data/examples/join_example.rb

@@ -10,7 +10,6 @@ begin
   meeting_name = "Test Meeting"
   meeting_id = "test-meeting"
   moderator_name = "House"
-  attendee_name = "Cameron"
   unless @api.is_meeting_running?(meeting_id)
     puts "---------------------------------------------------"
     options = { :moderatorPW => "54321",

data/features/config.yml.example

@@ -10,13 +10,11 @@ timeout_ending: 30
 timeout_bot_start: 60
 
 servers:
-  test-install-081:
+  test-install-091:
     salt: '8cd8ef52e8e101574e400365b55e11a6'
     url: 'http://test-install.blindsidenetworks.com/bigbluebutton/api'
-    version: '0.81'
-    mobile_salt: '03b07' # needed for >= 0.8
+    version: '0.9'
   bbb-08:
     salt: 'lka98f52e8akdlsoie400365b55e98s7'
     url: 'http://yourserver.com/bigbluebutton/api'
     version: '0.8'
-    mobile_salt: '03b07' # needed for >= 0.8

data/lib/bigbluebutton_api.rb

@@ -67,8 +67,8 @@ module BigBlueButton
     # url::       URL to a BigBlueButton server (e.g. http://demo.bigbluebutton.org/bigbluebutton/api)
     # salt::      Secret salt for this server
     # version::   API version e.g. 0.81
-    def initialize(url, salt, version='0.81', debug=false)
-      @supported_versions = ['0.8', '0.81']
+    def initialize(url, salt, version='0.9', debug=false)
+      @supported_versions = ['0.8', '0.81', '0.9']
       @url = url
       @salt = salt
       @debug = debug

data/spec/bigbluebutton_api_0.9_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+# Tests for BBB API version 0.81
+describe BigBlueButton::BigBlueButtonApi do
+
+  # default variables and API object for all tests
+  let(:url) { "http://server.com" }
+  let(:salt) { "1234567890abcdefghijkl" }
+  let(:version) { "0.9" }
+  let(:debug) { false }
+  let(:api) { BigBlueButton::BigBlueButtonApi.new(url, salt, version, debug) }
+
+  describe "#create_meeting" do
+    context "accepts the new parameters" do
+      let(:req_params) {
+        { :name => "name", :meetingID => "meeting-id",
+          :moderatorOnlyMessage => "my-msg", :autoStartRecording => "false",
+          :allowStartStopRecording => "true"
+        }
+      }
+
+      before { api.should_receive(:send_api_request).with(:create, req_params) }
+      it {
+        options = {
+          :moderatorOnlyMessage => "my-msg",
+          :autoStartRecording => "false",
+          :allowStartStopRecording => "true"
+        }
+        api.create_meeting("name", "meeting-id", options)
+      }
+    end
+  end
+end

data/spec/bigbluebutton_api_spec.rb

@@ -4,728 +4,734 @@ require 'spec_helper'
 #   there are separate files with more tests.
 describe BigBlueButton::BigBlueButtonApi do
 
-  # default variables and API object for all tests
-  let(:url) { "http://server.com" }
-  let(:salt) { "1234567890abcdefghijkl" }
-  let(:version) { "0.8" }
-  let(:debug) { false }
-  let(:api) { BigBlueButton::BigBlueButtonApi.new(url, salt, version, debug) }
-
-  describe "#initialize" do
-    context "standard initialization" do
-      subject { BigBlueButton::BigBlueButtonApi.new(url, salt, version, debug) }
-      it { subject.url.should == url }
-      it { subject.salt.should == salt }
-      it { subject.version.should == version }
-      it { subject.debug.should == debug }
-      it { subject.timeout.should == 10 }
-      it { subject.supported_versions.should include("0.8") }
-      it { subject.supported_versions.should include("0.81") }
-      it { subject.request_headers.should == {} }
-    end
+  shared_examples_for "BigBlueButtonApi" do |version|
+
+    # default variables and API object for all tests
+    let(:url) { "http://server.com" }
+    let(:salt) { "1234567890abcdefghijkl" }
+    let(:debug) { false }
+    let(:api) { BigBlueButton::BigBlueButtonApi.new(url, salt, version, debug) }
+
+    describe "#initialize" do
+      context "standard initialization" do
+        subject { BigBlueButton::BigBlueButtonApi.new(url, salt, version, debug) }
+        it { subject.url.should == url }
+        it { subject.salt.should == salt }
+        it { subject.version.should == version }
+        it { subject.debug.should == debug }
+        it { subject.timeout.should == 10 }
+        it { subject.supported_versions.should include("0.8") }
+        it { subject.supported_versions.should include("0.81") }
+        it { subject.supported_versions.should include("0.9") }
+        it { subject.request_headers.should == {} }
+      end
 
-    context "when the version is not informed, get it from the BBB server" do
-      before { BigBlueButton::BigBlueButtonApi.any_instance.should_receive(:get_api_version).and_return("0.8") }
-      subject { BigBlueButton::BigBlueButtonApi.new(url, salt, nil) }
-      it { subject.version.should == "0.8" }
-    end
+      context "when the version is not informed, get it from the BBB server" do
+        before { BigBlueButton::BigBlueButtonApi.any_instance.should_receive(:get_api_version).and_return("0.8") }
+        subject { BigBlueButton::BigBlueButtonApi.new(url, salt, nil) }
+        it { subject.version.should == "0.8" }
+      end
 
-    it "when the version is not supported raise an error" do
-      expect {
-        BigBlueButton::BigBlueButtonApi.new(url, salt, "0.not-supported", nil)
-      }.to raise_error(BigBlueButton::BigBlueButtonException)
-    end
+      it "when the version is not supported raise an error" do
+        expect {
+          BigBlueButton::BigBlueButtonApi.new(url, salt, "0.not-supported", nil)
+        }.to raise_error(BigBlueButton::BigBlueButtonException)
+      end
 
-    context "current supported versions" do
-      subject { BigBlueButton::BigBlueButtonApi.new(url, salt) }
-      it { subject.supported_versions.should == ["0.8", "0.81"] }
+      context "current supported versions" do
+        subject { BigBlueButton::BigBlueButtonApi.new(url, salt) }
+        it { subject.supported_versions.should == ["0.8", "0.81", "0.9"] }
+      end
     end
-  end
 
-  describe "#create_meeting" do
-    context "standard case" do
-      let(:req_params) {
-        { :name => "name", :meetingID => "meeting-id", :moderatorPW => "mp", :attendeePW => "ap",
-          :welcome => "Welcome!", :dialNumber => 12345678, :logoutURL => "http://example.com",
-          :maxParticipants => 25, :voiceBridge => 12345, :webVoice => "12345abc", :record => "true" }
-      }
-      let(:req_response) {
-        { :meetingID => 123, :moderatorPW => 111, :attendeePW => 222, :hasBeenForciblyEnded => "FALSE" }
-      }
-      let(:final_response) {
-        { :meetingID => "123", :moderatorPW => "111", :attendeePW => "222", :hasBeenForciblyEnded => false }
-      }
+    describe "#create_meeting" do
+      context "standard case" do
+        let(:req_params) {
+          { :name => "name", :meetingID => "meeting-id", :moderatorPW => "mp", :attendeePW => "ap",
+            :welcome => "Welcome!", :dialNumber => 12345678, :logoutURL => "http://example.com",
+            :maxParticipants => 25, :voiceBridge => 12345, :webVoice => "12345abc", :record => "true" }
+        }
+        let(:req_response) {
+          { :meetingID => 123, :moderatorPW => 111, :attendeePW => 222, :hasBeenForciblyEnded => "FALSE" }
+        }
+        let(:final_response) {
+          { :meetingID => "123", :moderatorPW => "111", :attendeePW => "222", :hasBeenForciblyEnded => false }
+        }
 
-      # ps: not mocking the formatter here because it's easier to just check the results (final_response)
-      before { api.should_receive(:send_api_request).with(:create, req_params).and_return(req_response) }
-      subject {
-        options = { :moderatorPW => "mp", :attendeePW => "ap", :welcome => "Welcome!",
-          :dialNumber => 12345678, :logoutURL => "http://example.com", :maxParticipants => 25,
-          :voiceBridge => 12345, :webVoice => "12345abc", :record => "true" }
-        api.create_meeting("name", "meeting-id", options)
-      }
-      it { subject.should == final_response }
-    end
+        # ps: not mocking the formatter here because it's easier to just check the results (final_response)
+        before { api.should_receive(:send_api_request).with(:create, req_params).and_return(req_response) }
+        subject {
+          options = { :moderatorPW => "mp", :attendeePW => "ap", :welcome => "Welcome!",
+            :dialNumber => 12345678, :logoutURL => "http://example.com", :maxParticipants => 25,
+            :voiceBridge => 12345, :webVoice => "12345abc", :record => "true" }
+          api.create_meeting("name", "meeting-id", options)
+        }
+        it { subject.should == final_response }
+      end
 
-    context "accepts non standard options" do
-      let(:params) {
-        { :name => "name", :meetingID => "meeting-id",
-          :moderatorPW => "mp", :attendeePW => "ap", :nonStandard => 1 }
-      }
-      before { api.should_receive(:send_api_request).with(:create, params) }
-      it { api.create_meeting("name", "meeting-id", params) }
-    end
+      context "accepts non standard options" do
+        let(:params) {
+          { :name => "name", :meetingID => "meeting-id",
+            :moderatorPW => "mp", :attendeePW => "ap", :nonStandard => 1 }
+        }
+        before { api.should_receive(:send_api_request).with(:create, params) }
+        it { api.create_meeting("name", "meeting-id", params) }
+      end
 
-    context "accepts :record as boolean" do
-      let(:req_params) {
-        { :name => "name", :meetingID => "meeting-id",
-          :moderatorPW => "mp", :attendeePW => "ap", :record => "true" }
-      }
-      before { api.should_receive(:send_api_request).with(:create, req_params) }
-      it {
-        params = { :name => "name", :meetingID => "meeting-id",
-          :moderatorPW => "mp", :attendeePW => "ap", :record => true }
-        api.create_meeting("name", "meeting-id", params)
-      }
-    end
+      context "accepts :record as boolean" do
+        let(:req_params) {
+          { :name => "name", :meetingID => "meeting-id",
+            :moderatorPW => "mp", :attendeePW => "ap", :record => "true" }
+        }
+        before { api.should_receive(:send_api_request).with(:create, req_params) }
+        it {
+          params = { :name => "name", :meetingID => "meeting-id",
+            :moderatorPW => "mp", :attendeePW => "ap", :record => true }
+          api.create_meeting("name", "meeting-id", params)
+        }
+      end
 
-    context "with modules" do
-      let(:req_params) {
-        { :name => "name", :meetingID => "meeting-id", :moderatorPW => "mp", :attendeePW => "ap" }
-      }
-      let(:req_response) {
-        { :meetingID => 123, :moderatorPW => 111, :attendeePW => 222, :hasBeenForciblyEnded => "FALSE", :createTime => "123123123" }
-      }
-      let(:final_response) {
-        { :meetingID => "123", :moderatorPW => "111", :attendeePW => "222", :hasBeenForciblyEnded => false, :createTime => 123123123 }
-      }
-      let(:modules) {
-        m = BigBlueButton::BigBlueButtonModules.new
-        m.add_presentation(:url, "http://www.samplepdf.com/sample.pdf")
-        m.add_presentation(:url, "http://www.samplepdf.com/sample2.pdf")
-        m.add_presentation(:base64, "JVBERi0xLjQKJ....[clipped here]....0CiUlRU9GCg==", "first-class.pdf")
-        m
-      }
+      context "with modules" do
+        let(:req_params) {
+          { :name => "name", :meetingID => "meeting-id", :moderatorPW => "mp", :attendeePW => "ap" }
+        }
+        let(:req_response) {
+          { :meetingID => 123, :moderatorPW => 111, :attendeePW => 222, :hasBeenForciblyEnded => "FALSE", :createTime => "123123123" }
+        }
+        let(:final_response) {
+          { :meetingID => "123", :moderatorPW => "111", :attendeePW => "222", :hasBeenForciblyEnded => false, :createTime => 123123123 }
+        }
+        let(:modules) {
+          m = BigBlueButton::BigBlueButtonModules.new
+          m.add_presentation(:url, "http://www.samplepdf.com/sample.pdf")
+          m.add_presentation(:url, "http://www.samplepdf.com/sample2.pdf")
+          m.add_presentation(:base64, "JVBERi0xLjQKJ....[clipped here]....0CiUlRU9GCg==", "first-class.pdf")
+          m
+        }
 
-      before {
-        api.should_receive(:send_api_request).with(:create, req_params, modules.to_xml).
+        before {
+          api.should_receive(:send_api_request).with(:create, req_params, modules.to_xml).
           and_return(req_response)
-      }
-      subject {
-        options = { :moderatorPW => "mp", :attendeePW => "ap" }
-        api.create_meeting("name", "meeting-id", options, modules)
-      }
-      it { subject.should == final_response }
-    end
+        }
+        subject {
+          options = { :moderatorPW => "mp", :attendeePW => "ap" }
+          api.create_meeting("name", "meeting-id", options, modules)
+        }
+        it { subject.should == final_response }
+      end
 
-    context "without modules" do
-      let(:req_params) {
-        { :name => "name", :meetingID => "meeting-id", :moderatorPW => "mp", :attendeePW => "ap",
-          :welcome => "Welcome!", :dialNumber => 12345678, :logoutURL => "http://example.com",
-          :maxParticipants => 25, :voiceBridge => 12345, :record => "true", :duration => 20,
-          :meta_1 => "meta1", :meta_2 => "meta2" }
-      }
-      let(:req_response) {
-        { :meetingID => 123, :moderatorPW => 111, :attendeePW => 222, :hasBeenForciblyEnded => "FALSE", :createTime => "123123123" }
-      }
-      let(:final_response) {
-        { :meetingID => "123", :moderatorPW => "111", :attendeePW => "222", :hasBeenForciblyEnded => false, :createTime => 123123123 }
-      }
+      context "without modules" do
+        let(:req_params) {
+          { :name => "name", :meetingID => "meeting-id", :moderatorPW => "mp", :attendeePW => "ap",
+            :welcome => "Welcome!", :dialNumber => 12345678, :logoutURL => "http://example.com",
+            :maxParticipants => 25, :voiceBridge => 12345, :record => "true", :duration => 20,
+            :meta_1 => "meta1", :meta_2 => "meta2" }
+        }
+        let(:req_response) {
+          { :meetingID => 123, :moderatorPW => 111, :attendeePW => 222, :hasBeenForciblyEnded => "FALSE", :createTime => "123123123" }
+        }
+        let(:final_response) {
+          { :meetingID => "123", :moderatorPW => "111", :attendeePW => "222", :hasBeenForciblyEnded => false, :createTime => 123123123 }
+        }
 
-      before { api.should_receive(:send_api_request).with(:create, req_params).and_return(req_response) }
-      subject {
-        options = { :moderatorPW => "mp", :attendeePW => "ap", :welcome => "Welcome!", :dialNumber => 12345678,
-          :logoutURL => "http://example.com", :maxParticipants => 25, :voiceBridge => 12345, :record => true,
-          :duration => 20, :meta_1 => "meta1", :meta_2 => "meta2" }
-        api.create_meeting("name", "meeting-id", options)
-      }
-      it { subject.should == final_response }
+        before { api.should_receive(:send_api_request).with(:create, req_params).and_return(req_response) }
+        subject {
+          options = { :moderatorPW => "mp", :attendeePW => "ap", :welcome => "Welcome!", :dialNumber => 12345678,
+            :logoutURL => "http://example.com", :maxParticipants => 25, :voiceBridge => 12345, :record => true,
+            :duration => 20, :meta_1 => "meta1", :meta_2 => "meta2" }
+          api.create_meeting("name", "meeting-id", options)
+        }
+        it { subject.should == final_response }
+      end
     end
-  end
 
-  describe "#end_meeting" do
-    let(:meeting_id) { "meeting-id" }
-    let(:moderator_password) { "password" }
+    describe "#end_meeting" do
+      let(:meeting_id) { "meeting-id" }
+      let(:moderator_password) { "password" }
 
-    context "standard case" do
-      let(:params) { { :meetingID => meeting_id, :password => moderator_password } }
-      let(:response) { "anything" }
+      context "standard case" do
+        let(:params) { { :meetingID => meeting_id, :password => moderator_password } }
+        let(:response) { "anything" }
 
-      before { api.should_receive(:send_api_request).with(:end, params).and_return(response) }
-      it { api.end_meeting(meeting_id, moderator_password).should == response }
-    end
+        before { api.should_receive(:send_api_request).with(:end, params).and_return(response) }
+        it { api.end_meeting(meeting_id, moderator_password).should == response }
+      end
 
-    context "accepts non standard options" do
-      let(:params_in) {
-        { :anything1 => "anything-1", :anything2 => 2 }
-      }
-      let(:params_out) {
-        { :meetingID => meeting_id, :password => moderator_password,
-          :anything1 => "anything-1", :anything2 => 2 }
-      }
-      before { api.should_receive(:send_api_request).with(:end, params_out) }
-      it { api.end_meeting(meeting_id, moderator_password, params_in) }
+      context "accepts non standard options" do
+        let(:params_in) {
+          { :anything1 => "anything-1", :anything2 => 2 }
+        }
+        let(:params_out) {
+          { :meetingID => meeting_id, :password => moderator_password,
+            :anything1 => "anything-1", :anything2 => 2 }
+        }
+        before { api.should_receive(:send_api_request).with(:end, params_out) }
+        it { api.end_meeting(meeting_id, moderator_password, params_in) }
+      end
     end
-  end
 
-  describe "#is_meeting_running?" do
-    let(:meeting_id) { "meeting-id" }
-    let(:params) { { :meetingID => meeting_id } }
+    describe "#is_meeting_running?" do
+      let(:meeting_id) { "meeting-id" }
+      let(:params) { { :meetingID => meeting_id } }
 
-    context "when the meeting is running" do
-      let(:response) { { :running => "TRUE" } }
-      before { api.should_receive(:send_api_request).with(:isMeetingRunning, params).and_return(response) }
-      it { api.is_meeting_running?(meeting_id).should == true }
-    end
+      context "when the meeting is running" do
+        let(:response) { { :running => "TRUE" } }
+        before { api.should_receive(:send_api_request).with(:isMeetingRunning, params).and_return(response) }
+        it { api.is_meeting_running?(meeting_id).should == true }
+      end
 
-    context "when the meeting is not running" do
-      let(:response) { { :running => "FALSE" } }
-      before { api.should_receive(:send_api_request).with(:isMeetingRunning, params).and_return(response) }
-      it { api.is_meeting_running?(meeting_id).should == false }
-    end
+      context "when the meeting is not running" do
+        let(:response) { { :running => "FALSE" } }
+        before { api.should_receive(:send_api_request).with(:isMeetingRunning, params).and_return(response) }
+        it { api.is_meeting_running?(meeting_id).should == false }
+      end
 
-    context "accepts non standard options" do
-      let(:params_in) {
-        { :anything1 => "anything-1", :anything2 => 2 }
-      }
-      let(:params_out) {
-        { :meetingID => meeting_id, :anything1 => "anything-1", :anything2 => 2 }
-      }
-      before { api.should_receive(:send_api_request).with(:isMeetingRunning, params_out) }
-      it { api.is_meeting_running?(meeting_id, params_in) }
+      context "accepts non standard options" do
+        let(:params_in) {
+          { :anything1 => "anything-1", :anything2 => 2 }
+        }
+        let(:params_out) {
+          { :meetingID => meeting_id, :anything1 => "anything-1", :anything2 => 2 }
+        }
+        before { api.should_receive(:send_api_request).with(:isMeetingRunning, params_out) }
+        it { api.is_meeting_running?(meeting_id, params_in) }
+      end
     end
-  end
 
-  describe "#join_meeting_url" do
-    context "standard case" do
-      let(:params) {
-        { :meetingID => "meeting-id", :password => "pw", :fullName => "Name",
-          :userID => "id123", :webVoiceConf => 12345678, :createTime => 9876543 }
-      }
+    describe "#join_meeting_url" do
+      context "standard case" do
+        let(:params) {
+          { :meetingID => "meeting-id", :password => "pw", :fullName => "Name",
+            :userID => "id123", :webVoiceConf => 12345678, :createTime => 9876543 }
+        }
 
-      before { api.should_receive(:get_url).with(:join, params).and_return("test-url") }
-      it {
-        options = { :userID => "id123", :webVoiceConf => 12345678, :createTime => 9876543 }
-        api.join_meeting_url("meeting-id", "Name", "pw", options).should == "test-url"
-      }
-    end
+        before { api.should_receive(:get_url).with(:join, params).and_return("test-url") }
+        it {
+          options = { :userID => "id123", :webVoiceConf => 12345678, :createTime => 9876543 }
+          api.join_meeting_url("meeting-id", "Name", "pw", options).should == "test-url"
+        }
+      end
 
-    context "accepts non standard options" do
-      let(:params) {
-        { :meetingID => "meeting-id", :password => "pw",
-          :fullName => "Name", :userID => "id123", :nonStandard => 1 }
-      }
-      before { api.should_receive(:get_url).with(:join, params) }
-      it { api.join_meeting_url("meeting-id", "Name", "pw", params) }
+      context "accepts non standard options" do
+        let(:params) {
+          { :meetingID => "meeting-id", :password => "pw",
+            :fullName => "Name", :userID => "id123", :nonStandard => 1 }
+        }
+        before { api.should_receive(:get_url).with(:join, params) }
+        it { api.join_meeting_url("meeting-id", "Name", "pw", params) }
+      end
     end
-  end
-
-  describe "#get_meeting_info" do
-    let(:meeting_id) { "meeting-id" }
-    let(:password) { "password" }
 
-    context "standard case" do
-      let(:params) { { :meetingID => meeting_id, :password => password } }
+    describe "#get_meeting_info" do
+      let(:meeting_id) { "meeting-id" }
+      let(:password) { "password" }
+
+      context "standard case" do
+        let(:params) { { :meetingID => meeting_id, :password => password } }
+
+        let(:attendee1) { { :userID => 123, :fullName => "Dexter Morgan", :role => "MODERATOR" } }
+        let(:attendee2) { { :userID => "id2", :fullName => "Cameron", :role => "VIEWER" } }
+        let(:response) {
+          { :meetingID => 123, :moderatorPW => 111, :attendeePW => 222, :hasBeenForciblyEnded => "FALSE",
+            :running => "TRUE", :startTime => "Thu Sep 01 17:51:42 UTC 2011", :endTime => "null",
+            :returncode => true, :attendees => { :attendee => [ attendee1, attendee2 ] },
+            :messageKey => "mkey", :message => "m", :participantCount => "50", :moderatorCount => "3",
+            :meetingName => "meeting-name", :maxUsers => "100", :voiceBridge => "12341234", :createTime => "123123123",
+            :recording => "false", :meta_1 => "abc", :meta_2 => "2" }
+        } # hash after the send_api_request call, before the formatting
+
+        let(:expected_attendee1) { { :userID => "123", :fullName => "Dexter Morgan", :role => :moderator } }
+        let(:expected_attendee2) { { :userID => "id2", :fullName => "Cameron", :role => :viewer } }
+        let(:final_response) {
+          { :meetingID => "123", :moderatorPW => "111", :attendeePW => "222", :hasBeenForciblyEnded => false,
+            :running => true, :startTime => DateTime.parse("Thu Sep 01 17:51:42 UTC 2011"), :endTime => nil,
+            :returncode => true, :attendees => [ expected_attendee1, expected_attendee2 ],
+            :messageKey => "mkey", :message => "m", :participantCount => 50, :moderatorCount => 3,
+            :meetingName => "meeting-name", :maxUsers => 100, :voiceBridge => 12341234, :createTime => 123123123,
+            :recording => false, :meta_1 => "abc", :meta_2 => "2" }
+        } # expected return hash after all the formatting
+
+        # ps: not mocking the formatter here because it's easier to just check the results (final_response)
+        before { api.should_receive(:send_api_request).with(:getMeetingInfo, params).and_return(response) }
+        it { api.get_meeting_info(meeting_id, password).should == final_response }
+      end
 
-      let(:attendee1) { { :userID => 123, :fullName => "Dexter Morgan", :role => "MODERATOR" } }
-      let(:attendee2) { { :userID => "id2", :fullName => "Cameron", :role => "VIEWER" } }
-      let(:response) {
-        { :meetingID => 123, :moderatorPW => 111, :attendeePW => 222, :hasBeenForciblyEnded => "FALSE",
-          :running => "TRUE", :startTime => "Thu Sep 01 17:51:42 UTC 2011", :endTime => "null",
-          :returncode => true, :attendees => { :attendee => [ attendee1, attendee2 ] },
-          :messageKey => "mkey", :message => "m", :participantCount => "50", :moderatorCount => "3",
-          :meetingName => "meeting-name", :maxUsers => "100", :voiceBridge => "12341234", :createTime => "123123123",
-          :recording => "false", :meta_1 => "abc", :meta_2 => "2" }
-      } # hash after the send_api_request call, before the formatting
-
-      let(:expected_attendee1) { { :userID => "123", :fullName => "Dexter Morgan", :role => :moderator } }
-      let(:expected_attendee2) { { :userID => "id2", :fullName => "Cameron", :role => :viewer } }
-      let(:final_response) {
-        { :meetingID => "123", :moderatorPW => "111", :attendeePW => "222", :hasBeenForciblyEnded => false,
-          :running => true, :startTime => DateTime.parse("Thu Sep 01 17:51:42 UTC 2011"), :endTime => nil,
-          :returncode => true, :attendees => [ expected_attendee1, expected_attendee2 ],
-          :messageKey => "mkey", :message => "m", :participantCount => 50, :moderatorCount => 3,
-          :meetingName => "meeting-name", :maxUsers => 100, :voiceBridge => 12341234, :createTime => 123123123,
-          :recording => false, :meta_1 => "abc", :meta_2 => "2" }
-      } # expected return hash after all the formatting
-
-      # ps: not mocking the formatter here because it's easier to just check the results (final_response)
-      before { api.should_receive(:send_api_request).with(:getMeetingInfo, params).and_return(response) }
-      it { api.get_meeting_info(meeting_id, password).should == final_response }
+      context "accepts non standard options" do
+        let(:params_in) {
+          { :anything1 => "anything-1", :anything2 => 2 }
+        }
+        let(:params_out) {
+          { :meetingID => meeting_id, :password => password,
+            :anything1 => "anything-1", :anything2 => 2 }
+        }
+        before { api.should_receive(:send_api_request).with(:getMeetingInfo, params_out).and_return({}) }
+        it { api.get_meeting_info(meeting_id, password, params_in) }
+      end
     end
 
-    context "accepts non standard options" do
-      let(:params_in) {
-        { :anything1 => "anything-1", :anything2 => 2 }
-      }
-      let(:params_out) {
-        { :meetingID => meeting_id, :password => password,
-          :anything1 => "anything-1", :anything2 => 2 }
-      }
-      before { api.should_receive(:send_api_request).with(:getMeetingInfo, params_out).and_return({}) }
-      it { api.get_meeting_info(meeting_id, password, params_in) }
+    describe "#get_meetings" do
+      context "standard case" do
+        let(:meeting_hash1) { { :meetingID => "Demo Meeting", :attendeePW => "ap", :moderatorPW => "mp", :hasBeenForciblyEnded => false, :running => true } }
+        let(:meeting_hash2) { { :meetingID => "Ended Meeting", :attendeePW => "pass", :moderatorPW => "pass", :hasBeenForciblyEnded => true, :running => false } }
+        let(:flattened_response) {
+          { :returncode => true, :meetings => [ meeting_hash1, meeting_hash2 ], :messageKey => "mkey", :message => "m" }
+        } # hash *after* the flatten_objects call
+
+        before {
+          api.should_receive(:send_api_request).with(:getMeetings, {}).
+          and_return(flattened_response)
+          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
+          formatter_mock.should_receive(:flatten_objects).with(:meetings, :meeting)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_mock)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:format_meeting).with(meeting_hash1)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:format_meeting).with(meeting_hash2)
+        }
+        it { api.get_meetings }
+      end
+
+      context "accepts non standard options" do
+        let(:params) {
+          { :anything1 => "anything-1", :anything2 => 2 }
+        }
+        before { api.should_receive(:send_api_request).with(:getMeetings, params).and_return({}) }
+        it { api.get_meetings(params) }
+      end
     end
-  end
 
-  describe "#get_meetings" do
-    context "standard case" do
-      let(:meeting_hash1) { { :meetingID => "Demo Meeting", :attendeePW => "ap", :moderatorPW => "mp", :hasBeenForciblyEnded => false, :running => true } }
-      let(:meeting_hash2) { { :meetingID => "Ended Meeting", :attendeePW => "pass", :moderatorPW => "pass", :hasBeenForciblyEnded => true, :running => false } }
-      let(:flattened_response) {
-        { :returncode => true, :meetings => [ meeting_hash1, meeting_hash2 ], :messageKey => "mkey", :message => "m" }
-      } # hash *after* the flatten_objects call
+    describe "#get_api_version" do
+      context "returns the version returned by the server" do
+        let(:hash) { { :returncode => true, :version => "0.8" } }
+        before { api.should_receive(:send_api_request).with(:index).and_return(hash) }
+        it { api.get_api_version.should == "0.8" }
+      end
 
-      before {
-        api.should_receive(:send_api_request).with(:getMeetings, {}).
-        and_return(flattened_response)
-        formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-        formatter_mock.should_receive(:flatten_objects).with(:meetings, :meeting)
-        BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_mock)
-        BigBlueButton::BigBlueButtonFormatter.should_receive(:format_meeting).with(meeting_hash1)
-        BigBlueButton::BigBlueButtonFormatter.should_receive(:format_meeting).with(meeting_hash2)
-      }
-      it { api.get_meetings }
+      context "returns an empty string when the server responds with an empty hash" do
+        before { api.should_receive(:send_api_request).with(:index).and_return({}) }
+        it { api.get_api_version.should == "" }
+      end
     end
 
-    context "accepts non standard options" do
-      let(:params) {
-        { :anything1 => "anything-1", :anything2 => 2 }
-      }
-      before { api.should_receive(:send_api_request).with(:getMeetings, params).and_return({}) }
-      it { api.get_meetings(params) }
+    describe "#test_connection" do
+      context "returns the returncode returned by the server" do
+        let(:hash) { { :returncode => "any-value" } }
+        before { api.should_receive(:send_api_request).with(:index).and_return(hash) }
+        it { api.test_connection.should == "any-value" }
+      end
     end
-  end
 
-  describe "#get_api_version" do
-    context "returns the version returned by the server" do
-      let(:hash) { { :returncode => true, :version => "0.8" } }
-      before { api.should_receive(:send_api_request).with(:index).and_return(hash) }
-      it { api.get_api_version.should == "0.8" }
-    end
+    describe "#==" do
+      let(:api2) { BigBlueButton::BigBlueButtonApi.new(url, salt, version, debug) }
 
-    context "returns an empty string when the server responds with an empty hash" do
-      before { api.should_receive(:send_api_request).with(:index).and_return({}) }
-      it { api.get_api_version.should == "" }
-    end
-  end
+      context "compares attributes" do
+        it { api.should == api2 }
+      end
 
-  describe "#test_connection" do
-    context "returns the returncode returned by the server" do
-      let(:hash) { { :returncode => "any-value" } }
-      before { api.should_receive(:send_api_request).with(:index).and_return(hash) }
-      it { api.test_connection.should == "any-value" }
-    end
-  end
+      context "differs #debug" do
+        before { api2.debug = !api.debug }
+        it { api.should_not == api2 }
+      end
 
-  describe "#==" do
-    let(:api2) { BigBlueButton::BigBlueButtonApi.new(url, salt, version, debug) }
+      context "differs #salt" do
+        before { api2.salt = api.salt + "x" }
+        it { api.should_not == api2 }
+      end
 
-    context "compares attributes" do
-      it { api.should == api2 }
-    end
+      context "differs #version" do
+        before { api2.version = api.version + "x" }
+        it { api.should_not == api2 }
+      end
 
-    context "differs #debug" do
-      before { api2.debug = !api.debug }
-      it { api.should_not == api2 }
+      context "differs #supported_versions" do
+        before { api2.supported_versions << "x" }
+        it { api.should_not == api2 }
+      end
     end
 
-    context "differs #salt" do
-      before { api2.salt = api.salt + "x" }
-      it { api.should_not == api2 }
-    end
+    describe "#last_http_response" do
+      # we test this through a #test_connection call
 
-    context "differs #version" do
-      before { api2.version = api.version + "x" }
-      it { api.should_not == api2 }
+      let(:request_mock) { mock }
+      before {
+        api.should_receive(:get_url)
+        # this return value will be stored in @http_response
+        api.should_receive(:send_request).and_return(request_mock)
+        # to return fast from #send_api_request
+        request_mock.should_receive(:body).and_return("")
+        api.test_connection
+      }
+      it { api.last_http_response.should == request_mock }
     end
 
-    context "differs #supported_versions" do
-      before { api2.supported_versions << "x" }
-      it { api.should_not == api2 }
+    describe "#last_xml_response" do
+      # we test this through a #test_connection call
+
+      let(:request_mock) { mock }
+      let(:expected_xml) { "<response><returncode>SUCCESS</returncode></response>" }
+      before {
+        api.should_receive(:get_url)
+        api.should_receive(:send_request).and_return(request_mock)
+        request_mock.should_receive(:body).at_least(1).and_return(expected_xml)
+        api.test_connection
+      }
+      it { api.last_xml_response.should == expected_xml }
     end
-  end
 
-  describe "#last_http_response" do
-    # we test this through a #test_connection call
-
-    let(:request_mock) { mock }
-    before {
-      api.should_receive(:get_url)
-      # this return value will be stored in @http_response
-      api.should_receive(:send_request).and_return(request_mock)
-      # to return fast from #send_api_request
-      request_mock.should_receive(:body).and_return("")
-      api.test_connection
-    }
-    it { api.last_http_response.should == request_mock }
-  end
+    describe "#get_url" do
 
-  describe "#last_xml_response" do
-    # we test this through a #test_connection call
-
-    let(:request_mock) { mock }
-    let(:expected_xml) { "<response><returncode>SUCCESS</returncode></response>" }
-    before {
-      api.should_receive(:get_url)
-      api.should_receive(:send_request).and_return(request_mock)
-      request_mock.should_receive(:body).at_least(1).and_return(expected_xml)
-      api.test_connection
-    }
-    it { api.last_xml_response.should == expected_xml }
-  end
+      context "when method = :index" do
+        it { api.get_url(:index).should == api.url }
+      end
 
-  describe "#get_url" do
+      context "when method != :index" do
+        context "validates the entire url" do
+          context "with params" do
+            let(:params) { { :param1 => "value1", :param2 => "value2" } }
+            subject { api.get_url(:join, params) }
+            it {
+              # the hash can be sorted differently depending on the ruby version
+              if params.map{ |k,v| "#{k}" }.join =~ /^param1/
+                subject.should match(/#{url}\/join\?param1=value1&param2=value2/)
+              else
+                subject.should match(/#{url}\/join\?param2=value2&param1=value1/)
+              end
+            }
+          end
 
-    context "when method = :index" do
-      it { api.get_url(:index).should == api.url }
-    end
+          context "without params" do
+            subject { api.get_url(:join) }
+            it { subject.should match(/#{url}\/join\?[^&]/) }
+          end
+        end
 
-    context "when method != :index" do
-      context "validates the entire url" do
-        context "with params" do
-          let(:params) { { :param1 => "value1", :param2 => "value2" } }
+        context "discards params with nil value" do
+          let(:params) { { :param1 => "value1", :param2 => nil } }
+          subject { api.get_url(:join, params) }
+          it { subject.should_not match(/param2=/) }
+        end
+
+        context "escapes all params" do
+          let(:params) { { :param1 => "value with spaces", :param2 => "@$" } }
           subject { api.get_url(:join, params) }
-          it {
+          it { subject.should match(/param1=value\+with\+spaces/) }
+          it { subject.should match(/param2=%40%24/) }
+        end
+
+        context "includes the checksum" do
+          let(:params) { { :param1 => "value1", :param2 => "value2" } }
+          let(:checksum) {
             # the hash can be sorted differently depending on the ruby version
             if params.map{ |k,v| "#{k}" }.join =~ /^param1/
-              subject.should match(/#{url}\/join\?param1=value1&param2=value2/)
+              "67882ae54f49600f56f358c10d24697ef7d8c6b2"
             else
-              subject.should match(/#{url}\/join\?param2=value2&param1=value1/)
+              "85a54e28e4ec18bfdcb214a73f74d35b09a84176"
             end
           }
-        end
-
-        context "without params" do
-          subject { api.get_url(:join) }
-          it { subject.should match(/#{url}\/join\?[^&]/) }
+          subject { api.get_url(:join, params) }
+          it { subject.should match(/checksum=#{checksum}$/) }
         end
       end
+    end
 
-      context "discards params with nil value" do
-        let(:params) { { :param1 => "value1", :param2 => nil } }
-        subject { api.get_url(:join, params) }
-        it { subject.should_not match(/param2=/) }
-      end
+    describe "#send_api_request" do
+      let(:method) { :join }
+      let(:params) { { :param1 => "value1" } }
+      let(:data) { "any data" }
+      let(:url) { "http://test-server:8080?param1=value1&checksum=12345" }
+      let(:make_request) { api.send_api_request(method, params, data) }
+      let(:response_mock) { mock() } # mock of what send_request() would return
 
-      context "escapes all params" do
-        let(:params) { { :param1 => "value with spaces", :param2 => "@$" } }
-        subject { api.get_url(:join, params) }
-        it { subject.should match(/param1=value\+with\+spaces/) }
-        it { subject.should match(/param2=%40%24/) }
-      end
+      before { api.should_receive(:get_url).with(method, params).and_return(url) }
 
-      context "includes the checksum" do
-        let(:params) { { :param1 => "value1", :param2 => "value2" } }
-        let(:checksum) {
-          # the hash can be sorted differently depending on the ruby version
-          if params.map{ |k,v| "#{k}" }.join =~ /^param1/
-            "67882ae54f49600f56f358c10d24697ef7d8c6b2"
-          else
-            "85a54e28e4ec18bfdcb214a73f74d35b09a84176"
-          end
-        }
-        subject { api.get_url(:join, params) }
-        it { subject.should match(/checksum=#{checksum}$/) }
+      context "returns an empty hash if the response body is empty" do
+        before do
+          api.should_receive(:send_request).with(url, data).and_return(response_mock)
+          response_mock.should_receive(:body).and_return("")
+        end
+        it { make_request.should == { } }
       end
-    end
-  end
-
-  describe "#send_api_request" do
-    let(:method) { :join }
-    let(:params) { { :param1 => "value1" } }
-    let(:data) { "any data" }
-    let(:url) { "http://test-server:8080?param1=value1&checksum=12345" }
-    let(:make_request) { api.send_api_request(method, params, data) }
-    let(:response_mock) { mock() } # mock of what send_request() would return
 
-    before { api.should_receive(:get_url).with(method, params).and_return(url) }
+      context "hashfies and validates the response body" do
+        before do
+          api.should_receive(:send_request).with(url, data).and_return(response_mock)
+          response_mock.should_receive(:body).twice.and_return("response-body")
+        end
 
-    context "returns an empty hash if the response body is empty" do
-      before do
-        api.should_receive(:send_request).with(url, data).and_return(response_mock)
-        response_mock.should_receive(:body).and_return("")
-      end
-      it { make_request.should == { } }
-    end
+        context "checking if it has a :response key" do
+          before { BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return({ }) }
+          it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
+        end
 
-    context "hashfies and validates the response body" do
-      before do
-        api.should_receive(:send_request).with(url, data).and_return(response_mock)
-        response_mock.should_receive(:body).twice.and_return("response-body")
+        context "checking if it the :response key has a :returncode key" do
+          before { BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return({ :response => { } }) }
+          it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
+        end
       end
 
-      context "checking if it has a :response key" do
-        before { BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return({ }) }
-        it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
+      context "formats the response hash" do
+        let(:response) { { :returncode => "SUCCESS" } }
+        let(:formatted_response) { { :returncode => true, :messageKey => "", :message => "" } }
+        before do
+          api.should_receive(:send_request).with(url, data).and_return(response_mock)
+          response_mock.should_receive(:body).twice.and_return("response-body")
+          BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return(response)
+
+          # here starts the validation
+          # doesn't test the resulting format, only that the formatter was called
+          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_mock)
+          formatter_mock.should_receive(:default_formatting).and_return(formatted_response)
+        end
+        it { make_request }
       end
 
-      context "checking if it the :response key has a :returncode key" do
-        before { BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return({ :response => { } }) }
+      context "raise an error if the formatted response has no :returncode" do
+        let(:response) { { :returncode => true } }
+        let(:formatted_response) { { } }
+        before do
+          api.should_receive(:send_request).with(url, data).and_return(response_mock)
+          response_mock.should_receive(:body).twice.and_return("response-body")
+          BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return(response)
+
+          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_mock)
+          formatter_mock.should_receive(:default_formatting).and_return(formatted_response)
+        end
         it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
       end
     end
 
-    context "formats the response hash" do
-      let(:response) { { :returncode => "SUCCESS" } }
-      let(:formatted_response) { { :returncode => true, :messageKey => "", :message => "" } }
-      before do
-        api.should_receive(:send_request).with(url, data).and_return(response_mock)
-        response_mock.should_receive(:body).twice.and_return("response-body")
-        BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return(response)
+    describe "#send_request" do
+      let(:url) { "http://test-server:8080/res?param1=value1&checksum=12345" }
+      let(:url_parsed) { URI.parse(url) }
 
-        # here starts the validation
-        # doesn't test the resulting format, only that the formatter was called
-        formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-        BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_mock)
-        formatter_mock.should_receive(:default_formatting).and_return(formatted_response)
-      end
-      it { make_request }
-    end
-
-    context "raise an error if the formatted response has no :returncode" do
-      let(:response) { { :returncode => true } }
-      let(:formatted_response) { { } }
       before do
-        api.should_receive(:send_request).with(url, data).and_return(response_mock)
-        response_mock.should_receive(:body).twice.and_return("response-body")
-        BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return(response)
-
-        formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-        BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_mock)
-        formatter_mock.should_receive(:default_formatting).and_return(formatted_response)
+        @http_mock = mock(Net::HTTP)
+        @http_mock.should_receive(:"open_timeout=").with(api.timeout)
+        @http_mock.should_receive(:"read_timeout=").with(api.timeout)
+        Net::HTTP.should_receive(:new).with("test-server", 8080).and_return(@http_mock)
       end
-      it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
-    end
-  end
 
-  describe "#send_request" do
-    let(:url) { "http://test-server:8080/res?param1=value1&checksum=12345" }
-    let(:url_parsed) { URI.parse(url) }
+      context "standard case" do
+        before { @http_mock.should_receive(:get).with("/res?param1=value1&checksum=12345", {}).and_return("ok") }
+        it { api.send(:send_request, url).should == "ok" }
+      end
 
-    before do
-      @http_mock = mock(Net::HTTP)
-      @http_mock.should_receive(:"open_timeout=").with(api.timeout)
-      @http_mock.should_receive(:"read_timeout=").with(api.timeout)
-      Net::HTTP.should_receive(:new).with("test-server", 8080).and_return(@http_mock)
-    end
+      context "handles a TimeoutError" do
+        before { @http_mock.should_receive(:get) { raise TimeoutError } }
+        it { expect { api.send(:send_request, url) }.to raise_error(BigBlueButton::BigBlueButtonException) }
+      end
 
-    context "standard case" do
-      before { @http_mock.should_receive(:get).with("/res?param1=value1&checksum=12345", {}).and_return("ok") }
-      it { api.send(:send_request, url).should == "ok" }
-    end
+      context "handles general Exceptions" do
+        before { @http_mock.should_receive(:get) { raise Exception } }
+        it { expect { api.send(:send_request, url) }.to raise_error(BigBlueButton::BigBlueButtonException) }
+      end
 
-    context "handles a TimeoutError" do
-      before { @http_mock.should_receive(:get) { raise TimeoutError } }
-      it { expect { api.send(:send_request, url) }.to raise_error(BigBlueButton::BigBlueButtonException) }
-    end
+      context "post with data" do
+        let(:data) { "any data" }
+        before {
+          path = "/res?param1=value1&checksum=12345"
+          opts = { 'Content-Type' => 'text/xml' }
+          @http_mock.should_receive(:post).with(path, data, opts).and_return("ok")
+        }
+        it {
+          api.send(:send_request, url, data).should == "ok"
+        }
+      end
 
-    context "handles general Exceptions" do
-      before { @http_mock.should_receive(:get) { raise Exception } }
-      it { expect { api.send(:send_request, url) }.to raise_error(BigBlueButton::BigBlueButtonException) }
-    end
+      context "get with headers" do
+        let(:headers_hash) { { :anything => "anything" } }
+        before { @http_mock.should_receive(:get).with("/res?param1=value1&checksum=12345", headers_hash).and_return("ok") }
+        it {
+          api.request_headers = headers_hash
+          api.send(:send_request, url).should == "ok"
+        }
+      end
 
-    context "post with data" do
-      let(:data) { "any data" }
-      before {
-        path = "/res?param1=value1&checksum=12345"
-        opts = { 'Content-Type' => 'text/xml' }
-        @http_mock.should_receive(:post).with(path, data, opts).and_return("ok")
-      }
-      it {
-        api.send(:send_request, url, data).should == "ok"
-      }
+      context "get with headers" do
+        let(:headers_hash) { { :anything => "anything" } }
+        let(:data) { "any data" }
+        before {
+          path = "/res?param1=value1&checksum=12345"
+          opts = { 'Content-Type' => 'text/xml', :anything => "anything" }
+          @http_mock.should_receive(:post).with(path, data, opts).and_return("ok")
+        }
+        it {
+          api.request_headers = headers_hash
+          api.send(:send_request, url, data).should == "ok"
+        }
+      end
     end
 
-    context "get with headers" do
-      let(:headers_hash) { { :anything => "anything" } }
-      before { @http_mock.should_receive(:get).with("/res?param1=value1&checksum=12345", headers_hash).and_return("ok") }
-      it {
-        api.request_headers = headers_hash
-        api.send(:send_request, url).should == "ok"
+    describe "#get_recordings" do
+      let(:recording1) { { :recordID => "id1", :meetindID => "meeting-id" } } # simplified "recording" node in the response
+      let(:recording2) { { :recordID => "id2", :meetindID => "meeting-id" } }
+      let(:response) {
+        { :returncode => true, :recordings => { :recording => [ recording1, recording2 ] }, :messageKey => "mkey", :message => "m" }
       }
-    end
+      let(:flattened_response) {
+        { :returncode => true, :recordings => [ recording1, recording2 ], :messageKey => "mkey", :message => "m" }
+      } # hash *after* the flatten_objects call
 
-    context "get with headers" do
-      let(:headers_hash) { { :anything => "anything" } }
-      let(:data) { "any data" }
-      before {
-        path = "/res?param1=value1&checksum=12345"
-        opts = { 'Content-Type' => 'text/xml', :anything => "anything" }
-        @http_mock.should_receive(:post).with(path, data, opts).and_return("ok")
-      }
-      it {
-        api.request_headers = headers_hash
-        api.send(:send_request, url, data).should == "ok"
-      }
-    end
-  end
+      context "accepts non standard options" do
+        let(:params) { { :meetingID => "meeting-id", :nonStandard => 1 } }
+        before { api.should_receive(:send_api_request).with(:getRecordings, params).and_return(response) }
+        it { api.get_recordings(params) }
+      end
 
-  describe "#get_recordings" do
-    let(:recording1) { { :recordID => "id1", :meetindID => "meeting-id" } } # simplified "recording" node in the response
-    let(:recording2) { { :recordID => "id2", :meetindID => "meeting-id" } }
-    let(:response) {
-      { :returncode => true, :recordings => { :recording => [ recording1, recording2 ] }, :messageKey => "mkey", :message => "m" }
-    }
-    let(:flattened_response) {
-      { :returncode => true, :recordings => [ recording1, recording2 ], :messageKey => "mkey", :message => "m" }
-    } # hash *after* the flatten_objects call
-
-    context "accepts non standard options" do
-      let(:params) { { :meetingID => "meeting-id", :nonStandard => 1 } }
-      before { api.should_receive(:send_api_request).with(:getRecordings, params).and_return(response) }
-      it { api.get_recordings(params) }
-    end
+      context "without meeting ID" do
+        before { api.should_receive(:send_api_request).with(:getRecordings, {}).and_return(response) }
+        it { api.get_recordings.should == response }
+      end
 
-    context "without meeting ID" do
-      before { api.should_receive(:send_api_request).with(:getRecordings, {}).and_return(response) }
-      it { api.get_recordings.should == response }
-    end
+      context "with one meeting ID" do
+        context "in an array" do
+          let(:options) { { :meetingID => ["meeting-id"] } }
+          let(:req_params) { { :meetingID => "meeting-id" } }
+          before { api.should_receive(:send_api_request).with(:getRecordings, req_params).and_return(response) }
+          it { api.get_recordings(options).should == response }
+        end
 
-    context "with one meeting ID" do
-      context "in an array" do
-        let(:options) { { :meetingID => ["meeting-id"] } }
-        let(:req_params) { { :meetingID => "meeting-id" } }
-        before { api.should_receive(:send_api_request).with(:getRecordings, req_params).and_return(response) }
-        it { api.get_recordings(options).should == response }
+        context "in a string" do
+          let(:options) { { :meetingID => "meeting-id" } }
+          let(:req_params) { { :meetingID => "meeting-id" } }
+          before { api.should_receive(:send_api_request).with(:getRecordings, req_params).and_return(response) }
+          it { api.get_recordings(options).should == response }
+        end
       end
 
-      context "in a string" do
-        let(:options) { { :meetingID => "meeting-id" } }
-        let(:req_params) { { :meetingID => "meeting-id" } }
-        before { api.should_receive(:send_api_request).with(:getRecordings, req_params).and_return(response) }
-        it { api.get_recordings(options).should == response }
-      end
-    end
+      context "with several meeting IDs" do
+        context "in an array" do
+          let(:options) { { :meetingID => ["meeting-id-1", "meeting-id-2"] } }
+          let(:req_params) { { :meetingID => "meeting-id-1,meeting-id-2" } }
+          before { api.should_receive(:send_api_request).with(:getRecordings, req_params).and_return(response) }
+          it { api.get_recordings(options).should == response }
+        end
 
-    context "with several meeting IDs" do
-      context "in an array" do
-        let(:options) { { :meetingID => ["meeting-id-1", "meeting-id-2"] } }
-        let(:req_params) { { :meetingID => "meeting-id-1,meeting-id-2" } }
-        before { api.should_receive(:send_api_request).with(:getRecordings, req_params).and_return(response) }
-        it { api.get_recordings(options).should == response }
+        context "in a string" do
+          let(:options) { { :meetingID => "meeting-id-1,meeting-id-2" } }
+          let(:req_params) { { :meetingID => "meeting-id-1,meeting-id-2" } }
+          before { api.should_receive(:send_api_request).with(:getRecordings, req_params).and_return(response) }
+          it { api.get_recordings(options).should == response }
+        end
       end
 
-      context "in a string" do
-        let(:options) { { :meetingID => "meeting-id-1,meeting-id-2" } }
-        let(:req_params) { { :meetingID => "meeting-id-1,meeting-id-2" } }
-        before { api.should_receive(:send_api_request).with(:getRecordings, req_params).and_return(response) }
-        it { api.get_recordings(options).should == response }
+      context "formats the response" do
+        before {
+          api.should_receive(:send_api_request).with(:getRecordings, anything).and_return(flattened_response)
+          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
+          formatter_mock.should_receive(:flatten_objects).with(:recordings, :recording)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:format_recording).with(recording1)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:format_recording).with(recording2)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_mock)
+        }
+        it { api.get_recordings }
       end
     end
 
-    context "formats the response" do
-      before {
-        api.should_receive(:send_api_request).with(:getRecordings, anything).and_return(flattened_response)
-        formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-        formatter_mock.should_receive(:flatten_objects).with(:recordings, :recording)
-        BigBlueButton::BigBlueButtonFormatter.should_receive(:format_recording).with(recording1)
-        BigBlueButton::BigBlueButtonFormatter.should_receive(:format_recording).with(recording2)
-        BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_mock)
-      }
-      it { api.get_recordings }
-    end
-  end
+    describe "#publish_recordings" do
 
-  describe "#publish_recordings" do
-
-    context "publish is converted to string" do
-      let(:recordIDs) { "any" }
-      let(:req_params) { { :publish => "false", :recordID => "any" } }
-      before { api.should_receive(:send_api_request).with(:publishRecordings, req_params) }
-      it { api.publish_recordings(recordIDs, false) }
-    end
-
-    context "with one recording ID" do
-      context "in an array" do
-        let(:recordIDs) { ["id-1"] }
-        let(:req_params) { { :publish => "true", :recordID => "id-1" } }
+      context "publish is converted to string" do
+        let(:recordIDs) { "any" }
+        let(:req_params) { { :publish => "false", :recordID => "any" } }
         before { api.should_receive(:send_api_request).with(:publishRecordings, req_params) }
-        it { api.publish_recordings(recordIDs, true) }
+        it { api.publish_recordings(recordIDs, false) }
       end
 
-      context "in a string" do
-        let(:recordIDs) { "id-1" }
-        let(:req_params) { { :publish => "true", :recordID => "id-1" } }
-        before { api.should_receive(:send_api_request).with(:publishRecordings, req_params) }
-        it { api.publish_recordings(recordIDs, true) }
+      context "with one recording ID" do
+        context "in an array" do
+          let(:recordIDs) { ["id-1"] }
+          let(:req_params) { { :publish => "true", :recordID => "id-1" } }
+          before { api.should_receive(:send_api_request).with(:publishRecordings, req_params) }
+          it { api.publish_recordings(recordIDs, true) }
+        end
+
+        context "in a string" do
+          let(:recordIDs) { "id-1" }
+          let(:req_params) { { :publish => "true", :recordID => "id-1" } }
+          before { api.should_receive(:send_api_request).with(:publishRecordings, req_params) }
+          it { api.publish_recordings(recordIDs, true) }
+        end
       end
-    end
 
-    context "with several recording IDs" do
-      context "in an array" do
-        let(:recordIDs) { ["id-1", "id-2"] }
-        let(:req_params) { { :publish => "true", :recordID => "id-1,id-2" } }
-        before { api.should_receive(:send_api_request).with(:publishRecordings, req_params) }
-        it { api.publish_recordings(recordIDs, true) }
+      context "with several recording IDs" do
+        context "in an array" do
+          let(:recordIDs) { ["id-1", "id-2"] }
+          let(:req_params) { { :publish => "true", :recordID => "id-1,id-2" } }
+          before { api.should_receive(:send_api_request).with(:publishRecordings, req_params) }
+          it { api.publish_recordings(recordIDs, true) }
+        end
+
+        context "in a string" do
+          let(:recordIDs) { "id-1,id-2,id-3" }
+          let(:req_params) { { :publish => "true", :recordID => "id-1,id-2,id-3" } }
+          before { api.should_receive(:send_api_request).with(:publishRecordings, req_params) }
+          it { api.publish_recordings(recordIDs, true) }
+        end
       end
 
-      context "in a string" do
-        let(:recordIDs) { "id-1,id-2,id-3" }
-        let(:req_params) { { :publish => "true", :recordID => "id-1,id-2,id-3" } }
-        before { api.should_receive(:send_api_request).with(:publishRecordings, req_params) }
-        it { api.publish_recordings(recordIDs, true) }
+      context "accepts non standard options" do
+        let(:recordIDs) { ["id-1"] }
+        let(:params_in) {
+          { :anything1 => "anything-1", :anything2 => 2 }
+        }
+        let(:params_out) {
+          { :publish => "true", :recordID => "id-1",
+            :anything1 => "anything-1", :anything2 => 2 }
+        }
+        before { api.should_receive(:send_api_request).with(:publishRecordings, params_out) }
+        it { api.publish_recordings(recordIDs, true, params_in) }
       end
     end
 
-    context "accepts non standard options" do
-      let(:recordIDs) { ["id-1"] }
-      let(:params_in) {
-        { :anything1 => "anything-1", :anything2 => 2 }
-      }
-      let(:params_out) {
-        { :publish => "true", :recordID => "id-1",
-          :anything1 => "anything-1", :anything2 => 2 }
-      }
-      before { api.should_receive(:send_api_request).with(:publishRecordings, params_out) }
-      it { api.publish_recordings(recordIDs, true, params_in) }
-    end
-  end
+    describe "#delete_recordings" do
 
-  describe "#delete_recordings" do
+      context "with one recording ID" do
+        context "in an array" do
+          let(:recordIDs) { ["id-1"] }
+          let(:req_params) { { :recordID => "id-1" } }
+          before { api.should_receive(:send_api_request).with(:deleteRecordings, req_params) }
+          it { api.delete_recordings(recordIDs) }
+        end
 
-    context "with one recording ID" do
-      context "in an array" do
-        let(:recordIDs) { ["id-1"] }
-        let(:req_params) { { :recordID => "id-1" } }
-        before { api.should_receive(:send_api_request).with(:deleteRecordings, req_params) }
-        it { api.delete_recordings(recordIDs) }
+        context "in a string" do
+          let(:recordIDs) { "id-1" }
+          let(:req_params) { { :recordID => "id-1" } }
+          before { api.should_receive(:send_api_request).with(:deleteRecordings, req_params) }
+          it { api.delete_recordings(recordIDs) }
+        end
       end
 
-      context "in a string" do
-        let(:recordIDs) { "id-1" }
-        let(:req_params) { { :recordID => "id-1" } }
-        before { api.should_receive(:send_api_request).with(:deleteRecordings, req_params) }
-        it { api.delete_recordings(recordIDs) }
-      end
-    end
+      context "with several recording IDs" do
+        context "in an array" do
+          let(:recordIDs) { ["id-1", "id-2"] }
+          let(:req_params) { { :recordID => "id-1,id-2" } }
+          before { api.should_receive(:send_api_request).with(:deleteRecordings, req_params) }
+          it { api.delete_recordings(recordIDs) }
+        end
 
-    context "with several recording IDs" do
-      context "in an array" do
-        let(:recordIDs) { ["id-1", "id-2"] }
-        let(:req_params) { { :recordID => "id-1,id-2" } }
-        before { api.should_receive(:send_api_request).with(:deleteRecordings, req_params) }
-        it { api.delete_recordings(recordIDs) }
+        context "in a string" do
+          let(:recordIDs) { "id-1,id-2,id-3" }
+          let(:req_params) { { :recordID => "id-1,id-2,id-3" } }
+          before { api.should_receive(:send_api_request).with(:deleteRecordings, req_params) }
+          it { api.delete_recordings(recordIDs) }
+        end
       end
 
-      context "in a string" do
-        let(:recordIDs) { "id-1,id-2,id-3" }
-        let(:req_params) { { :recordID => "id-1,id-2,id-3" } }
-        before { api.should_receive(:send_api_request).with(:deleteRecordings, req_params) }
-        it { api.delete_recordings(recordIDs) }
+      context "accepts non standard options" do
+        let(:recordIDs) { ["id-1"] }
+        let(:params_in) {
+          { :anything1 => "anything-1", :anything2 => 2 }
+        }
+        let(:params_out) {
+          { :recordID => "id-1", :anything1 => "anything-1", :anything2 => 2 }
+        }
+        before { api.should_receive(:send_api_request).with(:deleteRecordings, params_out) }
+        it { api.delete_recordings(recordIDs, params_in) }
       end
     end
-
-    context "accepts non standard options" do
-      let(:recordIDs) { ["id-1"] }
-      let(:params_in) {
-        { :anything1 => "anything-1", :anything2 => 2 }
-      }
-      let(:params_out) {
-        { :recordID => "id-1", :anything1 => "anything-1", :anything2 => 2 }
-      }
-      before { api.should_receive(:send_api_request).with(:deleteRecordings, params_out) }
-      it { api.delete_recordings(recordIDs, params_in) }
-    end
   end
 
+  it_should_behave_like "BigBlueButtonApi", "0.8"
+  it_should_behave_like "BigBlueButtonApi", "0.81"
+  it_should_behave_like "BigBlueButtonApi", "0.9"
 end