示例#1
0
        private void DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            int size = _reader.ReadInt16();

            byte[] payLoad = _reader.ReadBytes(size);
            ResponseBuffer.TryAdd(Response.GetId(payLoad), payLoad);
        }
示例#2
0
        protected virtual bool ProcessPortResponse()
        {
            bool complete = false;

            TimeoutTimer.Disarm();

            if (Test.Steps[CurrentStep].Response != null)
            {
                if (!string.IsNullOrEmpty(Test.Steps[CurrentStep].Response.Header))
                {
                    int index = ResponseBuffer.LastIndexOf(Test.Steps[CurrentStep].Response.Header);
                    if (index >= 0)
                    {
                        ResponseBuffer = ResponseBuffer.Substring(index);
                    }
                }
            }

            if (!string.IsNullOrEmpty(ResponseBuffer))
            {
                qf4net.QF.Instance.Publish(new RecorderEvent(QFSignal.RecorderRecord, Name, CurrentStep + 1, ResponseBuffer));
            }

            ResponseProcessor.Process(Test.Name, Test.Steps[CurrentStep], ResponseBuffer);
            ResponseBuffer = string.Empty;
            complete       = true;

            return(complete);
        }
 public void Reset()
 {
     ResponseBuffer.Clear();
     ArgumentBytes = 0;
     Argument      = 0;
     CommandNumber = 0;
     State         = SpiState.WaitingForCommand;
 }
示例#4
0
 public void Clean()
 {
     if (ResponseBuffer != null)
     {
         ResponseBuffer.FinishedWriting();
         ResponseBuffer = null;
     }
 }
示例#5
0
 public void Clean()
 {
     if (ResponseBuffer != null)
     {
         ResponseBuffer.Close();
         ResponseBuffer = null;
     }
 }
        private void StartMessageBuffer()
        {
            byte[] buffer = new byte[2];

            Task.Factory.StartNew(async() =>
            {
                while (!CancellationToken.IsCancellationRequested)
                {
                    await _stream.ReadAsync(buffer, 0, buffer.Length, CancellationToken);

                    short size = (short)(buffer[1] | buffer[2] << 8);
                    if (size > 0)
                    {
                        byte[] payLoad = new byte[size];
                        await _stream.ReadAsync(payLoad, 0, payLoad.Length);
                        ResponseBuffer.TryAdd(Response.GetId(payLoad), payLoad);
                    }
                }
            }, CancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Current);

            Task.Factory.StartNew(async() =>
            {
                while (!CancellationToken.IsCancellationRequested)
                {
                    try
                    {
                        Command command;
                        if (NoReplyCommandBuffer.TryDequeue(out command))
                        {
                            await _stream.WriteAsync(command.PayLoad, 0, command.PayLoad.Length);
                            _stream.Flush();
                            ResponseBuffer.TryAdd(command.Id, null);
                        }


                        if (CommandBuffer.TryDequeue(out command))
                        {
                            await _stream.WriteAsync(command.PayLoad, 0, command.PayLoad.Length);
                            _stream.Flush();

                            int retry = 0;
                            while (!ResponseBuffer.ContainsKey(command.Id) && retry < 20)
                            {
                                await Task.Delay(50, CancellationToken);
                                retry++;
                            }
                        }

                        if (EventBuffer.TryDequeue(out command))
                        {
                            await _stream.WriteAsync(command.PayLoad, 0, command.PayLoad.Length);
                            _stream.Flush();
                        }
                    }
                    catch (TaskCanceledException) { }
                }
            }, CancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Current);
        }
 /// <summary>
 /// Form that manages unit tests for a form.
 /// </summary>
 /// <param name="form"></param>
 /// <param name="sessionData"></param>
 public UnitTestManagerForm(HtmlFormTag form, ResponseBuffer sessionData, InspectorConfiguration config)
 {
     //
     // Required for Windows Form Designer support
     //
     InitializeComponent();
     this.inspectorConfig = config;
     this.CurrentForm = form;
     this.lblFormName.Text = form.Name;
     this.lblUrl.Text = ((Uri)sessionData.RequestHeaderCollection["Request Uri"]).AbsoluteUri;
 }
        private void StartMessageBuffer()
        {
            Task.Factory.StartNew(async() =>
            {
                while (!CancellationToken.IsCancellationRequested)
                {
                    byte[] payLoad = await Read();
                    if (payLoad != null)
                    {
                        ResponseBuffer.TryAdd(Response.GetId(payLoad), payLoad);
                    }
                }
            }, CancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Current);

            Task.Factory.StartNew(async() =>
            {
                while (!CancellationToken.IsCancellationRequested)
                {
                    try
                    {
                        Command command;
                        if (NoReplyCommandBuffer.TryDequeue(out command))
                        {
                            await Write(command);
                            ResponseBuffer.TryAdd(command.Id, null);
                        }


                        if (CommandBuffer.TryDequeue(out command))
                        {
                            await Write(command);

                            int retry = 0;
                            while (!ResponseBuffer.ContainsKey(command.Id) && retry < 20)
                            {
                                await Task.Delay(50, CancellationToken);
                                retry++;
                            }
                        }

                        if (EventBuffer.TryDequeue(out command))
                        {
                            await Write(command);
                        }
                    }
                    catch (TaskCanceledException) { }
                }
            }, CancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Current);
        }
 protected void Clear()
 {
     ResponseBuffer.Clear();
     while (NoReplyCommandBuffer.Count > 0)
     {
         NoReplyCommandBuffer.TryDequeue(out _);
     }
     while (CommandBuffer.Count > 0)
     {
         CommandBuffer.TryDequeue(out _);
     }
     while (EventBuffer.Count > 0)
     {
         EventBuffer.TryDequeue(out _);
     }
 }
