public async Task FailingInitClosesModuleClient()
{
// Arrange
ConnectionStatusChangesHandler connectionStatusChangesHandler = (status, reason) => { };
DesiredPropertyUpdateCallback desiredPropertyUpdateCallback = (properties, context) => Task.CompletedTask;
var milestone = new SemaphoreSlim(0, 1);
var moduleClient = new Mock <IModuleClient>();
moduleClient.Setup(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>())).Callback(() => milestone.Release()).Throws <TimeoutException>();
var moduleClientProvider = new Mock <IModuleClientProvider>();
moduleClientProvider.Setup(m => m.Create(connectionStatusChangesHandler)).ReturnsAsync(moduleClient.Object);
var requestManager = new Mock <IRequestManager>();
bool enableSubscriptions = true;
// Act
var moduleConnection = new ModuleConnection(moduleClientProvider.Object, requestManager.Object, connectionStatusChangesHandler, desiredPropertyUpdateCallback, enableSubscriptions);
await milestone.WaitAsync(TimeSpan.FromSeconds(10));
await Task.Delay(TimeSpan.FromSeconds(0.5)); // the milestone is hit a bit earlier than the exception, so wait a tiny bit
// Assert
moduleClient.Verify(m => m.CloseAsync(), Times.Once);
}
internal void ConnectModuleServer()
{
this.ModuleConnection = new Connection();
ModuleConnection.EnableSession = true;
ModuleConnection.EnableSecureTunnel = true;
Envelope rsp = this.GreeningConnection.SendRequest("DS.Base.GetPassportToken", new Envelope());
PassportSecurityToken stt = new PassportSecurityToken(rsp.Body.XmlString);
ModuleConnection.Connect(_moduleURL, "developer", stt);
}
/// <summary>
/// Adds a new output to an existing decoder.
/// </summary>
/// <param name="output">An instance of <see cref="SwitchboardPanel"/> containing the data for the new panel.</param>
public void Add(ModuleConnection output)
{
string sql = string.Empty;
Logger.LogDebug(this, "[CLASS].Add([{0}])", output);
try
{
// Check if related decoder exists
CheckDecoderExists(output);
Connect();
output.ID = (int)ExecuteScalar(sql);
// Añade el registro
sql = @"INSERT INTO
" + ModuleConnectionManager.SQL_TABLE + @" (" + ModuleConnectionManager.SQL_FIELDS_INSERT + @")
VALUES
(@decoderid, @blockid, @name, @address, @switchtime, @out1, @out2)";
SetParameter("decoderid", output.DecoderID);
SetParameter("blockid", output.BlockID);
SetParameter("name", output.Name);
SetParameter("address", output.Address);
SetParameter("switchtime", output.SwitchTime);
SetParameter("out1", output.Output1);
SetParameter("out2", output.Output2);
ExecuteNonQuery(sql);
// Obtiene el nuevo ID
sql = @"SELECT
Max(id) As id
FROM
" + ModuleConnectionManager.SQL_TABLE;
output.ID = (int)ExecuteScalar(sql);
}
catch (Exception ex)
{
Logger.LogError(this, ex);
throw;
}
finally
{
Disconnect();
}
}
/// <summary>
/// Read a category from the current reader record.
/// </summary>
internal static ModuleConnection ReadEntityRecord(SQLiteDataReader reader)
{
ModuleConnection record = new ModuleConnection();
record.ID = reader.GetInt32(0);
record.DecoderID = reader.GetInt32(1);
record.BlockID = reader.IsDBNull(2) ? 0 : reader.GetInt32(2);
record.Name = reader.IsDBNull(3) ? string.Empty : reader.GetString(3);
record.Address = reader.IsDBNull(4) ? 0 : reader.GetInt32(4);
record.SwitchTime = reader.IsDBNull(5) ? 0 : reader.GetInt32(5);
record.Output1 = reader.IsDBNull(6) ? ModuleConnection.DecoderFunctionOutputStatus.Unknown : (ModuleConnection.DecoderFunctionOutputStatus)reader.GetInt32(6);
record.Output2 = reader.IsDBNull(7) ? ModuleConnection.DecoderFunctionOutputStatus.Unknown : (ModuleConnection.DecoderFunctionOutputStatus)reader.GetInt32(7);
return(record);
}
/// <summary>
/// Update the specified connection.
/// </summary>
/// <param name="output">An instance with the updated data.</param>
public void Update(ModuleConnection output)
{
string sql = string.Empty;
Logger.LogDebug(this, "[CLASS].Update([{0}])", output);
try
{
// Check if related decoder exists
CheckDecoderExists(output);
Connect();
sql = @"UPDATE
" + ModuleConnectionManager.SQL_TABLE + @"
SET
decoderid = @decoderid,
blockid = @blockid,
name = @name,
address = @address,
switchtime = @switchtime,
out1 = @out1,
out2 = @out2
WHERE
id = @id";
SetParameter("decoderid", output.DecoderID);
SetParameter("blockid", output.BlockID);
SetParameter("name", output.Name);
SetParameter("address", output.Address);
SetParameter("switchtime", output.SwitchTime);
SetParameter("out1", output.Output1);
SetParameter("out2", output.Output2);
SetParameter("id", output.ID);
ExecuteNonQuery(sql);
}
catch (Exception ex)
{
Logger.LogError(this, ex);
throw;
}
finally
{
Disconnect();
}
}
private void CheckDecoderExists(ModuleConnection output)
{
// Check if the decoder is informed
if (output.DecoderID <= 0)
{
throw new LayoutConfigurationException("Cannot create a decoder output without related decoder.");
}
// Check if the decoder is in database
ControlModuleManager decManager = new ControlModuleManager(this.Settings);
if (decManager.GetByID(output.DecoderID) == null)
{
throw new LayoutConfigurationException("Cannot create a decoder output: related decoder #{0} not found.", output.DecoderID);
}
}
private static ModuleConnectionDto GetModuleConnectionDto(ModuleConnection mc)
{
if (mc == null)
{
return(null);
}
return(new ModuleConnectionDto
{
Id = mc.Id,
SourceConnectorName = mc.SourceConnectorName,
SourceId = mc.SourceModuleId,
TargetConnectorName = mc.TargetConnectorName,
TargetId = mc.TargetModuleId
});
}
/// <summary>
/// Gets all blocks from a specified switchboard panel.
/// </summary>
/// <param name="decoderId">The switchboard panel unique identifier (DB).</param>
/// <returns>The requested list of <see cref="BlockBase"/>.</returns>
public List <ModuleConnection> GetByDecoder(int decoderId)
{
string sql = string.Empty;
ModuleConnection item = null;
List <ModuleConnection> items = new List <ModuleConnection>();
Logger.LogDebug(this, "[CLASS].GetByDecoder({0})", decoderId);
try
{
Connect();
sql = @"SELECT
" + ModuleConnectionManager.SQL_FIELDS_SELECT + @"
FROM
" + ModuleConnectionManager.SQL_TABLE + @"
WHERE
panelid = @panelid";
SetParameter("panelid", decoderId);
using (SQLiteDataReader reader = ExecuteReader(sql))
{
while (reader.Read())
{
item = ModuleConnectionManager.ReadEntityRecord(reader);
if (item != null)
{
items.Add(item);
}
}
}
return(items);
}
catch (Exception ex)
{
Logger.LogError(this, ex);
throw;
}
finally
{
Disconnect();
}
}
public Envelope SendModuleRequest(string srvName, Envelope request)
{
try
{
return(ModuleConnection.SendRequest(srvName, request));
}
catch (DSAServerException ex)
{
if (ex.Status == "511")
{
ConnectModuleServer();
return(SendModuleRequest(srvName, request));
}
else
{
throw ex;
}
}
}
public async Task CreateAndInitTest()
{
// Arrange
ConnectionStatusChangesHandler connectionStatusChangesHandler = (status, reason) => { };
DesiredPropertyUpdateCallback desiredPropertyUpdateCallback = (properties, context) => Task.CompletedTask;
var moduleClient = new Mock <IModuleClient>();
moduleClient.Setup(m => m.IsActive).Returns(true);
var moduleClientProvider = new Mock <IModuleClientProvider>();
moduleClientProvider.Setup(m => m.Create(connectionStatusChangesHandler))
.ReturnsAsync(moduleClient.Object);
var requestManager = new Mock <IRequestManager>();
bool enableSubscriptions = true;
// Act
var moduleConnection = new ModuleConnection(moduleClientProvider.Object, requestManager.Object, connectionStatusChangesHandler, desiredPropertyUpdateCallback, enableSubscriptions);
await Task.Delay(TimeSpan.FromSeconds(5));
Option <IModuleClient> resultModuleClientOption = moduleConnection.GetModuleClient();
// Assert
Assert.True(resultModuleClientOption.HasValue);
Assert.Equal(moduleClient.Object, resultModuleClientOption.OrDefault());
moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Once);
moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once);
moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once);
// Act
IModuleClient resultModuleClient = await moduleConnection.GetOrCreateModuleClient();
// Assert
Assert.NotNull(resultModuleClient);
Assert.Equal(moduleClient.Object, resultModuleClient);
moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Once);
moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once);
moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once);
}
public async Task CreateAndCloseTest()
{
// Arrange
ConnectionStatusChangesHandler connectionStatusChangesHandler = (status, reason) => { };
DesiredPropertyUpdateCallback desiredPropertyUpdateCallback = (properties, context) => Task.CompletedTask;
Task <IModuleClient> GetModuleClient() => Task.FromResult(Mock.Of <IModuleClient>(m => m.IsActive));
var moduleClientProvider = new Mock <IModuleClientProvider>();
moduleClientProvider.Setup(m => m.Create(connectionStatusChangesHandler))
.Returns(GetModuleClient);
var requestManager = new Mock <IRequestManager>();
bool enableSubscriptions = true;
// Act
var moduleConnection = new ModuleConnection(moduleClientProvider.Object, requestManager.Object, connectionStatusChangesHandler, desiredPropertyUpdateCallback, enableSubscriptions);
IModuleClient resultModuleClient = await moduleConnection.GetOrCreateModuleClient();
Option <IModuleClient> optionResultModuleClient = moduleConnection.GetModuleClient();
// Assert
Assert.NotNull(resultModuleClient);
Assert.True(optionResultModuleClient.HasValue);
moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Once);
Mock <IModuleClient> moduleClient = Mock.Get(resultModuleClient);
moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once);
moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once);
// Act - Set the client to not active and try to get a Get a module client
moduleClient.Setup(m => m.IsActive).Returns(false);
optionResultModuleClient = moduleConnection.GetModuleClient();
// Assert
Assert.False(optionResultModuleClient.HasValue);
// Act
resultModuleClient = await moduleConnection.GetOrCreateModuleClient();
optionResultModuleClient = moduleConnection.GetModuleClient();
// Assert
Assert.NotNull(resultModuleClient);
Assert.True(optionResultModuleClient.HasValue);
moduleClient = Mock.Get(resultModuleClient);
moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Exactly(2));
moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once);
moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once);
// Act - Set the client to not active and raise the client closed event
moduleClient.Setup(m => m.IsActive).Returns(false);
moduleClient.Raise(m => m.Closed += null, new EventArgs());
await Task.Delay(TimeSpan.FromSeconds(3));
optionResultModuleClient = moduleConnection.GetModuleClient();
// Assert
Assert.True(optionResultModuleClient.HasValue);
moduleClient = Mock.Get(resultModuleClient);
moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Exactly(3));
moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once);
moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once);
// Act
resultModuleClient = await moduleConnection.GetOrCreateModuleClient();
// Assert
Assert.NotNull(resultModuleClient);
moduleClient = Mock.Get(resultModuleClient);
moduleClientProvider.Verify(m => m.Create(connectionStatusChangesHandler), Times.Exactly(3));
moduleClient.Verify(m => m.SetDefaultMethodHandlerAsync(It.IsAny <MethodCallback>()), Times.Once);
moduleClient.Verify(m => m.SetDesiredPropertyUpdateCallbackAsync(desiredPropertyUpdateCallback), Times.Once);
}
private void Awake()
{
moduleConnection = GameObject.FindObjectOfType <ModuleConnection>();
}
void Awake()
{
DontDestroyOnLoad(this.gameObject);
moduleConnection = GameObject.FindObjectOfType <ModuleConnection>();
}
