bigbluebutton-api-ruby 1.2.0 → 1.3.0

data/lib/bigbluebutton_config_layout.rb

@@ -0,0 +1,56 @@
+require "xmlsimple"
+
+module BigBlueButton
+
+  # A helper class to work with layout definition files.
+  # You set an xml file on it (usually obtained from a property of in the XML obtained from
+  # BigBlueButtonApi#get_default_config_xml), use it to work with the layouts, and then get
+  # the new xml from this class.
+  #
+  # === Usage example:
+  #
+  #   xml = api.get_default_config_xml
+  #   config_xml = BigBlueButton::BigBlueButtonConfigXml.new(xml)
+  #   url = config_xml.get_attribute("LayoutModule", "layoutConfig", true)
+  #   # send a request to 'url' to fetch the xml file into 'response'
+  #
+  #   layout_config = BigBlueButton::BigBlueButtonConfigLayout.new(response)
+  #   layout_config.get_available_layouts
+  #
+  class BigBlueButtonConfigLayout
+
+    attr_accessor :xml
+
+    # xml (string)::  The XML that has the definition of all layouts, usually fetched from
+    #                 the web conference server.
+    def initialize(xml)
+      @xml = nil
+      opts = { 'ForceArray' => false, 'KeepRoot' => true }
+      begin
+        @xml = XmlSimple.xml_in(xml, opts)
+      rescue Exception => e
+        raise BigBlueButton::BigBlueButtonException.new("Error parsing the layouts XML. Error: #{e.message}")
+      end
+    end
+
+    # Returns an array with the name of each layout available in the XML.
+    # Will return only unique names, ordered the way they are ordered in the XML.
+    # Returns nil if the XML is not properly formatted and an empty
+    # array if there are no layouts in the file.
+    def get_available_layouts
+      if xml_has_layouts
+        xml["layouts"]["layout"].map{ |l| l["name"] }.uniq
+      else
+        nil
+      end
+    end
+
+    protected
+
+    def xml_has_layouts
+      @xml and @xml["layouts"] and @xml["layouts"]["layout"]
+    end
+
+  end
+
+end

data/lib/bigbluebutton_config_xml.rb

@@ -0,0 +1,122 @@
+require "xmlsimple"
+
+module BigBlueButton
+
+  # A helper class to work with config.xml files.
+  # You set an xml file on it (usually obtained via BigBlueButtonApi#get_default_config_xml),
+  # use it to modify this xml, and then get the new xml from this class (usually to set in the
+  # server using BigBlueButtonApi#set_config_xml).
+  #
+  # === Usage example:
+  #
+  #   xml = api.get_default_config_xml
+  #   config_xml = BigBlueButton::BigBlueButtonConfigXml.new(xml)
+  #
+  #   # change the xml a bit
+  #   config_xml.set_attribute("skinning", "enabled", "false", false)
+  #   config_xml.set_attribute("layout", "defaultLayout", "Webinar", false)
+  #   config_xml.set_attribute("layout", "showLayoutTools", "false", false)
+  #
+  #   # set the new xml in the server
+  #   api.set_config_xml("meeting-id", config_xml)
+  #
+  class BigBlueButtonConfigXml
+
+    attr_accessor :xml
+
+    def initialize(xml)
+      @original_xml = nil
+      @xml = nil
+      unless xml.nil?
+        opts = { 'ForceArray' => false, 'KeepRoot' => true }
+        begin
+          @xml = XmlSimple.xml_in(xml, opts)
+          @original_xml = Marshal.load(Marshal.dump(@xml))
+        rescue Exception => e
+          raise BigBlueButton::BigBlueButtonException.new("Error parsing the config XML. Error: #{e.message}")
+        end
+      end
+    end
+
+    def get_attribute(finder, attr_name, is_module=true)
+      if is_module
+        tag = find_module(finder)
+      else
+        tag = find_tag(finder)
+      end
+      if tag
+        find_attribute(tag, attr_name)
+      else
+        nil
+      end
+    end
+
+    def set_attribute(finder, attr_name, value, is_module=true)
+      if is_module
+        tag = find_module(finder)
+      else
+        tag = find_tag(finder)
+      end
+      if tag
+        attr = find_attribute(tag, attr_name)
+        if attr
+          tag[attr_name] = value
+        else
+          nil
+        end
+      else
+        nil
+      end
+    end
+
+    def as_string
+      XmlSimple.xml_out(@xml, { 'RootName' => nil, 'XmlDeclaration' => false, 'NoIndent' => true })
+    end
+
+    def is_modified?
+      @xml and
+        @xml != @original_xml
+    end
+
+    protected
+
+    def find_module(module_name)
+      if xml_has_modules
+        modules = @xml["config"]["modules"]["module"]
+        modules = [modules] unless modules.is_a?(Array)
+        modules.each do |mod|
+          if mod["name"] == module_name
+            return mod
+          end
+        end
+      end
+      nil
+    end
+
+    def find_tag(name)
+      if xml_has_config
+        @xml["config"][name]
+      end
+    end
+
+    def find_attribute(mod, attr_name)
+      if mod and mod[attr_name]
+        return mod[attr_name]
+      else
+        return nil
+      end
+    end
+
+    def xml_has_modules
+      xml_has_config and
+        @xml["config"]["modules"] and
+        @xml["config"]["modules"]["module"]
+    end
+
+    def xml_has_config
+      @xml and @xml["config"]
+    end
+
+  end
+
+end

