public void Dispose()
{
var parts = new TypeCatalog(typeof(FooImpl), typeof(FooImpl2), typeof(FooImpl2)).Parts;
var exports = parts.Select(p => Tuple.Create(p, p.ExportDefinitions.First()));
TestCatalog catalog = new TestCatalog(
() => parts,
() => exports);
var import = parts.SelectMany(p => p.ImportDefinitions).First();
CompositionScopeDefinition scope = new CompositionScopeDefinition(catalog, null);
scope.Dispose();
var ex = ExceptionAssert.Throws <ObjectDisposedException>(RetryMode.DoNotRetry, () =>
{
var ps = scope.Parts;
});
ex = ExceptionAssert.Throws <ObjectDisposedException>(RetryMode.DoNotRetry, () =>
{
var es = scope.GetExports(import);
});
scope.Dispose();
ex = ExceptionAssert.Throws <ObjectDisposedException>(RetryMode.DoNotRetry, () =>
{
var ps = scope.Parts;
});
ex = ExceptionAssert.Throws <ObjectDisposedException>(RetryMode.DoNotRetry, () =>
{
var es = scope.GetExports(import);
});
}
public void TestCatalog_FetchTest_WhenInvalidResourceIdTestName_ShouldReturnNull()
{
//------------Setup for test--------------------------
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var serviceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 1"
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 2"
}
};
testCatalog.SaveTests(Guid.NewGuid(), serviceTestModelTos);
//------------Assert Preconditions-------------------
//------------Execute Test---------------------------
var test = testCatalog.FetchTest(resourceID, "Test 6");
//------------Assert Results-------------------------
Assert.IsNull(test);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new CompressedExecuteMessage {
HasError = false
};
var jsonSerializer = new Dev2JsonSerializer();
try
{
values.TryGetValue("excludeList", out StringBuilder excludeTests);
var testsToLive = jsonSerializer.Deserialize <List <string> >(excludeTests);
TestCatalog.DeleteAllTests(testsToLive.Select(a => a.ToUpper()).ToList());
result.SetMessage("Test reload succesful");
}
catch (Exception ex)
{
result.HasError = true;
result.SetMessage("Error reloading tests...");
Dev2Logger.Error(ex, GlobalConstants.WarewolfError);
}
var serializer = new Dev2JsonSerializer();
return(serializer.SerializeToBuilder(result));
}
public IExplorerRepositoryResult DeleteItem(IExplorerItem itemToDelete, Guid workSpaceId)
{
if (itemToDelete == null)
{
return(new ExplorerRepositoryResult(ExecStatus.Fail, ErrorResource.ItemToDeleteWasNull));
}
if (itemToDelete.ResourceType == "Folder")
{
return(DeleteFolder(itemToDelete, workSpaceId));
}
var result = ResourceCatalogue.DeleteResource(workSpaceId, itemToDelete.ResourceId, itemToDelete.ResourceType);
TestCatalog.DeleteAllTests(itemToDelete.ResourceId);
if (result.Status == ExecStatus.Success)
{
var itemDeleted = Find(_root, itemToDelete.ResourceId);
if (itemDeleted != null)
{
var parent = Find(_root, item => item.ResourcePath == GetSavePath(itemDeleted));
if (parent != null)
{
parent.Children.Remove(itemDeleted);
}
else
{
_root.Children.Remove(itemDeleted);
}
}
}
return(new ExplorerRepositoryResult(result.Status, result.Message));
}
public void TestCatalog_SaveTests_WhenNoResourceIdList_ShouldSaveTestAsFiles()
{
//------------Setup for test--------------------------
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var testToSave = new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 1"
};
//------------Execute Test---------------------------
testCatalog.SaveTest(resourceID, testToSave);
//------------Assert Results-------------------------
var path = EnvironmentVariables.TestPath + "\\" + resourceID;
Assert.IsTrue(Directory.Exists(path));
var testFiles = Directory.EnumerateFiles(path).ToList();
var test1FilePath = path + "\\" + "Test 1.test";
Assert.AreEqual(test1FilePath, testFiles[0]);
var test1String = File.ReadAllText(test1FilePath);
var serializer = new Dev2JsonSerializer();
var test1 = serializer.Deserialize <IServiceTestModelTO>(test1String);
Assert.AreEqual("Test 1", test1.TestName);
Assert.IsFalse(test1.Enabled);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Fetch Tests Service", GlobalConstants.WarewolfInfo);
values.TryGetValue("resourceID", out StringBuilder resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
if (!Guid.TryParse(resourceIdString.ToString(), out Guid resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
var tests = TestCatalog.Fetch(resourceId);
var message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(tests));
message.HasError = false;
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public void TestCatalog_Reload_ShouldLoadDictionaryWithResourceIdAndTests()
{
//------------Setup for test--------------------------
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var resourceID2 = Guid.NewGuid();
var serviceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 1"
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 2"
}
};
var res2ServiceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 21"
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 22"
}
};
testCatalog.SaveTests(resourceID, serviceTestModelTos);
testCatalog.SaveTests(resourceID2, res2ServiceTestModelTos);
testCatalog.Load();
//------------Assert Preconditions-------------------
Assert.AreEqual(2, testCatalog.Tests.Count);
var res1Tests = testCatalog.Tests[resourceID];
Assert.AreEqual(2, res1Tests.Count);
Assert.AreEqual("Test 1", res1Tests[0].TestName);
Assert.AreEqual("Test 2", res1Tests[1].TestName);
var res2Tests = testCatalog.Tests[resourceID2];
Assert.AreEqual(2, res2Tests.Count);
Assert.AreEqual("Test 21", res2Tests[0].TestName);
Assert.AreEqual("Test 22", res2Tests[1].TestName);
DirectoryWrapperInstance().CleanUp(EnvironmentVariables.TestPath);
Directory.CreateDirectory(EnvironmentVariables.TestPath);
//------------Execute Test---------------------------
testCatalog.ReloadAllTests();
//------------Assert Results-------------------------
Assert.AreEqual(0, testCatalog.Tests.Count);
}
public void CatalogPresentation()
{
var description = Guid.NewGuid().ToString();
var catalog = new TestCatalog
{
Наименование = description
};
Assert.That(Функции.Представление(catalog), Is.EqualTo(description));
}
public void TestCatalog_DeleteAllTests_WhenResourceIdTestName_ShouldDeleteTestFolder()
{
//------------Setup for test--------------------------
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var serviceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 1"
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 2"
}
};
testCatalog.SaveTests(resourceID, serviceTestModelTos);
//------------Assert Preconditions-------------------
var path = EnvironmentVariables.TestPath + "\\" + resourceID;
Assert.IsTrue(Directory.Exists(path));
var testFiles = Directory.EnumerateFiles(path).ToList();
var test1FilePath = path + "\\" + "Test 1.test";
Assert.AreEqual(test1FilePath, testFiles[0]);
var test2FilePath = path + "\\" + "Test 2.test";
Assert.AreEqual(test2FilePath, testFiles[1]);
var modelTO = testCatalog.Tests.Select(pair => pair.Value.Single(to => to.TestName == "Test 2")).Single();
Assert.IsNotNull(modelTO);
var test1String = File.ReadAllText(test1FilePath);
var serializer = new Dev2JsonSerializer();
var test1 = serializer.Deserialize <IServiceTestModelTO>(test1String);
Assert.AreEqual("Test 1", test1.TestName);
Assert.IsTrue(test1.Enabled);
var test2String = File.ReadAllText(test2FilePath);
var test2 = serializer.Deserialize <IServiceTestModelTO>(test2String);
Assert.AreEqual("Test 2", test2.TestName);
Assert.IsFalse(test2.Enabled);
//------------Execute Test---------------------------
testCatalog.DeleteAllTests(resourceID);
//------------Assert Results-------------------------
Assert.IsFalse(File.Exists(test1FilePath));
Assert.IsFalse(File.Exists(test2FilePath));
modelTO = testCatalog.Tests.Select(pair => pair.Value.SingleOrDefault(to => to.TestName == "Test 2")).SingleOrDefault();
Assert.IsNull(modelTO);
Assert.IsFalse(Directory.Exists(path));
}
public void TestCatalog_SaveTests_WhenEmptyList_ShouldDoNothing()
{
//------------Setup for test--------------------------
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
//------------Execute Test---------------------------
testCatalog.SaveTests(resourceID, new List <IServiceTestModelTO>());
//------------Assert Results-------------------------
Assert.IsFalse(Directory.Exists(EnvironmentVariables.TestPath + "\\" + resourceID));
}
public void Parts_DelegateToCatalog()
{
var parts = new TypeCatalog(typeof(FooImpl), typeof(FooImpl2), typeof(FooImpl2)).Parts;
var exports = parts.Select(p => Tuple.Create(p, p.ExportDefinitions.First()));
TestCatalog catalog = new TestCatalog(
() => parts,
() => exports);
CompositionScopeDefinition scope = new CompositionScopeDefinition(catalog, null);
EqualityExtensions.CheckEquals(parts, scope.Parts);
}
public void Parts_DelegateToCatalog()
{
var parts = new TypeCatalog(typeof(FooImpl), typeof(FooImpl2), typeof(FooImpl2)).Parts;
var exports = parts.Select(p => Tuple.Create(p, p.ExportDefinitions.First()));
TestCatalog catalog = new TestCatalog(
() => parts,
() => exports);
CompositionScopeDefinition scope = new CompositionScopeDefinition(catalog, null);
EnumerableAssert.AreSequenceEqual(parts, scope.Parts);
}
public void TestCatalog_Load_WhenTests_ShouldLoadDictionaryWithResourceIdAndTests()
{
//------------Setup for test--------------------------
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var resourceID2 = Guid.NewGuid();
var serviceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 1"
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 2"
}
};
var res2ServiceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 21"
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 22"
}
};
testCatalog.SaveTests(resourceID, serviceTestModelTos);
testCatalog.SaveTests(resourceID2, res2ServiceTestModelTos);
//------------Execute Test---------------------------
testCatalog.Load();
//------------Assert Results-------------------------
Assert.AreEqual(2, testCatalog.Tests.Count);
var res1Tests = testCatalog.Tests[resourceID];
Assert.AreEqual(2, res1Tests.Count);
Assert.AreEqual("Test 1", res1Tests[0].TestName);
Assert.AreEqual("Test 2", res1Tests[1].TestName);
var res2Tests = testCatalog.Tests[resourceID2];
Assert.AreEqual(2, res2Tests.Count);
Assert.AreEqual("Test 21", res2Tests[0].TestName);
Assert.AreEqual("Test 22", res2Tests[1].TestName);
}
public void GetExports_DelegateToCatalog()
{
var parts = new TypeCatalog(typeof(FooImpl), typeof(FooImpl2), typeof(FooImpl2)).Parts;
var exports = parts.Select(p => Tuple.Create(p, p.ExportDefinitions.First()));
var import = parts.SelectMany(p => p.ImportDefinitions).First();
TestCatalog catalog = new TestCatalog(
() => parts,
() => exports);
CompositionScopeDefinition scope = new CompositionScopeDefinition(catalog, null);
Assert.Same(exports, scope.GetExports(import));
}
public async Task Items_By_Brand_And_TypeId_Should_Return_HttpOk()
{
//Arrange
var items = TestCatalog.CreateItems();
_repository.Setup(x => x.GetItemsAsync(1, 1, 0, 10)).Returns(Task.FromResult(items));
//Act
var actionResult = await _controller.Items(1, 1, 10, 0) as ObjectResult;
//Assert
Assert.NotNull(actionResult);
Assert.Equal(actionResult.StatusCode, (int)HttpStatusCode.OK);
}
public void Notifications()
{
var parts = new TypeCatalog(typeof(FooImpl), typeof(FooImpl2), typeof(FooImpl2)).Parts;
var exports = parts.Select(p => Tuple.Create(p, p.ExportDefinitions.First()));
TestCatalog catalog = new TestCatalog(
() => parts,
() => exports);
CompositionScopeDefinition scope = new CompositionScopeDefinition(catalog, null);
ComposablePartCatalogChangeEventArgs args = new ComposablePartCatalogChangeEventArgs(Enumerable.Empty <ComposablePartDefinition>(), Enumerable.Empty <ComposablePartDefinition>(), null);
bool changedFired = false;
scope.Changed += new EventHandler <ComposablePartCatalogChangeEventArgs>((o, e) =>
{
Assert.AreSame(args, e);
Assert.AreSame(scope, o);
changedFired = true;
});
bool changingFired = false;
scope.Changing += new EventHandler <ComposablePartCatalogChangeEventArgs>((o, e) =>
{
Assert.AreSame(args, e);
Assert.AreSame(scope, o);
changingFired = true;
});
catalog.OnChanged(args);
Assert.IsTrue(changedFired);
catalog.OnChanging(args);
Assert.IsTrue(changingFired);
changedFired = false;
changingFired = false;
scope.Dispose();
catalog.OnChanged(args);
catalog.OnChanging(args);
Assert.IsFalse(changedFired);
Assert.IsFalse(changingFired);
}
public void TestCatalog_Fetch_WhenResourceIdValid_ShouldReturnListOfTestsForResourceId()
{
//------------Setup for test--------------------------
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var resourceID2 = Guid.NewGuid();
var serviceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 1"
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 2"
}
};
var res2ServiceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 21"
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 22"
}
};
testCatalog.SaveTests(resourceID, serviceTestModelTos);
testCatalog.SaveTests(resourceID2, res2ServiceTestModelTos);
testCatalog.Load();
//------------Execute Test---------------------------
var tests = testCatalog.Fetch(resourceID2);
//------------Assert Results-------------------------
var res2Tests = tests;
Assert.AreEqual(2, res2Tests.Count);
Assert.AreEqual("Test 21", res2Tests[0].TestName);
Assert.AreEqual("Test 22", res2Tests[1].TestName);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Delete Test Service");
StringBuilder resourceIdString;
values.TryGetValue("resourceID", out resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
Guid resourceId;
if (!Guid.TryParse(resourceIdString.ToString(), out resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
StringBuilder testName;
values.TryGetValue("testName", out testName);
if (string.IsNullOrEmpty(testName?.ToString()))
{
throw new InvalidDataContractException("testName is missing");
}
TestCatalog.DeleteTest(resourceId, testName.ToString());
CompressedExecuteMessage message = new CompressedExecuteMessage {
HasError = false
};
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Reload All Tests", GlobalConstants.WarewolfInfo);
TestCatalog.ReloadAllTests();
var message = new CompressedExecuteMessage {
HasError = false
};
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Fetch Tests for deploy Service");
StringBuilder resourceIdString;
values.TryGetValue("resourceID", out resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
Guid resourceId;
if (!Guid.TryParse(resourceIdString.ToString(), out resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
var tests = TestCatalog.Fetch(resourceId);
foreach (var serviceTestModelTO in tests.Where(to => !string.IsNullOrEmpty(to.Password)))
{
serviceTestModelTO.Password = SecurityEncryption.Encrypt(serviceTestModelTO.Password);
}
CompressedExecuteMessage message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(tests));
message.HasError = false;
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new CompressedExecuteMessage {
HasError = false
};
try
{
TestCatalog.Load();
result.SetMessage("Test reload succesful");
}
catch (Exception ex)
{
result.HasError = true;
result.SetMessage("Error reloading tests...");
Dev2Logger.Error(ex, GlobalConstants.WarewolfError);
}
var serializer = new Dev2JsonSerializer();
return(serializer.SerializeToBuilder(result));
}
public CatalogRepositoryTests()
{
var logger = new Mock <ILogger>();
var builder = new WebHostBuilder()
.UseEnvironment("UnitTesting")
.UseStartup <Startup>();
var server = new TestServer(builder);
_context = server.Host.Services.GetService(typeof(CatalogContext)) as CatalogContext;
_repository = new CatalogRepository(_context, logger.Object);
_catalogBrands = TestCatalog.CreateBrands();
_catalogTypes = TestCatalog.CreateTypes();
_catalogResponse = TestCatalog.CreateItems();
_context.AddRange(_catalogBrands);
_context.AddRange(_catalogTypes);
_context.AddRange(_catalogResponse.ItemsOnPage);
_context.SaveChanges();
}
public IExplorerRepositoryResult DeleteFolder(string path, bool deleteContents, Guid workSpaceId)
{
if (!Directory.Exists(DirectoryStructureFromPath(path)))
{
return(new ExplorerRepositoryResult(ExecStatus.Fail, string.Format(ErrorResource.RequestedFolderDoesNotExistOnServer, path)));
}
var resourceList = ResourceCatalogue.GetResourceList(workSpaceId);
if (!deleteContents && resourceList.Count(a => a.GetResourcePath(workSpaceId) == path) > 0)
{
return(new ExplorerRepositoryResult(ExecStatus.Fail, string.Format(ErrorResource.RequestedFolderDoesNotExistOnServer, path)));
}
if (path.Trim() == "")
{
return(new ExplorerRepositoryResult(ExecStatus.Fail, ErrorResource.CannotDeleteRootPath));
}
try
{
var testResourceIDsToDelete = resourceList.Where(resource => resource.GetResourcePath(workSpaceId).StartsWith(path));
var guids = testResourceIDsToDelete.Select(resourceToDelete => resourceToDelete.ResourceID);
Directory.Delete(DirectoryStructureFromPath(path), true);
foreach (var guid in guids)
{
TestCatalog.DeleteAllTests(guid);
}
return(new ExplorerRepositoryResult(ExecStatus.Success, ""));
}
catch (Exception err)
{
return(new ExplorerRepositoryResult(ExecStatus.Fail, err.Message));
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Tests Service");
StringBuilder testDefinitionMessage;
StringBuilder resourceIdString;
StringBuilder resourcePathString;
values.TryGetValue("resourceID", out resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
Guid resourceId;
if (!Guid.TryParse(resourceIdString.ToString(), out resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
values.TryGetValue("resourcePath", out resourcePathString);
if (resourcePathString == null)
{
throw new InvalidDataContractException("resourcePath is missing");
}
values.TryGetValue("testDefinitions", out testDefinitionMessage);
if (testDefinitionMessage == null || testDefinitionMessage.Length == 0)
{
throw new InvalidDataContractException("testDefinition is missing");
}
var res = new ExecuteMessage
{
HasError = false,
Message = serializer.SerializeToBuilder(new TestSaveResult
{
Result = SaveResult.Success,
})
};
var decompressedMessage = serializer.Deserialize <CompressedExecuteMessage>(testDefinitionMessage).GetDecompressedMessage();
var serviceTestModelTos = serializer.Deserialize <List <IServiceTestModelTO> >(decompressedMessage);
var resource = ResourceCatalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceId);
if (resource == null)
{
var testResult = new TestSaveResult
{
Result = SaveResult.ResourceDeleted,
Message = $"Resource {resourcePathString} has been deleted. No Tests can be saved for this resource."
};
res.Message = serializer.SerializeToBuilder(testResult);
}
else
{
var resourcePath = resource.GetResourcePath(GlobalConstants.ServerWorkspaceID);
if (!resourcePath.Equals(resourcePathString.ToString(), StringComparison.InvariantCultureIgnoreCase))
{
var testResult = new TestSaveResult
{
Result = SaveResult.ResourceUpdated,
Message = $"Resource {resourcePathString} has changed to {resourcePath}. Tests have been saved for this resource."
};
res.Message = serializer.SerializeToBuilder(testResult);
}
TestCatalog.SaveTests(resourceId, serviceTestModelTos);
}
return(serializer.SerializeToBuilder(res));
}
catch (Exception err)
{
Dev2Logger.Error(err);
var res = new ExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public void TestCatalog_UpdateTestsBasedOnIOChange_WhenTestsFound_ShouldUpdateBasedOnChange_RecordSets()
{
//------------Setup for test--------------------------
var inputDefs = new List <IDev2Definition> {
DataListFactory.CreateDefinition_Recordset("Age", "", "", "", false, "", false, "", false), DataListFactory.CreateDefinition_Recordset("Gender", "", "", "", false, "", false, "", false), DataListFactory.CreateDefinition_Recordset("f", "", "", "rs", false, "", false, "", false), DataListFactory.CreateDefinition_Recordset("g", "", "", "rs", false, "", false, "", false), DataListFactory.CreateDefinition_Recordset("i", "", "", "rs", false, "", false, "", false), DataListFactory.CreateDefinition_Recordset("set", "", "", "rec", false, "", false, "", false)
};
var outputDefs = new List <IDev2Definition> {
DataListFactory.CreateDefinition_Recordset("MessageForUser", "", "", "", false, "", false, "", false), DataListFactory.CreateDefinition_Recordset("out", "", "", "res", false, "", false, "", false)
};
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var serviceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 1",
Inputs = new List <IServiceTestInput>
{
new ServiceTestInputTO
{
Variable = "Name"
},
new ServiceTestInputTO
{
Variable = "Age",
Value = "20"
},
new ServiceTestInputTO
{
Variable = "rs(1).f",
Value = "20"
},
new ServiceTestInputTO
{
Variable = "rs(1).g",
Value = "2"
},
new ServiceTestInputTO
{
Variable = "rs(1).h",
Value = "1"
},
new ServiceTestInputTO
{
Variable = "rs(2).f",
Value = "20"
},
new ServiceTestInputTO
{
Variable = "rs(2).g",
Value = "2"
},
new ServiceTestInputTO
{
Variable = "rs(2).h",
Value = "1"
}
},
Outputs = new List <IServiceTestOutput>
{
new ServiceTestOutputTO
{
Variable = "OutputMessage"
},
new ServiceTestOutputTO
{
Variable = "MessageForUser",
Value = "This is the message"
}
}
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 2",
Inputs = new List <IServiceTestInput>
{
new ServiceTestInputTO
{
Variable = "Name"
},
new ServiceTestInputTO
{
Variable = "Age",
Value = "25"
}
}
}
};
testCatalog.SaveTests(resourceID, serviceTestModelTos);
//------------Execute Test---------------------------
testCatalog.UpdateTestsBasedOnIOChange(resourceID, inputDefs, outputDefs);
//------------Assert Results-------------------------
var updatedTests = testCatalog.Fetch(resourceID);
var updatedTest1 = updatedTests[0];
var updatedTest2 = updatedTests[1];
Assert.AreEqual("Test 1", updatedTest1.TestName);
Assert.IsTrue(updatedTest1.TestInvalid);
Assert.IsFalse(updatedTest1.TestFailing);
Assert.IsFalse(updatedTest1.TestPassed);
Assert.IsFalse(updatedTest1.TestPending);
Assert.AreEqual(9, updatedTest1.Inputs.Count);
Assert.AreEqual("Age", updatedTest1.Inputs[0].Variable);
Assert.AreEqual("20", updatedTest1.Inputs[0].Value);
Assert.AreEqual("Gender", updatedTest1.Inputs[1].Variable);
Assert.AreEqual("", updatedTest1.Inputs[1].Value);
Assert.IsFalse(updatedTest1.Inputs[1].EmptyIsNull);
Assert.AreEqual(2, updatedTest1.Outputs.Count);
Assert.AreEqual("MessageForUser", updatedTest1.Outputs[0].Variable);
Assert.AreEqual("This is the message", updatedTest1.Outputs[0].Value);
Assert.AreEqual("Test 2", updatedTest2.TestName);
Assert.IsTrue(updatedTest2.TestInvalid);
Assert.IsFalse(updatedTest2.TestFailing);
Assert.IsFalse(updatedTest2.TestPassed);
Assert.IsFalse(updatedTest2.TestPending);
Assert.AreEqual(6, updatedTest2.Inputs.Count);
Assert.AreEqual("Age", updatedTest2.Inputs[0].Variable);
Assert.AreEqual("25", updatedTest2.Inputs[0].Value);
Assert.AreEqual("Gender", updatedTest2.Inputs[1].Variable);
Assert.AreEqual("", updatedTest2.Inputs[1].Value);
Assert.IsFalse(updatedTest2.Inputs[1].EmptyIsNull);
Assert.AreEqual(2, updatedTest2.Outputs.Count);
Assert.AreEqual("MessageForUser", updatedTest2.Outputs[0].Variable);
Assert.AreEqual("", updatedTest2.Outputs[0].Value);
}
private IEnumerable <DeployResult> DeployResource(Guid resourceId, StringBuilder roles, Dev2JsonSerializer serializer, IHubProxy proxy, bool doTestDeploy)
{
var toReturn = new List <DeployResult>();
var savePath = new StringBuilder();
var resourceContent = ResourceCatalog.GetResourceContents(GlobalConstants.ServerWorkspaceID, resourceId);
var resource = ResourceCatalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceId);
if (!resource.IsService)
{
var fetchResourceService = new FetchResourceDefinition();
resourceContent = fetchResourceService.DecryptAllPasswords(resourceContent);
}
savePath.Append(resource.GetSavePath());
var esbExecuteRequest = new EsbExecuteRequest {
ServiceName = "DeployResourceService"
};
esbExecuteRequest.AddArgument("savePath", savePath);
esbExecuteRequest.AddArgument("ResourceDefinition", resourceContent);
esbExecuteRequest.AddArgument("Roles", roles);
Envelope envelope = new Envelope
{
Content = serializer.SerializeToBuilder(esbExecuteRequest).ToString(),
PartID = 0,
Type = typeof(Envelope)
};
var messageId = Guid.NewGuid();
proxy.Invoke <Receipt>("ExecuteCommand", envelope, true, Guid.Empty, Guid.Empty, messageId).Wait();
Task <string> fragmentInvoke = proxy.Invoke <string>("FetchExecutePayloadFragment", new FutureReceipt {
PartID = 0, RequestID = messageId
});
var fragmentInvokeResult = fragmentInvoke.Result;
var execResult = serializer.Deserialize <ExecuteMessage>(fragmentInvokeResult) ?? new ExecuteMessage {
HasError = true, Message = new StringBuilder("Deploy Fialed")
};
toReturn.Add(new DeployResult(execResult, resource.ResourceName));
if (doTestDeploy)
{
var testsToDeploy = TestCatalog.Fetch(resourceId);
CompressedExecuteMessage message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(testsToDeploy));
var testDeployRequest = new EsbExecuteRequest {
ServiceName = "SaveTests"
};
testDeployRequest.AddArgument("resourceID", resourceId.ToString().ToStringBuilder());
testDeployRequest.AddArgument("resourcePath", savePath);
testDeployRequest.AddArgument("testDefinitions", serializer.SerializeToBuilder(message));
Envelope deployEnvelope = new Envelope
{
Content = serializer.SerializeToBuilder(testDeployRequest).ToString(),
PartID = 0,
Type = typeof(Envelope)
};
var deployMessageId = Guid.NewGuid();
proxy.Invoke <Receipt>("ExecuteCommand", deployEnvelope, true, Guid.Empty, Guid.Empty, deployMessageId).Wait();
Task <string> deployFragmentInvoke = proxy.Invoke <string>("FetchExecutePayloadFragment", new FutureReceipt {
PartID = 0, RequestID = deployMessageId
});
var deployFragmentInvokeResult = deployFragmentInvoke.Result;
var deployExecResult = serializer.Deserialize <ExecuteMessage>(deployFragmentInvokeResult) ?? new ExecuteMessage {
HasError = true, Message = new StringBuilder("Deploy Fialed")
};
toReturn.Add(new DeployResult(deployExecResult, $"{resource.ResourceName} Tests"));
}
return(toReturn);
}
public void TestCatalog_Fetch_WhenPassResult_ShouldReturnListOfTestsForResourceIdWithCorrectPassResult()
{
//------------Setup for test--------------------------
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var resourceID2 = Guid.NewGuid();
var serviceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 1",
TestFailing = true,
TestInvalid = true,
TestPassed = true,
TestPending = true
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 2",
TestFailing = true,
TestInvalid = true,
TestPassed = true,
TestPending = true
}
};
var res2ServiceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 21",
TestFailing = true,
TestInvalid = true,
TestPassed = true,
TestPending = true
},
new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 22",
TestFailing = true,
TestInvalid = true,
TestPassed = true,
TestPending = true
}
};
testCatalog.SaveTests(resourceID, serviceTestModelTos);
testCatalog.SaveTests(resourceID2, res2ServiceTestModelTos);
testCatalog.Load();
//------------Execute Test---------------------------
var tests = testCatalog.Fetch(resourceID2);
//------------Assert Results-------------------------
var res2Tests = tests;
Assert.AreEqual(2, res2Tests.Count);
Assert.AreEqual(true, res2Tests[0].TestFailing);
Assert.AreEqual(true, res2Tests[0].TestInvalid);
Assert.AreEqual(true, res2Tests[0].TestPending);
Assert.AreEqual(true, res2Tests[0].TestPassed);
Assert.AreEqual(true, res2Tests[1].TestPassed);
Assert.AreEqual(true, res2Tests[1].TestPassed);
Assert.AreEqual(true, res2Tests[1].TestPassed);
Assert.AreEqual(true, res2Tests[1].TestPassed);
}
public void TestCatalog_UpdateTestsBasedOnIOChange_WhenTestsFound_ShouldUpdateStepsToInvalid()
{
//------------Setup for test--------------------------
var inputDefs = new List <IDev2Definition> {
DataListFactory.CreateDefinition_Recordset("Age", "", "", "", false, "", false, "", false), DataListFactory.CreateDefinition_Recordset("Gender", "", "", "", false, "", false, "", false)
};
var outputDefs = new List <IDev2Definition> {
DataListFactory.CreateDefinition_Recordset("MessageForUser", "", "", "", false, "", false, "", false)
};
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var serviceTestModelTos = new List <IServiceTestModelTO>
{
new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 1",
TestSteps = new List <IServiceTestStep>
{
new ServiceTestStepTO
{
StepOutputs = new System.Collections.ObjectModel.ObservableCollection <IServiceTestOutput>
{
new ServiceTestOutputTO
{
Variable = "OutputMessage"
},
new ServiceTestOutputTO
{
Variable = "MessageForUser",
Value = "This is the message"
}
},
Result = new TestRunResult
{
RunTestResult = RunResult.TestPassed
}
},
new ServiceTestStepTO
{
Result = new TestRunResult
{
RunTestResult = RunResult.TestFailed
},
Children = new System.Collections.ObjectModel.ObservableCollection <IServiceTestStep>
{
new ServiceTestStepTO
{
StepOutputs = new System.Collections.ObjectModel.ObservableCollection <IServiceTestOutput>
{
new ServiceTestOutputTO
{
Variable = "OutputMessage"
},
new ServiceTestOutputTO
{
Variable = "MessageForUser",
Value = "This is the message"
}
},
Result = new TestRunResult
{
RunTestResult = RunResult.TestPassed
}
}
}
}
},
Inputs = new List <IServiceTestInput>
{
new ServiceTestInputTO
{
Variable = "Name"
},
new ServiceTestInputTO
{
Variable = "Age",
Value = "20"
}
},
Outputs = new List <IServiceTestOutput>
{
new ServiceTestOutputTO
{
Variable = "OutputMessage"
},
new ServiceTestOutputTO
{
Variable = "MessageForUser",
Value = "This is the message"
}
}
}
};
testCatalog.SaveTests(resourceID, serviceTestModelTos);
//------------Execute Test---------------------------
testCatalog.UpdateTestsBasedOnIOChange(resourceID, inputDefs, outputDefs);
//------------Assert Results-------------------------
var updatedTests = testCatalog.Fetch(resourceID);
var updatedTest1 = updatedTests[0];
Assert.AreEqual("Test 1", updatedTest1.TestName);
Assert.IsTrue(updatedTest1.TestInvalid);
Assert.AreEqual(RunResult.TestInvalid, updatedTest1.TestSteps[0].Result.RunTestResult);
Assert.AreEqual(RunResult.TestInvalid, updatedTest1.TestSteps[0].StepOutputs[0].Result.RunTestResult);
Assert.AreEqual(RunResult.TestInvalid, updatedTest1.TestSteps[1].Result.RunTestResult);
Assert.AreEqual(RunResult.TestInvalid, updatedTest1.TestSteps[1].Children[0].StepOutputs[0].Result.RunTestResult);
}
public void TestCatalog_SaveTests_WhenResourceIdListHasTest_ShouldSaveTestUpdateToList()
{
//------------Setup for test--------------------------
var testCatalog = new TestCatalog();
var resourceID = Guid.NewGuid();
var testToSave = new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 1"
};
var testToSave2 = new ServiceTestModelTO
{
Enabled = false,
TestName = "Test 2"
};
testCatalog.SaveTest(resourceID, testToSave);
testCatalog.SaveTest(resourceID, testToSave2);
//------------Assert Preconditions-------------------
var path = EnvironmentVariables.TestPath + "\\" + resourceID;
Assert.IsTrue(Directory.Exists(path));
var testFiles = Directory.EnumerateFiles(path).ToList();
var test1FilePath = path + "\\" + "Test 1.test";
var test2FilePath = path + "\\" + "Test 2.test";
Assert.AreEqual(test1FilePath, testFiles[0]);
Assert.AreEqual(test2FilePath, testFiles[1]);
var test1String = File.ReadAllText(test2FilePath);
var serializer = new Dev2JsonSerializer();
var test2 = serializer.Deserialize <IServiceTestModelTO>(test1String);
Assert.AreEqual("Test 2", test2.TestName);
Assert.IsFalse(test2.Enabled);
var testInList = testCatalog.FetchTest(resourceID, "Test 2");
Assert.IsNotNull(testInList);
Assert.AreEqual("Test 2", testInList.TestName);
//------------Execute Test---------------------------
var testToSaveUpdate = new ServiceTestModelTO
{
Enabled = true,
TestName = "Test 2"
};
testCatalog.SaveTest(resourceID, testToSaveUpdate);
//------------Assert Results-------------------------
var test2StringUpdated = File.ReadAllText(test2FilePath);
var test2Updated = serializer.Deserialize <IServiceTestModelTO>(test2StringUpdated);
Assert.AreEqual("Test 2", test2Updated.TestName);
Assert.IsTrue(test2Updated.Enabled);
var testInListUpdated = testCatalog.FetchTest(resourceID, "Test 2");
Assert.IsNotNull(testInListUpdated);
Assert.AreEqual("Test 2", testInListUpdated.TestName);
Assert.IsTrue(testInListUpdated.Enabled);
}
