Beispiel #1
0
        protected RecordingJobStateInformation GetRecordingJobState(string token)
        {
            RecordingJobStateInformation stateInformation = null;

            RunStep(() => { stateInformation = Client.GetRecordingJobState(token); },
                    string.Format("Get Recording Job State (token = '{0}')", token));
            DoRequestDelay();
            return(stateInformation);
        }
Beispiel #2
0
        public override RecordingJobStateInformation GetRecordingJobState(string JobToken)
        {
            var jobStateInfo = new RecordingJobStateInformation();

            var jobState = Search.SearchStorage.Instance.RecordingJobs.Where(j => j.JobToken == JobToken).FirstOrDefault();

            jobStateInfo.RecordingToken = jobState.JobConfiguration.RecordingToken;
            jobStateInfo.State          = "state";
            if (Search.SearchStorage.Instance.JobStates.ContainsKey(JobToken))
            {
                jobStateInfo.State = Search.SearchStorage.Instance.JobStates[JobToken];
            }
            List <RecordingJobStateSource> jobStateSourceList = new List <RecordingJobStateSource>();

            if (jobState.JobConfiguration.Source != null)
            {
                foreach (var source in jobState.JobConfiguration.Source)
                {
                    var jobStateSource = new RecordingJobStateSource();
                    jobStateSource.SourceToken = source.SourceToken;
                    jobStateSource.State       = "state";
                    List <RecordingJobStateTrack> jobStateTracks = new List <RecordingJobStateTrack>();
                    foreach (var track in source.Tracks)
                    {
                        RecordingJobStateTrack jobStateTrack = new RecordingJobStateTrack();
                        jobStateTrack.SourceTag   = track.SourceTag;
                        jobStateTrack.Destination = track.Destination;
                        jobStateTrack.State       = "state";
                        jobStateTracks.Add(jobStateTrack);
                    }
                    jobStateSource.Tracks       = new RecordingJobStateTracks();
                    jobStateSource.Tracks.Track = jobStateTracks.ToArray();
                    jobStateSourceList.Add(jobStateSource);
                }
            }
            jobStateInfo.Sources = jobStateSourceList.ToArray();
            return(jobStateInfo);
        }