data/lib/bigbluebutton_formatter.rb

@@ -52,7 +52,7 @@ module BigBlueButton
           if value.downcase == "null"
             result = nil
           else
-            # note: BBB 0.7 uses strings in the format: "Thu Sep 01 17:51:42 UTC 2011"
+            # note: just in case the value comes as a string in the format: "Thu Sep 01 17:51:42 UTC 2011"
             result = DateTime.parse(value)
           end
         end
@@ -92,11 +92,17 @@ module BigBlueButton
     def self.format_meeting(meeting)
       f = BigBlueButtonFormatter.new(meeting)
       f.to_string(:meetingID)
+      f.to_string(:meetingName)
       f.to_string(:moderatorPW)
       f.to_string(:attendeePW)
       f.to_boolean(:hasBeenForciblyEnded)
       f.to_boolean(:running)
       f.to_int(:createTime) if meeting.has_key?(:createTime)
+      f.to_string(:dialNumber)
+      f.to_int(:voiceBridge)
+      f.to_int(:participantCount)
+      f.to_int(:listenerCount)
+      f.to_int(:videoCount)
       meeting
     end
 
@@ -152,18 +158,18 @@ module BigBlueButton
     #
     # Other examples:
     #
-    # Hash:
+    #   # Hash:
     #   { :name => "Test", :attendees => {} }
-    # Result:
+    #   # Result:
     #   { :name => "Test", :attendees => [] }
     #
-    # Hash:
+    #   # Hash:
     #   { :name => "Test", :attendees => { :attendee => { :name => "attendee1" } } }
-    # Result:
+    #   # Result:
     #   { :name => "Test", :attendees => [ { :name => "attendee1" } ] }
     #
     def flatten_objects(first, second)
-      if @hash[first].empty?
+      if !@hash[first] or @hash[first].empty?
         collection = []
       else
         node = @hash[first][second]

data/lib/bigbluebutton_hash_to_xml.rb

@@ -0,0 +1,35 @@
+require 'xmlsimple'
+
+module BigBlueButton
+  class BigBlueButtonHash < Hash
+    class << self
+      def from_xml(xml_io)
+        begin
+          # we'll not use 'KeyToSymbol' because it doesn't symbolize the keys for node attributes
+          opts = { 'ForceArray' => false, 'ForceContent' => false } #
+          hash = XmlSimple.xml_in(xml_io, opts)
+          return symbolize_keys(hash)
+        rescue Exception => e
+          raise BigBlueButtonException.new("Impossible to convert XML to hash. Error: #{e.message}")
+        end
+      end
+
+      def symbolize_keys(arg)
+        case arg
+        when Array
+          arg.map {  |elem| symbolize_keys elem }
+        when Hash
+          Hash[
+               arg.map {  |key, value|
+                 k = key.is_a?(String) ? key.to_sym : key
+                 v = symbolize_keys value
+                 [k,v]
+               }]
+        else
+          arg
+        end
+      end
+
+    end
+  end
+end

