bigbluebutton-api-ruby 0.0.11 → 0.1.0.rc1

data/spec/bigbluebutton_api_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 
+# Note: this file tests the functioning of the API object using BBB API version 0.7 as a basis
 describe BigBlueButton::BigBlueButtonApi do
 
   # default variables and API object for all tests
@@ -16,8 +17,9 @@ describe BigBlueButton::BigBlueButtonApi do
       it { subject.salt.should be(salt) }
       it { subject.version.should be(version) }
       it { subject.debug.should be(debug) }
-      it { subject.timeout.should be(2) }
+      it { subject.timeout.should be(10) }
       it { subject.supported_versions.should include("0.7") }
+      it { subject.supported_versions.should include("0.8") }
     end
 
     context "when the version is not informed, get it from the BBB server" do
@@ -34,51 +36,55 @@ describe BigBlueButton::BigBlueButtonApi do
 
     context "current supported versions" do
       subject { BigBlueButton::BigBlueButtonApi.new(url, salt) }
-      it { subject.supported_versions.should == ["0.7"] }
+      it { subject.supported_versions.should == ["0.7", "0.8"] }
     end
   end
 
-  describe "#join_meeting_url" do
-    let(:meeting_id) { "meeting-id" }
-    let(:password) { "password" }
-    let(:user_name) { "user-name" }
-    let(:user_id) { "user-id" }
-    let(:web_voice_conf) { "web-voice-conf" }
-    let(:params) {
-      { :meetingID => meeting_id, :password => password, :fullName => user_name,
-        :userID => user_id, :webVoiceConf => web_voice_conf }
-    }
+  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" }
+      }
+      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" }
+        api.create_meeting("name", "meeting-id", options)
+      }
+      it { subject.should == final_response }
+    end
 
-    before { api.should_receive(:get_url).with(:join, params).and_return("test-url") }
-    it { api.join_meeting_url(meeting_id, user_name, password, user_id, web_voice_conf).should == "test-url" }
-  end
+    context "discards invalid options" do
+      let(:req_params) {
+        { :name => "name", :meetingID => "meeting-id", :moderatorPW => "mp", :attendeePW => "ap" }
+      }
+      before { api.should_receive(:send_api_request).with(:create, req_params) }
+      it {
+        options = { :invalidParam => "1", :moderatorPW => "mp", :attendeePW => "ap", :invalidParam2 => "1" }
+        api.create_meeting("name", "meeting-id", options)
+      }
+    end
 
-  describe "#create_meeting" do
-    let(:meeting_name) { "name" }
-    let(:meeting_id) { "meeting-id" }
-    let(:moderator_password) { "moderator-password" }
-    let(:attendee_password) { "attendee-password" }
-    let(:welcome_message) { "welcome" }
-    let(:dial_number) { "dial-number" }
-    let(:logout_url) { "logout-url" }
-    let(:max_participants) { "max-participants" }
-    let(:voice_bridge) { "voice-bridge" }
-    let(:params) {
-      { :name => meeting_name, :meetingID => meeting_id,
-        :moderatorPW => moderator_password, :attendeePW => attendee_password,
-        :welcome => welcome_message, :dialNumber => dial_number,
-        :logoutURL => logout_url, :maxParticpants => max_participants,
-        :voiceBridge => voice_bridge }
-    }
-    let(:response) { { :meetingID => 123, :moderatorPW => 111, :attendeePW => 222, :hasBeenForciblyEnded => "FALSE" } }
-    let(:expected_response) { { :meetingID => "123", :moderatorPW => "111", :attendeePW => "222", :hasBeenForciblyEnded => false } }
-
-    # ps: not mocking the formatter here because it's easier to just check the results (expected_response)
-    before { api.should_receive(:send_api_request).with(:create, params).and_return(response) }
-    subject { api.create_meeting(meeting_name, meeting_id, moderator_password,
-                                 attendee_password, welcome_message, dial_number,
-                                 logout_url, max_participants, voice_bridge) }
-    it { subject.should == expected_response }
+    context "discards options for >0.7" do
+      let(:req_params) {
+        { :name => "name", :meetingID => "meeting-id" }
+      }
+      before { api.should_receive(:send_api_request).with(:create, req_params) }
+      it {
+        options = { :record => true, :duration => 25, :meta_any => "meta" }
+        api.create_meeting("name", "meeting-id", options)
+      }
+    end
   end
 
   describe "#end_meeting" do
