RubyGems - steam-condenser - Versions diffs - 1.3.10 → 1.3.11 - Mend

steam-condenser 1.3.10 → 1.3.11

Files changed (1307) hide show

data/pkg/steam-condenser-1.3.8.1/test/steam/community/test_steam_id.rb DELETED

@@ -1,144 +0,0 @@
-# This code is free software; you can redistribute it and/or modify it under
-# the terms of the new BSD License.
-#
-# Copyright (c) 2011, Sebastian Staudt
-require 'helper'
-require 'steam/community/steam_id'
-class TestSteamId < Test::Unit::TestCase
-  context 'The SteamId class' do
-    should 'be able to resolve vanity URLs' do
-      WebApi.expects(:json).
-        with('ISteamUser', 'ResolveVanityURL', 1, { :vanityurl => 'koraktor' }).
-        returns '{ "response": { "success": 1, "steamid": "76561197961384956" } }'
-      steam_id64 = SteamId.resolve_vanity_url 'koraktor'
-      assert_equal 76561197961384956, steam_id64
-    end
-    should 'be return nil when not able to resolve a vanity URL' do
-      WebApi.expects(:json).
-        with('ISteamUser', 'ResolveVanityURL', 1, { :vanityurl => 'unknown' }).
-        returns '{ "response": { "success": 42 } }'
-      assert_nil SteamId.resolve_vanity_url 'unknown'
-    end
-    should 'provide a conversion between 64bit Steam IDs and STEAM_IDs' do
-      steam_id = SteamId.convert_community_id_to_steam_id 76561197960290418
-      assert_equal 'STEAM_0:0:12345', steam_id
-    end
-    should 'provide a conversion between STEAM_IDs and 64bit Steam IDs' do
-      steam_id64 = SteamId.convert_steam_id_to_community_id 'STEAM_0:0:12345'
-      assert_equal 76561197960290418, steam_id64
-    end
-    should 'provide a conversion between U_IDs and 64bit Steam IDs' do
-      steam_id64 = SteamId.convert_steam_id_to_community_id '[U:1:12345]'
-      assert_equal 76561197960278073, steam_id64
-    end
-  end
-  context 'A Steam ID' do
-    should 'be correctly cached' do
-      assert_not SteamId.cached? 76561197983311154
-      steam_id = SteamId.new 76561197983311154, false
-      assert steam_id.cache
-      assert SteamId.cached? 76561197983311154
-    end
-    should 'be correctly cached with its custom URL' do
-      assert_not SteamId.cached? 'Son_of_Thor'
-      steam_id = SteamId.new 'Son_of_Thor', false
-      assert steam_id.cache
-      assert SteamId.cached? 'son_of_Thor'
-    end
-    should 'have an ID' do
-      steam_id1 = SteamId.new 76561197983311154, false
-      steam_id2 = SteamId.new 'Son_of_Thor', false
-      assert_equal 76561197983311154, steam_id1.id
-      assert_equal 'son_of_thor', steam_id2.id
-    end
-    should 'be able to fetch its data' do
-      url = fixture_io 'sonofthor.xml'
-      SteamId.any_instance.expects(:open).with('http://steamcommunity.com/id/son_of_thor?xml=1', { :proxy => true }).returns url
-      steam_id = SteamId.new 'Son_of_Thor'
-      assert_equal 76561197983311154, steam_id.steam_id64
-      assert_equal 'son_of_thor', steam_id.custom_url
-      assert_equal 'Bellevue, Washington, United States', steam_id.location
-      assert_equal 'Dad serious.', steam_id.head_line
-      assert_equal 'Son of Thor', steam_id.nickname
-      assert_equal 'Torsten Zabka', steam_id.real_name
-      assert_equal 'Last Online: 3 days ago', steam_id.state_message
-      assert_equal 'We jump that fence when we get to it.', steam_id.summary
-      assert_equal 'None', steam_id.trade_ban_state
-      assert_equal 'http://media.steampowered.com/steamcommunity/public/images/avatars/b8/b8438d91481295b7cc8da9578004cd63a2c3b2e4_full.jpg', steam_id.full_avatar_url
-      assert_equal 'http://media.steampowered.com/steamcommunity/public/images/avatars/b8/b8438d91481295b7cc8da9578004cd63a2c3b2e4.jpg', steam_id.icon_url
-      assert_equal 'http://media.steampowered.com/steamcommunity/public/images/avatars/b8/b8438d91481295b7cc8da9578004cd63a2c3b2e4_medium.jpg', steam_id.medium_avatar_url
-      assert_not steam_id.banned?
-      assert_not steam_id.limited?
-      assert_not steam_id.online?
-      assert steam_id.fetched?
-      assert steam_id.public?
-    end
-    should 'be found by the 64bit SteamID' do
-      steam_id = SteamId.new 76561197983311154, false
-      assert_equal 76561197983311154, steam_id.steam_id64
-      assert_equal 'http://steamcommunity.com/profiles/76561197983311154', steam_id.base_url
-    end
-    should 'be found by the SteamID\'s custom URL' do
-      steam_id = SteamId.new 'Son_of_Thor', false
-      assert_equal 'son_of_thor', steam_id.custom_url
-      assert_equal 'http://steamcommunity.com/id/son_of_thor', steam_id.base_url
-    end
-    should 'raise an exception when parsing invalid XML' do
-      error = assert_raises SteamCondenserError do
-        url = fixture_io 'invalid.xml'
-        SteamId.any_instance.expects(:open).with('http://steamcommunity.com/id/son_of_thor?xml=1', { :proxy => true }).returns url
-        SteamId.new 'Son_of_Thor'
-      end
-      assert_equal 'XML data could not be parsed.', error.message
-    end
-    should 'not cache an empty hash when an error is encountered on steam' do
-      SteamId.any_instance.expects(:parse).raises(OpenURI::HTTPError.new('', nil))
-      steam_id = SteamId.new(76561197983311154, false)
-      assert_raises OpenURI::HTTPError do
-        steam_id.games
-      end
-      assert_equal(nil, steam_id.instance_variable_get("@games"))
-    end
-    teardown do
-      SteamId.clear_cache
-    end
-  end
-end