Beispiel #3
0
        public void RecordingJobConfigurationDiffPriorTest2()
        {
            string recordingToken = string.Empty;
            string profileToken   = string.Empty;
            string jobToken       = string.Empty;
            string jobTokenSecond = string.Empty;

            bool recordingCreated            = false;
            bool isRecordingJobDeleted       = false;
            bool isRecordingJobSecondDeleted = false;

            RunTest(() =>
            {
                // A.15 - Selection or Creation of Recording for recording job creation on a Media profile
                GetRecordingForJobCreationMediaProfile(out recordingToken, out profileToken, out recordingCreated, 1);

                // pass test if there is no recording token and profile token
                if (recordingToken == string.Empty && profileToken == string.Empty)
                {
                    return;
                }

                // create 1st recording job configuration
                var source = new RecordingJobSource
                {
                    SourceToken = new SourceReference {
                        Token = profileToken, Type = PROFILESOURCETYPE
                    },
                    AutoCreateReceiverSpecified = false
                };

                var jobConfiguration = new RecordingJobConfiguration
                {
                    RecordingToken = recordingToken,
                    Mode           = ACTIVE,
                    Priority       = 1,
                    Source         = new[] { source }
                };
                var confStand = (RecordingJobConfiguration)CopyObject(jobConfiguration);

                // create 1st recording job
                jobToken = CreateRecordingJob(ref jobConfiguration);

                Assert(!string.IsNullOrEmpty(jobToken),
                       "Job token wasn't returned",
                       "Check that job token was returned");

                ValidateRecordingJobConfiguration(jobConfiguration, confStand);

                // wait
                Sleep(_operationDelay);

                // get job state
                RecordingJobStateInformation info = GetRecordingJobState(jobToken);

                ValidateJobState(info, recordingToken, ACTIVE);

                // create 1st recording job configuration
                var jobConfigurationSecond      = confStand;
                jobConfigurationSecond.Priority = 2;
                confStand = (RecordingJobConfiguration)CopyObject(jobConfigurationSecond);

                // create 2nd recording job
                jobTokenSecond = CreateRecordingJob(ref jobConfigurationSecond);

                Assert(!string.IsNullOrEmpty(jobTokenSecond),
                       "Job token wasn't returned",
                       "Check that job token was returned");

                ValidateRecordingJobConfiguration(jobConfigurationSecond, confStand);

                // wait
                Sleep(_operationDelay);

                // get job state
                info = GetRecordingJobState(jobToken);
                ValidateJobState(info, recordingToken, IDLE);

                // get job state
                info = GetRecordingJobState(jobTokenSecond);
                ValidateJobState(info, recordingToken, ACTIVE);

                // delete 2nd job
                DeleteRecordingJob(jobTokenSecond);
                isRecordingJobSecondDeleted = true;

                // wait
                Sleep(_operationDelay);

                // get job state
                info = GetRecordingJobState(jobToken);
                ValidateJobState(info, recordingToken, ACTIVE);

                // delete 1st job
                DeleteRecordingJob(jobToken);
                isRecordingJobDeleted = true;
            }, () =>
            {
                if (!isRecordingJobDeleted && !string.IsNullOrEmpty(jobToken))
                {
                    DeleteRecordingJob(jobToken);
                }

                if (!isRecordingJobSecondDeleted && !string.IsNullOrEmpty(jobTokenSecond))
                {
                    DeleteRecordingJob(jobTokenSecond);
                }

                if (recordingCreated && !string.IsNullOrEmpty(recordingToken))
                {
                    DeleteRecording(recordingToken);
                }
            });
        }
        private void CompareJobStates(GetRecordingJobsResponseItem job,
                                      RecordingJobStateInformation jobState)
        {
            StringBuilder logger = new StringBuilder();
            bool          ok     = true;

            if (job.JobConfiguration.RecordingToken != jobState.RecordingToken)
            {
                ok = false;
                logger.Append(string.Format("   Recording tokens in JobResponse and in JobStateResponse are different{0}",
                                            Environment.NewLine));
            }


            if (job.JobConfiguration.Source != null && jobState.Sources != null)
            {
                var jobStateSourceList = jobState.Sources;
                var jobSourceList      = job.JobConfiguration.Source;
                foreach (var source in jobSourceList)
                {
                    var jobStateSource = jobStateSourceList.FirstOrDefault(
                        s => s.SourceToken.Token == source.SourceToken.Token && s.SourceToken.Type == source.SourceToken.Type);
                    if (jobStateSource == null)
                    {
                        ok = false;
                        logger.Append(string.Format(
                                          "   Source list in GetRecordingJobStateResponse doesn't contain " +
                                          "source with SourceToken='{0}' and Type='{1}'{2}",
                                          source.SourceToken.Token, source.SourceToken.Type,
                                          Environment.NewLine));
                    }
                    else
                    {
                        if (source.Tracks == null &&
                            (jobStateSource.Tracks == null || jobStateSource.Tracks.Track == null))
                        {
                            if (jobStateSource.Tracks == null || jobStateSource.Tracks.Track == null)
                            {
                                ok = false;
                                logger.Append(string.Format(
                                                  "   Recording job source '{0}' in GetRecordingJobStateResponse don't contain track list{1}",
                                                  jobStateSource.SourceToken.Token, Environment.NewLine));
                            }
                            if (source.Tracks == null)
                            {
                                ok = false;
                                logger.Append(string.Format(
                                                  "   Recording job source '{0}' in GetRecordingJobsResponse don't contain track list{1}",
                                                  source.SourceToken.Token, Environment.NewLine));
                            }
                        }
                        else
                        {
                            var jobStateTrackList = jobStateSource.Tracks.Track;
                            var jobTrackList      = source.Tracks;
                            foreach (var track in jobTrackList)
                            {
                                var jobStateTrack = jobStateTrackList.FirstOrDefault(
                                    t => t.SourceTag == track.SourceTag && t.Destination == track.Destination);
                                if (jobStateTrack == null)
                                {
                                    ok = false;
                                    logger.Append(string.Format(
                                                      "   Source {0} in GetRecordingJobStateResponse doesn't " +
                                                      "contain track with Tag='{1}' and Destination='{2}' which is " +
                                                      "contained in GetRecordingJobsResponse{3}",
                                                      source.SourceToken.Token, track.SourceTag,
                                                      track.Destination, Environment.NewLine));
                                }
                            }
                            foreach (var track in jobStateTrackList)
                            {
                                var jobTrack = jobTrackList.FirstOrDefault(
                                    t => t.SourceTag == track.SourceTag && t.Destination == track.Destination);
                                if (jobTrack == null)
                                {
                                    ok = false;
                                    logger.Append(string.Format(
                                                      "   Source {0} in GetRecordingJobsResponse doesn't " +
                                                      "contain track with Tag='{1}' and Destination='{2}' which is " +
                                                      "contained in GetRecordingJobStateResponse{3}",
                                                      source.SourceToken.Token, track.SourceTag,
                                                      track.Destination, Environment.NewLine));
                                }
                            }
                        }
                    }
                }
                foreach (var source in jobStateSourceList)
                {
                    var jobSource = jobSourceList.FirstOrDefault(s =>
                                                                 s.SourceToken.Token == source.SourceToken.Token && s.SourceToken.Type == source.SourceToken.Type);
                    if (jobSource == null)
                    {
                        ok = false;
                        logger.Append(string.Format(
                                          "   Source list in GetRecordingJobsResponse doesn't contain " +
                                          "source with SourceToken='{0}' and Type='{1}'{2}",
                                          source.SourceToken.Token, source.SourceToken.Type,
                                          Environment.NewLine));
                    }
                }
            }
            else
            {
                if (job.JobConfiguration.Source == null && jobState.Sources != null)
                {
                    ok = false;
                    logger.Append(string.Format("   Job with token = '{0}' in GetRecordingJobsResponse" +
                                                " doesn't contain Source list{1}", job.JobToken, Environment.NewLine));
                }
                if (jobState.Sources == null && job.JobConfiguration.Source != null)
                {
                    ok = false;
                    logger.Append(string.Format("   Job with token = '{0}' in GetRecordingJobStateResponse doesn't contain Source list{1}", job.JobToken, Environment.NewLine));
                }
            }
            Assert(ok, logger.ToStringTrimNewLine(), "Validate RecordingJobStateResponse");
        }