mediawiki-gateway 0.6.2 → 1.0.0.rc1

data/spec/fake_media_wiki/query_handling.rb

@@ -1,136 +0,0 @@
-
-module FakeMediaWiki
-  
-  module QueryHandling
-
-    def action
-      [:userrights].each do |action_type|
-        return send(action_type)
-      end
-      halt(404, "Page not found")
-    end
-
-    def query
-      [:prop, :export, :list, :meta].each do |query_type|
-        return send(query_type) if params[query_type]
-      end
-      halt(404, "Page not found")
-    end
-
-    def prop
-      return get_revisions if params[:prop] == "revisions"
-      return get_undelete_token if params[:drprop] == 'token'
-      return get_token if params[:intoken]
-      return get_info if params[:prop] == "info"
-    end
-
-    def export
-      builder do |_|
-        _.mediawiki do
-          requested_page_titles.each do |requested_title|
-            page = @pages.get(requested_title)
-            _.page do
-              _.title(page[:title])
-              _.id(page[:pageid])
-              _.revision do
-                _.id(page[:pageid])
-                _.text(page[:content])
-              end
-            end
-          end
-        end
-      end
-    end
-    
-    def list
-      list_type = params[:list].to_sym
-
-      # api.php?action=query&list=users&ususers=Bob&ustoken=userrights
-      if list_type == :users && params[:ustoken] && params[:ususers]
-        # This "list" is actually a request for a user rights token
-        return get_userrights_token(params[:ususers])
-      end
-      
-      # This is a real list
-      return send(list_type) if respond_to?(list_type)
-      halt(404, "Page not found")
-    end
-
-    def allpages
-      api_response do |_|
-        _.query do
-          _.allpages do
-            prefix = params[:apprefix]
-            namespace = @pages.namespaces_by_id[params[:apnamespace].to_i]
-            prefix = "#{namespace}:#{prefix}" unless namespace.empty?
-            @pages.list(prefix).each do |key, page|
-              _.p(nil, { :title => page[:title], :ns => page[:namespace], :id => page[:pageid] })
-            end
-          end
-        end
-      end
-    end
-
-    def search
-      api_response do |_|
-        _.query do
-          _.search do
-            namespaces = params[:srnamespace] ? params[:srnamespace].split('|') : [ "0" ]
-            @pages.search(params[:srsearch], namespaces).first(params[:srlimit].to_i).each do |key, page|
-              _.p(nil, { :title => page[:title], :ns => page[:namespace], :id => page[:pageid] })
-            end
-          end
-        end
-      end
-    end
-    
-    def meta
-      meta_type = params[:meta].to_sym
-      return send(meta_type) if respond_to?(meta_type)
-      halt(404, "Page not found")
-    end
-    
-    def siteinfo
-      if siteinfo_type = params[:siprop]
-        return send(siteinfo_type) if respond_to?(siteinfo_type)
-        halt(404, "Page not found")
-      else
-        api_response do |_|
-          _.query do
-            _.general(generator: "MediaWiki #{MediaWiki::VERSION}")
-          end
-        end
-      end
-    end
-    
-    def namespaces
-      api_response do |_|
-        _.query do
-          _.namespaces do
-            @pages.namespaces_by_prefix.each do |prefix, id|
-              attr = { :id => id }
-              attr[:canonical] = prefix unless prefix.empty?
-              _.ns(prefix, attr)
-            end
-          end
-        end
-      end
-    end
-
-    def extensions
-      api_response do |_|
-        _.query do
-          _.extensions do
-            @extensions.each do |name, version|
-              attr = { :version => version }
-              attr[:name] = name unless name.empty?
-              _.ext(name, attr)
-            end
-          end
-        end
-      end
-    end
-    
-  end
-
-end

data/spec/gateway_spec.rb

