public void TransmittionIsSavedToStorageFolder()
            {
                var testDirectory = new DirectoryInfo(Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()));

                testDirectory.Create();

                try
                {
                    Transmitter transmitter = new Transmitter();
                    transmitter.StorageFolder = testDirectory.FullName;

                    transmitter.MaxSenderCapacity = 0;
                    transmitter.MaxBufferCapacity = 0;

                    transmitter.Initialize();

                    transmitter.Enqueue(new StubTransmission());

                    Assert.Equal(1, testDirectory.EnumerateFiles().Count());
                }
                finally
                {
                    testDirectory.Delete(true);
                }
            }
            public void StoresTransmissionWhenBufferIsFull()
            {
                Transmission storedTransmission = null;
                var          storage            = new StubTransmissionStorage
                {
                    OnEnqueue = transmission =>
                    {
                        storedTransmission = transmission;
                        return(false);
                    }
                };

                var sender = new StubTransmissionSender {
                    OnEnqueue = t => false
                };
                var buffer = new StubTransmissionBuffer {
                    OnEnqueue = t => false
                };
                Transmitter transmitter = CreateTransmitter(sender: sender, buffer: buffer, storage: storage);

                var enqueuedTransmission = new StubTransmission();

                transmitter.Enqueue(enqueuedTransmission);

                Assert.Same(enqueuedTransmission, storedTransmission);
            }
            public void AppliesTransmistionPoliciesIfTheyNeverBeenAppliedBefore()
            {
                var senderPolicy = new StubTransmissionPolicy {
                    MaxSenderCapacity = 0
                };
                var sender = new StubTransmissionSender {
                    Capacity = 1
                };
                Transmitter transmitter = CreateTransmitter(sender: sender, policies: new[] { senderPolicy });

                transmitter.Enqueue(new StubTransmission());

                Assert.Equal(senderPolicy.MaxSenderCapacity, sender.Capacity);
            }
            public void TracesDiagnosticsEvent()
            {
                Transmitter transmitter = CreateTransmitter();

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

                    transmitter.Enqueue(new StubTransmission());

                    EventWrittenEventArgs trace = listener.Messages.First();
                    Assert.Equal(21, trace.EventId);
                }
            }
            public void DoesNotApplyPolicesIfTheyAlreadyApplied()
            {
                var senderPolicy = new StubTransmissionPolicy {
                    MaxSenderCapacity = 0
                };
                var         sender      = new StubTransmissionSender();
                Transmitter transmitter = CreateTransmitter(sender: sender, policies: new[] { senderPolicy });

                transmitter.ApplyPolicies();
                senderPolicy.MaxSenderCapacity = 2;

                transmitter.Enqueue(new StubTransmission());

                Assert.NotEqual(senderPolicy.MaxSenderCapacity, sender.Capacity);
            }
            public void PassesTransmissionToSenderAndReturnsTrue()
            {
                Transmission sentTransmission = null;
                var          sender           = new StubTransmissionSender
                {
                    OnEnqueue = getTransmission =>
                    {
                        sentTransmission = getTransmission();
                        return(sentTransmission != null);
                    },
                };

                Transmitter transmitter = CreateTransmitter(sender: sender);

                var transmission = new StubTransmission();

                transmitter.Enqueue(transmission);

                Assert.Same(transmission, sentTransmission);
            }
            public void BuffersTransmissionWhenSenderIsFull()
            {
                var sender = new StubTransmissionSender {
                    OnEnqueue = t => false
                };

                Transmission bufferedTransmission = null;
                var          buffer = new StubTransmissionBuffer
                {
                    OnEnqueue = getTransmission =>
                    {
                        bufferedTransmission = getTransmission();
                        return(bufferedTransmission != null);
                    },
                };

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

                var transmission = new StubTransmission();

                transmitter.Enqueue(transmission);

                Assert.Same(transmission, bufferedTransmission);
            }
            public void TransmittionIsSavedToStorageFolder()
            {
                var testDirectory = new DirectoryInfo(Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()));
                testDirectory.Create();

                try
                {
                    Transmitter transmitter = new Transmitter();
                    transmitter.StorageFolder = testDirectory.FullName;

                    transmitter.MaxSenderCapacity = 0;
                    transmitter.MaxBufferCapacity = 0;

                    transmitter.Initialize();

                    transmitter.Enqueue(new StubTransmission());

                    Assert.Equal(1, testDirectory.EnumerateFiles().Count());
                }
                finally
                {
                    testDirectory.Delete(true);
                }
            }