@@ -108,19 +114,78 @@ describe BigBlueButton::BigBlueButtonApi do
     end
   end
 
+  describe "#join_meeting_url" do
+    context "standard case" do
+      let(:params) {
+        { :meetingID => "meeting-id", :password => "pw", :fullName => "Name",
+          :userID => "id123", :webVoiceConf => 12345678 }
+      }
+
+      before { api.should_receive(:get_url).with(:join, params).and_return("test-url") }
+      it {
+        options = { :userID => "id123", :webVoiceConf => 12345678 }
+        api.join_meeting_url("meeting-id", "Name", "pw", options).should == "test-url"
+      }
+    end
+
+    context "discards invalid options" do
+      let(:params) {
+        { :meetingID => "meeting-id", :password => "pw", :fullName => "Name", :userID => "id123" }
+      }
+      before { api.should_receive(:get_url).with(:join, params) }
+      it {
+        options = { :invalidParam => "1", :userID => "id123", :invalidParam2 => "1" }
+        api.join_meeting_url("meeting-id", "Name", "pw", options)
+      }
+    end
+
+    context "discards options for <= 0.7" do
+      let(:params) {
+        { :meetingID => "meeting-id", :password => "pw", :fullName => "Name" }
+      }
+      before { api.should_receive(:get_url).with(:join, params) }
+      it {
+        options = { :createTime => 123456789 }
+        api.join_meeting_url("meeting-id", "Name", "pw", options)
+      }
+    end
+  end
+
   describe "#join_meeting" do
-    let(:meeting_id) { "meeting-id" }
-    let(:password) { "password" }
-    let(:user_name) { "user-name" }
-    let(:user_id) { "user-id" }
-    let(:web_voice_conf) { "web-voice-conf" }
-    let(:params) {
-      { :meetingID => meeting_id, :password => password, :fullName => user_name,
-        :userID => user_id, :webVoiceConf => web_voice_conf }
-    }
+    context "standard case" do
+      let(:params) {
+        { :meetingID => "meeting-id", :password => "pw", :fullName => "Name",
+          :userID => "id123", :webVoiceConf => 12345678 }
+      }
+
+      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"
+      }
+    end
+
+    context "discards invalid options" do
+      let(:params) {
+        { :meetingID => "meeting-id", :password => "pw", :fullName => "Name", :userID => "id123" }
+      }
+      before { api.should_receive(:send_api_request).with(:join, params) }
+      it {
+        options = { :invalidParam => "1", :userID => "id123", :invalidParam2 => "1" }
+        api.join_meeting("meeting-id", "Name", "pw", options)
+      }
+    end
 
-    before { api.should_receive(:send_api_request).with(:join, params).and_return("join-return") }
-    it { api.join_meeting(meeting_id, user_name, password, user_id, web_voice_conf).should == "join-return" }
+    context "discards options for <= 0.7" do
+      let(:params) {
+        { :meetingID => "meeting-id", :password => "pw", :fullName => "Name" }
+      }
+      before { api.should_receive(:send_api_request).with(:join, params) }
+      it {
+        options = { :createTime => 123456789 }
+        api.join_meeting("meeting-id", "Name", "pw", options)
+      }
+    end
   end
 
   describe "#get_meeting_info" do
@@ -133,20 +198,22 @@ describe BigBlueButton::BigBlueButtonApi do
     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" }
