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();
AssertEx.Contains(storedTransmission, sentTransmissions);
}
public void DoesNotChangeComponentCapacityIfNoneOfPoliciesAreApplicable()
{
var sender = new StubTransmissionSender {
Capacity = 1
};
var buffer = new StubTransmissionBuffer {
Capacity = 10
};
var storage = new StubTransmissionStorage {
Capacity = 100
};
var policies = new[] { new StubTransmissionPolicy() };
Transmitter transmitter = CreateTransmitter(sender, buffer, storage, policies: policies);
Assert.AreEqual(1, sender.Capacity);
Assert.AreEqual(10, buffer.Capacity);
Assert.AreEqual(100, storage.Capacity);
}
public void SetsStorageCapacityToMinValueReturnedByTransmissionPolicies()
{
var storage = new StubTransmissionStorage();
var policies = new[]
{
new StubTransmissionPolicy {
MaxStorageCapacity = 4
},
new StubTransmissionPolicy {
MaxStorageCapacity = 2
},
};
Transmitter transmitter = CreateTransmitter(storage: storage, policies: policies);
transmitter.ApplyPolicies();
Assert.AreEqual(2, storage.Capacity);
}
public void MovesOldestTransmissionFromStorageToBuffer()
{
var previouslyStoredTransmissions = new List <Transmission> {
new StubTransmission(), new StubTransmission()
};
int storageIndex = 0;
var storage = new StubTransmissionStorage
{
OnDequeue = () =>
{
if (storageIndex < previouslyStoredTransmissions.Count)
{
return(previouslyStoredTransmissions[storageIndex++]);
}
return(null);
}
};
var newlyBufferedTransmissions = new List <Transmission>();
var buffer = new StubTransmissionBuffer
{
OnEnqueue = getTransmission =>
{
var transmission = getTransmission();
if (transmission != null)
{
newlyBufferedTransmissions.Add(transmission);
return(true);
}
return(false);
}
};
var sender = new StubTransmissionSender();
Transmitter queue = CreateTransmitter(sender: sender, buffer: buffer, storage: storage);
buffer.OnTransmissionDequeued(new TransmissionProcessedEventArgs(null));
AssertEx.AreEqual(previouslyStoredTransmissions, newlyBufferedTransmissions);
}
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 async Task LogsEventAfterMovingTransmissionsToStorage()
{
var sender = new StubTransmissionSender {
OnEnqueue = t => false
};
var buffer = new TransmissionBuffer();
var storage = new StubTransmissionStorage {
OnEnqueue = t => false
};
buffer.Enqueue(() => new StubTransmission());
Transmitter transmitter = CreateTransmitter(sender: sender, buffer: buffer, storage: storage);
using (var listener = new TestEventListener())
{
const long AllKeywords = -1;
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.LogAlways, (EventKeywords)AllKeywords);
await transmitter.MoveTransmissionsAndWaitForSender(default);
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 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 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 EmptiesBufferIfCapacityIsZero()
{
//// We set capacity to 0 and clear the cache when DC responds with 439.
var buffer = new StubTransmissionBuffer();
buffer.Enqueue(() => new StubTransmission());
var storage = new StubTransmissionStorage();
storage.Enqueue(() => new StubTransmission());
var sender = new StubTransmissionSender();
sender.Enqueue(() => new StubTransmission());
var policy = new StubTransmissionPolicy();
policy.MaxStorageCapacity = 0;
Transmitter transmitter = CreateTransmitter(sender, buffer, storage, new[] { policy });
policy.Apply();
Assert.Equal(0, storage.Queue.Count);
}
public async Task StoresTransmissionWhenSenderIsFull()
{
bool isInStorage = false;
var sender = new StubTransmissionSender {
OnEnqueue = t => false
};
var buffer = new TransmissionBuffer();
var storage = new StubTransmissionStorage
{
OnEnqueue = getTransmission =>
{
isInStorage = true;
return(true);
}
};
Transmitter transmitter = CreateTransmitter(sender: sender, buffer: buffer, storage: storage);
var transmission = new StubTransmission();
var result = await transmitter.FlushAsync(transmission, default);
Assert.IsTrue(isInStorage);
Assert.IsTrue(result);
}
