Load Test Plug-in – Simulate Repeated Peak Load Modeling
In my previous posts, I have shown how to simulate repeated custom user load pattern groups. Here is another plug-in sample to simulate the PeakLoad modeling, i.e. VallyLoad-StepUp-PeakLoad-StepDown. In this plug-in, all the configurations can be passed in through the Load Test Plug-in properties. As shown in the below screenshot, it simulates a peak load of 800 users every 3 minutes.
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.