# Extracts the secrets for the XMMP account `account_name`. def xmpp_account(account_name, required_options = []) begin account = $config["Pidgin"]["Accounts"]["XMPP"][account_name] check_keys = ["username", "domain", "password"] + required_options for key in check_keys do assert(account.has_key?(key)) assert_not_nil(account[key]) assert(!account[key].empty?) end rescue NoMethodError, Test::Unit::AssertionFailedError raise( <<EOF Your Pidgin:Accounts:XMPP:#{account} is incorrect or missing from your local configuration file (#{LOCAL_CONFIG_FILE}). See wiki/src/contribute/release_process/test/usage.mdwn for the format. EOF ) end return account end def wait_and_focus(img, time = 10, window) begin @screen.wait(img, time) rescue FindFailed $vm.focus_window(window) @screen.wait(img, time) end end def focus_pidgin_irc_conversation_window(account) if account == 'I2P' # After connecting to Irc2P messages are sent from services. Most of the # time the services will send their messages right away. If there's lag we # may in fact join the channel _before_ the message is received. We'll look # for a message from InfoServ first then default to looking for '#i2p' try_for(20) do begin $vm.focus_window('InfoServ') rescue ExecutionFailedInVM $vm.focus_window('#i2p') end end else account = account.sub(/^irc\./, '') try_for(20) do $vm.focus_window(".*#{Regexp.escape(account)}$") end end end When /^I create my XMPP account$/ do account = xmpp_account("Tails_account") @screen.click("PidginAccountManagerAddButton.png") @screen.wait("PidginAddAccountWindow.png", 20) @screen.click_mid_right_edge("PidginAddAccountProtocolLabel.png") @screen.click("PidginAddAccountProtocolXMPP.png") # We first wait for some field that is shown for XMPP but not the # default (IRC) since we otherwise may decide where we click before # the GUI has updated after switching protocol. @screen.wait("PidginAddAccountXMPPDomain.png", 5) @screen.click_mid_right_edge("PidginAddAccountXMPPUsername.png") @screen.type(account["username"]) @screen.click_mid_right_edge("PidginAddAccountXMPPDomain.png") @screen.type(account["domain"]) @screen.click_mid_right_edge("PidginAddAccountXMPPPassword.png") @screen.type(account["password"]) @screen.click("PidginAddAccountXMPPRememberPassword.png") if account["connect_server"] @screen.click("PidginAddAccountXMPPAdvancedTab.png") @screen.click_mid_right_edge("PidginAddAccountXMPPConnectServer.png") @screen.type(account["connect_server"]) end @screen.click("PidginAddAccountXMPPAddButton.png") end Then /^Pidgin automatically enables my XMPP account$/ do $vm.focus_window('Buddy List') @screen.wait("PidginAvailableStatus.png", 60*3) end Given /^my XMPP friend goes online( and joins the multi-user chat)?$/ do |join_chat| account = xmpp_account("Friend_account", ["otr_key"]) bot_opts = account.select { |k, v| ["connect_server"].include?(k) } if join_chat bot_opts["auto_join"] = [@chat_room_jid] end @friend_name = account["username"] @chatbot = ChatBot.new(account["username"] + "@" + account["domain"], account["password"], account["otr_key"], bot_opts) @chatbot.start add_after_scenario_hook { @chatbot.stop } $vm.focus_window('Buddy List') @screen.wait("PidginFriendOnline.png", 60) end When /^I start a conversation with my friend$/ do $vm.focus_window('Buddy List') # Clicking the middle, bottom of this image should query our # friend, given it's the only subscribed user that's online, which # we assume. r = @screen.find("PidginFriendOnline.png") bottom_left = r.getBottomLeft() x = bottom_left.getX + r.getW/2 y = bottom_left.getY @screen.doubleClick_point(x, y) # Since Pidgin sets the window name to the contact, we have no good # way to identify the conversation window. Let's just look for the # expected menu bar. @screen.wait("PidginConversationWindowMenuBar.png", 10) end And /^I say something to my friend( in the multi-user chat)?$/ do |multi_chat| msg = "ping" + Sikuli::Key.ENTER if multi_chat $vm.focus_window(@chat_room_jid.split("@").first) msg = @friend_name + ": " + msg else $vm.focus_window(@friend_name) end @screen.type(msg) end Then /^I receive a response from my friend( in the multi-user chat)?$/ do |multi_chat| if multi_chat $vm.focus_window(@chat_room_jid.split("@").first) else $vm.focus_window(@friend_name) end @screen.wait("PidginFriendExpectedAnswer.png", 20) end When /^I start an OTR session with my friend$/ do $vm.focus_window(@friend_name) @screen.click("PidginConversationOTRMenu.png") @screen.hide_cursor @screen.click("PidginOTRMenuStartSession.png") end Then /^Pidgin automatically generates an OTR key$/ do @screen.wait("PidginOTRKeyGenPrompt.png", 30) @screen.wait_and_click("PidginOTRKeyGenPromptDoneButton.png", 30) end Then /^an OTR session was successfully started with my friend$/ do $vm.focus_window(@friend_name) @screen.wait("PidginConversationOTRUnverifiedSessionStarted.png", 10) end # The reason the chat must be empty is to guarantee that we don't mix # up messages/events from other users with the ones we expect from the # bot. When /^I join some empty multi-user chat$/ do $vm.focus_window('Buddy List') @screen.click("PidginBuddiesMenu.png") @screen.wait_and_click("PidginBuddiesMenuJoinChat.png", 10) @screen.wait_and_click("PidginJoinChatWindow.png", 10) @screen.click_mid_right_edge("PidginJoinChatRoomLabel.png") account = xmpp_account("Tails_account") if account.has_key?("chat_room") && \ !account["chat_room"].nil? && \ !account["chat_room"].empty? chat_room = account["chat_room"] else chat_room = random_alnum_string(10, 15) end @screen.type(chat_room) # We will need the conference server later, when starting the bot. @screen.click_mid_right_edge("PidginJoinChatServerLabel.png") @screen.type("a", Sikuli::KeyModifier.CTRL) @screen.type("c", Sikuli::KeyModifier.CTRL) conference_server = $vm.execute_successfully("xclip -o", :user => LIVE_USER).stdout.chomp @chat_room_jid = chat_room + "@" + conference_server @screen.click("PidginJoinChatButton.png") # The following will both make sure that the we joined the chat, and # that it is empty. We'll also deal with the *potential* "Create New # Room" prompt that Pidgin shows for some server configurations. images = ["PidginCreateNewRoomPrompt.png", "PidginChat1UserInRoom.png"] image_found, _ = @screen.waitAny(images, 30) if image_found == "PidginCreateNewRoomPrompt.png" @screen.click("PidginCreateNewRoomAcceptDefaultsButton.png") end $vm.focus_window(@chat_room_jid) @screen.wait("PidginChat1UserInRoom.png", 10) end # Since some servers save the scrollback, and sends it when joining, # it's safer to clear it so we do not get false positives from old # messages when looking for a particular response, or similar. When /^I clear the multi-user chat's scrollback$/ do $vm.focus_window(@chat_room_jid) @screen.click("PidginConversationMenu.png") @screen.wait_and_click("PidginConversationMenuClearScrollback.png", 10) end Then /^I can see that my friend joined the multi-user chat$/ do $vm.focus_window(@chat_room_jid) @screen.wait("PidginChat2UsersInRoom.png", 60) end def configured_pidgin_accounts accounts = Hash.new xml = REXML::Document.new($vm.file_content('$HOME/.purple/accounts.xml', LIVE_USER)) xml.elements.each("account/account") do |e| account = e.elements["name"].text account_name, network = account.split("@") protocol = e.elements["protocol"].text port = e.elements["settings/setting[@name='port']"].text nickname = e.elements["settings/setting[@name='username']"].text real_name = e.elements["settings/setting[@name='realname']"].text accounts[network] = { 'name' => account_name, 'network' => network, 'protocol' => protocol, 'port' => port, 'nickname' => nickname, 'real_name' => real_name, } end return accounts end def chan_image (account, channel, image) images = { 'irc.oftc.net' => { '#tails' => { 'roster' => 'PidginTailsChannelEntry', 'conversation_tab' => 'PidginTailsConversationTab', 'welcome' => 'PidginTailsChannelWelcome', } }, 'I2P' => { '#i2p' => { 'roster' => 'PidginI2PChannelEntry', 'conversation_tab' => 'PidginI2PConversationTab', 'welcome' => 'PidginI2PChannelWelcome', } } } return images[account][channel][image] + ".png" end def default_chan (account) chans = { 'irc.oftc.net' => '#tails', 'I2P' => '#i2p', } return chans[account] end def pidgin_otr_keys return $vm.file_content('$HOME/.purple/otr.private_key', LIVE_USER) end Given /^Pidgin has the expected accounts configured with random nicknames$/ do expected = [ ["irc.oftc.net", "prpl-irc", "6697"], ["127.0.0.1", "prpl-irc", "6668"], ] configured_pidgin_accounts.values.each() do |account| assert(account['nickname'] != "XXX_NICK_XXX", "Nickname was no randomised") assert_equal(account['nickname'], account['real_name'], "Nickname and real name are not identical: " + account['nickname'] + " vs. " + account['real_name']) assert_equal(account['name'], account['nickname'], "Account name and nickname are not identical: " + account['name'] + " vs. " + account['nickname']) candidate = [account['network'], account['protocol'], account['port']] assert(expected.include?(candidate), "Unexpected account: #{candidate}") expected.delete(candidate) end assert(expected.empty?, "These Pidgin accounts are not configured: " + "#{expected}") end When /^I start Pidgin through the GNOME menu$/ do step 'I start "Pidgin" via the GNOME "Internet" applications menu' end When /^I open Pidgin's account manager window$/ do @screen.wait_and_click('PidginMenuAccounts.png', 20) @screen.wait_and_click('PidginMenuManageAccounts.png', 20) step "I see Pidgin's account manager window" end When /^I see Pidgin's account manager window$/ do @screen.wait("PidginAccountWindow.png", 40) end When /^I close Pidgin's account manager window$/ do @screen.wait_and_click("PidginAccountManagerCloseButton.png", 10) end When /^I (de)?activate the "([^"]+)" Pidgin account$/ do |deactivate, account| @screen.click("PidginAccount_#{account}.png") @screen.type(Sikuli::Key.LEFT + Sikuli::Key.SPACE) if deactivate @screen.waitVanish('PidginAccountEnabledCheckbox.png', 5) else # wait for the Pidgin to be connecting, otherwise sometimes the step # that closes the account management dialog happens before the account # is actually enabled @screen.waitAny(['PidginConnecting.png', 'PidginAvailableStatus.png'], 5) end end def deactivate_and_activate_pidgin_account(account) debug_log("Deactivating and reactivating Pidgin account #{account}") step "I open Pidgin's account manager window" step "I deactivate the \"#{account}\" Pidgin account" step "I close Pidgin's account manager window" step "I open Pidgin's account manager window" step "I activate the \"#{account}\" Pidgin account" step "I close Pidgin's account manager window" end Then /^Pidgin successfully connects to the "([^"]+)" account$/ do |account| expected_channel_entry = chan_image(account, default_chan(account), 'roster') reconnect_button = 'PidginReconnect.png' recovery_on_failure = Proc.new do if @screen.exists('PidginReconnect.png') @screen.click('PidginReconnect.png') else deactivate_and_activate_pidgin_account(account) end end retrier_method = account == 'I2P' ? method(:retry_i2p) : method(:retry_tor) retrier_method.call(recovery_on_failure) do begin $vm.focus_window('Buddy List') rescue ExecutionFailedInVM # Sometimes focusing the window with xdotool will fail with the # conversation window right on top of it. We'll try to close the # conversation window. At worst, the test will still fail... close_pidgin_conversation_window(account) end on_screen, _ = @screen.waitAny([expected_channel_entry, reconnect_button], 60) unless on_screen == expected_channel_entry raise "Connecting to account #{account} failed." end end end Then /^the "([^"]*)" account only responds to PING and VERSION CTCP requests$/ do |irc_server| ctcp_cmds = [ "CLIENTINFO", "DATE", "ERRMSG", "FINGER", "PING", "SOURCE", "TIME", "USERINFO", "VERSION" ] expected_ctcp_replies = { "PING" => /^\d+$/, "VERSION" => /^Purple IRC$/ } spam_target = configured_pidgin_accounts[irc_server]["nickname"] ctcp_check = CtcpChecker.new(irc_server, 6667, spam_target, ctcp_cmds, expected_ctcp_replies) ctcp_check.verify_ctcp_responses end Then /^I can join the "([^"]+)" channel on "([^"]+)"$/ do |channel, account| @screen.doubleClick( chan_image(account, channel, 'roster')) @screen.hide_cursor focus_pidgin_irc_conversation_window(account) try_for(60) do begin @screen.wait_and_click(chan_image(account, channel, 'conversation_tab'), 5) rescue FindFailed => e # If the channel tab can't be found it could be because there were # multiple connection attempts and the channel tab we want is off the # screen. We'll try closing tabs until the one we want can be found. @screen.type("w", Sikuli::KeyModifier.CTRL) raise e end end @screen.hide_cursor @screen.wait( chan_image(account, channel, 'welcome'), 10) end Then /^I take note of the configured Pidgin accounts$/ do @persistent_pidgin_accounts = configured_pidgin_accounts end Then /^I take note of the OTR key for Pidgin's "([^"]+)" account$/ do |account_name| @persistent_pidgin_otr_keys = pidgin_otr_keys end Then /^Pidgin has the expected persistent accounts configured$/ do current_accounts = configured_pidgin_accounts assert(current_accounts <=> @persistent_pidgin_accounts, "Currently configured Pidgin accounts do not match the persistent ones:\n" + "Current:\n#{current_accounts}\n" + "Persistent:\n#{@persistent_pidgin_accounts}" ) end Then /^Pidgin has the expected persistent OTR keys$/ do assert_equal(pidgin_otr_keys, @persistent_pidgin_otr_keys) end def pidgin_add_certificate_from (cert_file) # Here, we need a certificate that is not already in the NSS database step "I copy \"/usr/share/ca-certificates/spi-inc.org/spi-cacert-2008.crt\" to \"#{cert_file}\" as user \"amnesia\"" $vm.focus_window('Buddy List') @screen.wait_and_click('PidginToolsMenu.png', 10) @screen.wait_and_click('PidginCertificatesMenuItem.png', 10) @screen.wait('PidginCertificateManagerDialog.png', 10) @screen.wait_and_click('PidginCertificateAddButton.png', 10) begin @screen.wait_and_click('GtkFileChooserDesktopButton.png', 10) rescue FindFailed # The first time we're run, the file chooser opens in the Recent # view, so we have to browse a directory before we can use the # "Type file name" button. But on subsequent runs, the file # chooser is already in the Desktop directory, so we don't need to # do anything. Hence, this noop exception handler. end @screen.wait_and_click('GtkFileTypeFileNameButton.png', 10) @screen.type("l", Sikuli::KeyModifier.ALT) # "Location" field @screen.type(cert_file + Sikuli::Key.ENTER) end Then /^I can add a certificate from the "([^"]+)" directory to Pidgin$/ do |cert_dir| pidgin_add_certificate_from("#{cert_dir}/test.crt") wait_and_focus('PidginCertificateAddHostnameDialog.png', 10, 'Certificate Import') @screen.type("XXX test XXX" + Sikuli::Key.ENTER) wait_and_focus('PidginCertificateTestItem.png', 10, 'Certificate Manager') end Then /^I cannot add a certificate from the "([^"]+)" directory to Pidgin$/ do |cert_dir| pidgin_add_certificate_from("#{cert_dir}/test.crt") wait_and_focus('PidginCertificateImportFailed.png', 10, 'Import Error') end When /^I close Pidgin's certificate manager$/ do wait_and_focus('PidginCertificateManagerDialog.png', 10, 'Certificate Manager') @screen.type(Sikuli::Key.ESC) # @screen.wait_and_click('PidginCertificateManagerClose.png', 10) @screen.waitVanish('PidginCertificateManagerDialog.png', 10) end When /^I close Pidgin's certificate import failure dialog$/ do @screen.type(Sikuli::Key.ESC) # @screen.wait_and_click('PidginCertificateManagerClose.png', 10) @screen.waitVanish('PidginCertificateImportFailed.png', 10) end When /^I see the Tails roadmap URL$/ do try_for(60) do begin @screen.find('PidginTailsRoadmapUrl.png') rescue FindFailed => e @screen.type(Sikuli::Key.PAGE_UP) raise e end end end When /^I click on the Tails roadmap URL$/ do @screen.click('PidginTailsRoadmapUrl.png') end