-    } # hash after the send_api_request call, before the specific formatting
+        :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(:expected_response) {
+    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" }
+        :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 (expected_response)
+    # 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 == expected_response }
+    it { api.get_meeting_info(meeting_id, password).should == final_response }
   end
 
   describe "#get_meetings" do
@@ -157,13 +224,13 @@ describe BigBlueButton::BigBlueButtonApi do
     } # hash *after* the flatten_objects call
 
     before {
-      # FIXME: how to expect a hash with a random value in the should_receive below?
-      api.should_receive(:send_api_request).with(:getMeetings, anything).and_return(flattened_response)
+      api.should_receive(:send_api_request).with(:getMeetings, hash_including(:random => kind_of(Integer))).
+        and_return(flattened_response)
       formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
       formatter_mock.should_receive(:flatten_objects).with(:meetings, :meeting)
-      formatter_mock.should_receive(:format_meeting).with(meeting_hash1)
-      formatter_mock.should_receive(:format_meeting).with(meeting_hash2)
       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
@@ -232,6 +299,20 @@ describe BigBlueButton::BigBlueButtonApi do
     it { api.last_http_response.should == request_mock }
   end
 
+  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
+
   describe "#get_url" do
 
     context "when method = :index" do
@@ -243,7 +324,14 @@ describe BigBlueButton::BigBlueButtonApi do
         context "with params" do
           let(:params) { { :param1 => "value1", :param2 => "value2" } }
           subject { api.get_url(:join, params) }
-          it { subject.should match(/#{url}\/join\?param1=value1&param2=value2/) }
+          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 "without params" do
@@ -267,59 +355,33 @@ describe BigBlueButton::BigBlueButtonApi do
 
       context "includes the checksum" do
         let(:params) { { :param1 => "value1", :param2 => "value2" } }
-        let(:checksum) { Digest::SHA1.hexdigest("joinparam1=value1&param2=value2#{salt}") }
+        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}$/) }
       end
     end
   end
 
-  # FIXME: this complex test means that the method is too complex - try to refactor it
   describe "#send_api_request" do
     let(:method) { :join }
     let(:params) { { :param1 => "value1" } }
-    let(:target_url) { "http://test-server:8080?param1=value1&checksum=12345" }
-    let(:make_request) { api.send_api_request(method, params) }
-    before { api.should_receive(:get_url).with(method, params).and_return(target_url) }
+    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
 
-    def setup_http_mock
-      @http_mock = mock(Net::HTTP)
-      Net::HTTP.should_receive(:new).with("test-server", 8080).and_return(@http_mock)
-      @http_mock.should_receive(:"open_timeout=").with(api.timeout)
-      @http_mock.should_receive(:"read_timeout=").with(api.timeout)
-    end
-
-    context "sets up the Net::HTTP object correctly" do
-      before do
-        setup_http_mock
-        response_mock = mock()
-        @http_mock.should_receive(:get).and_return(response_mock)
-        response_mock.should_receive(:body).and_return("") # so the method exits right after the setup
-      end
-      it { make_request }
-    end
-
-    context "handles a TimeoutError" do
-      before do
-        setup_http_mock
-        @http_mock.should_receive(:get) { raise TimeoutError }
-      end
-      it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
-    end
-
-    context "handles general Exceptions" do
-      before do
-        setup_http_mock
-        @http_mock.should_receive(:get) { raise Exception }
-      end
-      it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
-    end
+    before { api.should_receive(:get_url).with(method, params).and_return(url) }
 
     context "returns an empty hash if the response body is empty" do
       before do
-        setup_http_mock
-        response_mock = mock()
-        @http_mock.should_receive(:get).and_return(response_mock)
+        api.should_receive(:send_request).with(url, data).and_return(response_mock)
         response_mock.should_receive(:body).and_return("")
       end
       it { make_request.should == { } }
@@ -327,9 +389,7 @@ describe BigBlueButton::BigBlueButtonApi do
 
     context "hashfies and validates the response body" do
       before do
-        setup_http_mock
-        response_mock = mock()
-        @http_mock.should_receive(:get).and_return(response_mock)
+        api.should_receive(:send_request).with(url, data).and_return(response_mock)
         response_mock.should_receive(:body).twice.and_return("response-body")
       end
 
@@ -345,17 +405,15 @@ describe BigBlueButton::BigBlueButtonApi do
     end
 
     context "formats the response hash" do
-      let(:response) { { :response => { :returncode => true } } }
-      let(:formatted_response) { { :returncode => true } }
+      let(:response) { { :returncode => "SUCCESS" } }
+      let(:formatted_response) { { :returncode => true, :messageKey => "", :message => "" } }
       before do
