public void testAccountUpdate()
{
AccountUpdate accountUpdate = new AccountUpdate();
accountUpdate.ReportGroup = "Planets";
accountUpdate.OrderId = "12344";
CardType card = new CardType();
card.Type = MethodOfPaymentTypeEnum.VI;
card.Number = "4100000000000002";
card.ExpDate = "1210";
accountUpdate.Card = card;
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<accountUpdateResponse reportGroup=\"Merch01ReportGrp\" xmlns=\"http://www.litle.com/schema\"><litleTxnId>123</litleTxnId><orderId>MERCH01-0002</orderId><response>000</response><responseTime>2010-04-11T15:44:26</responseTime><message>Approved</message></accountUpdateResponse>")
.Returns("<accountUpdateResponse reportGroup=\"Merch01ReportGrp\" xmlns=\"http://www.litle.com/schema\"><litleTxnId>124</litleTxnId><orderId>MERCH01-0002</orderId><response>000</response><responseTime>2010-04-11T15:44:26</responseTime><message>Approved</message></accountUpdateResponse>");
BatchResponse mockLitleBatchResponse = new BatchResponse();
mockLitleBatchResponse.SetAccountUpdateResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
Communications mockedCommunication = mockCommunications.Object;
litle.SetCommunication(mockedCommunication);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddAccountUpdate(accountUpdate);
litleBatchRequest.AddAccountUpdate(accountUpdate);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
AccountUpdateResponse actualAccountUpdateResponse1 = actualLitleBatchResponse.NextAccountUpdateResponse();
AccountUpdateResponse actualAccountUpdateResponse2 = actualLitleBatchResponse.NextAccountUpdateResponse();
AccountUpdateResponse nullAccountUpdateResponse = actualLitleBatchResponse.NextAccountUpdateResponse();
Assert.AreEqual(123, actualAccountUpdateResponse1.LitleTxnId);
Assert.AreEqual("000", actualAccountUpdateResponse1.Response);
Assert.AreEqual(124, actualAccountUpdateResponse2.LitleTxnId);
Assert.AreEqual("000", actualAccountUpdateResponse2.Response);
Assert.IsNull(nullAccountUpdateResponse);
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void TestDeleteItemProperty()
{
Object resp2;
Request[] requests = new Request[] {
new DeleteItemProperty("int_property"),
new DeleteItemProperty("int_property"),
new DeleteItemProperty("***not_valid$$$"),
new DeleteItemProperty("not_existing")
};
BatchResponse batchResponse = client.Send(new Batch(requests));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(404, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(400, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(404, (int)batchResponse.StatusCodes.ElementAt(3));
}
public async void TestListSearchSynonymsAsync()
{
Object resp2;
System.Threading.Thread.Sleep(10000);
resp2 = await client.SendAsync(new AddSearchSynonym("sci-fi", "science fiction"));
Request[] requests = new Request[] {
new ListSearchSynonyms(),
new ListSearchSynonyms(count: 10, offset: 1)
};
BatchResponse batchResponse = await client.SendAsync(new Batch(requests));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(1, ((ListSearchSynonymsResponse)batchResponse[0]).Synonyms.Count());
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(0, ((ListSearchSynonymsResponse)batchResponse[1]).Synonyms.Count());
}
public void TestItemBasedRecommendation()
{
Request[] requests = new Request[] {
new ItemBasedRecommendation("entity_id", 9),
new ItemBasedRecommendation("nonexisting", 9, cascadeCreate: true),
new ItemBasedRecommendation("nonexisting2", 9, cascadeCreate: true, expertSettings: new Dictionary <string, object>()
{
})
};
BatchResponse batchResponse = client.Send(new Batch(requests));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(9, ((IEnumerable <Recommendation>)batchResponse[0]).Count());
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(9, ((IEnumerable <Recommendation>)batchResponse[1]).Count());
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(9, ((IEnumerable <Recommendation>)batchResponse[2]).Count());
}
private async Task <bool> ConstainsSplitIsTrueInternal(HttpStatusCode statusCode, SubStatusCodes subStatusCode)
{
List <BatchOperationResult> results = new List <BatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.AddComputeGatewayRequestCharges, 0, "0");
results.Add(
new BatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
maxBodyLength : 100,
maxOperationCount : 1,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : default(CancellationToken));
ResponseMessage response = new ResponseMessage(statusCode)
{
Content = responseContent
};
response.Headers.SubStatusCode = subStatusCode;
BatchResponse batchresponse = await BatchResponse.PopulateFromContentAsync(
response,
batchRequest,
new CosmosJsonDotNetSerializer());
PartitionKeyRangeBatchExecutionResult result = new PartitionKeyRangeBatchExecutionResult("0", arrayOperations, batchresponse);
return(result.IsSplit());
}
public async void TestAddUserProperty()
{
Request[] requests =
{
new AddUserProperty("number", "int"),
new AddUserProperty("str", "string"),
new AddUserProperty("prop", "integer"),
new AddUserProperty("number2", "int"),
new AddUserProperty("number2", "int")
};
BatchResponse batchResponse = await client.SendAsync(new Batch(requests));
Assert.Equal(201, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(201, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(400, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(201, (int)batchResponse.StatusCodes.ElementAt(3));
Assert.Equal(409, (int)batchResponse.StatusCodes.ElementAt(4));
}
public async void TestSearchItemsAsync()
{
Object resp2;
Request[] requests = new Request[] {
new SearchItems("entity_id", "hell", 9),
new SearchItems("entity_id", "sdhskldf", 9),
new SearchItems("entity_id", "hell", 9, returnProperties: true)
};
BatchResponse batchResponse = await client.SendAsync(new Batch(requests));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(1, ((SearchResponse)batchResponse[0]).Recomms.Count());
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(0, ((SearchResponse)batchResponse[1]).Recomms.Count());
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(1, ((SearchResponse)batchResponse[2]).Recomms.Count());
}
public async Task GivenBatchRequest_WhenSentToOneHost_ReceiveTwoResults()
{
TestFrontendHost host = TestApplication.StartHosts();
var batchRequest = new BatchRequest
{
Request = "I am happy",
Models = TestApplication.ModelNames.Select(x => new ModelRequest
{
ModelName = x,
IntentLimit = 1,
}).ToList(),
};
PostResponse <BatchResponse> response = await new FrontEndRestApi(host.HttpClient).PostRequest(batchRequest);
response.Should().NotBeNull();
response.StatusCode.Should().Be(HttpStatusCode.OK);
BatchResponse batchResponse = response.Value !;
batchResponse.Should().NotBeNull();
batchResponse.Request.Should().Be(batchRequest.Request);
batchResponse.Responses.Should().NotBeNull();
batchResponse.Responses !.Count.Should().Be(TestApplication.ModelNames.Count);
batchResponse.Responses.All(x => x?.Model?.Name.ToNullIfEmpty() != null).Should().BeTrue();
TestApplication.ModelNames.OrderBy(x => x)
.Zip(batchResponse.Responses.OrderBy(x => x !.Model !.Name), (versionId, batchResponse) => (versionId, batchResponse))
.ForEach(x =>
{
x.batchResponse.Should().NotBeNull();
x.batchResponse !.Model.Should().NotBeNull();
x.batchResponse.Model !.Name.Should().Be(x.versionId);
x.batchResponse.Model.Version.Should().Be("1.0");
x.batchResponse.Request.Should().Be(batchRequest.Request);
x.batchResponse.Intents.Should().NotBeNull();
x.batchResponse.Intents.Count().Should().Be(1);
x.batchResponse.Intents.First().Label.Should().Be("HAPPINESS");
x.batchResponse.Intents.First().Score.Should().Be(0.9824827);
});
}
public void SomeResponse()
{
var responses = new SendResponse[]
{
SendResponse.FromMessageId("message1"),
SendResponse.FromMessageId("message2"),
SendResponse.FromException(
new FirebaseException(
"error-message",
null)),
};
var batchResponse = new BatchResponse(responses);
Assert.Equal(2, batchResponse.SuccessCount);
Assert.Equal(1, batchResponse.FailureCount);
Assert.Equal(3, batchResponse.Responses.Count);
Assert.True(responses.SequenceEqual(batchResponse.Responses));
}
public void TestAddItemProperty()
{
Object resp2;
Request[] requests = new Request[] {
new AddItemProperty("number", "int"),
new AddItemProperty("str", "string"),
new AddItemProperty("prop", "integer"),
new AddItemProperty("number2", "int"),
new AddItemProperty("number2", "int")
};
BatchResponse batchResponse = client.Send(new Batch(requests));
Assert.Equal(201, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(201, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(400, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(201, (int)batchResponse.StatusCodes.ElementAt(3));
Assert.Equal(409, (int)batchResponse.StatusCodes.ElementAt(4));
}
public async void TestInsertToSeriesAsync()
{
Request[] requests = new Request[] {
new AddItem("new_item"),
new InsertToSeries("entity_id", "item", "new_item", 3),
new InsertToSeries("new_set", "item", "new_item2", 1, cascadeCreate: true),
new AddItem("new_item3"),
new InsertToSeries("entity_id", "item", "new_item3", 2),
new InsertToSeries("entity_id", "item", "new_item3", 2)
};
BatchResponse batchResponse = await client.SendAsync(new Batch(requests));
Assert.Equal(201, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(201, (int)batchResponse.StatusCodes.ElementAt(3));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(4));
Assert.Equal(409, (int)batchResponse.StatusCodes.ElementAt(5));
}
public void TestInsertToGroup()
{
Request[] requests = new Request[] {
new AddItem("new_item"),
new InsertToGroup("entity_id", "item", "new_item"),
new InsertToGroup("new_set", "item", "new_item2", cascadeCreate: true),
new AddItem("new_item3"),
new InsertToGroup("entity_id", "item", "new_item3"),
new InsertToGroup("entity_id", "item", "new_item3")
};
BatchResponse batchResponse = client.Send(new Batch(requests));
Assert.Equal(201, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(201, (int)batchResponse.StatusCodes.ElementAt(3));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(4));
Assert.Equal(409, (int)batchResponse.StatusCodes.ElementAt(5));
}
public async void TestSetItemValuesAsync()
{
Object resp2;
Request[] requests = new Request[] {
new SetItemValues("entity_id", new Dictionary <string, object>()
{
{ "int_property", 5 }
}),
new SetItemValues("entity_id", new Dictionary <string, object>()
{
{ "str_property", "šřžذ的" }
}),
new SetItemValues("entity_id", new Dictionary <string, object>()
{
{ "int_property", 5 }, { "str_property", "test" }
}),
new SetItemValues("new_entity", new Dictionary <string, object>()
{
{ "int_property", 5 }, { "str_property", "test" }, { "!cascadeCreate", true }
}),
new SetItemValues("new_entity2", new Dictionary <string, object>()
{
{ "int_property", 5 }, { "str_property", "test" }
}, cascadeCreate: true),
new SetItemValues("nonexisting", new Dictionary <string, object>()
{
{ "int_property", 5 }
})
};
BatchResponse batchResponse = await client.SendAsync(new Batch(requests));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(3));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(4));
Assert.Equal(404, (int)batchResponse.StatusCodes.ElementAt(5));
}
public void TestInsertToSeries()
{
Object resp2;
resp2 = client.Send(new AddItem("new_item"));
resp2 = client.Send(new AddItem("new_item3"));
Request[] requests = new Request[] {
new InsertToSeries("entity_id", "item", "new_item", 3),
new InsertToSeries("new_set", "item", "new_item2", 1, cascadeCreate: true),
new InsertToSeries("entity_id", "item", "new_item3", 2),
new InsertToSeries("entity_id", "item", "new_item3", 2)
};
BatchResponse batchResponse = client.Send(new Batch(requests));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(409, (int)batchResponse.StatusCodes.ElementAt(3));
}
public async Task BatchReadsOnlyAsync()
{
Container container = BatchTestBase.JsonContainer;
await this.CreateJsonTestDocsAsync(container);
BatchResponse batchResponse = await new BatchCore((ContainerCore)container, BatchTestBase.GetPartitionKey(this.PartitionKey1))
.ReadItem(this.TestDocPk1ExistingA.Id)
.ReadItem(this.TestDocPk1ExistingB.Id)
.ReadItem(this.TestDocPk1ExistingC.Id)
.ExecuteAsync();
BatchSinglePartitionKeyTests.VerifyBatchProcessed(batchResponse, numberOfOperations: 3);
Assert.AreEqual(HttpStatusCode.OK, batchResponse[0].StatusCode);
Assert.AreEqual(HttpStatusCode.OK, batchResponse[1].StatusCode);
Assert.AreEqual(HttpStatusCode.OK, batchResponse[2].StatusCode);
Assert.AreEqual(this.TestDocPk1ExistingA, batchResponse.GetOperationResultAtIndex <TestDoc>(0).Resource);
Assert.AreEqual(this.TestDocPk1ExistingB, batchResponse.GetOperationResultAtIndex <TestDoc>(1).Resource);
Assert.AreEqual(this.TestDocPk1ExistingC, batchResponse.GetOperationResultAtIndex <TestDoc>(2).Resource);
}
public async void TestInsertToGroupAsync()
{
Object resp2;
resp2 = await client.SendAsync(new AddItem("new_item"));
resp2 = await client.SendAsync(new AddItem("new_item3"));
Request[] requests = new Request[] {
new InsertToGroup("entity_id", "item", "new_item"),
new InsertToGroup("new_set", "item", "new_item2", cascadeCreate: true),
new InsertToGroup("entity_id", "item", "new_item3"),
new InsertToGroup("entity_id", "item", "new_item3")
};
BatchResponse batchResponse = await client.SendAsync(new Batch(requests));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(409, (int)batchResponse.StatusCodes.ElementAt(3));
}
public void TestSetViewPortion()
{
Request[] requests = new Request[] {
new SetViewPortion("u_id", "i_id", 1, cascadeCreate: true),
new SetViewPortion("entity_id", "entity_id", 0),
new SetViewPortion("entity_id", "nonex_id", 1),
new SetViewPortion("nonex_id", "entity_id", 0.5),
new SetViewPortion("entity_id", "entity_id", 0, timestamp: UnixTimeStampToDateTime(-15)),
new SetViewPortion("entity_id", "entity_id", -2),
new SetViewPortion("entity_id", "entity_id", 0.7, sessionId: "a****")
};
BatchResponse batchResponse = client.Send(new Batch(requests));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(404, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(404, (int)batchResponse.StatusCodes.ElementAt(3));
Assert.Equal(400, (int)batchResponse.StatusCodes.ElementAt(4));
Assert.Equal(400, (int)batchResponse.StatusCodes.ElementAt(5));
Assert.Equal(400, (int)batchResponse.StatusCodes.ElementAt(6));
}
//---------------------------------------------------------------------
public BatchResponse SendAndVerify(params AstoriaRequest[] requests)
{
// Populate batch.
BatchChangeset cs = base.GetChangeset();
foreach (var r in requests)
{
if (r == null) // Begin new changeset.
{
cs = base.GetChangeset();
}
else
{
// Expect no dummy etags from stream provider for batched requests.
r.ETagHeaderExpected = false;
if (r.Verb == RequestVerb.Get) // Add request to batch.
{
r.ContentType = null;
base.Add(r, true);
}
else // Add request to current changeset.
{
if (r.Verb == RequestVerb.Delete)
{
r.ContentType = null;
}
cs.Add(r, true);
}
}
}
// Send and verify batch request. SendAndVerify() logic not applied.
BatchResponse response = base.GetResponse() as BatchResponse;
response.Verify();
return(response);
}
private directoryRequestResponse callClient(dsmlSoapClient client, directoryRequestRequest mainRequest)
{
directoryRequestResponse response = null;
try
{
response = client.directoryRequest(mainRequest);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Problem calling client: " + e);
}
System.Diagnostics.Debug.WriteLine("Response: " + response);
if (response != null)
{
BatchResponse bResponse = response.batchResponse;
Object[] responseItems = bResponse.Items;
if (responseItems != null)
{
if (responseItems is ErrorResponse[])
{
for (int i = 0; i < responseItems.Length; i++)
{
ErrorResponse eResponse = (ErrorResponse)responseItems[i];
System.Diagnostics.Debug.WriteLine(eResponse.message);
System.Diagnostics.Debug.WriteLine(eResponse.detail);
System.Diagnostics.Debug.WriteLine(eResponse.type);
}
}
else
{
System.Diagnostics.Debug.WriteLine("Hooray no errors on response from calling client directory request");
}
}
}
return(response);
}
public async Task DiagnosticsAreSetThroughResponseAsync()
{
List <BatchOperationResult> results = new List <BatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.AddComputeGatewayRequestCharges, 0, "0");
results.Add(
new BatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
maxBodyLength : 100,
maxOperationCount : 1,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : default(CancellationToken));
CosmosDiagnostics diagnostics = new PointOperationStatistics(HttpStatusCode.OK, SubStatusCodes.Unknown, 0, string.Empty, HttpMethod.Get, new Uri("http://localhost"), new CosmosClientSideRequestStatistics());
BatchResponse batchresponse = await BatchResponse.PopulateFromContentAsync(
new ResponseMessage(HttpStatusCode.OK) { Content = responseContent, Diagnostics = diagnostics },
batchRequest,
new CosmosJsonDotNetSerializer());
PartitionKeyRangeBatchResponse response = new PartitionKeyRangeBatchResponse(arrayOperations.Length, batchresponse, new CosmosJsonDotNetSerializer());
Assert.AreEqual(diagnostics, response.Diagnostics);
}
public void TestAddDetailView()
{
Request[] requests = new Request[] {
new AddDetailView("u_id", "i_id", cascadeCreate: true),
new AddDetailView("entity_id", "entity_id"),
new AddDetailView("entity_id", "entity_id", timestamp: ParseDateTime("2013-10-29T09:38:41.341Z")),
new AddDetailView("entity_id", "nonex_id"),
new AddDetailView("nonex_id", "entity_id"),
new AddDetailView("entity_id", "entity_id", timestamp: UnixTimeStampToDateTime(-15)),
new AddDetailView("u_id2", "i_id2", cascadeCreate: true, timestamp: UnixTimeStampToDateTime(5)),
new AddDetailView("u_id2", "i_id2", cascadeCreate: true, timestamp: UnixTimeStampToDateTime(5))
};
BatchResponse batchResponse = client.Send(new Batch(requests));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(404, (int)batchResponse.StatusCodes.ElementAt(3));
Assert.Equal(404, (int)batchResponse.StatusCodes.ElementAt(4));
Assert.Equal(400, (int)batchResponse.StatusCodes.ElementAt(5));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(6));
Assert.Equal(409, (int)batchResponse.StatusCodes.ElementAt(7));
}
public void TestAddRating()
{
Request[] requests = new Request[] {
new AddRating("u_id", "i_id", 1, cascadeCreate: true),
new AddRating("entity_id", "entity_id", 0),
new AddRating("entity_id", "nonex_id", -1),
new AddRating("nonex_id", "entity_id", 0.5),
new AddRating("entity_id", "entity_id", 0, timestamp: UnixTimeStampToDateTime(-15)),
new AddRating("entity_id", "entity_id", -2),
new AddRating("u_id", "i_id", 0.3, cascadeCreate: true, timestamp: UnixTimeStampToDateTime(5)),
new AddRating("u_id", "i_id", 0.3, cascadeCreate: true, timestamp: UnixTimeStampToDateTime(5))
};
BatchResponse batchResponse = client.Send(new Batch(requests));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(0));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(1));
Assert.Equal(404, (int)batchResponse.StatusCodes.ElementAt(2));
Assert.Equal(404, (int)batchResponse.StatusCodes.ElementAt(3));
Assert.Equal(400, (int)batchResponse.StatusCodes.ElementAt(4));
Assert.Equal(400, (int)batchResponse.StatusCodes.ElementAt(5));
Assert.Equal(200, (int)batchResponse.StatusCodes.ElementAt(6));
Assert.Equal(409, (int)batchResponse.StatusCodes.ElementAt(7));
}
public async System.Threading.Tasks.Task TestBatch()
{
IUserRequest meRequest = graphClient.Me.Request();
IGraphServiceUsersCollectionRequest newUserRequest = graphClient.Users.Request(); // We have the ./users URL, query parameters, and request headers.
User newUser = new User();
newUser.DisplayName = "New User";
newUser.UserPrincipalName = "*****@*****.**";
IDirectoryObjectWithReferenceRequest managerRequest = graphClient.Me.Manager.Request(); // We have the /me/manager URL, query parameters, and request headers.
IDriveItemChildrenCollectionRequest driveRequest = graphClient.Me.Drive.Root.Children.Request(); // We have the /me/drive/root/children URL, query parameters, and request headers.
IEducationRootRequest eduRequest = graphClient.Education.Request(); // We have the /education URL, query parameters, and request headers.
BatchContainer batchContainer = new BatchContainer();
BatchPart part1 = batchContainer.AddToBatch(meRequest, Method.GET); // I don't think we need a copy of the BatchPart.
batchContainer.AddToBatch(driveRequest, Method.GET);
batchContainer.AddToBatch(eduRequest, Method.GET);
batchContainer.AddToBatch(newUserRequest, Method.POST, 4, newUser, new BatchPart[] { part1 }); // We have to use reflection to determine which HttpVerb method we are using, and then, what
// the return type will be. This might be costly batch scenario can contain a large number
BatchResponse response = await graphClient.Batch.PostAsync(batchContainer); // of requests across many batches. I think we want to avoid reflection.
User me = (User)response.batchResponses.Where(i => i.id == 1).First().body; // No auto-deserialization.
User me2 = (User)response.batchResponses.Where(i => i.body.GetType() == typeof(User)).FirstOrDefault().body;
foreach (BatchResponsePart part in response.batchResponses)
{
var responseItem = part.body; // If we deserialize into a dynamic object, the customer would have
int statusCode = part.status;
}
Assert.IsNotNull(me.UserPrincipalName);
}
public void testAuthReversal()
{
AuthReversal authreversal = new AuthReversal();
authreversal.LitleTxnId = 12345678000;
authreversal.Amount = 106;
authreversal.PayPalNotes = "Notes";
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<authReversalResponse id=\"123\" customerId=\"Customer Id\" reportGroup=\"Auth Reversals\" xmlns=\"http://www.litle.com/schema\"><litleTxnId>123</litleTxnId><orderId>abc123</orderId><response>000</response><responseTime>2011-08-30T13:15:43</responseTime><message>Approved</message></authReversalResponse>")
.Returns("<authReversalResponse id=\"123\" customerId=\"Customer Id\" reportGroup=\"Auth Reversals\" xmlns=\"http://www.litle.com/schema\"><litleTxnId>124</litleTxnId><orderId>abc123</orderId><response>000</response><responseTime>2011-08-30T13:15:43</responseTime><message>Approved</message></authReversalResponse>");
BatchResponse mockLitleBatchResponse = new BatchResponse();
mockLitleBatchResponse.SetAuthReversalResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
Communications mockedCommunications = mockCommunications.Object;
litle.SetCommunication(mockedCommunications);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddAuthReversal(authreversal);
litleBatchRequest.AddAuthReversal(authreversal);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
AuthReversalResponse actualAuthReversalResponse1 = actualLitleBatchResponse.NextAuthReversalResponse();
AuthReversalResponse actualAuthReversalResponse2 = actualLitleBatchResponse.NextAuthReversalResponse();
AuthReversalResponse nullAuthReversalResponse = actualLitleBatchResponse.NextAuthReversalResponse();
Assert.AreEqual(123, actualAuthReversalResponse1.LitleTxnId);
Assert.AreEqual(124, actualAuthReversalResponse2.LitleTxnId);
Assert.IsNull(nullAuthReversalResponse);
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void testCapture()
{
Capture capture = new Capture();
capture.LitleTxnId = 12345678000;
capture.Amount = 106;
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<captureResponse id=\"123\" reportGroup=\"RG27\" xmlns=\"http://www.litle.com/schema\"> <litleTxnId>123</litleTxnId> <orderId>12z58743y1</orderId> <response>000</response> <responseTime>2011-09-01T10:24:31</responseTime> <message>message</message> </captureResponse>")
.Returns("<captureResponse id=\"124\" reportGroup=\"RG27\" xmlns=\"http://www.litle.com/schema\"> <litleTxnId>124</litleTxnId> <orderId>12z58743y1</orderId> <response>000</response> <responseTime>2011-09-01T10:24:31</responseTime> <message>message</message> </captureResponse>");
BatchResponse mockedLitleBatchResponse = new BatchResponse();
mockedLitleBatchResponse.SetCaptureResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockedLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
Communications mockedCommunications = mockCommunications.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetCommunication(mockedCommunications);
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddCapture(capture);
litleBatchRequest.AddCapture(capture);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
CaptureResponse actualCaptureResponse1 = actualLitleBatchResponse.NextCaptureResponse();
CaptureResponse actualCaptureResponse2 = actualLitleBatchResponse.NextCaptureResponse();
CaptureResponse nullCaptureResponse = actualLitleBatchResponse.NextCaptureResponse();
Assert.AreEqual(123, actualCaptureResponse1.LitleTxnId);
Assert.AreEqual(124, actualCaptureResponse2.LitleTxnId);
Assert.IsNull(nullCaptureResponse);
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void testCreatePlan()
{
CreatePlan createPlan = new CreatePlan();
createPlan.PlanCode = "thePlanCode";
createPlan.Name = "theName";
createPlan.IntervalType = IntervalType.Annual;
createPlan.Amount = 100;
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<createPlanResponse xmlns=\"http://www.litle.com/schema\"><litleTxnId>123</litleTxnId></createPlanResponse>")
.Returns("<createPlanResponse xmlns=\"http://www.litle.com/schema\"><litleTxnId>124</litleTxnId></createPlanResponse>");
BatchResponse mockLitleBatchResponse = new BatchResponse();
mockLitleBatchResponse.SetCreatePlanResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
Communications mockedCommunication = mockCommunications.Object;
litle.SetCommunication(mockedCommunication);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddCreatePlan(createPlan);
litleBatchRequest.AddCreatePlan(createPlan);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
Assert.AreSame(mockLitleBatchResponse, actualLitleBatchResponse);
Assert.AreEqual("123", actualLitleBatchResponse.NextCreatePlanResponse().LitleTxnId);
Assert.AreEqual("124", actualLitleBatchResponse.NextCreatePlanResponse().LitleTxnId);
Assert.IsNull(actualLitleBatchResponse.NextCreatePlanResponse());
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void testCredit()
{
Credit credit = new Credit();
credit.OrderId = "12344";
credit.Amount = 106;
credit.OrderSource = OrderSourceType.Ecommerce;
CardType card = new CardType();
card.Type = MethodOfPaymentTypeEnum.VI;
card.Number = "4100000000000001";
card.ExpDate = "1210";
credit.Card = card;
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<creditResponse xmlns='http://www.litle.com/schema'><litleTxnId>123</litleTxnId></creditResponse>")
.Returns("<creditResponse xmlns='http://www.litle.com/schema'><litleTxnId>124</litleTxnId></creditResponse>");
BatchResponse mockedLitleBatchResponse = new BatchResponse();
mockedLitleBatchResponse.SetCreditResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockedLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
Communications mockedCommunications = mockCommunications.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetCommunication(mockedCommunications);
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddCredit(credit);
litleBatchRequest.AddCredit(credit);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
CreditResponse actualCreditReponse1 = actualLitleBatchResponse.NextCreditResponse();
CreditResponse actualCreditReponse2 = actualLitleBatchResponse.NextCreditResponse();
CreditResponse nullCreditReponse1 = actualLitleBatchResponse.NextCreditResponse();
Assert.AreEqual(123, actualCreditReponse1.LitleTxnId);
Assert.AreEqual(124, actualCreditReponse2.LitleTxnId);
Assert.IsNull(nullCreditReponse1);
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void testEcheckPreNoteSale()
{
EcheckPreNoteSale echeckPreNoteSale = new EcheckPreNoteSale();
echeckPreNoteSale.OrderId = "12345";
echeckPreNoteSale.OrderSource = OrderSourceType.Ecommerce;
EcheckType echeck = new EcheckType();
echeck.AccType = EcheckAccountTypeEnum.Checking;
echeck.AccNum = "12345657890";
echeck.RoutingNum = "123456789";
echeck.CheckNum = "123455";
echeckPreNoteSale.Echeck = echeck;
Contact contact = new Contact();
contact.Name = "Bob";
contact.City = "lowell";
contact.State = "MA";
contact.Email = "litle.com";
echeckPreNoteSale.BillToAddress = contact;
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<echeckPreNoteSaleResponse xmlns='http://www.litle.com/schema'><litleTxnId>123</litleTxnId></echeckPreNoteSaleResponse>")
.Returns("<echeckPreNoteSaleResponse xmlns='http://www.litle.com/schema'><litleTxnId>124</litleTxnId></echeckPreNoteSaleResponse>");
BatchResponse mockedLitleBatchResponse = new BatchResponse();
mockedLitleBatchResponse.SetEcheckPreNoteSaleResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockedLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
Communications mockedCommunications = mockCommunications.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetCommunication(mockedCommunications);
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddEcheckPreNoteSale(echeckPreNoteSale);
litleBatchRequest.AddEcheckPreNoteSale(echeckPreNoteSale);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
EcheckPreNoteSaleResponse actualEcheckPreNoteSaleResponse1 = actualLitleBatchResponse.NextEcheckPreNoteSaleResponse();
EcheckPreNoteSaleResponse actualEcheckPreNoteSaleResponse2 = actualLitleBatchResponse.NextEcheckPreNoteSaleResponse();
EcheckPreNoteSaleResponse nullEcheckPreNoteSalesResponse = actualLitleBatchResponse.NextEcheckPreNoteSaleResponse();
Assert.AreEqual(123, actualEcheckPreNoteSaleResponse1.LitleTxnId);
Assert.AreEqual(124, actualEcheckPreNoteSaleResponse2.LitleTxnId);
Assert.IsNull(nullEcheckPreNoteSalesResponse);
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public async Task <bool> SendBulkAsync(string[] registeredUserDeviceTokens, string title, string body)
{
BatchResponse result = await _firebaseMessaging.SendMulticastAsync(Notification(registeredUserDeviceTokens, title, body));
return(result.SuccessCount > 0);
}
public void testCancelSubscription()
{
CancelSubscription cancel = new CancelSubscription();
cancel.SubscriptionId = 12345;
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<cancelSubscriptionResponse xmlns=\"http://www.litle.com/schema\"><litleTxnId>54321</litleTxnId><response>000</response><message>Approved</message><responseTime>2013-09-04T21:55:14</responseTime><subscriptionId>12345</subscriptionId></cancelSubscriptionResponse>")
.Returns("<cancelSubscriptionResponse xmlns=\"http://www.litle.com/schema\"><litleTxnId>12345</litleTxnId><response>000</response><message>Approved</message><responseTime>2013-09-04T21:55:14</responseTime><subscriptionId>54321</subscriptionId></cancelSubscriptionResponse>");
BatchResponse mockLitleBatchResponse = new BatchResponse();
mockLitleBatchResponse.SetCancelSubscriptionResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
Communications mockedCommunication = mockCommunications.Object;
litle.SetCommunication(mockedCommunication);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddCancelSubscription(cancel);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
Assert.AreSame(mockLitleBatchResponse, actualLitleBatchResponse);
Assert.AreEqual("12345", actualLitleBatchResponse.NextCancelSubscriptionResponse().SubscriptionId);
Assert.AreEqual("54321", actualLitleBatchResponse.NextCancelSubscriptionResponse().SubscriptionId);
Assert.IsNull(actualLitleBatchResponse.NextCancelSubscriptionResponse());
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
private void InternalCallBack(CimXmlHeader header, object CimObject)
{
if (responses == null)
{
if (header.IsMultipleResponse)
responses = new BatchResponse(header);
else
responses = new BatchResponse(header, 1); // Save Mem
}
while (responses.Count <= header.ResponseNumber)
{
responses.Add(new SingleResponse());
responses.LastResponse.MethodName = header.MethodName;
}
if (CimObject is CimName)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = new CimNameList();
}
((CimNameList)responses.LastResponse.Value).Add((CimName)CimObject);
}
else if (CimObject is CimClass)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = new CimClassList();
}
((CimClassList)responses.LastResponse.Value).Add((CimClass)CimObject);
}
else if (CimObject is CimInstance)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = new CimInstanceList();
}
((CimInstanceList)responses.LastResponse.Value).Add((CimInstance)CimObject);
}
else if (CimObject is CimInstanceName)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = new CimInstanceNameList();
}
((CimInstanceNameList)responses.LastResponse.Value).Add((CimInstanceName)CimObject);
}
else if (CimObject is string)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = (string)CimObject;
}
((CimValueList)responses.LastResponse.Value).Add((string)CimObject);
}
else if (CimObject is CimQualifierDeclaration)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = new CimQualifierDeclarationList();
}
((CimQualifierDeclarationList)responses.LastResponse.Value).Add((CimQualifierDeclaration)CimObject);
}
else if (CimObject is CimClassPath)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = new CimClassPathList();
}
((CimClassPathList)responses.LastResponse.Value).Add((CimClassPath)CimObject);
}
else if (CimObject is CimInstancePath)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = new CimInstancePathList();
}
((CimInstancePathList)responses.LastResponse.Value).Add((CimInstancePath)CimObject);
}
else if (CimObject is CimClassNamePath)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = new CimClassNamePathList();
}
((CimClassNamePathList)responses.LastResponse.Value).Add((CimClassNamePath)CimObject);
}
else if (CimObject is CimInstanceNamePath)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = new CimInstanceNamePathList();
}
((CimInstanceNamePathList)responses.LastResponse.Value).Add((CimInstanceNamePath)CimObject);
}
else if (CimObject is CimMethodResponse)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = (CimMethodResponse)CimObject;
}
}
else if (CimObject is CimomError)
{
if (responses.LastResponse.Value == null)
{
responses.LastResponse.Value = (CimomError)CimObject;
}
}
else if (CimObject == null)
{
// Do nothing, take the defaults
}
else
{
throw new Exception("Not implemented yet");
}
}
/*
* first time running this by just changing the filter a little i got this message.
* There was an error generating the XML document. ---> System.InvalidOperationException:
* Value of ItemElementName mismatches the type of DirectorySearchBusinessLogicLayer.gov.ny.svc.daws.SubstringFilter;
* you need to set it to DirectorySearchBusinessLogicLayer.gov.ny.svc.daws.ItemChoiceType.@substrings.
*
*
* System.InvalidOperationException: There was an error generating the XML document. --->
* System.InvalidOperationException: Value of ItemElementName mismatches the type of DirectorySearchBusinessLogicLayer.gov.ny.svc.daws.SubstringFilter;
* you need to set it to DirectorySearchBusinessLogicLayer.gov.ny.svc.daws.ItemChoiceType.@substrings.
*
*
* The next time I changed out the ava filter for a substring type and got this message
* Error Response
* [LDAP: error code 50 - Search filter not permitted (substring too short)]
*/
public IEnumerable <NyGovUser> GetUsers(String ou)
{
GlobalProxySelection.Select = new WebProxy("127.0.0.1", 8888);
List <NyGovUser> returnList = new List <NyGovUser>();
//example OU |||| dn =”ou = Department of General Services,ou = Government,o = ny,c = us
BatchRequest batch = new BatchRequest();
SearchRequest search = new SearchRequest();
Filter filter = new Filter();
dsmlQueryService client = new dsmlQueryService();
client.Url = "https://qadaws.svc.ny.gov/daws/services/dsmlSoapQuery";
batch.searchRequest = new SearchRequest[1] {
search
};
client.Credentials = new NetworkCredential("prxwsTL1HESC", "sfvwRMnB7N");
search.dn = "'ou = Department of General Services,ou = Government,o = ny,c = us'";
//search.dn = ou;
//can't use attribute value assertion for substring choice. instead make substring filter
//AttributeValueAssertion ava = new AttributeValueAssertion();
//ava.name = "nyacctgovernment";
//ava.value = "Y";
SubstringFilter[] substrings = new SubstringFilter[4];
SubstringFilter substring = new SubstringFilter();
substring.name = "nyacctgovernment";
substring.initial = "Y";
substrings[0] = substring;
SubstringFilter substring1 = new SubstringFilter();
substring1.name = "nyacctlevel1";
substring1.initial = "Y";
substrings[1] = substring1;
SubstringFilter substring2 = new SubstringFilter();
substring2.name = "sn";
substring2.initial = "smith";
substrings[2] = substring2;
SubstringFilter substring3 = new SubstringFilter();
substring3.name = "ou";
substring3.initial = "Department of General Services";
substrings[3] = substring3;
//FilterSet fSet = new FilterSet();
//ItemsChoiceType[] chioceTypes = new ItemsChoiceType[4];
//fSet.ItemsElementName = chioceTypes;
filter.ItemElementName = ItemChoiceType.substrings;
filter.Item = substring2;
search.filter = filter;
search.scope = SearchRequestScope.wholeSubtree;
AttributeDescriptions attrBucket = new AttributeDescriptions();
AttributeDescription[] attributeDescriptionList = new AttributeDescription[7];
attributeDescriptionList[0] = new AttributeDescription()
{
name = "nyacctgovernment"
};
attributeDescriptionList[1] = new AttributeDescription()
{
name = "sn"
};
attributeDescriptionList[2] = new AttributeDescription()
{
name = "givenname"
};
attributeDescriptionList[3] = new AttributeDescription()
{
name = "mail"
};
attributeDescriptionList[4] = new AttributeDescription()
{
name = "uid"
};
attributeDescriptionList[5] = new AttributeDescription()
{
name = "nyacctpersonal"
};
attributeDescriptionList[6] = new AttributeDescription()
{
name = "nyacctbusiness"
};
attrBucket.attribute = attributeDescriptionList;
search.attributes = attrBucket;
//client.PreAuthenticate = true;
//client.AllowAutoRedirect = true;
BatchResponse response = null;
try
{
//WebProxy myproxy = new WebProxy("proxy-internet.cio.state.nyenet", 80);
//myproxy.BypassProxyOnLocal = false;
//myproxy.Credentials = new NetworkCredential("mjordan", "fuckU023$6");
//client.Proxy = myproxy;
response = client.directoryRequest(batch);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Dang it. probably a 502 from the server and even more probable about async. " + e);
}
System.Diagnostics.Debug.WriteLine("just sent the request for a batch seach to directory request");
System.Diagnostics.Debug.WriteLine("Response: " + response);
if (response != null)
{
SearchResponse[] sResponses = response.searchResponse;
System.Diagnostics.Debug.WriteLine("Search Response: " + sResponses);
if (sResponses != null)
{
System.Diagnostics.Debug.WriteLine("Got " + sResponses.Length + " responses");
for (int i = 0; i < sResponses.Length; i++)
{
System.Diagnostics.Debug.WriteLine("Search Response #" + i + " requestID: " + sResponses[i].requestID);
SearchResultEntry[] srEntries = sResponses[i].searchResultEntry;
LDAPResult srd = sResponses[i].searchResultDone;
if (srd != null)
{
System.Diagnostics.Debug.WriteLine("LDAP Result AKA search result done");
System.Diagnostics.Debug.WriteLine(srd.resultCode.descr);
}
if (srEntries != null)
{
System.Diagnostics.Debug.WriteLine("Search Result Entries Cycle");
for (int r = 0; r < srEntries.Length; r++)
{
NyGovUser user = new NyGovUser();
user.NysSogUid = srEntries[r].dn;
System.Diagnostics.Debug.WriteLine(srEntries[r].dn);
System.Diagnostics.Debug.WriteLine(srEntries[r].attr);
DsmlAttr[] attributeList = srEntries[r].attr;
if (attributeList != null)
{
for (int a = 0; a < attributeList.Length; a++)
{
System.Diagnostics.Debug.WriteLine("name: " + attributeList[a].name);
String attName = attributeList[a].name;
StringBuilder valueBuilder = new StringBuilder();
if (attributeList[a].value != null)
{
for (int x = 0; x < attributeList[a].value.Length; x++)
{
System.Diagnostics.Debug.WriteLine("value: " + attributeList[a].value[x]);
valueBuilder.Append(attributeList[a].value[x]);
}
}
if (attName.Equals("uid"))
{
user.Uid = valueBuilder.ToString();
}
else if (attName.Equals("cn"))
{
user.CommonName = valueBuilder.ToString();
}
else if (attName.Equals("nyacctgovernment"))
{
user.IsGovernmentAccount = Convert.ToBoolean(valueBuilder.ToString());
}
else if (attName.Equals("sn"))
{
user.Surname = valueBuilder.ToString();
}
else if (attName.Equals("givenname"))
{
user.Firstname = valueBuilder.ToString();
}
else if (attName.Equals("mail"))
{
user.EmailAddress = valueBuilder.ToString();
}
else if (attName.Equals("nyacctbusiness"))
{
user.IsBusinessPartnerAccount = Convert.ToBoolean(valueBuilder.ToString());
}
else if (attName.Equals("nyacctpersonal"))
{
user.IsCitizenAccount = Convert.ToBoolean(valueBuilder.ToString());
}
}
}
returnList.Add(user);
}
}
else
{
System.Diagnostics.Debug.WriteLine("Search results list is null for some reason");
}
}
}
ErrorResponse[] eResponses = response.errorResponse;
if (eResponses != null)
{
System.Diagnostics.Debug.WriteLine("Checking out errors from the batch response");
System.Diagnostics.Debug.WriteLine("Errors Count: " + eResponses.Length);
//After adding a attribute value assertion and fitler to the search the error response ends up null so make a check for that
if (eResponses != null)
{
if (eResponses.Length > 0)
{
System.Diagnostics.Debug.WriteLine("Error Response");
for (int i = 0; i < eResponses.Length; i++)
{
ErrorResponse error = eResponses[i];
System.Diagnostics.Debug.WriteLine(error.message);
System.Diagnostics.Debug.WriteLine(error.detail);
System.Diagnostics.Debug.WriteLine(error.type);
}
}
}
}
else
{
System.Diagnostics.Debug.WriteLine("No errors from the response");
}
}
return(returnList);
}
public void testEcheckRedeposit()
{
EcheckRedeposit echeckredeposit = new EcheckRedeposit();
echeckredeposit.LitleTxnId = 123456;
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<echeckRedepositResponse xmlns='http://www.litle.com/schema'><litleTxnId>123</litleTxnId></echeckRedepositResponse>")
.Returns("<echeckRedepositResponse xmlns='http://www.litle.com/schema'><litleTxnId>124</litleTxnId></echeckRedepositResponse>");
BatchResponse mockedLitleBatchResponse = new BatchResponse();
mockedLitleBatchResponse.SetEcheckRedepositResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockedLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
Communications mockedCommunications = mockCommunications.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetCommunication(mockedCommunications);
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddEcheckRedeposit(echeckredeposit);
litleBatchRequest.AddEcheckRedeposit(echeckredeposit);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
EcheckRedepositResponse actualEcheckRedepositResponse1 = actualLitleBatchResponse.NextEcheckRedepositResponse();
EcheckRedepositResponse actualEcheckRedepositResponse2 = actualLitleBatchResponse.NextEcheckRedepositResponse();
EcheckRedepositResponse nullEcheckRedepositResponse = actualLitleBatchResponse.NextEcheckRedepositResponse();
Assert.AreEqual(123, actualEcheckRedepositResponse1.LitleTxnId);
Assert.AreEqual(124, actualEcheckRedepositResponse2.LitleTxnId);
Assert.IsNull(nullEcheckRedepositResponse);
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void testDeactivate()
{
Deactivate deactivate = new Deactivate();
deactivate.OrderId = "theOrderId";
deactivate.OrderSource = OrderSourceType.Ecommerce;
deactivate.Card = new CardType();
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<deactivateResponse xmlns=\"http://www.litle.com/schema\"><litleTxnId>123</litleTxnId></deactivateResponse>")
.Returns("<deactivateResponse xmlns=\"http://www.litle.com/schema\"><litleTxnId>124</litleTxnId></deactivateResponse>");
BatchResponse mockLitleBatchResponse = new BatchResponse();
mockLitleBatchResponse.SetDeactivateResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
Communications mockedCommunication = mockCommunications.Object;
litle.SetCommunication(mockedCommunication);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddDeactivate(deactivate);
litleBatchRequest.AddDeactivate(deactivate);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
Assert.AreSame(mockLitleBatchResponse, actualLitleBatchResponse);
Assert.AreEqual(123, actualLitleBatchResponse.NextDeactivateResponse().LitleTxnId);
Assert.AreEqual(124, actualLitleBatchResponse.NextDeactivateResponse().LitleTxnId);
Assert.IsNull(actualLitleBatchResponse.NextDeactivateResponse());
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public async Task BatchCrudRequestAsync()
{
Random random = new Random();
TestItem createItem = new TestItem("create");
byte[] createStreamContent = new byte[20];
random.NextBytes(createStreamContent);
byte[] createStreamBinaryId = new byte[20];
random.NextBytes(createStreamBinaryId);
int createTtl = 45;
BatchItemRequestOptions createRequestOptions = new BatchItemRequestOptions()
{
Properties = new Dictionary <string, object>()
{
{ WFConstants.BackendHeaders.BinaryId, createStreamBinaryId },
{ WFConstants.BackendHeaders.TimeToLiveInSeconds, createTtl.ToString() },
},
IndexingDirective = Microsoft.Azure.Cosmos.IndexingDirective.Exclude
};
string readId = Guid.NewGuid().ToString();
byte[] readStreamBinaryId = new byte[20];
random.NextBytes(readStreamBinaryId);
BatchItemRequestOptions readRequestOptions = new BatchItemRequestOptions()
{
Properties = new Dictionary <string, object>()
{
{ WFConstants.BackendHeaders.BinaryId, readStreamBinaryId }
},
IfNoneMatchEtag = "readCondition"
};
TestItem replaceItem = new TestItem("repl");
byte[] replaceStreamContent = new byte[20];
random.NextBytes(replaceStreamContent);
const string replaceStreamId = "replStream";
byte[] replaceStreamBinaryId = new byte[20];
random.NextBytes(replaceStreamBinaryId);
BatchItemRequestOptions replaceRequestOptions = new BatchItemRequestOptions()
{
Properties = new Dictionary <string, object>()
{
{ WFConstants.BackendHeaders.BinaryId, replaceStreamBinaryId }
},
IfMatchEtag = "replCondition",
IndexingDirective = Microsoft.Azure.Cosmos.IndexingDirective.Exclude
};
TestItem upsertItem = new TestItem("upsert");
byte[] upsertStreamContent = new byte[20];
random.NextBytes(upsertStreamContent);
byte[] upsertStreamBinaryId = new byte[20];
random.NextBytes(upsertStreamBinaryId);
BatchItemRequestOptions upsertRequestOptions = new BatchItemRequestOptions()
{
Properties = new Dictionary <string, object>()
{
{ WFConstants.BackendHeaders.BinaryId, upsertStreamBinaryId }
},
IfMatchEtag = "upsertCondition",
IndexingDirective = Microsoft.Azure.Cosmos.IndexingDirective.Exclude
};
string deleteId = Guid.NewGuid().ToString();
byte[] deleteStreamBinaryId = new byte[20];
random.NextBytes(deleteStreamBinaryId);
BatchItemRequestOptions deleteRequestOptions = new BatchItemRequestOptions()
{
Properties = new Dictionary <string, object>()
{
{ WFConstants.BackendHeaders.BinaryId, deleteStreamBinaryId }
},
IfNoneMatchEtag = "delCondition"
};
CosmosJsonDotNetSerializer jsonSerializer = new CosmosJsonDotNetSerializer();
BatchTestHandler testHandler = new BatchTestHandler((request, operations) =>
{
Assert.AreEqual(new Cosmos.PartitionKey(BatchUnitTests.PartitionKey1).ToString(), request.Headers.PartitionKey);
Assert.AreEqual(bool.TrueString, request.Headers[HttpConstants.HttpHeaders.IsBatchAtomic]);
Assert.AreEqual(bool.TrueString, request.Headers[HttpConstants.HttpHeaders.IsBatchOrdered]);
Assert.IsFalse(request.Headers.TryGetValue(HttpConstants.HttpHeaders.ShouldBatchContinueOnError, out string unused));
Assert.AreEqual(16, operations.Count);
int operationIndex = 0;
// run the loop twice, once for operations without item request options, and one for with item request options
for (int loopCount = 0; loopCount < 2; loopCount++)
{
bool hasItemRequestOptions = loopCount == 1;
ItemBatchOperation operation = operations[operationIndex++];
Assert.AreEqual(OperationType.Create, operation.OperationType);
Assert.IsNull(operation.Id);
Assert.AreEqual(createItem, BatchUnitTests.Deserialize(operation.ResourceBody, jsonSerializer));
BatchUnitTests.VerifyBatchItemRequestOptionsAreEqual(hasItemRequestOptions ? createRequestOptions : null, operation.RequestOptions);
operation = operations[operationIndex++];
Assert.AreEqual(OperationType.Read, operation.OperationType);
Assert.AreEqual(readId, operation.Id);
BatchUnitTests.VerifyBatchItemRequestOptionsAreEqual(hasItemRequestOptions ? readRequestOptions : null, operation.RequestOptions);
operation = operations[operationIndex++];
Assert.AreEqual(OperationType.Replace, operation.OperationType);
Assert.AreEqual(replaceItem.Id, operation.Id);
Assert.AreEqual(replaceItem, BatchUnitTests.Deserialize(operation.ResourceBody, jsonSerializer));
BatchUnitTests.VerifyBatchItemRequestOptionsAreEqual(hasItemRequestOptions ? replaceRequestOptions : null, operation.RequestOptions);
operation = operations[operationIndex++];
Assert.AreEqual(OperationType.Upsert, operation.OperationType);
Assert.IsNull(operation.Id);
Assert.AreEqual(upsertItem, BatchUnitTests.Deserialize(operation.ResourceBody, jsonSerializer));
BatchUnitTests.VerifyBatchItemRequestOptionsAreEqual(hasItemRequestOptions ? upsertRequestOptions : null, operation.RequestOptions);
operation = operations[operationIndex++];
Assert.AreEqual(OperationType.Delete, operation.OperationType);
Assert.AreEqual(deleteId, operation.Id);
BatchUnitTests.VerifyBatchItemRequestOptionsAreEqual(hasItemRequestOptions ? deleteRequestOptions : null, operation.RequestOptions);
operation = operations[operationIndex++];
Assert.AreEqual(OperationType.Create, operation.OperationType);
Assert.IsNull(operation.Id);
Assert.IsTrue(operation.ResourceBody.Span.SequenceEqual(createStreamContent));
BatchUnitTests.VerifyBatchItemRequestOptionsAreEqual(hasItemRequestOptions ? createRequestOptions : null, operation.RequestOptions);
operation = operations[operationIndex++];
Assert.AreEqual(OperationType.Replace, operation.OperationType);
Assert.AreEqual(replaceStreamId, operation.Id);
Assert.IsTrue(operation.ResourceBody.Span.SequenceEqual(replaceStreamContent));
BatchUnitTests.VerifyBatchItemRequestOptionsAreEqual(hasItemRequestOptions ? replaceRequestOptions : null, operation.RequestOptions);
operation = operations[operationIndex++];
Assert.AreEqual(OperationType.Upsert, operation.OperationType);
Assert.IsNull(operation.Id);
Assert.IsTrue(operation.ResourceBody.Span.SequenceEqual(upsertStreamContent));
BatchUnitTests.VerifyBatchItemRequestOptionsAreEqual(hasItemRequestOptions ? upsertRequestOptions : null, operation.RequestOptions);
}
return(Task.FromResult(new ResponseMessage(HttpStatusCode.OK)));
});
Container container = BatchUnitTests.GetContainer(testHandler);
BatchResponse batchResponse = await new BatchCore((ContainerCore)container, new Cosmos.PartitionKey(BatchUnitTests.PartitionKey1))
.CreateItem(createItem)
.ReadItem(readId)
.ReplaceItem(replaceItem.Id, replaceItem)
.UpsertItem(upsertItem)
.DeleteItem(deleteId)
// stream
.CreateItemStream(new MemoryStream(createStreamContent))
.ReplaceItemStream(replaceStreamId, new MemoryStream(replaceStreamContent))
.UpsertItemStream(new MemoryStream(upsertStreamContent))
// regular with options
.CreateItem(createItem, createRequestOptions)
.ReadItem(readId, readRequestOptions)
.ReplaceItem(replaceItem.Id, replaceItem, replaceRequestOptions)
.UpsertItem(upsertItem, upsertRequestOptions)
.DeleteItem(deleteId, deleteRequestOptions)
// stream with options
.CreateItemStream(new MemoryStream(createStreamContent), createRequestOptions)
.ReplaceItemStream(replaceStreamId, new MemoryStream(replaceStreamContent), replaceRequestOptions)
.UpsertItemStream(new MemoryStream(upsertStreamContent), upsertRequestOptions)
.ExecuteAsync();
}
public void testUpdateCardValidationNumOnToken()
{
UpdateCardValidationNumOnToken updateCardValidationNumOnToken = new UpdateCardValidationNumOnToken();
updateCardValidationNumOnToken.OrderId = "12344";
updateCardValidationNumOnToken.LitleToken = "123";
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<updateCardValidationNumOnTokenResponse xmlns='http://www.litle.com/schema'><litleTxnId>123</litleTxnId></updateCardValidationNumOnTokenResponse>")
.Returns("<updateCardValidationNumOnTokenResponse xmlns='http://www.litle.com/schema'><litleTxnId>124</litleTxnId></updateCardValidationNumOnTokenResponse>");
BatchResponse mockedLitleBatchResponse = new BatchResponse();
mockedLitleBatchResponse.SetUpdateCardValidationNumOnTokenResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockedLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
Communications mockedCommunications = mockCommunications.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetCommunication(mockedCommunications);
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddUpdateCardValidationNumOnToken(updateCardValidationNumOnToken);
litleBatchRequest.AddUpdateCardValidationNumOnToken(updateCardValidationNumOnToken);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
UpdateCardValidationNumOnTokenResponse actualUpdateCardValidationNumOnTokenResponse1 = actualLitleBatchResponse.NextUpdateCardValidationNumOnTokenResponse();
UpdateCardValidationNumOnTokenResponse actualUpdateCardValidationNumOnTokenResponse2 = actualLitleBatchResponse.NextUpdateCardValidationNumOnTokenResponse();
UpdateCardValidationNumOnTokenResponse nullUpdateCardValidationNumOnTokenResponse = actualLitleBatchResponse.NextUpdateCardValidationNumOnTokenResponse();
Assert.AreEqual(123, actualUpdateCardValidationNumOnTokenResponse1.LitleTxnId);
Assert.AreEqual(124, actualUpdateCardValidationNumOnTokenResponse2.LitleTxnId);
Assert.IsNull(nullUpdateCardValidationNumOnTokenResponse);
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void testUpdateSubscription()
{
UpdateSubscription update = new UpdateSubscription();
update.BillingDate = new DateTime(2002, 10, 9);
Contact billToAddress = new Contact();
billToAddress.Name = "Greg Dake";
billToAddress.City = "Lowell";
billToAddress.State = "MA";
billToAddress.Email = "*****@*****.**";
update.BillToAddress = billToAddress;
CardType card = new CardType();
card.Number = "4100000000000001";
card.ExpDate = "1215";
card.Type = MethodOfPaymentTypeEnum.VI;
update.Card = card;
update.PlanCode = "abcdefg";
update.SubscriptionId = 12345;
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<updateSubscriptionResponse xmlns=\"http://www.litle.com/schema\"><litleTxnId>54321</litleTxnId><response>000</response><message>Approved</message><responseTime>2013-09-04T21:55:14</responseTime><subscriptionId>12345</subscriptionId></updateSubscriptionResponse>")
.Returns("<updateSubscriptionResponse xmlns=\"http://www.litle.com/schema\"><litleTxnId>12345</litleTxnId><response>000</response><message>Approved</message><responseTime>2013-09-04T21:55:14</responseTime><subscriptionId>54321</subscriptionId></updateSubscriptionResponse>");
BatchResponse mockLitleBatchResponse = new BatchResponse();
mockLitleBatchResponse.SetUpdateSubscriptionResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
Communications mockedCommunication = mockCommunications.Object;
litle.SetCommunication(mockedCommunication);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddUpdateSubscription(update);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
Assert.AreSame(mockLitleBatchResponse, actualLitleBatchResponse);
Assert.AreEqual("12345", actualLitleBatchResponse.NextUpdateSubscriptionResponse().SubscriptionId);
Assert.AreEqual("54321", actualLitleBatchResponse.NextUpdateSubscriptionResponse().SubscriptionId);
Assert.IsNull(actualLitleBatchResponse.NextUpdateSubscriptionResponse());
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
/*
* When I first made this method it ran correctly but I received an error message about access. as seen below
* Logged User prxwstl1hesc cannot create in ou = people,ou = OFA,ou = Government,o = ny,c = us because user is not in OU scope of DA
*
* Since this is a HESC account I will make a HESC user but i now need to find out the ou for that. Since we make these apps for other people there might need to be a master level id we use or each agency specific work we do should have their own id
*
*/
public void AddUser()
{
dsmlQueryService client = new dsmlQueryService();
client.Url = "https://qadaws.svc.ny.gov/daws/services/dsmlSoapQuery";
client.Credentials = new NetworkCredential("prxwsTL1HESC", "sfvwRMnB7N");
AddRequest[] addRequest = new AddRequest[1] {
new AddRequest()
};
addRequest[0].dn = "ou = people,ou =NYS Department of Higher Education Services Corporation,ou = Government,o = ny,c = us";
DsmlAttr[] attributesToAdd = new DsmlAttr[11];
attributesToAdd[0] = new DsmlAttr()
{
name = "dn", value = new String[] { "ou = people,ou =NYS Department of Higher Education Services Corporation,ou = Government,o = ny,c = us" }
};
attributesToAdd[1] = new DsmlAttr()
{
name = "sn", value = new String[] { "Jordan" }
};
attributesToAdd[2] = new DsmlAttr()
{
name = "uid", value = new String[] { "MontyJordanEBSTest001" }
};
attributesToAdd[3] = new DsmlAttr()
{
name = "givenname", value = new String[] { "Monty" }
};
attributesToAdd[4] = new DsmlAttr()
{
name = "mail", value = new String[] { "*****@*****.**" }
};
attributesToAdd[5] = new DsmlAttr()
{
name = "userpassword", value = new String[] { "uzRpa$$w0Rd" }
};
attributesToAdd[6] = new DsmlAttr()
{
name = "nyaccttl", value = new String[] { "1" }
};
attributesToAdd[7] = new DsmlAttr()
{
name = "nyaccttlidsource1", value = new String[] { "n/a" }
};
attributesToAdd[8] = new DsmlAttr()
{
name = "nyaccttlidsource2", value = new String[] { "n/a" }
};
attributesToAdd[9] = new DsmlAttr()
{
name = "nyaccttlivmethod", value = new String[] { "n/a" }
};
attributesToAdd[10] = new DsmlAttr()
{
name = "vetted", value = new String[] { "n/a" }
};
//attributesToAdd[9] = new DsmlAttr() { name = "", value = new String[] { "" } };
addRequest[0].attr = attributesToAdd;
BatchRequest batchRequest = new BatchRequest();
batchRequest.addRequest = addRequest;
BatchResponse batchResponse = client.directoryRequest(batchRequest);
if (batchResponse != null)
{
LDAPResult[] ldapResult = batchResponse.addResponse;
ErrorResponse[] errorResponse = batchResponse.errorResponse;
if (errorResponse != null)
{
for (int i = 0; i < errorResponse.Length; i++)
{
System.Diagnostics.Debug.WriteLine(errorResponse[i].message);
}
}
}
}
public async Task <BatchResponse> Store(string bucketName, BatchSet batch)
{
using (var client = new MyCouchClient(DbServerUrl, bucketName))
{
var dbExists = await client.Database.HeadAsync();
if (dbExists.IsSuccess)
{
BulkRequest bulkRequest = new BulkRequest();
DateTime start = DateTime.Now;
int size = 0;
SiaqodbDocument crObjForUpdateViews = null;
if (batch.ChangedDocuments != null)
{
foreach (SiaqodbDocument obj in batch.ChangedDocuments)
{
if (obj != null)
{
if (crObjForUpdateViews == null)
{
crObjForUpdateViews = obj;
}
await CheckTagsViews(client, bucketName, obj.Tags);
CouchDBDocument doc = Mapper.ToCouchDBDoc(obj);
var serializedObject = client.Serializer.Serialize <CouchDBDocument>(doc);
bulkRequest.Include(serializedObject);
size += serializedObject.Length;
}
}
}
if (batch.DeletedDocuments != null)
{
foreach (DeletedDocument obj in batch.DeletedDocuments)
{
if (obj != null)
{
if (obj.Version != null)//otherwise means is a non-existing object
{
bulkRequest.Delete(obj.Key, obj.Version);
}
}
}
}
var response = await client.Documents.BulkAsync(bulkRequest);
if (response.IsSuccess)
{
var cnorResponse = new BatchResponse();
if (response.Rows != null)
{
cnorResponse.BatchItemResponses = new List <BatchItemResponse>();
SyncLogItem syncLogItem = new SyncLogItem();
syncLogItem.KeyVersion = new Dictionary <string, string>();
foreach (var row in response.Rows)
{
BatchItemResponse wresp = new BatchItemResponse();
if (!string.IsNullOrEmpty(row.Error))
{
cnorResponse.ItemsWithErrors++;
}
wresp.Error = row.Error;
wresp.ErrorDesc = row.Reason;
wresp.Key = row.Id;
wresp.Version = row.Rev;
cnorResponse.BatchItemResponses.Add(wresp);
if (string.IsNullOrEmpty(row.Error))
{
syncLogItem.KeyVersion.Add(row.Id, row.Rev);
}
}
if (syncLogItem.KeyVersion.Count > 0)
{
syncLogItem.TimeInserted = DateTime.UtcNow;
using (var clientLog = new MyCouchClient(DbServerUrl, SyncLogBucket))
{
string serLogItem = Newtonsoft.Json.JsonConvert.SerializeObject(syncLogItem);
var logResp = await clientLog.Documents.PostAsync(serLogItem);
cnorResponse.UploadAnchor = logResp.Id;
}
}
}
if (crObjForUpdateViews != null)
{
await this.StartRebuildViews(client, crObjForUpdateViews);
}
return(cnorResponse);
}
else
{
CheckBucketNotFound(bucketName, response);
}
}
else if (dbExists.StatusCode == System.Net.HttpStatusCode.NotFound)
{
throw new BucketNotFoundException(bucketName);
}
return(null);
}
}
private Dictionary <string, List <Dictionary <string, AttributeValue> > > GetAttributeItems(bool isAsync)
{
var allItems = new Dictionary <string, List <Dictionary <string, AttributeValue> > >();
if (Batches == null || Batches.Count == 0)
{
return(allItems);
}
DocumentBatchGet firstBatch = this.Batches[0];
BatchGetItemRequest request = new BatchGetItemRequest();
request.BeforeRequestEvent += isAsync ?
new RequestEventHandler(firstBatch.TargetTable.UserAgentRequestEventHandlerAsync) :
new RequestEventHandler(firstBatch.TargetTable.UserAgentRequestEventHandlerSync);
foreach (var batch in Batches)
{
if (batch.Keys != null && batch.Keys.Count > 0)
{
if (request.RequestItems.ContainsKey(batch.TargetTable.TableName))
{
throw new InvalidOperationException("Multiple batches refer to the same table.");
}
request.RequestItems.Add(
batch.TargetTable.TableName,
new KeysAndAttributes
{
Keys = batch.Keys,
AttributesToGet = batch.AttributesToGet,
ConsistentRead = batch.ConsistentRead
});
}
}
var client = firstBatch.TargetTable.DDBClient;
do
{
var batchGetItemResponse = client.BatchGetItem(request);
var result = batchGetItemResponse.BatchGetItemResult;
var responses = result.Responses;
foreach (var response in responses)
{
string tableName = response.Key;
BatchResponse batchResponse = response.Value;
List <Dictionary <string, AttributeValue> > items = batchResponse.Items;
List <Dictionary <string, AttributeValue> > fetchedItems;
if (!allItems.TryGetValue(tableName, out fetchedItems))
{
fetchedItems = new List <Dictionary <string, AttributeValue> >();
allItems[tableName] = fetchedItems;
}
fetchedItems.AddRange(items);
}
request.RequestItems = result.UnprocessedKeys;
} while (request.RequestItems.Count > 0);
return(allItems);
}
public async Task <BatchResponse> Store(string bucketName, BatchSet value)
{
var db = client.GetDatabase(DbName);
var collection = db.GetCollection <BsonDocument>(bucketName);
var response = new BatchResponse();
response.BatchItemResponses = new List <BatchItemResponse>();
SyncLogItem syncLogItem = new SyncLogItem();
syncLogItem.KeyVersion = new Dictionary <string, string>();
foreach (var document in value.ChangedDocuments)
{
var newDoc = Mapper.ToBsonDoc(document);
newDoc["_rev"] = this.GenerateNewVersion();
try
{
var exists = await collection.Find(filter : new BsonDocument {
{ "_id", document.Key }
}).FirstOrDefaultAsync();
if (exists == null && !string.IsNullOrEmpty(document.Version)) //somebody else deleted the doc-> conflict
{
BatchItemResponse respWithError = BuildResponseWithError(document.Key, document.Version, "conflict");
response.ItemsWithErrors++;
response.BatchItemResponses.Add(respWithError);
continue;
}
var result = await collection.ReplaceOneAsync(filter : new BsonDocument {
{ "_id", document.Key }, { "_rev", BsonTypeMapper.MapToBsonValue(document.Version) }
},
options : new UpdateOptions {
IsUpsert = true
},
replacement : newDoc);
BatchItemResponse itemResp = new BatchItemResponse
{
Key = document.Key,
Version = newDoc["_rev"].AsString
};
response.BatchItemResponses.Add(itemResp);
syncLogItem.KeyVersion.Add(itemResp.Key, itemResp.Version);
}
catch (MongoWriteException ex)
{
string error = ex.Message;
if (ex.Message.Contains("duplicate key"))//conflict
{
error = "conflict";
}
var itemResp = BuildResponseWithError(document.Key, document.Version, error);
response.ItemsWithErrors++;
response.BatchItemResponses.Add(itemResp);
}
}
foreach (var document in value.DeletedDocuments)
{
BatchItemResponse itemResp = new BatchItemResponse()
{
Key = document.Key,
Version = document.Version
};
var del = await collection.DeleteOneAsync(filter : new BsonDocument {
{ "_id", document.Key }, { "_rev", BsonTypeMapper.MapToBsonValue(document.Version) }
});
if (del.DeletedCount == 0)
{
var docFromDB = collection.Find(filter: new BsonDocument {
{ "_id", document.Key }
}).FirstOrDefaultAsync();
if (docFromDB != null)
{
itemResp.Error = "conflict";
itemResp.ErrorDesc = "conflict";
response.ItemsWithErrors++;
}
}
response.BatchItemResponses.Add(itemResp);
}
//store uploadedAnchor
if (syncLogItem.KeyVersion.Count > 0)
{
syncLogItem.TimeInserted = DateTime.UtcNow;
BsonDocument syncLogDoc = new BsonDocument();
syncLogDoc["KeyVersion"] = new BsonDocument(syncLogItem.KeyVersion);
syncLogDoc["TimeInserted"] = syncLogItem.TimeInserted;
var collectionLog = db.GetCollection <BsonDocument>(SyncLogBucket);
await collectionLog.InsertOneAsync(syncLogDoc);
response.UploadAnchor = syncLogDoc["_id"].ToString();
}
return(response);
}
public async Task <IActionResult> DispatchRequest([FromHeader(Name = "Authorization")] string authToken,
List <DispatchRequest> request)
{
try
{
if (request == null)
{
return(BadRequest("Bad Request"));
}
// Fetch account configuration to be used through the whole request.
AccountConfiguration accConfiguration = GetAccountConfiguration().Result;
if (accConfiguration == null)
{
EventLogList.AddEventByLevel(2, SharedSettings.NoConfigInSPA, null);
await EventLogList.AddEventLogs(ViaMongoDB);
return(StatusCode(Microsoft.AspNetCore.Http.StatusCodes.Status500InternalServerError, SharedSettings.NoConfigInSPA));
}
// Validate Auth token(Basic or Bearer) and reject if fail.
if (!AuthTokenValidation.ValidateBearerToken(authToken, accConfiguration))
{
EventLogList.AddEventByLevel(2, SharedSettings.AuthorizationDenied, null, null);
await EventLogList.AddEventLogs(ViaMongoDB);
return(Unauthorized(SharedSettings.AuthDeniedResponse));
}
// Check for Payload size and number of Dispatches
if (!PayloadValidation.ValidateRequestPayloadSize(request, EventLogList))
{
await EventLogList.AddEventLogs(ViaMongoDB);
return(StatusCode(Microsoft.AspNetCore.Http.StatusCodes.Status413PayloadTooLarge, SharedSettings.PayLoadTooLarge));
}
//Generate batch ID for the request
string batchId = Guid.NewGuid().ToString();
// Check for sampling
if (accConfiguration.ExtendedProperties.TryGetValue("Sampler", out string samplername))
{
if (SharedSettings.AvailableSamplers.TryGetValue(samplername, out ISampler sampler))
{
await sampler.IsSampledAsync(request);
}
else
{
EventLogList.AddEventByLevel(4, SharedSettings.NoSamplingConfigured, batchId);
}
}
BatchResponse batchResponse = new BatchResponse()
{
BatchId = batchId,
StatusByDispatch = new List <StatusByDispatch>()
};
try
{
ProcessInvitations processInvitations = new ProcessInvitations(authToken, ViaMongoDB, batchId,
EventLogList, accConfiguration);
bool res = processInvitations.GetAllInfoForDispatch();
if (!res)
{
EventLogList.AddEventByLevel(2, SharedSettings.APIResponseFail, batchId, null);
await EventLogList.AddEventLogs(ViaMongoDB);
return(StatusCode(Microsoft.AspNetCore.Http.StatusCodes.Status500InternalServerError,
SharedSettings.APIResponseFail));
}
await processInvitations.CheckDispatchData(request, batchId, batchResponse);
}
catch (Exception ex)
{
EventLogList.AddExceptionEvent(ex, batchId, null, null, null, SharedSettings.DispatchControllerEx2);
await EventLogList.AddEventLogs(ViaMongoDB);
return(ex.Message switch
{
SharedSettings.AuthorizationDenied => Unauthorized(ex.Message),
_ => StatusCode(Microsoft.AspNetCore.Http.StatusCodes.Status500InternalServerError, ex.Message)
});
}
public virtual BatchResponse NextBatchResponse()
{
if (_batchResponseReader.ReadState == ReadState.Closed) return null;
var litleBatchResponse = new BatchResponse(_batchResponseReader, _filePath);
if (!_batchResponseReader.ReadToFollowing("batchResponse"))
{
_batchResponseReader.Close();
}
return litleBatchResponse;
}
public void testAuth()
{
Authorization authorization = new Authorization();
authorization.ReportGroup = "Planets";
authorization.OrderId = "12344";
authorization.Amount = 106;
authorization.OrderSource = OrderSourceType.Ecommerce;
CardType card = new CardType();
card.Type = MethodOfPaymentTypeEnum.VI;
card.Number = "4100000000000002";
card.ExpDate = "1210";
authorization.Card = card;
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<authorizationResponse id=\"\" reportGroup=\"Planets\" xmlns=\"http://www.litle.com/schema\"><litleTxnId>123</litleTxnId><orderId>123</orderId><response>000</response><responseTime>2013-06-19T19:54:42</responseTime><message>Approved</message><authCode>123457</authCode><fraudResult><avsResult>00</avsResult></fraudResult><tokenResponse><litleToken>1711000103054242</litleToken><tokenResponseCode>802</tokenResponseCode><tokenMessage>Account number was previously registered</tokenMessage><type>VI</type><bin>424242</bin></tokenResponse></authorizationResponse>")
.Returns("<authorizationResponse id=\"\" reportGroup=\"Planets\" xmlns=\"http://www.litle.com/schema\"><litleTxnId>124</litleTxnId><orderId>124</orderId><response>000</response><responseTime>2013-06-19T19:54:42</responseTime><message>Approved</message><authCode>123457</authCode><fraudResult><avsResult>00</avsResult></fraudResult><tokenResponse><litleToken>1711000103054242</litleToken><tokenResponseCode>802</tokenResponseCode><tokenMessage>Account number was previously registered</tokenMessage><type>VI</type><bin>424242</bin></tokenResponse></authorizationResponse>");
BatchResponse mockLitleBatchResponse = new BatchResponse();
mockLitleBatchResponse.SetAuthorizationResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
Communications mockedCommunication = mockCommunications.Object;
litle.SetCommunication(mockedCommunication);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddAuthorization(authorization);
litleBatchRequest.AddAuthorization(authorization);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
Assert.AreSame(mockLitleBatchResponse, actualLitleBatchResponse);
Assert.AreEqual(123, actualLitleBatchResponse.NextAuthorizationResponse().LitleTxnId);
Assert.AreEqual(124, actualLitleBatchResponse.NextAuthorizationResponse().LitleTxnId);
Assert.IsNull(actualLitleBatchResponse.NextAuthorizationResponse());
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
public void testDefaultReportGroup()
{
Authorization authorization = new Authorization();
authorization.OrderId = "12344";
authorization.Amount = 106;
authorization.OrderSource = OrderSourceType.Ecommerce;
CardType card = new CardType();
card.Type = MethodOfPaymentTypeEnum.VI;
card.Number = "4100000000000002";
card.ExpDate = "1210";
authorization.Card = card;
var mockLitleResponse = new Mock<LitleResponse>();
var mockLitleXmlSerializer = new Mock<LitleXmlSerializer>();
mockXmlReader.SetupSequence(XmlReader => XmlReader.ReadOuterXml())
.Returns("<authorizationResponse reportGroup=\"Default Report Group\" xmlns='http://www.litle.com/schema'><litleTxnId>123</litleTxnId></authorizationResponse>")
.Returns("<authorizationResponse reportGroup=\"Default Report Group\" xmlns='http://www.litle.com/schema'><litleTxnId>124</litleTxnId></authorizationResponse>");
BatchResponse mockedLitleBatchResponse = new BatchResponse();
mockedLitleBatchResponse.SetAuthorizationResponseReader(mockXmlReader.Object);
mockLitleResponse.Setup(litleResponse => litleResponse.NextBatchResponse()).Returns(mockedLitleBatchResponse);
LitleResponse mockedLitleResponse = mockLitleResponse.Object;
Communications mockedCommunications = mockCommunications.Object;
mockLitleXmlSerializer.Setup(litleXmlSerializer => litleXmlSerializer.DeserializeObjectFromFile(It.IsAny<String>())).Returns(mockedLitleResponse);
LitleXmlSerializer mockedLitleXmlSerializer = mockLitleXmlSerializer.Object;
LitleFile mockedLitleFile = mockLitleFile.Object;
litle.SetCommunication(mockedCommunications);
litle.SetLitleXmlSerializer(mockedLitleXmlSerializer);
litle.SetLitleFile(mockedLitleFile);
litle.SetLitleTime(mockLitleTime.Object);
BatchRequest litleBatchRequest = new BatchRequest();
litleBatchRequest.SetLitleFile(mockedLitleFile);
litleBatchRequest.SetLitleTime(mockLitleTime.Object);
litleBatchRequest.AddAuthorization(authorization);
litleBatchRequest.AddAuthorization(authorization);
litle.AddBatch(litleBatchRequest);
string batchFileName = litle.SendToLitle();
LitleResponse actualLitleResponse = litle.ReceiveFromLitle(batchFileName);
BatchResponse actualLitleBatchResponse = actualLitleResponse.NextBatchResponse();
AuthorizationResponse actualAuthorizationResponse1 = actualLitleBatchResponse.NextAuthorizationResponse();
AuthorizationResponse actualAuthorizationResponse2 = actualLitleBatchResponse.NextAuthorizationResponse();
AuthorizationResponse nullAuthorizationResponse = actualLitleBatchResponse.NextAuthorizationResponse();
Assert.AreEqual(123, actualAuthorizationResponse1.LitleTxnId);
Assert.AreEqual("Default Report Group", actualAuthorizationResponse1.ReportGroup);
Assert.AreEqual(124, actualAuthorizationResponse2.LitleTxnId);
Assert.AreEqual("Default Report Group", actualAuthorizationResponse2.ReportGroup);
Assert.IsNull(nullAuthorizationResponse);
mockLitleFile.Verify(litleFile => litleFile.AppendLineToFile(mockFilePath, It.IsRegex(".*reportGroup=\"Default Report Group\".*", RegexOptions.Singleline)));
mockCommunications.Verify(Communications => Communications.FtpDropOff(It.IsAny<String>(), mockFileName, It.IsAny<Dictionary<String, String>>()));
mockCommunications.Verify(Communications => Communications.FtpPickUp(It.IsAny<String>(), It.IsAny<Dictionary<String, String>>(), mockFileName));
}
