Each Web session is identified by a unique identifier, i.e. SessionID. By default, SessionID value is stored in a cookie. However, the application can be configured to store SessionID value in the URL for a "cookieless" session, i.e. you will have the following configured in your Web site’s app.config file.

<system.web>
  <sessionState cookieless="true" />
</system.web>

When the SessionID is passed in the URL, VSTS does not automatically promote the correlation after Web test recording or in a correlation run. This following post will describe the details on how to extract the SessionID and correlate the recorded Web test requests by implementing a Web test recorder plug-in.

The following screenshots show the differences in the Web tests before and after enabling the SessionID recorder plug-in.

Before enabling the SessionID recorder plug-in	After enabling the SessionID recorder plug-in

Step 1 – Create a C# class library

Step 2 – Add a reference to Microsoft.VisualStudio.QualityTools.WebTestFramework.

Step 3 - Write an extraction rule to extract the SessionID from a url.

[ExtractionRule.cs]

using System;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.WebTesting;
using System.Globalization;
using System.Text.RegularExpressions;
using System.ComponentModel;

namespace SampleRecorderPlugin
{
    //---------------------------------------------------------------------------------
    // This class creates a custom extraction rule named "Extract Session ID from Path"
    //---------------------------------------------------------------------------------
    public class ExtractSessionIDFromPath : ExtractionRule
    {
        /// Specify a name for use in the user interface.
        /// The user sees this name in the Add Extraction dialog box.
        //---------------------------------------------------------------------
        public override string RuleName
        {
            get { return "ExtractSessionIDFromPath"; }
        }

        /// Specify a description for use in the user interface.
        /// The user sees this description in the Add Extraction dialog box.
        //---------------------------------------------------------------------
        public override string RuleDescription
        {
            get { return "Extract Session ID from Path"; }
        }

        internal enum SearchResult
        {
            Found,
            StartsWithNotFound,
            EndsWithNotFound,
        }

        public string StartsWith
        {
            get { return m_startsWith; }
            set { m_startsWith = value; }
        }

        public string EndsWith
        {
            get { return m_endsWith; }
            set { m_endsWith = value; }
        }

        [DefaultValue(false)]
        public bool IgnoreCase
        {
            get { return m_ignoreCase; }
            set { m_ignoreCase = value; }
        }

        [DefaultValue(true)]
        public bool IsRequired
        {
            get { return m_required; }
            set { m_required = value; }
        }

        internal void Initialize()
        {
            string startsWith = StartsWith;
            string endsWith = EndsWith;
            startsWith = Regex.Escape(StartsWith);
            endsWith = Regex.Escape(EndsWith);

            RegexOptions options = RegexOptions.Singleline;
            if (IgnoreCase)
            {
                options |= RegexOptions.IgnoreCase;
            }

            m_startsWithRegEx = new Regex(startsWith, options);
            m_endsWithRegEx = new Regex(endsWith, options);

            m_result = null;
        }

        // Finds the match
        internal SearchResult FindMatch(string url)
        {
            Match startMatch;
            Match endMatch;
            int startIndex = 0;
            int endIndex = 0;

            if (!string.IsNullOrEmpty(StartsWith))
            {
                // Find the start
                startMatch = m_startsWithRegEx.Match(url, 0);
                if (!startMatch.Success)
                {
                    return SearchResult.StartsWithNotFound;
                }
                startIndex = startMatch.Index;
            }

            if (!string.IsNullOrEmpty(EndsWith))
            {
                // Find the end
                endMatch = m_endsWithRegEx.Match(url, startIndex);
                if (!endMatch.Success)
                {
                    return SearchResult.EndsWithNotFound;
                }
                endIndex = endMatch.Index + EndsWith.Length;
            }

            m_result = url.Substring(startIndex, endIndex - startIndex);
            return SearchResult.Found;
        }


        // Searches for the SessionID in the path.
        public override void Extract(object sender, ExtractionEventArgs e)
        {
            // Finds the match
            Initialize();
            SearchResult result = FindMatch(e.Request.Url);
            e.Success = !m_required || result == SearchResult.Found; ;

            if (result == SearchResult.Found)
            {
                e.WebTest.Context[this.ContextParameterName] = Result;
            }
            else
            {
                if (result == SearchResult.StartsWithNotFound)
                {
                    e.Message = String.Format(CultureInfo.CurrentCulture, "StartsWith not found");
                }
                else
                {
                    e.Message = String.Format(CultureInfo.CurrentCulture, "EndsWith not found");
                }
            }
        }

        // Called in the Recorder Plug-in to retrieve the sessionID string
        public string ExtractSessionID(string url)
        {
            Initialize();
            FindMatch(url);
            return Result;
        }
        // ************************************************************************
        // ************************************************************************

        internal string Result
        {
            get { return m_result; }
            set { m_result = value; }
        }

        // ****************************************************************************
        // Private Members
        // ****************************************************************************

        // Properties for saving the tag and attribute information
        private string m_startsWith;
        private string m_endsWith;
        private Regex m_startsWithRegEx;
        private Regex m_endsWithRegEx;

        private bool m_required = true;
        private bool m_ignoreCase = true;
        private string m_result;
    }
}

If you want to modify the extraction rule for your testing, the generic information to write a custom extraction rule can be found in this MSDN page.

Step 4 – Write a Web test recorder plug-in

This plug-in will extract the SessionID from a request url or the redirected page, add an extraction rule created in Step 2 to the request, save the SessionID in a Web test context parameter called “SessionID”, and correlate the SessionID in the recorded Web test requests.

[RecorderPlugin.cs]

using System;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.WebTesting;
using System.Globalization;
using System.Text.RegularExpressions;
using System.ComponentModel;
using System.Diagnostics;