-        setup_http_mock
-
-        response_mock = mock()
-        @http_mock.should_receive(:get).and_return(response_mock)
+        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)
 
         # 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)
@@ -364,13 +422,10 @@ describe BigBlueButton::BigBlueButtonApi do
     end
 
     context "raise an error if the formatted response has no :returncode" do
-      let(:response) { { :response => { :returncode => true } } }
+      let(:response) { { :returncode => true } }
       let(:formatted_response) { { } }
       before do
-        setup_http_mock
-
-        response_mock = mock()
-        @http_mock.should_receive(:get).and_return(response_mock)
+        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)
 
@@ -380,6 +435,45 @@ describe BigBlueButton::BigBlueButtonApi do
       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) }
+
+    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 "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 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 "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 "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
 
   end
 

data/spec/bigbluebutton_formatter_spec.rb

@@ -8,33 +8,158 @@ describe BigBlueButton::BigBlueButtonFormatter do
     it { subject.should respond_to(:"hash=") }
   end
 
-  describe "#to_stringtring" do
+  describe "#initialize" do
+    context "with a hash" do
+      let(:hash) { { :param1 => "123", :param2 => 123, :param3 => true } }
+      subject { BigBlueButton::BigBlueButtonFormatter.new(hash) }
+      it { subject.hash.should == hash }
+    end
+
+    context "without a hash" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new(nil) }
+      it { subject.hash.should == { } }
+    end
+  end
+
+  describe "#to_string" do
     let(:hash) { { :param1 => "123", :param2 => 123, :param3 => true } }
-    subject { BigBlueButton::BigBlueButtonFormatter.new(hash) }
-    it { subject.to_string(:param1).should == "123" }
-    it { subject.to_string(:param2).should == "123" }
-    it { subject.to_string(:param3).should == "true" }
+    let(:formatter) { BigBlueButton::BigBlueButtonFormatter.new(hash) }
+    before {
+      formatter.to_string(:param1)
+      formatter.to_string(:param2)
+      formatter.to_string(:param3)
+    }
+    it { hash[:param1].should == "123" }
+    it { hash[:param2].should == "123" }
+    it { hash[:param3].should == "true" }
+
+    context "returns empty string if the param doesn't exists" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new({ :param => 1 }) }
+      it { subject.to_string(:inexistent).should == "" }
+    end
+
+    context "returns empty string if the hash is nil" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new(nil) }
+      it { subject.to_string(:inexistent).should == "" }
+    end
   end
 
-  describe "#to_booleanoolean" do
+  describe "#to_boolean" do
     let(:hash) { { :true1 => "TRUE", :true2 => "true", :false1 => "FALSE", :false2 => "false" } }
-    subject { BigBlueButton::BigBlueButtonFormatter.new(hash) }
-    it { subject.to_boolean(:true1).should be_true }
-    it { subject.to_boolean(:true2).should be_true }
-    it { subject.to_boolean(:false1).should be_false }
-    it { subject.to_boolean(:false2).should be_false }
+    let(:formatter) { BigBlueButton::BigBlueButtonFormatter.new(hash) }
+    before {
+      formatter.to_boolean(:true1)
+      formatter.to_boolean(:true2)
+      formatter.to_boolean(:false1)
+      formatter.to_boolean(:false2)
+    }
+    it { hash[:true1].should be_true }
+    it { hash[:true2].should be_true }
+    it { hash[:false1].should be_false }
+    it { hash[:false2].should be_false }
+
+    context "returns false if the param doesn't exists" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new({ :param => 1}) }
+      it { subject.to_boolean(:inexistent).should == false }
+    end
+
+    context "returns false if the hash is nil" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new(nil) }
+      it { subject.to_boolean(:inexistent).should == false }
+    end
   end
 
   describe "#to_datetime" do
