public List <GetRecordingsResponseItem> GetRecordings()
{
List <GetRecordingsResponseItem> list = new List <GetRecordingsResponseItem>();
GetRecordingsResponseItem[] response = new GetRecordingsResponseItem[0];
GetRecordings request = new GetRecordings();
if (Security == Security.None)
{
Action action = ConstructSecurityTolerantAction(
() =>
{
response = Client.GetRecordings(request);
}
);
action();
}
else
{
response = Client.GetRecordings(request);
}
list.AddRange(response);
return(list);
}
private bool CompareRecordings(GetRecordingsResponseItem prevRecording, GetRecordingsResponseItem newRecording, StringBuilder logger)
{
bool ok = true;
if (!CompareComplexStringFields <RecordingConfiguration>(prevRecording.Configuration, newRecording.Configuration, logger, newRecording.RecordingToken))
{
ok = false;
}
if (!CompareComplexStringFields <RecordingSourceInformation>(prevRecording.Configuration.Source, newRecording.Configuration.Source, logger, newRecording.RecordingToken))
{
ok = false;
}
//ok &= CompareComplexStringFields<RecordingConfiguration>(prevRecording.Configuration, newRecording.Configuration, logger, newRecording.RecordingToken);
//ok &= CompareComplexStringFields<RecordingSourceInformation>(prevRecording.Configuration.Source, newRecording.Configuration.Source, logger, newRecording.RecordingToken);
//GetTracksResponseItem track = null;
//foreach (var item in prevRecording.Tracks.Track)
//{
// track = newRecording.Tracks.Track.FirstOrDefault(t => t.TrackToken == item.TrackToken);
// if (track == null)
// {
// ok = false;
// logger.Append(string.Format("Recording '{0}' of new recording list doesn't contain track with token '{1}'{2}",
// newRecording.RecordingToken, item.TrackToken, Environment.NewLine));
// }
// else
// {
// ok &= CompareTracks(item, track, logger, prevRecording.RecordingToken);
// }
//}
return(ok);
}
/// <summary>
///
/// </summary>
/// <param name="fullList"></param>
/// <param name="list"></param>
/// <param name="logger"></param>
/// <returns></returns>
/// <remarks>When this method is called, it's assumed THAT
/// a. Tokens are unique in fullList
/// b. "Configuration" element is not null for all items in fullList
/// c. For each recording in list received via search, token can be found in fullList
/// </remarks>
protected bool CheckRecordings(GetRecordingsResponseItem[] fullList, IEnumerable <RecordingInformation> list, StringBuilder logger)
{
bool ok = true;
// info - in search result
// item - in full list
foreach (RecordingInformation info in list)
{
// find entry in fullList;
// compare
string token = info.RecordingToken;
GetRecordingsResponseItem item =
fullList.FirstOrDefault(RI => RI.RecordingToken == token);
// Content [Description]
if (info.Content != item.Configuration.Content)
{
ok = false;
logger.AppendFormat(
"Content is different for item with token='{0}' ('{1}' for GetRecordings and '{2}' for GetRecordingSearchResults){3}",
token, item.Configuration.Content, info.Content, Environment.NewLine);
}
// TrackInformation
bool local = CompareTracks(item.Tracks, info.Track, item.RecordingToken, logger);
ok = ok && local;
// RecordingSourceInformation
local = CompareSourceInformation(item.Configuration.Source, info.Source, item.RecordingToken, logger);
ok = ok && local;
}
return(ok);
}
public override GetRecordingsResponseItem[] GetRecordings()
{
List <GetRecordingsResponseItem> items = new List <GetRecordingsResponseItem>();
foreach (Search.RecordingInformation info in Search.SearchStorage.Instance.Recordings)
{
GetRecordingsResponseItem item = new GetRecordingsResponseItem();
item.RecordingToken = info.RecordingToken;
item.Configuration = new RecordingConfiguration();
item.Configuration.Source = new RecordingSourceInformation();
item.Configuration.Source.Description = info.Source.Description;
item.Configuration.Source.Address = info.Source.Address;
item.Configuration.Source.Location = info.Source.Location;
item.Configuration.Source.Name = info.Source.Name;
item.Configuration.Source.SourceId = info.Source.SourceId;
item.Configuration.Content = info.Content;
item.Configuration.MaximumRetentionTime = "PT10S";
item.Tracks = new GetTracksResponseList();
List <GetTracksResponseItem> trackItems = new List <GetTracksResponseItem>();
bool first = true;
foreach (Search.TrackInformation track in info.Track)
{
//if (info.RecordingToken.EndsWith("1"))
//{
// if (first)
// {
// first = false;
// continue;
// }
//}
GetTracksResponseItem trackItem = new GetTracksResponseItem();
trackItem.TrackToken = track.TrackToken;
trackItem.Configuration = new TrackConfiguration();
trackItem.Configuration.Description = track.Description;
trackItem.Configuration.TrackType = (TrackType)((int)track.TrackType);
//if (info.RecordingToken.EndsWith("2"))
//{
// trackItem.Configuration.TrackType = (TrackType)(3-(int)track.TrackType);
//}
trackItems.Add(trackItem);
}
item.Tracks.Track = trackItems.ToArray();
items.Add(item);
}
return(items.ToArray());
}
protected void DeleteRecordingIfNecessary(GetRecordingsResponseItem[] recordings,
out String recordingTokenDeleted,
out RecordingConfiguration oldConfig)
{
bool isDeleted = false;
oldConfig = null;
recordingTokenDeleted = null;
foreach (GetRecordingsResponseItem recording in recordings)
{
try
{
// Saving of old config to restore it later
oldConfig = GetRecordingConfiguration(recording.RecordingToken);
DeleteRecording(recording.RecordingToken);
isDeleted = true;
recordingTokenDeleted = recording.RecordingToken;
break;
}
catch (FaultException exc)
{
if (exc.IsValidOnvifFault("Receiver/Action/CannotDelete"))
{
LogStepEvent(string.Format("Can't delete recording (token = {0})", recording.RecordingToken));
StepPassed();
}
else
{
StepFailed(exc);
}
}
}
// In case if deleting of every recording caused "Receiver/Action/CannotDelete" fault
Assert(isDeleted == true, "No one recording was deleted", "Checking if some recording was deleted");
// Checking if recording was deleted in reality
if (isDeleted == true && recordingTokenDeleted != null)
{
GetRecordingsResponseItem[] recordingsRefreshed = GetRecordings();
String recordingTokenDeletedCopy = recordingTokenDeleted;
GetRecordingsResponseItem recording =
recordingsRefreshed.FirstOrDefault(r => r.RecordingToken == recordingTokenDeletedCopy);
Assert(recording == null, string.Format("Recording (token = {0}) was not deleted in reality", recordingTokenDeleted),
"Validation of deleted recording");
}
}
private void CheckRecordingListChanged(GetRecordingsResponseItem[] prevList, GetRecordingsResponseItem[] newList)
{
GetRecordingsResponseItem recording = null;
StringBuilder logger = new StringBuilder();
bool ok = true;
if (prevList != null && newList != null)
{
if (prevList.Count() != newList.Count())
{
ok = false;
logger.AppendLine(string.Format("The initial recording list contain different number of recordings"));
}
else
{
foreach (var item in newList)
{
recording = prevList.FirstOrDefault(r => r.RecordingToken == item.RecordingToken);
if (recording == null)
{
ok = false;
logger.AppendLine(string.Format("First recording list doesn't contain recording with token '{0}'", item.RecordingToken));
}
else
{
ok = ok && CompareRecordings(item, recording, logger);
}
}
}
}
else
{
if (prevList != null && newList == null)
{
ok = false;
logger.AppendLine("New recording list doesn't contain any recordings, while previous is not empty");
}
if (prevList == null && newList != null && newList.Any())
{
ok = false;
logger.AppendLine("New recording list is not empty");
}
}
Assert(ok, logger.ToStringTrimNewLine(),
"Check that initial recording list wasn't changed");
}
private bool CompareRecordingTracks(GetRecordingsResponseItem oldRecording, GetRecordingsResponseItem newRecording, StringBuilder logger)
{
bool ok = true;
GetTracksResponseItem track = null;
if (oldRecording.Tracks.Track == null && newRecording.Tracks.Track != null)
{
ok = false;
logger.Append("Initial track list was changed");
return(ok);
}
else if (oldRecording.Tracks.Track != null && newRecording.Tracks.Track == null)
{
ok = false;
logger.Append("Initial track list was changed");
return(ok);
}
else if (oldRecording.Tracks.Track == null && newRecording.Tracks.Track == null)
{
ok = true;
return(ok);
}
if (oldRecording.Tracks.Track.Length != newRecording.Tracks.Track.Length)
{
ok = false;
logger.Append("Initial track list was changed");
return(ok);
}
foreach (var item in oldRecording.Tracks.Track)
{
track = newRecording.Tracks.Track.FirstOrDefault(t => t.TrackToken == item.TrackToken);
if (track == null)
{
ok = false;
logger.Append("Initial track list was changed");
}
else
{
ok &= CompareTracks(item, track, logger, oldRecording.RecordingToken);
}
}
return(ok);
}
private void CheckTrackListChanged_AllRecordings(GetRecordingsResponseItem[] oldRecordings,
GetRecordingsResponseItem[] newRecordings,
string stepName)
{
GetRecordingsResponseItem recording = null;
StringBuilder logger = new StringBuilder();
bool ok = true;
if (oldRecordings != null && newRecordings != null)
{
if (oldRecordings.Length != newRecordings.Length)
{
ok = false;
logger.Append("Initial recording list was changed");
Assert(ok, logger.ToStringTrimNewLine(), stepName);
}
foreach (var item in newRecordings)
{
recording = oldRecordings.FirstOrDefault(r => r.RecordingToken == item.RecordingToken);
if (recording == null)
{
ok = false;
logger.Append("Initial recording list was changed");
}
else
{
ok &= CompareRecordingTracks(item, recording, logger);
}
}
}
else
{
if (oldRecordings != null && newRecordings == null)
{
ok = false;
logger.AppendLine("Initial recording list was changed");
}
if (oldRecordings == null && newRecordings != null && newRecordings.Length > 0)
{
ok = false;
logger.AppendLine("Initial recording list was changed");
}
}
Assert(ok, logger.ToStringTrimNewLine(), stepName);
}
public void DynamicTrackConfigurationTest()
{
string recordingToken = string.Empty;
string trackTypeStr = string.Empty;
string trackToken = string.Empty;
bool isTrackDeleted = false;
bool isTrackCreated = false;
bool isRecordingCreated = false;
TrackConfiguration deletedTrackConf = null;
RunTest(() =>
{
// A.14 - Selection of Recording for track creation
GetRecordingForTrackCreation(out recordingToken,
out trackTypeStr,
out isRecordingCreated,
out isTrackDeleted, out deletedTrackConf);
TrackType trackType = (trackTypeStr == "Video" ? TrackType.Video :
(trackTypeStr == "Audio" ? TrackType.Audio :
(trackTypeStr == "Metadata" ? TrackType.Metadata : TrackType.Extended)));
// prepare track configuration
var trackConf = new TrackConfiguration();
trackConf.Description = "New Track";
trackConf.TrackType = trackType;
// get initial recordings
GetRecordingsResponseItem[] recordingsInitial = GetRecordings();
Assert(recordingsInitial != null, "Recording list is empty", "Check that recording list is not empty");
// create track
trackToken = CreateTrack(recordingToken, trackConf);
isTrackCreated = true;
// check that created track token is not presented in selected recording (from initial track list)
GetRecordingsResponseItem recordingInitial = recordingsInitial.FirstOrDefault(rec => rec.RecordingToken == recordingToken);
GetTracksResponseItem track = null;
if (recordingInitial.Tracks.Track != null)
{
track = recordingInitial.Tracks.Track.FirstOrDefault(t => t.TrackToken == trackToken);
}
Assert(track == null,
String.Format("Track (token = {0}) has already presented in recording (token = {1})", trackToken, recordingToken),
String.Format("Check that new track (token = {0}) wasn't presented in recording (token = {1})", trackToken, recordingToken));
// get updated recordings (after CreateTrack)
GetRecordingsResponseItem[] recordingsUpdated = GetRecordings();
Assert(recordingsUpdated != null, "Recording list is empty", "Check that recording list is not empty");
// check that created track token is presented in selected recording (from updated track list)
GetRecordingsResponseItem recordingUpdated = recordingsUpdated.FirstOrDefault(rec => rec.RecordingToken == recordingToken);
Assert(recordingUpdated != null, "Recording is not found",
string.Format("Check that recording (token = {0}) exists in updated recording list", recordingToken));
GetTracksResponseItem track2 = null;
if (recordingUpdated.Tracks.Track != null)
{
track2 = recordingUpdated.Tracks.Track.FirstOrDefault(t => t.TrackToken == trackToken);
}
Assert(track2 != null,
String.Format("Track (token = {0}) isn't presented in recording (token = {1})", trackToken, recordingToken),
String.Format("Check that new track (token = {0}) is presented in recording (token = {1})", trackToken, recordingToken));
// check track parameters
CheckRecordingTrack(track2, trackConf);
// check that all other tracks for initial selected recording
// have the same parameters as for updated selected recording
GetTracksResponseItem[] trackInitialOther = null;
if (recordingInitial.Tracks.Track != null)
{
trackInitialOther = (recordingInitial.Tracks.Track.Where(tr => tr.TrackToken != trackToken)).ToArray <GetTracksResponseItem>();
}
GetTracksResponseItem[] trackUpdatedOther = null;
if (recordingUpdated.Tracks.Track != null)
{
trackUpdatedOther = (recordingUpdated.Tracks.Track.Where(tr => tr.TrackToken != trackToken)).ToArray <GetTracksResponseItem>();
}
if (trackInitialOther != null && trackInitialOther.Length == 0)
{
trackInitialOther = null;
}
if (trackUpdatedOther != null && trackUpdatedOther.Length == 0)
{
trackUpdatedOther = null;
}
CheckTrackListChanged(trackInitialOther, trackUpdatedOther,
string.Format("Check that initial track list of recording (token = {0}) wasn't changed", recordingInitial.RecordingToken));
// check that all other recordings have the same parameters value
// as before creating a track
GetRecordingsResponseItem[] recordingsInitialOther = null;
if (recordingsInitial != null)
{
recordingsInitialOther = (recordingsInitial.Where(rec => rec.RecordingToken != recordingToken)).ToArray <GetRecordingsResponseItem>();
}
GetRecordingsResponseItem[] recordingsUpdatedOther = null;
if (recordingsUpdated != null)
{
recordingsUpdatedOther = (recordingsUpdated.Where(rec => rec.RecordingToken != recordingToken)).ToArray <GetRecordingsResponseItem>();
}
if (recordingsInitialOther != null && recordingsInitialOther.Length == 0)
{
recordingsInitialOther = null;
}
if (recordingsUpdatedOther != null && recordingsUpdatedOther.Length == 0)
{
recordingsUpdatedOther = null;
}
// check that after CreateTrack
// all tracks of all other recordings are the same
CheckTrackListChanged_AllRecordings(recordingsInitialOther, recordingsUpdatedOther,
"Check that initial track list of other existing recordings wasn't changed after CreateTrack");
// delete track
DeleteTrack(recordingToken, trackToken);
isTrackCreated = false;
// get updated recordings (after DeleteTrack)
GetRecordingsResponseItem[] recordingsUpdated2 = GetRecordings();
Assert(recordingsUpdated2 != null, "Recording list is empty", "Check that recording list is not empty");
// check that deleted track token is no longer presented in selected recording (from updated track list after deletion)
GetRecordingsResponseItem recordingUpdated2 = recordingsUpdated2.FirstOrDefault(rec => rec.RecordingToken == recordingToken);
Assert(recordingUpdated2 != null, "Recording is not found",
string.Format("Check that recording (token = {0}) exists in updated recording list", recordingToken));
GetTracksResponseItem track3 = null;
if (recordingUpdated2.Tracks.Track != null)
{
track3 = recordingUpdated2.Tracks.Track.FirstOrDefault(t => t.TrackToken == trackToken);
}
Assert(track3 == null,
String.Format("Track (token = {0}) is still presented in recording (token = {1})", trackToken, recordingToken),
String.Format("Check that deleted track (token = {0}) is no longer presented in recording (token = {1})", trackToken, recordingToken));
// check that before CreateTrack all other tracks in selected recording
// have the same parameters as after DeleteTrack
CheckTrackListChanged(recordingInitial.Tracks.Track, recordingUpdated2.Tracks.Track,
string.Format("Check that initial track list of recording (token = {0}) wasn't changed", recordingInitial.RecordingToken));
// check that afteer CreateTrack + DeleteTrack
// all tracks of all recordings are the same
CheckTrackListChanged_AllRecordings(recordingsInitial, recordingsUpdated2,
"Check that initial track list of existing recordings wasn't changed");
}, () =>
{
if (isTrackCreated || isRecordingCreated || isTrackDeleted)
{
LogTestEvent(string.Format("Restoring the initial settings...{0}", Environment.NewLine));
}
// reverting changes made during test
if (isTrackCreated && !string.IsNullOrEmpty(trackToken))
{
DeleteTrack(recordingToken, trackToken);
}
// reverting changes made during A.14
if (isRecordingCreated && !string.IsNullOrEmpty(recordingToken))
{
DeleteRecording(recordingToken);
}
// reverting changes made during A.14
if (isTrackDeleted && !string.IsNullOrEmpty(recordingToken) && deletedTrackConf != null)
{
CreateTrack(recordingToken, deletedTrackConf);
}
});
}
protected void CheckRecording(RecordingServiceCapabilities capabilities, GetRecordingsResponseItem recording, RecordingConfiguration conf)
{
//var recording = recordings.Where(r => r.RecordingToken == recordingToken).FirstOrDefault();
//Assert(recording != null,
// "recording list doesn't contain new recording",
// "Check that recording list contains new recording after refresh");
bool ok = true;
StringBuilder logger = new StringBuilder();
if (recording.Configuration.MaximumRetentionTime != conf.MaximumRetentionTime)
{
ok = false;
logger.Append(string.Format("MaximumRetentionTime is invalid{0}", Environment.NewLine));
}
if (recording.Configuration.Content != conf.Content)
{
ok = false;
logger.Append(string.Format("Content is '{0}' but must be '{1}'{2}",
recording.Configuration.Content, conf.Content, Environment.NewLine));
}
if (recording.Configuration.Source != null)
{
if (recording.Configuration.Source.Address != conf.Source.Address)
{
ok = false;
logger.Append(string.Format("Source Address is '{0}' but must be '{1}'{2}",
recording.Configuration.Source.Address, conf.Source.Address,
Environment.NewLine));
}
if (recording.Configuration.Source.Description != conf.Source.Description)
{
ok = false;
logger.Append(string.Format("Source Description is '{0}' but must be '{1}'{2}",
recording.Configuration.Source.Description, conf.Source.Description,
Environment.NewLine));
}
if (recording.Configuration.Source.Location != conf.Source.Location)
{
ok = false;
logger.Append(string.Format("Source Location is '{0}' but must be '{1}'{2}",
recording.Configuration.Source.Location, conf.Source.Location,
Environment.NewLine));
}
if (recording.Configuration.Source.Name != conf.Source.Name)
{
ok = false;
logger.Append(string.Format("Source Name is '{0}' but must be '{1}'{2}",
recording.Configuration.Source.Name, conf.Source.Name,
Environment.NewLine));
}
if (recording.Configuration.Source.SourceId != conf.Source.SourceId)
{
ok = false;
logger.Append(string.Format("Source SourceId is '{0}' but must be '{1}'{2}",
recording.Configuration.Source.SourceId, conf.Source.SourceId,
Environment.NewLine));
}
}
else
{
ok = false;
logger.Append(string.Format("recording doesn't contain Source{0}", Environment.NewLine));
}
if (recording.Tracks == null || recording.Tracks.Track == null)
{
ok = false;
logger.Append(string.Format("Track list of recording '{0}' is empty", recording.RecordingToken));
}
else
{
foreach (TrackType type in Enum.GetValues(typeof(TrackType)))
{
if (type != TrackType.Extended)
{
//if (recording.Tracks.Track.FirstOrDefault(t => t.Configuration.TrackType == type) == null)
//{
// ok = false;
// logger.Append(string.Format("Recording doesn't contain tracks with track type '{0}'{1}", type, Environment.NewLine));
//}
var actualTrackCount = recording.Tracks.Track.Count(t => t.Configuration.TrackType == type);
if (TrackType.Audio == type)
{
var audioEncodingsCount = capabilities.Encoding.Count(e =>
{
AudioEncoding v;
return(AudioEncoding.TryParse(e, out v));
});
if (0 != audioEncodingsCount)
{
var flag = (1 <= actualTrackCount);
if (!flag)
{
logger.AppendLine(string.Format("There are no tracks of type: '{0}'.", type));
}
ok = ok && flag;
}
}
if (TrackType.Video == type)
{
var videoEncodingsCount = capabilities.Encoding.Count(e =>
{
VideoEncoding v;
return(VideoEncoding.TryParse(e, out v));
});
if (0 != videoEncodingsCount)
{
var flag = (1 <= actualTrackCount);
if (!flag)
{
logger.AppendLine(string.Format("There are no tracks of type: '{0}'.", type));
}
ok = ok && flag;
}
}
if (TrackType.Metadata == type && Features.ContainsFeature(Feature.MetadataRecording))
{
var flag = (1 <= actualTrackCount);
if (!flag)
{
logger.AppendLine(string.Format("There are no tracks of type: '{0}'.", type));
}
ok = ok && flag;
}
}
}
}
Assert(ok, logger.ToStringTrimNewLine(), "Check that configuration parameters of new recording are valid");
}
protected void CheckRecording(GetRecordingsResponseItem recording, RecordingConfiguration conf)
{
//var recording = recordings.Where(r => r.RecordingToken == recordingToken).FirstOrDefault();
//Assert(recording != null,
// "recording list doesn't contain new recording",
// "Check that recording list contains new recording after refresh");
bool ok = true;
StringBuilder logger = new StringBuilder();
if (recording.Configuration.MaximumRetentionTime != conf.MaximumRetentionTime)
{
ok = false;
logger.Append(string.Format("MaximumRetentionTime is invalid{0}", Environment.NewLine));
}
if (recording.Configuration.Content != conf.Content)
{
ok = false;
logger.Append(string.Format("Content is '{0}' but must be '{1}'{2}",
recording.Configuration.Content, conf.Content, Environment.NewLine));
}
if (recording.Configuration.Source != null)
{
if (recording.Configuration.Source.Address != conf.Source.Address)
{
ok = false;
logger.Append(string.Format("Source Address is '{0}' but must be '{1}'{2}",
recording.Configuration.Source.Address, conf.Source.Address,
Environment.NewLine));
}
if (recording.Configuration.Source.Description != conf.Source.Description)
{
ok = false;
logger.Append(string.Format("Source Description is '{0}' but must be '{1}'{2}",
recording.Configuration.Source.Description, conf.Source.Description,
Environment.NewLine));
}
if (recording.Configuration.Source.Location != conf.Source.Location)
{
ok = false;
logger.Append(string.Format("Source Location is '{0}' but must be '{1}'{2}",
recording.Configuration.Source.Location, conf.Source.Location,
Environment.NewLine));
}
if (recording.Configuration.Source.Name != conf.Source.Name)
{
ok = false;
logger.Append(string.Format("Source Name is '{0}' but must be '{1}'{2}",
recording.Configuration.Source.Name, conf.Source.Name,
Environment.NewLine));
}
if (recording.Configuration.Source.SourceId != conf.Source.SourceId)
{
ok = false;
logger.Append(string.Format("Source SourceId is '{0}' but must be '{1}'{2}",
recording.Configuration.Source.SourceId, conf.Source.SourceId,
Environment.NewLine));
}
}
else
{
ok = false;
logger.Append(string.Format("recording doesn't contain Source{0}",
Environment.NewLine));
}
if (recording.Tracks == null || recording.Tracks.Track == null)
{
ok = false;
logger.Append(string.Format("Track list of recording '{0}' is empty", recording.RecordingToken));
}
else
{
foreach (var type in Enum.GetValues(typeof(TrackType)))
{
if ((TrackType)type != TrackType.Extended)
{
if (recording.Tracks.Track.FirstOrDefault(
t => t.Configuration.TrackType == (TrackType)type) == null)
{
ok = false;
logger.Append(string.Format("Recording doesn't contain tracks with track type '{0}'{1}",
(TrackType)type, Environment.NewLine));
}
}
}
}
Assert(ok, logger.ToStringTrimNewLine(),
"Check that configuration parameters of new recording are valid");
}