namespace SampleRecorderPlugin
{
    [DisplayName("WebTestRecorderPluginSessionIdInPath")]
    [Description("Adds a recorder plug-in that retrieves session ID from url")]
    public class RecorderPluginThatExtractsSessionIDInPath : WebTestRecorderPlugin
    {
        public override void PostWebTestRecording(object sender, PostWebTestRecordingEventArgs e)
        {
            ExtractSessionIDFromPath extractionRule = new ExtractSessionIDFromPath();
            extractionRule.StartsWith = "/(S(";
            extractionRule.EndsWith = "))/";
            extractionRule.IgnoreCase = true;

            string sessionID = null;
            bool foundSessionID = false;

            WebTestResultIteration recordedIteration = e.RecordedWebTestResult;
            foreach (WebTestResultUnit resultUnit in recordedIteration.Children)
            {
                WebTestResultPage pageResult = resultUnit as WebTestResultPage;
                if (pageResult != null)
                {
                    WebTestRequestResult finalRequestResult = pageResult.RequestResult;                  
                    string url = pageResult.RequestResult.Request.Url;
                    // If there were redirects then need to get the last redirected requests
                    if (pageResult.RedirectedPages.Count > 0)
                    {
                        finalRequestResult = pageResult.RedirectedPages[pageResult.RedirectedPages.Count - 1].RequestResult;
                        url = finalRequestResult.Request.Url;
                    }

                    // Check if there is an session ID in the url path
                    sessionID = extractionRule.ExtractSessionID(url);
                    if (string.IsNullOrEmpty(sessionID))
                    {
                        continue;
                    }

                    // Get the corresponding request in the Declarative Web test
                    WebTestRequest requestInWebTest =
                            e.RecordedWebTest.GetItem(pageResult.DeclarativeWebTestItemId) as WebTestRequest;

                    // Add an custom extraction rule to the current request
                    if (requestInWebTest != null)
                    {
                        ExtractionRuleReference extractionRuleReference = new ExtractionRuleReference();
                        extractionRuleReference.Type = typeof(ExtractSessionIDFromPath);
                        extractionRuleReference.Properties.Add(new PluginOrRuleProperty("StartsWith", @"/(S("));
                        extractionRuleReference.Properties.Add(new PluginOrRuleProperty("EndsWith", @"))/"));
                        extractionRuleReference.Properties.Add(new PluginOrRuleProperty("IgnoreCase", "false"));
                        extractionRuleReference.Properties.Add(new PluginOrRuleProperty("IsRequired", "true"));
                        extractionRuleReference.ContextParameterName = "SessionID";
                        requestInWebTest.ExtractionRuleReferences.Add(extractionRuleReference);
                        e.RecordedWebTestModified = true;
                    }

                    foundSessionID = true;
                    break;
                }
            }

            // replace the session ID with the context parameter
            if (foundSessionID && !string.IsNullOrEmpty(sessionID))
            {
                for (int i = 0; i < e.RecordedWebTest.Items.Count; i++)
                {
                    //get the item and see if it is a comment
                    WebTestItem item = e.RecordedWebTest.Items[i];
                    
                    if (item is WebTestRequest)
                    {
                        ((WebTestRequest)item).Url = ((WebTestRequest)item).Url.Replace(sessionID, "{{SessionID}}");
                    }
                }
            }
        }
    }
}

Step 5 – Drop the dll to %Program Files%\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies\WebTestPlugins

In order to use the extraction rule created in Step 2, you will need to restart Visual Studio and add a reference to the class library to your test project. When you record a new Web test from Visual Studio, a dialog will be popped up and let you enable the RecorderPluginThatExtractsSessionIDInPath. Once the plug-in is enabled, the requests will be automatically correlated.

There is one more step. Since the request url is built dynamically during your run, the last step is to remove the default validation rule in the recorded Web test. Otherwise, the requests will fail due to validation errors. To do this, click on the “Response Time Goal” under Validation Rules, and press the Delete key.

One of the questions some forum users asked is ‘Did Load Test insert item records into my table?’ To find out this, I add a load test containing a Web test that purchases orders from a online store (Web application) to my test project. I create a SimpleRowCountDataCollector to collect the counts of the Order table before and after the Load test run. Then I enable the data collector in a .testsettings file, run the Web test in a Load test, and check the row counts after the run completes.

Since this sample data collector can be downloaded from https://teamtestplugins.codeplex.com/, I will only outline the steps in this post. If you would like more detailed instructions, read this page.

Step 1 – Create a Data Collector

1. Create a new class library

2. Add references to the following dlls

Microsoft.VisualStudio.QualityTools.ExecutionCommon

Microsoft.VisualStudio.QualityTools.Common.dll

3. Add RowCountDataCollector.cs

Specify the URI and a friendly name for the collector

    [DataCollectorTypeUri("datacollector://MyCompany/SimpleRowCountDataCollector/1.0")]
    [DataCollectorFriendlyName("RowCountDataCollector", false)]
    [DataCollectorConfigurationEditor("configurationeditor://Microsoft/GenericEditor/1.0")]
    public class SimpleRowCountDataCollector : DataCollector

Below are the brief descriptions of the major functions.

3.1 Initialize() function

This function does three thing

- Init data members

- Retrieve the collector configuration from the test settings file

- Register the TestCaseStart and TestCaseEnd events

       // Required method called by the testing framework
        public override void Initialize(
            XmlElement configurationElement, 
            DataCollectionEvents events, 
            DataCollectionSink sink, 
            DataCollectionLogger logger, 
            DataCollectionEnvironmentContext environmentContext)
        {
            // 1. Init members 
            dataEvents = events; // The test events
            dataLogger = logger; // The error and warning log
            dataSink = sink;     // Saves collected data
            
            // Configuration from the test settings
            configurationSettings = configurationElement;

            // 2. Read collector configurations from the test settings
            CollectorConfigurationManager configManager = new CollectorConfigurationManager(configurationSettings);
            server = configManager["server"];
            if (string.IsNullOrEmpty(server))
            {
                server = Environment.MachineName;
            }

            database = configManager["database"];
            table = configManager["table"]; 

            // 3. Register TestCaseStart and TestCaseEnd events for the data collector
            dataEvents.TestCaseStart +=
                new EventHandler<TestCaseStartEventArgs>(OnTestCaseStart);

            dataEvents.TestCaseEnd +=
                new EventHandler<TestCaseEndEventArgs>(OnTestCaseEnd);
        }

3.2 OnTestCaseStart Event Handler

This function get the order count from the Order table right before the load test is started. As I mentioned in the previous post, you can log warning or error messages in the code. The message will show up in the Load Test Errors Table.

        public void OnTestCaseStart(object sender, TestCaseEventArgs e)
        {
            // dataLogger.LogWarning(e.Context, "OnTestCaseStart. Time:" + DateTime.Now.ToString());
            rowCountBeforeTestRun = SQLHelper.GetRowCount(server, database, table);
        }

3.3 OnTestCaseEnd Event Handler

This function get the order count from the Order table after the load test is completed, write the tabular data in XML format, and send the file back to client (VS).

       // Write the counts to a table in XML format
        public void OnTestCaseEnd(object sender, TestCaseEndEventArgs e)
        {
            // Get the row count after run ends
            rowCountAfterTestRun = SQLHelper.GetRowCount(server, database, table);

            // create the table to be integrated into load test database
            string filePath = Path.Combine(Path.GetTempPath(), "rowCounts.xml");
            RowCountXMLWriter.CreateDataTable();
            RowCountXMLWriter.AddDataRow("BeforeTestStart", rowCountBeforeTestRun);
            RowCountXMLWriter.AddDataRow("AfterTestEnd", rowCountAfterTestRun);
            RowCountXMLWriter.WriteRowCountsToXmlFile(filePath);

            // Send the file back
            dataSink.SendFileAsync(e.Context, filePath, false);
        }

