public void FetchResourceDefinition_Execute_WhenDefintionExist_ResourceDefinition()
{
//------------Setup for test--------------------------
var workspace = new Mock <IWorkspace>();
workspace.Setup(m => m.ID).Returns(_workspaceID);
IEsbManagementEndpoint endPoint = new FetchResourceDefintition();
Dictionary <string, StringBuilder> data = new Dictionary <string, StringBuilder>();
data["ResourceID"] = new StringBuilder("b2b0cc87-32ba-4504-8046-79edfb18d5fd");
//data["ResourceType"] = new StringBuilder();
//------------Execute Test---------------------------
var xaml = endPoint.Execute(data, workspace.Object);
//------------Assert Results-------------------------
var expected = XmlResource.Fetch("Calculate_RecordSet_Subtract_Expected").ToString(SaveOptions.DisableFormatting);
var obj = ConvertToMsg(xaml.ToString());
Assert.AreEqual(expected.Replace(" ", ""), obj.Message.Replace(Environment.NewLine, "").Replace(" ", "").ToString());
}
// ReSharper disable InconsistentNaming - Unit Tests
public void LoadInstance_With_FileUsedByAnotherProcess_Expected_ThrowsInstancePersistenceException()
// ReSharper restore InconsistentNaming
{
var instanceId = Guid.NewGuid();
var path = Path.Combine(TestPath, instanceId + ".xml");
var metaPath = Path.Combine(TestPath, instanceId + ".meta.xml");
try
{
var xml = XmlResource.Fetch(TestFileName);
xml.Save(path);
xml = XmlResource.Fetch(TestMetaFileName);
xml.Save(metaPath);
// Force error: The process cannot access the file because it is being used by another process
using (var fs = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.None))
{
var store = new FileSystemInstanceStoreIO();
IDictionary <XName, InstanceValue> instanceData;
IDictionary <XName, InstanceValue> instanceMetadata;
var result = store.LoadInstance(instanceId, out instanceData, out instanceMetadata);
}
}
finally
{
if (File.Exists(path))
{
File.Delete(path);
}
if (File.Exists(metaPath))
{
File.Delete(metaPath);
}
}
}
// ReSharper disable InconsistentNaming - Unit Tests
public void GetInstanceAssociation_With_InvalidFileName_Expected_ReturnsEmptyGuid()
// ReSharper restore InconsistentNaming
{
const string InvalidInstanceId = "99999";
var instanceKey = Guid.NewGuid();
var path = Path.Combine(TestPath, string.Format("Key.{0}.{1}.xml", instanceKey, InvalidInstanceId));
try
{
var xml = XmlResource.Fetch(TestFileName);
xml.Save(path);
var store = new FileSystemInstanceStoreIO();
var result = store.GetInstanceAssociation(instanceKey);
Assert.AreEqual(Guid.Empty, result);
}
finally
{
if (File.Exists(path))
{
File.Delete(path);
}
}
}
public void DsfWebDeleteActivity_ExecutionImpl_ErrorResultTO_ReturnErrors_ToActivity_Success()
{
//-----------------------Arrange-------------------------
const string response = "{\"Message\":\"TEST Error\"}";
var environment = new ExecutionEnvironment();
var mockEsbChannel = new Mock <IEsbChannel>();
var mockDSFDataObject = new Mock <IDSFDataObject>();
var mockExecutionEnvironment = new Mock <IExecutionEnvironment>();
var errorResultTO = new ErrorResultTO();
using (var service = new WebService(XmlResource.Fetch("WebService"))
{
RequestResponse = response
})
{
mockDSFDataObject.Setup(o => o.Environment).Returns(environment);
mockDSFDataObject.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
var dsfWebGetActivity = new TestDsfWebDeleteActivity
{
OutputDescription = service.GetOutputDescription(),
ResourceID = InArgument <Guid> .FromValue(Guid.Empty),
QueryString = "test Query",
Headers = new List <INameValue>(),
ResponseFromWeb = response,
HasErrorMessage = "Some error"
};
//-----------------------Act-----------------------------
dsfWebGetActivity.TestExecutionImpl(mockEsbChannel.Object, mockDSFDataObject.Object, "Test Inputs", "Test Outputs", out errorResultTO, 0);
//-----------------------Assert--------------------------
Assert.AreEqual(1, errorResultTO.FetchErrors().Count);
Assert.AreEqual("Some error", errorResultTO.FetchErrors()[0]);
}
}
public void FetchResourceDefinition_Execute_WhenServiceHasUnlimitedNamespace_ResourceDefinition()
{
//------------Setup for test--------------------------
const string serviceName = "Bug9304";
var workspace = new Mock <IWorkspace>();
workspace.Setup(m => m.ID).Returns(_workspaceID);
var xml = XmlResource.Fetch(serviceName);
var categoryElement = xml.Element("Category");
Assert.IsNotNull(categoryElement);
var resourcePath = categoryElement.Value;
ResourceCatalog.Instance.SaveResource(_workspaceID, xml.ToStringBuilder());
var resource = ResourceCatalog.Instance.GetResource(_workspaceID, resourcePath + "\\" + serviceName);
IEsbManagementEndpoint endPoint = new FetchResourceDefintition();
Dictionary <string, StringBuilder> data = new Dictionary <string, StringBuilder>();
data["ResourceID"] = new StringBuilder(resource.ResourceID.ToString());
//------------Execute Test---------------------------
var xaml = endPoint.Execute(data, workspace.Object);
//------------Assert Results-------------------------
var expected = XmlResource.Fetch("Bug9304_RemovedUnlimitedNamespace").ToString(SaveOptions.DisableFormatting);
var obj = ConvertToMsg(xaml.ToString());
var actual = obj.Message.ToString();
Assert.IsFalse(String.IsNullOrWhiteSpace(actual));
// There seems to be an extra " " somewhere ;(
StringAssert.Contains(actual.Replace(" ", ""), expected.Replace(" ", ""));
}
public void Webservice_Test_WhenJsonPathSet_ExpectShapedData()
{
//------------Setup for test--------------------------
var serviceXml = XmlResource.Fetch("WebService");
var sourceXml = XmlResource.Fetch("WebSource");
var response = JsonResource.Fetch("cryptsy_all_markets");
var expected = JsonResource.Fetch("cryptsy_all_markets_shaped_response");
var service = new WebService(serviceXml)
{
Source = new WebSource(sourceXml)
};
var services = new WebServicesMock();
service.RequestResponse = response;
service.JsonPath = "$.return.markets[*]";
//------------Execute Test---------------------------
var result = services.ApplyPath(service.ToString(), Guid.Empty, Guid.Empty);
//------------Assert Results-------------------------
Assert.AreEqual(expected, result.JsonPathResult);
}
public static void ClassInitialize(TestContext testContext)
{
//
// This is called from other tests e.g. DynamicServicesInvokerTest
//
lock (InitLock)
{
if (_isInitialized)
{
return;
}
Directory.SetCurrentDirectory(testContext.TestDir);
_testDir = testContext.TestDir;
var workspaceID = Guid.NewGuid();
#region Copy server services to file system
var workspacePath = Path.Combine(GlobalConstants.WorkspacePath, workspaceID.ToString());
#region Initialize services
_servicesPath = Path.Combine(workspacePath, "Services");
var servicesVersionControlPath = Path.Combine(_servicesPath, "VersionControl");
var serverServicesPath = Path.Combine(_testDir, "Services");
Directory.CreateDirectory(_servicesPath);
Directory.CreateDirectory(servicesVersionControlPath);
Directory.CreateDirectory(serverServicesPath);
var xml = XmlResource.Fetch(ServiceName);
xml.Save(Path.Combine(_servicesPath, ServiceName + ".xml"));
xml.Save(Path.Combine(servicesVersionControlPath, ServiceName + ".V" + VersionNo + ".xml"));
xml.Save(Path.Combine(serverServicesPath, ServiceName + ".xml"));
xml = XmlResource.Fetch(ServiceNameUnsigned);
xml.Save(Path.Combine(_servicesPath, ServiceNameUnsigned + ".xml"));
xml.Save(Path.Combine(servicesVersionControlPath, ServiceNameUnsigned + ".V" + VersionNo + ".xml"));
xml.Save(Path.Combine(serverServicesPath, ServiceNameUnsigned + ".xml"));
_testServiceDefinition = xml.ToString();
#endregion
#region Initialize sources
_sourcesPath = Path.Combine(workspacePath, "Sources");
var sourcesVersionControlPath = Path.Combine(_sourcesPath, "VersionControl");
var serverSourcesPath = Path.Combine(_testDir, "Sources");
Directory.CreateDirectory(_sourcesPath);
Directory.CreateDirectory(sourcesVersionControlPath);
Directory.CreateDirectory(serverSourcesPath);
xml = XmlResource.Fetch(SourceName);
xml.Save(Path.Combine(_sourcesPath, SourceName + ".xml"));
xml.Save(Path.Combine(sourcesVersionControlPath, SourceName + ".V" + VersionNo + ".xml"));
xml.Save(Path.Combine(serverSourcesPath, SourceName + ".xml"));
_testSourceDefinition = xml.ToString();
xml = XmlResource.Fetch(ServerConnection1Name);
xml.Save(Path.Combine(_sourcesPath, ServerConnection1ResourceName + ".xml"));
xml.Save(Path.Combine(_sourcesPath, ServerConnection1ResourceName + ".xml"));
xml.Save(Path.Combine(sourcesVersionControlPath, ServerConnection1ResourceName + ".V" + VersionNo + ".xml"));
xml.Save(Path.Combine(serverSourcesPath, ServerConnection1ResourceName + ".xml"));
xml = XmlResource.Fetch(ServerConnection2Name);
xml.Save(Path.Combine(_sourcesPath, ServerConnection2ResourceName + ".xml"));
xml.Save(Path.Combine(sourcesVersionControlPath, ServerConnection2ResourceName + ".V" + VersionNo + ".xml"));
xml.Save(Path.Combine(serverSourcesPath, ServerConnection2ResourceName + ".xml"));
#endregion
#endregion
_workspace = WorkspaceRepository.Instance.Get(workspaceID);
_testInstance = WorkspaceRepository.Instance;
_isInitialized = true;
}
}
public void ScrubberScrubXmlWithValidFormatExpectedGeneratesValidOutputDescription()
{
var expectedPaths = CreateCurrentWeatherExpectedPaths();
VerifyScrub(XmlResource.Fetch("Bug9519_1").ToString(), expectedPaths);
}
public void ConstructorWithValidXmlNullWebServerUriArgumentExpectedThrowsArgumentNullException()
{
var config = new Configuration.Settings.Configuration(XmlResource.Fetch("Settings"));
ValidateInitializesAllProperties(config);
}
public void ConstructorWithValidXmlArgumentExpectedInitializesAllProperties()
{
var config = new Configuration.Settings.Configuration(XmlResource.Fetch("Settings"));
ValidateInitializesAllProperties(config);
}
public void LoggingSettingChangedExpectsHasChangesFalseWhenInitializating()
{
var config = new Configuration.Settings.Configuration(XmlResource.Fetch("Settings"));
Assert.IsFalse(config.HasChanges);
}
public void DsfWebPutActivity_Execute_WithValidTextResponse_ShouldSetVariables()
{
//------------Setup for test--------------------------
const string response = "{\"Location\": \"Paris\",\"Time\": \"May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC\"," +
"\"Wind\": \"from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0\"," +
"\"Visibility\": \"greater than 7 mile(s):0\"," +
"\"Temperature\": \"59 F (15 C)\"," +
"\"DewPoint\": \"41 F (5 C)\"," +
"\"RelativeHumidity\": \"51%\"," +
"\"Pressure\": \"29.65 in. Hg (1004 hPa)\"," +
"\"Status\": \"Success\"" +
"}";
var environment = new ExecutionEnvironment();
environment.Assign("[[City]]", "PMB", 0);
environment.Assign("[[CountryName]]", "South Africa", 0);
var DsfWebPutActivity = new TestDsfWebPutActivity
{
ResourceCatalog = new Mock <IResourceCatalog>().Object
};
var serviceInputs = new List <IServiceInput> {
new ServiceInput("CityName", "[[City]]"), new ServiceInput("Country", "[[CountryName]]")
};
var serviceOutputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("Response", "[[Response]]", "")
};
DsfWebPutActivity.Inputs = serviceInputs;
DsfWebPutActivity.Outputs = serviceOutputs;
var serviceXml = XmlResource.Fetch("WebService");
using (var service = new WebService(serviceXml)
{
RequestResponse = response
})
{
DsfWebPutActivity.OutputDescription = service.GetOutputDescription();
DsfWebPutActivity.ResponseFromWeb = response;
var dataObjectMock = new Mock <IDSFDataObject>();
dataObjectMock.Setup(o => o.Environment).Returns(environment);
dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
DsfWebPutActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty);
DsfWebPutActivity.QueryString = "";
DsfWebPutActivity.PutData = "";
DsfWebPutActivity.SourceId = Guid.Empty;
DsfWebPutActivity.Headers = new List <INameValue>();
DsfWebPutActivity.OutputDescription = new OutputDescription();
DsfWebPutActivity.OutputDescription.DataSourceShapes.Add(new DataSourceShape {
Paths = new List <IPath> {
new StringPath {
ActualPath = "[[Response]]", OutputExpression = "[[Response]]"
}
}
});
//------------Execute Test---------------------------
DsfWebPutActivity.Execute(dataObjectMock.Object, 0);
//------------Assert Results-------------------------
Assert.IsNotNull(DsfWebPutActivity.OutputDescription);
Assert.AreEqual(response, ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[Response]]", 0)));
}
}
public void WebPutActivity_ExecutionImpl_ResponseManager_PushResponseIntoEnvironment_GivenJsonResponse_MappedToRecodSet_ShouldSucess()
{
//-----------------------Arrange-------------------------
const string json = "{\"Messanger\":\"jSon response from the request\"}";
var response = Convert.ToBase64String(json.ToBytesArray());
const string mappingFrom = "mapFrom";
const string recordSet = "recset";
const string mapTo = "mapTo";
const string variableNameMappingTo = "[[recset().mapTo]]";
var environment = new ExecutionEnvironment();
var mockEsbChannel = new Mock <IEsbChannel>();
var mockDSFDataObject = new Mock <IDSFDataObject>();
var mockExecutionEnvironment = new Mock <IExecutionEnvironment>();
var errorResultTO = new ErrorResultTO();
using (var service = new WebService(XmlResource.Fetch("WebService"))
{
RequestResponse = response
})
{
mockDSFDataObject.Setup(o => o.Environment).Returns(environment);
mockDSFDataObject.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
var dsfWebGetActivity = new TestWebPutActivity
{
OutputDescription = service.GetOutputDescription(),
ResourceID = InArgument <Guid> .FromValue(Guid.Empty),
QueryString = "test Query",
Headers = new List <INameValue>(),
ResponseFromWeb = response,
IsObject = false,
Outputs = new List <IServiceOutputMapping>
{
{
new ServiceOutputMapping
{
MappedFrom = mappingFrom,
MappedTo = mapTo,
RecordSetName = recordSet
}
}
}
};
//-----------------------Act-----------------------------
dsfWebGetActivity.TestExecutionImpl(mockEsbChannel.Object, mockDSFDataObject.Object, "Test Inputs", "Test Outputs", out errorResultTO, 0);
//-----------------------Assert--------------------------
Assert.IsFalse(errorResultTO.HasErrors());
//assert first DataSourceShapes
var resourceManager = dsfWebGetActivity.ResponseManager;
var outputDescription = resourceManager.OutputDescription;
var dataShapes = outputDescription.DataSourceShapes;
var paths = dataShapes.First().Paths;
Assert.IsNotNull(outputDescription);
Assert.AreEqual("Messanger", paths.First().ActualPath);
Assert.AreEqual("Messanger", paths.First().DisplayPath);
Assert.AreEqual(variableNameMappingTo, paths.First().OutputExpression);
Assert.AreEqual("jSon response from the request", paths.First().SampleData);
//assert execution environment
var envirVariable = environment.Eval(variableNameMappingTo, 0);
var resultItem = (envirVariable as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult).Item;
Assert.IsNotNull(envirVariable);
if (resultItem.First() is DataStorage.WarewolfAtom.DataString firstItem)
{
Assert.AreEqual("jSon response from the request", firstItem.Item);
}
else
{
Assert.Fail("expected jSon response from the request");
}
}
}
public void DsfWebDeleteActivity_Execute_WithValidXmlEscaped_ShouldSetVariables()
{
//------------Setup for test--------------------------
const string response = "<CurrentWeather>" +
"<Location><Paris></Location>" +
"<Time>May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC</Time>" +
"<Wind>from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0</Wind>" +
"<Visibility><greater than 7 mile(s):0></Visibility>" +
"<Temperature> 59 F (15 C)</Temperature>" +
"<DewPoint> 41 F (5 C)</DewPoint>" +
"<RelativeHumidity> 51%</RelativeHumidity>" +
"<Pressure> 29.65 in. Hg (1004 hPa)</Pressure>" +
"<Status>Success</Status>" +
"</CurrentWeather>";
var environment = new ExecutionEnvironment();
environment.Assign("[[City]]", "PMB", 0);
environment.Assign("[[CountryName]]", "South Africa", 0);
var dsfWebDeleteActivity = CreateTestDeleteActivity();
var serviceInputs = new List <IServiceInput> {
new ServiceInput("CityName", "[[City]]"), new ServiceInput("Country", "[[CountryName]]")
};
var serviceOutputs = new List <IServiceOutputMapping>
{
new ServiceOutputMapping("Location", "[[weather().Location]]", "weather")
, new ServiceOutputMapping("Time", "[[weather().Time]]", "weather")
, new ServiceOutputMapping("Wind", "[[weather().Wind]]", "weather")
, new ServiceOutputMapping("Visibility", "[[Visibility]]", "")
};
dsfWebDeleteActivity.Inputs = serviceInputs;
dsfWebDeleteActivity.Outputs = serviceOutputs;
var serviceXml = XmlResource.Fetch("WebService");
var service = new WebService(serviceXml)
{
RequestResponse = response
};
dsfWebDeleteActivity.OutputDescription = service.GetOutputDescription();
dsfWebDeleteActivity.ResponseFromWeb = response;
var dataObjectMock = new Mock <IDSFDataObject>();
dataObjectMock.Setup(o => o.Environment).Returns(environment);
dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
dsfWebDeleteActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty);
dsfWebDeleteActivity.QueryString = "";
//dsfWebPostActivity.PostData = "";
dsfWebDeleteActivity.SourceId = Guid.Empty;
dsfWebDeleteActivity.Headers = new List <INameValue>();
//------------Execute Test---------------------------
dsfWebDeleteActivity.Execute(dataObjectMock.Object, 0);
//------------Assert Results-------------------------
Assert.IsNotNull(dsfWebDeleteActivity.OutputDescription);
var visibility = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[Visibility]]", 0));
Assert.AreEqual("<greater than 7 mile(s):0>", visibility);
var location = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Location]]", 0));
Assert.AreEqual("<Paris>", location);
var time = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Time]]", 0));
Assert.AreEqual("May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC", time);
var wind = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Wind]]", 0));
Assert.AreEqual("from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0", wind);
}
public static void ClassInitialize(TestContext context)
{
_connectionXml = XmlResource.Fetch("ServerConnection2");
_connection = new Connection(_connectionXml);
}
public static void MyClassInitialize(TestContext testContext)
{
Directory.SetCurrentDirectory(testContext.TestDir);
_simulationShape = XmlResource.Fetch("SimulationShape").ToString();
_simulationData = XmlResource.Fetch("SimulationData").ToString();
}
public void GetDebugInputs_GivenMockEnvironment_ShouldAddDebugInputItems()
{
//---------------Set up test pack-------------------
const string response = "{\"Location\": \"Paris\",\"Time\": \"May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC\"," +
"\"Wind\": \"from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0\"," +
"\"Visibility\": \"greater than 7 mile(s):0\"," +
"\"Temperature\": \"59 F (15 C)\"," +
"\"DewPoint\": \"41 F (5 C)\"," +
"\"RelativeHumidity\": \"51%\"," +
"\"Pressure\": \"29.65 in. Hg (1004 hPa)\"," +
"\"Status\": \"Success\"" +
"}";
var environment = new ExecutionEnvironment();
environment.Assign("[[City]]", "PMB", 0);
environment.Assign("[[CountryName]]", "South Africa", 0);
environment.Assign("[[Post]]", "Some data", 0);
var dsfWebPostActivity = new TestDsfWebPostActivity
{
Headers = new List <INameValue> {
new NameValue("Header 1", "[[City]]")
},
QueryString = "http://www.testing.com/[[CountryName]]",
PostData = "This is post:[[Post]]"
};
var serviceOutputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("Location", "[[weather().Location]]", "weather"), new ServiceOutputMapping("Time", "[[weather().Time]]", "weather"), new ServiceOutputMapping("Wind", "[[weather().Wind]]", "weather"), new ServiceOutputMapping("Visibility", "[[Visibility]]", "")
};
dsfWebPostActivity.Outputs = serviceOutputs;
var serviceXml = XmlResource.Fetch("WebService");
var service = new WebService(serviceXml)
{
RequestResponse = response
};
dsfWebPostActivity.OutputDescription = service.GetOutputDescription();
dsfWebPostActivity.ResponseFromWeb = response;
var dataObjectMock = new Mock <IDSFDataObject>();
dataObjectMock.Setup(o => o.Environment).Returns(environment);
dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
dsfWebPostActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty);
var cat = new Mock <IResourceCatalog>();
var src = new WebSource {
Address = "www.example.com"
};
cat.Setup(a => a.GetResource <WebSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(src);
dsfWebPostActivity.ResourceCatalog = cat.Object;
//---------------Assert Precondition----------------
Assert.IsNotNull(environment);
Assert.IsNotNull(dsfWebPostActivity);
//---------------Execute Test ----------------------
var debugInputs = dsfWebPostActivity.GetDebugInputs(environment, 0);
//---------------Test Result -----------------------
Assert.IsNotNull(debugInputs);
Assert.AreEqual(4, debugInputs.Count);
}
public void DsfWebPutActivity_Execute_WithInValidWebResponse_ShouldError()
{
//------------Setup for test--------------------------
const string response = "{\"Location\": \"Paris\",\"Time\": \"May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC\"," +
"\"Wind\": \"from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0\"," +
"\"Visibility\": \"greater than 7 mile(s):0\"," +
"\"Temperature\": \"59 F (15 C)\"," +
"\"DewPoint\": \"41 F (5 C)\"," +
"\"RelativeHumidity\": \"51%\"," +
"\"Pressure\": \"29.65 in. Hg (1004 hPa)\"," +
"\"Status\": \"Success\"" +
"}";
const string invalidResponse = "{\"Location\" \"Paris\",\"Time\": \"May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC\"," +
"\"Wind\": \"from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0\"," +
"\"Visibility\": \"greater than 7 mile(s):0\"," +
"\"Temperature\": \"59 F (15 C)\"," +
"\"DewPoint\": \"41 F (5 C)\"," +
"\"RelativeHumidity\": \"51%\"," +
"\"Pressure\": \"29.65 in. Hg (1004 hPa)\"," +
"\"Status\": \"Success\"" +
"";
var environment = new ExecutionEnvironment();
environment.Assign("[[City]]", "PMB", 0);
environment.Assign("[[CountryName]]", "South Africa", 0);
var DsfWebPutActivity = new TestDsfWebPutActivity
{
ResourceCatalog = new Mock <IResourceCatalog>().Object
};
var serviceInputs = new List <IServiceInput> {
new ServiceInput("CityName", "[[City]]"), new ServiceInput("Country", "[[CountryName]]")
};
var serviceOutputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("Location", "[[weather().Location]]", "weather"), new ServiceOutputMapping("Time", "[[weather().Time]]", "weather"), new ServiceOutputMapping("Wind", "[[weather().Wind]]", "weather"), new ServiceOutputMapping("Visibility", "[[Visibility]]", "")
};
DsfWebPutActivity.Inputs = serviceInputs;
DsfWebPutActivity.Outputs = serviceOutputs;
var serviceXml = XmlResource.Fetch("WebService");
using (var service = new WebService(serviceXml)
{
RequestResponse = response
})
{
DsfWebPutActivity.OutputDescription = service.GetOutputDescription();
DsfWebPutActivity.ResponseFromWeb = invalidResponse;
var dataObjectMock = new Mock <IDSFDataObject>();
dataObjectMock.Setup(o => o.Environment).Returns(environment);
dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
DsfWebPutActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty);
DsfWebPutActivity.QueryString = "";
DsfWebPutActivity.PutData = "";
DsfWebPutActivity.SourceId = Guid.Empty;
DsfWebPutActivity.Headers = new List <INameValue>();
//------------Execute Test---------------------------
DsfWebPutActivity.Execute(dataObjectMock.Object, 0);
//------------Assert Results-------------------------
Assert.IsNotNull(DsfWebPutActivity.OutputDescription);
Assert.AreEqual(1, environment.Errors.Count);
StringAssert.Contains(environment.Errors.ToList()[0], "Invalid character after parsing property name");
}
}
public void HasErrorReturnsFalse()
{
var config = new Configuration.Settings.Configuration(XmlResource.Fetch("Settings"));
Assert.IsFalse(config.HasError);
}
