public void OutputsRegion_ObjectName_GivenIsObjectAndObjectResult_ShouldUpdateDatalist()
{
//---------------Set up test pack-------------------
CustomContainer.DeRegister <IShellViewModel>();
var shellVm = new Mock <IShellViewModel>();
shellVm.Setup(model => model.UpdateCurrentDataListWithObjectFromJson(It.IsAny <string>(), It.IsAny <string>())).Verifiable();
CustomContainer.Register(shellVm.Object);
var act = new WebGetActivity
{
SourceId = Guid.NewGuid(),
Outputs = new List <IServiceOutputMapping>(),
IsObject = true,
};
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true)
{
ObjectResult = this.SerializeToJsonString(new DefaultSerializationBinder())
};
//---------------Assert Precondition----------------
Assert.IsTrue(outputsRegion.IsObject);
Assert.IsTrue(!string.IsNullOrEmpty(outputsRegion.ObjectResult));
Assert.IsTrue(FsInteropFunctions.ParseLanguageExpressionWithoutUpdate("[[@objName]]").IsJsonIdentifierExpression);
//---------------Execute Test ----------------------
outputsRegion.ObjectName = "[[@objName]]";
//---------------Test Result -----------------------
shellVm.Verify(model => model.UpdateCurrentDataListWithObjectFromJson(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
Assert.AreEqual(outputsRegion.ObjectName, act.ObjectName);
}
public void OutputsRegion_ObjectName_GivenIsObjectAndObjectResult_ShouldFireChanges()
{
//---------------Set up test pack-------------------
var act = new WebGetActivity
{
SourceId = Guid.NewGuid(),
Outputs = new List <IServiceOutputMapping>(),
IsObject = true,
};
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true)
{
ObjectResult = this.SerializeToJsonString(new DefaultSerializationBinder())
};
var wasCalled = false;
outputsRegion.PropertyChanged += (sender, args) =>
{
wasCalled = true;
};
//---------------Assert Precondition----------------
Assert.IsTrue(outputsRegion.IsObject);
//---------------Execute Test ----------------------
outputsRegion.ObjectName = "a";
//---------------Test Result -----------------------
Assert.IsTrue(wasCalled);
Assert.AreEqual(outputsRegion.ObjectName, act.ObjectName);
}
public void OutputsRegion_Errors_Expect_NoObjectName()
{
//---------------Set up test pack-------------------
var updatedOutputs = new List <IServiceOutputMapping>
{
new ServiceOutputMapping {
MappedFrom = "Name", MappedTo = "[[Person().Firstname]]", RecordSetName = "Person"
},
};
var act = new WebGetActivity
{
SourceId = Guid.NewGuid(),
Outputs = new List <IServiceOutputMapping>(),
IsObject = true,
};
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true);
outputsRegion.Outputs.Add(new ServiceOutputMapping {
MappedFrom = "Name", MappedTo = "[[Person().Name]]", RecordSetName = "Person"
});
//---------------Assert Precondition----------------
Assert.AreEqual(1, outputsRegion.Outputs.Count);
Assert.AreEqual("[[Person().Name]]", outputsRegion.Outputs.First().MappedTo);
//---------------Execute Test ----------------------
outputsRegion.ResetOutputs(updatedOutputs);
//---------------Test Result -----------------------
Assert.AreEqual(1, outputsRegion.Outputs.Count);
Assert.AreEqual("[[Person().Firstname]]", outputsRegion.Outputs.First().MappedTo);
Assert.AreEqual(1, outputsRegion.Errors.Count);
Assert.AreEqual("Please enter an 'Object Name' as 'Is Object' has been selected.", outputsRegion.Errors[0]);
}
public void OutputsRegion_GivenNull_ShouldRemovedEventHandlers()
{
//---------------Set up test pack-------------------
var act = new WebGetActivity
{
SourceId = Guid.NewGuid(),
Outputs = new List <IServiceOutputMapping>(),
};
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true);
var serviceOutputMapping = new ServiceOutputMapping
{
MappedFrom = "j",
MappedTo = "H"
};
var outPutsChanged = false;
serviceOutputMapping.PropertyChanged += (sender, args) =>
{
outPutsChanged |= args.PropertyName == "MappedFrom";
};
//---------------Assert Precondition----------------
Assert.IsNotNull(outputsRegion.Outputs);
//---------------Execute Test ----------------------
outputsRegion.Outputs.Add(serviceOutputMapping);
outputsRegion.Outputs.Add(new ServiceOutputMapping());
outputsRegion.Outputs.First(mapping => mapping.MappedFrom == "j").MappedFrom = "b";
Assert.IsTrue(outPutsChanged);
outPutsChanged = false;
//---------------Test Result -----------------------
outputsRegion.Outputs.Remove(serviceOutputMapping);
outputsRegion.Outputs.First().MappedFrom = "b";
Assert.IsFalse(outPutsChanged);
}
public void ManageWebServiceInputViewModel_TestActionSetSourceAndTestClickOk()
{
//------------Setup for test--------------------------
var mod = new MyWebModel();
var act = new WebGetActivity();
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
var inputview = new ManageWebServiceInputViewModel(webget, mod)
{
Model = new WebServiceDefinition()
};
inputview.ExecuteTest();
//------------Execute Test---------------------------
Assert.IsTrue(inputview.InputArea.IsEnabled);
Assert.IsTrue(inputview.OutputArea.IsEnabled);
Assert.IsNotNull(inputview.OutputArea.Outputs);
Assert.IsTrue(inputview.OutputArea.Outputs.Count > 0);
inputview.ExecuteOk();
//------------Execute Ok---------------------------
Assert.IsTrue(webget.SourceRegion.IsEnabled);
Assert.IsTrue(webget.OutputsRegion.IsEnabled);
Assert.IsTrue(webget.InputArea.IsEnabled);
Assert.IsTrue(webget.ErrorRegion.IsEnabled);
Assert.IsFalse(webget.ManageServiceInputViewModel.InputArea.IsEnabled);
//------------Assert Results-------------------------
}
public void WebPutInputRegion_RestoreFromPrevious_Restore_ExpectValuesChanged()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new WebGetActivity {
SourceId = id
};
var mod = new Mock <IWebServiceModel>();
mod.Setup(a => a.RetrieveSources()).Returns(new List <IWebServiceSource>());
var webSourceRegion = new WebSourceRegion(mod.Object, ModelItemUtils.CreateModelItem(new DsfWebPutActivity()));
var region = new WebPutInputRegion(ModelItemUtils.CreateModelItem(act), webSourceRegion);
var regionToRestore = new WebPutInputRegion(ModelItemUtils.CreateModelItem(act), webSourceRegion)
{
IsEnabled = true,
QueryString = "blob",
Headers = new ObservableCollection <INameValue> {
new NameValue("a", "b")
}
};
//------------Execute Test---------------------------
region.RestoreRegion(regionToRestore);
//------------Assert Results-------------------------
Assert.AreEqual(region.QueryString, "blob");
Assert.AreEqual(region.Headers.First().Name, "a");
Assert.AreEqual(region.Headers.First().Value, "b");
}
public void Restore_Region_ExpectRestore()
{
var id = Guid.NewGuid();
var act = new WebGetActivity()
{
SourceId = id
};
var src = new Mock <IWebServiceModel>();
var websrc = new WebServiceSourceDefinition()
{
Id = id
};
var s2 = new WebServiceSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new List <IWebServiceSource> {
websrc, s2
});
var region = new WebSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
var regionToRestore = new WebSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
regionToRestore.SelectedSource = s2;
region.RestoreRegion(regionToRestore);
Assert.AreEqual(region.SelectedSource, s2);
}
public void WebGetInputRegion_SrcChanged_UpdateValues()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new WebGetActivity {
SourceId = id
};
var mod = new Mock <IWebServiceModel>();
var lst = new List <IWebServiceSource> {
new WebServiceSourceDefinition()
{
HostName = "bob", DefaultQuery = "Dave"
}, new WebServiceSourceDefinition()
{
HostName = "f", DefaultQuery = "g"
}
};
mod.Setup(a => a.RetrieveSources()).Returns(lst);
var webSourceRegion = new WebSourceRegion(mod.Object, ModelItemUtils.CreateModelItem(new WebGetActivity()));
var region = new WebGetInputRegion(ModelItemUtils.CreateModelItem(act), webSourceRegion);
webSourceRegion.SelectedSource = lst[0];
Assert.AreEqual(region.QueryString, "Dave");
Assert.AreEqual(region.RequestUrl, "bob");
}
public void DataGridActivityFindMissingStrategy_GetActivityFields_WebGetActivity_ShouldReturnResults_IsObject()
{
//------------Setup for test--------------------------
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
var activity = new WebGetActivity
{
Inputs = new List <IServiceInput> {
new ServiceInput("Input1", "[[InputValue1]]"), new ServiceInput("Input2", "[[InputValue2]]"), new ServiceInput("Input3", "[[InputValue3]]")
},
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("Output1", "OutputValue1", "rec"), new ServiceOutputMapping("Output2", "OutputValue2", "rec")
},
QueryString = "[[qstring]]",
Headers = new List <INameValue> {
new NameValue("Content-Type", "[[ctype]]")
},
OnErrorVariable = "[[err]]",
OnErrorWorkflow = "[[errSvc]]",
IsObject = true,
ObjectName = "TheObject"
};
//------------Execute Test---------------------------
var fields = strategy.GetActivityFields(activity);
//------------Assert Results-------------------------
Assert.IsTrue(fields.Contains("TheObject"));
}
public void Webget_TestActionSetSource()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new MyWebModel();
var act = new WebGetActivity();
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
webget.ManageServiceInputViewModel = new InputViewForTest(webget, mod);
webget.SourceRegion.SelectedSource = webget.SourceRegion.Sources.First();
webget.SourceRegion.SelectedSource.AuthenticationType = AuthenticationType.Public;
webget.SourceRegion.SelectedSource.UserName = "";
webget.SourceRegion.SelectedSource.Password = "";
webget.SourceRegion.SelectedSource.Path = "";
//------------Execute Test---------------------------
var hashCode = webget.SourceRegion.SelectedSource.GetHashCode();
Assert.IsTrue(webget.SourceRegion.IsEnabled);
Assert.IsFalse(webget.OutputsRegion.IsEnabled);
Assert.IsTrue(webget.InputArea.IsEnabled);
Assert.IsTrue(webget.ErrorRegion.IsEnabled);
Assert.AreEqual("", webget.SourceRegion.SelectedSource.UserName);
Assert.AreEqual("", webget.SourceRegion.SelectedSource.Password);
Assert.AreEqual(AuthenticationType.Public, webget.SourceRegion.SelectedSource.AuthenticationType);
Assert.AreEqual("", webget.SourceRegion.SelectedSource.Path);
Assert.AreEqual(hashCode, webget.SourceRegion.SelectedSource.GetHashCode());
//------------Assert Results-------------------------
}
public void Webget_TestActionSetSourceAndTestClickOkHasQueryStringAndHeadersRecSet()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new MyWebModel();
var act = new WebGetActivity();
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
webget.ManageServiceInputViewModel = new InputViewForTest(webget, mod);
webget.SourceRegion.SelectedSource = webget.SourceRegion.Sources.First();
webget.InputArea.Headers.Add(new NameValue("[[a]]", "asa"));
webget.InputArea.QueryString = "the [[b().a]]";
#pragma warning disable 4014
webget.TestInputCommand.Execute();
webget.ManageServiceInputViewModel.TestCommand.Execute(null);
webget.ManageServiceInputViewModel.IsEnabled = true;
webget.ManageServiceInputViewModel.OutputArea.Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c")
};
webget.ManageServiceInputViewModel.OkCommand.Execute(null);
#pragma warning restore 4014
//------------Execute Test---------------------------
Assert.IsTrue(webget.SourceRegion.IsEnabled);
Assert.IsTrue(webget.OutputsRegion.IsEnabled);
Assert.IsTrue(webget.InputArea.IsEnabled);
Assert.IsTrue(webget.ErrorRegion.IsEnabled);
Assert.IsTrue(webget.ManageServiceInputViewModel.InputArea.Inputs.Count == 2);
Assert.IsTrue(webget.ManageServiceInputViewModel.InputArea.Inputs.First().Name == "[[b().a]]");
Assert.IsTrue(webget.ManageServiceInputViewModel.InputArea.Inputs.Last().Name == "[[a]]");
Assert.AreEqual(0, webget.ManageServiceInputViewModel.Errors.Count);
//------------Assert Results-------------------------
}
public void Webget_TestActionSetSourceAndTestClickOkHasserialisationIssue()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new MyWebModel();
mod.IsTextResponse = true;
var act = new WebGetActivity();
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
webget.ManageServiceInputViewModel = new InputViewForTest(webget, mod);
webget.SourceRegion.SelectedSource = webget.SourceRegion.Sources.First();
#pragma warning disable 4014
webget.TestInputCommand.Execute();
webget.ManageServiceInputViewModel.TestCommand.Execute(null);
webget.ManageServiceInputViewModel.IsEnabled = true;
webget.ManageServiceInputViewModel.OkCommand.Execute(null);
#pragma warning restore 4014
//------------Execute Test---------------------------
Assert.AreEqual(webget.OutputsRegion.Outputs.First().MappedFrom, "Result");
//------------Assert Results-------------------------
}
public void CloneRegionExpectClone()
{
var id = Guid.NewGuid();
var act = new WebGetActivity()
{
SourceId = id
};
var src = new Mock <IWebServiceModel>();
var websrc = new WebServiceSourceDefinition()
{
Id = id
};
var s2 = new WebServiceSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new List <IWebServiceSource> {
websrc, s2
});
var region = new WebSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
var cloned = region.CloneRegion();
Assert.AreEqual(((WebSourceRegion)cloned).SelectedSource, region.SelectedSource);
}
public void ChangeSrcExpectSomethingChanged()
{
var id = Guid.NewGuid();
var act = new WebGetActivity()
{
SourceId = id
};
var src = new Mock <IWebServiceModel>();
var websrc = new WebServiceSourceDefinition()
{
Id = id
};
var Evt = false;
var s2 = new WebServiceSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new List <IWebServiceSource> {
websrc, s2
});
var region = new WebSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
region.SomethingChanged += (a, b) => { Evt = true; };
region.SelectedSource = s2;
Assert.IsTrue(Evt);
}
public void ManageWebServiceInputViewModel_Ctor()
{
var mod = new MyWebModel();
var act = new WebGetActivity()
{
SourceId = mod.Sources[0].Id,
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("d", "e", "f")
},
Headers = new List <INameValue> {
new NameValue("a", "x")
},
QueryString = "Bob the builder",
ServiceName = "dsfBob"
};
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
//------------Assert Results-------------------------
var vm = new ManageWebServiceInputViewModel(webget, mod);
Assert.IsNotNull(vm.CloseCommand);
Assert.IsNotNull(vm.PasteResponseCommand);
Assert.IsNotNull(vm.CloseCommand);
}
public void ManageWebServiceInputViewModel_TestActionSetSourceAndTest_ExistingContent()
{
//------------Setup for test--------------------------
var mod = new MyModel()
{
Response = "{\"NormalText\":\"\"}"
};
var act = new WebGetActivity()
{
Headers = new List <INameValue>()
{
new NameValue("Content-Type", "Application/xml")
}
};
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
var inputview = new ManageWebServiceInputViewModel(webget, mod)
{
Model = new WebServiceDefinition()
};
Assert.AreEqual(2, webget.InputArea.Headers.Count);
//------------Execute Test---------------------------
inputview.ExecuteTest();
//------------Assert Results-------------------------
Assert.IsTrue(inputview.InputArea.IsEnabled);
Assert.IsTrue(inputview.OutputArea.IsEnabled);
Assert.IsNotNull(inputview.OutputArea.Outputs);
Assert.IsTrue(inputview.OutputArea.Outputs.Count > 0);
Assert.AreEqual(2, webget.InputArea.Headers.Count);
}
public void OutputsRegion_Restore()
{
CustomContainer.Register <IFieldAndPropertyMapper>(new FieldAndPropertyMapper());
//------------Setup for test--------------------------
var act = new WebGetActivity
{
SourceId = Guid.NewGuid(),
Outputs = null,
};
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true);
outputsRegion.Outputs.Add(new ServiceOutputMapping());
outputsRegion.Outputs.Add(new ServiceOutputMapping());
outputsRegion.Outputs.Add(new ServiceOutputMapping());
outputsRegion.Outputs.Add(new ServiceOutputMapping());
//------------Execute Test---------------------------
Assert.IsFalse(outputsRegion.IsEnabled);
Assert.IsTrue(outputsRegion.IsObjectOutputUsed);
var x = outputsRegion.CloneRegion() as OutputsRegion;
outputsRegion.Outputs.Clear();
Assert.IsFalse(outputsRegion.IsEnabled);
//------------Assert Results-------------------------
outputsRegion.RestoreRegion(x);
Assert.IsFalse(outputsRegion.IsEnabled);
}
public void WebGetActivity_Equals_Given_Different_Headers_IsNOTEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var headers = new List <INameValue>();
var headers2 = new List <INameValue> {
new NameValue("a", "x")
};
var webGet = new WebGetActivity()
{
UniqueID = uniqueId, Headers = headers
};
var webGet1 = new WebGetActivity()
{
UniqueID = uniqueId, Headers = headers2
};
//---------------Assert Precondition----------------
Assert.IsNotNull(webGet);
//---------------Execute Test ----------------------
var @equals = webGet.Equals(webGet1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void WebGetActivity_Equals_Given_Different_OutputDescription_IsNOTEqual()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var outDescr = new OutputDescription()
{
Format = OutputFormats.Unknown
};
var outDescr2 = new OutputDescription()
{
Format = OutputFormats.ShapedXML
};
var webGet = new WebGetActivity()
{
UniqueID = uniqueId, OutputDescription = outDescr
};
var webGet1 = new WebGetActivity()
{
UniqueID = uniqueId, OutputDescription = outDescr2
};
//---------------Assert Precondition----------------
Assert.IsNotNull(webGet);
//---------------Execute Test ----------------------
var @equals = webGet.Equals(webGet1);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
public void Webget_TestActionSetSourceAndTestClickOkHasMappingsErrorFromServer()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new MyWebModel();
mod.HasRecError = true;
var act = new WebGetActivity();
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
webget.ManageServiceInputViewModel = new InputViewForTest(webget, mod);
webget.SourceRegion.SelectedSource = webget.SourceRegion.Sources.First();
#pragma warning disable 4014
webget.TestInputCommand.Execute();
webget.ManageServiceInputViewModel.TestCommand.Execute(null);
webget.ManageServiceInputViewModel.IsEnabled = true;
webget.ManageServiceInputViewModel.OutputArea.Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c")
};
webget.ManageServiceInputViewModel.OkCommand.Execute(null);
#pragma warning restore 4014
//------------Execute Test---------------------------
Assert.IsTrue(webget.ErrorRegion.IsEnabled);
//------------Assert Results-------------------------
}
public void WebGetInputRegion_Headers_AddEmptyHeaders()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var webGetActivity = new WebGetActivity
{
SourceId = id,
Headers = new ObservableCollection <INameValue> {
new NameValue("a", "b")
},
};
var mod = new Mock <IWebServiceModel>();
mod.Setup(a => a.RetrieveSources()).Returns(new List <IWebServiceSource>());
var modelItem = ModelItemUtils.CreateModelItem(webGetActivity);
var webSourceRegion = new WebSourceRegion(mod.Object, modelItem);
var region = new WebGetInputRegion(modelItem, webSourceRegion);
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.AreEqual(2, region.Headers.Count);
Assert.AreEqual("a", region.Headers[0].Name);
Assert.AreEqual("b", region.Headers[0].Value);
Assert.AreEqual("", region.Headers[1].Name);
Assert.AreEqual("", region.Headers[1].Value);
}
public void ManageWebServiceInputViewModel_Properties()
{
var mod = new MyWebModel();
var act = new WebGetActivity()
{
SourceId = mod.Sources[0].Id,
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("d", "e", "f")
},
Headers = new List <INameValue> {
new NameValue("a", "x")
},
QueryString = "Bob the builder",
ServiceName = "dsfBob"
};
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
var vm = new ManageWebServiceInputViewModel(webget, mod);
var lst = new List <IServiceInput>();
vm.InputArea.Inputs = lst;
Assert.AreEqual(lst.Count, vm.InputArea.Inputs.Count);
var lsto = new List <IServiceOutputMapping>();
vm.OutputArea.Outputs = lsto;
Assert.AreEqual(lsto, vm.OutputArea.Outputs);
vm.TestResults = "bob";
Assert.AreEqual("bob", vm.TestResults);
vm.TestResultsAvailable = true;
Assert.IsTrue(vm.TestResultsAvailable);
vm.OkSelected = true;
Assert.IsTrue(vm.OkSelected);
vm.IsTestResultsEmptyRows = true;
Assert.IsTrue(vm.IsTestResultsEmptyRows);
vm.IsTesting = true;
Assert.IsTrue(vm.IsTesting);
vm.PasteResponseVisible = true;
Assert.IsTrue(vm.PasteResponseVisible);
vm.PasteResponseAvailable = true;
Assert.IsTrue(vm.PasteResponseAvailable);
var b = new WebServiceDefinition()
{
Headers = new List <INameValue>()
{
new NameValue("a", "b")
}
};
vm.Model = b;
Assert.IsNotNull(vm.Model);
}
public void WebGetActivity_Equals_Given_SameWebGetTool_IsEqual()
{
//---------------Set up test pack-------------------
var webGetActivity = new WebGetActivity();
var webGetActivity1 = webGetActivity;
//---------------Assert Precondition----------------
Assert.IsNotNull(webGetActivity);
//---------------Execute Test ----------------------
var @equals = webGetActivity.Equals(webGetActivity1);
//---------------Test Result -----------------------
Assert.IsTrue(@equals);
}
public void OutputsRegion_Ctor_NewModelItem_ExpectVisibleAndValidData()
{
//------------Setup for test--------------------------
var act = new WebGetActivity
{
SourceId = Guid.NewGuid(),
Outputs = null,
};
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true);
//------------Execute Test---------------------------
Assert.IsFalse(outputsRegion.IsEnabled);
Assert.IsTrue(outputsRegion.IsObjectOutputUsed);
//------------Assert Results-------------------------
}
public void SavedSource_DifferentType_Is_NotEqual()
{
//---------------Set up test pack-------------------
var webServiceSourceDefinition = new WebServiceSourceDefinition {
Name = "bravo"
};
object differentObject = new WebGetActivity
{
SourceId = Guid.NewGuid(),
ActionName = "A"
};
//---------------Assert Precondition----------------
Assert.IsFalse(webServiceSourceDefinition.Equals(differentObject), "Equals operator can't compare to differently typed object.");
}
public void Webget_MethodName_ClearErrors()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new MyWebModel();
var act = new WebGetActivity();
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
//------------Execute Test---------------------------
webget.ClearValidationMemoWithNoFoundError();
//------------Assert Results-------------------------
Assert.IsNull(webget.Errors);
Assert.AreEqual(webget.DesignValidationErrors.Count, 1);
}
public void Webget_MethodName_ValidateExpectErrors()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new MyWebModel();
var act = new WebGetActivity();
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
webget.Validate();
//------------Execute Test---------------------------
Assert.AreEqual(webget.Errors.Count, 1);
Assert.AreEqual(webget.DesignValidationErrors.Count, 2);
//------------Assert Results-------------------------
}
public void WebGetInputRegion_TestInputCtor()
{
var id = Guid.NewGuid();
var act = new WebGetActivity {
SourceId = id
};
var mod = new Mock <IWebServiceModel>();
mod.Setup(a => a.RetrieveSources()).Returns(new List <IWebServiceSource>());
var webSourceRegion = new WebSourceRegion(mod.Object, ModelItemUtils.CreateModelItem(new WebGetActivity()));
var region = new WebGetInputRegion(ModelItemUtils.CreateModelItem(act), webSourceRegion);
Assert.AreEqual(region.IsEnabled, false);
Assert.AreEqual(region.Errors.Count, 0);
}
public void Webget_Ctor_EmptyModelItem()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new MyWebModel();
var act = new WebGetActivity();
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
//------------Execute Test---------------------------
Assert.IsTrue(webget.SourceRegion.IsEnabled);
Assert.IsFalse(webget.OutputsRegion.IsEnabled);
Assert.IsFalse(webget.InputArea.IsEnabled);
Assert.IsTrue(webget.ErrorRegion.IsEnabled);
//------------Assert Results-------------------------
}
public void GetHeaderRegion_GivenIsNew_ShouldReturnInputArea()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new MyWebModel();
var act = new WebGetActivity();
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
//------------Execute Test---------------------------
Assert.IsTrue(webget.SourceRegion.IsEnabled);
Assert.IsFalse(webget.OutputsRegion.IsEnabled);
Assert.IsFalse(webget.InputArea.IsEnabled);
Assert.IsTrue(webget.ErrorRegion.IsEnabled);
//------------Assert Results-------------------------
Assert.AreSame(webget.InputArea, webget.GetHeaderRegion());
}