One important thing to keep in mind is that only files sent back in OnTestCaseStart and OnTestCaseEnd events can be added to Load Test Tables view in post run.

4. Add RowCountXMLWriter.cs file

This class creates a DataTable, add rows to the table, and write out the data in XML format

        static DataTable m_dataTable;

        public static void CreateDataTable()
        {
            m_dataTable = new DataTable();

            m_dataTable.Locale = CultureInfo.InvariantCulture;
            m_dataTable.Columns.Add(new DataColumn("Description", typeof(string)));
            m_dataTable.Columns.Add(new DataColumn("RowCount", typeof(Int32)));
        }

        public static void AddDataRow(string description, int rowCount)
        {
            DataRow row = m_dataTable.NewRow();
            row["Description"] = description;
            row["RowCount"] = rowCount;
            m_dataTable.Rows.Add(row);
        }

        public static void WriteRowCountsToXmlFile(string xmlFilePath)
        {
            DataSet dataSet = new DataSet();
            dataSet.Locale = CultureInfo.InvariantCulture;
            dataSet.Tables.Add(m_dataTable);

            using (System.IO.StreamWriter xmlStreamWriter = new System.IO.StreamWriter(xmlFilePath))
            {
                dataSet.WriteXml(xmlStreamWriter, XmlWriteMode.WriteSchema);
                xmlStreamWriter.Close();
            }

            dataSet.Dispose();
        }

5. Add ConfigurationManager.cs

This class reads the data collector settings into a dictionary. Please note, it is written for the format described in Step 6, section <DefaultConfiguration>.

6. Add an App.config file

Note this data collector is configured to use a Generic XML editor. If you want to create your own UI editor, read this MSDN page.

[DataCollectorConfigurationEditor("configurationeditor://Microsoft/GenericEditor/1.0")]
public class SimpleRowCountDataCollector : DataCollector

[App.config]

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSection>
    <section
      name="DataCollectorConfiguration"
      type="Microsoft.VisualStudio.QualityTools.Execution.DataCollectorConfigurationSection,
        Microsoft.visualStudio.QualityTools.ExecutionCommon,
        Version=4.0.0.0, Culture=neutral,
        PublicKeyToken=b03f5f7f11d50a3a" />
  </configSection>
  <DataCollectorConfiguration xmlns="https://microsoft.com/schemas/VisualStudio/TeamTest/2010">
  <DataCollector typeUri="datacollector://MyCompany/SimpleRowCountDataCollector/1.0">
    <DefaultConfiguration>
        <Setting name="server" value="YourWebServer" />
        <Setting name="database" value="Store" />
        <Setting name="table" value="Order" />
  </DefaultConfiguration>
  </DataCollector>
  </DataCollectorConfiguration>
</configuration>

This data collector config file allows you to specify three settings, Web server, database, and table name.

Step 2 – Install the Data Collector

You need to drop a copy of the data collector on every machine you want to collect data.

Setup Requirement: You must install Agent on these machines.

Files to drop: RowCountDataCollector.dll, RowCountDataCollector.dll.config

Drop location: %Program Files%\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies\DataCollectors

An example of the setup

Machine1: VS2010 Ultimate, Controller, Agent

Machine2: Web Server, Agent, RowCountDataCollector.

For you to try out the sample collector, you can drop it on your local machine, configure it to point to a table in your local load test database (step 3), and then run the test(step 4).

Step 3 – Configure the Data Collector

Open the Testsetting file used by your load test run. Click on Data and Diagnostics. Enable the RowCountDataCollector.

Click on Configure, it will launch the default editor for you to modify the settings.

Step 4 – Run your load test and view the data

Run your load test view the before/after order counts in post run table.

Given a very simple example here, I collected the row count of my Order table in the Web server’s database before and after a load test run. As shown in the following screenshot, the counts were displayed in a table in post run.

To implement this, only three major steps are involved.

Step 1 – Create a data collector.

Step 2 – Install the data collector.

Step 3 – Enable/configure the custom data collector in the test project.

I will go through the steps to create a sample data collector in a separate post. In this post, I will highlight the points closely related to Load test that you should know before getting started.

1. Supported Data Format – Tabular data in XML

In order to integrate your report into Load Test Analyzer, the data collector needs to write the report data to a table in XML format.

2. Supported data types in the XML table.

Bit

Byte[]

Int16, Int32, Int64

double, float

String

DateTime

3. Data collector basics

3.1 Data Collector Events

Your data collector can register events in the following table to write log messages and send files back to the client (VS).

Event	Description	Notes
SessionStart	Start of your test run	You test run may contain several test types, e.g. one Load test and five Unit test. This event will be fired once for the entire run.
SessionEnd	End of your test run
TestCaseStart	Start of each test in the test run	If you test run contains only one Load Test, this event will be fired once when the Load test is started.
TestCaseEnd	End of each test in the test run	If you test run contains only one Load Test, this event will be fired once when the Load test is complete.

Remember, ONLY log/data files sent back through the TestCaseStart and TestCaseEnd events can be integrated into the Load Test database.

Log/data files sent back through the SessionStart and SessionEnd events are listed in the Run Results Summary window. Under section Collected Files.

3.2 Data Collector Events Logs

You can log warning/error messages in the following events

Event	Description
SessionStart	Log messages will be displayed in the Results Summary window
SessionEnd	Log messages will be displayed in the Results Summary window
TestCaseStart	Log messages will be displayed in the Errors table in Load Test Analyzer

3.3 Data Collector configuration

If any configuration is required for the collector, you need to create an App.config file.

Data collector can be enabled through the Test Settings dialog as shown in the below screenshot.

Data collector can be configured if you click on the Configure button. Here you have two choices, you can create a custom UI editor, or you can use a generic XML editor and just do text editing. The later will be covered in Create a Simple Data Collector to Integrate Data into Load Test Analyzer.

As I mentioned in the beginning, what I listed above is just a high-level summary for you to get started. After going through these briefly, you can try the sample collector in my post and start to write your own. For more information on Custom Data Collectors, please read this MSDN page for details.

Step 1 – Create CustomLoadProfiles library

You can copy the code in this post and build the class library. [The sample code can be downloaded from codeplex.]

Step 2 – Add a reference to class library CustomLoadProfiles in the test project

Step 3 – Add the PeakLoadModelingPlugin to the test project

[PeakLoadModelingPlugin.cs] [The sample code can be downloaded from codeplex.]

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using Microsoft.VisualStudio.TestTools.LoadTesting;
using CustomLoadProfiles;

