public void WebPostActivity_CreateClient_GivenWebSourceAuthenticationTypeIsUser_ShouldSetWebClientPasswordAndUserName()
{
//---------------Set up test pack-------------------
var webPostActivity = new TestWebPostActivity
{
QueryString = "http://www.testing.com/[[CountryName]]",
PostData = "This is post:[[Post]]"
};
var webSource = new WebSource {
AuthenticationType = AuthenticationType.User, UserName = "******", Password = "******"
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var webClient = WebPostActivity.CreateClient(null, String.Empty, webSource);
//---------------Test Result -----------------------
Assert.IsNotNull(webClient);
var networkCredentialFromWebSource = new NetworkCredential(webSource.UserName, webSource.Password);
var webClientCredentials = webClient.Credentials as NetworkCredential;
Assert.IsNotNull(webClientCredentials);
Assert.AreEqual(webClientCredentials.UserName, networkCredentialFromWebSource.UserName);
Assert.AreEqual(webClientCredentials.Password, networkCredentialFromWebSource.Password);
}
public void WebPostActivity_Execute_ErrorResponse_ShouldSetVariables()
{
//------------Setup for test--------------------------
const string response = "{\"Message\":\"Error\"}";
var environment = new ExecutionEnvironment();
var webPostActivity = new TestWebPostActivity();
webPostActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty);
var mockResourceCatalog = new Mock <IResourceCatalog>();
var webSource = new WebSource();
webSource.Address = "http://TFSBLD.premier.local:9910/api/";
webSource.AuthenticationType = AuthenticationType.Anonymous;
mockResourceCatalog.Setup(resCat => resCat.GetResource <WebSource>(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(webSource);
webPostActivity.ResourceCatalog = mockResourceCatalog.Object;
var serviceOutputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("Message", "[[Message]]", "")
};
webPostActivity.Outputs = serviceOutputs;
var serviceXml = XmlResource.Fetch("WebService");
var service = new WebService(serviceXml)
{
RequestResponse = response
};
webPostActivity.OutputDescription = service.GetOutputDescription();
webPostActivity.ResponseFromWeb = response;
webPostActivity.QueryString = "Error";
webPostActivity.SourceId = Guid.Empty;
webPostActivity.Headers = new List <INameValue>();
var dataObjectMock = new Mock <IDSFDataObject>();
dataObjectMock.Setup(o => o.Environment).Returns(environment);
dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
webPostActivity.SourceId = Guid.Empty;
webPostActivity.Headers = new List <INameValue>();
webPostActivity.OutputDescription = new OutputDescription();
webPostActivity.OutputDescription.DataSourceShapes.Add(new DataSourceShape()
{
Paths = new List <IPath>()
{
new StringPath()
{
ActualPath = "[[Response]]", OutputExpression = "[[Response]]"
}
}
});
//------------Execute Test---------------------------
webPostActivity.Execute(dataObjectMock.Object, 0);
//------------Assert Results-------------------------
Assert.AreEqual(response, ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[Message]]", 0)));
}
public void WebPostActivity_Execute_WithInputVariables_ShouldEvalVariablesBeforeExecutingWebRequest()
{
//------------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);
environment.Assign("[[Post]]", "Some data", 0);
var webPostActivity = new TestWebPostActivity
{
Headers = new List <INameValue> {
new NameValue("Header 1", "[[City]]")
},
QueryString = "http://www.testing.com/[[CountryName]]",
PostData = "This is post:[[Post]]",
ResourceCatalog = new Mock <IResourceCatalog>().Object,
};
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]]", "")
};
webPostActivity.Outputs = serviceOutputs;
var serviceXml = XmlResource.Fetch("WebService");
var service = new WebService(serviceXml)
{
RequestResponse = response
};
webPostActivity.OutputDescription = service.GetOutputDescription();
webPostActivity.ResponseFromWeb = response;
var dataObjectMock = new Mock <IDSFDataObject>();
dataObjectMock.Setup(o => o.Environment).Returns(environment);
dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
webPostActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty);
//------------Assert Preconditions-------------------
Assert.AreEqual(1, webPostActivity.Headers.Count);
Assert.AreEqual("Header 1", webPostActivity.Headers.ToList()[0].Name);
Assert.AreEqual("[[City]]", webPostActivity.Headers.ToList()[0].Value);
Assert.AreEqual("http://www.testing.com/[[CountryName]]", webPostActivity.QueryString);
Assert.AreEqual("This is post:[[Post]]", webPostActivity.PostData);
//------------Execute Test---------------------------
webPostActivity.Execute(dataObjectMock.Object, 0);
//------------Assert Results-------------------------
Assert.AreEqual("PMB", webPostActivity.Head.ToList()[0].Value);
Assert.AreEqual("http://www.testing.com/South Africa", webPostActivity.QueryRes);
Assert.AreEqual("This is post:Some data", webPostActivity.PostValue);
}
public void WebPostActivity_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 webPostActivity = new TestWebPostActivity
{
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]]", "")
};
webPostActivity.Inputs = serviceInputs;
webPostActivity.Outputs = serviceOutputs;
var serviceXml = XmlResource.Fetch("WebService");
var service = new WebService(serviceXml)
{
RequestResponse = response
};
webPostActivity.OutputDescription = service.GetOutputDescription();
webPostActivity.ResponseFromWeb = response;
var dataObjectMock = new Mock <IDSFDataObject>();
dataObjectMock.Setup(o => o.Environment).Returns(environment);
dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
webPostActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty);
webPostActivity.QueryString = "";
webPostActivity.PostData = "";
webPostActivity.SourceId = Guid.Empty;
webPostActivity.Headers = new List <INameValue>();
//------------Execute Test---------------------------
webPostActivity.Execute(dataObjectMock.Object, 0);
//------------Assert Results-------------------------
Assert.IsNotNull(webPostActivity.OutputDescription);
Assert.AreEqual("<greater than 7 mile(s):0>", ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[Visibility]]", 0)));
Assert.AreEqual("<Paris>", ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Location]]", 0)));
Assert.AreEqual("May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC", ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Time]]", 0)));
Assert.AreEqual("from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0", ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Wind]]", 0)));
}
public void WebPostActivity_Execute_WithValidWebResponse_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 webPostActivity = new TestWebPostActivity();
webPostActivity.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]]", "")
};
webPostActivity.Inputs = serviceInputs;
webPostActivity.Outputs = serviceOutputs;
var serviceXml = XmlResource.Fetch("WebService");
var service = new WebService(serviceXml)
{
RequestResponse = response
};
webPostActivity.OutputDescription = service.GetOutputDescription();
webPostActivity.ResponseFromWeb = response;
var dataObjectMock = new Mock <IDSFDataObject>();
dataObjectMock.Setup(o => o.Environment).Returns(environment);
dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
webPostActivity.ResourceID = InArgument <Guid> .FromValue(Guid.Empty);
webPostActivity.QueryString = "";
webPostActivity.PostData = "";
webPostActivity.SourceId = Guid.Empty;
webPostActivity.Headers = new List <INameValue>();
//------------Execute Test---------------------------
webPostActivity.Execute(dataObjectMock.Object, 0);
//------------Assert Results-------------------------
Assert.IsNotNull(webPostActivity.OutputDescription);
Assert.AreEqual("greater than 7 mile(s):0", ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[Visibility]]", 0)));
Assert.AreEqual("Paris", ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Location]]", 0)));
Assert.AreEqual("May 29, 2013 - 09:00 AM EDT / 2013.05.29 1300 UTC", ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Time]]", 0)));
Assert.AreEqual("from the NW (320 degrees) at 10 MPH (9 KT) (direction variable):0", ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval("[[weather().Wind]]", 0)));
}
public void WebPostActivity_GetDebugInputs_GivenEnvironmentIsNull_ShouldReturnZeroDebugInputs()
{
//---------------Set up test pack-------------------
var webPostActivity = new TestWebPostActivity();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var debugInputs = webPostActivity.GetDebugInputs(null, 0);
//---------------Test Result -----------------------
Assert.AreEqual(0, debugInputs.Count);
}
public void WebPostActivity_GetFindMissingType_GivenWebPostActivity_ShouldReturnMissingTypeDataGridActivity()
{
//---------------Set up test pack-------------------
var webPostActivity = new TestWebPostActivity();
//---------------Assert Precondition----------------
Assert.IsNotNull(webPostActivity.Type);
Assert.IsNotNull(webPostActivity);
//---------------Execute Test ----------------------
//---------------Test Result -----------------------
Assert.AreEqual(enFindMissingType.DataGridActivity, webPostActivity.GetFindMissingType());
}
public void WebPostActivity_Constructor_GivenHasInstance_ShouldHaveType()
{
//---------------Set up test pack-------------------
var webPostActivity = new TestWebPostActivity();
//---------------Assert Precondition----------------
Assert.IsNotNull(webPostActivity);
//---------------Execute Test ----------------------
//---------------Test Result -----------------------
Assert.IsNotNull(webPostActivity.Type);
}
public void WebPostActivity_CreateClient_GivenNoHeaders_ShouldGlobalConstantsUserAgent()
{
//---------------Set up test pack-------------------
var webPostActivity = new TestWebPostActivity
{
QueryString = "http://www.testing.com/[[CountryName]]",
PostData = "This is post:[[Post]]"
};
var webClient = WebPostActivity.CreateClient(null, String.Empty, new WebSource());
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var userAgentValue = webClient.Headers[_userAgent];
//---------------Test Result -----------------------
Assert.AreEqual(userAgentValue, GlobalConstants.UserAgentString);
}
public void WebPostActivity_CreateClient_GivenNoHeaders_ShouldHaveTwoHeaders()
{
//---------------Set up test pack-------------------
var webPostActivity = new TestWebPostActivity
{
QueryString = "http://www.testing.com/[[CountryName]]",
PostData = "This is post:[[Post]]"
};
//---------------Assert Precondition----------------
Assert.IsNotNull(webPostActivity);
//---------------Execute Test ----------------------
var webClient = WebPostActivity.CreateClient(null, String.Empty, new WebSource());
//---------------Test Result -----------------------
var actualHeaderCount = webClient.Headers.Count;
Assert.AreEqual(1, actualHeaderCount);
}
public void WebPostActivity_CreateClient_GivenAuthenticationTypeIsNotUser_ShouldNotSetCredentials()
{
//---------------Set up test pack-------------------
var webPostActivity = new TestWebPostActivity
{
QueryString = "http://www.testing.com/[[CountryName]]",
PostData = "This is post:[[Post]]"
};
var webSource = new WebSource {
AuthenticationType = AuthenticationType.Windows, UserName = "******", Password = "******"
};
var webClient = WebPostActivity.CreateClient(null, String.Empty, webSource);
//---------------Assert Precondition----------------
Assert.IsNotNull(webClient);
//---------------Execute Test ----------------------
//---------------Test Result -----------------------
Assert.IsNull(webClient.Credentials);
}
public void WebPostActivity_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 TestWebPostActivity
{
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(response, errorResultTO.FetchErrors()[0]);
}
}
public void WebPostActivity_CreateClient_GivenHeaders_ShouldHaveHeadersAdded()
{
//---------------Set up test pack-------------------
var webPostActivity = new TestWebPostActivity
{
QueryString = "http://www.testing.com/[[CountryName]]",
PostData = "This is post:[[Post]]"
};
var headers = new List <INameValue>
{
new NameValue("Content", "text/json")
};
//---------------Assert Precondition----------------
Assert.IsNotNull(webPostActivity);
//---------------Execute Test ----------------------
var webClient = WebPostActivity.CreateClient(headers, String.Empty, new WebSource());
//---------------Test Result -----------------------
var actualHeaderCount = webClient.Headers.Count;
Assert.AreEqual(2, actualHeaderCount);
Assert.AreEqual("text/json", webClient.Headers["Content"]);
}
public void WebPostActivity_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 TestWebPostActivity
{
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(recordSet, 0);
var ress = envirVariable as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
Assert.IsNotNull(envirVariable);
Assert.IsFalse(ress.Item.IsNothing, "Item should contain the recset mapped to the messanger key");
}
}
public void WebPostActivity_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 webPostActivity = new TestWebPostActivity
{
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]]", "")
};
webPostActivity.Outputs = serviceOutputs;
var serviceXml = XmlResource.Fetch("WebService");
var service = new WebService(serviceXml)
{
RequestResponse = response
};
webPostActivity.OutputDescription = service.GetOutputDescription();
webPostActivity.ResponseFromWeb = response;
var dataObjectMock = new Mock <IDSFDataObject>();
dataObjectMock.Setup(o => o.Environment).Returns(environment);
dataObjectMock.Setup(o => o.EsbChannel).Returns(new Mock <IEsbChannel>().Object);
webPostActivity.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);
webPostActivity.ResourceCatalog = cat.Object;
//---------------Assert Precondition----------------
Assert.IsNotNull(environment);
Assert.IsNotNull(webPostActivity);
//---------------Execute Test ----------------------
var debugInputs = webPostActivity.GetDebugInputs(environment, 0);
//---------------Test Result -----------------------
Assert.IsNotNull(debugInputs);
Assert.AreEqual(4, debugInputs.Count);
}
