We were lucky to be selected by the development team at Cordelta to help them automate and performance test a high profile public website called MyHospitals. We were able to test millions of hits per hour from domestic and international locations in a wide variety of load scenarios. The success of this approach was underpinned by the following:

1. An open minded project / development team not coupled to a ‘must-have-most-expensive-toolset-to-do-job’ mentality
2. An open minded performance test analyst (me!) who believes Excel really is the grandpa of charting, R is the grandma of stats, Sparklines are the only way to present time series data to management, ANY tool can simulate load via HTTP/S and that there is no real distinction between good software testers or developers (only hard work separates the best from the worst).
3. That 2010 come-no-doubt 2011 buzz word… Cloud

As I sit here pluggin’ our alternative approach at Altentee, I can see the rise of other more successful punters taking on the big kids. I sit and [continue to] chuckle at the reaction to LR pricing and LR zealots who will fall on their swords over LR itself. I have come to realise one thing though, it is not about the tool, or even the alternate tool like perhaps I first thought. It is more about the freedom of choice.

To tackle MyHospitals I was free to choose and implement the following tools:

1. WatirGrid to orchestrate a small flotilla of IE and FireFox based browsers based on Watir
2. JMeter to add more at the protocol level of performance testing
3. httperf to do some basic benchmarking, similar to my front page
4. numbrcrunchr to pull together system metrics and make for easier analysis
5. A variety of Australian cloud providers and of course Amazon EC2 to host the test environment

It has been a great year. I’m not entirely free of the commercial chains just yet and am still needing the LR type work to prop up this approach, but I hope 2011 brings about some fresh thinking in performance and test automation with hopefully me somewhere amidst that space.

Even worse, have you had to write those scripts against a development environment with an unstable code base and shocking performance? Sound familiar? Ever felt the frustration of re-recording manual test cases back into LoadRunner in said environments. Why wouldn’t you just automate the script recording process?

Well if you’re in a LoadRunner shop there’s probably a QTP license floating around. However there’s a great alternative with Ruby, specifically Web Application Testing In Ruby.

The gist is that you setup your manual test case using a watir script, then re-record your LoadRunner scripts using those watir scripts as the driver. The benefits are many:

1. Reduce user input errors when recording the LoadRunner scripts.
2. Have a consistent way of re-recording LoadRunner scripts based on the same input delivered by the watir script.
3. Diffing for correlation becomes easier because of consistency between multiple recordings of the same script.
4. Watir scripts are easier to maintain than LoadRunner scripts.
5. You can incorporate other Ruby gems into your watir scripts to assist with repetitive tasks during recording. For example, I copy transaction names to the clipboard between each step so I can easily paste them into transaction start timers.
6. Watir scripts can double as a smoke test which you can run in parallel with load tests that use only virtual users.
7. Watir scripts (and sampling response time from a real browser) will incorporate other factors such as client render time. Something which vusers really can’t do.

Downside is that you need to do a little more preparation than you might have to if you’re just following a manual test case. Once you have a framework for creating your watir script, this becomes easier. I figure it takes me about 1 hour to script up an end to end transaction that might have around 30 sub transactions (or design steps).

So what do you need to get started?

Firstly to install watir, follow these instructions here.

Come up with a framework for driving your manual test cases. There’s plenty of examples out there on how to make bullet proof frameworks driven from a variety of sources. Alister shares some good tips here.

Here’s a simple framework to get you started.

I have a helpers class that fires up the browser (attaches to the window that LoadRunner spawns) and some common methods for starting/stopping transaction timers and writing out information to a logfile. It looks like this.
helpers.rb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

require 'rubygems'
require 'watir'
require 'logger'
require 'win32/clipboard'
require 'dl'
require 'win32/sound'
include Win32
 
logfile = 'C:\temp\output.log'
@log = Logger.new(logfile, 'daily')
@log.info("\nNew test started at " + Time.now.to_s)
@log.datetime_format = "%H:%M:%S"
 
# if I want each step to start on the minute
# useful when tracing back through profile logs
# on the target server
@staggered = false
 