namespace TestProject1
{
    [Description("This plug-in simulates the Peak user load Pattern every 3 minutes")]
    public class PeakLoadModelingPlugin : ILoadTestPlugin
    {     
        public void Initialize(LoadTest loadTest)
        {
            m_loadTest = loadTest;
            m_profileManager = new LoadProfileManager();

            // The heartbeat event will be fired every second, it can be used to adjust the user load
            m_loadTest.Heartbeat += new EventHandler<HeartbeatEventArgs>(m_loadTest_Heartbeat);

            // Create the custom load pattern based on the configurations passed through the plug-in properties
            CreateLoadProfileGroups();
        }

        // Create a custom user load profile group: Valley-StepUp-Peak-StepDown
        void CreateLoadProfileGroups()
        {           
            // Create the custom load pattern group
            // Calculate the duration
            // If the RepeatCount for the Peak Load pattern is not specified, check the PercentageOfDuration, and calculate
            int patternDuration = 0;
            if (RepeatCount == 0)
            {
                double patternDurationInDouble = m_loadTest.RunSettings.RunDuration * PercentageOfDuration / 100;
                patternDuration = (Int32)Math.Ceiling(patternDurationInDouble);
            }
            else
            {
                patternDuration = (ValleyTime + RampUpTime + PeakTime + RampDownTime) * RepeatCount;
            }

            LoadProfileGroup profileGroup = new LoadProfileGroup("Valley-StepUp-Peak-StepDown", patternDuration);

            // Add the load profiles to a group
            // The step duration 5 seconds will be used to simulate the step up/down
            int stepDuration = 5;

            // 1. Simulate the ValleyLoad for a duration of ValleyTime
            profileGroup.AddProfile(new ConstLoadWrapper(ValleyLoad, ValleyTime));

            // 2. Simulate step up load - step up from ValleyLoad to PeakLoad in the RampUpTime window
            double stepCount = Math.Round((double)(PeakLoad - ValleyLoad) * stepDuration / RampUpTime);
            profileGroup.AddProfile(new StepLoadWrapper(ValleyLoad, ValleyLoad, PeakLoad, (int)stepCount, stepDuration, 0, RampUpTime));

            // 3. Simulate Peakload for PeakTime
            profileGroup.AddProfile(new ConstLoadWrapper(PeakLoad, PeakTime));

            // 4. Simulate step down load - step down from PeakLoad to ValleyLoad in the RampDownTime window
            stepCount = Math.Round((double)(PeakLoad - ValleyLoad) * stepDuration / RampDownTime);
            CustomLoadWrapper profileWrapper = new CustomLoadWrapper(RampDownTime);
            profileWrapper.Profile = new LoadTestStepDownLoadProfile(PeakLoad, ValleyLoad, PeakLoad, (int)stepCount, stepDuration);
            profileGroup.AddProfile(profileWrapper);

            // Add the profile group 
            m_profileManager.ProfileGroups.Add(profileGroup);

            // Tell the profile manager that we want to simulate the custom pattern right after test run is started
            m_profileManager.SetStartEndTimeForProfileGroups(0);
        }

        // The following heartbeat event will be fired every second, it can be used to adjust the user load
        void m_loadTest_Heartbeat(object sender, HeartbeatEventArgs e)
        {
            if (!e.IsWarmupComplete)
            {
                return;
            }

            // Get the load profile to be applied for the event
            LoadTestLoadProfile profile = m_profileManager.GetCurrentLoadProfile(e.ElapsedSeconds, m_loadTest.Scenarios[0].CurrentLoad);
            if (profile != null)
            {
                m_loadTest.Scenarios[0].LoadProfile = profile;
            }
        }

        #region Load Profile Configurations
        [DefaultValue(20)]
        [Description("The Valley Load")]
        public int ValleyLoad
        {
            get { return m_valleyLoad; }
            set { m_valleyLoad = value; }
        }

        [DefaultValue(20)]
        [Description("The Peak Load")]
        public int PeakLoad
        {
            get { return m_peakLoad; }
            set { m_peakLoad = value; }
        }

        [DefaultValue(60)]
        [Description("The amount of time that ValleyLoad will be simulated")]
        public int ValleyTime
        {
            get { return m_valleyTime; }
            set { m_valleyTime = value; }
        }

        [DefaultValue(60)]
        [Description("The amount of time that PeakLoad will be simulated")]
        public int PeakTime
        {
            get { return m_peakTime; }
            set { m_peakTime = value; }
        }

        [DefaultValue(20)]
        [Description("The amount of time to ramp up from ValleyLoad to PeakLoad")]
        public int RampUpTime
        {
            get { return m_rampUpTime; }
            set { m_rampUpTime = value; }
        }

        [DefaultValue(20)]
        [Description("The amount of time to step down from PeakLoad to ValleyLoad")]
        public int RampDownTime
        {
            get { return m_rampDownTime; }
            set { m_rampDownTime = value; }
        }

        [DefaultValue(20)]
        [Description("The number of times to repeat this pattern")]
        public int RepeatCount
        {
            get { return m_repeatCount; }
            set { m_repeatCount = value; }
        }

        [DefaultValue(100)]
        [Description("When the RepeatCount is 0. This property specifies the % of the duration that the pattern will be simulated. Default to entire duration")]
        public int PercentageOfDuration
        {
            get { return m_percentageOfDuration; }
            set { m_percentageOfDuration = value; }
        }

        #endregion

        private LoadTest m_loadTest;
        private LoadProfileManager m_profileManager;

        private int m_valleyLoad;
        private int m_peakLoad;

        private int m_valleyTime;
        private int m_peakTime;
        private int m_rampUpTime;
        private int m_rampDownTime;

        private int m_repeatCount;
        private int m_percentageOfDuration;
    }
}

Step 4 – Configure the modeling properties

Add the PeakLoadModelingPlugin to your load test. The modeling properties can be configured through the Add Load Test Plug-in dialog.

Step 1 – Create a RunHelper class to wrap up the MsTest.exe process

This helper class constructs the command-line argument list for MsTest.exe, starts the MsTest process to run your tests, and logs the output. You can modify the MSTestArgumentsFormat to use different set of mstest switches.

public class RunHelper

{

    static readonly string VSPath = Path.Combine(Environment.GetEnvironmentVariable("ProgramFiles"),

                                                  @"Microsoft Visual Studio 10.0\Common7\IDE");

    static readonly string MSTestPath = Path.Combine(VSPath, "MSTest.exe");

    static readonly string MSTestArgumentsFormat =

        string.Format(CultureInfo.InvariantCulture,

                "/testcontainer:{0} /testsettings:{1} /resultsfile:{2}",

                @"{0}",

                @"{1}",

                @"{2}"

            );

    public static void RunMSTest(string container, string testsettings, string resultsFileName, int timeout)

