public void VersionedMessageHandler_WhenErrorAndNotThrowOnError_ExpectHandled()
{
// Arrange
var entityTwo = default(TestEntityTwo);
var defaultValue = default(string);
var exception = default(Exception);
var versionedMessageHandler = new VersionedMessageHandler(SerializerType.Json, false)
.On <TestEntityOne>(e => throw new DivideByZeroException())
.On <TestEntityTwo>(e => entityTwo = e)
.Else(s => defaultValue = s)
.OnError(e => exception = e);
var versionedMessage = new VersionedMessage
{
Data = new TestEntityOne().SerializeToString(SerializerType.Json),
Version = typeof(TestEntityOne).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
versionedMessageHandler.Post(versionedMessage);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(entityTwo, Is.Null);
Assert.That(defaultValue, Is.Null);
Assert.That(exception, Is.Not.Null);
Assert.That(exception.GetType(), Is.EqualTo(typeof(DivideByZeroException)));
}
public async Task VersionedMessageHandler_WhenVersionMatchOnSecond_ExpectAction()
{
// Arrange
var entityOne = default(TestEntityOne);
var entityTwo = default(TestEntityTwo);
var defaultValue = default(string);
var exception = default(Exception);
var versionedMessageHandler = new AsyncVersionedMessageHandler(SerializerType.ProtocolBuffers, true)
.On <TestEntityOne>(
e =>
{
entityOne = e;
return(Task.CompletedTask);
})
.On <TestEntityTwo>(
typeof(TestEntityTwo).GetVersion(),
e =>
{
entityTwo = e;
return(Task.CompletedTask);
})
.Else(
s =>
{
defaultValue = s;
return(Task.CompletedTask);
})
.OnError(
e =>
{
exception = e;
return(Task.CompletedTask);
});
var versionedMessage = new VersionedMessage
{
Data = new TestEntityTwo {
Value1 = "test", Value2 = new DateTime(2018, 1, 1)
}.SerializeToString(),
Version = typeof(TestEntityTwo).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
await versionedMessageHandler.PostAsync(versionedMessage).ConfigureAwait(false);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(entityOne, Is.Null);
Assert.That(entityTwo, Is.Not.Null);
Assert.That(defaultValue, Is.Null);
Assert.That(exception, Is.Null);
Assert.That(entityTwo.Value1, Is.EqualTo("test"));
Assert.That(entityTwo.Value2, Is.EqualTo(new DateTime(2018, 1, 1)));
}
public void VersionedMessageHandler_WhenErrorAndThrowOnError_ExpectThrows()
{
// Arrange
var versionedMessageHandler = new VersionedMessageHandler <TestEntityOne>(SerializerType.Json, true)
.On <TestEntityOne>(e => throw new DivideByZeroException())
.On <TestEntityTwo>(e => null)
.Else(s => null)
.OnError(
e =>
{
return(null);
});
var versionedMessage = new VersionedMessage
{
Data = new TestEntityOne().SerializeToString(SerializerType.Json),
Version = typeof(TestEntityOne).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
Assert.Throws <DivideByZeroException>(() => versionedMessageHandler.Post(versionedMessage));
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
}
public VersionedMessage assembleMessage(List <VersionedDocument> documents)
{
VersionedMessage vm = new VersionedMessage();
//Length of messageId shall be 32 or less
vm.messageId = GetUniqID(); //Guid.NewGuid().ToString().Substring(9);
//Length of dealId shall be 32 or less
vm.dealId = "CNTM-" + GetUniqID(); //Guid.NewGuid().ToString().Substring(9);
//Length of sender shall be 76 or less
vm.sender = _sender;
//length of receiver shall be 42 or less
vm.receiver = _receiver;
vm.timestamp = DateTime.Now;
vm.format = "FCXAPI";
vm.version = "1.1.0";
//Length of transaction shall be 30 or less
vm.transaction = _transaction; //"Submit to Lender";
if (documents != null)
{
foreach (VersionedDocument doc in documents)
{
doc.format = "FCXAPI";
doc.mimetype = "base64Binary/xml";
doc.version = "1.1.0";
}
vm.documents = documents.ToArray();
}
return(vm);
}
public async Task VersionedMessageHandler_WhenNoMatch_ExpectDefault()
{
// Arrange
var entityOne = default(TestEntityOne);
var entityTwo = default(TestEntityTwo);
var defaultValue = default(string);
var exception = default(Exception);
var versionedMessageHandler = new AsyncVersionedMessageHandler(SerializerType.Json, true)
.On <TestEntityOne>(
e =>
{
entityOne = e;
return(Task.CompletedTask);
})
.On <TestEntityTwo>(
e =>
{
entityTwo = e;
return(Task.CompletedTask);
})
.Else(
s =>
{
defaultValue = s;
return(Task.CompletedTask);
})
.OnError(
e =>
{
exception = e;
return(Task.CompletedTask);
});
var versionedMessage = new VersionedMessage
{
Data = new TestEntityThree {
Value1 = 25.3m
}.SerializeToString(SerializerType.Json),
Version = typeof(TestEntityThree).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
await versionedMessageHandler.PostAsync(versionedMessage).ConfigureAwait(false);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(entityOne, Is.Null);
Assert.That(entityTwo, Is.Null);
Assert.That(defaultValue, Is.Not.Null);
Assert.That(exception, Is.Null);
Assert.That(defaultValue, Is.EqualTo("{\"Value1\":25.3}"));
}
public Response submitMessage(VersionedMessage versionedMessage)
{
getServiceCall().Timeout = 600000;
Response response = fcxService.setMessage(versionedMessage);
if (response != null && response.status != null && !"OK".Equals(response.status, StringComparison.CurrentCultureIgnoreCase))
{//handle submission error}
}
return(response);
}
public async Task VersionedMessageHandler_WhenErrorAndNotThrowOnError_ExpectHandled()
{
// Arrange
var defaultValue = default(string);
var exception = default(Exception);
var versionedMessageHandler = new AsyncVersionedMessageHandler <TestEntityOne>(SerializerType.Json, false)
.On <TestEntityOne>(e => throw new DivideByZeroException())
.On <TestEntityTwo>(
e => Task.FromResult(
new TestEntityOne
{
Value2 = 5,
Value1 = e.Value1,
}))
.Else(
s =>
{
defaultValue = s;
return(Task.FromResult(default(TestEntityOne)));
})
.OnError(
e =>
{
exception = e;
return(Task.FromResult(default(TestEntityOne)));
});
var versionedMessage = new VersionedMessage
{
Data = new TestEntityOne().SerializeToString(SerializerType.Json),
Version = typeof(TestEntityOne).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
var rtn = await versionedMessageHandler.PostAsync(versionedMessage).ConfigureAwait(false);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(rtn, Is.Null);
Assert.That(defaultValue, Is.Null);
Assert.That(exception, Is.Not.Null);
Assert.That(exception.GetType(), Is.EqualTo(typeof(DivideByZeroException)));
}
public async Task VersionedMessageHandler_WhenNoMatch_ExpectDefault()
{
// Arrange
var exception = default(Exception);
var versionedMessageHandler = new AsyncVersionedMessageHandler <TestEntityOne>(SerializerType.Json, true)
.On <TestEntityOne>(e => Task.FromResult(default(TestEntityOne)))
.On <TestEntityTwo>(e => Task.FromResult(default(TestEntityOne)))
.Else(
s => Task.FromResult(new TestEntityOne
{
Value2 = 42,
Value1 = "DEFAULT",
}))
.OnError(
e =>
{
exception = e;
return(Task.FromResult(default(TestEntityOne)));
});
var versionedMessage = new VersionedMessage
{
Data = new TestEntityThree {
Value1 = 25.3m
}.SerializeToString(SerializerType.Json),
Version = typeof(TestEntityThree).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
var rtn = await versionedMessageHandler.PostAsync(versionedMessage).ConfigureAwait(false);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(exception, Is.Null);
Assert.That(rtn.Value1, Is.EqualTo("DEFAULT"));
Assert.That(rtn.Value2, Is.EqualTo(42));
}
public void VersionedMessageHandler_WhenNoMatch_ExpectDefault()
{
// Arrange
var exception = default(Exception);
var versionedMessageHandler = new VersionedMessageHandler <TestEntityOne>(SerializerType.Json, true)
.On <TestEntityOne>(e => null)
.On <TestEntityTwo>(e => null)
.Else(s => new TestEntityOne {
Value1 = "DEFAULT", Value2 = 5
})
.OnError(
e =>
{
exception = e;
return(null);
});
var versionedMessage = new VersionedMessage
{
Data = new TestEntityThree {
Value1 = 25.3m
}.SerializeToString(SerializerType.Json),
Version = typeof(TestEntityThree).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
var rtn = versionedMessageHandler.Post(versionedMessage);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(exception, Is.Null);
Assert.That(rtn.Value1, Is.EqualTo("DEFAULT"));
Assert.That(rtn.Value2, Is.EqualTo(5));
}
public void VersionedMessageHandler_WhenVersionMatchOnFirst_ExpectAction()
{
// Arrange
var entityOne = default(TestEntityOne);
var entityTwo = default(TestEntityTwo);
var defaultValue = default(string);
var exception = default(Exception);
var versionedMessageHandler = new VersionedMessageHandler(SerializerType.ProtocolBuffers, true)
.On <TestEntityOne>(e => entityOne = e)
.On <TestEntityTwo>(e => entityTwo = e)
.Else(s => defaultValue = s)
.OnError(e => exception = e);
var versionedMessage = new VersionedMessage
{
Data = new TestEntityOne {
Value1 = "test", Value2 = 42
}.SerializeToString(),
Version = typeof(TestEntityOne).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
versionedMessageHandler.Post(versionedMessage);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(entityOne, Is.Not.Null);
Assert.That(entityTwo, Is.Null);
Assert.That(defaultValue, Is.Null);
Assert.That(exception, Is.Null);
Assert.That(entityOne.Value1, Is.EqualTo("test"));
Assert.That(entityOne.Value2, Is.EqualTo(42));
}
public void VersionedMessageHandler_WhenVersionMatchOnSecond_ExpectAction()
{
// Arrange
var exception = default(Exception);
var versionedMessageHandler =
new VersionedMessageHandler <TestEntityTwo>(SerializerType.ProtocolBuffers, true)
.On <TestEntityOne>(e => null)
.On <TestEntityTwo>(typeof(TestEntityTwo).GetVersion(), e => e)
.Else(s => null)
.OnError(
e =>
{
exception = e;
return(null);
});
var versionedMessage = new VersionedMessage
{
Data = new TestEntityTwo {
Value1 = "test", Value2 = new DateTime(2018, 1, 1)
}.SerializeToString(),
Version = typeof(TestEntityTwo).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
var rtn = versionedMessageHandler.Post(versionedMessage);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(exception, Is.Null);
Assert.That(rtn.Value1, Is.EqualTo("test"));
Assert.That(rtn.Value2, Is.EqualTo(new DateTime(2018, 1, 1)));
}
public void VersionedMessageHandler_WhenNoMatch_ExpectDefault()
{
// Arrange
var entityOne = default(TestEntityOne);
var entityTwo = default(TestEntityTwo);
var defaultValue = default(string);
var exception = default(Exception);
var versionedMessageHandler = new VersionedMessageHandler(SerializerType.Json, true)
.On <TestEntityOne>(e => entityOne = e)
.On <TestEntityTwo>(e => entityTwo = e)
.Else(s => defaultValue = s)
.OnError(e => exception = e);
var versionedMessage = new VersionedMessage
{
Data = new TestEntityThree {
Value1 = 25.3m
}.SerializeToString(SerializerType.Json),
Version = typeof(TestEntityThree).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
versionedMessageHandler.Post(versionedMessage);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(entityOne, Is.Null);
Assert.That(entityTwo, Is.Null);
Assert.That(defaultValue, Is.Not.Null);
Assert.That(exception, Is.Null);
Assert.That(defaultValue, Is.EqualTo("{\"Value1\":25.3}"));
}
public async Task VersionedMessageHandler_WhenVersionMatchOnFirst_ExpectAction()
{
// Arrange
var exception = default(Exception);
var versionedMessageHandler = new AsyncVersionedMessageHandler <TestEntityOne>(SerializerType.ProtocolBuffers, true)
.On <TestEntityOne>(Task.FromResult)
.On <TestEntityTwo>(e => Task.FromResult(default(TestEntityOne)))
.Else(e => Task.FromResult(default(TestEntityOne)))
.OnError(
e =>
{
exception = e;
return(Task.FromResult(default(TestEntityOne)));
});
var versionedMessage = new VersionedMessage
{
Data = new TestEntityOne {
Value1 = "test", Value2 = 42
}.SerializeToString(),
Version = typeof(TestEntityOne).GetVersion(),
};
// Act
var stopwatch = Stopwatch.StartNew();
var testEntityOne = await versionedMessageHandler.PostAsync(versionedMessage).ConfigureAwait(false);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(exception, Is.Null);
Assert.That(testEntityOne.Value1, Is.EqualTo("test"));
Assert.That(testEntityOne.Value2, Is.EqualTo(42));
}
/// <summary>
/// Serializes the message.
/// </summary>
/// <param name="source">The source.</param>
/// <returns>
/// The <see cref="string" />
/// </returns>
public string SerializeToString(VersionedMessage source)
{
var serializerType = this.serializerSettings.SerializerType;
return(source.SerializeToString(serializerType));
}