-    let(:hash) { { :param1 => "Thu Sep 01 17:51:42 UTC 2011", :param2 => "Thu Sep 08", :param3 => "NULL" } }
-    subject { BigBlueButton::BigBlueButtonFormatter.new(hash) }
-    it { subject.to_datetime(:param1).should == DateTime.parse("Thu Sep 01 17:51:42 UTC 2011") }
-    it { subject.to_datetime(:param2).should == DateTime.parse("Thu Sep 08") }
-    it { subject.to_datetime(:param3).should == nil }
+    let(:hash) { { :param1 => "Thu Sep 01 17:51:42 UTC 2011", :param2 => "Thu Sep 08",
+                   :param3 => 1315254777880, :param4 => "1315254777880",
+                   :param5 => "0", :param6 => 0,
+                   :param7 => "NULL", :param8 => nil } }
+    let(:formatter) { BigBlueButton::BigBlueButtonFormatter.new(hash) }
+    before {
+      formatter.to_datetime(:param1)
+      formatter.to_datetime(:param2)
+      formatter.to_datetime(:param3)
+      formatter.to_datetime(:param4)
+      formatter.to_datetime(:param5)
+      formatter.to_datetime(:param6)
+      formatter.to_datetime(:param7)
+    }
+    it { hash[:param1].should == DateTime.parse("Thu Sep 01 17:51:42 UTC 2011") }
+    it { hash[:param2].should == DateTime.parse("Thu Sep 08") }
+    it { hash[:param3].should == DateTime.parse("2011-09-05 17:32:57 -0300") }
+    it { hash[:param4].should == DateTime.parse("2011-09-05 17:32:57 -0300") }
+    it { hash[:param5].should == nil }
+    it { hash[:param6].should == nil }
+    it { hash[:param7].should == nil }
+    it { hash[:param8].should == nil }
+
+    context "returns nil if the param doesn't exists" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new({ :param => 1}) }
+      it { subject.to_datetime(:inexistent).should == nil }
+    end
+
+    context "returns nil if the hash is nil" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new(nil) }
+      it { subject.to_datetime(:inexistent).should == nil }
+    end
+  end
+
+  describe "#to_sym" do
+    let(:hash) { { :param1 => :sym1, :param2 => "sym2", :param3 => "SyM3" } }
+    let(:formatter) { BigBlueButton::BigBlueButtonFormatter.new(hash) }
+    before {
+      formatter.to_sym(:param1)
+      formatter.to_sym(:param2)
+      formatter.to_sym(:param3)
+    }
+    it { hash[:param1].should == :sym1 }
+    it { hash[:param2].should == :sym2 }
+    it { hash[:param3].should == :sym3 }
+
+    context "returns empty string if the param doesn't exists" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new({ :param => 1 }) }
+      it { subject.to_string(:inexistent).should == "" }
+    end
+
+    context "returns empty string if the hash is nil" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new(nil) }
+      it { subject.to_string(:inexistent).should == "" }
+    end
+
+    context "returns empty string if the value to be converted is an empty string" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new({ :param => "" }) }
+      it { subject.to_string(:param).should == "" }
+    end
+  end
+
+  describe "#to_int" do
+    let(:hash) { { :param1 => 5, :param2 => "5" } }
+    let(:formatter) { BigBlueButton::BigBlueButtonFormatter.new(hash) }
+    before {
+      formatter.to_int(:param1)
+      formatter.to_int(:param2)
+    }
+    it { hash[:param1].should == 5 }
+    it { hash[:param2].should == 5 }
+
+    context "returns 0 if the param doesn't exists" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new({ :param => 1 }) }
+      it { subject.to_int(:inexistent).should == 0 }
+    end
+
+    context "returns 0 if the hash is nil" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new(nil) }
+      it { subject.to_int(:inexistent).should == 0 }
+    end
+
+    context "returns 0 if the value to be converted is invalid" do
+      subject { BigBlueButton::BigBlueButtonFormatter.new({ :param => "invalid" }) }
+      it { subject.to_int(:param).should == 0 }
+    end
   end
 
   describe "#default_formatting" do
-    let(:input) { { :response => { :returncode => "SUCCESS", :messageKey => "mkey", :message => "m" } } }
+    let(:input) { { :returncode => "SUCCESS", :messageKey => "mkey", :message => "m" } }
     let(:formatter) { BigBlueButton::BigBlueButtonFormatter.new(input) }
 
     context "standard case" do
