public void GivenIOpenRedisSource(string resourceName)
{
var redisSourceControl = _scenarioContext.Get <RedisSourceControl>(Utils.ViewNameKey);
var mockStudioUpdateManager = new Mock <IRedisSourceModel>();
mockStudioUpdateManager.Setup(model => model.ServerName).Returns("localhost");
var mockEventAggregator = new Mock <IEventAggregator>();
var mockExecutor = new Mock <IExternalProcessExecutor>();
var redisSourceDefinition = new RedisSourceDefinition
{
Name = "Test-Redis",
HostName = "http://TFSBLD.premier.local/IntegrationTestSite",
Password = "******",
Port = "6379"
};
mockStudioUpdateManager.Setup(model => model.FetchSource(It.IsAny <Guid>()))
.Returns(redisSourceDefinition);
var redisSourceViewModel = new RedisSourceViewModel(mockStudioUpdateManager.Object, mockEventAggregator.Object, redisSourceDefinition, new SynchronousAsyncWorker(), mockExecutor.Object);
redisSourceControl.DataContext = redisSourceViewModel;
_scenarioContext.Remove("viewModel");
_scenarioContext.Add("viewModel", redisSourceViewModel);
}
public void TestRedisSource_Execute_GivenResourceDefinition_ShouldTestNewSourceReturnResourceDefinitionMsg()
{
//---------------Set up test pack-------------------
var dependency = new Depends(Depends.ContainerType.AnonymousRedis);
var serializer = new Dev2JsonSerializer();
var source = new RedisSourceDefinition()
{
Id = Guid.Empty,
Name = "Name",
HostName = dependency.Container.IP,
Port = dependency.Container.Port,
AuthenticationType = Dev2.Runtime.ServiceModel.Data.AuthenticationType.Anonymous
};
var testRedisSource = new TestRedisSource();
var values = new Dictionary <string, StringBuilder>
{
{ "RedisSource", source.SerializeToJsonStringBuilder() }
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var jsonResult = testRedisSource.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsFalse(result.HasError, result.Message.ToString());
}
public void SaveRedisSource_Execute_GivenResourceDefination_GivenExising_ShouldReturnResourceDefinationMsg()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var source = new RedisSourceDefinition()
{
Id = Guid.Empty,
Name = "Name",
HostName = "HostName",
Port = "3679",
AuthenticationType = AuthenticationType.Anonymous
};
var compressedExecuteMessage = new CompressedExecuteMessage();
var serializeToJsonString = source.SerializeToJsonString(new DefaultSerializationBinder());
compressedExecuteMessage.SetMessage(serializeToJsonString);
var values = new Dictionary <string, StringBuilder>
{
{ "RedisSource", source.SerializeToJsonStringBuilder() }
};
var catalog = new Mock <IResourceCatalog>();
var redisSource = new RedisSource();
catalog.Setup(resourceCatalog => resourceCatalog.GetResource(It.IsAny <Guid>(), source.Name)).Returns(redisSource);
catalog.Setup(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), redisSource, It.IsAny <string>()));
var saveRedisSource = new SaveRedisSource(catalog.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var jsonResult = saveRedisSource.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsFalse(result.HasError);
catalog.Verify(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), redisSource, It.IsAny <string>()));
}
public void SaveRedisSource_Execute_GivenResourceDefinition_ShouldSave()
{
//----------------------Arrange----------------------
var mockResourceCatalog = new Mock <IResourceCatalog>();
var redisSourceDefination = new RedisSourceDefinition
{
Name = "redisSource",
HostName = "testHost",
Password = "******",
AuthenticationType = AuthenticationType.Password
};
mockResourceCatalog.Setup(o => o.SaveResource(It.IsAny <Guid>(), redisSourceDefination.SerializeToJsonStringBuilder(), string.Empty));
var sut = new SaveRedisSource(mockResourceCatalog.Object);
//----------------------Act--------------------------
var result = sut.Execute(new Dictionary <string, StringBuilder> {
{ "RedisSource", redisSourceDefination.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 <RedisSource>(), It.IsAny <string>()), Times.Once);
}
public void RedisSourceDefinition_Equals_RedisServiceSource_Expected_True()
{
const AuthenticationType expectedAuthenticationType = AuthenticationType.Password;
var expectedId = Guid.NewGuid();
const string expectedName = "testResourceName";
const string expectedPassword = "******";
const string expectedHostName = "testHost";
var mockRedisSource = new Mock <IRedisSource>();
mockRedisSource.Setup(redisSource => redisSource.HostName).Returns(expectedHostName);
mockRedisSource.Setup(redisSource => redisSource.ResourceID).Returns(expectedId);
mockRedisSource.Setup(redisSource => redisSource.ResourceName).Returns(expectedName);
mockRedisSource.Setup(redisSource => redisSource.Password).Returns(expectedPassword);
mockRedisSource.Setup(redisSource => redisSource.AuthenticationType).Returns(expectedAuthenticationType);
var redisSourceDefinition = new RedisSourceDefinition(mockRedisSource.Object);
var mockRedisServiceSource = new Mock <IRedisServiceSource>();
mockRedisServiceSource.Setup(redisServiceSource => redisServiceSource.HostName).Returns(expectedHostName);
mockRedisServiceSource.Setup(redisServiceSource => redisServiceSource.Id).Returns(expectedId);
mockRedisServiceSource.Setup(redisServiceSource => redisServiceSource.Name).Returns(expectedName);
mockRedisServiceSource.Setup(redisServiceSource => redisServiceSource.Password).Returns(expectedPassword);
mockRedisServiceSource.Setup(redisServiceSource => redisServiceSource.AuthenticationType).Returns(expectedAuthenticationType);
var isEqual = redisSourceDefinition.Equals(mockRedisServiceSource.Object);
Assert.IsTrue(isEqual);
}
public void RedisSourceDefinition_Equals_Object_GetType_Expected_False()
{
const AuthenticationType expectedAuthenticationType = AuthenticationType.Password;
var expectedId = Guid.NewGuid();
const string expectedName = "testResourceName";
const string expectedPassword = "******";
const string expectedHostName = "testHost";
const string expectedPath = "testPath";
var mockRedisSource = new Mock <IRedisSource>();
mockRedisSource.Setup(redisSource => redisSource.AuthenticationType).Returns(expectedAuthenticationType);
mockRedisSource.Setup(redisSource => redisSource.ResourceID).Returns(expectedId);
mockRedisSource.Setup(redisSource => redisSource.ResourceName).Returns(expectedName);
mockRedisSource.Setup(redisSource => redisSource.Password).Returns(expectedPassword);
mockRedisSource.Setup(redisSource => redisSource.HostName).Returns(expectedHostName);
mockRedisSource.Setup(redisSource => redisSource.GetSavePath()).Returns(expectedPath);
var redisSourceDefinition = new RedisSourceDefinition(mockRedisSource.Object);
var redisSourceObj = new object();
var isEqual = redisSourceDefinition.Equals(redisSourceObj);
Assert.IsFalse(isEqual);
}
public void RedisSourceDefinition_Validate()
{
const AuthenticationType expectedAuthenticationType = AuthenticationType.Password;
var expectedId = Guid.NewGuid();
const string expectedName = "testResourceName";
const string expectedPassword = "******";
const string expectedHostName = "testHost";
const string expectedPath = "testPath";
var mockRedisSource = new Mock <IRedisSource>();
mockRedisSource.Setup(redisSource => redisSource.AuthenticationType).Returns(expectedAuthenticationType);
mockRedisSource.Setup(redisSource => redisSource.ResourceID).Returns(expectedId);
mockRedisSource.Setup(redisSource => redisSource.ResourceName).Returns(expectedName);
mockRedisSource.Setup(redisSource => redisSource.Password).Returns(expectedPassword);
mockRedisSource.Setup(redisSource => redisSource.HostName).Returns(expectedHostName);
mockRedisSource.Setup(redisSource => redisSource.GetSavePath()).Returns(expectedPath);
var redisSourceDefinition = new RedisSourceDefinition(mockRedisSource.Object);
Assert.AreEqual(expectedAuthenticationType, redisSourceDefinition.AuthenticationType);
Assert.AreEqual(expectedId, redisSourceDefinition.Id);
Assert.AreEqual(expectedName, redisSourceDefinition.Name);
Assert.AreEqual(expectedPassword, redisSourceDefinition.Password);
Assert.AreEqual(expectedHostName, redisSourceDefinition.HostName);
Assert.AreEqual(expectedPath, redisSourceDefinition.Path);
}
public IRedisServiceSource FetchSource(Guid id)
{
var xaml = _queryProxy.FetchResourceXaml(id);
var redisSource = new RedisSource(xaml.ToXElement());
var def = new RedisSourceDefinition(redisSource);
return(def);
}
public void RedisSourceDefinition_Equals_RedisServiceSource_Null_Expected_False()
{
var redisSourceDefinition = new RedisSourceDefinition();
const IRedisServiceSource redisServiceSource = null;
var isEqual = redisSourceDefinition.Equals(redisServiceSource);
Assert.IsFalse(isEqual);
}
public void RedisSourceDefinition_GetHashCode_Expect_Zero()
{
var mockRedisSource = new Mock <IRedisSource>();
var redisSourceDefinition = new RedisSourceDefinition(mockRedisSource.Object);
var hashCode = redisSourceDefinition.GetHashCode();
Assert.AreEqual(0, hashCode);
}
public void RedisSourceDefinition_Equals_Object_Null_Expected_False()
{
var redisSourceDefinition = new RedisSourceDefinition();
const object redisSource = null;
var isEqual = redisSourceDefinition.Equals(redisSource);
Assert.IsFalse(isEqual);
}
public void RedisSourceDefinition_Equals_RedisSourceDefinition_Null_Expected_False()
{
var redisSourceDefinition = new RedisSourceDefinition();
const RedisSourceDefinition nullRedisSourceDefinition = null;
var isEqual = redisSourceDefinition.Equals(nullRedisSourceDefinition);
Assert.IsFalse(isEqual);
}
public void RedisSourceDefinition_GetHashCode_Not_Equal_To_Zero()
{
const AuthenticationType expectedAuthenticationType = AuthenticationType.Password;
var expectedId = Guid.NewGuid();
const string expectedName = "testResourceName";
const string expectedPassword = "******";
const string expectedHostName = "testHost";
const string expectedPath = "testPath";
var mockRedisSource = new Mock <IRedisSource>();
mockRedisSource.Setup(redisSource => redisSource.AuthenticationType).Returns(expectedAuthenticationType);
mockRedisSource.Setup(redisSource => redisSource.ResourceID).Returns(expectedId);
mockRedisSource.Setup(redisSource => redisSource.ResourceName).Returns(expectedName);
mockRedisSource.Setup(redisSource => redisSource.Password).Returns(expectedPassword);
mockRedisSource.Setup(redisSource => redisSource.HostName).Returns(expectedHostName);
mockRedisSource.Setup(redisSource => redisSource.GetSavePath()).Returns(expectedPath);
var redisSourceDefinition = new RedisSourceDefinition(mockRedisSource.Object);
var hashCode = redisSourceDefinition.GetHashCode();
Assert.AreNotEqual(0, hashCode);
}