    {

        // Build the command line argument

        string commandLineArguments = string.Format(CultureInfo.InvariantCulture,

                                            MSTestArgumentsFormat,

                                            container,

                                            testsettings,

                                            resultsFileName

                                        );

        ProcessStartInfo startInfo =

            new ProcessStartInfo(

                    MSTestPath,

                    commandLineArguments

                );

        startInfo.CreateNoWindow = true;

        startInfo.UseShellExecute = false;

        startInfo.RedirectStandardError = true;

        startInfo.RedirectStandardOutput = true;

        startInfo.WindowStyle = ProcessWindowStyle.Hidden;

        // Create and run the process

        Process mstestProcess = Process.Start(startInfo);

        mstestProcess.StartInfo = startInfo;

        mstestProcess.Start();

        string stdout = mstestProcess.StandardOutput.ReadToEnd();

        string stderr = mstestProcess.StandardError.ReadToEnd();

        mstestProcess.WaitForExit(timeout);

        int exitCode = mstestProcess.ExitCode;

        mstestProcess.Close();

        // log the output

        Console.WriteLine("{0} {1}", MSTestPath, commandLineArguments);

        Console.WriteLine("exitcode: {0}", exitCode);

        Console.WriteLine("stdout: {0}", stdout);

        Console.WriteLine("stderr: {0}", stderr);

    }

}

Step 2 – Create a TestRunner class to run all the tests

I added three simple functions to the following helper class for running Web, coded Web, and load tests. Basically, you can add your logics to the methods to use different testsettings files in different test environments, e.g. local vs remote, 32-bit mode vs 64-bit mode, running tests with or without data collection, and running tests using different controllers.

public class TestRunner

{

    // Specify a proper timeout for you testing

    static readonly int TIMEOUT = 120000;

    static public void RunWebTests()

    {

        RunHelper.RunMSTest(@"e:\webtest1.webtest",

                            @"e:\local.testsettings",

                            @"e:\webtest1Result.trx",

                            TIMEOUT);

    }

    static public void RunCodedWebTests()

    {

        RunHelper.RunMSTest(@"e:\codedTests.dll",

                            @"e:\remote.testsettings",

                            @"e:\CodedWebtestResults.trx",

                            TIMEOUT);

    }

    static public void RunLoadTests()

    {

        RunHelper.RunMSTest(@"e:\Stress1.loadtest",

                            @"e:\64Bit.testsettings",

                            @"e:\Stress1Result.trx",

                            TIMEOUT);

    }

}

Step 3 – Run the tests from a console application

The last step is to create a console application, add classes created in step 1 and 2, and call methods in the TestRunner class. In the following code, it just calls the TestRunner to run all the Web tests.

static void Main(string[] args)

{

    TestRunner.RunWebTests();

}

And the output is

For example, in the below graph for a 30-min Load run, several load profiles, including const, stepUp, stepDown, CustomSinWave, are simulated about every 7.5 minutes.

This post will show you step by step on how to

1) Create customize user load profiles besides the existing LoadTestConstLoadProfile, LoadTestStepLoadProfile, and LoadTestGoalBasedLoadProfile (Covered in Step 1)

2) Simulate multiple and repeated user load patterns in a load test run (Covered in Step 2)

In the previous blog post, we have completed Step 2-1, i.e. Creating CustomLoadProfiles library. In this post, we will complete the load test plug-in code.

Step2 – Create Load Test Plug-in To Simulate User Load Patterns

The changes to enable multi- load profiles are highlighted as below

1) Plug-in data members

Add a private member of type LoadProfileManager. It is used to manage the profile groups, and return the load test profile at run time.

2) Initialize()

Add a Load Test heartbeat event handler to apply the user load change.

Add the profile groups you want to simulate. To simulate more than one load patterns, you can add multiple profiles to a given load test, e.g. const load 40 for 60 seconds followed by user load oscillation between (800, 1000) for 240 seconds. To simulate repeated load pattern group, you can specify the duration of the pattern group. During the load test run, the plug-in will cycle through the load profiles and apply the load accordingly.

3) Load Test heartbeat event handler

Get the Load profile to be applied for the current heart beat event.

[LoadTestPlugin.cs] For graphical view, see the screenshot at the beginning of this post.

using System;
using System.IO;
using System.Reflection;
using System.Collections;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.LoadTesting;
using CustomLoadProfiles;

namespace TestProject1
{
    // How to use this class?
    // This is a regular load test plugin class
    // InitLoadProfileGroups() - You specify the pattern groups you want to simulate // m_loadTest_Heartbeat event handler() -
    // CustomLoadProfiles.cs - add more custom load profiles to this file

    public class MultiLoadPatternsPlugin : ILoadTestPlugin
    {
        LoadTest m_loadTest;
        LoadProfileManager m_profileManager;

        public void Initialize(LoadTest loadTest)
        {
            m_loadTest = loadTest;
            m_profileManager = new LoadProfileManager();

            // The heartbeat event will be fired every second, it can be used to adjust the user load
            m_loadTest.Heartbeat += new EventHandler<HeartbeatEventArgs>(m_loadTest_Heartbeat);

            // Add the pattern groups you want to simulate
            InitLoadProfileGroups();
        }

        void InitLoadProfileGroups()
        {
            // Add profiles to a group
            // Simulate a custom user load pattern for 30 mins
            LoadProfileGroup profileGroup = new LoadProfileGroup("Custom1", 2400);

            // Simulate Const load 50 for 60 seconds
            profileGroup.AddProfile(new ConstLoadWrapper(50, 60));

            // Add custom load profile - simulate sin curve load
            CustomLoadWrapper profileWrapper = new CustomLoadWrapper(240);
            profileWrapper.Profile = new LoadTestSinLoadProfile(60, 30, 30, 1, 5);
            profileGroup.AddProfile(profileWrapper);

            // Simulate step up load - step up 30 users every 5 seconds for 40 seconds
            profileGroup.AddProfile(new StepLoadWrapper(60, 0, 300, 30, 5, 0, 40));

            // Simulate user load oscillation between [280, 320] for 60 seconds
            profileWrapper = new CustomLoadWrapper(60);
            profileWrapper.Profile = new LoadTestSinLoadProfile(300, 20, 30, 2, 5);
            profileGroup.AddProfile(profileWrapper);

            // Step down user load - step down 30 users every 5 seconds for 40 seconds
            profileWrapper = new CustomLoadWrapper(40);
            profileWrapper.Profile = new LoadTestStepDownLoadProfile(300, 60, 300, 30, 5);
            profileGroup.AddProfile(profileWrapper);

            // Add the profile group
            m_profileManager.ProfileGroups.Add(profileGroup);

            m_profileManager.SetStartEndTimeForProfileGroups(0);
        }