# pause after each step to prompt you to
# stop a transaction time or start a new one
@pause = false
 
# setup a clipboard object to copy transaction names to
@clipboard ||= Win32::Clipboard
 
# setup my browser object and attach to a running browser
# spawned by the loadrunner recording engine
@b ||=Watir::IE.attach(:title, /FOOBAR/)
 
# alternatively start a new browser
#~ @b ||=Watir::Browser.new
@b.visible = true
@b.speed = :fast
@b.bring_to_front
 
# display a simple message box with a dodgy sound
# to grab your attention
def message_box(txt, title=APP_TITLE, buttons=0)
  5.upto(10) { |i| Sound.beep(i*1000,30) }
  user32 = DL.dlopen('user32')
  msgbox = user32['MessageBoxA', 'ILSSI']
  r, rs = msgbox.call(0, txt, title, buttons)
  return r
end
 
# a start timer method
def timer_start
 
  # figure out how long to sleep if staggered start is true
  now = DateTime.now
  diff = 60 - now.sec
  sleep diff if @staggered
 
  # empty clipboard and copy current transaction name to it
  @clipboard.empty()
  @clipboard.set_data(@t)
 
  # prompt you to start a new transaction if pause is true
  message_box(@t, "Start Transaction", 0) if @pause
 
  @start_time = Time.now
end
 
# end timer method
def timer_end
  @end_time = Time.now
 
  # prompt you to stpo end a transaction if pause is true
  message_box(@t, "End Transaction", 0) if @pause
 
  # figure out elapsed time
  @elapsed_time = (@end_time - @start_time) * 1000
  tab = "\t"
 
  # write it all to you logger
  @log.info(@start_time.to_f.to_s + tab + @end_time.to_f.to_s  + tab \
  + tab + @start_time.to_s + tab + sprintf('%-60s', @t) + tab + sprintf('%10s', @elapsed_time.to_s) )
end
 
# a simple sync method to wait for text on a scren
def sync(text)
  Watir::Waiter.wait_until{ @b.text.include?(text) }
end

Now your manual test case in ruby should look pretty simple. I typically rely on things like the :name, :text or :id attributes of html elements depending on how the application was written by the developers. The manual test case will look something like this.
001_test_case.rb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

require 'helpers.rb'
 
begin
 
  @t = "INIT"
  timer_start
  @b.goto('https://foobar/wps/myportal')
  timer_end
 
  @t = "LOGIN"
  timer_start
  @b.text_field(:name, "username").set("yoohoo")
  @b.text_field(:name, "password").set("foobar")
  @b.button(:index, 1).click
  timer_end
 
  @t = "FOOBAR_03a_03_Tab"
  timer_start
  @b.link(:text, /FOOBAR/).click
  timer_end
 
  @t = "FOOBAR_03a_04_FOOBAR_Tab"
  timer_start
  @b.link(:text, /FOOBAR/).click
  sync("New FOOBAR")
  timer_end
 
  @t = "FOOBAR_03a_27_Record_Notes"
  @b.text_field(:id, "PC_7_C5L40JR2001F002J5MT98S28H6__L_8_0_1_0_14_1_1").set("Justification")
  timer_start
  @b.button(:text, /Save/).click
  timer_end
 
  @t = "FOOBAR_03a_28_Save_And_Foobaz"
  timer_start
  @b.link(:text, /Save & Foobaz/).click
  timer_end
 
  # etc ...
 
rescue Exception => e
  @log.error(@start_time.to_i.to_s + "\t" + sprintf('%-60s', @trans) + "\tError\n" + e)
end

Running this test case will output a log file to C:\temp\output.log that looks like this.