data/lib/bigbluebutton_modules.rb

@@ -2,8 +2,7 @@ require "base64"
 
 module BigBlueButton
 
-  # An object to store the modules configuration to be passed in
-  # BigBlueButtonApi#create_meeting().
+  # A class to store the modules configuration to be passed in BigBlueButtonApi#create_meeting().
   #
   # === Usage example:
   #

data/spec/bigbluebutton_api_0.81_spec.rb

@@ -0,0 +1,154 @@
+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.81" }
+  let(:debug) { false }
+  let(:api) { BigBlueButton::BigBlueButtonApi.new(url, salt, version, debug) }
+
+  describe "#get_default_config_xml" do
+    let(:response) { "<response><returncode>1</returncode></response>" }
+    let(:response_asObject) { {"response" => {"returncode" => "1" } } }
+
+    context "with response as a string" do
+      context "and without non standard options" do
+        before { api.should_receive(:send_api_request).with(:getDefaultConfigXML, {}, nil, true).and_return(response) }
+        it { api.get_default_config_xml() }
+        it { api.get_default_config_xml().should == response }
+        it { api.get_default_config_xml(false).should_not == response_asObject }
+      end
+
+      context "and with non standard options" do
+        let(:params_in) {
+          { :anything1 => "anything-1", :anything2 => 2 }
+        }
+        before { api.should_receive(:send_api_request).with(:getDefaultConfigXML, params_in, nil, true).and_return(response) }
+        it { api.get_default_config_xml(false, params_in) }
+        it { api.get_default_config_xml(false, params_in).should == response }
+        it { api.get_default_config_xml(false, params_in).should_not == response_asObject }
+      end
+    end
+
+    context "with response as a object" do
+      context "and without non standard options" do
+        before { api.should_receive(:send_api_request).with(:getDefaultConfigXML, {}, nil, true).and_return(response) }
+        it { api.get_default_config_xml(true) }
+        it { api.get_default_config_xml(true).should == response_asObject }
+        it { api.get_default_config_xml(true).should_not == response }
+      end
+
+      context "and with non standard options" do
+        let(:params_in) {
+          { :anything1 => "anything-1", :anything2 => 2 }
+        }
+        before { api.should_receive(:send_api_request).with(:getDefaultConfigXML, params_in, nil, true).and_return(response) }
+        it { api.get_default_config_xml(true, params_in) }
+        it { api.get_default_config_xml(true, params_in).should == response_asObject }
+        it { api.get_default_config_xml(true, params_in).should_not == response }
+      end
+    end
+  end
+
+  describe "#set_config_xml" do
+    let(:configToken) { "asdfl234kjasdfsadfy" }
+    let(:meeting_id) { "meeting-id" }
+    let(:xml) { "<response><returncode>SUCCESS</returncode><configToken>asdfl234kjasdfsadfy</configToken></response>" }
+    let(:response) {
+      { :returncode => "SUCCESS", :configToken => configToken }
+    }
+
+    context "without non standard options" do
+      let(:params) {
+        { :meetingID => meeting_id, :configXML => xml }
+      }
+
+      before { api.should_receive(:send_api_request).with(:setConfigXML, params, xml).and_return(response) }
+      it { api.set_config_xml(meeting_id, xml) }
+      it { api.set_config_xml(meeting_id, xml).should == configToken }
+    end
+
+    context "with non standard options" do
+      let(:params_in) {
+        { :anything1 => "anything-1", :anything2 => 2 }
+      }
+      let(:params_out) {
+        { :meetingID => meeting_id, :configXML => xml, :anything1 => "anything-1", :anything2 => 2 }
+      }
+
+      before { api.should_receive(:send_api_request).with(:setConfigXML, params_out, xml).and_return(response) }
+      it { api.set_config_xml(meeting_id, xml, params_in) }
+      it { api.set_config_xml(meeting_id, xml, params_in).should == configToken }
+    end
+  end
+
+  describe "#get_available_layouts" do
+    let(:config_xml) { # a simplified config.xml file
+      "<config>
+         <modules>
+           <module name=\"LayoutModule\" url=\"http://test-server.org/client/LayoutModule.swf?v=4357\"
+                   uri=\"rtmp://test-server.org/bigbluebutton\"
+                   layoutConfig=\"http://test-server.org/client/conf/layout.xml\"
+                   enableEdit=\"false\"/>
+         </modules>
+       </config>"
+    }
+    let(:layouts_xml) { # a simplified layouts.xml file
+      "<layouts>
+         <layout name=\"Default\" default=\"true\">
+           <window name=\"NotesWindow\" hidden=\"true\" width=\"0.7\" height=\"1\" x=\"0\" y=\"0\" draggable=\"false\" resizable=\"false\"/>
+         </layout>
+         <layout name=\"Video Chat\">
+           <window name=\"NotesWindow\" hidden=\"true\" width=\"0.7\" height=\"1\" x=\"0\" y=\"0\" draggable=\"false\" resizable=\"false\"/>
+         </layout>
+       </layouts>"
+    }
+
+    context "when an XML is passed" do
+      before {
+        response = double("Net::HTTPResponse")
+        response.stub(:body).and_return(layouts_xml)
+        api.should_receive(:send_request)
+          .with("http://test-server.org/client/conf/layout.xml")
+          .and_return(response)
+      }
+      subject { api.get_available_layouts(config_xml) }
+      it { should be_instance_of(Array) }
+      it { subject.count.should be(2) }
+      it { should include("Default") }
+      it { should include("Video Chat") }
+    end
+
+    context "when no XML is passed" do
+      before {
+        api.should_receive(:get_default_config_xml)
+          .and_return(config_xml)
+        response = double("Net::HTTPResponse")
+        response.stub(:body).and_return(layouts_xml)
+        api.should_receive(:send_request)
+          .with("http://test-server.org/client/conf/layout.xml")
+          .and_return(response)
+      }
+      subject { api.get_available_layouts }
+      it { should be_instance_of(Array) }
+      it { subject.count.should be(2) }
+      it { should include("Default") }
+      it { should include("Video Chat") }
+    end
+  end
+
+  describe "#get_default_layouts" do
+    subject { api.get_default_layouts }
+    it { should be_instance_of(Array) }
+    it { should include("Default") }
+    it { should include("Video Chat") }
+    it { should include("Meeting") }
+    it { should include("Webinar") }
+    it { should include("Lecture assistant") }
+    it { should include("Lecture") }
+  end
+
+end