        // The following heartbeat event will be fired every second, it can be used to adjust the user load
        void m_loadTest_Heartbeat(object sender, HeartbeatEventArgs e)
        {
            if (!e.IsWarmupComplete)
            {
                return;
            }

            // Get the load profile to be applied for the event
            LoadTestLoadProfile profile = m_profileManager.GetCurrentLoadProfile(e.ElapsedSeconds, m_loadTest.Scenarios[0].CurrentLoad);
            if (profile != null)
            {
                m_loadTest.Scenarios[0].LoadProfile = profile;
            }
        }
    }
} ]]> https://docs.microsoft.com/archive/blogs/yutong/load-test-plug-in-simulate-multiple-and-repeated-user-load-patterns-step-2-1 Mon, 15 Mar 2010 19:01:12 GMT https://blogs.msdn.microsoft.com/yutong/2010/03/15/load-test-plug-in-simulate-multiple-and-repeated-user-load-patterns-step-2-1/ With the Load Test Editor, you can configure one load test profile for a given scenario. However, in the real-world testing, you may want to observe the performance of your applications / system under tests under different load patterns. And this can be achieved by writing custom load profile management classes and a load test plug-in. (Sample code included and available for downloading from codeplex)

For example, in the below graph for a 30-min Load run, several load profiles, including const, stepUp, stepDown, CustomSinWave, are simulated about every 7.5 minutes.

This post will show you step by step on how to

1) Create customized user load profiles and profile group management classes (Covered in Step 1)

2) Simulate multiple and repeated user load patterns in a load test run (Covered in Step 2)

Step1 – Create CustomLoadProfiles Library

In the sample code, I have implemented two *.cs files to manage the custom load patterns.

CustomLoadProfiles.cs – This file contains

-- Two custom Step load profiles. One for linear stepping down and the other for simulating user load oscillations with a Math.Sin() curve.

-- CustomLoadProfile wrapper classes for existing and customized LoadTestLoadProfiles. A wrapper class allows you to specify the duration you want to simulate the user pattern.

LoadProfileManager.cs – This files contains two classes.

-- LoadProfileGroup class

   The class contains all the profiles you want to simulate. For example, a const load profile for 60 seconds, a sin wave for 120 seconds, and a step down load for 40 seconds.  You  can specify the duration of the profile group. For example, if the duration of this group is set to 20 min. The Load test plug-in will cycle through all the load profiles added to this group till the end of 20th minute if the duration of the load test is longer than 20 mins.

-- LoadProfileGroupManagers class

   It allows you to simulate multiple pattern groups in your run. It will find the right load test profile to be applied at run time.

1) Create a class library and add the reference to the Microsoft.VisualStudio.TestTools.LoadTesting.

2) Create the custom load profiles. (CustomLoadProfiles.cs)

Details on how to create custom load profiles can be found in https://blogs.msdn.com/billbar/pages/load-test-api-enhancements-in-vsts-2008-sp1-beta.aspx.

Add the following code to your library and add your own custom load profiles. 

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.LoadTesting;

// CustomLoadProfiles.cs
// Add more cutom profiles in this file
namespace CustomLoadProfiles
{
    #region Custom LoadProfile

    // The base class for customized load profile
    // Add different validations as needed
    [Serializable]
    public class CustomLoadProfile : LoadTestStepLoadProfile
    {
        int m_currentUserLoad;
        public CustomLoadProfile()
        {
            m_currentUserLoad = 0;
        }

        public int CurrentUserLoad
        {
            get { return m_currentUserLoad; }
            set { m_currentUserLoad = value; }
        }

        public override int GetLoad(int elaspsedTimeInProfile)
        {
            return 0;
        }

        public override void  Validate() {}
    }

    // Custom step up/down - Sin wave simulation
    // y(t) = A * sin(2* PI * f * t / unitTimeInterval)
    // t - time
    // f - number of oscillations occur in an unit time interval
    [Serializable]
    public class LoadTestSinLoadProfile : CustomLoadProfile
    {
        int m_amplitude;
        int m_unitTimeInterval;
        int m_freq;
        public LoadTestSinLoadProfile(int initCount, int amplitude, int unitTmeInterval, int frequency, int stepDuration)
        {
            InitialUserCount = initCount;
            StepDuration = stepDuration;
            m_amplitude = amplitude;
            m_unitTimeInterval = unitTmeInterval;
            m_freq = frequency;
        }

        public override int GetLoad(int elapsedTimeInProfile)
        {
            if (elapsedTimeInProfile % StepDuration == 0)
            {
               CurrentUserLoad = CalculateUserLoad(elapsedTimeInProfile);
            }

            return (int)Math.Max(CurrentUserLoad, MinUserCount);
        }

        // If you are familiar with Sin curves, you can modify the formula to calculate user load
        int CalculateUserLoad(int elapsedTimeInProfile)
        {
            double userLoad = 0;
            userLoad = Math.Sin(2* Math.PI * m_freq * elapsedTimeInProfile / m_unitTimeInterval) * m_amplitude;
            userLoad = InitialUserCount + userLoad;

            return (Int32)(userLoad);
        }
    }

    // Custom step down - linear
    [Serializable]
    public class LoadTestStepDownLoadProfile : CustomLoadProfile
    {
        public LoadTestStepDownLoadProfile(int initCount, int minCount, int maxCount, int stepCount, int stepDuration)
        {
            InitialUserCount = initCount;
            StepUserCount = stepCount;
            StepDuration = stepDuration;
            MinUserCount = minCount;
            MaxUserCount = maxCount;
            CurrentUserLoad = initCount;
        }

        public override int GetLoad(int elapsedTimeInProfile)
        {
            if (elapsedTimeInProfile % StepDuration == 0)
            {
                CurrentUserLoad -= StepUserCount;
            }

            return (int)Math.Max(CurrentUserLoad, MinUserCount);
        }
    }

    #endregion

    #region CustomLoadProfile Warpper Classes
    // The base class (wrapper) for a customized load profile
    public abstract class LoadProfileWrapper
    {
        bool m_inUse;
        int m_duration;  // How long this pattern will be simulated

        public int Duration
        {
            get { return m_duration; }
            set { m_duration = value; }
        }

        public bool InUse
        {
            get { return m_inUse; }
            set { m_inUse = value; }
        }

        public abstract LoadTestLoadProfile Profile
        {
            get;
            set;
        }

        public virtual void UpdateProfileStatus(bool inUse, int currentUserLoad)
        {
            InUse = inUse;
        }
    }

    public class CustomLoadWrapper : LoadProfileWrapper
    {
        LoadTestLoadProfile m_profile;
        public CustomLoadWrapper(int patternDuration)
        {
            m_profile = new LoadTestConstantLoadProfile(); // instantiate it as an const load file
            InUse = false;
            Duration = patternDuration;
        }

        public override LoadTestLoadProfile Profile
        {
            get { return m_profile; }
            set { m_profile = (LoadTestLoadProfile)value; }
        }

        public override void UpdateProfileStatus(bool inUse, int currentUserCount)
        {
            InUse = inUse;
            if (m_profile is CustomLoadProfile)
            {
                ((CustomLoadProfile)m_profile).CurrentUserLoad = currentUserCount;
            }
        }
    }

