[Description("WebTestPlugin that adds a specified number of days to the current date and stores the new date in a Context Parameter that you specify. Overrides PreWebTest")]

public class AddDaysToCurrentDate : WebTestPlugin

{

public AddDaysToCurrentDate()

{

DaysToAdd = 1;

ContextParameterName = "FutureDate";

}

public override void PreWebTest(object sender, PreWebTestEventArgs e)

{

//TODO: Adjust the date format to obtain output needed. Search C# DateTime.Now Formats for examples and msdn documentation

//Example: FutureDate=Saturday, August 18, 10:49:21, 2012

//e.WebTest.Context[ContextParameterName] = DateTime.Now.AddDays(DaysToAdd).ToString("dddd, MMMM dd, HH:mm:ss, yyyy");

e.WebTest.Context[ContextParameterName] = DateTime.Now.AddDays(DaysToAdd).ToString();

}

[Description("Number of days to add to the current date. Default value is 1.")]

[DefaultValue(1)]

public double DaysToAdd { get; set; }

[Description("Context Parameter that will hold the new date value. Default value is 'FutureDate'.")]

[DefaultValue("FutureDate")]

public string ContextParameterName { get; set; }

}

 [Description("WebTest Plugin that dynamically Sets the Maximum or Minimum think time value for each request. Overrides the PreRequest event")]
    public class SetMaxMinThinkTime : WebTestPlugin
    {
        public SetMaxMinThinkTime()
        {
            MaxThinkTime = 60;
            MinThinkTime = 0;
            OutputComments = false;
            Enabled = true;
            ThrowExceptionIfThresholdExceeded = false;
        }
 
        public override void PreRequest(object sender, PreRequestEventArgs e)
        {
            //if plugin is disabled output a comment and return
            if (Enabled == false)
            {
                if (OutputComments)
                    e.WebTest.AddCommentToResult(this.ToString() + " Plugin is Disabled, no processing occured.");
                return;
            }
 
            //determine if threshold values exceeded and throw if exception enabled
            if (((e.Request.ThinkTime > MaxThinkTime) || (e.Request.ThinkTime < MinThinkTime)) && (ThrowExceptionIfThresholdExceeded))
            {
                e.WebTest.AddCommentToResult(this.ToString() + " Think Time Threshold value exceeded. Think Time = " + e.Request.ThinkTime.ToString());
                throw new Exception("A Think Time threshold value was exceeded.");
            }
                
            //update think time if greater than MaxThinkTime
            if (e.Request.ThinkTime > MaxThinkTime)
                e.Request.ThinkTime = MaxThinkTime;
 
            //update think time if less than MinThinkTime
            if (e.Request.ThinkTime < MinThinkTime)
                e.Request.ThinkTime = MinThinkTime;
 
            if (OutputComments)
                e.WebTest.AddCommentToResult("SetMaxMinThinkTime value = " + e.Request.ThinkTime.ToString());
        }
 
        [Description("Maximum Think Time value for any request")]
        [DefaultValue(60)]
        public int MaxThinkTime { get; set; }
 
        [Description("Minimum Think Time value for any request")]
        [DefaultValue(0)]
        public int MinThinkTime { get; set; }
 
        [Description("Enable output comments added to the test results view. Default is false")]
        [DefaultValue(false)]
        public bool OutputComments { get; set; }
 
        [Description("Enable or Disable the plugin execution. Default is Enabled (true)")]
        [DefaultValue(true)]
        public bool Enabled { get; set; }
 
        [Description("Throw exception when encountering Min or Max values that exceed threshold value. Default is false")]
        [DefaultValue(false)]
        public bool ThrowExceptionIfThresholdExceeded { get; set; }
 
 
    }

I created this Visual Studio 2010 webtestplugin which allows you to set the terminating value property of a conditional loop in a Declarative Web Test. As an example you might want to load the terminating value from a data source or other Context Parameter. Add a class to your test project and put this code in the .cs file,be sure to add a using for System.ComponentModel.