data/spec/bigbluebutton_api_spec.rb

@@ -1,12 +1,13 @@
 require 'spec_helper'
 
-# Note: this file tests the functioning of the API object using BBB API version 0.7 as a basis
+# Note: Uses version 0.8 by default. For things that only exist in newer versions,
+#   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.7" }
+  let(:version) { "0.8" }
   let(:debug) { false }
   let(:api) { BigBlueButton::BigBlueButtonApi.new(url, salt, version, debug) }
 
@@ -18,15 +19,15 @@ describe BigBlueButton::BigBlueButtonApi do
       it { subject.version.should == version }
       it { subject.debug.should == debug }
       it { subject.timeout.should == 10 }
-      it { subject.supported_versions.should include("0.7") }
       it { subject.supported_versions.should include("0.8") }
+      it { subject.supported_versions.should include("0.81") }
       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.7") }
+      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.7" }
+      it { subject.version.should == "0.8" }
     end
 
     it "when the version is not supported raise an error" do
@@ -37,7 +38,7 @@ describe BigBlueButton::BigBlueButtonApi do
 
     context "current supported versions" do
       subject { BigBlueButton::BigBlueButtonApi.new(url, salt) }
-      it { subject.supported_versions.should == ["0.7", "0.8"] }
+      it { subject.supported_versions.should == ["0.8", "0.81"] }
     end
   end
 