New test started at Thu Oct 08 20:37:48 +1100 2009
1254994670.936  1254994671.576          Thu Oct 08 20:37:50 +1100 2009  INIT                                                                 640.0
1254994671.576  1254994678.233          Thu Oct 08 20:37:51 +1100 2009  LOGIN                                                               6657.0
1254994678.233  1254994694.123          Thu Oct 08 20:37:58 +1100 2009  FOOBAR_03a_03_Tab                                          15890.0
1254994694.123  1254994696.014          Thu Oct 08 20:38:14 +1100 2009  FOOBAR_03a_04_FOOBAR_Tab                                      1891.0
1254994717.171  1254994727.608          Thu Oct 08 20:38:37 +1100 2009  FOOBAR_03a_05_Enter_FOOBAR_Type                              10437.0
1254994729.28   1254994743.499          Thu Oct 08 20:38:49 +1100 2009  FOOBAR_03a_06_Search_for_Primary_Person                      14219.0
1254994748.093  1254994767.265          Thu Oct 08 20:39:08 +1100 2009  FOOBAR_03a_07_Associate_Primary_Person                       19172.0
1254994767.265  1254994780.796          Thu Oct 08 20:39:27 +1100 2009  FOOBAR_03a_08_Enter_Primary_Person_Address_Details           13531.0
1254994780.796  1254994818.765          Thu Oct 08 20:39:40 +1100 2009  FOOBAR_03a_09_Enter_Primary_Person_Doc_Details        37969.0
1254994818.765  1254994835.906          Thu Oct 08 20:40:18 +1100 2009  FOOBAR_03a_16_Add_PoC _Link                                     17141.0
1254994838.828  1254994843.515          Thu Oct 08 20:40:38 +1100 2009  FOOBAR_03a_17_Add_PoC                                            4687.0
1254994852.078  1254994855.469          Thu Oct 08 20:40:52 +1100 2009  FOOBAR_03a_18_Search_Agent                                       3391.0
1254994855.469  1254994859.203          Thu Oct 08 20:40:55 +1100 2009  FOOBAR_03a_19_View_Agent                                         3734.0
1254994863.953  1254994876.203          Thu Oct 08 20:41:03 +1100 2009  FOOBAR_03a_20_Associate_Agent                                   12250.0
1254994876.203  1254994879.484          Thu Oct 08 20:41:16 +1100 2009  FOOBAR_03a_21_Add_Payment_Link                                   3281.0
1254994894.094  1254994894.703          Thu Oct 08 20:41:34 +1100 2009  FOOBAR_03a_22_Record_Payment_Details                              609.0
1254995196.611  1254995196.611          Thu Oct 08 20:46:36 +1100 2009  SAP                                                                    0.0
1254995202.486  1254995258.517          Thu Oct 08 20:46:42 +1100 2009  FOOBAR_03a_25_ Run Validity Assessment                          56031.0
1254995267.736  1254995280.017          Thu Oct 08 20:47:47 +1100 2009  FOOBAR_03a_27_Record_Notes                                      12281.0
1254995280.017  1254995346.579          Thu Oct 08 20:48:00 +1100 2009  FOOBAR_03a_28_Save_And_Foobaz                                    66562.0

Which gives you things like start and stop times, elapsed times and action names to help you debug things further down the track.

All up I think it’s a pretty neat solution for re-re-re-recording LoadRunner scripts (or your tool of choice) you inevitably face in fast changing environments. Whilst writing this post I had a script ticking away in the background recording some 3000+ LoadRunner events. YMMV.

Here’s how you implement search and replace functionality with the same POSIX libraries used in the previous example.

Create a replace function in your favourite headers file or wherever you keep your framework’y stuff… You also need the pcre3.dll and pcreposix.h header added as files to your script.

replace(const char *string, char *pattern, char *replace, char *match)
{
 
   int length;
   int  status;
   int  eflag;
   char buf[1024] = "";
   char out[1024] = "";
 
   regex_t re;
   regmatch_t pmatch[128];
   lr_load_dll("pcre3.dll");
 
   if((status = regcomp(&re, pattern, REG_EXTENDED)) != 0){
      regerror(status, &re, buf, 120);
      lr_output_message("Match PCRE Exit 2");
      return 2;
   }
 
   while(status = regexec( &re, string, 1, pmatch, eflag)== 0){
      strncat(out, string, pmatch[0].rm_so);
      strcat(out, replace);
      string += pmatch[0].rm_eo;
      eflag = REG_NOTBOL;
   }
   strcat(out, string);
   lr_save_string(out, match);
}

