Exemple #1
0
        protected FindRecordingResultList GetRecordingSearchResults(string searchToken, int?minResults, int?maxResults, string waitTime, string stepName)
        {
            FindRecordingResultList response = null;

            GetRecordingSearchResults request = new GetRecordingSearchResults();

            request.SearchToken         = searchToken;
            request.WaitTime            = waitTime;
            request.MaxResultsSpecified = maxResults.HasValue;
            request.MaxResults          = maxResults.GetValueOrDefault();
            request.MinResultsSpecified = minResults.HasValue;
            request.MinResults          = minResults.GetValueOrDefault();
            RunStep(() => { response = Client.GetRecordingSearchResults(request).ResultList; }, stepName);
            DoRequestDelay();
            return(response);
        }
        public void GetRecordingSearchResultsInvalidTokenTest()
        {
            RunTest(
                () =>
            {
                string searchToken = Guid.NewGuid().ToString().Substring(0, 8);

                RunStep(
                    () =>
                {
                    GetRecordingSearchResults request = new GetRecordingSearchResults();
                    request.SearchToken = searchToken;
                    Client.GetRecordingSearchResults(request);
                }, string.Format("Get recordings search result with invalid token ({0})", searchToken),
                    Definitions.Onvif.OnvifFaults.InvalidToken,
                    true);
            });
        }
        public void GetRecordingSearchResultsAfterEndSearchTest()
        {
            int    testKeepAlive = _searchKeepAlive;
            bool   searchEnded   = true;
            string searchToken   = string.Empty;

            RunTest(
                () =>
            {
                string keepAlive  = string.Format("PT{0}S", testKeepAlive);
                SearchScope scope = new SearchScope();

                searchToken = FindRecordings(scope, null, keepAlive);
                searchEnded = false;

                EndSearch(searchToken);
                searchEnded = true;

                RunStep(
                    () =>
                {
                    GetRecordingSearchResults request = new GetRecordingSearchResults();
                    request.SearchToken = searchToken;
                    Client.GetRecordingSearchResults(request);
                },
                    "Get recordings search result",
                    Definitions.Onvif.OnvifFaults.InvalidToken,
                    true);
            },
                () =>
            {
                if (!searchEnded)
                {
                    ReleaseSearch(searchToken, testKeepAlive * 1000);
                }
            });
        }
Exemple #4
0
        protected List <RecordingInformation> GetAllRecordingsSearchResults(string searchToken, int?minResults, int?maxResults, string waitTime, out SearchState state)
        {
            DateTime requestSent      = DateTime.MinValue;
            DateTime responseReceived = DateTime.MinValue;

            Action <string> logRequest  = new Action <string>((s) => { requestSent = DateTime.Now; });
            Action <string> logResponse = new Action <string>((s) => { responseReceived = DateTime.Now; });

            _trafficListener.RequestSent      += logRequest;
            _trafficListener.ResponseReceived += logResponse;

            TimeSpan ts = new TimeSpan(0);

            if (!string.IsNullOrEmpty(waitTime))
            {
                ts = XmlConvert.ToTimeSpan(waitTime);
                ts = ts.Add(new TimeSpan(0, 0, 1));
            }

            try
            {
                List <RecordingInformation> recordingsList = new List <RecordingInformation>();

                FindRecordingResultList   response = null;
                GetRecordingSearchResults request  = new GetRecordingSearchResults();
                request.SearchToken         = searchToken;
                request.WaitTime            = waitTime;
                request.MaxResultsSpecified = maxResults.HasValue;
                request.MaxResults          = maxResults.GetValueOrDefault();
                request.MinResultsSpecified = minResults.HasValue;
                request.MinResults          = minResults.GetValueOrDefault();

                DateTime started      = DateTime.Now;
                DateTime dueTo        = started.AddSeconds(_searchTimeout);
                DateTime lastResponse = DateTime.Now;

                bool completed = true;

                LogTestEvent(string.Format("All results should be received by {0}{1}",
                                           dueTo.StdTimeToString(), Environment.NewLine));

                do
                {
                    RunStep(
                        () =>
                    {
                        response = Client.GetRecordingSearchResults(request).ResultList;
                    }, "Get Recording Search results");
                    lastResponse = DateTime.Now;
                    // no request delay here!
                    if (response.RecordingInformation != null)
                    {
                        recordingsList.AddRange(response.RecordingInformation);
                    }

                    if (lastResponse > dueTo)
                    {
                        completed = false;
                        break;
                    }

                    if (maxResults.HasValue)
                    {
                        int count = 0;
                        if (response.RecordingInformation != null)
                        {
                            count = response.RecordingInformation.Length;
                        }
                        state = response.SearchState;
                        Assert(count <= maxResults.Value, string.Format("Number of recordings received ({0}) is more than maxResults ({1})", count, maxResults.Value), "Check that maxResults parameter is not exceeded");
                    }

                    if (!string.IsNullOrEmpty(waitTime))
                    {
                        TimeSpan duration = responseReceived - requestSent;
                        Assert(duration < ts,
                               string.Format("Response received {0}.{1} seconds after request is sent (waitTime is {2})", duration.Seconds, duration.Milliseconds.ToString("000"), waitTime),
                               "Check that waitTime is taken into account");
                    }
                } while (response.SearchState != SearchState.Completed);

                state = response.SearchState;

                Assert(completed, string.Format("Completed state has not been achieved (last response received at {0}, State: {1})", lastResponse.StdTimeToString(), response.SearchState), "Check that search has been completed in due time");

                return(recordingsList);
            }
            finally
            {
                _trafficListener.RequestSent      -= logRequest;
                _trafficListener.ResponseReceived -= logResponse;
            }
        }