Call setConfigXML via POST and change encoding method

Now it uses an encoding method that is more similar to the one used in
BigBlueButton. Fixes issues when there was an asterisk (*) in the
config.xml.

Also made setConfigXML be sent always via POST, so that the XML will be in
the body of the request and not in the URL. It was generating URLs way too
long since the default config.xml is growing.

Author: daronco

lib/bigbluebutton_api.rb

@@ -226,7 +226,8 @@ def is_meeting_running?(meeting_id, options={})
     #                         in this hash and they will be added to the API call.
     def join_meeting_url(meeting_id, user_name, password, options={})
       params = { :meetingID => meeting_id, :password => password, :fullName => user_name }.merge(options)
-      get_url(:join, params)
+      url, data = get_url(:join, params)
+      url
     end
 
     # Returns a hash object containing the information of a meeting.
@@ -600,7 +601,8 @@ def test_connection
     end
 
     def check_url
-      get_url(:check)
+      url, data = get_url(:check)
+      url
     end
 
     # API's are equal if all the following attributes are equal.
@@ -627,31 +629,35 @@ def last_xml_response
     # params (Hash)::    The parameters to be passed in the URL
     def get_url(method, params={})
       if method == :index
-        return @url
+        return @url, nil
       elsif method == :check
         baseurl = URI.join(@url, "/").to_s
-        return "#{baseurl}check"
+        return "#{baseurl}check", nil
       end
 
-      url = "#{@url}/#{method}?"
-
       # stringify and escape all params
       params.delete_if { |k, v| v.nil? } unless params.nil?
       # some API calls require the params to be sorted
       # first make all keys symbols, so the comparison works
       params = params.inject({}){ |memo,(k,v)| memo[k.to_sym] = v; memo }
       params = Hash[params.sort]
       params_string = ""
-      params_string = params.map{ |k,v| "#{k}=" + CGI::escape(v.to_s) unless k.nil? || v.nil? }.join("&")
+      params_string = params.map{ |k,v| "#{k}=" + URI.encode_www_form_component(v.to_s) unless k.nil? || v.nil? }.join("&")
 
       # checksum calc
       checksum_param = params_string + @secret
       checksum_param = method.to_s + checksum_param
       checksum = Digest::SHA1.hexdigest(checksum_param)
 
-      # final url
-      url += "#{params_string}&" unless params_string.empty?
-      url += "checksum=#{checksum}"
+      if method == :setConfigXML
+        params_string = "checksum=#{checksum}&#{params_string}"
+        return "#{@url}/#{method}", params_string
+      else
+        url = "#{@url}/#{method}?"
+        url += "#{params_string}&" unless params_string.empty?
+        url += "checksum=#{checksum}"
+        return url, nil
+      end
     end
 
     # Performs an API call.
@@ -668,7 +674,9 @@ def get_url(method, params={})
     # raw (boolean)::    If true, returns the data as it was received. Will not parse it into a Hash,
     #                    check for errors or throw exceptions.
     def send_api_request(method, params={}, data=nil, raw=false)
-      url = get_url(method, params)
+      # if the method returns a body, use it as the data in the post request
+      url, body = get_url(method, params)
+      data = body if body
 
       @http_response = send_request(url, data)
       return {} if @http_response.body.empty?
@@ -718,7 +726,7 @@ def send_request(url, data=nil)
           response = http.get(url_parsed.request_uri, @request_headers)
         else
           puts "BigBlueButtonAPI: Sending as a POST request with data.size = #{data.size}" if @debug
-          opts = { 'Content-Type' => 'text/xml' }.merge @request_headers
+          opts = { 'Content-Type' => 'application/x-www-form-urlencoded' }.merge @request_headers
           response = http.post(url_parsed.request_uri, data, opts)
         end
         puts "BigBlueButtonAPI: URL response = #{response.body}" if @debug

spec/bigbluebutton_api_spec.rb

@@ -226,7 +226,7 @@
             :userID => "id123", :webVoiceConf => 12345678, :createTime => 9876543 }
         }
 