Then anywhere in your actions you can call on this function, passing it the string buffer you wish to operate on, a search value, a replace value and the name of the LoadRunner parameter you want the result saved into.

lr_save_string("FOO%20BAR%20DING", "buffer");
replace(lr_eval_string("{buffer}"),"%20"," ", "custom");

What you’ll end up with is something like this:


Home.c(6): Notify: Saving Parameter "buffer = FOO%20BAR%20DING"
Home.c(7): Notify: Parameter Substitution: parameter "buffer" = "FOO%20BAR%20DING"
framework.h(135): Notify: Saving Parameter "custom = FOO BAR DING"


Enjoy.

Error -27492: "HttpSendRequest" failed, Windows error code=12057 (certificate revoked) and retry limit (0) exceeded for URL="
https://someplacesecure.com.au/secure.html", Snapshot Info [MSH 1 2]

This error occurs when using WinInet replay instead of sockets with Integrated Authentication enabled in run-time settings. The purpose of this was to allow vusers to use SSO with SPNEGO authentication in an IBM WebSEAL environment.

After spending some time with the mystical HP level 3 support, they identified an undocumented flag which helps out significantly in this. So, instead of using the WinInet replay engine (which is not encouraged by HP) you should do something similar to the following.

vuser_init()
{
 
	// Preferred run-time settings
	// Browser -> Browser Emulation
       // [ ] Simulate a new user on each iteration
       // Preferences -> Options
       // Enable Integration Authentication [Yes]
 
	web_set_sockets_option("INITIAL_BASIC_AUTH","1");
 
	web_set_user("DOMAIN.LOCAL\\username",
		"password",
		"someplacesecure.com.au:443");
 
	web_url("myportal",
		"URL=https://someplacesecure.com.au/wps",
		"Resource=0",
		"Referer=",
		"Mode=HTML",
		LAST);
 
	return 0;
}

The magic is in the web_set_sockets_option("INITIAL_BASIC_AUTH","1") flag. Set that and you can then use LoadRunner in Sockets mode which as it turns out, is much more stable.

Enjoy.

If that script references a data file (for parameters) then that data file is shared by *all* vuser groups.
e.g. my parameter called {values} has

When running, vuser group_b will error with these settings e.g.

i.e.

So 2 separate vuser groups still equals one shared parameter file (and settings).
Watch out for this!

There should be no doubt that purchasing LoadRunner licenses is expensive. How Mercury/HP has achieved this stranglehold on the market is strange to behold but it is the way it is.

Needless to say, in another purchasing license cycle I jokingly said to a colleague that it would probably be cheaper to fly to India, hire some office space and PCs, give some training to 100 production workers and pay them 3 months wage to facilitate your whole test effort using real people and PCs. You’d still probably come out ahead of a typical yearly budget for HP products… Or would you?

Estimates in AUD…
Average Indian production worker yearly salary, $2,192
Office space in Pune per month, $753
Return business class flights for me and a business partner/trainer, $12,000
Rental PC/laptop fleet per month, $10,000

Average cost of test effort over 3 months would be $105,000

I think you might come out with some change from that…

I didn’t have WebSEAL (which is what I was ultimately trying to simulate) but I believe this is reasonably close, to quote:

Integrated Windows authentication uses Kerberos v5 authentication and NTLM authentication. Kerberos is an industry-standard authentication protocol that is used to verify user or host identity. If Active Directory is installed on a domain controller running Windows 2000 Server or Windows Server 2003, and the client browser supports the Kerberos v5 authentication protocol, Kerberos v5 authentication is used; otherwise, NTLM authentication is used.

So to log on to my test page I needed to provide domain credentials in IE. I also made sure my client IE enforces IWA as per the following:

If I don’t provide my domain credentials (in this case: smallbusiness\fred) then I get knocked back with a 401 as expected.

