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)); }