示例#10
0
        private void StartMessageBuffer()
        {
            Task.Factory.StartNew(async() =>
            {
                while (!CancellationToken.IsCancellationRequested)
                {
                    try
                    {
                        Command command;

                        if (NoReplyCommandBuffer.TryDequeue(out command))
                        {
                            lock (_serialPort) _serialPort.Write(command.PayLoad, 0, command.PayLoad.Length);
                            ResponseBuffer.TryAdd(command.Id, null);
                        }


                        if (CommandBuffer.TryDequeue(out command))
                        {
                            lock (_serialPort) _serialPort.Write(command.PayLoad, 0, command.PayLoad.Length);
                            int retry = 0;
                            while (!ResponseBuffer.ContainsKey(command.Id) && retry < 20)
                            {
                                await Task.Delay(50, CancellationToken);
                                retry++;
                            }
                        }

                        if (EventBuffer.TryDequeue(out command))
                        {
                            lock (_serialPort) _serialPort.Write(command.PayLoad, 0, command.PayLoad.Length);
                        }
                    }
                    catch (TaskCanceledException) { }
                }
            }, CancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Current);
        }
        /// <summary>
        /// Gets the meta tag url from http content.
        /// </summary>
        /// <param name="httpResponse"> The response buffer.</param>
        /// <param name="url"> The response uri.</param>
        /// <returns> An url found in the META tag.</returns>
        private Uri GetMetaTagUrl(ResponseBuffer httpResponse, Uri url)
        {
            // check if html content has any META tag.
            string metaUrl = parser.GetMetaRedirectUrlString(httpResponse.HttpBody);
            Uri newUrl = null;

            if ( metaUrl.Length > 0 )
            {
                if ( metaUrl.ToLower().StartsWith("http") )
                {
                    try
                    {
                        newUrl = new Uri(metaUrl);
                    }
                    catch
                    {
                        newUrl = url;
                    }
                }
                else
                {
                    // make relative
                    newUrl = new Uri(UriResolver.ResolveUrl(url, metaUrl));
                }
            }

            return newUrl;
        }
        /// <summary>
        /// Executes the next safe request in order. Uses session cookies instead of updating them.
        /// </summary>
        /// <param name="state"> The HTTP state.</param>
        /// <param name="responseBufferData"> The ResponseBuffer.</param>
        private void ExecuteNextSafeRequest(HttpState state, ResponseBuffer responseBufferData)
        {
            CookieCollection cookies = null;

            // 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];

                //				// Location is found in Hashtable
                //				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"];
                //
                //						// Get redirect uri
                //						string redirectUri = UriResolver.ResolveUrl(url,location);
                //
                //						if ( this.SafeSession.IsCookieUpdatable )
                //						{
                //							// get cookies from cookie manager
                //							cookies = cookieManager.GetCookies(new Uri(redirectUri));
                //						}
                //						else
                //						{
                //							// else use saved cookies
                //							cookies = sessionRequest.RequestCookies;
                //						}
                //
                //						this.ApplyUrlRedirection(state, cookies,httpSettings, redirectUri);
                //					}
                //					#endregion
                //				}
                //				else
                //				{
                #region Get Request
                // get cookies.
                if ( this.SafeSession.IsCookieUpdatable )
                {
                    // get cookies from cookie manager
                    cookies = cookieManager.GetCookies(sessionRequest.Url);
                }
                else
                {
                    // else use saved cookies
                    cookies = sessionRequest.RequestCookies;
                }

                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(safeSessionGetRequest,
                    sessionRequest.Url.ToString(),
                    null,
                    cookies,
                    httpSettings,
                    state);
                #endregion
                //}
            }
            else
            {
                #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 )
                {
                    // get cookies from cookie manager
                    cookies = cookieManager.GetCookies(new Uri(postUrl));
                }
                else
                {
                    // else use saved cookies
                    cookies = sessionRequest.RequestCookies;
                }

                SessionCommandProcessEventArgs args = new SessionCommandProcessEventArgs("Requesting " + postUrl);

                // Check form for updates session values
                // Convert form
                ArrayList listValues = parser.ConvertToArrayList(sessionRequest.Form, responseBufferData.HttpBody);

                // Display posted values
                string posted = ConvertToPostDataString(listValues);
                args.Detail = "Posted data: " + posted;
                args.ProcessType = SessionProcessType.SafeRequest;
                this.DisplaySessionProcessEvent(this, args);

                // Request post
                this.StartPostRequest(safeSessionPostRequest,
                    postUrl,
                    listValues,
                    cookies,
                    httpSettings,
                    state);

                #endregion
            }
        }
        /// <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.ConvertToArrayList(filledForm, result.HttpBody, updateElementNames);
                }
                // Post Data Hashtable
                if ( test.UnitTestDataType == UnitTestDataContainer.PostDataHashtable )
                {
                    string postdata = ((PostSessionRequest)sessionRequest).PostData;

                    // convert post data to hashtable
                    FormConverter converter = new FormConverter();
                    Hashtable postDataHash = converter.ConvertPostDataString(postdata);

                    // Applies test to post data hashtable
                    Hashtable filledPostData = ApplyTestToPostData(test, (Hashtable)postDataHash.Clone());
                    values = converter.ConvertPostDataArrayList(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
                {
                    // post request
                    this.StartPostRequest(unitTestPostRequest,
                        requestUrl,
                        values,
                        cookies,
                        httpSettings,
                        httpRequestState);
                }

                //availableTests--;
            }
            #endregion
        }
        /// <summary>
        /// Fills the headers in the response buffer.
        /// </summary>
        /// <param name="sender"> The sender object.</param>
        /// <param name="e"> The event arguments.</param>
        private void InspectorPipeline_FillHeaders(object sender, EventArgs e)
        {
            ResponseBuffer respBuffer = null;
            HttpWebRequest webRequest = HttpStateData.HttpRequest;
            HttpWebResponse webResponse = HttpStateData.HttpResponse;

            if ( CompareString.Compare(webRequest.Method,"get") )
            {
                respBuffer = new ResponseBuffer(HttpRequestType.GET);
            }
            else if ( CompareString.Compare(webRequest.Method,"post") )
            {
                respBuffer = new ResponseBuffer(HttpRequestType.POST);
            }
            else if ( CompareString.Compare(webRequest.Method,"put") )
            {
                respBuffer = new ResponseBuffer(HttpRequestType.PUT);
            }
            else if ( CompareString.Compare(webRequest.Method,"head") )
            {
                respBuffer = new ResponseBuffer(HttpRequestType.HEAD);
            }
            else if ( CompareString.Compare(webRequest.Method,"delete") )
            {
                respBuffer = new ResponseBuffer(HttpRequestType.DELETE);
            }
            else if ( CompareString.Compare(webRequest.Method,"trace") )
            {
                respBuffer = new ResponseBuffer(HttpRequestType.TRACE);
            }
            else if ( CompareString.Compare(webRequest.Method,"options") )
            {
                respBuffer = new ResponseBuffer(HttpRequestType.OPTIONS);
            }

            respBuffer.StatusCode = (int)webResponse.StatusCode;
            respBuffer.StatusDescription = webResponse.StatusDescription;

            if ( webResponse.ProtocolVersion == HttpVersion.Version11  )
            {
                respBuffer.Version="1.1";
            }
            else
            {
                respBuffer.Version="1.0";
            }

            // Request Header Collection
            BufferBuilder.FillRequestHeader(respBuffer,webRequest.Headers,webRequest);

            // Header Collection
            BufferBuilder.FillResponseHeader(respBuffer,webRequest,webResponse.Headers,webResponse);

            this.HttpResponseData = respBuffer;
        }