/// <summary>
/// Fills the error message and returns the ResponseBuffer.
/// </summary>
/// <param name="errorMessage"> An error message explaining the cause of error.</param>
/// <param name="httpState"> The HTTP State</param>
/// <returns> A ResponseBuffer type.</returns>
internal static ResponseBuffer FillErrorBuffer(string errorMessage, HttpState httpState)
{
//StringBuilder textStream = new StringBuilder();
ResponseBuffer respBuffer = new ResponseBuffer();
respBuffer.ErrorMessage = errorMessage;
return respBuffer;
}
/// <summary>
/// Creates a new InspectorPipelineCommand.
/// </summary>
/// <param name="clientSettings"> The HTTP Properties.</param>
/// <param name="proxySettings"> The HTTP Proxy settings.</param>
/// <param name="httpState"> The HTTP State.</param>
/// <param name="callback"> The callback method.</param>
public InspectorPipelineCommand(HttpProperties clientSettings, HttpProxy proxySettings, HttpState httpState, Delegate callback)
{
Initialize();
inspectorPipeline.ClientSettings = clientSettings;
inspectorPipeline.ProxySettings = proxySettings;
HttpStateData = httpState;
CallbackMethod = callback;
}
/// <summary>
/// Fills the ResponseBuffer.
/// </summary>
/// <param name="response"> The HttpWebResponse type.</param>
/// <param name="hwr"> The HttpWebRequest type.</param>
/// <param name="clientSettings"> The http settings.</param>
/// <param name="httpState"> The Http state.</param>
/// <returns> A ResponseBuffer type.</returns>
internal static ResponseBuffer FillResponseBuffer(HttpWebResponse response, HttpWebRequest hwr, HttpProperties clientSettings, HttpState httpState)
{
ResponseBuffer respBuffer = null;
if ( CompareString.Compare(hwr.Method,"get") )
{
respBuffer = new ResponseBuffer(HttpRequestType.GET);
}
else
{
respBuffer = new ResponseBuffer(HttpRequestType.POST);
}
respBuffer.StatusCode = (int)response.StatusCode;
respBuffer.StatusDescription=response.StatusDescription;
if ( response.ProtocolVersion == HttpVersion.Version11 )
{
respBuffer.Version="1.1";
}
else
{
respBuffer.Version="1.0";
}
// Request Header Collection
BufferBuilder.FillRequestHeader(respBuffer,hwr.Headers,hwr);
// Header Collection
BufferBuilder.FillResponseHeader(respBuffer,hwr,response.Headers,response);
// Cookie collection
response.Cookies = hwr.CookieContainer.GetCookies(hwr.RequestUri);
BufferBuilder.FillCookieData(respBuffer,response.Cookies);
Stream stm = response.GetResponseStream();
BufferBuilder.FillHttpBody(respBuffer,stm);
stm.Close();
if ( response!=null )
{
response.Close();
}
return respBuffer;
}
/// <summary>
/// Begins a new asynchronous HTTP Get request.\r\nThis function is not thread safe.
/// </summary>
/// <param name="uri"> An uri to request.</param>
public void StartAsyncHttpGet(string uri)
{
httpRequestState = new HttpState();
uri = EncodeDecode.UrlDecode(uri);
uri = EncodeDecode.HtmlDecode(uri);
try
{
//this.ValidateIPAddress(new Uri(uri));
// Set HttpWebRequestProperties
//SetHttpWebRequestProperties(hwr, properties);
httpRequestState.HttpRequest = (HttpWebRequest)WebRequest.Create(uri);
// Continue headers
//hwr.ContinueDelegate=getRedirectHeaders;
// new CookieContainer
httpRequestState.HttpRequest.CookieContainer = new CookieContainer();
//httpRequestState.httpRequest.Referer = uri;
IAsyncResult ar = httpRequestState.HttpRequest.BeginGetResponse(new AsyncCallback(FastResponseCallback),httpRequestState);
// register a timeout
ThreadPool.RegisterWaitForSingleObject(ar.AsyncWaitHandle, new WaitOrTimerCallback(BaseHttpForm.RequestTimeoutCallback), httpRequestState, this.GetTimeout(), true);
}
catch
{
throw;
}
finally
{
if ( httpRequestState.HttpResponse != null )
{
httpRequestState.HttpResponse.Close();
}
}
}
/// <summary>
/// Begins a new asynchronous HTTP Get request. This function is not thread safe.
/// </summary>
/// <param name="uri"> An uri to request.</param>
/// <param name="properties"> The HttpProperties to set for the request.</param>
/// <param name="values"> The values to include for a GET request.</param>
/// <param name="cookies"> The cookies to set for the request.</param>
/// <param name="httpRequestState"> The HttpState.</param>
public ResponseBuffer StartSyncHttpGet(string uri, HttpProperties properties, ArrayList values, CookieCollection cookies, HttpState httpRequestState)
{
uri = EncodeDecode.UrlDecode(uri);
uri = EncodeDecode.HtmlDecode(uri);
try
{
//this.ValidateIPAddress(new Uri(uri));
if ( values != null )
uri = AppendToUri(uri,values);
httpRequestState.HttpRequest = (HttpWebRequest)WebRequest.Create(uri);
// Set HttpWebRequestProperties
SetHttpWebRequestProperties(httpRequestState.HttpRequest, properties);
// Apply proxy settings
if ( this.ProxySettings != null )
{
SetProxy(httpRequestState.HttpRequest,this.ProxySettings);
}
// save cookies
httpRequestState.HttpRequest.CookieContainer=new CookieContainer();
if ( cookies!=null )
{
httpRequestState.HttpRequest.CookieContainer.Add(cookies);
}
HttpWebResponse httpResponse = (HttpWebResponse)httpRequestState.HttpRequest.GetResponse();
httpRequestState.HttpResponse = httpResponse;
// get ResponseBuffer
ResponseBuffer responseBuffer = HttpPipeline.FillResponseBuffer(httpResponse,
httpRequestState.HttpRequest,
properties,
httpRequestState);
return responseBuffer;
}
catch
{
throw;
}
finally
{
if ( httpRequestState.HttpResponse != null )
{
httpRequestState.HttpResponse.Close();
}
}
}
/// <summary>
/// Get Async post request.
/// </summary>
/// <param name="postUrl"> The url to post.</param>
/// <param name="listValues"> The post data values.</param>
/// <param name="cookies"> The cookies.</param>
/// <param name="state"> The http state.</param>
private void StartPostRequest(PostForm httpCommand, string postUrl, ArrayList listValues, CookieCollection cookies,HttpProperties settings, HttpState state)
{
try
{
httpCommand.StartAsyncHttpPost(
postUrl,
settings,
listValues,
cookies, state);
}
catch (Exception ex)
{
// register and show
ExceptionHandler.RegisterException(ex);
AbortSessionRun(ex.Message);
}
}
/// <summary>
/// Begins a new asynchronous HTTP Get request. This function is not thread safe.
/// </summary>
/// <param name="uri"> An uri to request.</param>
/// <param name="properties"> The HttpProperties to set for the request.</param>
/// <param name="values"> The values to include for a GET request.</param>
/// <param name="cookies"> The cookies to set for the request.</param>
/// <param name="httpRequestState"> Sets the Http State type.</param>
/// <param name="doDecode"> Decodes the uri with Url and Html.</param>
public void StartAsyncHttpGet(string uri, HttpProperties properties, ArrayList values, CookieCollection cookies, HttpState httpRequestState, bool doDecode)
{
if ( doDecode )
{
uri = EncodeDecode.UrlDecode(uri);
uri = EncodeDecode.HtmlDecode(uri);
}
try
{
//this.ValidateIPAddress(new Uri(uri));
if ( values != null )
{
uri = AppendToUri(uri,values);
}
httpRequestState.HttpRequest = (HttpWebRequest)WebRequest.Create(uri);
// Set HttpWebRequestProperties
SetHttpWebRequestProperties(httpRequestState.HttpRequest, properties);
// Apply proxy settings
if ( this.ProxySettings != null )
{
SetProxy(httpRequestState.HttpRequest,this.ProxySettings);
}
// Continue headers
//hwr.ContinueDelegate=getRedirectHeaders;
// save cookies
httpRequestState.HttpRequest.CookieContainer=new CookieContainer();
if ( cookies!=null )
{
httpRequestState.HttpRequest.CookieContainer.Add(cookies);
}
//httpRequestState.httpRequest.Referer = uri;
IAsyncResult ar = httpRequestState.HttpRequest.BeginGetResponse(new AsyncCallback(FastResponseCallback),httpRequestState);
// register a timeout
ThreadPool.RegisterWaitForSingleObject(ar.AsyncWaitHandle, new WaitOrTimerCallback(BaseHttpForm.RequestTimeoutCallback), httpRequestState, this.GetTimeout(), true);
}
catch
{
throw;
}
finally
{
if ( httpRequestState.HttpResponse != null )
{
httpRequestState.HttpResponse.Close();
}
}
}
/// <summary>
/// Begins a new asynchronous HTTP Post request. This function is not thread safe.
/// </summary>
/// <param name="context"> The HttpRequestResponseContext type.</param>
public void StartAsyncHttpPostFileUpload(Ecyware.GreenBlue.Engine.Scripting.HttpRequestResponseContext context)
{
Ecyware.GreenBlue.Engine.Scripting.PostWebRequest postWebRequest = (Ecyware.GreenBlue.Engine.Scripting.PostWebRequest)context.Request;
HtmlFormTag formTag = postWebRequest.Form.WriteHtmlFormTag();
UploadFileInfo[] fileInfoItems = UploadFileInfo.GetUploadFiles(formTag);
HtmlParser parser = new HtmlParser();
httpRequestState = new HttpState();
string uriString = context.Request.Url;
if ( context.DecodeUrl )
{
uriString = EncodeDecode.UrlDecode(uriString);
}
// create webrequest
try
{
httpRequestState.HttpRequest = (HttpWebRequest)System.Net.WebRequest.Create(uriString);
// Set HttpWebRequestProperties
SetHttpWebRequestProperties(httpRequestState.HttpRequest, context.Request.RequestHttpSettings);
// Apply proxy settings
if ( this.ProxySettings != null )
{
SetProxy(httpRequestState.HttpRequest,this.ProxySettings);
}
// Save cookies
httpRequestState.HttpRequest.CookieContainer = new CookieContainer();
if ( context.Request.Cookies != null )
{
httpRequestState.HttpRequest.CookieContainer.Add(context.Request.GetCookieCollection());
}
#region Post Data
string boundary = "--------------" + DateTime.Now.Ticks.ToString("x");
byte[] data = null;
// Build the trailing boundary string as a byte array
// ensuring the boundary appears on a line by itself
byte[] boundaryBytes = null;
long sumFileLength = 0;
foreach ( UploadFileInfo uploadFile in fileInfoItems )
{
FileInfo fileInformation = new FileInfo(uploadFile.FileName);
sumFileLength += fileInformation.Length;
}
string postdata = GenerateMimeFormData(boundary, formTag, fileInfoItems);
data = Encoding.UTF8.GetBytes(postdata);
long length;
if ( fileInfoItems.Length == 0 )
{
boundaryBytes = Encoding.ASCII.GetBytes("--" + boundary + "--\r\n\0");
length = data.Length + sumFileLength +
boundaryBytes.Length;
}
else
{
boundaryBytes = Encoding.ASCII.GetBytes("\r\n--" + boundary + "--\r\n");
length = data.Length + sumFileLength +
boundaryBytes.Length;
}
// set properties
//httpRequestState.HttpRequest.AllowWriteStreamBuffering = false;
httpRequestState.HttpRequest.ServicePoint.Expect100Continue = false;
httpRequestState.HttpRequest.KeepAlive = true;
httpRequestState.HttpRequest.Timeout = 120000;
httpRequestState.HttpRequest.Method = "POST";
httpRequestState.HttpRequest.ContentType = "multipart/form-data; boundary=" + boundary;
httpRequestState.HttpRequest.ContentLength = length;
httpRequestState.HttpRequest.Headers.Add("Cache-Control","no-cache");
// get request stream and write header
Stream stm = httpRequestState.HttpRequest.GetRequestStream();
stm.Write(data,0,data.Length);
if ( fileInfoItems.Length > 0 )
{
foreach ( UploadFileInfo uploadFile in fileInfoItems )
{
UploadFile(uploadFile, boundaryBytes, stm);
}
}
stm.Write(boundaryBytes, 0, boundaryBytes.Length);
stm.Flush();
stm.Close();
#endregion
// Get Response
IAsyncResult ar = httpRequestState.HttpRequest.BeginGetResponse(new AsyncCallback(FastResponseCallback),httpRequestState);
// register a timeout
ThreadPool.RegisterWaitForSingleObject(ar.AsyncWaitHandle, new WaitOrTimerCallback(BaseHttpForm.RequestTimeoutCallback), httpRequestState,this.GetTimeout(), true);
}
catch
{
throw;
}
finally
{
if ( httpRequestState.HttpResponse != null )
{
httpRequestState.HttpResponse.Close();
}
}
}
/// <summary>
/// Starts a new HTTP Post request.
/// </summary>
/// <param name="postUri"> The Url string.</param>
/// <param name="properties"> The HttpProperties to set for the request.</param>
/// <param name="values"> The data to post.</param>
/// <param name="cookies"> The cookie data to set for the request.</param>
/// <returns> A ResponseBuffer type.</returns>
public ResponseBuffer StartSyncHttpPost(string postUri,HttpProperties properties,ArrayList values, CookieCollection cookies)
{
HttpWebResponse response=null;
ResponseBuffer respBuffer=new ResponseBuffer();
httpRequestState = new HttpState();
postUri = EncodeDecode.UrlDecode(postUri);
postUri = EncodeDecode.HtmlDecode(postUri);
// create webrequest
try
{
//this.ValidateIPAddress(new Uri(postUri));
httpRequestState.HttpRequest = (HttpWebRequest)WebRequest.Create(postUri);
// Set HttpWebRequestProperties
SetHttpWebRequestProperties(httpRequestState.HttpRequest, properties);
// Apply proxy settings
if ( this.ProxySettings != null )
{
SetProxy(httpRequestState.HttpRequest,this.ProxySettings);
}
byte[] data=null;
if (values!=null)
{
// transform to postdata and encode in bytes
string postData = GetPostData(values);
data=Encoding.UTF8.GetBytes(postData);
}
//httpRequestState.httpRequest.Referer = postUri;
// set properties
httpRequestState.HttpRequest.Method="POST";
httpRequestState.HttpRequest.ContentType="application/x-www-form-urlencoded";
httpRequestState.HttpRequest.ContentLength=data.Length;
// get request stream
Stream stm = httpRequestState.HttpRequest.GetRequestStream();
stm.Write(data,0,data.Length);
stm.Close();
//hwr.ContinueDelegate=getRedirectHeaders;
// save cookies
httpRequestState.HttpRequest.CookieContainer=new CookieContainer();
if ( cookies!=null )
{
httpRequestState.HttpRequest.CookieContainer.Add(cookies);
}
HttpWebResponse httpResponse = (HttpWebResponse)httpRequestState.HttpRequest.GetResponse();
httpRequestState.HttpResponse = httpResponse;
// get ResponseBuffer
respBuffer = HttpPipeline.FillResponseBuffer(httpResponse,
httpRequestState.HttpRequest,
properties,
httpRequestState);
}
catch (ProtocolViolationException p)
{
if ( response!=null )
{
response.Close();
}
respBuffer.ErrorMessage = "Protocol Exception:" + p.Message;
return respBuffer;
}
catch (WebException w)
{
StringBuilder s = new StringBuilder();
s.Append("Error message:");
s.Append(w.Message);
s.Append("\r\nStatus Code:");
s.Append(((HttpWebResponse)w.Response).StatusCode);
s.Append("\r\nStatus Description:");
s.Append(((HttpWebResponse)w.Response).StatusDescription);
if ( response!=null )
{
response.Close();
}
respBuffer.ErrorMessage = s.ToString();
return respBuffer;
}
// response here
return respBuffer;
}
/// <summary>
/// Get Async get request.
/// </summary>
/// <param name="getUrl"> The url.</param>
/// <param name="values"> The get values.</param>
/// <param name="cookies"> The cookies.</param>
/// <param name="state"> The http state.</param>
private void StartGetRequest(GetForm httpCommand, string getUrl, ArrayList values, CookieCollection cookies, HttpProperties settings, HttpState state)
{
try
{
httpCommand.StartAsyncHttpGet(
getUrl,
settings,
values,
cookies,
state,
false);
}
catch (Exception ex)
{
// register and show
ExceptionHandler.RegisterException(ex);
AbortSessionRun(ex.Message);
}
}
/// <summary>
/// Begins a new asynchronous HTTP Post request. This function is not thread safe.
/// </summary>
/// <param name="postUri"> The Url string.</param>
/// <param name="properties"> The HttpProperties to set for the request.</param>
/// <param name="values"> The data to post.</param>
/// <param name="cookies"> The cookie data to set for the request.</param>
/// <param name="httpRequestState"> The HttpState.</param>
public void StartAsyncHttpPost(string postUri,HttpProperties properties,ArrayList values, CookieCollection cookies, HttpState httpRequestState)
{
// httpRequestState = new HttpState();
// httpRequestState.TestItem = unitTestItem;
// httpRequestState.IsLastItem = lastItem;
postUri = EncodeDecode.UrlDecode(postUri);
postUri = EncodeDecode.HtmlDecode(postUri);
// create webrequest
try
{
//this.ValidateIPAddress(new Uri(postUri));
httpRequestState.HttpRequest = (HttpWebRequest)WebRequest.Create(postUri);
// Set HttpWebRequestProperties
SetHttpWebRequestProperties(httpRequestState.HttpRequest, properties);
// Apply proxy settings
if ( this.ProxySettings != null )
{
SetProxy(httpRequestState.HttpRequest,this.ProxySettings);
}
//httpRequestState.httpRequest.Referer = postUri;
// Continue headers
//hwr.ContinueDelegate = getRedirectHeaders;
// save cookies
httpRequestState.HttpRequest.CookieContainer=new CookieContainer();
if ( cookies!=null )
{
httpRequestState.HttpRequest.CookieContainer.Add(cookies);
}
byte[] data=null;
if (values!=null)
{
// transform to postdata and encode in bytes
string postData = GetPostData(values);
data = Encoding.UTF8.GetBytes(postData);
// set properties
httpRequestState.HttpRequest.Method="POST";
httpRequestState.HttpRequest.ContentType="application/x-www-form-urlencoded";
httpRequestState.HttpRequest.ContentLength=data.Length;
// get request stream
// TODO: async, but in our example we ain't posting files
Stream stm = httpRequestState.HttpRequest.GetRequestStream();
stm.Write(data,0,data.Length);
stm.Flush();
stm.Close();
}
// Get Response
IAsyncResult ar = httpRequestState.HttpRequest.BeginGetResponse(new AsyncCallback(FastResponseCallback),httpRequestState);
// register a timeout
ThreadPool.RegisterWaitForSingleObject(ar.AsyncWaitHandle, new WaitOrTimerCallback(BaseHttpForm.RequestTimeoutCallback), httpRequestState, this.GetTimeout(), true);
}
catch
{
throw;
}
finally
{
if ( httpRequestState.HttpResponse != null )
{
httpRequestState.HttpResponse.Close();
}
}
}
/// <summary>
/// Returns the result from the safe requests.
/// </summary>
/// <param name="sender"> The sender object.</param>
/// <param name="e"> The ResponseEventArgs.</param>
private void SafeSessionResult_EndHttp(object sender, ResponseEventArgs e)
{
// if is not running, then exit ...
if ( this.IsRunning )
{
// on return, run each test
SessionRequest testRequest = ((HttpState)e.State).TestSessionRequest;
// add cookies to cookie manager
cookieManager.AddCookies(e.Response.CookieCollection);
Uri responseUri = (Uri)e.Response.ResponseHeaderCollection["Response Uri"];
// // Update Session Headers
// if ( ( testRequest.Url.ToString() != responseUri.ToString() ) && ( responseUri != null ) )
// {
// // Updates the Test Url with the response uri from the safe session
// testRequest.Url = responseUri;
// }
try
{
#region Apply Tests and execute safe requests
if ( testRequest.WebUnitTest != null )
{
if ( testRequest.WebUnitTest.Tests != null )
{
#region Apply tests
if ( ( testRequest.WebUnitTest.Tests.Count > 0 ) )
{
// matchId > currentRestart
// apply tests
ApplyRequestTests(testRequest, e.Response);
}
#endregion
// add safe test report
// HtmlUnitTestReport report = rptBuilder.BuildReport(e);
// reports.Add(report);
HttpState state = new HttpState();
state.SessionRequestId = ((HttpState)e.State).SessionRequestId + 1;
// if equal, then we stop to request and enabled the report.
if ( state.SessionRequestId == this.SafeSession.SessionRequests.Count )
{
// end
// show report
UnitTestSessionReportEventArgs args = new UnitTestSessionReportEventArgs();
args.Report = reports;
this.CreateReportEvent(this, args);
}
else
{
// continue
state.TestSessionRequest = this.TestSession.SessionRequests[state.SessionRequestId];
ResponseBuffer inputResponse = e.Response;
// call safe request backtracking else call next safe request directly
if ( this.SafeSession.AllowSafeRequestBacktracking )
{
this.ExecuteNextSafeRequestById(state, inputResponse, state.SessionRequestId);
}
else
{
this.ExecuteNextSafeRequest(state, inputResponse);
}
}
}
}
#endregion
}
catch ( WebException web)
{
ExceptionHandler.RegisterException(web);
AbortSessionRun(web.Message);
}
catch (Exception ex)
{
ExceptionHandler.RegisterException(ex);
AbortSessionRun(ex.Message);
}
}
else
{
// abort requests
this.safeSessionGetRequest.SafeAbortRequest();
this.safeSessionPostRequest.SafeAbortRequest();
}
}
/// <summary>
/// PacketStateData Constructor.
/// </summary>
/// <param name="state"> The HttpState associated with the request.</param>
/// <param name="response"> The HttpWebResponse.</param>
public PacketStateData(HttpState state,HttpWebResponse response)
{
this.HttpStateData = state;
this.WebResponse = response;
}
/// <summary>
/// Executes the next safe request in order. Uses the session cookies, instead of updating them.
/// </summary>
/// <param name="state"> The HTTP state.</param>
/// <param name="responseBufferData"> The ResponseBuffer.</param>
/// <param name="loopToId"> The request id to start the loop.</param>
private void ExecuteNextSafeRequestById(HttpState state, ResponseBuffer responseBufferData, int loopToId)
{
CookieCollection cookies = null;
//ResponseBuffer result = null;
// Get safe session and execute
Session safeSession = this.SafeSession;
int k = -1;
if ( state.SafeSessionRequestCurrentId == -1 )
{
state.SafeSessionRequestCurrentId = 0;
k = 0;
}
else
{
k = state.SafeSessionRequestCurrentId;
}
// settings
HttpProperties httpSettings = null;
if ( safeSession.SessionRequests[k].RequestHttpSettings == null )
{
httpSettings = loopPostRequest.ClientSettings;
}
else
{
httpSettings = safeSession.SessionRequests[k].RequestHttpSettings;
}
if ( safeSession.SessionRequests[k].RequestType == HttpRequestType.GET )
{
// if ( responseBufferData.ResponseHeaderCollection.ContainsKey("Location") )
// {
// #region Redirect
// // Location is not empty
// if ( ((string)responseBufferData.ResponseHeaderCollection["Location"])!=String.Empty )
// {
// string location = (string)responseBufferData.ResponseHeaderCollection["Location"];
// Uri url = (Uri)responseBufferData.ResponseHeaderCollection["Response Uri"];
//
// string redirectUri = UriResolver.ResolveUrl(url,location);
//
// // get cookies ny url.
// if ( this.SafeSession.IsCookieUpdatable )
// {
// cookies = cookieManager.GetCookies(new Uri(redirectUri));
// } else {
// cookies = safeSession.SessionRequests[k].RequestCookies;
// }
//
// // Request, we only use url, http settings and cookies, because
// // IE doesn't returns and arraylist of values for GET requests.
// this.StartGetRequest(this.loopGetRequest,
// redirectUri,
// null,
// cookies,
// httpSettings,
// state);
//
//
// }
// #endregion
// }
// else
// {
#region Get Request
// get cookies ny url.
if ( this.SafeSession.IsCookieUpdatable )
{
cookies = cookieManager.GetCookies(safeSession.SessionRequests[k].Url);
}
else
{
cookies = safeSession.SessionRequests[k].RequestCookies;
}
GetSessionRequest sessionRequest = (GetSessionRequest)safeSession.SessionRequests[k];
//this.DisplaySessionProcessEvent(this, new SessionCommandProcessEventArgs("Requesting " + sessionRequest.Url.ToString()));
// Request, we only use url, http settings and cookies, because
// IE doesn't returns and arraylist of values for GET requests.
this.StartGetRequest(this.loopGetRequest,
sessionRequest.Url.ToString(),
null,
cookies,
httpSettings,
state);
#endregion
//}
}
else if ( safeSession.SessionRequests[k].RequestType == HttpRequestType.POST )
{
#region Post Request
PostSessionRequest sessionRequest = (PostSessionRequest)safeSession.SessionRequests[k];
// Post url
string postUrl = String.Empty;
#region Update post url
//if ( this.TestSession.SessionRequests[k].UpdateSessionUrl )
//{
Uri postUri = null;
// if response headers null, use from response buffer
if ( sessionRequest.ResponseHeaders == null )
{
postUri = (Uri)responseBufferData.ResponseHeaderCollection["Response Uri"];
}
else
{
// if it has uri
if ( sessionRequest.ResponseHeaders.ContainsKey("Response Uri") )
{
if ( sessionRequest.ResponseHeaders["Response Uri"] != null )
{
postUri = (Uri)sessionRequest.ResponseHeaders["Response Uri"];
}
}
}
string s = string.Empty;
if ( postUri.Query.Length > 0 )
{
s = postUri.AbsoluteUri.Replace(postUri.Query,"");
}
else
{
s = postUri.AbsoluteUri;
}
string action = parser.GetFormActionByAbsoluteUrl(s, responseBufferData.HttpBody);
if ( action == "" )
{
postUrl = s;
}
else
{
// Resolve url
postUrl = UriResolver.ResolveUrl(postUri,action);
}
//}
#endregion
// get cookies.
if ( this.SafeSession.IsCookieUpdatable )
{
cookies = cookieManager.GetCookies(new Uri(postUrl));
}
else
{
cookies = sessionRequest.RequestCookies;
}
//SessionCommandProcessEventArgs args = new SessionCommandProcessEventArgs("Requesting " + sessionRequest.Url.ToString());
// // Posted Data Event Console Info
ArrayList listValues = parser.GetArrayList(sessionRequest.Form, responseBufferData.HttpBody);
//string posted = ConvertToPostDataString(listValues);
//args.Detail = "Posted data: " + posted;
//this.DisplaySessionProcessEvent(this, args);
// Request post
this.StartPostRequest(loopPostRequest,
postUrl,
listValues,
cookies,
httpSettings,
state);
#endregion
}
// return result;
}
/// <summary>
/// Executes the next safe request in order.
/// </summary>
/// <param name="state"> The HTTP state.</param>
private void ExecuteNextSafeRequest(HttpState state)
{
// Get safe session and execute
Session safeSession = this.SafeSession;
int k = state.SessionRequestId;
// http settings
HttpProperties httpSettings = null;
if ( safeSession.SessionRequests[k].RequestHttpSettings == null )
{
httpSettings = safeSessionPostRequest.ClientSettings;
}
else
{
httpSettings = safeSession.SessionRequests[k].RequestHttpSettings;
}
if ( safeSession.SessionRequests[k].RequestType == HttpRequestType.GET )
{
GetSessionRequest sessionRequest = (GetSessionRequest)safeSession.SessionRequests[k];
SessionCommandProcessEventArgs args = new SessionCommandProcessEventArgs("Requesting " + sessionRequest.Url.ToString());
args.ProcessType = SessionProcessType.SafeRequest;
this.DisplaySessionProcessEvent(this, args);
// Request, we only use url, http settings and cookies, because
// IE doesn't returns and arraylist of values for GET requests.
this.StartGetRequest(safeSessionGetRequest,
sessionRequest.Url.ToString(),
null,
sessionRequest.RequestCookies,
httpSettings,
state);
}
else
{
PostSessionRequest sessionRequest = (PostSessionRequest)safeSession.SessionRequests[k];
SessionCommandProcessEventArgs args = new SessionCommandProcessEventArgs("Requesting " + sessionRequest.Url.ToString());
// TODO: Changed
ArrayList listValues = parser.GetArrayList(sessionRequest.Form);
string posted = ConvertToPostDataString(listValues);
args.Detail = "Posted data: " + posted;
args.ProcessType = SessionProcessType.SafeRequest;
this.DisplaySessionProcessEvent(this, args);
this.StartPostRequest(safeSessionPostRequest,
sessionRequest.Url.ToString(),
listValues,
sessionRequest.RequestCookies,
httpSettings,
state);
}
}
/// <summary>
/// Redirects to url.
/// </summary>
/// <param name="state"> The HTTP State.</param>
/// <param name="cookies"> The cookie collection.</param>
/// <param name="settings"> The HTTP Settings.</param>
/// <param name="url"> The url to redirect to.</param>
private void ApplyUrlRedirection(HttpState state, CookieCollection cookies,HttpProperties settings, string url)
{
this.DisplaySessionProcessEvent(this, new SessionCommandProcessEventArgs("Requesting " + url));
// Request, we only use url, http settings and cookies, because
// IE doesn't returns and arraylist of values for GET requests.
this.StartGetRequest(safeSessionGetRequest,url,null, cookies, settings, state);
}
/// <summary>
/// Apply the test requests for a session request.
/// </summary>
/// <param name="sessionRequest"> The session request.</param>
/// <param name="result"> The response buffer result from the safe session.</param>
private void ApplyRequestTests(SessionRequest sessionRequest, ResponseBuffer result)
{
UnitTestItem unitTestItem = sessionRequest.WebUnitTest;
unitTestItem.Form = sessionRequest.Form;
CookieCollection cookies = null;
//int availableTests = this.AvailableTests();
//bool lastItem = false;
string requestUrl = sessionRequest.Url.ToString();
#region Run each test in SessionRequest WebUnitTestItem
// run each test in Form
foreach (DictionaryEntry de in unitTestItem.Tests)
{
Test test = (Test)de.Value;
ArrayList values = new ArrayList();
// get cookies
cookies = cookieManager.GetCookies(sessionRequest.Url);
// set current test index
unitTestItem.SelectedTestIndex = unitTestItem.Tests.IndexOfValue(test);
// create SessionCommandProcessEventArgs
SessionCommandProcessEventArgs args = new SessionCommandProcessEventArgs("Applying test '" + test.Name + "' to " + sessionRequest.Url.ToString());
args.ProcessType = SessionProcessType.TestRequest;
#region Apply Test
// --------------------------------------------------------------------------------
// Process data
// Html Form Tag
if ( test.UnitTestDataType == UnitTestDataContainer.HtmlFormTag )
{
// is a form tag
// apply test to form
HtmlFormTag filledForm = ApplyTestToForm(test, sessionRequest.Form.CloneTag());
values = parser.GetArrayList(filledForm, result.HttpBody, updateElementNames);
}
// Post Data Hashtable
if ( test.UnitTestDataType == UnitTestDataContainer.PostDataHashtable )
{
string postdata = ((PostSessionRequest)sessionRequest).PostData;
// TODO: Change to PostDataCollection method.
// convert post data to hashtable
FormConverter converter = new FormConverter();
//Hashtable postDataCollection = converter.ConvertPostDataStringHashtable(postdata);
PostDataCollection postDataCollection = converter.GetPostDataCollection(postdata);
// Applies test to post data hashtable
PostDataCollection filledPostData = ApplyTestToPostData(test, postDataCollection.Clone());
values = converter.GetArrayList(filledPostData);
}
// Cookies
if ( test.UnitTestDataType == UnitTestDataContainer.Cookies )
{
cookies = ApplyTestToCookies(test, cookies);
}
// Url
if( test.UnitTestDataType == UnitTestDataContainer.NoPostData )
{
// a url test
requestUrl = ApplyTestToUrl(test, WebServerUriType.Normal,sessionRequest.Url).ToString();
}
// -----------------------------------------------------------------------------------
#endregion
if ( (test.UnitTestDataType == UnitTestDataContainer.HtmlFormTag ) || ( test.UnitTestDataType == UnitTestDataContainer.PostDataHashtable ) )
{
// Set post data for report
test.Arguments.PostData = ConvertToPostDataString(values);
args.Detail = "Posted Data:" + test.Arguments.PostData;
}
if ( test.UnitTestDataType == UnitTestDataContainer.NoPostData )
{
args.Detail = "Url query:" + requestUrl;
}
if ( test.UnitTestDataType == UnitTestDataContainer.Cookies )
{
StringBuilder cookieQuery = new StringBuilder();
foreach ( Cookie cky in cookies )
{
cookieQuery.Append("Name:" + cky.Name);
cookieQuery.Append(", ");
cookieQuery.Append("Value:" + cky.Value);
cookieQuery.Append(";");
}
args.Detail = "Cookie:" + cookieQuery.ToString();
}
// // set last item flag
// if ( availableTests == 1)
// {
// lastItem = true;
// }
// display the current processing
this.DisplaySessionProcessEvent(this,args);
// clone test item and set last item value
HttpState httpRequestState = new HttpState();
httpRequestState.TestItem = unitTestItem.Clone();
//httpRequestState.IsLastItem = lastItem;
// http settings
HttpProperties httpSettings = null;
if ( sessionRequest.RequestHttpSettings == null )
{
httpSettings = unitTestGetRequest.ClientSettings;
}
else
{
httpSettings = sessionRequest.RequestHttpSettings;
}
if ( sessionRequest.RequestType == HttpRequestType.GET )
{
// get request
this.StartGetRequest(unitTestGetRequest,
requestUrl,
null,
cookies,
httpSettings,
httpRequestState);
}
else if ( sessionRequest.RequestType == HttpRequestType.POST )
{
// post request
this.StartPostRequest(unitTestPostRequest,
requestUrl,
values,
cookies,
httpSettings,
httpRequestState);
}
//availableTests--;
}
#endregion
}
/// <summary>
/// Executes the session.
/// </summary>
public void Run()
{
this._isRunning = true;
reports = new ArrayList();
unitTestPostRequest = new PostForm();
unitTestGetRequest = new GetForm();
safeSessionGetRequest = new GetForm();
safeSessionPostRequest = new PostForm();
loopPostRequest = new PostForm();
loopGetRequest = new GetForm();
// Add proxy settings
loopPostRequest.ProxySettings = this.Proxy;
loopGetRequest.ProxySettings = this.Proxy;
unitTestPostRequest.ProxySettings = this.Proxy;
unitTestGetRequest.ProxySettings = this.Proxy;
safeSessionGetRequest.ProxySettings = this.Proxy;
safeSessionPostRequest.ProxySettings = this.Proxy;
// http settings
loopPostRequest.ClientSettings = this.ProtocolProperties;
loopGetRequest.ClientSettings = this.ProtocolProperties;
unitTestPostRequest.ClientSettings = this.ProtocolProperties;
unitTestGetRequest.ClientSettings = this.ProtocolProperties;
safeSessionGetRequest.ClientSettings = this.ProtocolProperties;
safeSessionPostRequest.ClientSettings = this.ProtocolProperties;
// set events for looping requests
loopPostRequest.EndHttp += new ResponseCallbackDelegate(LoopToNextSafeRequest_EndHttp);
loopGetRequest.EndHttp += new ResponseCallbackDelegate(LoopToNextSafeRequest_EndHttp);
// set events for unit test requests
unitTestPostRequest.EndHttp += new ResponseCallbackDelegate(UnitTestResult_EndHttp);
unitTestGetRequest.EndHttp += new ResponseCallbackDelegate(UnitTestResult_EndHttp);
// set events for safe session requests
safeSessionGetRequest.EndHttp += new ResponseCallbackDelegate(SafeSessionResult_EndHttp);
safeSessionPostRequest.EndHttp += new ResponseCallbackDelegate(SafeSessionResult_EndHttp);
HttpState state = new HttpState();
// the test sessin request of the safe request.
state.TestSessionRequest = this.TestSession.SessionRequests[0];
state.SessionRequestId = 0;
state.IsLastItem = true;
ExecuteNextSafeRequest(state);
}
/// <summary>
/// PacketStateData Constructor.
/// </summary>
/// <param name="state"> The HttpState associated with the request.</param>
/// <param name="response"> The HttpWebResponse.</param>
/// <param name="message"> The error message.</param>
public PacketStateData(HttpState state,HttpWebResponse response,string message)
{
this.HttpStateData = state;
this.WebResponse = response;
this.ErrorMessage = message;
}
/// <summary>
/// Runs the command.
/// </summary>
public void Run()
{
this._isRunning = true;
postRequest = new PostForm();
getRequest = new GetForm();
postRequest.EndHttp += new ResponseCallbackDelegate(httpResponse_EndHttp);
getRequest.EndHttp += new ResponseCallbackDelegate(httpResponse_EndHttp);
reports = new ArrayList();
TestCollection tests = GetTests();
UnitTestItem testItem = new UnitTestItem(FormTag, tests);
int availableTests = tests.Count;
bool lastItem = false;
#region Run each test in UnitTestItem
// run each test in Form
foreach (DictionaryEntry de in tests)
{
Test test = (Test)de.Value;
// apply test to form
HtmlFormTag filledForm = ApplyTestToForm(test, FormTag.CloneTag());
// set current test index
testItem.SelectedTestIndex = testItem.Tests.IndexOfValue(test);
// resolve uri
string url = UriResolver.ResolveUrl(this.Url,filledForm.Action);
// convert to array list
// TODO: Send HTML Source for bypassing fields. Will be needed for ASP.NET testing.
ArrayList al = parser.GetArrayList(filledForm);
// set posted data
StringBuilder postDataBuffer = new StringBuilder();
postDataBuffer.Append("?");
for (int k=0;k<al.Count;k++)
{
postDataBuffer.Append(al[k]);
postDataBuffer.Append("&");
}
test.Arguments.PostData = postDataBuffer.ToString();
// set last item flag
if ( availableTests == 1)
{
lastItem = true;
}
CookieManager cookieManager = new CookieManager();
CookieCollection cookies = cookieManager.GetCookies(new Uri(url));
HttpState httpRequestState = new HttpState();
httpRequestState.TestItem = testItem.Clone();
httpRequestState.IsLastItem = lastItem;
if ( filledForm.Method.ToLower(System.Globalization.CultureInfo.InvariantCulture) == "get" )
{
getRequest.StartAsyncHttpGet(
url,
this.ProtocolProperties,
al,
cookies,
httpRequestState,
false);
}
else
{
postRequest.StartAsyncHttpPost(
url,
this.ProtocolProperties,
al,
cookies,
httpRequestState);
}
availableTests--;
}
#endregion
}
