public void SaveElasticsearchSource_GivenResourceDefinition_ShouldSave()
{
//----------------------Arrange----------------------
var mockResourceCatalog = new Mock <IResourceCatalog>();
var elasticsearchSourceDefinition = new ElasticsearchSourceDefinition()
{
Name = "ElasticsearchSource",
HostName = "testHost",
Password = "******",
AuthenticationType = AuthenticationType.Password,
SearchIndex = "warewolflogs"
};
mockResourceCatalog.Setup(o => o.SaveResource(It.IsAny <Guid>(), elasticsearchSourceDefinition.SerializeToJsonStringBuilder(), string.Empty));
var sut = new SaveElasticsearchSource(mockResourceCatalog.Object);
//----------------------Act--------------------------
var result = sut.Execute(new Dictionary <string, StringBuilder> {
{ "ElasticsearchSource", elasticsearchSourceDefinition.SerializeToJsonStringBuilder() }
}, new Mock <IWorkspace>().Object);
//----------------------Assert-----------------------
var serializer = new Dev2JsonSerializer();
Assert.IsFalse(serializer.Deserialize <ExecuteMessage>(result).HasError);
mockResourceCatalog.Verify(o => o.SaveResource(It.IsAny <Guid>(), It.IsAny <ElasticsearchSource>(), It.IsAny <string>()), Times.Once);
}
public void SaveElasticsearchSource_Execute_GivenResourceDefination_ShouldSaveNewSourceReturnResourceDefinationMsg()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var source = new ElasticsearchSourceDefinition()
{
Id = Guid.Empty,
Name = "Name",
HostName = "HostName",
Port = "3679",
AuthenticationType = AuthenticationType.Anonymous,
SearchIndex = "warewolflogs"
};
var compressedExecuteMessage = new CompressedExecuteMessage();
var serializeToJsonString = source.SerializeToJsonString(new DefaultSerializationBinder());
compressedExecuteMessage.SetMessage(serializeToJsonString);
var values = new Dictionary <string, StringBuilder>
{
{ "ElasticsearchSource", source.SerializeToJsonStringBuilder() }
};
var catalog = new Mock <IResourceCatalog>();
catalog.Setup(resourceCatalog => resourceCatalog.GetResource(It.IsAny <Guid>(), source.Name));
catalog.Setup(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), It.IsAny <IResource>(), It.IsAny <string>()));
var elasticsearchSource = new SaveElasticsearchSource(catalog.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var jsonResult = elasticsearchSource.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsFalse(result.HasError);
catalog.Verify(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), It.IsAny <IResource>(), It.IsAny <string>()));
}
public void GivenIOpenElasticsearchSource(string resourceName)
{
var elasticsearchSourceControl = _scenarioContext.Get <ElasticsearchSourceControl>(Utils.ViewNameKey);
var mockStudioUpdateManager = new Mock <IElasticsearchSourceModel>();
mockStudioUpdateManager.Setup(model => model.ServerName).Returns("rsaklfwynand");
var mockEventAggregator = new Mock <IEventAggregator>();
var mockExecutor = new Mock <IExternalProcessExecutor>();
var elasticsearchSourceDefinition = new ElasticsearchSourceDefinition
{
Name = "Test-Elasticsearch",
HostName = "http://rsaklfwynand",
Password = "******",
SearchIndex = "warewolflogs",
Port = "9200"
};
mockStudioUpdateManager.Setup(model => model.FetchSource(It.IsAny <Guid>())).Returns(elasticsearchSourceDefinition);
var elasticsearchSourceViewModel = new ElasticsearchSourceViewModel(mockStudioUpdateManager.Object, mockEventAggregator.Object, elasticsearchSourceDefinition, new SynchronousAsyncWorker(), mockExecutor.Object, new Mock <IServer>().Object);
elasticsearchSourceControl.DataContext = elasticsearchSourceViewModel;
_scenarioContext.Remove("viewModel");
_scenarioContext.Add("viewModel", elasticsearchSourceViewModel);
}
public IElasticsearchSourceDefinition FetchSource(Guid id)
{
var xaml = _queryManager.FetchResourceXaml(id);
var source = new ElasticsearchSource(xaml.ToXElement());
var def = new ElasticsearchSourceDefinition(source);
return(def);
}
void ToItem()
{
Item = new ElasticsearchSourceDefinition
{
HostName = _elasticsearchServiceSource.HostName,
SearchIndex = _elasticsearchServiceSource.SearchIndex,
Password = _elasticsearchServiceSource.Password,
Username = _elasticsearchServiceSource.Username,
Port = _elasticsearchServiceSource.Port,
Name = _elasticsearchServiceSource.Name,
Id = _elasticsearchServiceSource.Id,
AuthenticationType = _elasticsearchServiceSource.AuthenticationType,
Path = _elasticsearchServiceSource.Path,
};
}
public void TestElasticsearchSource_Execute_Auth_Password_GivenResourceDefinition_ShouldTestNewSourceReturnResourceDefinitionMsg()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var dependency = new Depends(Depends.ContainerType.AnonymousElasticsearch);
var hostName = "http://" + dependency.Container.IP;
var source = new ElasticsearchSourceDefinition()
{
Id = Guid.Empty,
Name = "Name",
HostName = hostName,
Port = dependency.Container.Port,
Username = "******",
Password = "******",
SearchIndex = "warewolftestlogs",
AuthenticationType = Dev2.Runtime.ServiceModel.Data.AuthenticationType.Password
};
var testElasticsearchSource = new TestElasticsearchSource();
var values = new Dictionary <string, StringBuilder>
{
{ "ElasticsearchSource", source.SerializeToJsonStringBuilder() }
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
try
{
var jsonResult = testElasticsearchSource.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsFalse(result.HasError, result.Message.ToString());
}
catch (Exception e)
{
if (e.Message.Contains("could not connect to elasticsearch Instance"))
{
Assert.Inconclusive(e.Message);
}
else
{
throw;
}
}
}