    #endregion
}

3) Add the LoadProfileManager.cs to your library

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.LoadTesting;

namespace CustomLoadProfiles
{
    // This the pattern group class
    // It contains the list of profiles to be simulated in a specified time window
    // Each group can contain several load test profiles
    // During a load run, the test engine will cycle through the LoadTestProfiles and ajust the user load
    public class LoadProfileGroup
    {
        string m_name;
        List<LoadProfileWrapper> m_profileGroup;
        int m_startTime;
        int m_endTime;
        int m_duration;
        int m_patternCycleDuration;
        int m_timeInGroup;
        int m_previousCycleCount;

        public LoadProfileGroup(string name, int duration)
        {
            m_name = name;
            m_duration = duration;
            m_timeInGroup = 0;
            m_previousCycleCount = 0;
            m_patternCycleDuration = 0;
            m_profileGroup = new List<LoadProfileWrapper>();
        }

        public void AddProfile(LoadProfileWrapper profile)
        {
            m_profileGroup.Add(profile);
            m_patternCycleDuration += profile.Duration;
        }

        // The load profiles to be simulated
        public List<LoadProfileWrapper> LoadProfiles
        { get { return m_profileGroup; } }

        public int StartTime
        {
            get { return m_startTime; }
            set { m_startTime = value; }
        }

        public int EndTime
        {
            get { return m_endTime; }
            set { m_endTime = value; }
        }

        public int Duration
        { get { return m_duration; } }

        public String Name
        { get { return m_name; } }

        // This function will find out what load test profile will be used for current heartbeat event
        // If no change will be made, null will be returned
        public LoadTestLoadProfile GetLoadProfile(int elapsedTime, int currentUserLoad)
        {
            // Calculate the elapased time in the group
            m_timeInGroup = elapsedTime - m_startTime;

            int currentCycleCount = m_timeInGroup / m_patternCycleDuration;

            // Reset the InUse status of each profile to false at the beginning of each cycle
            if (m_previousCycleCount < currentCycleCount && m_timeInGroup % m_patternCycleDuration != 0)
            {
                m_previousCycleCount++;

                for (int i = 0; i < LoadProfiles.Count; i++)
                {
                    LoadProfileWrapper profileWrapper = LoadProfiles[i];
                    profileWrapper.InUse = false;
                }
            }

            // Find out if new load test profile should be applied
            int durationLength = 0;
            foreach (LoadProfileWrapper profileWrapper in LoadProfiles)
            {
                durationLength += profileWrapper.Duration;

                if ((m_timeInGroup == 0) || // the first profile
                    (m_timeInGroup > 0 && m_timeInGroup % m_patternCycleDuration <= durationLength))
                {
                    if (!profileWrapper.InUse)
                    {
                        // Found the new profile to be applied
                        profileWrapper.UpdateProfileStatus(true, currentUserLoad);
                        return (LoadTestLoadProfile)profileWrapper.Profile;
                    }

                    break;
                }
            }

            return null;
        }
    }

    /// <summary>
    /// Manages all pattern groups to be simulated in the load test run
    /// </summary>
    public class LoadProfileManager
    {
        List<LoadProfileGroup> m_profileGroups;
        private string previousGroup;

        public LoadProfileManager()
        {
            m_profileGroups = new List<LoadProfileGroup>();
        }

        // All the profiles included in this pattern
        public List<LoadProfileGroup> ProfileGroups
        {
            get { return m_profileGroups; }
            set { m_profileGroups = value; }
        }

        // Get the current Load profile based on the elapsed time
        public LoadTestLoadProfile GetCurrentLoadProfile(int elapsedSeconds, int currentUserLoad)
        {
            LoadTestLoadProfile profile = null;
            bool foundProfileGroup = false;

            foreach (LoadProfileGroup group in m_profileGroups)
            {
                // Get the pattern group to be simulated
                if (elapsedSeconds <= group.EndTime && elapsedSeconds > group.StartTime)
                {
                    foundProfileGroup = true;

                    if (!String.Equals(previousGroup, group.Name, StringComparison.OrdinalIgnoreCase))
                    {
                        previousGroup = group.Name;
                    }

                    // Get the profile
                    profile = group.GetLoadProfile(elapsedSeconds, currentUserLoad);
                    break;
                }
            }

            // If no profile group is found, the load test run will continue with a const load

            if (foundProfileGroup == false)
            {
                profile = new LoadTestConstantLoadProfile();
                ((LoadTestConstantLoadProfile)profile).UserCount = currentUserLoad;
            }

            return profile;
        }

        // Set the start/end times for each pattern group
        public void SetStartEndTimeForProfileGroups(int elapsedSeconds)
        {
            int prevGroupEndTime = elapsedSeconds;
            int duration = 0;
            foreach (LoadProfileGroup group in m_profileGroups)
            {
                // set the start time
                group.StartTime = prevGroupEndTime;

                // set the end time
                duration += group.Duration;
                group.EndTime = duration;

                // update the start time for next pattern group
                prevGroupEndTime = duration;
            }
        }
    }
}

4) Add the class library for assembly binding

Drop the class library to the %Program Files\Microsoft Visual Studio 10.0\Common7\IDE\PrivateAssemblies to avoid any serialization issues at run-time.

If you want the initialization code of load profiles in the Load test plug-in to be simple and clean,  you can add the wrapper classes for the build-in load profiles to CustomLoadProfiles.cs

// The const load profile wrapper
    public class ConstLoadWrapper : LoadProfileWrapper
    {
        LoadTestConstantLoadProfile m_profile;
        public ConstLoadWrapper(int userCount, int duration)
        {
            m_profile = new LoadTestConstantLoadProfile();
            m_profile.UserCount = userCount;
            Duration = duration;
        }

        public override LoadTestLoadProfile Profile
        {
            get { return m_profile; }
            set { m_profile = (LoadTestConstantLoadProfile)value; }
        }
    }

    // The goal based load profile wrapper
    public class GoalBasedLoadWrapper : LoadProfileWrapper
    {
        LoadTestGoalBasedLoadProfile m_profile;
        public GoalBasedLoadWrapper(int initialCount, int minCount, int maxCount, int maxIncrement, int maxDecrement, int patternDuration)
        {
            m_profile = new LoadTestGoalBasedLoadProfile();
            m_profile.InitialUserCount = initialCount;
            m_profile.MinUserCount = minCount;
            m_profile.MaxUserCount = maxCount;
            m_profile.MaxUserCountIncrease = maxIncrement;
            m_profile.MaxUserCountDecrease = maxDecrement;
            Duration = patternDuration;
        }

        public void SetCounter(string machine, string category, string counter, string instance, bool stopAdjustingAtGoal)
        {
            m_profile.MachineName = machine;
            m_profile.InstanceName = instance;
            m_profile.CategoryName = category;
            m_profile.CounterName = counter;
            m_profile.StopAdjustingAtGoal = stopAdjustingAtGoal;
        }

        public override LoadTestLoadProfile Profile
        {
            get { return m_profile; }
            set { m_profile = (LoadTestGoalBasedLoadProfile)value; }
        }
    }

    // The step load profile wrapper
    public class StepLoadWrapper : LoadProfileWrapper
    {
        LoadTestStepLoadProfile m_profile;
        public StepLoadWrapper(int initCount, int minCount, int maxCount, int stepCount, int stepDuration, int stepRampTime, int patternDuration)
        {
            m_profile = new LoadTestStepLoadProfile();
            m_profile.InitialUserCount = initCount;
            m_profile.MinUserCount = minCount;
            m_profile.MaxUserCount = maxCount;
            m_profile.StepUserCount = stepCount;
            m_profile.StepDuration = stepDuration;
            m_profile.StepRampTime = stepRampTime;
            InUse = false;
            Duration = patternDuration;
        }

        public override LoadTestLoadProfile Profile
        {
            get { return m_profile; }
            set { m_profile = (LoadTestStepLoadProfile)value; }
        }
    }

