public override void Extract(object sender, ExtractionEventArgs e)
{
string body = e.Response.BodyString;
List <string> formElements = new List <string>();
var processMatches = new Action <MatchCollection, string>((extractMatches, prefix) =>
{
foreach (Match extractMatch in extractMatches)
{
string name = extractMatch.Groups["name"].Value;
string value = extractMatch.Groups["value"].Value;
string lastPartOfName = name.Substring(name.LastIndexOf('$') + 1);
string keyName = RuleHelper.PlaceUniqueItem(e.WebTest.Context, prefix + lastPartOfName, name);
e.WebTest.Context[keyName + VALUE_SUFFIX] = value;
// Create a name value pair in context as it is using the form element's name
e.WebTest.Context[name] = value;
formElements.Add(name);
}
});
processMatches(_FindInputTags.Matches(body), INPUT_PREFIX);
foreach (Match match in _FindSelectTags.Matches(body))
{
var extractMatches = _ExtractSelectTags.Matches(match.Value);
processMatches(extractMatches, SELECT_PREFIX);
}
e.WebTest.Context[FORM_ELEMENT_KEYS] = formElements.ToArray();
}
public override void Extract(object sender, ExtractionEventArgs e)
{
if (e.Response.BodyString != null)
{
if (e.Response.StatusCode == HttpStatusCode.OK)
{
var json = e.Response.BodyString;
Respone r = JsonConvert.DeserializeObject <Respone>(json);
if (AsHeaderValue)
{
e.WebTest.Context.Add(this.ContextParameterName, string.Format("Bearer {0}", r.access_token));
}
else
{
e.WebTest.Context.Add(this.ContextParameterName, r.access_token);
}
e.Message = string.Format("Extracted Bearertoken into: {0}", this.ContextParameterName);
e.Success = true;
}
else
{
e.Message = string.Format("Authentication failed: {0} ", e.Response.BodyString);
e.Success = false;
}
}
else
{
e.Message = "No response or response empty";
e.Success = false;
}
}
// The Extract method. The parameter e contains the web performance test context.
//---------------------------------------------------------------------
public override void Extract(object sender, ExtractionEventArgs e)
{
if (e.Response.HtmlDocument != null)
{
foreach (HtmlTag tag in e.Response.HtmlDocument.GetFilteredHtmlTags(new string[] { "input" }))
{
if (String.Equals(tag.GetAttributeValueAsString("name"), Name, StringComparison.InvariantCultureIgnoreCase))
{
string formFieldValue = tag.GetAttributeValueAsString("checked");
if (formFieldValue == null)
{
formFieldValue = "off";
}
else
{
if (formFieldValue.ToLower().Equals("checked"))
{
formFieldValue = "on";
}
else
{
formFieldValue = "off";
}
}
// add the extracted value to the web performance test context
e.WebTest.Context.Add(this.ContextParameterName, formFieldValue);
e.Success = true;
return;
}
}
}
// If the extraction fails, set the error text that the user sees
e.Success = false;
e.Message = String.Format(CultureInfo.CurrentCulture, "Not Found: {0}", Name);
}
// The Extract method. The parameter e contains the web performance test context.
//---------------------------------------------------------------------
public override void Extract(object sender, ExtractionEventArgs e)
{
if (e.Response.HtmlDocument != null)
{
int skip = 1;
foreach (HtmlTag tag in e.Response.HtmlDocument.GetFilteredHtmlTags(new string[] { "select", "option" }))
{
if (String.Equals(tag.GetAttributeValueAsString("name"), Name, StringComparison.InvariantCultureIgnoreCase))
{
skip = 0;
}
else if (skip == 0)
{
if (String.Equals(tag.GetAttributeValueAsString("selected"), "selected", StringComparison.InvariantCultureIgnoreCase))
{
e.WebTest.Context.Add(this.ContextParameterName, tag.GetAttributeValueAsString("value"));
e.Success = true;
return;
}
}
else
{
skip = 1;
}
}
}
// If the extraction fails, set the error text that the user sees
e.Success = false;
e.Message = String.Format(CultureInfo.CurrentCulture, "Not Found: {0}", Name);
}
public override void Extract(object sender, ExtractionEventArgs e)
{
if (e.Response.HtmlDocument != null)
{
List<KeyValuePair<string, string>> hiddenWithValues = new List<KeyValuePair<string, string>>();
foreach (HtmlTag tag in e.Response.HtmlDocument.GetFilteredHtmlTags(new string[] { "input" }))
{
if (String.Equals(tag.GetAttributeValueAsString("type"), "hidden", StringComparison.InvariantCultureIgnoreCase))
{
string formFieldValue = tag.GetAttributeValueAsString("value").Replace(" ", "");
string fieldId = tag.GetAttributeValueAsString("name");
if (fieldId != null)
{
KeyValuePair<string, string> pair = new KeyValuePair<string, string>(fieldId, formFieldValue);
hiddenWithValues.Add(pair);
}
}
}
e.WebTest.Context.Add(this.ContextParameterName, hiddenWithValues);
e.Success = true;
return;
}
// If the extraction fails, set the error text that the user sees
e.Success = false;
e.Message = String.Format(CultureInfo.CurrentCulture, "Hidden Fields Not Found");
}
public override void Extract(object sender, ExtractionEventArgs e)
{
if (e.Response.HtmlDocument != null)
{
var document = e.Response.HtmlDocument;
var randomArticles = new List <HtmlTag>();
foreach (var anchor in document.GetFilteredHtmlTags(new string[] { "a" }))
{
var anchorClass = anchor.GetAttributeValueAsString("class");
if (!string.IsNullOrWhiteSpace(anchorClass) && anchorClass.Contains("show-article-link"))
{
randomArticles.Add(anchor);
}
}
if (randomArticles.Count > 0)
{
var randomArticle = randomArticles.Random();
var articleId = randomArticle.GetAttributeValueAsString("data-article-id");
e.WebTest.Context.Add(this.ContextParameterName, articleId);
e.Success = true;
return;
}
}
e.Success = false;
e.Message = "Not Found";
}
/// <summary>
/// Fires Extract event.
/// </summary>
/// <param name="args"></param>
protected virtual void OnExtract(ExtractionEventArgs args)
{
if (ExtractValues != null)
{
ExtractValues(this, args);
}
}
private void Request1_ExtractValues(object sender, ExtractionEventArgs e)
{
var decision = JsonConvert.DeserializeObject <PolicyDecision>(e.Response.BodyString);
e.WebTest.Context.Add("EventId", decision.EventId);
e.WebTest.Context.Add("Action", decision.Action);
}
public void Extract(object sender, ValidationEventArgs argsIn)
{
var newData = new List <Dto>(argsIn.EntriesAmount);
using (var package = new ExcelPackage(argsIn.SourceStream))
{
var worksheet = package.Workbook.Worksheets.First();
for (var row = worksheet.Dimension.Start.Row + 1; row <= worksheet.Dimension.End.Row; row++)
{
newData.Add(new BookDto
{
Name = GetSimple <string>(worksheet.Cells[row, argsIn.SourceMap["name"]].Value),
Isbn = GetSimple <string>(worksheet.Cells[row, argsIn.SourceMap["isbn"]].Value),
Pages = GetSimple <int>(worksheet.Cells[row, argsIn.SourceMap["pages"]].Value),
LimitedEdition = GetSimple <bool>(worksheet.Cells[row, argsIn.SourceMap["limitededition"]].Value),
WrittenIn = GetSimple <DateTime>(worksheet.Cells[row, argsIn.SourceMap["writtenin"]].Text),
Library = GetDto <LibraryDto>(dto => dto.Id == 1), // only one library is present for now (newItem.Library.Id)
Authors = GetCollection <AuthorDto>(worksheet.Cells[row, argsIn.SourceMap["authors"]].Value),
Genres = GetCollection <GenreDto>(worksheet.Cells[row, argsIn.SourceMap["genres"]].Value)
});
}
}
var argsOut = new ExtractionEventArgs
{
ExtractedData = newData
};
ExtractionPassed?.Invoke(this, argsOut);
}
public override void Extract(object sender, ExtractionEventArgs e)
{
string tokenName = "";
object contextValue;
if (e.Request.Body != null)
{
var json = e.Request.Body;
StringHttpBody httpBody = e.Request.Body as StringHttpBody;
if (httpBody == null)
{
return;
}
string body = httpBody.BodyString;
var data = JObject.Parse(body);
var value = "";
if (data != null)
{
if (e.WebTest.Context.TryGetValue(this.ContextParameterName, out contextValue))
{
tokenName = "Matter." + this.ContextParameterName;
value = (data.SelectToken(tokenName) ?? JValue.CreateNull()).ToObject <string>();
e.WebTest.Context.Add(this.ContextParameterName, value);
}
e.Success = true;
return;
}
}
e.Success = false;
e.Message = String.Format(CultureInfo.CurrentCulture, "Not Found: {0}", tokenName);
}
public override void Extract(object sender, ExtractionEventArgs e)
{
var jsonString = e.Response.BodyString;
var json = JObject.Parse(jsonString);
JToken jToken = null;
if (json == null)
{
e.Success = false;
e.Message = "Response received not in JSON format";
}
else
{
jToken = json.SelectToken(Token);
if (jToken == null)
{
e.Success = false;
e.Message = String.Format("{0} : Not found", Token);
}
else
{
e.Success = true;
e.WebTest.Context.Add(this.ContextParameterName, jToken);
}
}
}
public override void Extract(object sender, ExtractionEventArgs e)
{
string sourceValue = e.WebTest.Context[this.inputContextParameter].ToString();
System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(this.regexText);
//this option is potentially expensive from a computational standpoint.
if (this.pickRandomMatch)
{
System.Text.RegularExpressions.MatchCollection matches = regex.Matches(sourceValue);
int matchcount = matches.Count;
if (matchcount > 0)
{
AddToContext(e, matches[randomNumber.Next(0, matchcount)].Value);
}
else
{
throw new ArgumentException("Could not find regex in existing context parameter " + this.inputContextParameter);
}
}
//this option is cheaper.
else
{
System.Text.RegularExpressions.Match match = regex.Match(sourceValue);
if (match.Success)
{
AddToContext(e, match.Value);
}
else
{
throw new ArgumentException("Could not find regex in existing context parameter " + this.inputContextParameter);
}
}
}
public override void Extract(object sender, ExtractionEventArgs e)
{
string body = e.Response.BodyString;
List<string> formElements = new List<string>();
var processMatches = new Action<MatchCollection, string>((extractMatches, prefix) =>
{
foreach (Match extractMatch in extractMatches)
{
string name = extractMatch.Groups["name"].Value;
string value = extractMatch.Groups["value"].Value;
string lastPartOfName = name.Substring(name.LastIndexOf('$') + 1);
string keyName = RuleHelper.PlaceUniqueItem(e.WebTest.Context, prefix + lastPartOfName, name);
e.WebTest.Context[keyName + VALUE_SUFFIX] = value;
// Create a name value pair in context as it is using the form element's name
e.WebTest.Context[name] = value;
formElements.Add(name);
}
});
processMatches(_FindInputTags.Matches(body), INPUT_PREFIX);
foreach (Match match in _FindSelectTags.Matches(body))
{
var extractMatches = _ExtractSelectTags.Matches(match.Value);
processMatches(extractMatches, SELECT_PREFIX);
}
e.WebTest.Context[FORM_ELEMENT_KEYS] = formElements.ToArray();
}
public override void Extract(object sender, ExtractionEventArgs e)
{
string oldValue = e.WebTest.Context[this.ContextParameterName].ToString();
string newValue = oldValue.Replace(this.textToFind, this.replacementText);
e.WebTest.Context[this.ContextParameterName] = newValue;
}
public override void Extract(object sender, ExtractionEventArgs e)
{
string sourceValue = e.WebTest.Context[this.inputContextParameter].ToString();
int startIndex = sourceValue.IndexOf(this.textBefore) + this.textBefore.Length;
int endIndex = sourceValue.IndexOf(this.textAfter, startIndex);
if (endIndex > startIndex)
{
string extractedSubstring = sourceValue.Substring(startIndex, (endIndex - startIndex));
if (e.WebTest.Context.ContainsKey(this.ContextParameterName))
{
e.WebTest.Context[this.ContextParameterName] = extractedSubstring;
}
else
{
e.WebTest.Context.Add(this.ContextParameterName, extractedSubstring);
}
}
else
{
throw new ArgumentException("Cannot find expected substrings in existing context parameter " + this.inputContextParameter);
}
}
public override void Extract(object sender, ExtractionEventArgs e)
{
if (null == e.Response) {
e.Success = false;
e.Message = String.Format("Response was null");
return;
}
if (String.IsNullOrEmpty(e.Response.BodyString)) {
e.Success = false;
e.Message = String.Format("Response body was empty");
return;
}
var d = JObject.Parse(e.Response.BodyString);
if (null == d) {
e.Success = false;
e.Message = String.Format("Could not parse response");
return;
}
if (null == d[JsonProperty]) {
e.Success = false;
e.Message = String.Format(CultureInfo.CurrentCulture, "Property with name: {0} not found", JsonProperty);
return;
}
e.WebTest.Context.Add(ContextParameterName, d[JsonProperty]);
}
/// <summary>
/// Extract a JSON value from the response.
/// </summary>
public override void Extract(object sender, ExtractionEventArgs e)
{
JObject o = null;
var jsonBody = JsonConvert.DeserializeObject(e.Response.BodyString);
if (jsonBody.GetType() == typeof(JArray))
{
var a = JArray.FromObject(jsonBody);
o = (JObject)a.FirstOrDefault();
}
else
{
o = JObject.FromObject(jsonBody);
}
string value = (string)o.SelectToken(JSonPropertyName);
if (!string.IsNullOrWhiteSpace(value))
{
e.WebTest.Context.Add(ContextParameterName, value);
e.Message = $"Property '{JSonPropertyName}' has the value '{value}'";
e.Success = true;
}
else
{
e.Message = $"Property '{JSonPropertyName}' not found in response";
e.Success = false;
}
}
public override void Extract(object sender, ExtractionEventArgs e)
{
if (String.IsNullOrWhiteSpace(LabelId) == true)
{
Fail(e, "The label id value is invalid.");
}
else
{
HtmlTagInnerTextParser parser =
new HtmlTagInnerTextParser(e.Response.BodyString);
var match =
parser.GetInnerTextForHtmlTags(
"span", "id", LabelId, true, true, true).FirstOrDefault();
if (match == null)
{
Fail(e,
String.Format(
"Could not find a label with the Id of '{0}'.", LabelId));
}
else
{
e.WebTest.Context.Add(ContextParameterName, match.Value);
e.Success = true;
}
}
}
protected virtual void OnExtractionProgress(object sender, ExtractionEventArgs e)
{
var handler = ExtractionProgress;
if (handler != null)
{
handler(this, e);
}
}
public void Import(object sender, ExtractionEventArgs args)
{
var extractedBooks = args.ExtractedData.Cast <BookDto>().ToList();
var repository = _unitOfWork.GetRepository <BookDto>();
repository.InsertMultiple(extractedBooks.ToArray());
_unitOfWork.Save();
}
public override void Extract(Object sender, ExtractionEventArgs e)
{
foreach (var param in e.Request.QueryStringParameters)
{
if (param.Name != Name)
continue;
e.WebTest.Context.Add(ContextParameterName, param.Value);
break;
}
}
private void AddToContext(ExtractionEventArgs e, string value)
{
if (e.WebTest.Context.ContainsKey(this.ContextParameterName))
{
e.WebTest.Context[this.ContextParameterName] = value;
}
else
{
e.WebTest.Context.Add(this.ContextParameterName, value);
}
}
/// <summary>
/// Extracts the UpdatePanel Client ID which contains the specified Control. If the
/// Control is inside an UpdatePanel, then it returns the UpdatePanel Client ID, otherwise
/// it returns empty.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public override void Extract(object sender, ExtractionEventArgs e)
{
string body = e.Response.BodyString;
// Look for the doPostback('ControlID')
string lookingFor = "__doPostBack('" + this.ControlID + "'";
int controlPos = body.IndexOf(lookingFor);
if (controlPos == -1)
{
throw new ApplicationException("Cannot find in html: " + lookingFor);
}
// Find the nearest UpdatePanel
ExtractUpdatePanels.ExtractUpdatePanelNamesFromHtml(e.Response.BodyString, e.WebTest.Context);
int updatePanelCount = (int)e.WebTest.Context[ExtractUpdatePanels.UPDATE_PANEL_COUNT_KEY];
int minDistance = int.MaxValue;
string closestUpdatePanel = string.Empty;
for (int i = 1; i < updatePanelCount; i++)
{
string updatePanelKeyName = ExtractUpdatePanels.UPDATE_PANEL_PREFIX + i + ExtractUpdatePanels.UPDATE_PANEL_POS_KEY;
int updatePanelPos = (int)e.WebTest.Context[updatePanelKeyName];
// UpdatePanel must start before the control
if (updatePanelPos < controlPos)
{
int distance = controlPos - updatePanelPos;
if (distance <= minDistance)
{
minDistance = distance;
// Get the ID of the update panel
closestUpdatePanel = e.WebTest.Context[ExtractUpdatePanels.UPDATE_PANEL_PREFIX + i] as string;
}
}
}
if (!string.IsNullOrEmpty(closestUpdatePanel))
{
e.WebTest.Context[this.ContextParameterName] = closestUpdatePanel;
}
else
{
if (Required)
{
throw new ApplicationException(string.Format("UpdatePanel not found for Control ID: {0}", this.ControlID));
}
else
{
e.WebTest.Context[this.ContextParameterName] = string.Empty;
}
}
}
private void OnNotifyProgress(object sender, ExtractionEventArgs eventArgs)
{
if (eventArgs.Status == ExtractionStatus.Succeeded)
{
this.extractionSuccessCount += 1;
}
var extractor = (IDataExtractor)sender;
string message = string.Format("{0} [{1}]: {2}", extractor.Name, eventArgs.Status, eventArgs.Message);
Log.Debug(message);
}
public override void Extract(object sender, ExtractionEventArgs e)
{
string body = e.Response.BodyString;
if (e.Response.ContentType.Contains("text/html"))
{
ExtractUpdatePanelNamesFromHtml(body, e.WebTest.Context);
}
else // if (e.Response.ContentType.Contains("text/plain"))
{
ExtractUpdatePanelNamesFromAsyncPostback(body, e.WebTest.Context);
}
}
/// <summary>
/// When overridden in a derived class, this extracts information from both the request and response into the NetTestContext for the running test.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public virtual void Extract(Object sender, ExtractionEventArgs e)
{
HtmlAgilityPack.HtmlDocument document = new HtmlAgilityPack.HtmlDocument();
document.LoadHtml(((WebTestRequest)e.WebTestItem).HttpResponseBody);
document.OptionOutputAsXml = true;
using (StringWriter writer = new StringWriter())
{
document.Save(writer);
_document = XDocument.Parse(writer.GetStringBuilder().ToString());
}
}
public override void Extract(object sender, ExtractionEventArgs e)
{
var jss = new JavaScriptSerializer();
dynamic data = jss.Deserialize<dynamic>(e.Response.BodyString);
if (data != null && data[PropertyName] != null)
{
e.WebTest.Context.Add(ContextParameterName, data[PropertyName]);
e.Success = true;
}
else
e.Success = false;
}
private void addContextParameters(Match m, string name, ExtractionEventArgs e)
{
if (m.Groups.Count > 2)
{
for (int g = 1; g < m.Groups.Count; g++)
{
e.WebTest.Context.Add(name + "_g" + g, m.Groups[g].Value);
}
}
else
{
e.WebTest.Context.Add(name, m.Groups[1].Value);
}
}
public override void Extract(object sender, ExtractionEventArgs e)
{
JsonExtractionRule msgIdExtractionRule =
new JsonExtractionRule()
{
ContextParameterName = this.ContextParameterName, Name = ParamToExtract
};
msgIdExtractionRule.Extract(sender, e);
WebTestContext context = e.WebTest.Context;
try
{
if (context.ContainsKey(Constants.Context_MessageId) &&
context.ContainsKey(Constants.Context_UserActivity))
{
string jsonInput = context[Constants.Context_UserActivity].ToString();
Activity activity = JsonConvert.DeserializeObject <Activity>(jsonInput);
activity.Conversation =
new ConversationAccount()
{
Id = context[Constants.Context_ConvId].ToString()
};
activity.Id = context[Constants.Context_MessageId].ToString();
context[Constants.Context_UserActivity] = JsonConvert.SerializeObject(activity);
int waterMark = int.Parse(context[Constants.Context_MessageId].ToString().Split('|')[1]);
if (waterMark > 1)
{
waterMark--;
}
context[Constants.Context_Watermark] = $"/{waterMark}";
e.Success = true;
}
else
{
e.Success = false;
e.Message = "Message Id or User Activity not found";
}
}
catch
{
e.Success = false;
}
}
private void Clear(ExtractionEventArgs e)
{
int currentSize = 0;
if (e.WebTest.Context.ContainsKey(this.ContextParameterName))
{
currentSize = int.Parse(e.WebTest.Context[this.ContextParameterName].ToString());
}
for (int i = 1; i <= currentSize; i++)
{
e.WebTest.Context.Remove(this.ContextParameterName + "_NAME_" + i);
e.WebTest.Context.Remove(this.ContextParameterName + "_VALUE_" + i);
}
e.WebTest.Context.Remove(this.ContextParameterName);
}
public override void Extract(object sender, ExtractionEventArgs e)
{
var success = false;
try
{
var responseJObject = JToken.Parse(e.Response.BodyString);
var jToken = responseJObject.SelectToken(JsonPath);
e.WebTest.Context.Add(ContextParameterName, jToken.Value <string>());
success = true;
}
catch (Exception exception)
{
e.Message = $"Error extracting Json path: ({JsonPath}) from response body. {exception.Message}";
}
e.Success = success;
}
public override void Extract(object sender, ExtractionEventArgs e)
{
if (e.Response.BodyString != null)
{
var json = e.Response.BodyString;
var data = JObject.Parse(json);
if (data != null)
{
e.WebTest.Context.Add(ContextParameterName, data.SelectToken(Name));
e.Success = true;
return;
}
}
e.Success = false;
e.Message = String.Format(CultureInfo.CurrentCulture, "property not found: {0}", Name);
}
/// <summary>
/// Extracts the UpdatePanel Client ID which contains the specified Control. If the
/// Control is inside an UpdatePanel, then it returns the UpdatePanel Client ID, otherwise
/// it returns empty.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public override void Extract(object sender, ExtractionEventArgs e)
{
string body = e.Response.BodyString;
// Look for the doPostback('ControlID')
string lookingFor = "__doPostBack('" + this.ControlID + "'";
int controlPos = body.IndexOf(lookingFor);
if (controlPos == -1)
throw new ApplicationException("Cannot find in html: " + lookingFor);
// Find the nearest UpdatePanel
ExtractUpdatePanels.ExtractUpdatePanelNamesFromHtml(e.Response.BodyString, e.WebTest.Context);
int updatePanelCount = (int)e.WebTest.Context[ExtractUpdatePanels.UPDATE_PANEL_COUNT_KEY];
int minDistance = int.MaxValue;
string closestUpdatePanel = string.Empty;
for (int i = 1; i < updatePanelCount; i++)
{
string updatePanelKeyName = ExtractUpdatePanels.UPDATE_PANEL_PREFIX + i + ExtractUpdatePanels.UPDATE_PANEL_POS_KEY;
int updatePanelPos = (int)e.WebTest.Context[updatePanelKeyName];
// UpdatePanel must start before the control
if (updatePanelPos < controlPos)
{
int distance = controlPos - updatePanelPos;
if (distance <= minDistance)
{
minDistance = distance;
// Get the ID of the update panel
closestUpdatePanel = e.WebTest.Context[ExtractUpdatePanels.UPDATE_PANEL_PREFIX + i] as string;
}
}
}
if (!string.IsNullOrEmpty(closestUpdatePanel))
{
e.WebTest.Context[this.ContextParameterName] = closestUpdatePanel;
}
else
{
if (Required)
throw new ApplicationException(string.Format("UpdatePanel not found for Control ID: {0}", this.ControlID));
else
e.WebTest.Context[this.ContextParameterName] = string.Empty;
}
}
public override void Extract(object sender, ExtractionEventArgs e)
{
Regex exp = new Regex(this.Expression);
MatchCollection matches = exp.Matches(e.Response.BodyString);
Action <Match, string> storeMatch = new Action <Match, string>((match, keyName) =>
{
if (string.IsNullOrEmpty(this.GroupName))
{
Group group = match.Groups[this.GroupIndex];
e.WebTest.Context[keyName] = group.Value;
}
else
{
Group group = match.Groups[this.GroupName];
e.WebTest.Context[keyName] = group.Value;
}
});
if (!this.MatchAll)
{
if (this.MatchIndex < matches.Count)
{
Match match = matches[MatchIndex];
storeMatch(match, this.ContextParameterName);
}
else
{
e.Message = "Match index is higher than matches found or no match found";
e.Success = false;
}
}
else
{
int counter = 1;
foreach (Match match in matches)
{
storeMatch(match, this.ContextParameterName + "." + (counter++));
}
e.WebTest.Context[this.ContextParameterName + ".$COUNT"] = counter;
}
}
public override void Extract(object sender, ExtractionEventArgs e)
{
Regex exp = new Regex(this.Expression);
MatchCollection matches = exp.Matches(e.Response.BodyString);
Action<Match, string> storeMatch = new Action<Match, string>((match, keyName) =>
{
if (string.IsNullOrEmpty(this.GroupName))
{
Group group = match.Groups[this.GroupIndex];
e.WebTest.Context[keyName] = group.Value;
}
else
{
Group group = match.Groups[this.GroupName];
e.WebTest.Context[keyName] = group.Value;
}
});
if (!this.MatchAll)
{
if (this.MatchIndex < matches.Count)
{
Match match = matches[MatchIndex];
storeMatch(match, this.ContextParameterName);
}
else
{
e.Message = "Match index is higher than matches found or no match found";
e.Success = false;
}
}
else
{
int counter = 1;
foreach (Match match in matches)
{
storeMatch(match, this.ContextParameterName + "." + (counter++));
}
e.WebTest.Context[this.ContextParameterName + ".$COUNT"] = counter;
}
}
public override void Extract(object sender, ExtractionEventArgs e)
{
string response = e.Response.BodyString;
Regex rxSelect = new Regex("<select[^>]+[name|id]=\"" + _SelectName + "\"[^>]*>([\\s\\S]+?<\\/select>)");
if (!_ExcludeOption.Equals(""))
{
_ExcludeOption = "(?!" + _ExcludeOption + ")";
}
Regex rxOption = new Regex("<option[^>]+value=\"" + _ExcludeOption + "([^\"]+)");
if (IncludeEmpty)
{
rxOption = new Regex("<option[^>]+value=\"" + _ExcludeOption + "([^\"]*)");
}
MatchCollection select = rxSelect.Matches(response);
if (select.Count == 0)
{
e.Success = false;
e.Message = String.Format(CultureInfo.CurrentCulture, "Select \"{0}\" Not Found.", _SelectName);
return;
}
MatchCollection options = rxOption.Matches(select[0].Value);
if (options.Count == 0)
{
e.Success = false;
e.Message = String.Format(CultureInfo.CurrentCulture, "No Valid Options On Select \"{0}\".", _SelectName);
return;
}
Random rd = new Random();
string rdOption = options[rd.Next(options.Count)].Groups[1].Value;
e.WebTest.Context[ContextParameterName] = rdOption;
e.Success = true;
}
/// <summary>
/// The Extract method.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The parameter e contains the web performance test context. </param>
public override void Extract(object sender, ExtractionEventArgs e)
{
if (string.IsNullOrEmpty(CookieName))
{
throw new ArgumentException("Error --> CookieName cannot be null or empty.");
}
if (e.Response.Cookies != null)
{
Cookie cookie = e.Response.Cookies[CookieName];
if (cookie != null)
{
e.WebTest.Context[this.ContextParameterName] = cookie.Value;
e.Success = true;
return;
}
}
// If the extraction fails, set the error text that the user sees
e.Success = false;
e.Message = String.Format(CultureInfo.CurrentCulture, "Cookie Not Found: {0}", CookieName);
}
public override void Extract(object sender, ExtractionEventArgs e)
{
if (e.Request.HasQueryStringParameters)
{
foreach (QueryStringParameter parameter in e.Request.QueryStringParameters)
{
if (parameter.Name.Equals(ParameterName, StringComparison.CurrentCultureIgnoreCase))
{
if (parameter.Value != null)
{
e.Success = true;
e.Message = String.Format("Paramter Found with Value {0}", ParameterName);
}
return;
}
e.Success = false;
e.Message = String.Format("Paramter {0} not Found ", ParameterName);
}
}
e.Success = false;
e.Message = String.Format("Paramter {0} not Found ", ParameterName);
}
public override void Extract(object sender, ExtractionEventArgs e)
{
try
{
e.Success = true;
if (e.Response.BodyString != null)
{
e.WebTest.Context.Add(Constants.Context_BotResponseReceived, "false");
var json = e.Response.BodyString;
if (!string.IsNullOrEmpty(json))
{
var data = JObject.Parse(json);
if (data != null)
{
var v = data.SelectToken(Name);
e.WebTest.Context.Add(this.ContextParameterName, v);
return;
}
}
}
e.Message = String.Format(CultureInfo.CurrentCulture, "Not Found: {0}", Name);
}
catch (Exception ex)
{
e.Success = false;
e.WebTest.Context[Constants.Context_ConvId] = e.WebTest.Context.ContainsKey(Constants.Context_ConvId)
? e.WebTest.Context[Constants.Context_ConvId].ToString()
: $"ConvIdNotFound-{Guid.NewGuid()}";
e.WebTest.Context[Constants.Context_TestStatus] = false;
e.WebTest.Context[Constants.Context_TestStatusMessage] = ex.Message;
e.Message = ex.Message;
}
}
void Request_ExtractValues(object sender, ExtractionEventArgs e)
{
RuleHelper.WhenAspNetResponse(e.Response, () =>
{
RuleHelper.NotAlreadyExtracted <ExtractHiddenFields>(e.Request.ExtractionRuleReferences, () =>
{
// Extract all hidden fields so that they can be used in next async/sync postback
// Hidden fields like __EVENTVALIDATION, __VIEWSTATE changes after every async/sync
// postback. So, these fields need to be kept up-to-date to make subsequent async/sync
// postback
var extractionRule = new ExtractHiddenFields();
extractionRule.Required = true;
extractionRule.HtmlDecode = true;
extractionRule.ContextParameterName = "1";
extractionRule.Extract(sender, e);
});
// Extract all INPUT/SELECT elements so that they can be posted in (async)postback
RuleHelper.NotAlreadyExtracted <ExtractFormElements>(e.Request.ExtractionRuleReferences, () =>
{
new ExtractFormElements().Extract(sender, e);
});
// Extract all __doPostBack(...) so that the ID of the control can be used to make async
// postbacks
RuleHelper.NotAlreadyExtracted <ExtractPostbackNames>(e.Request.ExtractionRuleReferences, () =>
{
new ExtractPostbackNames().Extract(sender, e);
});
// Extract all updatepanels so that during async postback, the updatepanel name can be derived
RuleHelper.NotAlreadyExtracted <ExtractUpdatePanels>(e.Request.ExtractionRuleReferences, () =>
{
new ExtractUpdatePanels().Extract(sender, e);
});
});
}
void Request_ExtractValues(object sender, ExtractionEventArgs e)
{
RuleHelper.WhenAspNetResponse(e.Response, () =>
{
RuleHelper.NotAlreadyExtracted<ExtractHiddenFields>(e.Request.ExtractionRuleReferences, () =>
{
// Extract all hidden fields so that they can be used in next async/sync postback
// Hidden fields like __EVENTVALIDATION, __VIEWSTATE changes after every async/sync
// postback. So, these fields need to be kept up-to-date to make subsequent async/sync
// postback
var extractionRule = new ExtractHiddenFields();
extractionRule.Required = true;
extractionRule.HtmlDecode = true;
extractionRule.ContextParameterName = "1";
extractionRule.Extract(sender, e);
});
// Extract all INPUT/SELECT elements so that they can be posted in (async)postback
RuleHelper.NotAlreadyExtracted<ExtractFormElements>(e.Request.ExtractionRuleReferences, () =>
{
new ExtractFormElements().Extract(sender, e);
});
// Extract all __doPostBack(...) so that the ID of the control can be used to make async
// postbacks
RuleHelper.NotAlreadyExtracted<ExtractPostbackNames>(e.Request.ExtractionRuleReferences, () =>
{
new ExtractPostbackNames().Extract(sender, e);
});
// Extract all updatepanels so that during async postback, the updatepanel name can be derived
RuleHelper.NotAlreadyExtracted<ExtractUpdatePanels>(e.Request.ExtractionRuleReferences, () =>
{
new ExtractUpdatePanels().Extract(sender, e);
});
});
}
public override void Extract(object sender, ExtractionEventArgs e)
{
var jsonString = e.Response.BodyString;
var json = JObject.Parse(jsonString);
JToken jToken = null;
if (json == null)
{
e.Success = false;
e.Message = "Response received not in JSON format";
}
else
{
jToken = json.SelectToken(Token);
if (jToken == null){
e.Success = false;
e.Message = String.Format("{0} : Not found", Token);
}
else
{
e.Success = true;
e.WebTest.Context.Add(this.ContextParameterName, jToken);
}
}
}
public override void Extract(object sender, ExtractionEventArgs e)
{
if (null == e.Response) {
e.Success = false;
e.Message = String.Format("Response was null");
return;
}
if (e.Response.Cookies.Count == 0 ) {
e.Success = false;
e.Message = String.Format("No Cookies were found");
return;
}
var c = e.Response.Cookies[CookieName];
if (null == c) {
e.Success = false;
e.Message = String.Format(CultureInfo.CurrentCulture, "Cookie with name: {0} was not found", CookieName);
return;
}
e.WebTest.Context.Add(ContextParameterName, c.Value);
}
static void manager_Extracted(object sender, ExtractionEventArgs e)
{
Console.WriteLine("extraction completed");
}
public override void Extract(object sender, ExtractionEventArgs e)
{
string body = e.Response.BodyString;
if (e.Response.ContentType.Contains("text/html"))
ExtractUpdatePanelNamesFromHtml(body, e.WebTest.Context);
else // if (e.Response.ContentType.Contains("text/plain"))
ExtractUpdatePanelNamesFromAsyncPostback(body, e.WebTest.Context);
}
public override void Extract(object sender, ExtractionEventArgs e)
{
string bodyHtml = e.Response.BodyString;
ExtractPostBackNames(bodyHtml, e.WebTest.Context);
}
private void Fail(ExtractionEventArgs e, string message)
{
e.Success = false;
e.Message = message;
}
private void ManagerExtracted(object sender, ExtractionEventArgs e)
{
logger.Log("extraction completed");
}
public override void Extract(object sender, ExtractionEventArgs e)
{
object obj = JSON.JsonDecode(e.Response.BodyString);
ProcessObject(obj, this.ContextParameterName, e.WebTest.Context);
}