@@ -1,888 +0,0 @@
-require 'spec_helper'
-
-# Kickstart fake media wiki app
-require 'sham_rack'
-require_relative 'fake_media_wiki/app'
-
-$fake_media_wiki = FakeMediaWiki::App.new!
-ShamRack.mount($fake_media_wiki, 'dummy-wiki.example')
-
-describe MediaWiki::Gateway do
-
-  before do
-    @gateway = MediaWiki::Gateway.new('http://dummy-wiki.example/w/api.php')
-    $fake_media_wiki.reset
-  end
-
-  describe '#login' do
-
-    describe "with a valid username & password" do
-
-      before do
-        @gateway.login('atlasmw', 'wombat')
-      end
-
-      it "should login successfully with the default domain" do
-        $fake_media_wiki.logged_in('atlasmw').should == true
-      end
-
-    end
-
-    describe "with a valid username, password and domain" do
-
-      before do
-        @gateway.login('ldapuser', 'ldappass', 'ldapdomain')
-      end
-
-      it "should login successfully" do
-        $fake_media_wiki.logged_in('ldapuser').should == true
-      end
-
-    end
-
-    describe "with an non-existent username" do
-
-      it "should raise an error" do
-        lambda do
-          @gateway.login('bogususer', 'sekrit')
-        end.should raise_error(MediaWiki::Unauthorized)
-      end
-
-    end
-
-    describe "with an incorrect password" do
-
-      it "should raise an error" do
-        lambda do
-          @gateway.login('atlasmw', 'sekrit')
-        end.should raise_error(MediaWiki::Unauthorized)
-      end
-
-    end
-
-    describe "with an incorrect domain" do
-
-      it "should raise an error" do
-        lambda do
-          @gateway.login('atlasmw', 'wombat', 'bogusdomain')
-        end.should raise_error(MediaWiki::Unauthorized)
-      end
-
-    end
-
-  end
-
-  describe "#get_token" do
-
-    describe "when not logged in" do
-
-      describe "requesting an edit token" do
-
-        before do
-          @token = @gateway.send(:get_token, 'edit', 'Main Page')
-        end
-
-        it "should return a blank token" do
-          @token.should_not == nil
-          @token.should == "+\\"
-        end
-
-      end
-
-      describe "requesting an import token" do
-
-        it "should raise an error" do
-          lambda do
-            @gateway.send(:get_token, 'import', 'Main Page')
-          end.should raise_error(MediaWiki::Unauthorized)
-        end
-
-      end
-
-    end
-
-    describe "when logged in as admin user" do
-
-      before do
-        @gateway.login('atlasmw', 'wombat')
-      end
-
-      describe "requesting an edit token for a single page" do
-
-        before do
-          @token = @gateway.send(:get_token, 'edit', 'Main Page')
-        end
-
-        it "should return a token" do
-          @token.should_not == nil
-          @token.should_not == "+\\"
-        end
-
-      end
-
-      describe "requesting an edit token for multiple pages" do
-
-        before do
-          @token = @gateway.send(:get_token, 'edit', "Main Page|Another Page")
-        end
-
-        it "should return a token" do
-          @token.should_not == nil
-          @token.should_not == "+\\"
-        end
-
-      end
-
-      describe "requesting an import token" do
-
-        before do
-          @token = @gateway.send(:get_token, 'import', 'Main Page')
-        end
-
-        it "should return a token" do
-          @token.should_not == nil
-          @token.should_not == "+\\"
-        end
-
-      end
-
-    end
-
-  end
-
-  describe "#get" do
-
-    describe "for an existing wiki page" do
-
-      it "returns raw page content" do
-        @gateway.get("Main Page").should == "Content"
-      end
-
-    end
-
-    describe "for an existing empty wiki page" do
-
-      it "returns an empty string" do
-        @gateway.get("Empty").should == ""
-      end
-
-    end
-
-    describe "for a missing wiki page" do
-
-      it "returns nil" do
-        @gateway.get("page/missing").should be_nil
-      end
-
-    end
-
-    describe "for root (/)" do
-
-      it "returns nil" do
-        @gateway.get("").should be_nil
-      end
-
-    end
-
-    describe "when wiki returns 503" do
-
-      before do
-        @log = double(:debug => nil, :warn => nil)
-        @fail_gateway = MediaWiki::Gateway.new('http://dummy-wiki.example/w/api.php', {:maxlag => -1, :retry_delay => 0})
-        allow(@fail_gateway).to receive(:log) { @log }
-      end
-
-      it "should retry twice and fail" do
-        lambda {
-          @fail_gateway.get("")
-        }.should raise_error
-        @log.should have_received(:warn).with("503 Service Unavailable: Maxlag exceeded.  Retry in 0 seconds.").twice
-      end
-
-    end
-
-    it "should pass options to RestClient::Request" do
-      gateway = MediaWiki::Gateway.new('http://dummy-wiki.example/w/api.php', {}, :verify_ssl => false)
-      RestClient::Request.should receive(:execute).with(hash_including(:verify_ssl => false)).and_return([double(:elements => {})])
-      gateway.get("").should be_nil
-    end
-
-  end
-
-  describe "#redirect?" do
-
-    describe "for an existing redirect page" do
-
-      it "returns true" do
-        @gateway.redirect?("Redirect").should == true
-      end
-
-    end
-
-    describe "for an existing non-redirect page" do
-
-      it "returns false" do
-        @gateway.redirect?("Main Page").should == false
-      end
-
-    end
-
-    describe "for a missing wiki page" do
-
-      it "returns false" do
-        @gateway.redirect?("page/missing").should == false
-      end
-
-    end
-
-  end
-
-  describe "#render" do
-
-    describe "for an existing wiki page" do
-
-      before do
-        @pages = @gateway.render('Main Page')
-      end
-
-      it "should return the page content" do
-        expected = 'Sample <B>HTML</B> content.'
-        @pages.to_s.should == expected
-      end
-
-      it "should raise an ArgumentError on illegal options" do
-        lambda do
-          @gateway.render("Main Page", :doesnotexist => :at_all)
-        end.should raise_error(ArgumentError)
-      end
-
-      describe "with option" do
-
-        it "should strip img tags" do
-          @pages = @gateway.render('Foopage', :noimages => true)
-
-          expected = 'Sample <B>HTML</B> content.'\
-            '<span class="editsection">[<a title="Edit section: Nomenclature" href="/w/index.php?title=Seat_of_local_government&amp;action=edit&amp;section=1">edit</a>]</span>'\
-            '<a title="Interpreted language" href="/wiki/Interpreted_language">interpreted language</a>'
-          @pages.to_s.should == expected
-        end
-
-        it "should strip edit sections" do
-          @pages = @gateway.render('Foopage', :noeditsections => true)
-
-          expected = 'Sample <B>HTML</B> content.' \
-            '<img width="150" height="150" class="thumbimage" src="http://upload.wikimedia.org/foo/Ruby_logo.svg" alt="Ruby logo.svg"/>' \
-            '<a title="Interpreted language" href="/wiki/Interpreted_language">interpreted language</a>'
-          @pages.to_s.should == expected
-        end
-
-        it "should make all links absolute" do
-          @pages = @gateway.render('Foopage', :linkbase => "http://en.wikipedia.org")
-
-          expected = 'Sample <B>HTML</B> content.' \
-            '<img width="150" height="150" class="thumbimage" src="http://upload.wikimedia.org/foo/Ruby_logo.svg" alt="Ruby logo.svg"/>' \
-            '<span class="editsection">[<a title="Edit section: Nomenclature" href="/w/index.php?title=Seat_of_local_government&amp;action=edit&amp;section=1">edit</a>]</span>'\
-            '<a title="Interpreted language" href="http://en.wikipedia.org/wiki/Interpreted_language">interpreted language</a>'
-          @pages.to_s.should == expected
-        end
-
-      end
-
-    end
-
-    describe "for a missing wiki page" do
-
-      before do
-        @pages = @gateway.render('Invalidpage')
-      end
-
-      it "should return nil" do
-        @pages.should == nil
-      end
-
-    end
-
-  end
-
-  describe "#create" do
-
-    before do
-      @gateway.login('atlasmw', 'wombat')
-    end
-
-    describe "when creating a new page" do
-
-      before do
-        @page = @gateway.create("A New Page", "Some content")
-      end
-
-      it "should create the page" do
-        expected = <<-XML
-          <api>
-            <edit new='' result='Success' pageid='8' title='A New Page' oldrevid='0' newrevid='8'/>
-          </api>
-        XML
-        Hash.from_xml(@page.first.to_s).should == Hash.from_xml(expected)
-      end
-
-    end
-
-    describe "when creating a page that already exists" do
-
-      before do
-        $fake_media_wiki.reset
-      end
-
-      describe "and the 'overwrite' option is set" do
-
-        before do
-          @new_page = @gateway.create("Main Page", "Some new content", :summary => "The summary", :overwrite => true)
-        end
-
-        it "should overwrite the existing page" do
-          expected = <<-XML
-            <api>
-              <edit result='Success' pageid='8' title='Main Page' oldrevid='1' newrevid='8'/>
-            </api>
-          XML
-          Hash.from_xml(@new_page.first.to_s).should == Hash.from_xml(expected)
-        end
-
-      end
-
-      describe "and the 'overwrite' option is not set" do
-
-        it "should raise an error" do
-          lambda do
-            @gateway.create("Main Page", "Some new content")
-          end.should raise_error(MediaWiki::APIError)
-        end
-
-      end
-
-    end
-
-  end
-
-  describe "#edit" do
-    before do
-      $fake_media_wiki.reset
-      @edit_page = @gateway.edit("Main Page", "Some new content")
-    end
-
-    it "should overwrite the existing page" do
-      expected = <<-XML
-      <api>
-        <edit result='Success' pageid='8' title='Main Page' oldrevid='1' newrevid='8'/>
-      </api>
-      XML
-      Hash.from_xml(@edit_page.first.to_s).should == Hash.from_xml(expected)
-    end
-
-  end
-
-  describe "#upload" do
-
-    before do
-      @gateway.login('atlasmw', 'wombat')
-    end
-
-    describe "when uploading a new file" do
-
-      before do
-        @path = 'some/path/sample_image.jpg'
-        allow(File).to receive(:new).with(@path).and_return('SAMPLEIMAGEDATA')
-        @page = @gateway.upload(@path)
-      end
-
-      it "should open the file" do
-        File.should have_received(:new).with(@path)
-      end
-
-      it "should upload the file" do
-        expected = <<-XML
-          <api>
-            <upload result="Success" filename="sample_image.jpg"/>
-          </api>
-        XML
-        Hash.from_xml(@page.first.to_s).should == Hash.from_xml(expected)
-      end
-
-    end
-
-  end
-
-  describe "#delete" do
-
-    describe "when logged in as admin" do
-
-      describe "and the page exists" do
-        def delete_response
-         <<-XML
-            <api>
-              <delete title='Deletable Page' reason='Default reason'/>
-            </api>
-         XML
-        end
-
-        before do
-          @gateway.login("atlasmw", "wombat")
-
-          create("Deletable Page", "Some content")
-          @page = @gateway.delete("Deletable Page")
-        end
-
-        it "should delete the page" do
-          Hash.from_xml(@page.first.to_s) == Hash.from_xml(delete_response)
-        end
-      end
-
-      describe "and the page does not exist" do
-
-        before do
-          @gateway.login("atlasmw", "wombat")
-        end
-
-        it "should raise an error" do
-          lambda do
-            @gateway.delete("Missing Page")
-          end.should raise_error(MediaWiki::APIError)
-        end
-      end
-    end
-
-    describe "when not logged in" do
-
-      before do
-        create("Deletable Page", "Some content")
-      end
-
-      it "should raise an error" do
-        lambda do
-          @gateway.delete("Deletable Page")
-        end.should raise_error(MediaWiki::Unauthorized)
-      end
-
-    end
-
-  end
-
-  describe "#undelete" do
-
-    describe "when logged in as admin" do
-      before do
-        $fake_media_wiki.reset
-        @gateway.login("atlasmw", "wombat")
-      end
-
-      describe "and the page no longer exists" do
-        before do
-          @revs = @gateway.undelete("Sandbox:Undeleted")
-        end
-
-        it "should recreate the given page" do
-          @gateway.list("Sandbox:Undeleted").should == [ "Sandbox:Undeleted" ]
-        end
-
-        it "should report one undeleted revision" do
-          @revs.should == 1
-        end
-      end
-
-      describe "but the page exists" do
-        before do
-          @revs = @gateway.undelete("Main Page")
-        end
-
-        it "should report zero undeleted revisions" do
-          @revs.should == 0
-        end
-      end
-    end
-
-    describe "when not logged in" do
-
-      it "should raise an error" do
-        lambda do
-          @gateway.undelete("Undeletable Page")
-        end.should raise_error(MediaWiki::APIError)
-      end
-
-    end
-
-  end
-
-  describe "#list" do
-
-    before do
-      $fake_media_wiki.reset
-    end
-
-    describe "with an empty key" do
-
-      before do
-        @list = @gateway.list("")
-      end
-
-      it "should list all pages" do
-        @list.sort.should == [ "Book:Italy", "Empty", "Foopage", "Level/Level/Index", "Main 2", "Main Page", "Redirect" ]
-      end
-
-    end
-
-    describe "with a namespace as the key" do
-
-      before do
-        @list = @gateway.list("Book:")
-      end
-
-      it "should list all pages in the namespace" do
-        @list.should == [ "Book:Italy" ]
-      end
-
-    end
-
-    describe "with a partial title as the key" do
-
-      before do
-        @list = @gateway.list("Main")
-      end
-
-      it "should list all pages in the main namespace that start with key" do
-        @list.sort.should == [ "Main 2", "Main Page" ]
-      end
-
-    end
-
-  end
-
-  describe "#search" do
-
-    before do
-      $fake_media_wiki.reset
-      @gateway.create("Search Test", "Foo KEY Blah")
-      @gateway.create("Search Test 2", "Zomp KEY Zorg")
-      @gateway.create("Book:Search Test", "Bar KEY Baz")
-      @gateway.create("Sandbox:Search Test", "Evil KEY Evil")
-    end
-
-    describe "with an empty key" do
-
-      it "should raise an error" do
-        lambda do
-          @gateway.search("")
-        end.should raise_error(MediaWiki::APIError)
-      end
-
-    end
-
-    describe "with a valid key and no namespaces" do
-
-      before do
-        @search = @gateway.search("KEY")
-      end
-
-      it "should list all matching pages in the main namespace" do
-        @search.should =~ [ "Search Test", "Search Test 2" ]
-      end
-
-    end
-
-    describe "with a valid key and a namespace string" do
-
-      before do
-        @search = @gateway.search("KEY", "Book")
-      end
-
-      it "should list all matching pages in the specified namespaces" do
-        @search.should == [ "Book:Search Test" ]
-      end
-
-    end
-
-    describe "with a valid key and a namespace array" do
-
-      before do
-        @search = @gateway.search("KEY", ["Book", "Sandbox"])
-      end
-
-      it "should list all matching pages in the specified namespaces" do
-        @search.should =~ [ "Sandbox:Search Test", "Book:Search Test" ]
-      end
-
-    end
-
-    describe "with maximum number of results" do
-
-      before do
-        @search = @gateway.search("KEY", nil, 2, 1)
-      end
-
-      it "should return at most the maximum number of results asked" do
-        @search.size.should == 1
-      end
-    end
-
-  end
-
-  describe "#namespaces_by_prefix" do
-
-    before do
-      $fake_media_wiki.reset
-      @namespaces = @gateway.namespaces_by_prefix
-    end
-
-    it "should list all namespaces" do
-      @namespaces.should == { "" => 0, "Book" => 100, "Sandbox" => 200}
-    end
-
-  end
-
-  describe "#semantic_query" do
-
-    before do
-      @response = @gateway.semantic_query('[[place::123]]', ['mainlabel=Page'])
-    end
-
-    it "should return an HTML string" do
-      @response.should == 'Sample <B>HTML</B> content.'
-    end
-
-  end
-
-  describe "#import" do
-
-    def import_file
-      File.dirname(__FILE__) + "/import-test-data.xml"
-    end
-
-    describe "when not logged in" do
-
-      it "should raise an error" do
-        lambda do
-          @gateway.import(import_file)
-        end.should raise_error(MediaWiki::Unauthorized)
-      end
-
-    end
-
-    describe "when logged in as admin" do
-
-      def import_response
-        <<-XML
-          <api>
-            <import>
-              <page title='Main Page' ns='0' revisions='0'/>
-              <page title='Template:Header' ns='10' revisions='1'/>
-            </import>
-          </api>
-        XML
-      end
-
-      before do
-        @gateway.login("atlasmw", "wombat")
-        @page = @gateway.import(import_file)
-      end
-
-      it "should import content" do
-        Hash.from_xml(@page.first.to_s) == Hash.from_xml(import_response)
-      end
-
-    end
-
-  end
-
-  describe "#export" do
-
-    def export_response
-      <<-XML
-        <mediawiki>
-          <page>
-            <title>Main Page</title>
-            <id>1</id>
-            <revision>
-              <id>1</id>
-              <text>Content</text>
-            </revision>
-          </page>
-        </mediawiki>
-      XML
-    end
-
-    before do
-      @page = @gateway.export("Main Page")
-    end
-
-    it "should return export data for the page" do
-      Hash.from_xml(@page.to_s).should == Hash.from_xml(export_response)
-    end
-
-  end
-
-  describe "#siteinfo" do
-
-    before do
-      $fake_media_wiki.reset
-      @siteinfo = @gateway.siteinfo
-    end
-
-    it "should get the siteinfo" do
-      @siteinfo.should == { 'generator' => "MediaWiki #{MediaWiki::VERSION}" }
-    end
-
-  end
-
-  describe "#version" do
-
-    before do
-      $fake_media_wiki.reset
-      @version = @gateway.version
-    end
-
-    it "should get the version" do
-      @version.should == MediaWiki::VERSION
-    end
-
-  end
-
-  describe "#namespaces_by_prefix" do
-
-    before do
-      $fake_media_wiki.reset
-      @namespaces = @gateway.send :namespaces_by_prefix
-    end
-
-    it "should list all namespaces" do
-      @namespaces.should == { "" => 0, "Book" => 100, "Sandbox" => 200}
-    end
-
-  end
-
-  describe "#extensions" do
-
-    before do
-      $fake_media_wiki.reset
-      @extensions = @gateway.extensions
-    end
-
-    it "should list all extensions" do
-      @extensions.should == { "FooExtension" => "r1", "BarExtension" => "r2", 'Semantic MediaWiki' => '1.5' }
-    end
-
-  end
-
-  def create(title, content, options={})
-    form_data = {'action' => 'edit', 'title' => title, 'text' => content, 'summary' => (options[:summary] || ""), 'token' => @gateway.send(:get_token, 'edit', title)}
-    form_data['createonly'] = "" unless options[:overwrite]
-    @gateway.send(:make_api_request, form_data)
-  end
-
-  describe "#create_account" do
-
-    describe "when logged in as admin" do
-      before do
-        @gateway.login("atlasmw", "wombat")
-      end
-
-      it 'should get expected result' do
-        expected = <<-XML
-          <api>
-            <createaccount result='success' token='admin_token+\\' userid='4' username='FooBar'/>
-          </api>
-        XML
-
-        Hash.from_xml(@gateway.create_account({ 'name' => 'FooBar', 'password' => 'BarBaz' }).to_s).should == Hash.from_xml(expected)
-      end
-
-    end
-
-  end
-
-  describe '#options' do
-    
-    describe 'when logged in' do
-      before do
-        @gateway.login("atlasmw", "wombat")
-      end
-
-      describe 'requesting an options token' do
-        before  do
-          @token = @gateway.send(:get_options_token)
-        end
-
-        it "should return a token" do
-          @token.should_not == nil
-          @token.should_not == "+\\"
-        end
-
-      end
-
-      it 'should return the expected response' do
-        expected = '<api options="success" />'
-        Hash.from_xml(@gateway.options({ :realname => 'Bar Baz' }).to_s).should == Hash.from_xml(expected)
-      end
-
-    end
-
-  end
-
-  describe "#user_rights" do
-
-    describe "when logged in as admin" do
-      before do
-        @gateway.login("atlasmw", "wombat")
-      end
-
-      describe "requesting a userrights token for an existing user" do
-
-        before do
-          @token = @gateway.send(:get_userrights_token, 'nonadmin')
-        end
-
-        it "should return a token" do
-          @token.should_not == nil
-          @token.should_not == "+\\"
-        end
-      end
-
-      describe "requesting a userrights token for an nonexistant user" do
-
-        it "should raise an error" do
-          lambda do
-            @gateway.send(:get_userrights_token, 'nosuchuser')
-          end.should raise_error(MediaWiki::APIError)
-        end
-      end
-
-      describe "changing a user's groups with a valid token" do
-
-        def userrights_response
-          <<-XML
-            <api>
-              <userrights user="nonadmin">
-                <removed>
-                  <group>oldgroup</group>
-                </removed>
-                <added>
-                  <group>newgroup</group>
-                </added>
-              </userrights>
-            </api>
-          XML
-        end
-
-        before do
-          @token = @gateway.send(:get_userrights_token, 'nonadmin')
-          @result = @gateway.send(:userrights, 'nonadmin', @token, 'newgroup', 'oldgroup', 'because I can')
-        end
-
-        it "should return a result matching the input" do
-          Hash.from_xml(@result.to_s).should == Hash.from_xml(userrights_response)
-        end
-
-      end
-
-    end
-  end
-
-end