On generation of my LR script the first response is a 401.2. It then does a second request with the authorization header i.e.
Authorization: Negotiate TlRMTVNTUAABAAAAB4IIogAAAAAAAAAAAAAAAAAAAAAFAs4OAAAADw==

The response header to this tells me to authenticate i.e.
WWW-Authenticate: Negotiate TlRMTVNTUAACAAAAGgAaADgAAAAFgomir1xcxf5zo2MAAAAAAAAAAOIA4gBSAAAABQLODgAAAA9TAE0AQQBMAEwAQgBVAFMASQBOAEUAUwBTAAIAGgBTAE0AQQBMAEwAQgBVAFMASQBOAEUAUwBTAAEAHgBLAE8ATwBQAFMALQA5ADYAWABZADIAVwBEAFUANgAEACYAcwBtAGEAbABsAGIAdQBzAGkAbgBlAHMAcwAuAGwAbwBjAGEAbAADAEYAawBvAG8AcABzAC0AOQA2AHgAeQAyAHcAZAB1ADYALgBzAG0AYQBsAGwAYgB1AHMAaQBuAGUAcwBzAC4AbABvAGMAYQBsAAUAJgBzAG0AYQBsAGwAYgB1AHMAaQBuAGUAcwBzAC4AbABvAGMAYQBsAAAAAAA=

The next request authorizes presumably with the correct token i.e.
Authorization: Negotiate TlRMTVNTUAADAAAAGAAYAIgAAAAYABgAoAAAABoAGgBIAAAACAAIAGIAAAAeAB4AagAAAAAAAAC4AAAABYKIogUCzg4AAAAPcwBtAGEAbABsAGIAdQBzAGkAbgBlAHMAcwBmAHIAZQBkAEsATwBPAFAAUwAtADkANgBYAFkAMgBXAEQAVQA2AB15bTxE3i63AAAAAAAAAAAAAAAAAAAAALQ6IC82wYIBXpniDchRG9zSW8/bC4891w==

From which the response is gravy, and my homepage loads.
So the recording process looks like it went through the necessary authentication steps.

Now in my LR script Action() I can set the domain credentials dynamically with web_set_user (hence emulate multiple users) i.e.
web_set_user("smallbusiness\\fred","********", "smallbusiness.local:80");

Then follow with a web_url request to the server i.e.

	web_url("smallbusiness.local",
		"URL=http://smallbusiness.local/",
		"Resource=0",
		"RecContentType=text/html",
		"Referer=",
		"Snapshot=t1.inf",
		"Mode=HTML",
		LAST);

Play that back and it fails. (Assuming WebSEAL will reject NTLM which in this case my test rig won’t, but I can make that assumption…)

Now change a couple of runtime settings:
Internet Protocol->Preferences->Options->Authentication->Enable Integrated Authentication

This makes sure that when the server asks for authentication via the first 401.2/1, that SPNEGO/Negotiate/Kerberos is tried *first* before any other protocol (like NTLM)

You also need to change:
Internet Protocol->Preferences->Advanced->WinInet [checked]:

This instructs VuGen to use the WinInet replay engine instead of the standard Sockets replay. VuGen has two HTTP replay engines: Sockets-based (default) or WinInet based. The WinInet is the engine used by Internet Explorer and it supports all of the features incorporated into the IE browser. I think this *better* emulates the IE client settings for IWA …

And re-run the script. I now get past the authentication using Kerberos and successfully load my home page… This can be repeated for WebSEAL provided you first do a web_set_user (so it knows what domain credentials to use) which effectively lets you run the test with multiple users… Great for testing those WebSEAL/SPNEGO/Kerberos single sign on solutions…

You will need to get the following jars from your Websphere MQ installation:
1. com.ibm.mq.jar
2. connector.jar
3. jta.jar

Make sure you include them in your run-time settings (F4) for your script:

PUT example

/*
 * LoadRunner Java script. (Build: 946)
 *
 * Script Description: simple test harness to PUT messages on a MQ queue
 * Author: Tim.Koopmans@90kts.com
 */
 