@@ -44,61 +169,85 @@ describe BigBlueButton::BigBlueButtonFormatter do
     end
 
     context "when :returncode should be false" do
-      before { input[:response][:returncode] = "ERROR" }
+      before { input[:returncode] = "ERROR" }
       subject { formatter.default_formatting }
       it { subject[:returncode].should be_false }
     end
 
     context "when :messageKey is empty" do
-      before { input[:response][:messageKey] = {} }
+      before { input[:messageKey] = {} }
       subject { formatter.default_formatting }
       it { subject[:messageKey].should == "" }
     end
 
     context "when :messageKey is nil" do
-      before { input[:response].delete(:messageKey) }
+      before { input.delete(:messageKey) }
       subject { formatter.default_formatting }
       it { subject[:messageKey].should == "" }
     end
 
     context "when :message is empty" do
-      before { input[:response][:message] = {} }
+      before { input[:message] = {} }
       subject { formatter.default_formatting }
       it { subject[:message].should == "" }
     end
 
     context "when there's no :message key" do
-      before { input[:response].delete(:message) }
+      before { input.delete(:message) }
       subject { formatter.default_formatting }
       it { subject[:message].should == "" }
     end
   end
 
-  describe "#format_meeting" do
-    let(:formatter) { BigBlueButton::BigBlueButtonFormatter.new({}) }
+  describe ".format_meeting" do
     let(:hash) {
       { :meetingID => 123, :moderatorPW => 111, :attendeePW => 222,
-        :hasBeenForciblyEnded => "FALSE", :running => "TRUE" }
+        :hasBeenForciblyEnded => "FALSE", :running => "TRUE", :createTime => "123456789" }
     }
 
-    subject { formatter.format_meeting(hash) }
+    subject { BigBlueButton::BigBlueButtonFormatter.format_meeting(hash) }
     it { subject[:meetingID].should == "123" }
     it { subject[:moderatorPW].should == "111" }
     it { subject[:attendeePW].should == "222" }
     it { subject[:hasBeenForciblyEnded].should == false }
     it { subject[:running].should == true }
+    it { subject[:createTime].should == 123456789 }
   end
 
-  describe "#format_attendee" do
-    let(:formatter) { BigBlueButton::BigBlueButtonFormatter.new({}) }
+  describe ".format_attendee" do
     let(:hash) { { :userID => 123, :fullName => "Cameron", :role => "VIEWER" } }
 
-    subject { formatter.format_attendee(hash) }
+    subject { BigBlueButton::BigBlueButtonFormatter.format_attendee(hash) }
     it { subject[:userID].should == "123" }
     it { subject[:fullName].should == "Cameron" }
     it { subject[:role].should == :viewer }
   end
 
+  describe ".format_recording" do
+    let(:hash) { { :recordID => 123, :meetingID => 123, :name => 123, :published => "true",
+                   :startTime => "Thu Mar 04 14:05:56 UTC 2010",
+                   :endTime => "Thu Mar 04 15:01:01 UTC 2010",
+                   :metadata => {
+                     :title => "Test Recording", :subject => "English 232 session",
+                     :description => "First Class", :creator => "Fred Dixon",
+                     :contributor => "Richard Alam", :language => "en_US"
+                    },
+                   :playback => {
+                     :format => {
+                       :type => "simple",
+                       :url => "http://server.com/simple/playback?recordID=183f0bf3a0982a127bdb8161-1",
+                       :length => 62 }
+                   }
+    } }
+
+    subject { BigBlueButton::BigBlueButtonFormatter.format_recording(hash) }
+    it { subject[:recordID].should == "123" }
+    it { subject[:meetingID].should == "123" }
+    it { subject[:name].should == "123" }
+    it { subject[:startTime].should == DateTime.parse("Thu Mar 04 14:05:56 UTC 2010") }
+    it { subject[:endTime].should == DateTime.parse("Thu Mar 04 15:01:01 UTC 2010") }
+  end
+
   describe "#flatten_objects" do
     let(:formatter) { BigBlueButton::BigBlueButtonFormatter.new({ }) }