public void DoesNotCountNullTransmissionsReturnedFromEmptyBufferAgainstMaxNumber()
{
var sender = new TransmissionSender { Capacity = 1 };
sender.Enqueue(() => null);
Transmission transmission2 = new StubTransmission();
Assert.True(sender.Enqueue(() => transmission2));
}
public void StartsSendingTransmissionAndReturnsImmediatelyToUnblockCallingThread()
{
var transmissionCanFinishSending = new ManualResetEventSlim();
var transmission = new StubTransmission { OnSend = () => transmissionCanFinishSending.Wait() };
var sender = new TransmissionSender();
sender.Enqueue(() => transmission);
transmissionCanFinishSending.Set();
}
public void DoesNotCountRejectedTransmissionsAgainstMaxNumber()
{
var sender = new TransmissionSender { Capacity = 0 };
Transmission transmission1 = new StubTransmission();
sender.Enqueue(() => transmission1);
sender.Capacity = 1;
Transmission transmission2 = new StubTransmission();
Assert.True(sender.Enqueue(() => transmission2));
}
public void DoesNotCountTransmissionsSentWithExceptionsAgainstMaxNumber()
{
var sender = new TransmissionSender { Capacity = 1 };
Transmission transmission1 = new StubTransmission { OnSend = () => { throw new TimeoutException(); } };
sender.Enqueue(() => transmission1);
Thread.Sleep(10);
Transmission transmission2 = new StubTransmission();
bool transmission2Sent = sender.Enqueue(() => transmission2);
Assert.True(transmission2Sent);
}
private StubTransmission Convert(Transmission transmission)
{
if (transmission != null)
{
if (transmission.TelemetryItems == null)
{
transmission = new StubTransmission(transmission.Content)
{
OnSave = this.OnSave,
OnSend = this.OnSend,
};
}
else
{
transmission = new StubTransmission(transmission.TelemetryItems)
{
OnSave = this.OnSave,
OnSend = this.OnSend,
};
}
}
return((StubTransmission)transmission);
}
public void MovesTransmissionsFromBufferToStorageWhenBufferCapacityIsZero()
{
var storage = new StubTransmissionStorage { Capacity = 1 };
var bufferedTransmission = new StubTransmission();
var buffer = new TransmissionBuffer();
storage.Enqueue(() => bufferedTransmission);
var policy = new StubTransmissionPolicy();
policy.MaxBufferCapacity = 1;
Transmitter transmitter = CreateTransmitter(buffer: buffer, storage: storage, policies: new[] { policy });
policy.MaxBufferCapacity = 0;
policy.Apply();
Transmission storedTransmission = storage.Dequeue();
Assert.Same(bufferedTransmission, storedTransmission);
}
public void MovesTransmissionsFromStorageToBufferWhenBufferCapacityIsGreaterThanZero()
{
var storedTransmission = new StubTransmission();
var storage = new StubTransmissionStorage();
storage.Enqueue(() => storedTransmission);
var buffer = new TransmissionBuffer();
var policy = new StubTransmissionPolicy();
policy.MaxBufferCapacity = 0;
Transmitter transmitter = CreateTransmitter(buffer: buffer, storage: storage, policies: new[] { policy });
policy.MaxBufferCapacity = 1;
policy.Apply();
Transmission bufferedTransmission = buffer.Dequeue();
Assert.Same(storedTransmission, bufferedTransmission);
}
public void DoesNotMoveTransmissionsFromStorageToSenderWhenBufferIsNotEmptyToPreserveQueueOrder()
{
var storedTransmission = new StubTransmission();
var storage = new StubTransmissionStorage();
storage.Enqueue(() => storedTransmission);
var buffer = new StubTransmissionBuffer { OnGetSize = () => 1 };
var sentTransmissions = new List<Transmission>();
StubTransmissionSender sender = CreateSender(sentTransmissions);
sender.OnGetCapacity = () => 1;
Transmitter transmitter = CreateTransmitter(sender, buffer, storage);
transmitter.ApplyPolicies();
Assert.DoesNotContain(storedTransmission, sentTransmissions);
}
public void MovesTransmissionsFromStorageToSenderToAvoidWaitingUntilBufferIsFullBeforeSendingStarts()
{
var storedTransmission = new StubTransmission();
var storage = new StubTransmissionStorage();
storage.Enqueue(() => storedTransmission);
var buffer = new StubTransmissionBuffer();
var sentTransmissions = new List<Transmission>();
StubTransmissionSender sender = CreateSender(sentTransmissions);
sender.OnGetCapacity = () => 1;
Transmitter transmitter = CreateTransmitter(sender, buffer, storage);
transmitter.ApplyPolicies();
Assert.Contains(storedTransmission, sentTransmissions);
}
public void SavesTransmissionToTheNewlyCreatedFile()
{
string writtenContents = null;
StubStream fileStream = new StubStream();
fileStream.OnDispose = disposing =>
{
writtenContents = Encoding.UTF8.GetString(fileStream.ToArray());
};
var file = new StubPlatformFile { OnOpen = () => fileStream };
var folder = new StubPlatformFolder { OnCreateFile = fileName => file };
var provider = new StubApplicationFolderProvider { OnGetApplicationFolder = () => folder };
var storage = new TransmissionStorage(provider);
byte[] contents = Encoding.UTF8.GetBytes(Path.GetRandomFileName());
var transmission = new StubTransmission(contents);
storage.Enqueue(() => transmission);
string encodedContent = writtenContents.Split(Environment.NewLine.ToCharArray()).Last();
Assert.Equal(contents, Convert.FromBase64String(encodedContent));
}
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 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 IsRaisedWhenTransmissionThrownExceptionWhileSending()
{
var sender = new TransmissionSender();
var eventIsRaised = new ManualResetEventSlim();
object eventSender = null;
TransmissionProcessedEventArgs eventArgs = null;
sender.TransmissionSent += (s, a) =>
{
eventSender = s;
eventArgs = a;
eventIsRaised.Set();
};
var exception = new TimeoutException();
Transmission transmission = new StubTransmission { OnSend = () => { throw exception; } };
sender.Enqueue(() => transmission);
Assert.True(eventIsRaised.Wait(5000));
Assert.Same(sender, eventSender);
Assert.Same(transmission, eventArgs.Transmission);
Assert.Same(exception, eventArgs.Exception);
}
public void MovesTransmissionsFromBufferToSenderWhenSenderCapacityIsGreaterThanZero()
{
var bufferedTransmission = new StubTransmission();
var buffer = new TransmissionBuffer();
buffer.Enqueue(() => bufferedTransmission);
Transmission sentTransmission = null;
var sender = new StubTransmissionSender();
sender.OnEnqueue = getTransmission =>
{
sentTransmission = getTransmission();
return false;
};
var policy = new StubTransmissionPolicy { MaxSenderCapacity = 0 };
Transmitter transmitter = CreateTransmitter(sender: sender, buffer: buffer, policies: new[] { policy });
policy.MaxSenderCapacity = 1;
policy.Apply();
Assert.Same(bufferedTransmission, sentTransmission);
}
public void IsRaisedWhenTransmissionIsSentSuccessfully()
{
var sender = new TransmissionSender();
var eventIsRaised = new ManualResetEventSlim();
object eventSender = null;
TransmissionProcessedEventArgs eventArgs = null;
sender.TransmissionSent += (s, a) =>
{
eventSender = s;
eventArgs = a;
eventIsRaised.Set();
};
Transmission transmission = new StubTransmission();
sender.Enqueue(() => transmission);
Assert.True(eventIsRaised.Wait(50));
Assert.Same(sender, eventSender);
Assert.Same(transmission, eventArgs.Transmission);
}
public void TransmissionReturnsValueSuppliedByConstructor()
{
Transmission transmission = new StubTransmission();
var args = new TransmissionProcessedEventArgs(transmission);
Assert.Same(transmission, args.Transmission);
}
public void DoesNotRetrySuccessfulTransmission()
{
Transmission enqueuedTransmission = null;
var transmitter = new StubTransmitter();
transmitter.OnEnqueue = transmission =>
{
enqueuedTransmission = transmission;
};
var policy = new ErrorHandlingTransmissionPolicy();
policy.Initialize(transmitter);
var successfulTransmission = new StubTransmission();
transmitter.OnTransmissionSent(new TransmissionProcessedEventArgs(successfulTransmission));
Assert.Null(enqueuedTransmission);
Assert.Equal(0, policy.ConsecutiveErrors);
}
public void RetriesFailedTransmissionInfinitely()
{
Transmission enqueuedTransmission = null;
var transmitter = new StubTransmitter();
transmitter.OnEnqueue = transmission =>
{
enqueuedTransmission = transmission;
};
var policy = new TestableErrorHandlingTransmissionPolicy();
policy.BackOffTime = TimeSpan.FromMilliseconds(10);
policy.Initialize(transmitter);
var failedTransmission = new StubTransmission();
transmitter.OnTransmissionSent(new TransmissionProcessedEventArgs(failedTransmission, CreateException(statusCode: 408)));
transmitter.OnTransmissionSent(new TransmissionProcessedEventArgs(failedTransmission, CreateException(statusCode: 408)));
transmitter.OnTransmissionSent(new TransmissionProcessedEventArgs(failedTransmission, CreateException(statusCode: 408)));
Assert.Same(failedTransmission, enqueuedTransmission);
}
public void RetriesFailedTransmissionIfItsNumberOfAttemptsDidNotReachMaximum()
{
Transmission enqueuedTransmission = null;
var transmitter = new StubTransmitter();
transmitter.OnEnqueue = transmission =>
{
enqueuedTransmission = transmission;
};
var policy = new ErrorHandlingTransmissionPolicy();
policy.Initialize(transmitter);
var failedTransmission = new StubTransmission();
transmitter.OnTransmissionSent(new TransmissionProcessedEventArgs(failedTransmission, CreateException(statusCode: 408)));
Assert.Same(failedTransmission, enqueuedTransmission);
}
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 ReturnsOldestEnquedTransmission()
{
var buffer = new TransmissionBuffer();
Transmission transmission1 = new StubTransmission();
buffer.Enqueue(() => transmission1);
Transmission transmission2 = new StubTransmission();
buffer.Enqueue(() => transmission2);
Assert.Same(transmission1, buffer.Dequeue());
Assert.Same(transmission2, buffer.Dequeue());
}
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 ReflectsContentLengthOfTransmissionsAddedByEnqueueAsync()
{
Transmission transmission = new StubTransmission(new byte[42]);
var buffer = new TransmissionBuffer();
buffer.Enqueue(() => transmission);
Assert.Equal(transmission.Content.Length, buffer.Size);
}
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);
}
public void IsRaisedWhenTransmissionReturnsPartialSuccessResult()
{
var sender = new TransmissionSender();
var eventIsRaised = new ManualResetEventSlim();
object eventSender = null;
TransmissionProcessedEventArgs eventArgs = null;
sender.TransmissionSent += (s, a) =>
{
eventSender = s;
eventArgs = a;
eventIsRaised.Set();
};
var wrapper = new HttpWebResponseWrapper();
Transmission transmission = new StubTransmission { OnSend = () => wrapper };
sender.Enqueue(() => transmission);
Assert.True(eventIsRaised.Wait(50));
Assert.Same(sender, eventSender);
Assert.Same(transmission, eventArgs.Transmission);
Assert.Same(wrapper, eventArgs.Response);
}