Installation

Run setup.exe /full /q from command line.

Controller/Agent Configurations

The configuration can be done through UI or command line tools.

To configure through UI, go to Start->Programs->Microsoft Visual Studio 2010-> Microsoft Visual Studio Test Controller 2010 Configuration Tool for controller configuration; and go to go to Start->Programs->Microsoft Visual Studio 2010-> Microsoft Visual Studio Test Agent 2010 Configuration Tool for agent configuration.

To configure through command line tools, use TestControllerConfig.exe/TestAgentConfig.exe under D:\Program Files (or x86 on 64-bit machine) \Microsoft Visual Studio 10.0\Common7\IDE. Type /? for helps.

1. After a user records an http Upload request, the uploaded file is automatically added to the test project by a build-in FileUpload Plug-in. As you can see, test.txt is added to the test project after recording.

2. A new property called Generate Unique Name is added to the File Upload Parameter. By default, its value is set to true, which indicates that a unique file name will be generated before the request is sent. If it is set to false,  the file name will not be modified during test execution, which is the same as the upload behavior in VSTS2008 and VSTS2005. Note: In VSTS2010, for a upgraded Web test that contains a file upload request, the value is set to false.

3. When a user runs the recorded file upload Web test, the file to be uploaded is automatically deployed. A user does not need to add it explicitly to the deployment section of  the VSTS2010 .testsettings file before test execution.

After the sample Web test is executed, as you can see, the uploaded file is prefixed with a timestamp.  

If the server-side script does not modify the name of the uploaded file, a user should find the file "11062009091608978test.txt" on the Web Server machine.

4. Playback of the generate coded Web test just works. As you can see in the below code, the file to be uploaded is automatically added as a deployment item.

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.20608.0
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestProject1
{
    using System;
    using System.Collections.Generic;
    using System.Text;
    using Microsoft.VisualStudio.TestTools.WebTesting;
    using Microsoft.VisualStudio.TestTools.WebTesting.Rules;

    [DeploymentItem("test.txt")]
    public class WebTest2Coded : WebTest
    {

        public WebTest2Coded()
        {
            this.PreAuthenticate = true;
        }

        public override IEnumerator<WebTestRequest> GetRequestEnumerator()
        {
            // Initialize validation rules that apply to all requests in the WebTest
            if ((this.Context.ValidationLevel >= Microsoft.VisualStudio.TestTools.WebTesting.ValidationLevel.Low))
            {
                ValidateResponseUrl validationRule1 = new ValidateResponseUrl();
                this.ValidateResponse += new EventHandler<ValidationEventArgs>(validationRule1.Validate);
            }
            if ((this.Context.ValidationLevel >= Microsoft.VisualStudio.TestTools.WebTesting.ValidationLevel.Low))
            {
                ValidationRuleResponseTimeGoal validationRule2 = new ValidationRuleResponseTimeGoal();
                validationRule2.Tolerance = 0D;
                this.ValidateResponseOnPageComplete += new EventHandler<ValidationEventArgs>(validationRule2.Validate);
            }

            WebTestRequest request1 = new WebTestRequest("https://teamtestweb1/testwebsite/FileUpload.aspx");
            request1.ThinkTime = 26;
            ExtractHiddenFields extractionRule1 = new ExtractHiddenFields();
            extractionRule1.Required = true;
            extractionRule1.HtmlDecode = true;
            extractionRule1.ContextParameterName = "1";
            request1.ExtractValues += new EventHandler<ExtractionEventArgs>(extractionRule1.Extract);
            yield return request1;
            request1 = null;

            WebTestRequest request2 = new WebTestRequest("https://teamtestweb1/testwebsite/FileUpload.aspx");
            request2.Method = "POST";
            FormPostHttpBody request2Body = new FormPostHttpBody();
            request2Body.FormPostParameters.Add("__VIEWSTATE", this.Context["$HIDDEN1.__VIEWSTATE"].ToString());
            request2Body.FormPostParameters.Add(new FileUploadParameter("UploadFile", "test.txt", "text/plain", true));
            request2Body.FormPostParameters.Add("UploadButton", "Upload");
            request2Body.FormPostParameters.Add("SaveName", "test.txt");
            request2Body.FormPostParameters.Add("__EVENTVALIDATION", this.Context["$HIDDEN1.__EVENTVALIDATION"].ToString());
            request2.Body = request2Body;
            yield return request2;
            request2 = null;
        }
    }
} ]]> https://docs.microsoft.com/archive/blogs/yutong/vsts-2010-feature-view-recording-log-in-web-test-playback-window Wed, 10 Jun 2009 17:25:00 GMT https://blogs.msdn.microsoft.com/yutong/2009/06/10/vsts-2010-feature-view-recording-log-in-web-test-playback-window/ In VSTS2010, when a user records a Web test using Web Test Recorder, the recorded session result, including those for the dependant and redirected requests, is saved and can be loaded into the Web Test Result window later. So if the playback fails, for example, due to correlation (dynamic parameter detection) issues, a user can always compare the recorded result and the playback result side by side.

In the following example, the recorded Web test contains three requests. The first one is a non-redirect request and does not contain any dependant, the second one is request that is redirected twice, and the third one is redirected once and the redirect contains some dependant requests.

To load the recorded result in Web Test Result window, a user can run the Web test till completion and click on the Recorded Result button on the toolbar.

Below is the screenshot of the recorded result.

In the launched Recorded Result window, not only can a user view the recorded details, i.e. headers, cookies, query string parameters, post parameters, and the response for a selected request, the user can also perform a search or go to the recorded Web Test. With VSTS2010, only the first recorded session result will be saved at the end of recording.