import lrapi.lr;
import java.io.*;
import java.util.*;
import com.ibm.mq.*;
 
public class Actions
{
 
    private MQQueueManager myQueueManager;
    private MQPutMessageOptions myPutMsgOptions;
    private MQQueue myQueue;
 
    public int init() throws Throwable {
	try {
	    MQEnvironment.hostname = "192.168.145.131";
	    MQEnvironment.properties.put(MQC.TRANSPORT_PROPERTY,MQC.TRANSPORT_MQSERIES_CLIENT);
	    MQEnvironment.channel = "S_koops_5a7610a22";
	    MQEnvironment.port = 1414;
	    MQEnvironment.CCSID = 437;
 
	    myQueueManager = new MQQueueManager("QM_koops_5a7610a22");
	    int openOptions = MQC.MQOO_OUTPUT
			    | MQC.MQOO_INQUIRE
			    | MQC.MQOO_FAIL_IF_QUIESCING;
 
	    myQueue = myQueueManager.accessQueue("default", openOptions, null, null, null);
 
	    myPutMsgOptions = new MQPutMessageOptions();
	    myPutMsgOptions.options = MQC.MQPMO_NONE;
	} catch (Exception e) {
	    System.out.println(e);
	}
	return 0;
    }//end of init
 
    public int action() throws Throwable {
	try {
	    MQMessage myPutMessage = new MQMessage();
	    myPutMessage.clearMessage();
	    myPutMessage.persistence = MQC.MQPER_PERSISTENT;
	    //myPutMessage.persistence = MQC.MQPER_NOT_PERSISTENT;
	    myPutMessage.correlationId 	= MQC.MQCI_NONE;
	    myPutMessage.messageId 	= MQC.MQMI_NONE;
	    myPutMessage.writeString("<xml><data>foobar</data></xml>");
	    myQueue.put(myPutMessage, myPutMsgOptions);
	} catch (MQException e) {
	    System.out.println(e);
	}
	return 0;
    }//end of action
 
    public int end() throws Throwable {
	try {
	     myQueue.close();
	     myQueueManager.disconnect();
	} catch (Exception e ) {
	    System.out.println(e);
	}
	return 0;
    }//end of end
}

GET example
I’ve included a private method which decodes the hex string (for the msgID) into ascii. You can also get creative here. In previous test efforts I’ve embedded a date time string in the user data of the request message, then extracted and got the difference from the MQMD header on the reply queue. In other words, elapsed time between request and response. I’m keeping it simple for the example though …

/*
 * LoadRunner Java script. (Build: 946)
 *
 * Script Description: simple test harness to GET messages on a MQ queue
 * Author: Tim.Koopmans@90kts.com
 */
 
import lrapi.lr;
import java.io.*;
import java.util.*;
import com.ibm.mq.*;
 
public class Actions
{
 
    private MQQueueManager myQueueManager;
    private MQPutMessageOptions myPutMsgOptions;
    private MQQueue myQueue;
 
    public int init() throws Throwable {
	try {
	    MQEnvironment.hostname = "192.168.145.131";
	    MQEnvironment.properties.put(MQC.TRANSPORT_PROPERTY,MQC.TRANSPORT_MQSERIES_CLIENT);
	    MQEnvironment.channel = "S_koops_5a7610a22";
	    MQEnvironment.port = 1414;
	    MQEnvironment.CCSID = 437;
 
	    myQueueManager = new MQQueueManager("QM_koops_5a7610a22");
	    int openOptions = MQC.MQOO_INPUT_SHARED
                            | MQC.MQOO_INQUIRE
                            | MQC.MQOO_FAIL_IF_QUIESCING;
 
	    myQueue = myQueueManager.accessQueue("default", openOptions);
	} catch (Exception e) {
	    System.out.println(e);
	}
	return 0;
    }//end of init
 
 
    public int action() throws Throwable {
	try {
	    MQMessage myGetMessage = new MQMessage();
            myQueue.get(myGetMessage);
            System.out.println("MSG ID: \t"+dumpHexId(myGetMessage.messageId));
            System.out.println("CORREL ID: \t"+dumpHexId(myGetMessage.correlationId));
            System.out.println("MSG LENGTH:\t"+myGetMessage.getMessageLength()+" bytes");
            System.out.println("MSG CONTENT: "+myGetMessage.readLine());
 
	} catch (MQException e) {
	    System.out.println(e);
	}
	return 0;
    }//end of action
 
