public void ShouldSubmitJobWhereOutPutInDefaultStorage() { IAsset asset = AssetTests.CreateAsset(_dataContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IMediaProcessor mediaProcessor = GetMediaProcessor(_dataContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName, WindowsAzureMediaServicesTestConfiguration.MpEncoderVersion); string name = GenerateName("Job 1"); IJob job = _dataContext.Jobs.Create(name); ITask task = job.Tasks.AddNew("Task1", mediaProcessor, GetWamePreset(mediaProcessor), TaskOptions.None); task.InputAssets.Add(asset); task.OutputAssets.AddNew("Output asset", _dataContext.DefaultStorageAccount.Name, AssetCreationOptions.None); job.Submit(); WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished); }
public void ShouldReceiveNotificationsForCompeletedJob() { string endPointAddress = Guid.NewGuid().ToString(); CloudQueueClient client = CloudStorageAccount.Parse(WindowsAzureMediaServicesTestConfiguration.ClientStorageConnectionString).CreateCloudQueueClient(); CloudQueue queue = client.GetQueueReference(endPointAddress); queue.CreateIfNotExists(); string endPointName = Guid.NewGuid().ToString(); INotificationEndPoint notificationEndPoint = _mediaContext.NotificationEndPoints.Create(endPointName, NotificationEndPointType.AzureQueue, endPointAddress); Assert.IsNotNull(notificationEndPoint); string configuration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.DefaultMp4ToSmoothConfig); IAsset asset = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallMp41, AssetCreationOptions.StorageEncrypted); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpPackagerName); IJob job = _mediaContext.Jobs.Create("CreateJobWithNotificationSubscription"); ITask task = job.Tasks.AddNew("Task1", mediaProcessor, configuration, TaskOptions.None); task.InputAssets.Add(asset); task.OutputAssets.AddNew("Output", AssetCreationOptions.None); job.JobNotificationSubscriptions.AddNew(NotificationJobState.All, notificationEndPoint); job.Submit(); Assert.IsTrue(job.JobNotificationSubscriptions.Count > 0); WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished); Thread.Sleep((int)TimeSpan.FromMinutes(5).TotalMilliseconds); Assert.IsNotNull(queue); Assert.IsTrue(queue.Exists()); IEnumerable <CloudQueueMessage> messages = queue.GetMessages(10); Assert.IsTrue(messages.Any()); Assert.AreEqual(4, messages.Count(), "Expecting to have 4 notifications messages"); IJob lastJob = _mediaContext.Jobs.Where(j => j.Id == job.Id).FirstOrDefault(); Assert.IsNotNull(lastJob); Assert.IsTrue(lastJob.JobNotificationSubscriptions.Count > 0); IJobNotificationSubscription lastJobNotificationSubscription = lastJob.JobNotificationSubscriptions.Where(n => n.NotificationEndPoint.Id == notificationEndPoint.Id).FirstOrDefault(); Assert.IsNotNull(lastJobNotificationSubscription); INotificationEndPoint lastNotificationEndPoint = lastJobNotificationSubscription.NotificationEndPoint; Assert.IsNotNull(lastNotificationEndPoint); Assert.AreEqual(endPointName, lastNotificationEndPoint.Name); Assert.AreEqual(endPointAddress, lastNotificationEndPoint.EndPointAddress); }
public void ShouldFinishJobWithSuccessWhenPresetISUTF8() { IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); string presetXml = @"<?xml version=""1.0"" encoding=""utf-8""?> <Thumbnail Size=""80,60"" Type=""Jpeg"" Filename=""{OriginalFilename}_{ThumbnailTime}.{DefaultExtension}""> <Time Value=""0:0:0""/> <Time Value=""0:0:3"" Step=""0:0:0.25"" Stop=""0:0:10""/> </Thumbnail>"; string name = GenerateName("ShouldFinishJobWithSuccessWhenPresetISUTF8"); IJob job = CreateAndSubmitOneTaskJob(_mediaContext, name, mediaProcessor, presetXml, asset, TaskOptions.None); WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished); }
public void ShouldQueryJobByStartTime() { DateTime startDateTime = DateTime.UtcNow; IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); string name = GenerateName("Job 1"); IJob job = CreateAndSubmitOneTaskJob(_mediaContext, name, mediaProcessor, GetWamePreset(mediaProcessor), asset, TaskOptions.None); Task task = job.GetExecutionProgressTask(CancellationToken.None); task.Wait(); List <IJob> jobs = _mediaContext.Jobs.Where(j => j.StartTime > startDateTime && j.StartTime < DateTime.UtcNow).ToList(); Assert.IsTrue(jobs.Count > 0); }
public void ShouldContainTaskHistoryEventsOnceJobFinished() { IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); string name = GenerateName("ShouldContainTaskHistoryEventsOnceJobFinished"); string preset = GetWamePreset(mediaProcessor); IJob job = CreateAndSubmitOneTaskJob(_mediaContext, name, mediaProcessor, preset, asset, TaskOptions.None); ITask task = job.Tasks.FirstOrDefault(); Assert.IsNotNull(task); Assert.IsNotNull(task.HistoricalEvents, "HistoricalEvents should not be null for submitted job"); WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished); Assert.IsTrue(task.HistoricalEvents.Count > 0, "HistoricalEvents should not be empty after job has been finished"); }
public void ShouldDownloadToFileFromStorageEncryptedAsset() { string fileUploaded = _smallWmv; IAsset asset = AssetTests.CreateAsset(_mediaContext, Path.GetFullPath(fileUploaded), AssetCreationOptions.StorageEncrypted); IAssetFile assetFile = asset.AssetFiles.First(); Assert.AreEqual(AssetCreationOptions.StorageEncrypted, asset.Options); Assert.AreEqual(assetFile.Asset.Id, asset.Id); Assert.AreEqual(1, asset.Locators.Count); VerifyAndDownloadAssetFile(assetFile, asset, fileUploaded); }
public void ShouldCreateOriginLocator() { IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None); IAccessPolicy accessPolicy = _mediaContext.AccessPolicies.Create("Read", TimeSpan.FromMinutes(5), AccessPermissions.Read); ILocator locator = _mediaContext.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset, accessPolicy); Assert.IsNotNull(locator); string locatorIdWithoutPrefix = locator.Id.Remove(0, LocatorData.LocatorIdentifierPrefix.Length); Assert.AreEqual(locator.ContentAccessComponent, locatorIdWithoutPrefix, true); Assert.IsTrue(locator.Path.TrimEnd('/').EndsWith(locatorIdWithoutPrefix, StringComparison.OrdinalIgnoreCase)); }
public void ShouldSubmitAndFinishMp4ToSmoothJobWithStorageProtectedInputsAndOutputs() { string configuration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.DefaultMp4ToSmoothConfig); IAsset asset = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallMp41, AssetCreationOptions.StorageEncrypted); IJob job = _mediaContext.Jobs.Create("MP4 to Smooth with protected input and output assets"); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpPackagerName); ITask task = job.Tasks.AddNew(MediaPackager, mediaProcessor, configuration, TaskOptions.None); task.InputAssets.Add(asset); task.OutputAssets.AddNew("Output encrypted", AssetCreationOptions.StorageEncrypted); job.Submit(); Assert.IsNotNull(task.InputAssets); WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished); }
public void ShouldDownloadToFileFromCommonEncryptionProtectedAsset() { string fileUploaded = _smallWmv; string outputDirectory = "Download" + Guid.NewGuid(); IAsset asset = AssetTests.CreateAsset(_mediaContext, Path.GetFullPath(fileUploaded), AssetCreationOptions.CommonEncryptionProtected); IAssetFile assetFile = asset.AssetFiles.First(); Assert.AreEqual(AssetCreationOptions.CommonEncryptionProtected, asset.Options); Assert.AreEqual(assetFile.Asset.Id, asset.Id); Assert.AreEqual(1, asset.Locators.Count); VerifyAndDownloadAssetFile(assetFile, asset, fileUploaded); }
public void ShouldGenerateMetadataFile() { IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); string name = GenerateName("ShouldSplitMetadataLost"); IJob job = CreateAndSubmitOneTaskJob(_mediaContext, name, mediaProcessor, "H264 Smooth Streaming 720p", asset, TaskOptions.None); WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished); IJob refreshedJob = _mediaContext.Jobs.Where(c => c.Id == job.Id).Single(); bool ok = refreshedJob.Tasks.Single().OutputAssets.Single().AssetFiles.AsEnumerable().Select(f => f.Name).Contains("SmallWmv_manifest.xml"); Assert.IsTrue(ok); }
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 ShouldRecreateLocatorWithSameLocatorId() { IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None); IAccessPolicy accessPolicy = _mediaContext.AccessPolicies.Create("Read", TimeSpan.FromMinutes(5), AccessPermissions.Read); ILocator locator = _mediaContext.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset, accessPolicy); Assert.IsNotNull(locator); string id = locator.Id; locator.Delete(); Assert.IsNull(_mediaContext.Locators.Where(c => c.Id == id).FirstOrDefault()); locator = _mediaContext.Locators.CreateLocator(id, LocatorType.OnDemandOrigin, asset, accessPolicy, null); Assert.IsNotNull(locator); }
public void ShouldDownloadToFileFromStorageEncryptedAsset() { string fileUploaded = _smallWmv; string outputDirectory = "Download" + Guid.NewGuid(); string fileDownloaded = Path.Combine(outputDirectory, Path.GetFileName(fileUploaded)); var fileUploadedInfo = new FileInfo(fileUploaded); IAsset asset = AssetTests.CreateAsset(_dataContext, Path.GetFullPath(fileUploaded), AssetCreationOptions.StorageEncrypted); IAssetFile assetFile = asset.AssetFiles.First(); Assert.AreEqual(AssetCreationOptions.StorageEncrypted, asset.Options); Assert.AreEqual(assetFile.Asset.Id, asset.Id); Assert.AreEqual(1, asset.Locators.Count); CleanDirectory(outputDirectory); Assert.IsFalse(File.Exists(fileDownloaded)); double downloadProgress = 0; long bytesDownloaded = 0; assetFile.DownloadProgressChanged += (s, e) => { Assert.AreSame(assetFile, s); Assert.IsNotNull(e); Assert.AreEqual(fileUploadedInfo.Length, e.TotalBytes); Assert.IsTrue(e.BytesDownloaded <= e.TotalBytes); downloadProgress = e.Progress; bytesDownloaded = e.BytesDownloaded; }; assetFile.Download(fileDownloaded); Assert.IsTrue(File.Exists(fileDownloaded)); Assert.AreEqual(100, downloadProgress); var fileDownloadedInfo = new FileInfo(fileDownloaded); Assert.AreEqual(fileUploadedInfo.Length, fileDownloadedInfo.Length); Assert.AreEqual(fileDownloadedInfo.Length, bytesDownloaded); asset = _dataContext.Assets.Where(a => a.Id == asset.Id).Single(); Assert.AreEqual(1, asset.Locators.Count); }
public void ShouldUpdateJobPriorityWhenJobIsQueued() { const int newPriority = 3; IMediaProcessor processor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); //Create temp job to simuate queue when no reserved unit are allocated IJob tempJob = CreateAndSubmitOneTaskJob(_mediaContext, GenerateName("SubmitJobToCreateQueue"), processor, GetWamePreset(processor), asset, TaskOptions.None); IJob job = CreateAndSubmitOneTaskJob(_mediaContext, GenerateName("ShouldSubmitJobAndUpdatePriorityWhenJobIsQueued"), processor, GetWamePreset(processor), asset, TaskOptions.None); WaitForJobStateAndUpdatePriority(job, JobState.Queued, newPriority); WaitForJob(job.Id, JobState.Finished, (string id) => { var finished = _mediaContext.Jobs.Where(c => c.Id == job.Id && c.Priority == newPriority).FirstOrDefault(); Assert.IsNotNull(finished); }); }
public void ShouldSubmitAndFinishChainedTasksUsingParentOverload() { IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IJob job = _mediaContext.Jobs.Create("Test"); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); ITask task = job.Tasks.AddNew("Task1", mediaProcessor, GetWamePreset(mediaProcessor), TaskOptions.None); task.InputAssets.Add(asset); IAsset asset1 = task.OutputAssets.AddNew("output asset"); string xmlPreset = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.ThumbnailXml); ITask task2 = job.Tasks.AddNew("Task2", mediaProcessor, xmlPreset, TaskOptions.None, task); task2.OutputAssets.AddNew("JobOutput", options: AssetCreationOptions.None); job.Submit(); WaitForJob(job.Id, JobState.Finished, VerifyAllTasksFinished); }
public void ShouldThrowForbiddenExceptionWhenExpired() { string fileUploaded = _smallWmv; IAsset asset = AssetTests.CreateAsset(_mediaContext, Path.GetFullPath(fileUploaded), AssetCreationOptions.StorageEncrypted); IAssetFile assetFile = asset.AssetFiles.First(); Assert.AreEqual(assetFile.Asset.Id, asset.Id); try { VerifyAndDownloadAssetFileNTimes(assetFile, asset, 1, 1, true, true); } catch (AggregateException exception) { Assert.IsTrue(exception.InnerException.Message.Contains("The remote server returned an error: (403) Forbidden.")); throw exception.InnerException; } }
public void ShouldThrowTryingUpdateJobPriorityWhenJobIsFinished() { const int newPriority = 3; IMediaProcessor processor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IJob job = CreateAndSubmitOneTaskJob(_mediaContext, GenerateName("ShouldSubmitJobAndUpdatePriorityWhenJobIsQueued"), processor, GetWamePreset(processor), asset, TaskOptions.None); try { WaitForJobStateAndUpdatePriority(job, JobState.Finished, newPriority); } catch (DataServiceRequestException ex) { Assert.IsTrue(ex.InnerException.Message.Contains("Job's priority can only be changed if the job is in Queued state")); throw ex; } }
public void ShouldCreateAssetFileWithEncryption() { var filePaths = new[] { WindowsAzureMediaServicesTestConfiguration.SmallWmv }; IAsset asset = AssetTests.CreateAsset(_mediaContext, Path.GetFullPath(WindowsAzureMediaServicesTestConfiguration.SmallWmv), AssetCreationOptions.StorageEncrypted); // Associate an access policy with the asset so we can download the files associated with it IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Test", TimeSpan.FromMinutes(10), AccessPermissions.Read); _mediaContext.Locators.CreateSasLocator(asset, policy); Assert.IsNotNull(asset, "Asset should be non null"); Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID should not be null"); Assert.AreEqual(1, asset.AssetFiles.Count(), "Child files count wrong"); Assert.IsTrue(asset.Options == AssetCreationOptions.StorageEncrypted, "AssetCreationOptions did not have the expected value"); VerifyFileAndContentKeyMetadataForStorageEncryption(asset, _mediaContext); VerifyStorageEncryptionOnFiles(asset, filePaths); }
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 ValidateEffectiveEncryptionStatusOfStorageEncryptedWmv() { IAsset asset = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallWmv, AssetCreationOptions.StorageEncrypted); Assert.AreEqual(false, asset.IsStreamable); Assert.AreEqual(AssetType.Unknown, asset.AssetType); Assert.AreEqual(AssetCreationOptions.StorageEncrypted, asset.Options); AssetDeliveryProtocol protocolsToTest = AssetDeliveryProtocol.SmoothStreaming | AssetDeliveryProtocol.Dash | AssetDeliveryProtocol.HLS | AssetDeliveryProtocol.Hds; List <TestCase> testCases = GetTestsCasesForProtocolCombination(protocolsToTest, AssetEncryptionState.Unsupported); ValidateAssetEncryptionState(asset, testCases); CleanupAsset(asset); }
public void ShouldThrowSubmittingJobWhenNonexistingStorageSpecifiedForOutPut() { try { IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IMediaProcessor mediaProcessor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); string name = GenerateName("Job 1"); IJob job = _mediaContext.Jobs.Create(name); ITask task = job.Tasks.AddNew("Task1", mediaProcessor, GetWamePreset(mediaProcessor), TaskOptions.None); task.InputAssets.Add(asset); task.OutputAssets.AddNew("Output asset", Guid.NewGuid().ToString(), AssetCreationOptions.None); job.Submit(); } catch (DataServiceRequestException ex) { Assert.IsTrue(ex.Response.First().Error.Message.Contains("Cannot find the storage account")); throw; } }
public void ShouldFinishJobWithErrorWithInvalidPreset() { IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.StorageEncrypted); IMediaProcessor processor = GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncoderName); IJob job = CreateAndSubmitOneTaskJob(_mediaContext, GenerateName("ShouldFinishJobWithErrorWithInvalidPreset"), processor, "Some wrong Preset", asset, TaskOptions.None); Action <string> verify = id => { IJob job2 = _mediaContext.Jobs.Where(c => c.Id == id).SingleOrDefault(); Assert.IsNotNull(job2); Assert.IsNotNull(job2.Tasks); Assert.AreEqual(1, job2.Tasks.Count); Assert.IsNotNull(job2.Tasks[0].ErrorDetails); Assert.AreEqual(1, job2.Tasks[0].ErrorDetails.Count); Assert.IsNotNull(job2.Tasks[0].ErrorDetails[0]); Assert.AreEqual("ErrorParsingConfiguration", job2.Tasks[0].ErrorDetails[0].Code); }; WaitForJob(job.Id, JobState.Error, verify); }
public void ShouldReturnLocatorWhenCreateSasLocatorCalled() { // Arrange var accessPolicy = _mediaContext.AccessPolicies.Create("TestPolicy", TimeSpan.FromMinutes(10), AccessPermissions.List | AccessPermissions.Read); var asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None); // Act var actual = _mediaContext.Locators.CreateSasLocator(asset, accessPolicy); // Assert Assert.IsNotNull(actual); Assert.IsNotNull(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 ShouldUpdateExpiryTimeWhenUpdateLocatorCalledWithExpiryTime() { // Arrange var accessPolicyDuration = TimeSpan.FromHours(2); var expectedExpiryTime = DateTime.UtcNow.Date.AddDays(2); 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 locator.Update(expectedExpiryTime); var context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(); var actual = context2.Locators.Where(x => x.Id == locator.Id).FirstOrDefault(); // Assert Assert.AreEqual(expectedExpiryTime, locator.ExpirationDateTime); Assert.AreEqual(expectedExpiryTime, actual.ExpirationDateTime); }
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); try { 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"); } } finally { AssetFilesTests.CleanDirectory(path); } }
public void ShouldCreateAssetFileWithPlayReadyEncryption() { // 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); Guid keyId = Guid.NewGuid(); byte[] contentKey = GetRandomBuffer(16); IContentKey key = _mediaContext.ContentKeys.Create(keyId, contentKey); asset.ContentKeys.Add(key); Assert.IsNotNull(asset, "Asset should be non null"); Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID should not be null"); Assert.AreEqual(1, asset.AssetFiles.Count(), "Child files count wrong"); Assert.IsTrue(asset.Options == AssetCreationOptions.CommonEncryptionProtected, "AssetCreationOptions did not have the expected value"); VerifyFileAndContentKeyMetadataForCommonEncryption(asset); VerifyContentKeyVersusExpectedValue2(asset, contentKey, keyId); }
public void ShouldCreateTaskUsingStorageEncryptedAsset() { var filePaths = new[] { WindowsAzureMediaServicesTestConfiguration.SmallWmv }; IAsset asset = AssetTests.CreateAsset(_mediaContext, Path.GetFullPath(WindowsAzureMediaServicesTestConfiguration.SmallWmv), AssetCreationOptions.StorageEncrypted); IMediaProcessor processor = JobTests.GetEncoderMediaProcessor(_mediaContext); IJob job = _mediaContext.Jobs.Create("Encode Job with encrypted asset"); ITask task = job.Tasks.AddNew("Task 1", processor, JobTests.GetWamePreset(processor), TaskOptions.None); task.InputAssets.Add(asset); task.OutputAssets.AddNew("Encrypted Output", AssetCreationOptions.StorageEncrypted); job.Submit(); JobTests.WaitForJob(job.Id, JobState.Finished, JobTests.VerifyAllTasksFinished); CloudMediaContext context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(); IJob job2 = context2.Jobs.Where(c => c.Id == job.Id).Single(); foreach (IAsset outputAsset in job2.Tasks[0].OutputAssets) { VerifyFileAndContentKeyMetadataForStorageEncryption(outputAsset, _mediaContext); } }
public void ShouldDeleteAssetWithStorageEncryptionContentKey() { // Use two contexts to cover the case where the content key needs to be internally attached to // the data context. This simulates deleting a content key that we haven't just created. var dataContext2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(); IAsset asset = AssetTests.CreateAsset(_mediaContext, Path.GetFullPath(WindowsAzureMediaServicesTestConfiguration.SmallWmv), AssetCreationOptions.StorageEncrypted); Assert.AreEqual(1, asset.ContentKeys.Count, "Expected 1 content key associated with the asset for storage encryption"); Assert.AreEqual(ContentKeyType.StorageEncryption, asset.ContentKeys[0].ContentKeyType); // Get the ids to make sure they are no longer in the system after deleting the asset string assetId = asset.Id; string fileId = asset.AssetFiles.ToList()[0].Id; string keyId = asset.ContentKeys[0].Id; foreach (ILocator locator in asset.Locators) { locator.Delete(); } // Now delete the asset and ensure that the content key and file are also deleted asset.Delete(); foreach (IAsset assetFromRest in dataContext2.Assets) { Assert.IsFalse(assetFromRest.Id == assetId, "Asset was deleted we should not be able to query it by identifier."); } foreach (IAssetFile fileFromRest in dataContext2.Files) { Assert.IsFalse(fileFromRest.Id == fileId, "Asset was deleted we should not be able to query its associated File by identifier."); } foreach (IContentKey keyFromRest in dataContext2.ContentKeys) { Assert.IsFalse(keyFromRest.Id == keyId, "Asset was deleted we should not be able to query its associated storage encryption key by identifier."); } }
public void ShouldCreateLocatorWhenCreateSasLocatorCalled() { // Arrange var accessPolicy = _mediaContext.AccessPolicies.Create("TestPolicy", TimeSpan.FromMinutes(10), AccessPermissions.List | AccessPermissions.Read); var asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None); // Act var locator = _mediaContext.Locators.CreateSasLocator(asset, accessPolicy); 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 EncryptManifestFilesAndVerifyThemAfterDeencryption() { List <IIngestManifestFile> files; IIngestManifest ingestManifestCreated; var path = CreateManifestEncryptFiles(out files, out ingestManifestCreated); IIngestManifestAsset ingestManifestAsset = ingestManifestCreated.IngestManifestAssets.ToList().Where(c => c.Asset.Options == AssetCreationOptions.StorageEncrypted).FirstOrDefault(); IIngestManifestFile mFile = ingestManifestAsset.IngestManifestFiles.Where(c => c.Name == "File0.txt").FirstOrDefault(); Dictionary <string, string> filePaths = new Dictionary <string, string>(); foreach (var filePath in new[] { TestFile1, TestFile2 }) { FileInfo fileInfo = new FileInfo(filePath); filePaths.Add(fileInfo.Name, filePath); } var encryptedPath = Path.Combine(path, mFile.Name); Assert.IsTrue(File.Exists(encryptedPath)); var decryptedPath = DecryptedFile(mFile, encryptedPath, _context); Assert.IsTrue(AssetTests.CompareFiles(decryptedPath, filePaths[mFile.Name]), "Original file and Decrypted are not same"); }