public async Task Throws_NotSupportedException_When_Deserializing_Other_Type() { var serializer = new ByteArraySerializer(); Func <Task> testCode = async() => await serializer.DeserializeAsync(new ByteArrayContent(Array.Empty <byte>()), typeof(int)); await testCode.Should().ThrowAsync <NotSupportedException>(); }
public void ReturnNullIfDeserializingNull() { Serializer <byte[]> serializer = new ByteArraySerializer(); byte[] actualDeserializedValue = serializer.Deserialize(null); Assert.Null(actualDeserializedValue); }
public void SerializeAndDeserializeToTheSameObject(byte[] originalValue) { Serializer <byte[]> serializer = new ByteArraySerializer(); byte[] serializedValue = serializer.Serialize(originalValue); byte[] deserializedValue = serializer.Deserialize(serializedValue); Assert.Equal(originalValue, deserializedValue); }
public async Task Deserializes_ByteArray() { var expected = new byte[] { 1, 2, 3 }; var serializer = new ByteArraySerializer(); var deserialized = await serializer.DeserializeAsync(new ByteArrayContent(expected), typeof(byte[])); deserialized.Should().BeOfType <byte[]>(); deserialized.Should().BeEquivalentTo(expected); }
public static void ProcessNextMediaMessage(QueueValet queueValet, BlobValet blobValet) { try { var msg = queueValet.GetMessage(TimeSpan.FromMinutes(5)); if (msg != null) { if (msg.DequeueCount <= 1) { Trace.TraceInformation("DequeueCount = {0}", msg.DequeueCount); } else { Trace.TraceWarning("DequeueCount = {0}", msg.DequeueCount); } //TODO: if (msg.DequeueCount > 5) return; // Is it a photo or video? -- only photo supported for now... so assume that // (alternatively, might have a photo queue and a video queue) var mediaUploadInfo = ByteArraySerializer <MediaUploadModel> .Deserialize(msg.AsBytes); var uploadedPhotoUrl = mediaUploadInfo.BlobUrl; var username = mediaUploadInfo.Username; ProcessNextPhotoUpload(username, uploadedPhotoUrl, blobValet); queueValet.DeleteMessage(msg); // TODO: Ensure proper Poison Message Handling } } catch (Exception ex) { // this method CANNOT throw an exception - that's bad manners - even if there is a failure // SEE: Queue-Centric Workflow Pattern (chapter 3) plus Poison Message and Reliable Queue concepts // SEE: Strong Exception Guarantee http://en.wikipedia.org/wiki/Exception_safety // or relate to the NoFail Guaranteed from http://c2.com/cgi/wiki?ExceptionGuarantee var debugMsg = String.Format("Exception in PoP.ServiceTier.NewMediaProcessor.ProcessNextMediaMessage [{0}]\n[{1}]", ex.GetBaseException(), ex); Trace.TraceError(debugMsg); } }
/// <summary> /// Upload the blob and then (if nothing went wrong) drop a message on the queue announcing the blob /// </summary> /// <param name="queueValet"></param> /// <param name="mediaByteStream">Might be from File Upload via web page</param> /// <param name="origFilename"></param> /// <param name="mimeType"></param> /// <param name="byteCount">Count of bytes in the stream. Not used at this time. May be used in future to optimize the upload to blob storage, for telemetry, or to block uploads over a certain size.</param> /// <param name="destinationUrl"></param> /// <param name="blobValet"></param> public static void CaptureUploadedMedia(BlobValet blobValet, QueueValet queueValet, Stream mediaByteStream, string origFilename, string mimeType, int byteCount, string destinationUrl) { try { // TODO: obviate MediaStorageUrlFile.ExtTemplate by basing on MediaStorageValetKeyUrl value --- value="http://127.0.0.1:10000/devstoreaccount1/popmedia/{0}{1}" & "http://127.0.0.1:10000/devstoreaccount1/popmedia?sr=c&si=open-wide-container-access-policy&sig=X0yGw1Ydmu%2BCwk%2FTY7nj5HFgzv%2BIYg%2Bun%2BHQhNMmThk%3D" #if false var destinationUrl = String.Format(ConfigurationManager.AppSettings["MediaStorageUrlFile.ExtTemplate"], Guid.NewGuid(), new FileInfo(origFilename).Extension ); var valetKeyUrl = ConfigurationManager.AppSettings["MediaStorageValetKeyUrl"]; // if that worked, notify via queue var mediaIngestionQueueValetKeyUrl = ConfigurationManager.AppSettings["MediaIngestionQueueValetKeyUrl"]; #endif blobValet.UploadStream(new Uri(destinationUrl), mediaByteStream, mimeType); // TODO: at moment is sync (not async) to avoid race condition mentioned below var info = new MediaUploadModel { BlobUrl = destinationUrl, Username = "******" }; // prep an arbitrary object to send on the queue, not just a string (not rich enough for our use case) var queueMessage = new CloudQueueMessage(ByteArraySerializer <MediaUploadModel> .Serialize(info)); // TODO: race condition when both uploading a BLOB and posting the Queue message - the queue message processing // TODO: ... can begin before the blob upload is complete -- need to sync these // TODO: ... BUT! for now it will still FUNCTION CORRECTLY (if inefficiently) due to Queue-Centric Workflow Pattern retries IF not determined to be a Poison Message // There is no real need for a 50ms delay before the message can appear in queue, but just showing how to do it. // Technique is sometimes useful when there's a reason to delay its processing. You could use it to implement a // scheduler, for example. In the case of PoP, there are no obvious use cases. A made-up use case might be if PoP // introduced a way to make photos show up in the future allowing the user uploading them to indicate PoP should // delay processing for, say, up to 24 hours, and let the user optionally specify a delay within that range. queueValet.AddMessage(queueMessage, initialVisibilityDelay: TimeSpan.FromMilliseconds(50)); } catch (StorageException ex) { System.Diagnostics.Trace.TraceError("Exception thrown in BlobExtensions.UploadFile: " + ex); throw; } }
// [MaxTime(1000)] public void Sends(int length, int concurentLevel) { var channel = new TNT.Testing.TestChannel(false); channel.ImmitateConnect(); var transporter = new Transporter(channel); int id = 1; var serializer = new ByteArraySerializer(); var sender = new Sender(transporter, new Dictionary <int, ISerializer> { { id, serializer } }); int expectedHeadLength = 6; var start = new ManualResetEvent(false); int doneThreads = 0; for (int i = 0; i < concurentLevel; i++) { ThreadPool.QueueUserWorkItem((_) => { byte[] array = CreateArray(length, (byte)i); start.WaitOne(); sender.Say(id, new object[] { array }); }); } channel.OnWrited += (_, arg) => { Assert.AreEqual(expectedHeadLength + length, arg.Length); byte lastValue = arg.Last(); for (int i = expectedHeadLength; i < expectedHeadLength + length; i++) { Assert.AreEqual(lastValue, arg[i]); } doneThreads++; }; start.Set(); while (doneThreads != concurentLevel - 1) { Thread.Sleep(1); } }
public void NonDefinedConstructorInheritableTest() { var test = new ByteArraySerializer(); }