The idea for this came from a question posted on the forum here: https://social.msdn.microsoft.com/Forums/en-US/vstswebtest/thread/fc77f2f6-3e4d-488e-9a01-d87f06ed92e3

[Description("WebTestPlugin that sets a Conditional Loop terminating value dynamically in the PreWebTest event to a specified Context Parameter value. If using a datasource, be sure to select All Columns in the datasource properties in case the value your using is not bound in the test.")]
 public class SetLoopTerminatingValue : WebTestPlugin
 {
 [Description("ContextParameter specified in the Conditional Rule to hold the loop counter value. This is used to confirm which conditional rule you want this plugin to work against.")]
 public string ConditionalRuleContextParameter { get; set; }
 [Description("ContextParameter that holds the value you want to set the TerminatingValue property to in the conditional loop. If this is from a data source the syntax will resemble the following: DataSourc1.DataFile#csv.LoopTerminateValue")]
 public string ContextParameterTerminatingValue { get; set; }
 public override void PreWebTest(object sender, PreWebTestEventArgs e)
 {
 DeclarativeWebTest dwt = e.WebTest as DeclarativeWebTest;
 foreach (var conditionalRule in dwt.ConditionalRuleReferences)
 {
 //make sure this is the right conditional rule (they may have more than one) by checking the ContextParameterName that
 //the loop counter is using. This was specified by the user so they should be able to get this easily. 
 if (conditionalRule.Properties["ContextParameterName"] == ConditionalRuleContextParameter)
 {
 //make sure the context parameter they provided exists before setting terminating value
 if (e.WebTest.Context.ContainsKey(ContextParameterTerminatingValue))
 {
 conditionalRule.Properties["TerminatingValue"] = e.WebTest.Context[ContextParameterTerminatingValue].ToString();
 }
 else
 {
 //let them know this does not exist, and this will fail the test execution.
 throw new ArgumentException("Context Parameter for the Terminating Value does not exist. Please check for the existense of context parameter specified as '" + ContextParameterTerminatingValue + "'");
 }
 }
 }
 }
 }

Shows how to use the TestContext to access the Value copied
into the TestContext from the Load Test Plugin:

  [TestClass]

    public class UnitTest2

    {

        private TestContext testContextInstance;

        /// <summary>

        ///Gets or sets the test context which provides

        ///information about and functionality for the current test run.

        ///</summary>

        public TestContext TestContext

        {

            get

            {

                return testContextInstance;

            }

            set

            {

                testContextInstance = value;

            }

        }

        [TestMethod]

        public void TestMehod2()

        {

            string scenarioName = TestContext.Properties["ScenarioName"].ToString();

        }

    }

Load Test Plugin

Add a Class.cs file to the Test Project, then will need to Add
Reference to the LoadTestFramework as follows:

Microsoft.VisualStudio.QualityTools.LoadTestFramework