data/pkg/steam-condenser-1.3.8.1/test/steam/community/test_web_api.rb DELETED

@@ -1,124 +0,0 @@
-# This code is free software; you can redistribute it and/or modify it under
-# the terms of the new BSD License.
-#
-# Copyright (c) 2011, Sebastian Staudt
-require 'helper'
-require 'steam/community/web_api'
-class TestWebApi < Test::Unit::TestCase
-  context 'The Web API' do
-    setup do
-      WebApi.api_key = '0123456789ABCDEF0123456789ABCDEF'
-    end
-    should 'allow access to the API key' do
-      assert_equal '0123456789ABCDEF0123456789ABCDEF', WebApi.api_key
-    end
-    should 'allow to set the API key' do
-      WebApi.api_key = 'FEDCBA9876543210FEDCBA9876543210'
-      assert_equal 'FEDCBA9876543210FEDCBA9876543210', WebApi.api_key
-    end
-    should 'fail to set an invalid API key' do
-      error = assert_raises WebApiError do
-        WebApi.api_key = 'test'
-      end
-      assert_equal 'This is not a valid Steam Web API key.', error.message
-    end
-    should 'provide easy access to JSON data' do
-      WebApi.expects(:get).with :json, 'interface', 'method', 2, { :test => 'param' }
-      WebApi.json 'interface', 'method', 2, { :test => 'param' }
-    end
-    should 'provide easy access to parsed JSON data' do
-      data = mock
-      WebApi.expects(:json).with('interface', 'method', 2, { :test => 'param' }).
-        returns data
-      MultiJson.expects(:load).with(data, { :symbolize_keys => true }).
-        returns({ :result => { :status => 1 }})
-      assert_equal({ :status => 1 }, WebApi.json!('interface', 'method', 2, { :test => 'param' }))
-    end
-    should 'raise an error if the parsed JSON data is an error message' do
-      data = mock
-      WebApi.expects(:json).with('interface', 'method', 2, { :test => 'param' }).
-        returns data
-      MultiJson.expects(:load).with(data, { :symbolize_keys => true }).
-        returns({ :result => { :status => 2, :statusDetail => 'error' } })
-      error = assert_raises WebApiError do
-        WebApi.json! 'interface', 'method', 2, { :test => 'param' }
-      end
-      assert_equal 'The Web API request failed with the following error: error (status code: 2).', error.message
-    end
-    should 'load data from the Steam Community Web API' do
-      data = mock :read => 'data'
-      WebApi.expects(:open).with do |url, options|
-        options == { :proxy => true, 'Content-Type' => 'application/x-www-form-urlencoded' } &&
-        url.start_with?('https://api.steampowered.com/interface/method/v0002/?') &&
-        (url.split('?').last.split('&') & %w{test=param format=json key=0123456789ABCDEF0123456789ABCDEF}).size == 3
-      end.returns data
-      assert_equal 'data', WebApi.get(:json, 'interface', 'method', 2, { :test => 'param' })
-    end
-    should 'load data from the Steam Community Web API without an API key' do
-      WebApi.api_key = nil
-      data = mock :read => 'data'
-      WebApi.expects(:open).with do |url, options|
-        options == { :proxy => true, 'Content-Type' => 'application/x-www-form-urlencoded' } &&
-        url.start_with?('https://api.steampowered.com/interface/method/v0002/?') &&
-        (url.split('?').last.split('&') & %w{test=param format=json}).size == 2
-      end.returns data
-      assert_equal 'data', WebApi.get(:json, 'interface', 'method', 2, { :test => 'param' })
-    end
-    should 'handle unauthorized access error when loading data' do
-      io = mock :status => [401]
-      http_error = OpenURI::HTTPError.new '', io
-      WebApi.expects(:open).raises http_error
-      error = assert_raises WebApiError do
-        WebApi.get :json, 'interface', 'method', 2, { :test => 'param' }
-      end
-      assert_equal 'Your Web API request has been rejected. You most likely did not specify a valid Web API key.', error.message
-    end
-    should 'handle generic HTTP errors when loading data' do
-      io = mock :status => [[404, 'Not found']]
-      http_error = OpenURI::HTTPError.new '', io
-      WebApi.expects(:open).raises http_error
-      error = assert_raises WebApiError do
-        WebApi.get :json, 'interface', 'method', 2, { :test => 'param' }
-      end
-      assert_equal 'The Web API request has failed due to an HTTP error: Not found (status code: 404).', error.message
-    end
-    should 'use insecure HTTP if set' do
-      WebApi.secure = false
-      data = mock :read => 'data'
-      WebApi.expects(:open).with do |url, options|
-        options == { :proxy => true, 'Content-Type' => 'application/x-www-form-urlencoded' } &&
-        url.start_with?('http://api.steampowered.com/interface/method/v0002/?') &&
-        (url.split('?').last.split('&') & %w{test=param format=json key=0123456789ABCDEF0123456789ABCDEF}).size == 3
-      end.returns data
-      assert_equal 'data', WebApi.get(:json, 'interface', 'method', 2, { :test => 'param' })
-    end
-  end
-end