-        before { api.should_receive(:get_url).with(:join, params).and_return("test-url") }
+        before { api.should_receive(:get_url).with(:join, params).and_return(["test-url", nil]) }
         it {
           options = { :userID => "id123", :webVoiceConf => 12345678, :createTime => 9876543 }
           api.join_meeting_url("meeting-id", "Name", "pw", options).should == "test-url"
@@ -409,21 +409,21 @@
     describe "#get_url" do
 
       context "when method = :index" do
-        it { api.get_url(:index).should == api.url }
+        it { api.get_url(:index).should == [api.url, nil] }
       end
 
       context "when method = :check" do
         it {
           api.url = 'http://my-test-server.com/bigbluebutton/api'
-          api.get_url(:check).should == 'http://my-test-server.com/check'
+          api.get_url(:check).should == ['http://my-test-server.com/check', nil]
         }
       end
 
       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) }
+            subject { api.get_url(:join, params)[0] }
             it {
               # the hash can be sorted differently depending on the ruby version
               if params.map{ |k,v| "#{k}" }.join =~ /^param1/
@@ -435,35 +435,54 @@
           end
 
           context "without params" do
-            subject { api.get_url(:join) }
+            subject { api.get_url(:join)[0] }
             it { subject.should match(/#{url}\/join\?[^&]/) }
           end
         end
 
+        context "when method = :setConfigXML" do
+          it {
+            api.url = 'http://my-test-server.com/bigbluebutton/api'
+            response = api.get_url(:setConfigXML, { param1: 1, param2: 2 })
+            response[0].should eql('http://my-test-server.com/bigbluebutton/api/setConfigXML')
+            response[1].should match(/checksum=.*&param1=1&param2=2/)
+          }
+        end
+
         context "discards params with nil value" do
           let(:params) { { :param1 => "value1", :param2 => nil } }
-          subject { api.get_url(:join, params) }
+          subject { api.get_url(:join, params)[0] }
           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) }
+          subject { api.get_url(:join, params)[0] }
           it { subject.should match(/param1=value\+with\+spaces/) }
           it { subject.should match(/param2=%40%24/) }
         end
 
+        [ [' ', '+'],
+          ['*', '*']
+        ].each do |values|
+          context "escapes #{values[0].inspect} as #{values[1].inspect}" do
+            let(:params) { { param1: "before#{values[0]}after" } }
+            subject { api.get_url(:join, params)[0] }
+            it { subject.should match(/param1=before#{Regexp.quote(values[1])}after/) }
+          end
+        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/
+            if params.map{ |k,v| k }.join =~ /^param1/
               "67882ae54f49600f56f358c10d24697ef7d8c6b2"
             else
               "85a54e28e4ec18bfdcb214a73f74d35b09a84176"
             end
           }
-          subject { api.get_url(:join, params) }
+          subject { api.get_url(:join, params)[0] }
           it { subject.should match(/checksum=#{checksum}$/) }
         end
       end
@@ -477,7 +496,7 @@
       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) }
+      before { api.should_receive(:get_url).with(method, params).and_return([url, nil]) }
 
       context "returns an empty hash if the response body is empty" do
         before do
@@ -567,7 +586,7 @@
         let(:data) { "any data" }
         before {
           path = "/res?param1=value1&checksum=12345"
-          opts = { 'Content-Type' => 'text/xml' }
+          opts = { 'Content-Type' => 'application/x-www-form-urlencoded' }
           @http_mock.should_receive(:post).with(path, data, opts).and_return("ok")
         }
         it {
@@ -589,7 +608,7 @@
         let(:data) { "any data" }
         before {
           path = "/res?param1=value1&checksum=12345"
-          opts = { 'Content-Type' => 'text/xml', :anything => "anything" }
+          opts = { 'Content-Type' => 'application/x-www-form-urlencoded', :anything => "anything" }
           @http_mock.should_receive(:post).with(path, data, opts).and_return("ok")
         }
         it {