These two using will also be needed, and once you have the source code in you need to compile one time before gong to the Load Test and adding the LoadTest Plugin to the loadtest (right click on the loadtest name in the top node in the loadtest editor in VS, choose Add LoadTest Plugin, select from the list, and now your ready to use this:

using System.ComponentModel;

using Microsoft.VisualStudio.TestTools.LoadTesting;

 [System.ComponentModel.Description("WebTestPlugin, Overrides PreWebTest and appends either a context parameter or hard coded string to a specified target Context Parameter. As an example, this plugin could append the built in $WebTestIteration value to an existing datasource column value.")] 
 public class AppendValueToContextParameter : WebTestPlugin
 { 
 [System.ComponentModel.DefaultValue("DataSource1.SomeDataFile#csv.FieldName")]
 [System.ComponentModel.Description("The target context parameter that you would like to append the source context param value")]
 public string ContextParamTarget { get; set; }
 
 [System.ComponentModel.DefaultValue("$WebTestIteration")]
 [System.ComponentModel.Description("The source context parameter, or a hard coded string value you would like appended to the target context param")]
 public string ContextParamOrValueSource { get; set; }
 
 public AppendValueToContextParameter()
 {
 ContextParamOrValueSource = "$WebTestIteration";
 ContextParamTarget = "DataSource1.SomeDataFile#csv.FieldName";
 }
 
 public override void PreWebTest(object sender, PreWebTestEventArgs e)
 {
 //confirm the target context param exists 
 if (e.WebTest.Context.ContainsKey(ContextParamTarget))
 {
 //is the ContextParmOrValueSource a Context Parameter or a hard coded value?
 if (e.WebTest.Context.ContainsKey(ContextParamOrValueSource))
 {
 e.WebTest.Context[ContextParamTarget] += e.WebTest.Context[ContextParamOrValueSource].ToString();
 }
 else //hard coded value
 {
 e.WebTest.Context[ContextParamTarget] += ContextParamOrValueSource;
 } 
 }
 else
 {
 throw new ArgumentException("Required Context Parameter Target was not found");
 }
 }
 }

Then just right click on your WebTest in the editor and choose Add WebTest Plugin picking this one and you should be good.

Just use the curly brace syntax where your using it in the test just like any context parameter (i.e. {{RandomNumber}} ). You can have it regenerate the random number before every request, or just have it do this only once in the PreWebTest by setting the UpdateBeforeRequest property. If you need more random numbers, you can add more than one instance of this plugin,just remember to set the ContextParameter name to something different .

In the code, if you add the appropriate using System.ComponentModel, then you don’t have to put the full syntax as is listed below for the attributes [System.ComponentModel.xxx] you can use [Description(“Blah”)], etc.

[System.ComponentModel.Description("Creates a Random Number and stores the value in the Context Parameter defined. The value can be created once the test starts, or it can be updated before each web request.")]
    public class RandomNumberContextParameter : WebTestPlugin
    {
        [System.ComponentModel.Description("If True, the random number will be recalculated before each request is made. The default is false.")]
        [System.ComponentModel.DefaultValue(false)]
        public bool UpdateBeforeRequest { get; set; }
 
        [System.ComponentModel.Description("Name of the Context Paramter that will stroe the random number.")]
        [System.ComponentModel.DefaultValue("RandomNumber")]
        public string ContextParameter { get; set; }
 
        [System.ComponentModel.DefaultValue(1)]
        public int MinimumValue { get; set; }
        
        [System.ComponentModel.DefaultValue(101)]
        public int MaximumValue { get; set; }
        
        public RandomNumberContextParameter()
        {
            UpdateBeforeRequest = false;
            ContextParameter = "RandomNumber";
            MinimumValue = 1;
            MaximumValue = 100;
 
        }
        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            if (string.IsNullOrEmpty(ContextParameter))
                throw new ArgumentException(this.ToString() + "Error --> ContextParameter property cannot be null or empty. Please define a context paramater to output the random number.");
            
            if (MinimumValue > MaximumValue + 1)
                throw new ArgumentOutOfRangeException(this.ToString() + "Error --> The property for the MinimumValue must less than or equal to MaximumValue.");
           
            //note the Random.Next() method creates a random number based on the min, and max values, however the max value returnd is one less than specified
            //so we add one here so that it works the way most people would intuitively expect.
            e.WebTest.Context[ContextParameter] = new Random().Next(MinimumValue,MaximumValue + 1).ToString();
                      
        }
        public override void PreRequestDataBinding(object sender, PreRequestDataBindingEventArgs e)
        {
            //if they want a new random number generated for each new request
            if (UpdateBeforeRequest)
                e.WebTest.Context[ContextParameter] = new Random().Next(MinimumValue, MaximumValue + 1).ToString();
        }
 
    }

Unlimited Visual Studio 2010 SP1 Virtual Users with the Load Test Feature Pack now.