data/pkg/steam-condenser-1.3.8.1/test/steam/packets/test_steam_packet.rb DELETED

@@ -1,37 +0,0 @@
-# This code is free software; you can redistribute it and/or modify it under
-# the terms of the new BSD License.
-#
-# Copyright (c) 2012, Sebastian Staudt
-require 'helper'
-require 'steam/packets/steam_packet'
-class TestSteamPacket < Test::Unit::TestCase
-  class GenericSteamPacket
-    include SteamPacket
-  end
-  context 'A packet' do
-    setup do
-      @packet = GenericSteamPacket.new 0x61, 'test'
-    end
-    should 'have a data buffer' do
-      data = @packet.instance_variable_get(:@content_data)
-      assert_instance_of StringIO, data
-      assert_equal 'test', data.string
-    end
-    should 'know its header' do
-      assert_equal 0x61, @packet.instance_variable_get(:@header_data)
-    end
-    should 'have a valid byte representation' do
-      assert_equal [255, 255, 255, 255, 'atest'].pack('c4a*'), @packet.to_s
-    end
-  end
-end

data/pkg/steam-condenser-1.3.8.1/test/steam/servers/test_game_server.rb DELETED

@@ -1,296 +0,0 @@
-# This code is free software; you can redistribute it and/or modify it under
-# the terms of the new BSD License.
-#
-# Copyright (c) 2011, Sebastian Staudt
-require 'helper'
-require 'steam/servers/game_server'
-class TestGameServer < Test::Unit::TestCase
-  context 'A generic game server' do
-    class GenericGameServer
-      include GameServer
-    end
-    setup do
-      Socket.stubs(:getaddrinfo).
-        with('game', 27015, Socket::AF_INET, Socket::SOCK_DGRAM).
-        returns [[nil, nil, 'game', '127.0.0.1']]
-      @socket = mock
-      @server = GenericGameServer.new 'game', 27015
-      @server.instance_variable_set :@socket, @socket
-    end
-    should 'send packets using its client socket' do
-      packet = mock
-      @socket.expects(:send).with packet
-      @server.send :send_request, packet
-    end
-    should 'get replies using its client socket' do
-      packet = mock
-      @socket.expects(:reply).returns packet
-      assert_equal packet, @server.send(:reply)
-    end
-    should 'be able to calculate the latency of the server' do
-      @server.expects(:send_request).with do |packet|
-        packet.is_a? A2S_INFO_Packet
-      end
-      @server.expects(:reply).with { || sleep 0.05 }
-      @server.update_ping
-      assert_operator @server.instance_variable_get(:@ping), :>=, 50
-    end
-    should 'be able to get a challenge from the server' do
-      @server.expects(:handle_response_for_request).with :challenge
-      @server.update_challenge_number
-    end
-    should 'be able to get information about server' do
-      @server.expects(:handle_response_for_request).with :info
-      @server.update_server_info
-    end
-    should 'be able to get the server rules' do
-      @server.expects(:handle_response_for_request).with :rules
-      @server.update_rules
-    end
-    should 'be able to get the players on the server' do
-      @server.expects(:handle_response_for_request).with :players
-      @server.update_players
-    end
-    should 'provide a convenience wrapper for basic server methods' do
-      @server.expects :update_ping
-      @server.expects :update_server_info
-      @server.expects :update_challenge_number
-      @server.init
-    end
-    should 'know if its RCON connection is authenticated' do
-      assert_equal @server.instance_variable_get(:@rcon_authenticated),
-                   @server.rcon_authenticated?
-    end
-    should 'cache the ping of the server' do
-      @server.expects :update_ping
-      @server.ping
-      @server.instance_variable_set :@ping, 0
-      @server.ping
-    end
-    should 'cache the players on the server' do
-      @server.expects :update_players
-      @server.players
-      @server.instance_variable_set :@player_hash, 0
-      @server.players
-    end
-    should 'cache the server rules' do
-      @server.expects :update_rules
-      @server.rules
-      @server.instance_variable_set :@rules_hash, 0
-      @server.rules
-    end
-    should 'cache the server information' do
-      @server.expects :update_server_info
-      @server.server_info
-      @server.instance_variable_set :@info_hash, 0
-      @server.server_info
-    end
-    context 'be able to get additional information about the players on a Source server' do
-      setup do
-        status = fixture 'status_source'
-        @someone = mock
-        @somebody = mock
-        player_hash = { 'someone' => @someone, 'somebody' => @somebody }
-        @server.instance_variable_set :@player_hash, player_hash
-        @server.expects(:handle_response_for_request).with :players
-        @server.expects(:rcon_exec).with('status').returns status
-        someone_data = { :name => 'someone', :userid => '1', :uniqueid => 'STEAM_0:0:123456', :score => '10', :time => '3:52', :ping => '12', :loss => '0', :state => 'active' }
-        somebody_data = { :name => 'somebody', :userid => '2', :uniqueid => 'STEAM_0:0:123457', :score => '3', :time => '2:42', :ping => '34', :loss => '0', :state => 'active' }
-        attributes = mock
-        GameServer.expects(:player_status_attributes).
-          with('userid name           uniqueid            score connected ping loss state').
-          returns attributes
-        GameServer.expects(:split_player_status).
-          with(attributes, '1 "someone"      STEAM_0:0:123456    10    3:52      12   0    active').
-          returns somebody_data
-        GameServer.expects(:split_player_status).
-          with(attributes, '2 "somebody"     STEAM_0:0:123457    3     2:42      34   0    active').
-          returns someone_data
-        @somebody.expects(:add_info).with somebody_data
-        @someone.expects(:add_info).with someone_data
-      end
-      should 'with the RCON password' do
-        @server.expects(:rcon_auth).with 'password'
-        @server.update_players 'password'
-      end
-      should 'if the RCON connection is authenticated' do
-        @server.instance_variable_set :@rcon_authenticated, true
-        @server.update_players
-      end
-    end
-    should 'be able to get additional information about the players on a GoldSrc server with the RCON password' do
-      status = fixture 'status_goldsrc'
-      @someone = mock
-      @somebody = mock
-      player_hash = { 'someone' => @someone, 'somebody' => @somebody }
-      @server.instance_variable_set :@player_hash, player_hash
-      @server.expects(:handle_response_for_request).with :players
-      @server.expects(:rcon_exec).with('status').returns status
-      someone_data = { :name => 'someone', :userid => '1', :uniqueid => 'STEAM_0:0:123456', :score => '10', :time => '3:52', :ping => '12', :loss => '0', :adr => '0' }
-      somebody_data = { :name => 'somebody', :userid => '2', :uniqueid => 'STEAM_0:0:123457', :score => '3', :time => '2:42', :ping => '34', :loss => '0', :adr => '0' }
-      attributes = mock
-      GameServer.expects(:player_status_attributes).
-        with('name userid uniqueid frag time ping loss adr').
-        returns attributes
-      GameServer.expects(:split_player_status).
-        with(attributes, '1   "someone" 1 STEAM_0:0:123456 10 3:52 12 0 0').
-        returns somebody_data
-      GameServer.expects(:split_player_status).
-        with(attributes, '2   "somebody" 2 STEAM_0:0:123457 3 2:42 34 0 0').
-        returns someone_data
-      @somebody.expects(:add_info).with somebody_data
-      @someone.expects(:add_info).with someone_data
-      @server.expects(:rcon_auth).with 'password'
-      @server.update_players 'password'
-    end
-    should 'handle challenge requests' do
-      @server.expects(:send_request).with do |packet|
-        packet.is_a? A2S_PLAYER_Packet
-      end
-      packet = mock
-      packet.expects(:kind_of?).with(S2A_INFO_BasePacket).returns false
-      packet.expects(:kind_of?).with(S2A_PLAYER_Packet).returns false
-      packet.expects(:kind_of?).with(S2A_RULES_Packet).returns false
-      packet.expects(:kind_of?).with(S2C_CHALLENGE_Packet).twice.returns true
-      packet.expects(:challenge_number).returns 1234
-      @server.expects(:reply).returns packet
-      @server.handle_response_for_request :challenge
-      assert_equal 1234, @server.instance_variable_get(:@challenge_number)
-    end
-    should 'handle info requests' do
-      @server.expects(:send_request).with do |packet|
-        packet.is_a? A2S_INFO_Packet
-      end
-      packet = mock
-      packet.expects(:kind_of?).with(S2A_INFO_BasePacket).twice.returns true
-      packet.expects(:info).returns({ :test => 'test' })
-      @server.expects(:reply).returns packet
-      @server.handle_response_for_request :info
-      assert_equal({ :test => 'test' }, @server.instance_variable_get(:@info_hash))
-    end
-    should 'handle rule requests' do
-      @server.expects(:send_request).with do |packet|
-        packet.is_a? A2S_RULES_Packet
-      end
-      packet = mock
-      packet.expects(:kind_of?).with(S2A_INFO_BasePacket).returns false
-      packet.expects(:kind_of?).with(S2A_PLAYER_Packet).returns false
-      packet.expects(:kind_of?).with(S2A_RULES_Packet).twice.returns true
-      packet.expects(:rules_hash).returns({ :test => 'test' })
-      @server.expects(:reply).returns packet
-      @server.handle_response_for_request :rules
-      assert_equal({ :test => 'test' }, @server.instance_variable_get(:@rules_hash))
-    end
-    should 'handle player requests' do
-      @server.expects(:send_request).with do |packet|
-        packet.is_a? A2S_PLAYER_Packet
-      end
-      packet = mock
-      packet.expects(:kind_of?).with(S2A_INFO_BasePacket).returns false
-      packet.expects(:kind_of?).with(S2A_PLAYER_Packet).twice.returns true
-      packet.expects(:player_hash).returns({ :test => 'test' })
-      @server.expects(:reply).returns packet
-      @server.handle_response_for_request :players
-      assert_equal({ :test => 'test' }, @server.instance_variable_get(:@player_hash))
-    end
-    should 'handle unexpected answers and retry' do
-      @server.expects(:send_request).twice.with do |packet|
-        packet.is_a? A2S_PLAYER_Packet
-      end
-      packet1 = mock
-      packet1.expects(:kind_of?).with(S2A_INFO_BasePacket).returns true
-      packet1.expects(:kind_of?).with(S2A_PLAYER_Packet).returns false
-      packet1.expects(:info).returns({ :test => 'test1' })
-      packet2 = mock
-      packet2.expects(:kind_of?).with(S2A_INFO_BasePacket).returns false
-      packet2.expects(:kind_of?).with(S2A_PLAYER_Packet).twice.returns true
-      packet2.expects(:player_hash).returns({ :test => 'test2' })
-      @server.expects(:reply).twice.returns(packet1).returns packet2
-      @server.handle_response_for_request :players
-      assert_equal({ :test => 'test1' }, @server.instance_variable_get(:@info_hash))
-      assert_equal({ :test => 'test2' }, @server.instance_variable_get(:@player_hash))
-    end
-  end
-end