public void StudioNetworkServer_StudioNetworkServerUnitTest_UpdateMappingChangedMemo_MemoUpdated()
{
//init
var server = new MockEsbHub();
var message = new CompileMessageTO {
UniqueID = Guid.NewGuid(), ServiceID = Guid.NewGuid(), WorkspaceID = Guid.NewGuid(), MessageType = CompileMessageType.MappingChange, MessagePayload = "Test Error Message", ServiceName = "Test Service"
};
//exe
server.TestOnCompilerMessageReceived(new ICompileMessageTO[] { message });
//asserts
Assert.AreEqual(2, server.WriteEventProviderMemos.Count);
foreach (var memo1 in server.WriteEventProviderMemos)
{
var memo = (DesignValidationMemo)memo1;
Assert.AreEqual(message.ServiceID, memo.ServiceID, "Memo service name not updated with compiler message service name");
Assert.AreEqual(message.WorkspaceID, memo.WorkspaceID, "Memo workspace ID not updated");
Assert.IsFalse(memo.IsValid, "Error memo not invalidated");
Assert.AreEqual(1, memo.Errors.Count, "The wrong number of errors was added to the memo");
Assert.AreEqual(message.MessagePayload, memo.Errors[0].FixData, "The wrong error fix data was added to the memo");
Assert.AreEqual(message.UniqueID, memo.Errors[0].InstanceID, "The error instacen ID was added to the memo");
}
var serviceMemo = (DesignValidationMemo)server.WriteEventProviderMemos[0];
var unqiueMemo = (DesignValidationMemo)server.WriteEventProviderMemos[1];
Assert.AreEqual(message.UniqueID, unqiueMemo.InstanceID, "Memo ID not updated with compiler message unique ID");
Assert.AreEqual(message.ServiceID, serviceMemo.InstanceID, "Memo ID not updated with compiler message service ID");
}
public void StudioNetworkServer_StudioNetworkServerUnitTest_UpdateResourceSavedMemo_MemoUpdated()
{
//init
var server = new MockEsbHub();
var message = new CompileMessageTO {
ServiceID = Guid.NewGuid(), WorkspaceID = Guid.NewGuid(), MessageType = CompileMessageType.ResourceSaved, ServiceName = "Test Service"
};
//exe
server.TestOnCompilerMessageReceived(new ICompileMessageTO[] { message });
//asserts
Assert.AreEqual(1, server.WriteEventProviderMemos.Count);
var memo = (DesignValidationMemo)server.WriteEventProviderMemos[0];
Assert.AreEqual(message.ServiceID, memo.InstanceID, "Memo ID not updated with compiler message service ID");
Assert.AreEqual(message.ServiceID, memo.ServiceID, "Memo service name not updated with compiler message service name");
Assert.AreEqual(message.WorkspaceID, memo.WorkspaceID, "Memo workspace ID not updated");
Assert.IsTrue(memo.IsValid, "Resource saved with invalid memo");
}
public void CompileMessageTO_CompileMessageTOUnitTest_ToErrorInfo_CorrectErrorInfoReturned()
{
//init
var message = new CompileMessageTO();
var expectedID = Guid.NewGuid();
message.UniqueID = expectedID;
message.ErrorType = ErrorType.Critical;
const FixType expectedFixType = FixType.ReloadMapping;
message.MessageType = CompileMessageType.MappingChange;
message.MessagePayload = "Test Fix Data";
//exe
var actual = message.ToErrorInfo();
//aserts
Assert.AreEqual(expectedID, actual.InstanceID, "ToErrorInfo created an error info object with an incorrect InstanceID");
Assert.AreEqual(ErrorType.Critical, actual.ErrorType, "ToErrorInfo created an error info object with an incorrect ErrorType");
Assert.AreEqual(expectedFixType, actual.FixType, "ToErrorInfo created an error info object with an incorrect FixType");
Assert.AreEqual(CompileMessageType.MappingChange.GetDescription(), actual.Message, "ToErrorInfo created an error info object with an incorrect Message");
Assert.AreEqual("Test Fix Data", actual.FixData, "ToErrorInfo created an error info object with incorrect FixData");
}
public void CompileMessageTO_Clone_ShouldCloneAllProperties()
{
//------------Setup for test--------------------------
var message = new CompileMessageTO();
var uniqueID = Guid.NewGuid();
var workspaceID = Guid.NewGuid();
const string serviceName = "Some Service Name";
var messageID = Guid.NewGuid();
var serviceID = Guid.NewGuid();
const ErrorType errorType = ErrorType.Critical;
const FixType fixType = FixType.ReloadMapping;
const CompileMessageType messageType = CompileMessageType.MappingChange;
const string messagePayload = "Test Fix Data";
message.UniqueID = uniqueID;
message.WorkspaceID = workspaceID;
message.ServiceID = serviceID;
message.MessageID = messageID;
message.ErrorType = errorType;
message.ServiceName = serviceName;
message.MessageType = messageType;
message.MessagePayload = messagePayload;
//------------Execute Test---------------------------
var clonedTO = message.Clone();
//------------Assert Results-------------------------
Assert.AreEqual(workspaceID, clonedTO.WorkspaceID);
Assert.AreEqual(messageID, clonedTO.MessageID);
Assert.AreEqual(serviceID, clonedTO.ServiceID);
Assert.AreEqual(uniqueID, clonedTO.UniqueID);
Assert.AreEqual(serviceName, clonedTO.ServiceName);
Assert.AreEqual(errorType, clonedTO.ErrorType);
Assert.AreEqual(fixType, clonedTO.ToFixType());
Assert.AreEqual(messageType, clonedTO.MessageType);
Assert.AreEqual(messagePayload, clonedTO.MessagePayload);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
string serviceId = null;
string workspaceId = null;
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
var result = new ExecuteMessage {
HasError = false
};
StringBuilder tmp;
values.TryGetValue("ServiceID", out tmp);
if (tmp != null)
{
serviceId = tmp.ToString();
}
values.TryGetValue("WorkspaceID", out tmp);
if (tmp != null)
{
workspaceId = tmp.ToString();
}
values.TryGetValue("FilterList", out tmp);
if (tmp != null)
{
}
if (string.IsNullOrEmpty(serviceId) || string.IsNullOrEmpty(workspaceId))
{
throw new InvalidDataContractException("Null or empty ServiceID or WorkspaceID");
}
Guid wGuid;
Guid sGuid;
Guid.TryParse(workspaceId, out wGuid);
Guid.TryParse(serviceId, out sGuid);
var thisService = ResourceCatalog.Instance.GetResource(wGuid, sGuid);
var msgs = new CompileMessageList();
var dependants = new List <Guid>();
if (thisService != null)
{
var workspaceGuids = WorkspaceRepository.Instance.GetWorkspaceGuids();
workspaceGuids.ForEach(guid =>
{
var union = dependants.Union(ResourceCatalog.Instance.GetDependants(guid, thisService.ResourceID));
dependants = union.ToList();
});
var enumerable = dependants.Select(a =>
{
var resource = ResourceCatalog.Instance.GetResource(GlobalConstants.ServerWorkspaceID, a) ?? ResourceCatalog.Instance.GetResource(wGuid, a);
return(resource == null?"": resource.ResourcePath);
});
var deps = enumerable.Distinct().ToList();
if (deps.Count > 0)
{
// ReSharper disable ExpressionIsAlwaysNull
msgs = new CompileMessageList();
var compileMessageTo = new CompileMessageTO
{
ErrorType = ErrorType.Critical,
MessageType = CompileMessageType.MappingChange
};
msgs.Dependants = new List <string>();
deps.ForEach(s => msgs.Dependants.Add(s));
msgs.MessageList = new List <ICompileMessageTO> {
compileMessageTo
};
// ReSharper restore ExpressionIsAlwaysNull
return(serializer.SerializeToBuilder(msgs));
}
}
else
{
result.Message.Append("Could not locate service with ID [ " + sGuid + " ]");
}
return(serializer.SerializeToBuilder(msgs));
}