Check this link for the details. https://www.microsoft.com/visualstudio/en-us/products/2010-editions/load-test-virtual-user-pack/overview. 

This means where other load testing tools charge based on Virtual User licenses, Microsoft is providing these as an added benefit to those with Visual Studio 2010 Ultimate / MSDN Ultimate subscription. All the more reasons to adopt Visual Studio 2010 Ultimate as your primary Load Testing tool.

using System.ComponentModel;
using Microsoft.VisualStudio.TestTools.WebTesting;

namespace TestProject5
{
  [Description("Validates that the response URL after redirects are followed is the same as the recorded response URL. QueryString parameters are ignored. The match will be done on case insensitive basis.")]
  [DisplayName("Response URL Case Insensitive")]
  public class ResponseURLCaseInsensitive : ValidationRule
  {
    public override void Validate(object sender, ValidationEventArgs e)
    {
      //determine if request is a redirect follow and validate the URL accordingly
      if (e.Request.IsRedirectFollow)
      {
        //use to upper to force case insensitive comparision
        if (e.Request.ExpectedResponseUrl.ToUpper() == e.Request.Url.ToUpper())
        {
          e.IsValid = true;
          e.Message = "Response URL successfully matched case insensitive comparison. Expected Value=" + e.Request.ExpectedResponseUrl + " , Actual Value=" + e.Request.Url;
        }
        else
        {
          e.IsValid = false;
          e.Message = "Response URL did NOT match. Expected Value=" + e.Request.ExpectedResponseUrl + " , Actual Value=" + e.Request.Url;
        }
      } //if the request did not redirect, determine if one was expected and fail if true
      else if (!string.IsNullOrEmpty(e.Request.ExpectedResponseUrl))
      {
        e.IsValid = false;
        e.Message = "The expected response redirect did not occur. Expected Response URL=" + e.Request.ExpectedResponseUrl;
      }
    }
  }
}

So the default in Visual Studio is to use TLS, and not the downlevel SSLv3, but the question may come up , what do we do if we are stuck using a device that requires SSLv3? Well, the extensibility aspects of Visual Studio Test capability are there to help us fix this up. The following sample WebTest plugin shows you how you can override the default TLS. Hope this code sample helps you out if you.

The following code sample shows how to specify SSL vs. TLS in your WebTests by taking this code, put in a class file, and compile in your test project. Then you would right-click on your WebTest in the Visual Studio design view, and add WebTest Plugin using this plugin.

using System;

using System.ComponentModel;

using System.Net;

using System.Net.Security;

using System.Security.Cryptography.X509Certificates;

using Microsoft.VisualStudio.TestTools.WebTesting;





namespace ExperimentalTesting

{

    [Description("This plugin will force the underlying System.Net ServicePointManager to negotiate downlevel SSLv3 instead of TLS. WARNING: The servers X509 Certificate will be ignored as part of this process, so verify that you are testing the correct system.")]

    public class SSLv3ForcedPlugin : WebTestPlugin

    {

        [Description("Enable or Disable the plugin functionality")]

        [DefaultValue(true)]

        public bool Enabled {get;set;}



        public override void PreWebTest(object sender, PreWebTestEventArgs e)

        {

            base.PreWebTest(sender, e);



            // We're using SSL3 here and not TLS. Without this line, nothing works.

            ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3;



            //we wire up the callback so we can override  behavior and force it to accept the cert

            ServicePointManager.ServerCertificateValidationCallback = RemoteCertificateValidationCB;



            //let them know we made changes to the service point manager

            e.WebTest.AddCommentToResult(this.ToString() + " has made the following modification-> ServicePointManager.SecurityProtocol set to use SSLv3 in WebTest Plugin.");

        }

        public static bool RemoteCertificateValidationCB(Object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)

        {

            //If it is really important, validate the certificate issuer here.

            //this will accept any certificate

            return true;

        }

    }

}