private static void VerifyManifestDeletion(string id)
{
CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IIngestManifest expectedNull = context.IngestManifests.Where(c => c.Id == id).FirstOrDefault();
Assert.IsNull(expectedNull, "Manifest has not been deleted as expected");
}
public void ShouldDeleteAssetAndKeepAzureContainer()
{
IAsset asset = CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None);
Assert.AreEqual(AssetState.Initialized, asset.State);
foreach (ILocator locator in asset.Locators)
{
locator.Delete();
}
var result = asset.DeleteAsync(true).Result;
Assert.IsNull(_mediaContext.Assets.Where(a => a.Id == asset.Id).SingleOrDefault());
CloudMediaContext newContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
Assert.IsNull(newContext.Assets.Where(a => a.Id == asset.Id).SingleOrDefault());
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(WindowsAzureMediaServicesTestConfiguration.ClientStorageConnectionString);
string containername = asset.Id.Replace("nb:cid:UUID:", "asset-");
var client = storageAccount.CreateCloudBlobClient();
var container = client.GetContainerReference(containername);
Assert.IsTrue(container.Exists(), "Asset container {0} can't be found", container);
}
public static void ClassInit(TestContext context)
{
//CreateCounters();
_mediaContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IContentKeyAuthorizationPolicyOption policyOption = null;
for (int i = 0; i < 10; i++)
{
byte[] expectedKey = null;
IContentKey contentKey = GetKeyDeliveryUrlTests.CreateTestKey(_mediaContext, ContentKeyType.EnvelopeEncryption, out expectedKey);
policyOption = ContentKeyAuthorizationPolicyOptionTests.CreateOption(_mediaContext, String.Empty, ContentKeyDeliveryType.BaselineHttp, null, null, ContentKeyRestrictionType.Open);
List <IContentKeyAuthorizationPolicyOption> options = new List <IContentKeyAuthorizationPolicyOption>
{
policyOption
};
GetKeyDeliveryUrlTests.CreateTestPolicy(_mediaContext, String.Empty, options, ref contentKey);
Uri keyDeliveryServiceUri = contentKey.GetKeyDeliveryUrl(ContentKeyDeliveryType.BaselineHttp);
Assert.IsNotNull(keyDeliveryServiceUri);
string rawkey = EncryptionUtils.GetKeyIdAsGuid(contentKey.Id).ToString();
_testData.Add(new Tuple <Uri, string, string>(keyDeliveryServiceUri, TokenServiceClient.GetAuthTokenForKey(rawkey), GetKeyDeliveryUrlTests.GetString(expectedKey)));
}
}
public void ShouldDeleteAssetWithCommonEncryptionContentKey()
{
var dataContext2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
// Note that this file is not really PlayReady encrypted. For the purposes of this test that is okay.
IAsset asset = AssetTests.CreateAsset(_mediaContext, Path.GetFullPath(WindowsAzureMediaServicesTestConfiguration.SmallWmv), AssetCreationOptions.CommonEncryptionProtected);
string assetId = asset.Id;
string fileId = asset.AssetFiles.ToList()[0].Id;
Guid keyId = Guid.NewGuid();
byte[] contentKeyBytes = GetRandomBuffer(16);
IContentKey key = _mediaContext.ContentKeys.Create(keyId, contentKeyBytes);
asset.ContentKeys.Add(key);
string keyIdentifier = key.Id;
asset.Delete();
IAsset resultAsset = dataContext2.Assets.Where(a => a.Id == assetId).FirstOrDefault();
Assert.IsNull(resultAsset, "Asset was deleted we should not be able to query it by identifier.");
IAssetFile resultFile = dataContext2.Files.Where(f => f.Id == fileId).FirstOrDefault();
Assert.IsNull(resultFile, "Asset was deleted we should not be able to query its associated File by identifier.");
// The content key should not exists
IContentKey resultContentKey = dataContext2.ContentKeys.Where(c => c.Id == keyIdentifier).FirstOrDefault();
Assert.IsNull(resultContentKey, "Common Encryption Content Key should be deleted by deleting the asset");
}
public void EncryptManifestTestDisableOverwriteExistingFile()
{
CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
var sourcePath = DeploymentFolder1;
Assert.IsTrue(Directory.Exists(sourcePath));
List <string> files = Directory.EnumerateFiles(sourcePath, "*.txt").ToList();
const string manifestName = "Manifest 1";
IIngestManifest ingestManifestCreated = context.IngestManifests.Create(manifestName);
//Adding manifest asset info with multiple file
IAsset emptyAsset = context.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted);
IIngestManifestAsset ingestManifestAsset = ingestManifestCreated.IngestManifestAssets.Create(emptyAsset, files.ToArray());
var path = @".\Resources\TestFiles\" + Guid.NewGuid();
try
{
Directory.CreateDirectory(path);
string dupFileName = Path.Combine(path, Path.GetFileName(files[0]));
File.WriteAllText(dupFileName, "");
ingestManifestCreated.EncryptFiles(path, false);
}
catch (AggregateException ax)
{
var expectedExcpetion = ax.GetBaseException() as IOException;
throw expectedExcpetion;
}
finally
{
AssetFilesTests.CleanDirectory(path);
}
}
private static void FindLocatorByNameAndVerifyIt(string locatorNameToSearch, string expectedLocatorId)
{
var context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
var updated = context2.Locators.Where(c => c.Name == locatorNameToSearch).FirstOrDefault();
Assert.AreEqual(updated.Id, expectedLocatorId);
}
private static void EncryptFilesDecryptAndCompare(List <string> files)
{
CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
//Creating empty manifest
const string manifestName = "Manifest 1";
IIngestManifest ingestManifestCreated = context.IngestManifests.Create(manifestName);
//Adding manifest asset info with multiple file
IAsset emptyAsset = context.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted);
IIngestManifestAsset ingestManifestAsset = ingestManifestCreated.IngestManifestAssets.CreateAsync(emptyAsset, files.ToArray(), CancellationToken.None).Result;
var path = @".\Resources\TestFiles\" + Guid.NewGuid();
Directory.CreateDirectory(path);
ingestManifestCreated.EncryptFiles(path);
Dictionary <string, string> filePaths = new Dictionary <string, string>();
foreach (var filePath in files)
{
FileInfo fileInfo = new FileInfo(filePath);
filePaths.Add(fileInfo.Name, filePath);
}
foreach (var assetFile in ingestManifestAsset.IngestManifestFiles)
{
var encryptedPath = Path.Combine(path, assetFile.Name);
Assert.IsTrue(File.Exists(encryptedPath));
var decryptedPath = DecryptedFile(assetFile, encryptedPath, context);
Assert.IsTrue(AssetTests.CompareFiles(decryptedPath, filePaths[assetFile.Name]), "Original file and Decrypted are not same");
}
}
public void ShouldThrowExceptionWhenAttemptingToCreateManifestAssetFromContextCollection()
{
CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IAsset asset1 = context.Assets.Create("Asset1", AssetCreationOptions.CommonEncryptionProtected);
context.IngestManifestAssets.Create(asset1, new[] { "C:\\temp.txt" });
}
public void ExpirationTimeOfCreatedLocatorShouldMatchLocatorStartTimePlusPolicyDuration()
{
// Arrange
var accessPolicy = _mediaContext.AccessPolicies.Create("TestPolicy", TimeSpan.FromMinutes(10), AccessPermissions.List | AccessPermissions.Read);
var asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None);
DateTime locatorStartTime = DateTime.Now.AddHours(1);
// Act
var locatorTask = _mediaContext.Locators.CreateLocatorAsync(LocatorType.Sas, asset, accessPolicy, locatorStartTime.ToUniversalTime(), null);
locatorTask.Wait();
var locator = locatorTask.Result;
var context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
var actual = context2.Locators.Where(x => x.Id == locator.Id).FirstOrDefault();
// Assert
Assert.IsNotNull(actual);
Assert.AreEqual(locator.Id, actual.Id);
Assert.IsNotNull(actual.Path);
Assert.AreEqual(asset.Id, actual.Asset.Id);
Assert.AreEqual(asset.Name, actual.Asset.Name);
Assert.AreEqual(accessPolicy.Id, actual.AccessPolicy.Id);
var expectedExpiration = locatorStartTime.Add(accessPolicy.Duration).ToUniversalTime();
Assert.AreEqual(expectedExpiration, locator.ExpirationDateTime);
}
public void ShouldCreateLocatorWhenCreateSasLocatorAsyncCalled()
{
// Arrange
var accessPolicy = _mediaContext.AccessPolicies.Create("TestPolicy", TimeSpan.FromMinutes(10), AccessPermissions.List | AccessPermissions.Read);
var asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None);
// Act
var task = _mediaContext.Locators.CreateSasLocatorAsync(asset, accessPolicy);
task.Wait();
var locator = task.Result;
var context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
var actual = context2.Locators.Where(x => x.Id == locator.Id).FirstOrDefault();
// Assert
Assert.IsNotNull(actual);
Assert.AreEqual(locator.Id, actual.Id);
Assert.IsNotNull(actual.Path);
Assert.IsTrue(actual.ExpirationDateTime < DateTime.UtcNow.AddMinutes(11));
Assert.AreEqual(asset.Id, actual.Asset.Id);
Assert.AreEqual(asset.Name, actual.Asset.Name);
Assert.AreEqual(accessPolicy.Id, actual.AccessPolicy.Id);
}
public void ShouldUpdateExpiryTimeWhenUpdateLocatorAsyncCalledWithStartAndExpiryTime()
{
// Arrange
var accessPolicyDuration = TimeSpan.FromHours(2);
var expectedExpiryTime = DateTime.UtcNow.Date.AddDays(2);
var expectedStartTime = DateTime.UtcNow.Date.AddDays(1);
var accessPolicy = _mediaContext.AccessPolicies.Create("TestPolicy", accessPolicyDuration, AccessPermissions.Read);
var asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None);
var locator = _mediaContext.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset, accessPolicy);
// Act
var task = locator.UpdateAsync(expectedStartTime, expectedExpiryTime);
task.Wait();
var context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
var actual = context2.Locators.Where(x => x.Id == locator.Id).FirstOrDefault();
// Assert
Assert.AreEqual(expectedStartTime, locator.StartTime);
Assert.AreEqual(expectedExpiryTime, locator.ExpirationDateTime);
Assert.AreEqual(expectedExpiryTime, actual.ExpirationDateTime);
}
public void ListAssetsAndFilesForNewlyCreatedManifests()
{
IIngestManifest ingestManifest = CreateEmptyManifestAndVerifyIt();
IAsset asset = _mediaContext.Assets.Create("name", AssetCreationOptions.None);
Assert.IsNotNull(asset);
IIngestManifestAsset ingestManifestAsset = ingestManifest.IngestManifestAssets.Create(asset, new[] { TestFile1 });
VerifyManifestAsset(ingestManifestAsset);
IIngestManifestAsset firstAsset = ingestManifest.IngestManifestAssets.FirstOrDefault();
VerifyManifestAsset(firstAsset);
Assert.AreEqual(ingestManifestAsset.Id, firstAsset.Id);
_mediaContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IIngestManifest sameIngestManifest = _mediaContext.IngestManifests.Where(c => c.Id == ingestManifest.Id).FirstOrDefault();
Assert.IsNotNull(sameIngestManifest);
Assert.AreEqual(1, sameIngestManifest.IngestManifestAssets.Count(), "Manifest asset count is not matching expecting value 1");
firstAsset = sameIngestManifest.IngestManifestAssets.FirstOrDefault();
VerifyManifestAsset(firstAsset);
Assert.AreEqual(1, firstAsset.IngestManifestFiles.Count(), "Manifest file count is not matching expecting value 1");
IIngestManifestFile firstFile = firstAsset.IngestManifestFiles.FirstOrDefault();
Assert.AreEqual("text/plain", firstFile.MimeType, "IngestManifestFile's MimeType is wrong");
VerifyManifestFile(firstFile);
}
public void ShouldCancelDownloadToFileAsyncTaskAfter50Milliseconds()
{
string fileUploaded = _smallWmv;
string outputDirectory = "Download" + Guid.NewGuid();
string fileDownloaded = Path.Combine(outputDirectory, Path.GetFileName(fileUploaded));
IAsset asset = AssetTests.CreateAsset(_mediaContext, Path.GetFullPath(fileUploaded), AssetCreationOptions.StorageEncrypted);
IAssetFile assetFile = asset.AssetFiles.First();
Assert.AreEqual(assetFile.Asset.Id, asset.Id);
Assert.AreEqual(1, asset.Locators.Count);
CleanDirectory(outputDirectory);
var source = new CancellationTokenSource();
IAccessPolicy accessPolicy = _mediaContext.AccessPolicies.Create("SdkDownload", TimeSpan.FromHours(12), AccessPermissions.Read);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, accessPolicy);
BlobTransferClient blobTransferClient = _mediaContext.MediaServicesClassFactory.GetBlobTransferClient();
Exception canceledException = null;
Task downloadToFileTask = null;
try
{
downloadToFileTask = assetFile.DownloadAsync(fileDownloaded, blobTransferClient, locator, source.Token);
// Send a cancellation signal after 2 seconds.
Thread.Sleep(50);
source.Cancel();
// Block the thread waiting for the job to finish.
downloadToFileTask.Wait();
}
catch (AggregateException exception)
{
Assert.AreEqual(1, exception.InnerExceptions.Count);
canceledException = exception.InnerException;
}
finally
{
if (File.Exists(fileDownloaded))
{
File.Delete(fileDownloaded);
}
}
Assert.IsNotNull(canceledException);
Assert.IsInstanceOfType(canceledException, typeof(OperationCanceledException));
// The async task ends in a Canceled state.
Assert.AreEqual(TaskStatus.Canceled, downloadToFileTask.Status);
CloudMediaContext newContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IAsset retreivedAsset = newContext.Assets.Where(a => a.Id == asset.Id).Single();
Assert.AreEqual(2, retreivedAsset.Locators.Count);
}
private static void VerifyAssetStateAndDelete(IngestManifestState expectedState, string id)
{
IIngestManifest ingestManifest = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext().IngestManifests.Where(c => c.Id == id).FirstOrDefault();
Assert.IsNotNull(ingestManifest);
Assert.AreEqual(expectedState, ingestManifest.State);
ingestManifest.Delete();
}
private static void VerifyNameForExitingManifest(IIngestManifest ingestManifest, string newName, string id)
{
CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IIngestManifest updatedIngestManifest = context.IngestManifests.Where(c => c.Id == id).FirstOrDefault();
Assert.IsNotNull(updatedIngestManifest);
Assert.AreSame(newName, ingestManifest.Name);
}
public void MediaServicesCredentialsTestAuthorizationHeader()
{
var credentials = WindowsAzureMediaServicesTestConfiguration.CreateMediaServicesCredentials();
var header = credentials.GetAuthorizationHeader();
Assert.IsNotNull(header);
Assert.AreEqual("Bearer " + credentials.AccessToken, header);
}
public void SetupTest()
{
_mediaContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
_smallWmv = WindowsAzureMediaServicesTestConfiguration.GetVideoSampleFilePath(TestContext,
WindowsAzureMediaServicesTestConfiguration.SmallWmv);
_largeFile = WindowsAzureMediaServicesTestConfiguration.GetVideoSampleFilePath(TestContext, "largeFile");
_emptyFile = WindowsAzureMediaServicesTestConfiguration.GetVideoSampleFilePath(TestContext, "emptyFile");
_outputDirectory = "MediaDownloads";
}
public void CreateEmptyBulkIngestManifestAsync()
{
CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
const string manifestName = "";
Task <IIngestManifest> taskManifest = context.IngestManifests.CreateAsync(manifestName);
IIngestManifest ingestManifest = taskManifest.Result;
Assert.IsTrue(String.IsNullOrEmpty(ingestManifest.Name));
}
public static void VerifyAllTasksFinished(string jobId)
{
CloudMediaContext context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IJob job2 = context2.Jobs.Where(c => c.Id == jobId).Single();
Assert.AreEqual(JobState.Finished, job2.State);
foreach (ITask task in job2.Tasks)
{
Assert.AreEqual(JobState.Finished, task.State);
}
}
public void MediaServicesCredentialsTestGetToken()
{
MediaServicesCredentials target = WindowsAzureMediaServicesTestConfiguration.CreateMediaServicesCredentials();
Assert.IsNull(target.AccessToken);
Assert.IsTrue(target.TokenExpiration < DateTime.UtcNow);
target.RefreshToken();
Assert.IsNotNull(target.AccessToken);
Assert.IsTrue(target.AccessToken.Length > 0);
Assert.IsTrue(target.TokenExpiration > DateTime.UtcNow.AddHours(1));
}
public void When_Uploading_Multiple_Files_The_Progress_Event_Should_Only_Be_For_The_Bound_AssetFile()
{
IAsset asset = _mediaContext.Assets.Create("test", AssetCreationOptions.None);
string fileUploaded = _smallWmv;
var file = new FileInfo(fileUploaded);
IAssetFile fileInfo = asset.AssetFiles.Create(Path.GetFileName(_smallWmv));
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(10),
AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateLocator(LocatorType.Sas, asset, policy);
var btc = new BlobTransferClient
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
};
int allProgressEventsFiredCount = 0;
btc.TransferProgressChanged += (sender, args) => { allProgressEventsFiredCount++; };
bool progressFired = false;
bool wrongFileSize = true;
int fileProgressEventsCount = 0;
fileInfo.UploadProgressChanged += (s, e) =>
{
progressFired = true;
wrongFileSize = e.TotalBytes != file.Length;
fileProgressEventsCount++;
};
Task uploadTask = fileInfo.UploadAsync(fileUploaded, btc, locator, CancellationToken.None);
string competingFile = WindowsAzureMediaServicesTestConfiguration.GetVideoSampleFilePath(TestContext,
WindowsAzureMediaServicesTestConfiguration.SmallMp41);
var retryPolicy =
_mediaContext.MediaServicesClassFactory.GetBlobStorageClientRetryPolicy()
.AsAzureStorageClientRetryPolicy();
btc.UploadBlob(CreateUrl(locator, Path.GetFileName(competingFile)), competingFile, null, null,
CancellationToken.None, retryPolicy).Wait();
uploadTask.Wait();
Assert.IsTrue(progressFired, "No upload progress event fired");
Assert.IsFalse(wrongFileSize, "Received the wrong file size from the upload progress event");
Assert.IsTrue(condition: fileProgressEventsCount < allProgressEventsFiredCount,
message:
"Unexpected number of fired events, it should be more than the events fired for the uploaded file.");
}
public void DeleteManifestShouldDeleteAllManifestAssetsAndFiles()
{
CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IIngestManifest ingestManifest = CreateManifestWithAssetsAndVerifyIt(context);
VerifyExistenceofAssetsAndFilesForManifest(ingestManifest, context);
ingestManifest.Delete();
context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
int assetsCount = context.IngestManifestAssets.Where(c => c.ParentIngestManifestId == ingestManifest.Id).Count();
int filescount = context.IngestManifestFiles.Where(c => c.ParentIngestManifestId == ingestManifest.Id).Count();
Assert.AreEqual(0, assetsCount, "There are assets belonging to manifest after manifest deletion");
Assert.AreEqual(0, filescount, "There are files belonging to manifest assets after manifest deletion");
}
public void MediaServicesCredentialsPassingAcsEndPoint()
{
var context1 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
string account = WindowsAzureMediaServicesTestConfiguration.MediaServiceAccountName;
string key = WindowsAzureMediaServicesTestConfiguration.MediaServiceAccountKey;
MediaServicesCredentials credentials = new MediaServicesCredentials(account, key, WindowsAzureMediaServicesTestConfiguration.MediaServicesAccessScope, WindowsAzureMediaServicesTestConfiguration.MediaServicesAcsBaseAddress);
Assert.IsNull(credentials.AccessToken);
Assert.IsTrue(credentials.TokenExpiration < DateTime.UtcNow);
credentials.RefreshToken();
Assert.IsNotNull(credentials.AccessToken);
Assert.IsTrue(credentials.AccessToken.Length > 0);
Assert.IsTrue(credentials.TokenExpiration > DateTime.UtcNow);
}
public void AddingAdditionalFilesToAssetInManifest()
{
IIngestManifest ingestManifestCreated = CreateManifestWithAssetsAndVerifyIt(_mediaContext);
_mediaContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
var ingestManifestRefreshed = _mediaContext.IngestManifests.Where(c => c.Id == ingestManifestCreated.Id).FirstOrDefault();
Assert.IsNotNull(ingestManifestRefreshed.Statistics);
Assert.IsNotNull(ingestManifestCreated.Statistics);
Assert.AreEqual(2, ingestManifestRefreshed.Statistics.PendingFilesCount);
AddFileToExistingManifestAssetInfo(_mediaContext, ingestManifestCreated.Id);
_mediaContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
ingestManifestRefreshed = _mediaContext.IngestManifests.Where(c => c.Id == ingestManifestCreated.Id).FirstOrDefault();
Assert.AreEqual(3, ingestManifestRefreshed.Statistics.PendingFilesCount);
}
public static void WaitForJob(string jobId, JobState jobState, Action <string> verifyAction, Action <double> progressChangedAction = null)
{
DateTime start = DateTime.Now;
while (true)
{
CloudMediaContext context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IJob job2 = context2.Jobs.Where(c => c.Id == jobId).Single();
ITask jobtask = job2.Tasks.Where(t => t.State == JobState.Processing).FirstOrDefault();
if (jobtask != null && jobtask.Progress > 0 && jobtask.Progress <= 100)
{
if (progressChangedAction != null)
{
progressChangedAction(jobtask.Progress);
}
}
if (job2.State == jobState)
{
verifyAction(jobId);
return;
}
if (job2.State == JobState.Error)
{
StringBuilder str = new StringBuilder();
str.AppendFormat("Job should not fail - Current State = {0} Expected State = {1} jobId = {2}", job2.State, jobState, jobId);
str.AppendLine();
foreach (var task in job2.Tasks)
{
foreach (var error in task.ErrorDetails)
{
str.AppendFormat("Error Code: {0} ErrorMessage: {1}", error.Code, error.Message);
str.AppendLine();
}
}
throw new Exception(str.ToString());
}
if (DateTime.Now - start > TimeSpan.FromMinutes(JobTimeOutInMinutes))
{
throw new Exception("Job Timed out - Current State " + job2.State.ToString() + " Expected State " + jobState + " jobId = " + jobId);
}
Thread.Sleep(TimeSpan.FromSeconds(10));
}
}
public void ShouldDeleteLocatorWhenDeleteLocatorCalled()
{
// Arrange
var accessPolicy = _mediaContext.AccessPolicies.Create("TestPolicy", TimeSpan.FromMinutes(10), AccessPermissions.List | AccessPermissions.Read);
var asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None);
var locator = _mediaContext.Locators.CreateSasLocator(asset, accessPolicy);
// Act
locator.Delete();
var context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
var actual = context2.Locators.Where(x => x.Id == locator.Id).FirstOrDefault();
// Assert
Assert.IsNull(actual);
}
public void MediaServicesCredentialsTestReuseToken()
{
var context1 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
Assert.IsNull(context1.Credentials.AccessToken);
//In order to obtain token REST call need to be issued
MakeRestCallAndVerifyToken(context1);
MediaServicesCredentials credentials = new MediaServicesCredentials("whatever", "whatever")
{
AccessToken = context1.Credentials.AccessToken,
TokenExpiration = context1.Credentials.TokenExpiration
};
var context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(credentials);
context2.Assets.FirstOrDefault();
}
private static string CreateManifestEncryptFiles(out List <IIngestManifestFile> files, out IIngestManifest ingestManifestCreated)
{
CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
ingestManifestCreated = CreateManifestWithAssetsAndVerifyIt(context);
var destination = @".\Resources\TestFiles\" + Guid.NewGuid();
Directory.CreateDirectory(destination);
ingestManifestCreated.EncryptFilesAsync(destination, CancellationToken.None).Wait();
var manifestid = ingestManifestCreated.Id;
//returning all encrypted files
files = context.IngestManifestFiles.Where(c => c.ParentIngestManifestId == manifestid && c.IsEncrypted == true).ToList();
Assert.AreEqual(2, files.Count);
return(destination);
}
public void ShouldSubmitAndFinishEETaskWithStorageProtectedInputAndClearOutput()
{
//
// This test uses the same preset as the EE DRM tests but does not apply
// common encryption. This preset gets split into multiple subtasks by EE.
//
IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted);
// Load the EE preset to create a smooth streaming presentation with PlayReady protection
string xmlPreset = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.EncodePlusEncryptWithEeXml);
// Remove the DRM Section to produce clear content
var doc = new XmlDocument();
doc.LoadXml(xmlPreset);
XmlNodeList drmNodes = doc.GetElementsByTagName("Drm");
Assert.AreEqual(1, drmNodes.Count);
XmlNode drmNode = drmNodes[0];
drmNode.ParentNode.RemoveChild(drmNode);
xmlPreset = doc.OuterXml;
IMediaProcessor processor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName);
IJob job = CreateAndSubmitOneTaskJob(_mediaContext, GenerateName("ShouldSubmitAndFinishEETaskWithStorageProtectedInputAndClearOutput"), processor, xmlPreset, asset, TaskOptions.None);
Assert.AreEqual(1, job.Tasks.Count);
Assert.AreEqual(TaskOptions.None, job.Tasks[0].Options);
Assert.IsNull(job.Tasks[0].InitializationVector);
Assert.IsTrue(String.IsNullOrEmpty(job.Tasks[0].EncryptionKeyId));
Assert.IsNull(job.Tasks[0].EncryptionScheme);
Assert.IsNull(job.Tasks[0].EncryptionVersion);
WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished);
CloudMediaContext context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IJob job2 = context2.Jobs.Where(c => c.Id == job.Id).Single();
Assert.AreEqual(1, job2.Tasks.Count);
Assert.AreEqual(1, job2.Tasks[0].OutputAssets.Count);
}
public void ShouldDeleteEmptyAsset()
{
IAsset asset = _mediaContext.Assets.Create("ShouldDeleteEmptyAsset", AssetCreationOptions.None);
Assert.AreEqual(AssetState.Initialized, asset.State);
foreach (ILocator locator in asset.Locators)
{
locator.Delete();
}
asset.Delete();
Assert.IsNull(_mediaContext.Assets.Where(a => a.Id == asset.Id).SingleOrDefault());
CloudMediaContext newContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
Assert.IsNull(newContext.Assets.Where(a => a.Id == asset.Id).SingleOrDefault());
}