@@ -87,16 +88,84 @@ describe BigBlueButton::BigBlueButtonApi do
         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
+      }
+
+      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
+
+    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 }
+    end
   end
 
   describe "#end_meeting" do
     let(:meeting_id) { "meeting-id" }
     let(:moderator_password) { "password" }
-    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 }
+    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
+
+    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
 
   describe "#is_meeting_running?" do
@@ -114,18 +183,29 @@ describe BigBlueButton::BigBlueButtonApi do
       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) }
+    end
   end
 
   describe "#join_meeting_url" do
     context "standard case" do
       let(:params) {
         { :meetingID => "meeting-id", :password => "pw", :fullName => "Name",
-          :userID => "id123", :webVoiceConf => 12345678 }
+          :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 }
+        options = { :userID => "id123", :webVoiceConf => 12345678, :createTime => 9876543 }
         api.join_meeting_url("meeting-id", "Name", "pw", options).should == "test-url"
       }
     end
@@ -140,82 +220,87 @@ describe BigBlueButton::BigBlueButtonApi do
     end
   end
 
-  describe "#join_meeting" do
+  describe "#get_meeting_info" do
+    let(:meeting_id) { "meeting-id" }
+    let(:password) { "password" }
+
     context "standard case" do
-      let(:params) {
-        { :meetingID => "meeting-id", :password => "pw", :fullName => "Name",
-          :userID => "id123", :webVoiceConf => 12345678 }
-      }
+      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
 
-      before { api.should_receive(:send_api_request).with(:join, params).and_return("join-return") }
-      it {
-        options = { :userID => "id123", :webVoiceConf => 12345678 }
-        api.join_meeting("meeting-id", "Name", "pw", options).should == "join-return"
-      }
+      # 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
 
     context "accepts non standard options" do
-      let(:params) {
-        { :meetingID => "meeting-id", :password => "pw",
-          :fullName => "Name", :userID => "id123", :nonStandard => 1 }
+      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(:join, params) }
-      it { api.join_meeting("meeting-id", "Name", "pw", params) }
+      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
 
-  describe "#get_meeting_info" do
-    let(:meeting_id) { "meeting-id" }
-    let(:password) { "password" }
-    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" }
-    } # 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 }
-    } # 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
-
   describe "#get_meetings" 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
+    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, hash_including(:random => kind_of(Integer))).
+      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 }
+        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
 
   describe "#get_api_version" do
     context "returns the version returned by the server" do
-      let(:hash) { { :returncode => true, :version => "0.7" } }
+      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.7" }
+      it { api.get_api_version.should == "0.8" }
     end
 
     context "returns an empty string when the server responds with an empty hash" do
@@ -370,12 +455,12 @@ describe BigBlueButton::BigBlueButtonApi do
       end
 
       context "checking if it has a :response key" do
-        before { Hash.should_receive(:from_xml).with("response-body").and_return({ }) }
+        before { BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return({ }) }
         it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
       end
 
       context "checking if it the :response key has a :returncode key" do
-        before { Hash.should_receive(:from_xml).with("response-body").and_return({ :response => { } }) }
+        before { BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return({ :response => { } }) }
         it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
       end
     end
@@ -386,7 +471,7 @@ describe BigBlueButton::BigBlueButtonApi 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")
-        Hash.should_receive(:from_xml).with("response-body").and_return(response)
+        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
@@ -403,7 +488,7 @@ describe BigBlueButton::BigBlueButtonApi 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")
-        Hash.should_receive(:from_xml).with("response-body").and_return(response)
+        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)
@@ -473,7 +558,174 @@ describe BigBlueButton::BigBlueButtonApi do
         api.send(:send_request, url, data).should == "ok"
       }
     end
+  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 "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 "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 "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 "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
+
+    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" } }
+        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
 
+    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 "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
+
+    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 "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 "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 "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
 
 end