public void RestoresOriginalComponentCapacityInCaseOfOnePolicyRunningByTimerTwoTimes()
            {
                IList <Transmission> enqueuedTransmissions = new List <Transmission>();

                var sender = new StubTransmissionSender {
                    Capacity = 2
                };
                var buffer = new StubTransmissionBuffer {
                    Capacity = 1
                };
                var storage = new StubTransmissionStorage {
                    Capacity = 100
                };

                var         policies    = new[] { new StubTransmissionScheduledPolicy() };
                Transmitter transmitter = CreateTransmitter(sender, buffer, storage, policies: policies);

                var items = new List <ITelemetry> {
                    new EventTelemetry(), new EventTelemetry()
                };
                Transmission transmission = new Transmission(new Uri("http://uri"), items, "type", "encoding");

                string response = BackendResponseHelper.CreateBackendResponse(
                    itemsReceived: 2,
                    itemsAccepted: 1,
                    errorCodes: new[] { "500" });

                var wrapper = new HttpWebResponseWrapper
                {
                    StatusCode = 500,
                    Content    = response
                };

                sender.OnTransmissionSent(new TransmissionProcessedEventArgs(transmission, null, wrapper));
                sender.OnTransmissionSent(new TransmissionProcessedEventArgs(transmission, null, wrapper));
                sender.OnTransmissionSent(new TransmissionProcessedEventArgs(transmission, null, wrapper));

                Assert.IsTrue(policies[0].ActionInvoked.Wait(3000));

                Assert.AreNotEqual(0, sender.Capacity);
                Assert.AreNotEqual(0, buffer.Capacity);
            }
            public void LogsUnhandledAsyncExceptionsToPreventThemFromCrashingApplication()
            {
                var exception = new Exception(Guid.NewGuid().ToString());
                var sender    = new StubTransmissionSender {
                    OnEnqueue = getTransmissionAsync => { throw exception; }
                };
                Transmitter transmitter = CreateTransmitter(sender: sender);

                using (var listener = new TestEventListener())
                {
                    const long AllKeywords = -1;
                    listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.Warning, (EventKeywords)AllKeywords);

                    sender.OnTransmissionSent(new TransmissionProcessedEventArgs(new StubTransmission()));

                    EventWrittenEventArgs message = listener.Messages.First();
                    Assert.Contains(exception.Message, (string)message.Payload[0], StringComparison.Ordinal);
                }
            }
            public void MovesOldestTransmissionFromBufferToSender()
            {
                Transmission sentTransmission = null;
                var          sender           = new StubTransmissionSender();

                sender.OnEnqueue = getTransmission =>
                {
                    sentTransmission = getTransmission();
                    return(false);
                };

                Transmission bufferedTransmission = new StubTransmission();
                var          buffer = new TransmissionBuffer();

                buffer.Enqueue(() => bufferedTransmission);

                Transmitter transmitter = CreateTransmitter(sender: sender, buffer: buffer);

                sender.OnTransmissionSent(new TransmissionProcessedEventArgs(new StubTransmission()));

                Assert.Same(bufferedTransmission, sentTransmission);
            }
            public void RaisesTransmissionSentWhenTransmissionFinishesSending()
            {
                var         sender = new StubTransmissionSender();
                Transmitter queue  = CreateTransmitter(sender: sender);

                object eventSender = null;
                TransmissionProcessedEventArgs eventArgs = null;

                queue.TransmissionSent += (s, e) =>
                {
                    eventSender = s;
                    eventArgs   = e;
                };

                var transmission = new StubTransmission();
                var exception    = new Exception();

                sender.OnTransmissionSent(new TransmissionProcessedEventArgs(transmission, exception));

                Assert.Same(queue, eventSender);
                Assert.Same(transmission, eventArgs.Transmission);
                Assert.Same(exception, eventArgs.Exception);
            }