    public int end() throws Throwable {
	try {
	     myQueue.close();
	     myQueueManager.disconnect();
	} catch (Exception e ) {
	    System.out.println(e);
	}
	return 0;
    }//end of end
 
    private static String dumpHexId(byte[] myId) {
	String hexAscii = "";
	for (int i=0; i < myId.length;i++) {
	    char b = (char)(myId[i] & 0xFF);
	    if (b < 0x10) {
		hexAscii = hexAscii + "0";
	    }
	    hexAscii = hexAscii + (String)(Integer.toHexString(b)).toUpperCase();
	}
	return hexAscii;
    }//end of dumpHexId
}

So a quick hack to do it in C is as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

random_alpha(char* param_name, int length) {
  char buff[32] = "";
  int r,i;
  char c;
  srand((unsigned int)time(0)); //Seed number for rand()
  for (i = 0; i < length; i++) {
	// A-Z = 65-90 = rand() % 25 + 65
    r = rand() % 25 + 65;
    c = (char)r;
		buff[i] = c;
    printf("%c", c);
  }
  lr_save_string(buff, param_name);
  return 0;
}

I keep that as part of my functions library (referenced in globals.h) and can call on it in a script using the following syntax.
random_alpha(char* param_name, int length)

Example:
random_alpha("advertiser_name_suffix", 4);

Returns:
Notify: Saving Parameter "advertiser_name_suffix = SDNG"

A work colleague found a knowledge base reference that recommended using an RTE Vuser for secure FTP recording and replay. Document ID 41820 refers. I don’t know, but that seemed like a kludge to me, and I wasn’t keen on a multi-protocol harness, so we went searching on Google for a Java alternative.

A common recommendation in Java forums pointed towards using JSch, or Java Secure Channel. To quote:

JSch is a pure Java implementation of SSH2.
JSch allows you to connect to an sshd server and use port forwarding, X11 forwarding, file transfer, etc., and you can integrate its functionality into your own Java programs. JSch is licensed under a BSD style license.

So, no clunky RTE scripting and no additional $$$ required. On with the solution …

You will need the latest jar, we used jsch-0.1.37.jar which is available here. Copy that to your LoadRunner /classes subdirectory.

Create a new Java Vuser script and modify its run-time settings (F4). You need to modify the classpath settings and include your jsch jar file.

Import the relevant package into your script.

1

import com.jcraft.jsch.*;

Then add the relevant code to your action method. Following is an example of how to do a get from an sftp server. As we progress I’ll add more examples for other functions you might use. You can also check out the many examples provided here.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

    public int action()  {
	JSch jsch=new JSch();
	String host="myremotehost";
	String user="myuser";
	String pwd="mypwd";
        int port=22;
	try {
	    Session session=jsch.getSession(user, host, port);
            session.setPassword( pwd );
	    java.util.Properties config=new java.util.Properties();
	    // Don't bother checking for unknown host keys: UnknownHostKey
	    config.put("StrictHostKeyChecking", "no");
	    session.setConfig(config);
	    session.connect();
 
	    // SFTP get
            Channel channel=session.openChannel("sftp");
	    channel.setXForwarding(true);
	    //Connect to the site.
	    channel.connect();
 
	    ChannelSftp c=(ChannelSftp)channel;
	    c.cd("/tmp");
	    c.lcd("D:/");
            int mode=ChannelSftp.OVERWRITE;
	    c.get("test.txt", "get_test.txt", null, mode);
	    c.put("get_test.txt", "put_test.txt", null, mode);
	} catch (Exception e){
	    System.out.println(e);
	}
 
	System.exit(0);
 
	return 0;
 
    } //end of action