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>())); }
protected override List <string> PerformExecution(Dictionary <string, string> evaluatedValues) { try { RedisSource = ResourceCatalog.GetResource <RedisSource>(GlobalConstants.ServerWorkspaceID, SourceId); if (RedisSource == null || RedisSource.ResourceType != enSourceType.RedisSource.ToString()) { _messages.Add(ErrorResource.RedisSourceHasBeenRemoved); return(_messages); } _redisCache = new RedisCacheImpl(RedisSource.HostName, Convert.ToInt32(RedisSource.Port), RedisSource.Password); if (CounterType == "Increment") { _result = _redisCache.Increment(Key, StepSize); Dev2Logger.Debug($"Cache {Key} Incremented {StepSize}: {_result}", GlobalConstants.WarewolfDebug); } else { _result = _redisCache.Decrement(Key, StepSize); Dev2Logger.Debug($"Cache {Key} Decremented {StepSize}: {_result}", GlobalConstants.WarewolfDebug); } return(new List <string> { _result.ToString() }); } catch (Exception ex) { Dev2Logger.Error(nameof(RedisCounterActivity), ex, GlobalConstants.WarewolfError); throw new Exception(ex.GetAllMessages()); } }
public void RedisCacheIntegration_CacheVariableResult_GetDebugInputs_With_DataListUtilIsEvaluated_ShouldReturnInnerActivityOutputs() { try { //----------------------Arrange---------------------- var key = "key" + Guid.NewGuid(); TestAnonymousAuth(out string hostName, out string password, out int port); var redisSource = new RedisSource { HostName = hostName, Password = password, Port = port.ToString() }; var isCalValue = GlobalConstants.CalculateTextConvertPrefix + "rec(*).name" + GlobalConstants.CalculateTextConvertSuffix; var innerActivity = new DsfMultiAssignActivity() { FieldsCollection = new List <ActivityDTO> { new ActivityDTO("[[objectId1]]", "ObjectName1", 1), new ActivityDTO("[[objectId2]]", "ObjectName2", 2), new ActivityDTO(isCalValue, "ObjectName3", 3) } }; GenerateMocks(key, redisSource, out Mock <IResourceCatalog> mockResourceCatalog, out Mock <IDSFDataObject> mockDataObject); CreateRedisActivity(key, hostName, port, password, mockResourceCatalog, out TestRedisActivity sut, innerActivity); //----------------------Act-------------------------- sut.TestExecuteTool(mockDataObject.Object); var debugInputs = sut.GetDebugOutputs(mockDataObject.Object.Environment, 0); //----------------------Assert----------------------- var actualInnerActivity = sut.ActivityFunc.Handler; Assert.AreEqual("Assign", actualInnerActivity.DisplayName); Assert.IsTrue(debugInputs is List <DebugItem>, "Debug inputs must return List<DebugItem>"); Assert.AreEqual(4, debugInputs.Count); Assert.AreEqual(1, debugInputs[0].ResultsList.Count); AssertDebugItems(debugInputs, 0, 0, "Redis key { " + sut.Key + " } not found", null, "", ""); AssertDebugItems(debugInputs, 1, 0, "1", null, "", ""); AssertDebugItems(debugInputs, 1, 1, null, "[[objectId1]]", "=", "ObjectName1"); AssertDebugItems(debugInputs, 2, 0, "1", null, "", ""); AssertDebugItems(debugInputs, 2, 1, null, "[[objectId2]]", "=", "ObjectName2"); AssertDebugItems(debugInputs, 3, 0, "1", null, "", ""); } catch (Exception e) { if (e.Message.Contains("could not connect to redis Instance")) { Assert.Inconclusive(e.Message); } else { throw; } } }
public void RedisSources_Test_With_InvalidHost__AuthenticationType_Anonymous_Expected_InvalidValidationResult() { var source = new RedisSource { HostName = "ddd:222", AuthenticationType = Dev2.Runtime.ServiceModel.Data.AuthenticationType.Anonymous, Port = "6379" }.ToString(); try { var handler = new RedisSources(); var result = handler.Test(source); Assert.IsFalse(result.IsValid); Assert.AreEqual("could not connect to redis Instance at ddd:222:6379\r\nNo such host is known", result.ErrorMessage); } catch (Exception e) { if (e.Message.Contains("could not connect to redis Instance")) { Assert.Inconclusive(e.Message); } else { throw; } } }
public void RedisSources_Test_With_ValidHost_AuthenticationType_Anonymous_Expected_ValidValidationResult() { try { var dependency = new Depends(Depends.ContainerType.AnonymousRedis); var source = new RedisSource { HostName = dependency.Container.IP, AuthenticationType = Dev2.Runtime.ServiceModel.Data.AuthenticationType.Anonymous, Port = dependency.Container.Port }.ToString(); var handler = new RedisSources(); var result = handler.Test(source); Assert.IsTrue(result.IsValid, result.ErrorMessage); } catch (Exception e) { if (e.Message.Contains("could not connect to redis Instance")) { Assert.Inconclusive(e.Message); } else { throw; } } }
public void RedisSources_TestWithValidArgs_Expected_Valid_ValidationResult() { var handler = new RedisSources(); var redisSource = new RedisSource(); var result = handler.Test(redisSource); Assert.IsFalse(result.IsValid); }
public void RedisCacheIntegration_CacheVariableResult_EvaluateVariableAsKey() { try { var key = "[[RedisKey]]"; var keyValue = "someval" + Guid.NewGuid(); TestAnonymousAuth(out string hostName, out string password, out int port); var redisSource = new RedisSource { HostName = hostName, Password = password, Port = port.ToString() }; var innerActivity = new DsfMultiAssignActivity() { FieldsCollection = new List <ActivityDTO> { new ActivityDTO("[[objectId1]]", "ObjectName1", 1), new ActivityDTO("[[objectId2]]", "ObjectName2", 2) } }; var mockResourceCatalog = new Mock <IResourceCatalog>(); var mockDataObject = new Mock <IDSFDataObject>(); var environment = new ExecutionEnvironment(); environment.Assign(key, keyValue, 0); var env = new Mock <IExecutionEnvironment>(); env.Setup(e => e.EvalToExpression(It.IsAny <string>(), It.IsAny <int>())).Returns(key); mockResourceCatalog.Setup(o => o.GetResource <RedisSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(redisSource); mockDataObject.Setup(o => o.IsDebugMode()).Returns(true); mockDataObject.Setup(o => o.Environment).Returns(environment); CreateRedisActivity(key, hostName, port, password, mockResourceCatalog, out TestRedisActivity sut, innerActivity); //----------------------Act-------------------------- sut.TestExecuteTool(mockDataObject.Object); var debugOutputs = sut.GetDebugOutputs(mockDataObject.Object.Environment, 0); //----------------------Assert----------------------- Assert.AreEqual(3, debugOutputs.Count); Assert.AreEqual(1, debugOutputs[0].ResultsList.Count); AssertDebugItems(debugOutputs, 0, 0, "Redis key { " + keyValue + " } not found", null, "", ""); AssertDebugItems(debugOutputs, 1, 0, "1", null, "", ""); AssertDebugItems(debugOutputs, 1, 1, null, "[[objectId1]]", "=", "ObjectName1"); AssertDebugItems(debugOutputs, 2, 0, "1", null, "", ""); AssertDebugItems(debugOutputs, 2, 1, null, "[[objectId2]]", "=", "ObjectName2"); } catch (Exception e) { if (e.Message.Contains("could not connect to redis Instance")) { Assert.Inconclusive(e.Message); } else { throw; } } }
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 RedisCacheDesignerViewModel_Constructor_ModelItemIsValid_Constructor() { //------------Setup for test-------------------------- var expectedId = Guid.NewGuid(); var redisSource = new RedisSource { ResourceID = expectedId, ResourceName = "ResourceName", HostName = "HostName", Port = "6379", AuthenticationType = Runtime.ServiceModel.Data.AuthenticationType.Anonymous }; var redisSources = new List <RedisSource> { redisSource }; var mockResourceRepository = new Mock <IResourceRepository>(); mockResourceRepository.Setup(resourceRepository => resourceRepository.FindSourcesByType <RedisSource>(It.IsAny <IServer>(), enSourceType.RedisSource)).Returns(redisSources); var mockServer = new Mock <IServer>(); mockServer.Setup(server => server.ResourceRepository).Returns(mockResourceRepository.Object); var mockShellViewModel = new Mock <IShellViewModel>(); //------------Execute Test--------------------------- var RedisCacheDesignerViewModel = new RedisCacheDesignerViewModel(CreateModelItem(), mockServer.Object, mockShellViewModel.Object); //------------Assert Results------------------------- Assert.IsTrue(RedisCacheDesignerViewModel.HasLargeView); Assert.IsTrue(RedisCacheDesignerViewModel.ShowLarge); Assert.AreEqual(string.Empty, RedisCacheDesignerViewModel.ActivityFuncDisplayName); Assert.IsNull(RedisCacheDesignerViewModel.ActivityFuncIcon); Assert.AreEqual(1, RedisCacheDesignerViewModel.RedisSources.Count); Assert.AreEqual(expectedId, RedisCacheDesignerViewModel.RedisSources[0].ResourceID); Assert.AreEqual("ResourceName", RedisCacheDesignerViewModel.RedisSources[0].ResourceName); Assert.AreEqual("HostName", RedisCacheDesignerViewModel.RedisSources[0].HostName); Assert.AreEqual("6379", RedisCacheDesignerViewModel.RedisSources[0].Port); Assert.AreEqual(Runtime.ServiceModel.Data.AuthenticationType.Anonymous, RedisCacheDesignerViewModel.RedisSources[0].AuthenticationType); Assert.AreEqual(null, RedisCacheDesignerViewModel.Key); Assert.IsNull(RedisCacheDesignerViewModel.SelectedRedisSource); Assert.IsFalse(RedisCacheDesignerViewModel.IsRedisSourceSelected); Assert.AreEqual(5, RedisCacheDesignerViewModel.TTL); Assert.IsFalse(RedisCacheDesignerViewModel.EditRedisSourceCommand.CanExecute(null)); Assert.IsFalse(RedisCacheDesignerViewModel.IsKeyFocused); Assert.IsFalse(RedisCacheDesignerViewModel.IsRedisSourceFocused); RedisCacheDesignerViewModel.SelectedRedisSource = redisSource; Assert.IsNotNull(RedisCacheDesignerViewModel.SelectedRedisSource); Assert.IsTrue(RedisCacheDesignerViewModel.IsRedisSourceSelected); Assert.AreEqual(redisSource.ResourceID, RedisCacheDesignerViewModel.SelectedRedisSource.ResourceID); Assert.IsTrue(RedisCacheDesignerViewModel.EditRedisSourceCommand.CanExecute(null)); mockResourceRepository.Verify(resourceRepository => resourceRepository.FindSourcesByType <RedisSource>(It.IsAny <IServer>(), enSourceType.RedisSource), Times.Once); }
public void RedisSource_Constructor_Validate_DefaultValues() { var redisSource = new RedisSource(); Assert.IsNotNull(redisSource.ResourceID); Assert.AreEqual(Guid.Empty, redisSource.ResourceID); Assert.AreEqual(nameof(RedisSource), redisSource.ResourceType); Assert.AreEqual("6379", redisSource.Port); Assert.AreEqual(AuthenticationType.Anonymous, redisSource.AuthenticationType); }
public void RedisActivity_GetDebugInputs_ShouldReturnInnerActivityOutputs() { //----------------------Arrange---------------------- try { //----------------------Arrange---------------------- TestAnonymousAuth(new Depends(Depends.ContainerType.AnonymousRedis), out string key, out string hostName, out string password, out int port); var redisSource = new RedisSource { HostName = hostName, Password = password, Port = port.ToString() }; var innerActivity = new DsfMultiAssignActivity() { FieldsCollection = new List <ActivityDTO> { new ActivityDTO("[[objectId1]]", "ObjectName1", 1), new ActivityDTO("[[objectId2]]", "ObjectName2", 2) } }; GenerateMocks(key, redisSource, out Mock <IResourceCatalog> mockResourceCatalog, out Mock <IDSFDataObject> mockDataObject); GenerateSUTInstance(key, hostName, port, password, mockResourceCatalog, out Dictionary <string, string> evel, out TestRedisActivity sut, innerActivity); //----------------------Act-------------------------- sut.TestExecuteTool(mockDataObject.Object); sut.TestPerformExecution(evel); var debugInputs = sut.GetDebugInputs(mockDataObject.Object.Environment, 0); //----------------------Assert----------------------- var actualInnerActivity = sut.ActivityFunc.Handler; Assert.AreEqual("Assign", actualInnerActivity.DisplayName); Assert.IsTrue(debugInputs is List <DebugItem>, "Debug inputs must return List<DebugItem>"); Assert.AreEqual(4, debugInputs.Count); Assert.AreEqual(1, debugInputs[0].ResultsList.Count); AssertDebugItems(debugInputs, 0, 0, "Key", null, "=", sut.Key); AssertDebugItems(debugInputs, 1, 0, "Redis key { " + sut.Key + " } not found", null, "", ""); AssertDebugItems(debugInputs, 2, 0, "1", null, "", ""); AssertDebugItems(debugInputs, 2, 1, null, "[[objectId1]]", "=", "ObjectName1"); AssertDebugItems(debugInputs, 3, 0, "2", null, "", ""); AssertDebugItems(debugInputs, 3, 1, null, "[[objectId2]]", "=", "ObjectName2"); } catch (Exception e) { if (e.Message.Contains("could not connect to redis Instance")) { Assert.Inconclusive(e.Message); } else { throw; } } }
public void RedisSource_Validate_DefaultValues() { var redisSource = new RedisSource(); Assert.IsTrue(redisSource.IsSource); Assert.IsFalse(redisSource.IsService); Assert.IsFalse(redisSource.IsFolder); Assert.IsFalse(redisSource.IsReservedService); Assert.IsFalse(redisSource.IsServer); Assert.IsFalse(redisSource.IsResourceVersion); }
public CartServiceController(bool mock = false) { if (mock) { cache = new CartOnRedisMock(); } else { cache = new CartOnRedis(Environment.GetEnvironmentVariable("cache_redis_server")); } }
public void RedisRemoveActivity_ExecuteTool_RedisSource_NotNull_ExpectException_As_ExecutionEnvironmentError() { var key = "key"; var sourceId = Guid.NewGuid(); var exceptionMessage = "test: if the resource is not found"; var env = new ExecutionEnvironment(); env.Assign("[[key]]", key, 0); var redisSource = new RedisSource { HostName = "localhost", Password = "", Port = "1234", }; var mockDataObject = new Mock <IDSFDataObject>(); mockDataObject.Setup(o => o.Environment) .Returns(env); var mockResourceCatalog = new Mock <IResourceCatalog>(); mockResourceCatalog.Setup(o => o.GetResource <Resource>(GlobalConstants.ServerWorkspaceID, sourceId)) .Throws(new Exception(exceptionMessage)); var mockRedisCache = new Mock <IRedisCache>(); mockRedisCache.Setup(o => o.Remove(key)) .Returns(true); var mockRedisConnection = new Mock <IRedisConnection>(); mockRedisConnection.Setup(o => o.Cache) .Returns(mockRedisCache.Object); var redisRemoveActivity = new RedisRemoveActivity(mockResourceCatalog.Object, new RedisCacheStub(() => mockRedisConnection.Object)) { Key = key, SourceId = sourceId }; redisRemoveActivity.Execute(mockDataObject.Object, 0); var builder = new StringBuilder(); builder.Append(GlobalConstants.InnerErrorTag); builder.Append(exceptionMessage); builder.Append(GlobalConstants.InnerErrorTagEnd); Assert.AreEqual(builder.ToString(), env.FetchErrors()); }
private static void GenerateMocks(string key, RedisSource redisSource, out Mock <IResourceCatalog> mockResourceCatalog, out Mock <IDSFDataObject> mockDataObject) { mockResourceCatalog = new Mock <IResourceCatalog>(); mockDataObject = new Mock <IDSFDataObject>(); var environment = new ExecutionEnvironment(); environment.Assign(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>()); environment.EvalToExpression(key, 0); mockResourceCatalog.Setup(o => o.GetResource <RedisSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(redisSource); mockDataObject.Setup(o => o.IsDebugMode()).Returns(true); mockDataObject.Setup(o => o.Environment).Returns(environment); }
public void RedisSources_Test_With_ValidHost_AuthenticationType_Anonymous_Expected_ValidValidationResult() { var source = new RedisSource { HostName = Depends.EnableDocker?Depends.RigOpsIP:Depends.SVRDEVIP, AuthenticationType = Dev2.Runtime.ServiceModel.Data.AuthenticationType.Anonymous, Port = "6380" }.ToString(); var handler = new RedisSources(); var result = handler.Test(source); Assert.IsTrue(result.IsValid, result.ErrorMessage); }
public ValidationResult Test(RedisSource source) { try { return(CanConnectServer(source)); } catch (Exception ex) { RaiseError(ex); return(new ValidationResult { IsValid = false, ErrorMessage = ex.Message }); } }
public void RedisActivity_GetDebugOutputs_ShouldReturnInnerActivityOutputs_TTLReached() { //----------------------Arrange---------------------- TestAnonymousAuth(out string key, out string hostName, out string password, out int port); var redisSource = new RedisSource { HostName = hostName, Password = password, Port = port.ToString() }; var innerActivity = new DsfMultiAssignActivity() { FieldsCollection = new List <ActivityDTO> { new ActivityDTO("[[objectId1]]", "ObjectName1", 1), new ActivityDTO("[[objectId2]]", "ObjectName2", 2) } }; GenerateMocks(key, redisSource, out Mock <IResourceCatalog> mockResourceCatalog, out Mock <IDSFDataObject> mockDataObject); GenerateSUTInstance(key, hostName, port, password, mockResourceCatalog, out Dictionary <string, string> evel, out TestRedisActivity sut, innerActivity); //----------------------Act-------------------------- sut.TestExecuteTool(mockDataObject.Object); sut.TestPerformExecution(evel); var timer = new Stopwatch(); timer.Start(); do { Thread.Sleep(1000); } while (timer.Elapsed < TimeSpan.FromMilliseconds(sut.TTL)); timer.Stop(); var debugOutputs = sut.GetDebugOutputs(mockDataObject.Object.Environment, 0); //----------------------Assert----------------------- var actualInnerActivity = sut.ActivityFunc.Handler; Assert.AreEqual("Assign", actualInnerActivity.DisplayName); Assert.IsTrue(debugOutputs is List <DebugItem>, "Debug inputs must return List<DebugItem>"); Assert.AreEqual(3, debugOutputs.Count); Assert.AreEqual(1, debugOutputs[0].ResultsList.Count); AssertDebugItems(debugOutputs, 0, 0, "Redis key { " + sut.Key + " } found", null, "", ""); AssertDebugItems(debugOutputs, 1, 0, "1", null, "", ""); AssertDebugItems(debugOutputs, 1, 1, null, "[[objectId1]]", "=", "ObjectName1"); AssertDebugItems(debugOutputs, 2, 0, "2", null, "", ""); AssertDebugItems(debugOutputs, 2, 1, null, "[[objectId2]]", "=", "ObjectName2"); }
private static RedisSource TestRedisSource(out string hostName, out string password, out int port) { var dependency = new Depends(Depends.ContainerType.AnonymousRedis, true); hostName = dependency.Container.IP; password = ""; port = int.Parse(dependency.Container.Port); var redisSource = new RedisSource { HostName = hostName, Password = password, Port = port.ToString() }; return(redisSource); }
public void RedisSources_Test_With_InvalidHost_AuthenticationType_Password_Expected_InvalidValidationResult() { var source = new RedisSource { HostName = "ddd", Port = "6380", AuthenticationType = Dev2.Runtime.ServiceModel.Data.AuthenticationType.Password, Password = "******" }.ToString(); var handler = new RedisSources(); var result = handler.Test(source); Assert.IsFalse(result.IsValid); Assert.AreEqual("could not connect to redis Instance at ddd:6380\r\nNo such host is known", result.ErrorMessage); }
public void RedisActivity_GetDebugInputs_With_DataListUtilIsEvaluated_ShouldReturnInnerActivityOutputs() { //----------------------Arrange---------------------- TestAnonymousAuth(out string key, out string hostName, out string password, out int port); var redisSource = new RedisSource { HostName = hostName, Password = password, Port = port.ToString() }; var isCalValue = GlobalConstants.CalculateTextConvertPrefix + "rec(*).name" + GlobalConstants.CalculateTextConvertSuffix; var innerActivity = new DsfMultiAssignActivity() { FieldsCollection = new List <ActivityDTO> { new ActivityDTO("[[objectId1]]", "ObjectName1", 1), new ActivityDTO("[[objectId2]]", "ObjectName2", 2), new ActivityDTO(isCalValue, "ObjectName3", 3) } }; GenerateMocks(key, redisSource, out Mock <IResourceCatalog> mockResourceCatalog, out Mock <IDSFDataObject> mockDataObject); GenerateSUTInstance(key, hostName, port, password, mockResourceCatalog, out Dictionary <string, string> evel, out TestRedisActivity sut, innerActivity); //----------------------Act-------------------------- sut.TestExecuteTool(mockDataObject.Object); sut.TestPerformExecution(evel); var debugInputs = sut.GetDebugInputs(mockDataObject.Object.Environment, 0); //----------------------Assert----------------------- var actualInnerActivity = sut.ActivityFunc.Handler; Assert.AreEqual("Assign", actualInnerActivity.DisplayName); Assert.IsTrue(debugInputs is List <DebugItem>, "Debug inputs must return List<DebugItem>"); Assert.AreEqual(5, debugInputs.Count); Assert.AreEqual(1, debugInputs[0].ResultsList.Count); AssertDebugItems(debugInputs, 0, 0, "Key", null, "=", sut.Key); AssertDebugItems(debugInputs, 1, 0, "Redis key { " + sut.Key + " } not found", null, "", ""); AssertDebugItems(debugInputs, 2, 0, "1", null, "", ""); AssertDebugItems(debugInputs, 2, 1, null, "[[objectId1]]", "=", "ObjectName1"); AssertDebugItems(debugInputs, 3, 0, "2", null, "", ""); AssertDebugItems(debugInputs, 3, 1, null, "[[objectId2]]", "=", "ObjectName2"); AssertDebugItems(debugInputs, 4, 0, "3", null, "", ""); AssertDebugItems(debugInputs, 4, 1, null, isCalValue, "=", isCalValue); }
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace) { var msg = new ExecuteMessage(); var serializer = new Dev2JsonSerializer(); try { Dev2Logger.Info("Save Redis Resource Service", GlobalConstants.WarewolfInfo); values.TryGetValue(Warewolf.Service.SaveRedisSource.RedisSource, out StringBuilder resourceDefinition); IRedisServiceSource redisSourceDef = serializer.Deserialize <RedisSourceDefinition>(resourceDefinition); if (redisSourceDef.Path == null) { redisSourceDef.Path = string.Empty; } if (redisSourceDef.Path.EndsWith("\\")) { redisSourceDef.Path = redisSourceDef.Path.Substring(0, redisSourceDef.Path.LastIndexOf("\\", StringComparison.Ordinal)); } var redisSource = new RedisSource { ResourceID = redisSourceDef.Id, HostName = redisSourceDef.HostName, Port = redisSourceDef.Port, AuthenticationType = redisSourceDef.AuthenticationType, Password = redisSourceDef.Password, ResourceName = redisSourceDef.Name }; ResourceCat.SaveResource(GlobalConstants.ServerWorkspaceID, redisSource, redisSourceDef.Path); msg.HasError = false; } catch (Exception err) { msg.HasError = true; msg.Message = new StringBuilder(err.Message); Dev2Logger.Error(err, GlobalConstants.WarewolfError); } return(serializer.SerializeToBuilder(msg)); }
public void RedisCacheDesignerViewModel_Constructor_ModelItemIsValid_EditRedisServerSource() { var expectedId = Guid.NewGuid(); var redisSource = new RedisSource { ResourceID = expectedId, ResourceName = "ResourceName", HostName = "HostName", Port = "6379", AuthenticationType = Runtime.ServiceModel.Data.AuthenticationType.Anonymous }; var redisSources = new List <RedisSource> { redisSource }; var environmentId = Guid.NewGuid(); var mockResourceRepository = new Mock <IResourceRepository>(); mockResourceRepository.Setup(resourceRepository => resourceRepository.FindSourcesByType <RedisSource>(It.IsAny <IServer>(), enSourceType.RedisSource)).Returns(redisSources); var mockServer = new Mock <IServer>(); mockServer.Setup(server => server.EnvironmentID).Returns(environmentId); mockServer.Setup(server => server.ResourceRepository).Returns(mockResourceRepository.Object); var mockShellViewModel = new Mock <IShellViewModel>(); mockShellViewModel.Setup(shellViewModel => shellViewModel.ActiveServer).Returns(mockServer.Object); mockShellViewModel.Setup(shellViewModel => shellViewModel.OpenResource(redisSource.ResourceID, environmentId, mockServer.Object)); CustomContainer.Register(mockShellViewModel.Object); //------------Execute Test--------------------------- var RedisCacheDesignerViewModel = new RedisCacheDesignerViewModel(CreateModelItem(), mockServer.Object, mockShellViewModel.Object) { SelectedRedisSource = redisSource }; RedisCacheDesignerViewModel.EditRedisSourceCommand.Execute(null); mockShellViewModel.Verify(shellViewModel => shellViewModel.OpenResource(expectedId, environmentId, mockServer.Object), Times.Once); mockResourceRepository.Verify(resourceRepository => resourceRepository.FindSourcesByType <RedisSource>(It.IsAny <IServer>(), enSourceType.RedisSource), Times.Exactly(2)); }
static ValidationResult CanConnectServer(RedisSource redisSource) { RedisClient clientAnon = null; try { if (redisSource.AuthenticationType == AuthenticationType.Anonymous) { clientAnon = new RedisClient(redisSource.HostName, int.Parse(redisSource.Port)); } else { clientAnon = new RedisClient(redisSource.HostName, int.Parse(redisSource.Port), redisSource.Password); } var isValid = false; var errorMessage = ""; if (clientAnon.ServerVersion != null) { isValid = true; } else { errorMessage = "No such host can be found."; } return(new ValidationResult { IsValid = isValid, ErrorMessage = errorMessage }); } catch (Exception e) { return(new ValidationResult { IsValid = false, ErrorMessage = e.InnerException != null?string.Join(Environment.NewLine, e.Message, e.InnerException.Message) : e.Message }); } finally { clientAnon?.Dispose(); } }
public RedisSource Get(string resourceId, Guid workspaceId) { var result = new RedisSource(); try { var xmlStr = ResourceCatalog.Instance.GetResourceContents(workspaceId, Guid.Parse(resourceId)).ToString(); if (!string.IsNullOrEmpty(xmlStr)) { var xml = XElement.Parse(xmlStr); result = new RedisSource(xml); } } catch (Exception ex) { RaiseError(ex); } return(result); }
public void RedisRemoveActivity_ExecuteTool_RedisSource_NotNull_ExpectSuccess() { var key = "key"; var sourceId = Guid.NewGuid(); var redisSource = new RedisSource { HostName = "localhost", Password = "", Port = "1234", }; var mockDataObject = new Mock <IDSFDataObject>(); mockDataObject.Setup(o => o.Environment) .Returns(new ExecutionEnvironment()); var mockResourceCatalog = new Mock <IResourceCatalog>(); mockResourceCatalog.Setup(o => o.GetResource <Resource>(GlobalConstants.ServerWorkspaceID, sourceId)) .Returns(redisSource); var mockRedisCache = new Mock <IRedisCache>(); mockRedisCache.Setup(o => o.Remove(key)) .Returns(true); var mockRedisConnection = new Mock <IRedisConnection>(); mockRedisConnection.Setup(o => o.Cache) .Returns(mockRedisCache.Object); var redisRemoveActivity = new RedisRemoveActivity(mockResourceCatalog.Object, new RedisCacheStub(() => mockRedisConnection.Object)) { Key = key, SourceId = sourceId }; redisRemoveActivity.Execute(mockDataObject.Object, 0); mockRedisCache.Verify(o => o.Remove(key), Times.Once); Assert.AreEqual("Success", redisRemoveActivity.Response); }
public void RedisRemoveDesignerViewModel_Constructor_ModelItemIsValid_UpdateHelpDescriptor() { var expectedHelpText = "redis help text"; var mockHelpViewModel = new Mock <IHelpWindowViewModel>(); mockHelpViewModel.Setup(helpViewModel => helpViewModel.UpdateHelpText(expectedHelpText)); var mockShellViewModel = new Mock <IShellViewModel>(); mockShellViewModel.Setup(shellViewModel => shellViewModel.HelpViewModel).Returns(mockHelpViewModel.Object); CustomContainer.Register(mockShellViewModel.Object); var expectedId = Guid.NewGuid(); var redisSource = new RedisSource { ResourceID = expectedId, ResourceName = "ResourceName", HostName = "HostName", Port = "6379", AuthenticationType = Runtime.ServiceModel.Data.AuthenticationType.Anonymous }; var redisSources = new List <RedisSource> { redisSource }; var mockResourceRepository = new Mock <IResourceRepository>(); mockResourceRepository.Setup(resourceRepository => resourceRepository.FindSourcesByType <RedisSource>(It.IsAny <IServer>(), enSourceType.RedisSource)).Returns(redisSources); var mockServer = new Mock <IServer>(); mockServer.Setup(server => server.ResourceRepository).Returns(mockResourceRepository.Object); //------------Execute Test--------------------------- var redisRemoveDesignerViewModel = new RedisRemoveDesignerViewModel(CreateModelItem(), mockServer.Object, mockShellViewModel.Object); Assert.AreEqual("Use the Redis Remove tool to remove existing key with data from cache.", redisRemoveDesignerViewModel.HelpText); redisRemoveDesignerViewModel.UpdateHelpDescriptor(expectedHelpText); mockHelpViewModel.Verify(helpViewModel => helpViewModel.UpdateHelpText(expectedHelpText), Times.Once); }
public void RedisCacheDesignerViewModel_ActivityFuncIcon() { var expectedId = Guid.NewGuid(); var redisSource = new RedisSource { ResourceID = expectedId, ResourceName = "ResourceName", HostName = "HostName", Port = "6379", AuthenticationType = Runtime.ServiceModel.Data.AuthenticationType.Anonymous }; var key = "redisKey"; var ttl = 30; var redisSources = new List <RedisSource> { redisSource }; var mockResourceRepository = new Mock <IResourceRepository>(); mockResourceRepository.Setup(resourceRepository => resourceRepository.FindSourcesByType <RedisSource>(It.IsAny <IServer>(), enSourceType.RedisSource)).Returns(redisSources); var mockServer = new Mock <IServer>(); mockServer.Setup(server => server.ResourceRepository).Returns(mockResourceRepository.Object); var mockShellViewModel = new Mock <IShellViewModel>(); var mockApplicationAdapter = new Mock <IApplicationAdaptor>(); mockApplicationAdapter.Setup(p => p.TryFindResource(It.IsAny <string>())).Verifiable(); CustomContainer.Register(mockApplicationAdapter.Object); //------------Execute Test--------------------------- var RedisCacheDesignerViewModel = new RedisCacheDesignerViewModel(CreateModelItem(key, ttl), mockServer.Object, mockShellViewModel.Object); //------------Assert Results------------------------- Assert.IsTrue(RedisCacheDesignerViewModel.HasLargeView); Assert.AreEqual("Assign", RedisCacheDesignerViewModel.ActivityFuncDisplayName); Assert.IsNull(RedisCacheDesignerViewModel.ActivityFuncIcon); }
public void RedisRemoveDesignerViewModel_Constructor_ResultNotNull() { var expectedId = Guid.NewGuid(); var redisSource = new RedisSource { ResourceID = expectedId, ResourceName = "ResourceName", HostName = "HostName", Port = "6379", AuthenticationType = Runtime.ServiceModel.Data.AuthenticationType.Anonymous }; var redisSources = new List <RedisSource> { redisSource }; var environmentId = Guid.NewGuid(); var mockResourceRepository = new Mock <IResourceRepository>(); mockResourceRepository.Setup(resourceRepository => resourceRepository.FindSourcesByType <RedisSource>(It.IsAny <IServer>(), enSourceType.RedisSource)).Returns(redisSources); var mockServer = new Mock <IServer>(); mockServer.Setup(server => server.EnvironmentID).Returns(environmentId); mockServer.Setup(server => server.ResourceRepository).Returns(mockResourceRepository.Object); var mockShellViewModel = new Mock <IShellViewModel>(); mockShellViewModel.Setup(shellViewModel => shellViewModel.ActiveServer).Returns(mockServer.Object); mockShellViewModel.Setup(shellViewModel => shellViewModel.NewRedisSource("")); CustomContainer.Register(mockShellViewModel.Object); //------------Execute Test--------------------------- var redisRemoveDesignerViewModel = new RedisRemoveDesignerViewModel(CreateModelItemWithResult(), mockServer.Object, mockShellViewModel.Object); Assert.AreEqual("someResult", redisRemoveDesignerViewModel.Result); }
public void RedisRemoveActivity_ExecuteTool_RedisSource_NotNull_ExpectRedisSourceHasBeenRemoved() { var key = "key"; var env = new ExecutionEnvironment(); var redisSource = new RedisSource { HostName = "localhost", Password = "", Port = "1234", }; var mockDataObject = new Mock <IDSFDataObject>(); mockDataObject.Setup(o => o.Environment) .Returns(env); var mockRedisCache = new Mock <IRedisCache>(); mockRedisCache.Setup(o => o.Remove(key)) .Returns(true); var mockRedisConnection = new Mock <IRedisConnection>(); mockRedisConnection.Setup(o => o.Cache) .Returns(mockRedisCache.Object); var redisRemoveActivity = new RedisRemoveActivity(new Mock <IResourceCatalog>().Object, new RedisCacheStub(() => mockRedisConnection.Object)) { Key = key, }; var result = redisRemoveActivity.Execute(mockDataObject.Object, 0); mockRedisCache.Verify(o => o.Remove(key), Times.Never); Assert.IsNull(redisRemoveActivity.Response); }