public void FindService_GivenServiceName_ShouldReturnsCorreclty_serviceID()
{
//---------------Set up test pack-------------------
var recCat = new Mock <IResourceCatalog>();
var newGuid = Guid.NewGuid();
var service = new DynamicService();
var serviceAction = new ServiceAction();
service.Actions = new List <ServiceAction> {
serviceAction
};
recCat.Setup(catalog => catalog.GetDynamicObjects <DynamicService>(Guid.Empty, newGuid)).Returns(new List <DynamicService> {
service
});
var locator = new ServiceLocator();
var privateObject = new Warewolf.Testing.PrivateObject(locator);
privateObject.SetField("_resourceCatalog", recCat.Object);
//---------------Assert Precondition----------------
Assert.IsNotNull(locator);
//---------------Execute Test ----------------------
try
{
var dynamicService = locator.FindService(newGuid, Guid.Empty);
recCat.Verify(catalog => catalog.GetDynamicObjects <DynamicService>(Guid.Empty, newGuid));
Assert.IsNotNull(dynamicService);
Assert.AreEqual(newGuid, serviceAction.ServiceID);
}
catch (Exception e)
{
//---------------Test Result -----------------------
Assert.Fail(e.Message);
}
}
public void GivenIDragComdllToolOntoTheDesignSurface()
{
var comDllActivity = new DsfComDllActivity();
comDllActivity.SourceId = new Guid("f9c016b6-9db4-4971-9634-60295bfc546f");
var dataObject = new Mock <IDSFDataObject>();
var channel = new Mock <IEsbChannel>();
var environment = new Mock <IExecutionEnvironment>();
var errors = new HashSet <string>();
environment.SetupGet(executionEnvironment => executionEnvironment.Errors).Returns(errors);
MockedEnvironmentErrors = new HashSet <string>();
environment.Setup(executionEnvironment => executionEnvironment.AddError(It.IsAny <string>())).Callback <string>(error => { MockedEnvironmentErrors.Add(error); });
dataObject.Setup(dObj => dObj.Environment).Returns(environment.Object);
dataObject.Setup(dObj => dObj.EsbChannel).Returns(channel.Object);
dataObject.SetupGet(dObj => dObj.WorkspaceID).Returns(Guid.NewGuid);
var modelItem = ModelItemUtils.CreateModelItem(comDllActivity);
var pluginServiceModel = new Mock <IComPluginServiceModel>();
var plugInSources = new Mock <ObservableCollection <IComPluginSource> >();
pluginServiceModel.Setup(serviceModel => serviceModel.RetrieveSources())
.Returns(plugInSources.Object);
var viewModel = new ComDllViewModel(modelItem, pluginServiceModel.Object);
var privateObject = new Warewolf.Testing.PrivateObject(comDllActivity);
_scenarioContext.Add("ViewModel", viewModel);
_scenarioContext.Add("DataObject", dataObject.Object);
_scenarioContext.Add("Channel", channel);
_scenarioContext.Add("Environment", environment.Object);
_scenarioContext.Add("Model", pluginServiceModel);
_scenarioContext.Add("Activity", comDllActivity);
_scenarioContext.Add("PrivateObj", privateObject);
_scenarioContext.Add("PlugInSources", plugInSources);
}
public void FindService_GivenServiceID_InCache_ShouldReturnFromCache()
{
//---------------Set up test pack-------------------
var recCat = new Mock <IResourceCatalog>();
var res = new Mock <IResource>();
var resourceId = Guid.NewGuid();
res.Setup(resource => resource.ResourceID).Returns(resourceId);
recCat.Setup(catalog => catalog.GetDynamicObjects <DynamicService>(Guid.Empty, resourceId)).Returns(new List <DynamicService>()
{
new DynamicService()
});
ServiceActionRepo.Instance.AddToCache(resourceId, new DynamicService());
var locator = new ServiceLocator();
var privateObject = new Warewolf.Testing.PrivateObject(locator);
privateObject.SetField("_resourceCatalog", recCat.Object);
//---------------Assert Precondition----------------
Assert.IsNotNull(locator);
//---------------Execute Test ----------------------
try
{
var dynamicService = locator.FindService(resourceId, Guid.Empty);
recCat.Verify(catalog => catalog.GetDynamicObjects <DynamicService>(Guid.Empty, resourceId), Times.Never());
Assert.IsNotNull(dynamicService);
}
catch (Exception e)
{
//---------------Test Result -----------------------
Assert.Fail(e.Message);
}
}
void ValidateInstance(out Warewolf.Testing.PrivateObject privateObj, out List <IWarewolfIterator> variablesToIterateOn)
{
Assert.IsNotNull(_warewolfListIterator);
privateObj = new Warewolf.Testing.PrivateObject(_warewolfListIterator);
variablesToIterateOn = privateObj.GetField("_variablesToIterateOn") as List <IWarewolfIterator>;
Assert.IsNotNull(variablesToIterateOn);
}
public void SharepointFileUploadActivity_ValidateRequest_SharepointServerResourceId_EmptyGuid()
{
//------------Setup for test--------------------------
const string activityName = "SharepointMoveFile";
var sharepointMoveFileActivity = new SharepointMoveFileActivity
{
DisplayName = activityName,
Result = "[[Files(*).Name]]",
ServerInputPathFrom = @"C:\ProgramData\Warewolf\Resources\Hello World.bite"
};
var dataObj = new DsfDataObject(It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <string>());
var resourceCatalog = new Mock <IResourceCatalog>();
var mockSharepointSource = new Mock <SharepointSource>();
resourceCatalog.Setup(r => r.GetResource <SharepointSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(mockSharepointSource.Object);
var privateObject = new Warewolf.Testing.PrivateObject(sharepointMoveFileActivity);
privateObject.SetProperty("ResourceCatalog", resourceCatalog.Object);
sharepointMoveFileActivity.SharepointSource = mockSharepointSource.Object;
try
{
//------------Execute Test---------------------------
privateObject.Invoke("ValidateRequest");
}
catch (TargetInvocationException e)
{
//------------Assert Results-------------------------
Assert.AreEqual("Please select valid source\r\nParameter name: 00000000-0000-0000-0000-000000000000", e.InnerException?.Message, "Expected exception was not thrown.");
}
}
public void SharepointFileUploadActivity_ValidateRequest_ServerInputPath_IsEmpty()
{
//------------Setup for test--------------------------
const string activityName = "SharepointMoveFile";
var resourceId = Guid.NewGuid();
var sharepointMoveFileActivity = new SharepointMoveFileActivity
{
DisplayName = activityName,
SharepointServerResourceId = resourceId,
Result = "[[Files(*).Name]]"
};
var dataObj = new DsfDataObject(It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <string>());
var resourceCatalog = new Mock <IResourceCatalog>();
var mockSharepointSource = new Mock <SharepointSource>();
resourceCatalog.Setup(r => r.GetResource <SharepointSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(mockSharepointSource.Object);
var privateObject = new Warewolf.Testing.PrivateObject(sharepointMoveFileActivity);
privateObject.SetProperty("ResourceCatalog", resourceCatalog.Object);
sharepointMoveFileActivity.SharepointSource = mockSharepointSource.Object;
try
{
//------------Execute Test---------------------------
privateObject.Invoke("ValidateRequest");
}
catch (TargetInvocationException e)
{
//------------Assert Results-------------------------
Assert.AreEqual("Server input path FROM is not set", e.InnerException?.Message, "Expected exception was not thrown.");
}
}
public void WarewolfListIterator_GetOrdinal_ShouldReturn0()
{
var names = new List <string> {
Result
};
Assert.IsNotNull(_warewolfListIterator);
var privateObj = new Warewolf.Testing.PrivateObject(_warewolfListIterator);
var variablesToIterateOn = privateObj.GetField("_variablesToIterateOn") as List <IWarewolfIterator>;
Assert.IsNotNull(variablesToIterateOn);
var listIterator = _warewolfListIterator as WarewolfListIterator;
if (listIterator == null)
{
return;
}
listIterator.Names = names;
listIterator.Types = variablesToIterateOn.Select(iterator => iterator.GetType()).ToList();
var ordinal = listIterator.GetOrdinal(Result);
Assert.AreEqual(0, ordinal);
Assert.IsNotNull(listIterator.Types);
}
public void WarewolfListIterator_Object_GetValues()
{
//------------Setup for test--------------------------
_expr3 = new WarewolfIterator(_environment.Eval("[[RecSet()]]", 0));
var privateObj = new Warewolf.Testing.PrivateObject(_warewolfListIterator);
var variablesToIterateOn = privateObj.GetField("_variablesToIterateOn") as List <IWarewolfIterator>;
_warewolfListIterator.AddVariableToIterateOn(_expr3);
var listIterator = _warewolfListIterator as WarewolfListIterator;
listIterator.Types = variablesToIterateOn.Select(iterator => iterator.GetType()).ToList();
int integerPrimitive = 2;
float floatPrimitive = 1.23f;
Object[] objects = new Object[] {
integerPrimitive,
floatPrimitive
};
//------------Execute Test---------------------------
var val = listIterator.GetValues(objects);
//------------Assert Results-------------------------
Assert.AreEqual(2, val);
}
public void GivenHasAScheduleOf(string scheduleName, Table table)
{
AppUsageStats.LocalHost = "http://localhost:3142";
var mockServer = new Mock <IServer>();
var mockshell = new Mock <IShellViewModel>();
mockshell.Setup(a => a.ActiveServer).Returns(mockServer.Object);
mockshell.Setup(a => a.LocalhostServer).Returns(mockServer.Object);
mockServer.Setup(a => a.GetServerVersion()).Returns("1.0.0.0");
CustomContainer.Register(mockServer.Object);
CustomContainer.Register(mockshell.Object);
var mockPopupController = new Mock <IPopupController>();
mockPopupController.Setup(controller => controller.ShowDeleteConfirmation(It.IsAny <string>())).Returns(MessageBoxResult.Yes);
var serverRepository = ServerRepository.Instance;
var server = serverRepository.Source;
CustomContainer.Register(serverRepository);
var scheduler = new SchedulerViewModel(EventPublishers.Aggregator, new DirectoryObjectPickerDialog(), mockPopupController.Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new Mock <IServer>().Object, a => new Mock <IServer>().Object);
var resourceId = table.Rows[0]["ResourceId"];
server.Connect();
scheduler.ScheduledResourceModel = new ClientScheduledResourceModel(server, () => { });
scheduler.CurrentEnvironment = server;
scheduler.CreateNewTask();
scheduler.SelectedTask.Name = _scenarioContext["ScheduleName"].ToString();
scheduler.SelectedTask.OldName = "bob";
scheduler.SelectedTask.UserName = _scenarioContext["UserName"].ToString();
scheduler.SelectedTask.Password = _scenarioContext["Password"].ToString();
scheduler.SelectedTask.WorkflowName = _scenarioContext["WorkFlow"].ToString();
scheduler.SelectedTask.ResourceId = string.IsNullOrEmpty(resourceId) ? new Guid("acb75027-ddeb-47d7-814e-a54c37247ec1") : new Guid(resourceId);
scheduler.SelectedTask.NumberOfHistoryToKeep = (int)_scenarioContext["HistoryCount"];
scheduler.SelectedTask.Status = (SchedulerStatus)_scenarioContext["TaskStatus"];
scheduler.Errors.ClearErrors();
var task = scheduler.SelectedTask;
UpdateTrigger(task, table);
var po = new Warewolf.Testing.PrivateObject(scheduler.CurrentEnvironment);
var mockAuth = new Mock <IAuthorizationService>();
mockAuth.Setup(a => a.IsAuthorized(It.IsAny <AuthorizationContext>(), null)).Returns(true);
po.SetFieldOrProperty("AuthorizationService", mockAuth.Object);
_scenarioContext["Scheduler"] = scheduler;
try
{
scheduler.SaveCommand.Execute("");
if (scheduler.HasErrors)
{
_scenarioContext["Error"] = scheduler.Error;
Console.WriteLine("Error creating schedule: " + scheduler.Error);
}
}
catch (Exception e)
{
_scenarioContext["Error"] = e.Message;
Console.WriteLine("Error creating schedule: " + e.Message);
}
}
public void ServerProxy_NoFallbackOnConnectIfNormalException()
{
//------------Setup for test--------------------------
var serverProxy = new ServerProxy(new Uri("http://bob"));
var serverGuid = Guid.NewGuid();
var p = new Warewolf.Testing.PrivateObject(serverProxy);
var wrapped = new Mock <IEnvironmentConnection>();
var fallback = new Mock <IEnvironmentConnection>();
wrapped.Setup(a => a.Connect(It.IsAny <Guid>())).Throws(new Exception());
p.SetField("_wrappedConnection", wrapped.Object);
try
{
serverProxy.Connect(serverGuid);
}
catch
{
// ignored
}
var con = p.GetField("_wrappedConnection");
Assert.IsNotNull(con);
}
public void FindSourceByName_GivenServiceName_ShouldReturnsCorreclty_serviceID()
{
//---------------Set up test pack-------------------
var recCat = new Mock <IResourceCatalog>();
const string resourceName = "SourceName";
recCat.Setup(catalog => catalog.GetDynamicObjects <Source>(Guid.Empty, resourceName)).Returns(new List <Source>()
{
new Source()
});
var locator = new ServiceLocator();
var privateObject = new Warewolf.Testing.PrivateObject(locator);
privateObject.SetField("_resourceCatalog", recCat.Object);
//---------------Assert Precondition----------------
Assert.IsNotNull(locator);
//---------------Execute Test ----------------------
try
{
var dynamicService = locator.FindSourceByName(resourceName, Guid.Empty);
recCat.Verify(catalog => catalog.GetDynamicObjects <Source>(Guid.Empty, resourceName));
Assert.IsNotNull(dynamicService);
}
catch (Exception e)
{
//---------------Test Result -----------------------
Assert.Fail(e.Message);
}
}
public void FindService_GivenServiceName_ReturnsNull_ShouldUpdatePerfCounter()
{
//---------------Set up test pack-------------------
var mockWarewolfPerformanceCounterLocater = new Mock <IWarewolfPerformanceCounterLocater>();
var mockPerformanceCounter = new Mock <IPerformanceCounter>();
mockPerformanceCounter.Setup(counter => counter.Increment()).Verifiable();
mockWarewolfPerformanceCounterLocater.Setup(locater => locater.GetCounter(It.IsAny <string>())).Returns(mockPerformanceCounter.Object);
CustomContainer.Register(mockWarewolfPerformanceCounterLocater.Object);
var recCat = new Mock <IResourceCatalog>();
recCat.Setup(catalog => catalog.GetDynamicObjects <DynamicService>(Guid.Empty, "service")).Returns(new List <DynamicService> {
null
});
var locator = new ServiceLocator();
var privateObject = new Warewolf.Testing.PrivateObject(locator);
privateObject.SetField("_resourceCatalog", recCat.Object);
//---------------Assert Precondition----------------
Assert.IsNotNull(locator);
//---------------Execute Test ----------------------
var dynamicService = locator.FindService("service", Guid.Empty);
recCat.Verify(catalog => catalog.GetDynamicObjects <DynamicService>(Guid.Empty, "service"));
mockPerformanceCounter.Verify(counter => counter.Increment());
Assert.IsNull(dynamicService);
}
public void DsfPublishRabbitMQActivity_Execute_Failure_NullException()
{
//------------Setup for test--------------------------
var dsfPublishRabbitMQActivity = new DsfPublishRabbitMQActivity();
var resourceCatalog = new Mock <IResourceCatalog>();
var rabbitMQSource = new Mock <RabbitMQSource>();
var connectionFactory = new Mock <ConnectionFactory>();
resourceCatalog.Setup(r => r.GetResource <RabbitMQSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(rabbitMQSource.Object);
connectionFactory.Setup(c => c.CreateConnection()).Returns <IConnection>(null);
var p = new Warewolf.Testing.PrivateObject(dsfPublishRabbitMQActivity);
p.SetProperty("ConnectionFactory", connectionFactory.Object);
dsfPublishRabbitMQActivity.ResourceCatalog = resourceCatalog.Object;
try
{
//------------Execute Test---------------------------
_ = p.Invoke("PerformExecution", new Dictionary <string, string> {
{ "QueueName", "Q1" }, { "Message", "Test message" }
});
}
catch (TargetInvocationException e)
{
//------------Assert Results-------------------------
Assert.AreEqual("Object reference not set to an instance of an object.", e.InnerException?.Message, "Incorrect exception thrown.");
}
}
public void PerfcounterViewModel_ServerCountersCompare_Given_Null_Server_Counters_Returns_False()
{
CommonSetupHelper.RegisterServerRepository();
var authorizationService = new Mock <IAuthorizationService>();
var securityService = new Mock <ISecurityService>();
var permissions = new List <WindowsGroupPermission> {
new WindowsGroupPermission()
};
securityService.Setup(service => service.Permissions).Returns(permissions);
authorizationService.Setup(service => service.SecurityService).Returns(securityService.Object);
_mockConnection.Setup(connection => connection.IsConnected).Returns(true);
_mockConnection.Setup(connection => connection.DisplayName).Returns("TestServer");
_mockEnvironment.Setup(model => model.AuthorizationService).Returns(authorizationService.Object);
var activeServer = new Server(Guid.NewGuid(), _mockConnection.Object);
ServerRepository.Instance.ActiveServer = activeServer;
CustomContainer.Register <IExplorerTooltips>(new ExplorerTooltips());
var mockPerformanceCounters = new Mock <IPerformanceCounterTo>();
mockPerformanceCounters.Setup(counter => counter.NativeCounters).Returns(new List <IPerformanceCounter>());
mockPerformanceCounters.Setup(counter => counter.ResourceCounters).Returns(new List <IResourcePerformanceCounter>());
var privateCounters = new PerfcounterViewModel(mockPerformanceCounters.Object, new Mock <IServer>().Object);
var counters = new Warewolf.Testing.PrivateObject(privateCounters);
CustomContainer.Register(new Mock <IExplorerTooltips>().Object);
//------------Setup for test------------------------
//------------Execute Test--------------------------
var invokeStatic = counters.Invoke("GetEnvironment", true);
//------------Assert Results-------------------------
Assert.IsNotNull(invokeStatic);
}
public void SharepointSource_DoesNotExist_OnResourceCatalog_ShouldSetSharepointSource_ToGuidEmpty()
{
//------------Setup for test--------------------------
const string activityName = "SharepointMoveFile";
var resourceId = Guid.NewGuid();
var sharepointMoveFileActivity = new SharepointMoveFileActivity
{
DisplayName = activityName,
SharepointServerResourceId = resourceId,
Result = "[[Move]]",
ServerInputPathFrom = @"C:\ProgramData\Warewolf\Resources\Hello World.bite",
ServerInputPathTo = "Hello World.bite",
Overwrite = true
};
var dataObj = new DsfDataObject(It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <string>());
var resourceCatalog = new Mock <IResourceCatalog>();
var mockSharepointSource = new Mock <SharepointSource>();
var privateObject = new Warewolf.Testing.PrivateObject(sharepointMoveFileActivity);
privateObject.SetProperty("ResourceCatalog", resourceCatalog.Object);
sharepointMoveFileActivity.SharepointSource = mockSharepointSource.Object;
Assert.AreEqual(resourceId, sharepointMoveFileActivity.SharepointServerResourceId);
//------------Execute Test---------------------------
privateObject.Invoke("ExecuteTool", dataObj, 0);
Assert.AreEqual(Guid.Empty, sharepointMoveFileActivity.SharepointServerResourceId);
}
public static DataStorage.WarewolfEnvironment CreateEnvironmentWithData()
{
var env = new ExecutionEnvironment();
env.Assign("[[Rec(1).a]]", "1", 0);
env.Assign("[[Rec(2).a]]", "2", 0);
env.Assign("[[Rec(3).a]]", "3", 0);
env.Assign("[[Rec(4).a]]", "2", 0);
env.Assign("[[Rec(1).b]]", "a", 0);
env.Assign("[[Rec(2).b]]", "b", 0);
env.Assign("[[Rec(3).b]]", "c", 0);
env.Assign("[[Rec(4).b]]", "c", 0);
env.Assign("[[x]]", "1", 0);
env.Assign("[[y]]", "y", 0);
env.AssignJson(new AssignValue("[[@Person.Name]]", "bob"), 0);
env.AssignJson(new AssignValue("[[@Person.Age]]", "22"), 0);
env.AssignJson(new AssignValue("[[@Person.Spouse.Name]]", "dora"), 0);
env.AssignJson(new AssignValue("[[@Person.Children(1).Name]]", "Mary"), 0);
env.AssignJson(new AssignValue("[[@Person.Children(2).Name]]", "Jane"), 0);
env.AssignJson(new AssignValue("[[@Person.Score(1)]]", "2"), 0);
env.AssignJson(new AssignValue("[[@Person.Score(2)]]", "3"), 0);
env.AssignJson(new AssignValue("[[array(1)]]", "bob"), 0);
env.AssignJson(new AssignValue("[[arrayObj(1).Name]]", "bob"), 0);
env.AssignJson(new AssignValue("[[arrayObj(2).Name]]", "bobe"), 0);
var p = new Warewolf.Testing.PrivateObject(env);
return((DataStorage.WarewolfEnvironment)p.GetFieldOrProperty("_env"));
}
public void SharepointCopyFileActivity_ValidateRequest_ServerInputPathTo_IsEmpty_Expect_Exception()
{
//------------Setup for test--------------------------
const string activityName = "SharepointCopyFile";
var resourceCatalog = new Mock <IResourceCatalog>();
var mockSharepointSource = new Mock <SharepointSource>();
var resourceId = Guid.NewGuid();
var sharepointCopyFileActivity = new SharepointCopyFileActivity
{
DisplayName = activityName,
SharepointServerResourceId = resourceId,
Result = "[[Files(*).Name]]",
ServerInputPathFrom = @"C:\ProgramData\Warewolf\Resources\Hello World.bite",
Overwrite = true,
};
var privateObject = new Warewolf.Testing.PrivateObject(sharepointCopyFileActivity);
resourceCatalog.Setup(r => r.GetResource <SharepointSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(mockSharepointSource.Object);
sharepointCopyFileActivity.ResourceCatalog = resourceCatalog.Object;
sharepointCopyFileActivity.SharepointSource = mockSharepointSource.Object;
try
{
//------------Execute Test---------------------------
privateObject.Invoke("ValidateRequest");
}
catch (TargetInvocationException e)
{
//------------Assert Result--------------------------
Assert.AreEqual("Server input path TO is not set", e.InnerException?.Message, "Expected exception was not thrown.");
}
}
public void SharepointSource_DoesNotExist_OnResourceCatalog_ShouldSetSharepointSource_ToGuidEmpty()
{
//------------Setup for test--------------------------
const string activityName = "SharepointUpdateListItem";
var resourceId = Guid.NewGuid();
var sharepointUpdateListItemActivity = new SharepointUpdateListItemActivity
{
DisplayName = activityName,
SharepointServerResourceId = resourceId,
ReadListItems = new List <SharepointReadListTo>(),
FilterCriteria = new List <SharepointSearchTo>(),
RequireAllCriteriaToMatch = true
};
var dataObj = new DsfDataObject(It.IsAny <string>(), It.IsAny <Guid>(), It.IsAny <string>());
var resourceCatalog = new Mock <IResourceCatalog>();
var mockSharepointSource = new Mock <SharepointSource>();
var privateObject = new Warewolf.Testing.PrivateObject(sharepointUpdateListItemActivity);
privateObject.SetProperty("ResourceCatalog", resourceCatalog.Object);
//------------Execute Test---------------------------
privateObject.Invoke("ExecuteTool", dataObj, 0);
Assert.AreEqual(resourceId, sharepointUpdateListItemActivity.SharepointServerResourceId);
}
public void Debug_GivenDataObject_ShouldSetInnerBugOuputs_IncrementsDebugInputs()
{
//---------------Set up test pack-------------------
//string displayName, IDebugDispatcher debugDispatcher, bool isAsync = false
var switchActivity = new DsfFlowSwitchActivity("MyName", new Mock <IDebugDispatcher>().Object, It.IsAny <bool>())
{
UniqueID = Guid.NewGuid().ToString(),
ExpressionText = ""
};
var activity = new DsfSwitch(switchActivity)
{
Result = "[[MyResult]]"
};
var dataObject = new Mock <IDSFDataObject>();
dataObject.Setup(o => o.IsDebugMode()).Returns(true);
var obj = new Warewolf.Testing.PrivateObject(activity);
//---------------Assert Precondition----------------
var getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(0, getDebugInputs.Count);
//---------------Execute Test ----------------------
var result = "[[variable]]";
var mySwitch = new Dev2Switch();
obj.Invoke("Debug", dataObject.Object, result, mySwitch);
//---------------Test Result -----------------------
getDebugInputs = activity.GetDebugInputs(new Mock <IExecutionEnvironment>().Object, 1);
Assert.AreEqual(1, getDebugInputs.Count);
}
public void DsfDotNetMultiAssignActivity_RecordSetTypeEnsureLastErrorNoDuplicate()
{
var env = new ExecutionEnvironment();
env.AllErrors.Add("val1");
env.Assign("[[Errors().Message]]", "val1", 0);
var data = new Mock <IDSFDataObject>();
data.Setup(o => o.Environment).Returns(() => env);
data.Setup(o => o.IsDebugMode()).Returns(() => true);
var ob = new DsfDotNetMultiAssignActivity
{
FieldsCollection = new List <ActivityDTO>
{
new ActivityDTO("[[test]]", "testing123", 0)
},
OnErrorVariable = "[[Errors().Message]]"
};
ob.Execute(data.Object, 0);
var privateObject = new Warewolf.Testing.PrivateObject(env);
var warewolfEnvironment = privateObject.GetField("_env") as DataStorage.WarewolfEnvironment;
Assert.AreEqual(1, warewolfEnvironment?.RecordSets["Errors"].Data["Message"].Count);
}
public void PublicFunctions_EvalEnv_ShouldReturn1()
{
//------------Setup for test--------------------------
var e = new ExecutionEnvironment();
var p = new Warewolf.Testing.PrivateObject(e);
var env = (DataStorage.WarewolfEnvironment)p.GetFieldOrProperty("_env");
//------------Execute Test---------------------------
var res = PublicFunctions.EvalEnv(env);
var sb = new StringBuilder();
foreach (var s in res)
{
sb.Append(s);
}
var expected = "{\"scalars\":{}," +
"\"record_sets\":{}," +
"\"json_objects\":{}}";
var actual = sb.ToString();
Assert.AreEqual(expected, actual);
var jsonOb = JsonConvert.DeserializeObject(actual);
Assert.IsNotNull(jsonOb);
}
static DataStorage.WarewolfEnvironment CreateEmptyEnvironment()
{
var env = new ExecutionEnvironment();
var p = new Warewolf.Testing.PrivateObject(env);
return((DataStorage.WarewolfEnvironment)p.GetFieldOrProperty("_env"));
}
public void Dev2StudioSessionBroker_InitSessionWithNoDataBaseDirectoryIsNullStillInitialises()
{
var serviceName = "DummyService" + Guid.NewGuid();
var to = new DebugTO();
var rootFolder = Path.GetTempPath() + Guid.NewGuid();
var broker = Dev2StudioSessionFactory.CreateBroker();
to.RememberInputs = true;
to.BaseSaveDirectory = null;
to.DataList = "<DataList><scalar1/><rs><f1/><f2/></rs></DataList>";
to.XmlData = "<DataList><scalar1>s1</scalar1><rs><f1/>f1Value<f2/>f2Value</rs></DataList>";
to.ServiceName = serviceName;
to.WorkflowID = serviceName;
broker.InitDebugSession(to);
to = broker.PersistDebugSession(to);
to.BaseSaveDirectory = null;
var p = new Warewolf.Testing.PrivateObject(broker);
var field = p.GetField("_debugPersistSettings") as IDictionary <string, DebugTO>;
Assert.IsNotNull(field);
field.Add("bob", new DebugTO());
to = broker.PersistDebugSession(to);
Assert.AreEqual(string.Empty, to.Error);
Assert.IsNotNull(to.BinaryDataList);
DeleteDir(rootFolder);
}
public void GenerateRequestDictionaryFromDataObject_GivenValidArgs_ShouldClearArgsAndErros()
{
const string datalist = "<DataList><scalar1 ColumnIODirection=\"Input\"/><persistantscalar ColumnIODirection=\"Input\"/><rs><f1 ColumnIODirection=\"Input\"/><f2 ColumnIODirection=\"Input\"/></rs><recset><field1/><field2/></recset></DataList>";
var serviceAction = new ServiceAction()
{
DataListSpecification = new StringBuilder(datalist)
};
var dsfObj = new Mock <IDSFDataObject>();
dsfObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment());
dsfObj.Setup(o => o.Environment.Eval(It.IsAny <string>(), It.IsAny <int>()))
.Returns(CommonFunctions.WarewolfEvalResult.NewWarewolfAtomResult(DataStorage.WarewolfAtom.NewDataString("Args")));
var workSpace = new Mock <IWorkspace>();
var channel = new Mock <IEsbChannel>();
var esbExecuteRequest = new EsbExecuteRequest();
var internalServiceContainer = new InternalServiceContainer(serviceAction, dsfObj.Object, workSpace.Object, channel.Object, esbExecuteRequest);
var privateObject = new Warewolf.Testing.PrivateObject(internalServiceContainer);
//---------------Assert Precondition----------------
Assert.AreEqual(4, esbExecuteRequest.Args.Count);
//---------------Execute Test ----------------------
var errorResultTO = new ErrorResultTO();
privateObject.Invoke("GenerateRequestDictionaryFromDataObject", errorResultTO);
//---------------Test Result -----------------------
Assert.AreEqual(0, esbExecuteRequest.Args.Count);
}
public void WfApplicationUtils_GetVariableName_GetDebugValues_Value_IsJsonArrayAndRecordSetName_NotNull_ShouldAddRecNotationToValues()
{
//---------------Set up test pack-------------------
var mockDSFDataObject = new Mock <IDSFDataObject>();
var wfApplicationUtils = new WfApplicationUtils();
IList <IDev2Definition> definitions = new List <IDev2Definition>
{
new Dev2Definition("@rec(*).Name1", "rec().Map1", "value", false, "defaultValue", false, "rawValue")
{
IsJsonArray = false,
RecordSetName = "some recordSet"
}
};
var errorResultTO = new ErrorResultTO();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var privateObject = new Warewolf.Testing.PrivateObject(wfApplicationUtils);
var debugItems = privateObject.Invoke("GetDebugValues", definitions, mockDSFDataObject.Object, errorResultTO) as List <DebugItem>;
//---------------Test Result -----------------------
Assert.IsNotNull(debugItems);
Assert.AreEqual(1, debugItems.Count);
var count = debugItems.Count(item => item.ResultsList.Count(result => result.Variable == "[[some recordSet(*).@rec(*).Name1]]") == 1);
Assert.AreEqual(1, count);
}
public void DateTimeDesignerViewModel_ShouldSetOutputFormat_WhenNoInputFormat()
{
var modelItem = CreateModelItem();
var viewModel = new Dev2.Activities.Designers2.DateTimStandard.DateTimeDesignerViewModel(modelItem);
var expectedDefaultFormat = GlobalConstants.Dev2DotNetDefaultDateTimeFormat;
var po = new Warewolf.Testing.PrivateObject(viewModel);
Assert.AreEqual(expectedDefaultFormat, po.GetProperty("OutputFormat"));
}
public void WfApplicationUtils_DispatchDebugState_GivenValidParamsAndIntergoateOutputs_ShouldWriteUsingDebugDispactcher_GetResourceForDatalist()
{
//---------------Set up test pack-------------------
var catLog = new Mock <IResourceCatalog>();
catLog.Setup(catalog => catalog.GetResource(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(new Resource
{
DataList = new StringBuilder()
});
IResource dropBoxSource = new DropBoxSource
{
AppKey = "Key",
AccessToken = "token",
DataList = new StringBuilder("<DataList></DataList>")
};
catLog.Setup(catalog => catalog.GetResource(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(dropBoxSource);
var wfApplicationUtils = new WfApplicationUtils();
var envMock = new Mock <IExecutionEnvironment>();
var debugDispatcher = new Mock <IDebugDispatcher>();
var debugState = new DebugState {
StateType = StateType.Start
};
debugDispatcher.Setup(dispatcher => dispatcher.Write(new WriteArgs {
debugState = debugState, isTestExecution = It.IsAny <bool>(), isDebugFromWeb = It.IsAny <bool>(), testName = It.IsAny <string>(), isRemoteInvoke = It.IsAny <bool>(), remoteInvokerId = It.IsAny <string>(), parentInstanceId = It.IsAny <string>(), remoteDebugItems = It.IsAny <IList <IDebugState> >()
}));
var mock = new Mock <Func <IDebugDispatcher> >();
mock.Setup(func => func()).Returns(() => debugDispatcher.Object);
var mockObj = new Mock <IDSFDataObject>();
mockObj.Setup(o => o.Environment).Returns(envMock.Object);
mockObj.Setup(o => o.IsDebugMode()).Returns(true);
var privateObject = new Warewolf.Testing.PrivateObject(wfApplicationUtils);
privateObject.SetField("_getDebugDispatcher", mock.Object);
privateObject.SetField("_lazyCat", catLog.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
try
{
wfApplicationUtils.DispatchDebugState(mockObj.Object, StateType.Start, out var error);
var state = debugState;
debugDispatcher.Verify(dispatcher => dispatcher.Write(new WriteArgs {
debugState = state, isTestExecution = It.IsAny <bool>(), isDebugFromWeb = It.IsAny <bool>(), testName = It.IsAny <string>(), isRemoteInvoke = It.IsAny <bool>(), remoteInvokerId = It.IsAny <string>(), parentInstanceId = It.IsAny <string>(), remoteDebugItems = It.IsAny <IList <IDebugState> >()
}));
catLog.Verify(catalog => catalog.GetResource(It.IsAny <Guid>(), It.IsAny <Guid>()));
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public void WarewolfListIterator_Instance_ShouldHaveConstructor()
{
Assert.IsNotNull(_warewolfListIterator);
var privateObj = new Warewolf.Testing.PrivateObject(_warewolfListIterator);
var variablesToIterateOn = privateObj.GetField("_variablesToIterateOn");
var count = privateObj.GetField("_count");
Assert.IsNotNull(variablesToIterateOn);
Assert.AreEqual(-1, count);
}
protected override void LoadEnvironment(IEnvironmentViewModel localhostEnvironment)
{
localhostEnvironment.Children = new ObservableCollection <IExplorerItemViewModel>(Children ?? new List <IExplorerItemViewModel> {
CreateExplorerVMS()
});
var p = new Warewolf.Testing.PrivateObject(localhostEnvironment);
p.SetField("_isConnected", true);
localhostEnvironment.ResourceId = Guid.Empty;
AfterLoad(localhostEnvironment.Server.EnvironmentID);
}
public void WarewolfListIterator_HasMoreData_ShouldReturnTrue()
{
Assert.IsNotNull(_warewolfListIterator);
var privateObj = new Warewolf.Testing.PrivateObject(_warewolfListIterator);
var variablesToIterateOn = privateObj.GetField("_variablesToIterateOn") as List <IWarewolfIterator>;
Assert.IsNotNull(variablesToIterateOn);
var hasMoreData = _warewolfListIterator.HasMoreData();
Assert.IsTrue(hasMoreData);
}
