public void Should_return_default_for_TResponse()
        {
            var request = new TestRequest {CorrelationTag = "this is a query"};
            var response = Bus.Send (request);

            Assert.IsNull (response);
        }
        public async Task Should_send_encrypted_message_and_wait_for_response()
        {
            IServiceLocator serviceLocator = TestRig.CreateTestServiceLocator();

            var config = new ConnectionConfig(TestRig.AuthKey, 100500) {SessionId = 2};

            var messageProcessor = serviceLocator.ResolveType<IMessageCodec>();

            var request = new TestRequest {TestId = 9};
            var expectedResponse = new TestResponse {TestId = 9, TestText = "Number 1"};

            byte[] expectedResponseMessageBytes = messageProcessor.EncodeEncryptedMessage(
                new Message(0x0102030405060708, 3, expectedResponse),
                config.AuthKey,
                config.Salt,
                config.SessionId,
                Sender.Server);

            SetupMockTransportWhichReturnsBytes(serviceLocator, expectedResponseMessageBytes);

            using (var connection = serviceLocator.ResolveType<IMTProtoClientConnection>())
            {
                connection.Configure(config);
                await connection.Connect();

                TestResponse response = await connection.RequestAsync<TestResponse>(request, MessageSendingFlags.EncryptedAndContentRelated, TimeSpan.FromSeconds(5));
                response.Should().NotBeNull();
                response.Should().Be(expectedResponse);

                await connection.Disconnect();
            }
        }
        public async Task Should_send_Rpc_and_receive_response()
        {
            IServiceLocator serviceLocator = TestRig.CreateTestServiceLocator();

            var config = new ConnectionConfig(TestRig.AuthKey, 100500) {SessionId = 2};

            var messageProcessor = serviceLocator.ResolveType<IMessageCodec>();

            var request = new TestRequest {TestId = 9};
            var expectedResponse = new TestResponse {TestId = 9, TestText = "Number 1"};
            var rpcResult = new RpcResult {ReqMsgId = TestMessageIdsGenerator.MessageIds[0], Result = expectedResponse};

            byte[] expectedResponseMessageBytes = messageProcessor.EncodeEncryptedMessage(
                new Message(0x0102030405060708, 3, rpcResult),
                config.AuthKey,
                config.Salt,
                config.SessionId,
                Sender.Server);

            SetupMockTransportWhichReturnsBytes(serviceLocator, expectedResponseMessageBytes);

            using (var connection = serviceLocator.ResolveType<IMTProtoClientConnection>())
            {
                connection.Configure(config);
                await connection.Connect();

                TestResponse response = await connection.RpcAsync<TestResponse>(request);
                response.Should().NotBeNull();
                response.Should().Be(expectedResponse);

                await connection.Disconnect();
            }
        }
Ejemplo n.º 4
0
        public void Update_WhenChecklistIsNotMapped_UpdatesAnswers()
        {
            // Arrange.
            var request = new TestRequest { RootText = "abc", RootNumber = 123 };
            var dataContext = new SourceData(request);

            var childMapping1 = new SimpleFieldMapping(
                ReflectionHelper.GetProperty<TestAnswer>(x => x.Text),
                dc => dc.GetPropertyValue("RootText"),
                false,
                new SafeTypeConverter());
            var childMapping2 = new SimpleFieldMapping(
                ReflectionHelper.GetProperty<TestAnswer>(x => x.Number),
                dc => dc.GetPropertyValue("RootNumber"),
                true,
                new SafeTypeConverter());

            var dtm = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
            Mock.Arrange(() => dtm.NewEditableChild<IEditableRoot>(AnswerProcessName)).Returns(() => new TestAnswer());

            var mapping = new ChecklistFieldMapping(ReflectionHelper.GetProperty<TestEdit>(x => x.Checklist), null, new[] { childMapping1, childMapping2 }, dtm);

            var editItem = new TestEdit();

            // Act.
            mapping.Update(dataContext, editItem);

            // Assert.
            Assert.AreEqual(1, editItem.Checklist.AnswerProcessList.Count);

            var answer = (TestAnswer)editItem.Checklist.AnswerProcessList[0];
            Assert.AreEqual("abc", answer.Text);
            Assert.AreEqual(123, answer.Number);
        }
        public void RequestAllPages_CustomPageSize_CallsProxyUntilNoMoreData()
        {
            var request = new TestRequest { PageSize = 5 };
            ListResponse<TestResponse> result = _proxy.Object.RequestAllPages<TestResponse>(request);
            result.Count.ShouldBe(_results.Count);

            _proxy.Verify(x => x.Request<ListResponse<TestResponse>>(It.IsAny<TestRequest>()), Times.Exactly(7));
        }
        public async Task RequestAllPagesAsync_CallsProxyUntilNoMoreData()
        {
            var request = new TestRequest();
            ListResponse<TestResponse> result = await _proxy.Object.RequestAllPagesAsync<TestResponse>(request);
            result.Count.ShouldBe(_results.Count);

            _proxy.Verify(x => x.RequestAsync<ListResponse<TestResponse>>(It.IsAny<TestRequest>()), Times.Exactly(4));
        }
        public void GetList_CreatesListIfNotExisting()
        {
            var request = new TestRequest();
            request.Parameters.ShouldNotContainKey("TestList");

            var existingCount = request.TestList.Count;
            request.Parameters.ShouldContainKey("TestList");
        }
Ejemplo n.º 8
0
        public void Should_be_able_to_send_and_receive_via_rpc()
        {
            TestRequest request = new TestRequest();

            TestResponse response = _rpcBus.GetResponseTo<TestResponse>(request, TimeSpan.FromSeconds(5));

            Assert.That(response, Is.Not.Null, "RPC Response not received within timeout period.");
            Assert.That(response.Id, Is.EqualTo(request.Id), "The RPC Response did not match the request.");
        }
Ejemplo n.º 9
0
        private RouteData FindRoute(TestRequest request)
        {
            var stubRequest = new Mock<HttpRequestBase>();
            stubRequest.Setup(r => r.AppRelativeCurrentExecutionFilePath).Returns(request.Url);
            stubRequest.Setup(r => r.HttpMethod).Returns(request.HttpMethod);
            stubRequest.Setup(r => r.Form).Returns(request.Form);
            var stubContext = new Mock<HttpContextBase>();
            stubContext.Setup(ctx => ctx.Request).Returns(stubRequest.Object);

            return routes.GetRouteData(stubContext.Object);
        }
Ejemplo n.º 10
0
        public void Should_be_able_to_send_and_gather_via_rpc()
        {
            TestRequest request = new TestRequest{ResponseCount = 2};

            IEnumerable<TestResponse> responses = _rpcBus.GatherResponsesTo<TestResponse>(request, TimeSpan.FromSeconds(5));

            Assert.That(responses, Is.Not.Null, "RPC Response not received within timeout period.");
            TestResponse[] testResponses = responses.ToArray();
            Assert.That(testResponses.Length, Is.EqualTo(2), "The wrong number of responses were gathered.");
            foreach (var response in testResponses)
            {
                Assert.That(response.Id, Is.EqualTo(request.Id), "The RPC Response did not match the request.");
            }
        }
Ejemplo n.º 11
0
        public void Update_WhenChecklistIsMapped_UpdatesAnswers()
        {
            // Arrange.
            var request = new TestRequest();
            request.SourceItems.Add(new TestData { Text = "aaa", Number = 111 });
            request.SourceItems.Add(new TestData { Text = "bbb", Number = 222 });

            var dataContext = new SourceData(request);

            var childMapping1 = new SimpleFieldMapping(
                ReflectionHelper.GetProperty<TestAnswer>(x => x.Text),
                dc => dc.GetPropertyValue("SourceItems.Text"),
                true,
                new SafeTypeConverter());
            var childMapping2 = new SimpleFieldMapping(
                ReflectionHelper.GetProperty<TestAnswer>(x => x.Number),
                dc => dc.GetPropertyValue("SourceItems.Number"),
                false,
                new SafeTypeConverter());

            var dtm = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
            Mock.Arrange(() => dtm.NewEditableChild<IEditableRoot>(AnswerProcessName)).Returns(() => new TestAnswer());

            var mapping = new ChecklistFieldMapping(
                ReflectionHelper.GetProperty<TestEdit>(x => x.Checklist),
                dc => dc.EnumerateItems("SourceItems"),
                new[] { childMapping1, childMapping2 },
                dtm);

            var editItem = new TestEdit();

            // Act.
            mapping.Update(dataContext, editItem);

            // Assert.
            Assert.AreEqual(2, editItem.Checklist.AnswerProcessList.Count);

            var answer1 = (TestAnswer)editItem.Checklist.AnswerProcessList[0];
            Assert.AreEqual("aaa", answer1.Text);
            Assert.AreEqual(111, answer1.Number);

            var answer2 = (TestAnswer)editItem.Checklist.AnswerProcessList[1];
            Assert.AreEqual("bbb", answer2.Text);
            Assert.AreEqual(222, answer2.Number);
        }
Ejemplo n.º 12
0
    protected void GetProgrammerInfo()
    {
        TestRequest tr = new TestRequest(RequestID);

        strTTID       = tr.TTID;
        strDT         = tr.REQUESTDATETIME;
        strProgrammer = tr.PROGABB;
        strComment    = tr.COMMENT;

        Version v = new Version(tr.VERSIONID);

        strFiPVersion = v.VERSION;

        int DotCount = 0;
        int len      = 0;

        foreach (var c in strFiPVersion)
        {
            if (DotCount == 4)
            {
                int CharCode = c - 48;
                if (CharCode < 0 || CharCode > 9)
                {
                    break;
                }
            }
            if (c == '.')
            {
                DotCount++;
            }
            len++;
        }

        strFiPVersionBase = strFiPVersion.Substring(0, len);
        //check if base version exists. if no - use max admin version.
        DataSet DS = GetDataSet(@"select V.ID from FIPVERSION V where V.VERSION = '" + strFiPVersionBase + "'");

        if (DS.Tables[0].Rows.Count == 0)
        {
            DS = GetDataSet(@"select TOP 1 V.VERSION from TESTREQUESTS T, FIPVERSION V where T.ProgAbb = 'Admin' and T.VersionID = V.ID order by T.ID DESC");
            strFiPVersionBase = DS.Tables[0].Rows[0][0].ToString();
        }
    }
Ejemplo n.º 13
0
    public void StartTest(string guid, string commaseparatedbatches, string commaseparatedcommands, string priority)
    {
        BSTUser bu = new BSTUser("", "bst");

        string[] batches = commaseparatedbatches.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
        foreach (string batch in batches)
        {
            TestRequest.RunBatch4Request(bu.LOGIN, batch, guid, priority);
        }
        if (!string.IsNullOrEmpty(commaseparatedcommands))
        {
            TestRequest tr          = new TestRequest("", guid);
            string      txtcommands = string.Join("\r\n", commaseparatedcommands.Split(','));
            string[]    Commands;
            string[]    arrGroup;
            TestRequest.GetCommandsGroups(txtcommands, out Commands, out arrGroup);
            Schedule.AddCommands(Commands, arrGroup, tr.ID.ToString(), bu.ID.ToString(), priority);
        }
    }
        public async Task ShouldProvideBizStep()
        {
            //Arrange
            var callback = CreateCallback();

            try
            {
                var api = Prepare(callback.exchange.Name);

                var requestContent = new TestRequest
                {
                    Command = "biz-step"
                };

                //Act

                var reqId = await SendRequest(requestContent, api);

                await api.ProcApi.Call(p => p.GetStatus());

                TestCallDetails <RequestStatus> statusResp = await api.AsyncProcApi.Call(s => s.GetStatusAsync(reqId));

                int tryCount = 0;

                while (statusResp.ResponseContent.Step != ProcessStep.Completed && tryCount++ < 10)
                {
                    await Task.Delay(500);

                    statusResp = await api.AsyncProcApi.Call(s => s.GetStatusAsync(reqId));
                }

                var status = statusResp.ResponseContent;

                //Assert
                Assert.Equal(ProcessStep.Processing, status.Step);
                Assert.Equal("foo-step", status.BizStep);
            }
            finally
            {
                callback.exchange.Dispose();
                callback.incomingMq.Dispose();
            }
        }
Ejemplo n.º 15
0
        /*Build the received source files and generate logs*/
        private static void BuildCodes_method(string portN)
        {
            Console.WriteLine("\nRequirement: 7");
            Console.WriteLine("\nBuilding...");
            DllBuilder db1    = new DllBuilder();
            bool       result = db1.CreateDll(ref logfile, portN, rcv.arguments[0]); // Build the source files

            Count--;
            Console.WriteLine("\nRequirement: 8");
            Console.WriteLine("\nSending build log to RepoStorage");
            repo.postFile(logfile, "../../../RepoStorage", "../../../ChildBuilder" + (Int32.Parse(portN) - 8081) + "Storage/" + rcv.arguments[0]);
            //Send log file to repo
            if (result == true)
            {
                Console.WriteLine("\nBuilding Complete\n");
                Console.WriteLine("\nRequirement: 8");
                Console.WriteLine("\nCreating new test request");
                TestRequest cbldr = new TestRequest();  //Else create new test request for test harness
                cbldr.author     = "Client";
                cbldr.testDriver = "TestCase.dll";
                cbldr.makeRequest();
                Console.WriteLine("\n{0}\n", cbldr.doc.ToString());
                cbldr.saveXml("../../../ChildBuilder" + (Int32.Parse(portN) - 8081) + "Storage/" + rcv.arguments[0], "TestRequest.xml"); //Save test request in RepoStorage
                Console.WriteLine("\nSending test request and libraries to TestHarnessStorage");                                         //Send test request and libraries to test harness
                harness.postFile("TestRequest.xml", "../../../TestHarnessStorage/" + "TempStorage" + Count.ToString(), "../../../ChildBuilder" + (Int32.Parse(portN) - 8081) + "Storage/" + rcv.arguments[0]);
                harness.postFile("TestCase.dll", "../../../TestHarnessStorage/" + "TempStorage" + Count.ToString(), "../../../ChildBuilder" + (Int32.Parse(portN) - 8081) + "Storage/" + rcv.arguments[0]);
                CommMessage test = new CommMessage(CommMessage.MessageType.request);
                test.command = "ExecuteTests";
                test.author  = "Client";
                test.to      = "http://localhost:8078/IPluggableComm";
                test.from    = portN;
                test.arguments.Add("TempStorage" + Count.ToString());
                harness.postMessage(test);                  // Send a message to test harness to execute tests
            }
            string dir = Path.GetFullPath("../../../ChildBuilder" + (Int32.Parse(portN) - 8081) + "Storage/" + rcv.arguments[0]);

            deletefiles(dir);
            if (Count == 0)
            {
                Console.WriteLine("\nSending Ready message to Mother Builder..");
                csndr.postMessage(mMsg);
            }
        }
        public void QueryStringSerializer_TestRequest_old_output()
        {
            var testRequest = new TestRequest {
                ListOfA = new List <A> {
                    new A {
                        ListOfB = new List <B> {
                            new B {
                                Property = "prop1"
                            }, new B {
                                Property = "prop2"
                            }
                        }
                    }
                }
            };
            var str = QueryStringSerializer.SerializeToString(testRequest);

            Assert.That(str, Is.EqualTo("ListOfA=[{ListOfB:[{Property:prop1},{Property:prop2}]}]"));
        }
Ejemplo n.º 17
0
        public void AccessMultiplePipesOneByOne()
        {
            var request = new TestRequest
            {
                StringField = "Test request"
            };

            var stopwatch = Stopwatch.StartNew();

            foreach (var(pipeName, client) in _connectionFactory.Clients)
            {
                var response = client.Send <TestRequest, TestResponse>("test/receive-and-return-async", request);
                response.StringField.ShouldBe($"Received: {request.StringField} from pipe {pipeName}");
                _testOutputHelper.WriteLine(response.StringField);
            }

            stopwatch.Stop();
            stopwatch.Elapsed.ShouldBeGreaterThan(TimeSpan.FromSeconds(_connectionFactory.Clients.Count));
        }
Ejemplo n.º 18
0
        //<----------------------------------used for generating the test request------------------------------------>
        public void generatetestrequest(string buildrequest, List <string> outputfilelist)
        {
            Console.WriteLine("--------------------------------------Build Server Creating Test Request---------------------------------------");
            Console.WriteLine("\n");
            string       xmlstring   = File.ReadAllText(buildrequest);
            BuildRequest newRequest  = xmlstring.FromXml <BuildRequest>();
            TestRequest  testRequest = new TestRequest();

            testRequest.author = "Ramteja Repaka";
            foreach (BuildItem item in newRequest.Builds)
            {
                TestElement element = new TestElement();
                element.testName = item.builddesc;
                string testdrivername = null;
                foreach (file f in item.driver)
                {
                    String s = f.name;
                    s = s.Replace(".cs", ".dll");
                    element.addDriver(s);
                    testdrivername = s;
                }

                foreach (file f in item.sourcefiles)
                {
                    String s = f.name;
                    s = s.Replace(".cs", ".dll");
                    element.addCode(s);
                }
                if (outputfilelist.Contains(testdrivername))
                {
                    testRequest.tests.Add(element);
                }
            }

            string testxml = testRequest.ToXml();

            File.WriteAllText("../../../BuildServer/BuilderStorage/TestRequest.xml", testxml);
            Console.WriteLine("TestRequest saved to BuilderStorage\n");
            Console.WriteLine("Sending test Request to mock test harness\n");
            sendFile("../../../BuildServer/BuilderStorage/TestRequest.xml", "../../../MockTestHarness/DLLRepository");
            Console.WriteLine("\n");
        }
Ejemplo n.º 19
0
        //Add test
        public async Task <Test> Add(TestRequest testRequest)
        {
            var test = new Test
            {
                TestName      = testRequest.TestName,
                DateCreated   = DateTime.Now,
                State         = true,
                CourseId      = testRequest.CourseId,
                Createsby     = testRequest.Createsby,
                DateTest      = testRequest.DateTest,
                Time          = testRequest.Time,
                TotalQuestion = testRequest.TotalQuestion
            };

            var newTest = await _baseRepository.Add(test);

            var list = new List <TestDetail>();

            var    listIdQuestion = (await _questionService.GetAll()).Select(x => x.QuestionId).ToList();
            var    listTestId     = new List <int>();
            Random r = new Random();

            for (int i = 0; i < testRequest.TotalQuestion; i++)
            {
                int idTemp = listIdQuestion[r.Next(0, listIdQuestion.Count() - 1)];
                listTestId.Add(idTemp);
                listIdQuestion.Remove(idTemp);
            }
            for (int i = 0; i < listTestId.Count(); i++)
            {
                var testDetail = new TestDetail
                {
                    TestId     = newTest.TestId,
                    QuestionId = listTestId[i]
                };
                list.Add(testDetail);
            }

            await _testDetailService.AddRange(list);

            return(newTest);
        }
        public async Task Succeeds()
        {
            var model         = new TestRequest();
            var modelProvider = new Mock <IRequestModelProvider>();

            modelProvider.Setup(x => x.GetCurrentRequestModel()).Returns(model);
            var configurationProvider = new Mock <IListConfigurationProvider>();

            var listConfiguration = new ListConfiguration(typeof(TestRequest), typeof(TestItem), typeof(TestResult))
            {
                PostRedirectGetConfiguration = new PostRedirectGetConfiguration("Index", true),
                PageConfiguration            = new PageConfiguration("Page", 1),
                RowsConfiguration            = new RowsConfiguration("Rows", 20),
                SortColumnConfiguration      = new SortColumnConfiguration("Ordx", "Text"),
                SortDirectionConfiguration   = new SortDirectionConfiguration("Ordd", Direction.Ascending)
            };

            configurationProvider.Setup(x => x.GetConfiguration(It.IsAny <Type>())).Returns(listConfiguration);

            var actionFilter = new PostRedirectGetActionFilter(modelProvider.Object, configurationProvider.Object);

            actionFilter.Order.Should().Be(1);
            var httpContext   = new Mock <HttpContext>();
            var actionContext = new ActionContext(httpContext.Object, new RouteData(), new ControllerActionDescriptor()
            {
                ActionName = "Index"
            });

            var httpRequest             = new Mock <HttpRequest>();
            var actionExecutionDelegate = new Mock <ActionExecutionDelegate>();

            httpRequest.SetupGet(x => x.Method).Returns("POST");
            httpContext.SetupGet(x => x.Request).Returns(httpRequest.Object);

            var controller = new Mock <Controller>();

            var actionExecutingContext = new ActionExecutingContext(actionContext, new List <IFilterMetadata>(), new RouteValueDictionary(), controller.Object);

            await actionFilter.OnActionExecutionAsync(actionExecutingContext, actionExecutionDelegate.Object);

            actionExecutingContext.Result.Should().BeOfType <RedirectToActionResult>();
        }
Ejemplo n.º 21
0
        public override Task <TestReply> UnitTest(TestRequest request, ServerCallContext context)
        {
            bool finishFlag = false;

            MainThreadUtility.Instance.EnqueueAction(delegate
            {
                UnitTestServer.TestCall();
            });
            while (!finishFlag)
            {
                if (UnitTestServer.IsEnd())
                {
                    finishFlag = true;
                }
            }

            return(Task.FromResult(new TestReply {
                Message = "test reply " + request.Name + "," + UnitTestServer.GetResultDes()
            }));
        }
Ejemplo n.º 22
0
        public string SaveReqTest(TestRequest tReq)
        {
            int count = 0;

            foreach (var test in tReq.PTestList)
            {
                tReq.TestReqId = test.TestId;
                int rowAfftect = testReqGateway.SaveReqTest(tReq);
                if (rowAfftect > 0)
                {
                    count++;
                }
            }

            if (tReq.PTestList.Count == count)
            {
                return("Success");
            }
            return("Tests not saved.");
        }
Ejemplo n.º 23
0
            public void PerRequest_Uses_All_ExecutionContextExtensionInitialisers_To_Initialise_The_Current_ExecutionContext()
            {
                var request          = new TestRequest();
                var executionContext = Mock.Of <IExecutionContext>();
                var executionContextExtensionInitialisers =
                    GetExecutionContextExtensionInitialisers <TestRequest>(GetRand(10))
                    .ToArray(); // To get the final list

                CreateSubjectUnderTest(
                    executionContext,
                    executionContextExtensionInitialisers)
                .PerRequest(request);

                foreach (var executionContextExtensionInitialiser in
                         executionContextExtensionInitialisers)
                {
                    Mock.Get(executionContextExtensionInitialiser)
                    .Verify(e => e.Append(request), Times.Once());
                }
            }
Ejemplo n.º 24
0
        public void Should_Not_Run_Other_Handlers_When_Main_Handler_Failed()
        {
            var sut = IocHelper.GetRequestBus(sc =>
            {
                sc.AddTransient <IResponseHandler <TestRequest, TestResult>, DependentResponseHandler>();
                sc.AddTransient <IResponseHandler <TestRequest, TestResult>, IndependentResponseHandler>();
                sc.AddTransient <IResponseHandler <TestRequest, TestResult>, MainFailedResponseHandler>();
                sc.AddTransient <IResponseHandler <TestRequest, TestResult>, DependentNonApplicableResponseHandler>();
            });

            var request = new TestRequest
            {
                Name = "Ruhul"
            };

            var rsp = sut.Responses <TestRequest, TestResult>(request);

            rsp.MainResponse().IsSucceed.ShouldBe(false);
            rsp.MainResponse().Errors.Count().ShouldBe(0);
        }
 protected void btnSave_Click(object sender, EventArgs e)
 {
     try
     {
         TestRequest aTestRequest = new TestRequest();
         aTestRequest.PatientName  = txtPatientName.Text;
         aTestRequest.DateOfBirth  = txtDBO.Text;
         aTestRequest.MobileNumber = txtMobileNo.Text;
         DataTable dtList = (DataTable)ViewState["TableList"];
         string    Alert  = aTestRequestManager.SaveTestRequest(aTestRequest, dtList);
         ClientScript.RegisterStartupScript(this.GetType(), "Warning", "alert('" + Alert + "');", true);
         hfMstID.Value = DataTransfection.GetShowSingleValueInt("TOP(1)ID", "TestRequestMst order by ID desc").ToString();
         TestReport();
         btnSave.Enabled = false;
     }
     catch (Exception ex)
     {
         ClientScript.RegisterStartupScript(this.GetType(), "Warning", "alert('" + ex.Message + "');", true);
     }
 }
Ejemplo n.º 26
0
        public void Exception_In_NonMain_Handler_Should_Not_Stop_Other_Handlers_Execution()
        {
            var sut = IocHelper.GetRequestBus(sc =>
            {
                sc.AddTransient <IResponseHandler <TestRequest, TestResult>, InDependentHandlerWithException>();
                sc.AddTransient <IResponseHandler <TestRequest, TestResult>, DependentHandlerWithException>();
                sc.AddTransient <IResponseHandler <TestRequest, TestResult>, MainResponseHandler>();
            });

            var request = new TestRequest
            {
                Name = "Ruhul"
            };

            var rsp = sut.Responses <TestRequest, TestResult>(request);

            rsp.MainResponse().IsSucceed.ShouldBe(true);
            rsp.MainResponse().Value.Message.ShouldBe($"{request.Name} : handled by {nameof(MainResponseHandler)}");
            rsp.MainResponse().Errors.Count().ShouldBe(0);
        }
Ejemplo n.º 27
0
        //sends test request to Test Harness
        private void submitTestRequestButton_Click(object sender, RoutedEventArgs e)
        {
            XDocument testRquestDoc = new XDocument();

            testRquestDoc = XDocument.Load(TestRequest.Text);
            TestRequest TRobj = testRquestDoc.ToString().FromXml <TestRequest>();

            Messages.Message msg = new Messages.Message();
            msg.body = testRquestDoc.ToString();
            msg.type = "TestRequest";
            msg.from = Comm <Client3> .makeEndPoint(url, clientPort);

            msg.to = Comm <Client3> .makeEndPoint(url, THport);

            msg.time   = DateTime.Now;
            msg.author = TRobj.author;
            Console.WriteLine("**********Requirement 2 & 6: Test Request  sent to TestHarness");
            Console.WriteLine(msg.body);
            objComm.sndr.PostMessage(msg);
        }
Ejemplo n.º 28
0
        public async Task Process_UnregisteredHandler_ReturnsUnsuccessfulResult()
        {
            // arrange
            var autoMocker      = new AutoMocker();
            var serviceProvider = autoMocker.GetMock <IServiceProvider>();

            serviceProvider.Setup(s => s.GetService(typeof(IHandler <TestRequest, bool>)))
            .Returns(null);
            autoMocker.Use <IEnumerable <IInterceptor> >(new List <IInterceptor>());
            var sut     = autoMocker.CreateInstance <BoltOn.Mediator.Pipeline.Mediator>();
            var request = new TestRequest();

            // act
            var result = await Record.ExceptionAsync(() => sut.ProcessAsync(request));

            // assert
            Assert.NotNull(result);
            Assert.Equal(string.Format(Constants.ExceptionMessages.
                                       HANDLER_NOT_FOUND, request), result.Message);
        }
        public async Task ConfigurationResultType_ResultModelType_Mismatch_Fails()
        {
            var requestModel  = new TestRequest();
            var modelProvider = new Mock <IRequestModelProvider>();

            modelProvider.Setup(x => x.GetCurrentRequestModel()).Returns(requestModel);

            var listConfiguration = new Mock <IListConfiguration>();

            listConfiguration.SetupGet(x => x.ResultType).Returns(typeof(TestItem));

            var configurationProvider = new Mock <IListConfigurationProvider>();

            configurationProvider.Setup(x => x.GetConfiguration(It.IsAny <Type>())).Returns(listConfiguration.Object);

            var actionFilter = new TransferValuesActionFilter(modelProvider.Object, configurationProvider.Object);

            var httpContext   = new Mock <HttpContext>();
            var actionContext = new ActionContext(httpContext.Object, new RouteData(), new ControllerActionDescriptor());

            var controller = new Mock <Controller>();

            var httpRequest             = new Mock <HttpRequest>();
            var actionExecutionDelegate = new Mock <ActionExecutionDelegate>();
            var result = new JsonResult(new TestResult());
            var actionExecutedContext =
                new ActionExecutedContext(actionContext, new List <IFilterMetadata>(), controller.Object)
            {
                Result = result
            };

            actionExecutionDelegate.Setup(x => x.Invoke()).ReturnsAsync(() => actionExecutedContext);

            httpContext.SetupGet(x => x.Request).Returns(httpRequest.Object);

            var actionExecutingContext = new ActionExecutingContext(actionContext, new List <IFilterMetadata>(), new RouteValueDictionary(), controller.Object);

            await actionFilter.OnActionExecutionAsync(actionExecutingContext, actionExecutionDelegate.Object);

            actionExecutingContext.Result.Should().BeNull();
        }
Ejemplo n.º 30
0
        //Parse the test request recieved from Mother builder
        TestRequest parseTest()
        {
            TestRequest parsed = new TestRequest();
            XDocument   doc    = XDocument.Parse(testRequest);

            doc.Save(Dir + "/BuildRequest.xml");
            Console.WriteLine(Dir + "/BuildRequest.xml");

            TestRequest parser = new TestRequest();

            parsed = parser.parseXML(Dir, "BuildRequest.xml");
            foreach (Test test in parsed.test)
            {
                fileName.Add(test.testDriver);
                foreach (string file in test.testedFiles)
                {
                    fileName.Add(file);
                }
            }
            return(parsed);
        }
Ejemplo n.º 31
0
        public void SingleGaugeTest()
        {
            var         metrics     = new Metrics();
            string      metricName  = "GaugeMetric";
            GaugeMetric gaugeMetric = metrics.Gauge("test", metricName, GetNumberOfUsersLoggedIn);

            DataDogReporter reporter = CreateDefaultReporter(metrics);

            TestRequest request = new TestRequest();

            reporter.TransformMetrics(request, metrics, 0);

            IDictionary <string, DatadogSeries> convertedMetrics = request.Metrics;

            Assert.AreEqual(1, convertedMetrics.Count);
            DatadogSeries metric = convertedMetrics[APP + "." + DOMAIN + "." + metricName];

            Assert.NotNull(metric);
            Assert.IsTrue(metric is DatadogGauge);
            ValidateDefaultTags(metric.Tags);
        }
Ejemplo n.º 32
0
        public void SingleCounterTest()
        {
            var           metrics    = new Metrics();
            string        metricName = "CounterMetric";
            CounterMetric counter    = metrics.Counter("test", metricName);

            DataDogReporter reporter = CreateDefaultReporter(metrics);

            TestRequest request = new TestRequest();

            reporter.TransformMetrics(request, metrics, 0);

            IDictionary <string, DatadogSeries> convertedMetrics = request.Metrics;

            Assert.AreEqual(1, convertedMetrics.Count);
            DatadogSeries metric = convertedMetrics[APP + "." + DOMAIN + "." + metricName];

            Assert.NotNull(metric);
            Assert.IsTrue(metric is DatadogCounter);
            ValidateDefaultTags(metric.Tags);
        }
        public void LaunchServerAndHandleRequestResponseSync()
        {
            using var server = FunicularConnectionFactory.New(_serviceProvider).CreateServer("test-pipe");
            var client = FunicularClientFactory.New()
                         .CreateClient("test-pipe", (pipe, error) => _testOutputHelper.WriteLine($"{pipe}: {error.Message}"));

            var request = new TestRequest
            {
                StringField = "requestedFiled"
            };

            var cancellationTokenSource = new CancellationTokenSource();

            server.StartListening(
                (error, pipe) => _testOutputHelper.WriteLine($"{pipe}: {error.Message}"),
                cancellationTokenSource.Token);
            var response = client.Send <TestRequest, TestResponse>("test/receive-and-return", request);

            response.StringField.ShouldBe($"Received: {request.StringField} from pipe test-pipe");
            cancellationTokenSource.Cancel();
        }
Ejemplo n.º 34
0
        public async Task Process_RegisteredHandlerThatReturnsBool_ReturnsSuccessfulResult()
        {
            // arrange
            var autoMocker      = new AutoMocker();
            var serviceProvider = autoMocker.GetMock <IServiceProvider>();
            var testHandler     = new Mock <TestHandler>();

            serviceProvider.Setup(s => s.GetService(typeof(IHandler <TestRequest, bool>)))
            .Returns(testHandler.Object);
            autoMocker.Use <IEnumerable <IInterceptor> >(new List <IInterceptor>());
            var sut     = autoMocker.CreateInstance <BoltOn.Requestor.Pipeline.Requestor>();
            var request = new TestRequest();

            testHandler.Setup(s => s.HandleAsync(request, It.IsAny <CancellationToken>())).Returns(Task.FromResult(true));

            // act
            var result = await sut.ProcessAsync(request);

            // assert
            Assert.True(result);
        }
Ejemplo n.º 35
0
        public void Process_RegisteredHandlerThatReturnsBool_ReturnsSuccessfulResult()
        {
            // arrange
            var autoMocker      = new AutoMocker();
            var serviceProvider = autoMocker.GetMock <IServiceProvider>();
            var testHandler     = new Mock <TestHandler>();

            serviceProvider.Setup(s => s.GetService(typeof(IRequestHandler <TestRequest, bool>)))
            .Returns(testHandler.Object);
            autoMocker.Use <IEnumerable <IInterceptor> >(new List <IInterceptor>());
            var sut     = autoMocker.CreateInstance <BoltOn.Mediator.Pipeline.Mediator>();
            var request = new TestRequest();

            testHandler.Setup(s => s.Handle(request)).Returns(true);

            // act
            var result = sut.Process(request);

            // assert
            Assert.True(result);
        }
        public async Task UnhandledException_AvailableThroughLastExceptionFilter()
        {
            var expectedException = new Exception("test");

            var handler = new GrpcRequestHandler <TestRequest, TestResponse>
            {
                Method  = TestService.Descriptor.FindMethodByName("TestThrow"),
                Handler = (req, ctx) => throw expectedException
            };

            GrpcHandlers = new[] { handler };
            Build();

            var request = new TestRequest();
            var client  = new TestService.TestServiceClient(Channel);

            _ = await Assert.ThrowsAsync <RpcException>(async() => await client.TestThrowAsync(request));

            Assert.Same(expectedException, SentryGrpcTestInterceptor.LastException);
        }
    }
Ejemplo n.º 37
0
        public void Input_binding_summary_for_dictionary_value_name_map_as_expected(bool isMappedValue, string expectedSummary)
        {
            var request = new TestRequest();

            var requestType     = request.GetType().GetFlowObjectType();
            var requestProperty = requestType[nameof(TestRequest.InputStrings)];

            var inputBinding = new FlowValueInputBinding(requestProperty)
            {
                FlowValueSelector = new FlowValueListSelector(new Dictionary <string, string>
                {
                    { "FlowValue1", "DictionaryValue1" },
                    { "FlowValue2", "DictionaryValue2" },
                }),
                MapValue = isMappedValue ? v => v : (Func <object, object>)null,
            };

            var summary = inputBinding.GetSummary(request);

            Assert.Equal(expectedSummary, summary);
        }
Ejemplo n.º 38
0
        protected override string CallSingleImpl(TestRequest request)
        {
            switch (request)
            {
            case GetBlockCount req:
                return(service.GetBlockCount().ToString());

            case GetTransaction req:
                return(service.GetTransaction(req.TxId, (bool?)req.IncludeWatchOnly).ToString());

            case GetRawTransaction req:
                var tx = service.GetRawTransaction(req.TxId, req.Verbose.GetValueOrDefault(0));
                return(tx?.Hex);

            case DecodeRawTransaction req:
                return(service.DecodeRawTransaction(req.HexString).ToString());

            default:
                throw new NotImplementedException(request.MethodName);
            }
        }
Ejemplo n.º 39
0
        public override TestResponse Execute(TestRequest testRequest)
        {
            if (testRequest.TestStep == "1")
            {
                if (Validate(testRequest) == true)
                {
                    Response = this.VerifyFirstStep(CreditCardTransactionDataCollection, testRequest);
                }
            }
            else if (testRequest.TestStep == "2")
            {
                if (Validate(testRequest) == true)
                {
                    Response = this.VerifySecondStep(CreditCardTransactionDataCollection, testRequest);
                }
            }



            return(Response);
        }
        /*----< used to create test request >-----------------------------------------*/
        private void Createrequest(object sender, RoutedEventArgs e)
        {
            TestRequest tr = new TestRequest();

            string[] fname;
            if (test.Items.Count != 0)
            {
                for (int i = 1; i <= test.Items.Count; i++)
                {
                    TestElement te = new TestElement();
                    te.testName = testlist[tccnt];
                    fname       = tcfilenames[tccnt].Split(new char[0]);
                    for (int j = 0; j < fname.Length; j++)
                    {
                        if (fname[j].ToString().StartsWith("testdriver"))
                        {
                            te.addDriver(fname[j]);
                        }
                        else
                        {
                            te.addCode(fname[j]);
                        }
                    }
                    tr.author = "Dinesh";
                    tr.tests.Add(te);
                    string xml      = tr.ToXml();
                    string filename = "TestRequest_" + xmlcnt + "_" + DateTime.Now.ToString("MMddyyyyHHmmssfff") + ".xml";
                    sendTestRequestToRepo(filename + "," + xml);
                    request.Items.Add(filename);
                    test.Items.Clear();
                    tccnt = tccnt + 1;
                }
                xmlcnt       = xmlcnt + 1;
                requestcount = requestcount + 1;
            }
            else
            {
                MessageBox.Show(String.Format("No tests available to create request.! Please create test!"));
            }
        }
        private void button2_Click(object sender, RoutedEventArgs e)
        {
            if (listbox2.HasItems)
            {
                count++;
            }
            TestElement te1 = new TestElement();

            te1.testName = "test1";
            for (int i = 0; i < stringList.Count; i++)
            {
                if (stringList[i].ToString().StartsWith(value:"td"))
                {
                    te1.addDriver(stringList[i].ToString());
                }
                else
                {
                    te1.addCode(stringList[i].ToString());
                }
            }
            TestRequest tr = new TestRequest();

            tr.author = "Nitish Kumar";
            tr.tests.Add(te1);

            string trXml = tr.ToXml();

            TestRequest newRequest = trXml.FromXml <TestRequest>();
            string      typeName   = newRequest.GetType().Name;

            if (listbox2.HasItems)
            {
                testRequestName = "testrequest" + System.DateTime.Now.Millisecond + ".xml";
                File.WriteAllText(RepoEnvironment.fileStorage + "\\" + testRequestName, trXml);
            }

            listbox2.Items.Clear();
            PopulateListBox(listbox3, stringList, "listbox3");
            stringList.Clear();
        }
Ejemplo n.º 42
0
 public void When_a_query_is_sent()
 {
     var request = new TestRequest {CorrelationTag = "this is a query"};
     _response = Bus.Send (request);
 }
Ejemplo n.º 43
0
 public TestResponse Handle(TestRequest request)
 {
     Logger.LogInfo("Handled TestRequest with TestResponse");
     return new TestResponse() { Size = Environment.TickCount };
 }
Ejemplo n.º 44
0
        public async Task Should_send_plain_message_and_wait_for_response()
        {
            IServiceLocator serviceLocator = TestRig.CreateTestServiceLocator();

            var messageProcessor = serviceLocator.ResolveType<IMessageCodec>();

            var request = new TestRequest {TestId = 9};
            var expectedResponse = new TestResponse {TestId = 9, TestText = "Number 1"};
            var expectedResponseMessage = new Message(0x0102030405060708, 0, expectedResponse);
            byte[] expectedResponseMessageBytes = messageProcessor.EncodePlainMessage(expectedResponseMessage);

            SetupMockTransportWhichReturnsBytes(serviceLocator, expectedResponseMessageBytes);

            using (var connection = serviceLocator.ResolveType<IMTProtoClientConnection>())
            {
                await connection.Connect();

                // Testing sending a plain message.
                TestResponse response = await connection.RequestAsync<TestResponse>(request, MessageSendingFlags.None, TimeSpan.FromSeconds(5));
                response.Should().NotBeNull();
                response.Should().Be(expectedResponse);

                await connection.Disconnect();
            }
        }
            public async Task RequestRequesterIdEndsUpAsReplyToSessionId()
            {
                Mock<IMessageSender> mockMessageSender = new Mock<IMessageSender>();

                BrokeredMessage brokeredMessageSent = null;

                mockMessageSender.Setup(ms => ms.SendAsync(It.IsAny<BrokeredMessage>()))
                    .Callback<BrokeredMessage>(bm =>
                    {
                        brokeredMessageSent = bm;
                    })
                    .Returns(Task.FromResult<object>(null));

                Mock<IMessageSerializer> mockMessageSerializer = new Mock<IMessageSerializer>();

                Mock<IMessagePropertyProvider<TestMessage>> mockMessagePropertyProvider = new Mock<IMessagePropertyProvider<TestMessage>>();

                MessagePublisher<TestMessage> messagePublisher = new MessagePublisher<TestMessage>(mockMessageSender.Object, mockMessageSerializer.Object, mockMessagePropertyProvider.Object);

                TestRequest request = new TestRequest
                {
                    RequesterId = "TestRequesterId"
                };

                await messagePublisher.PublishAsync(request);

                mockMessageSender.Verify(ms => ms.SendAsync(It.IsAny<BrokeredMessage>()), Times.Once());

                brokeredMessageSent.Should().NotBeNull();
                brokeredMessageSent.ReplyToSessionId.Should().Be(request.RequesterId);
            }
 public object Get(TestRequest request)
 {
     return "OK";
 }
 public void QueryStringSerializer_TestRequest_output()
 {
     var testRequest = new TestRequest { ListOfA = new List<A> { new A { ListOfB = new List<B> { new B { Property = "prop1" }, new B { Property = "prop2" } } } } };
     var str = QueryStringSerializer.SerializeToString(testRequest);
     Assert.That(str, Is.EqualTo("ListOfA={ListOfB:[{Property:prop1},{Property:prop2}]}"));
 }
 public IHttpActionResult TestMethod(TestRequest request)
 {
     return Handle(request);
 }
Ejemplo n.º 49
0
			public string TestDataContract(TestRequest request)
			{
				return string.Format("Hello, {0}!", request.Name);
			}
Ejemplo n.º 50
0
 public void Constructor_SerialisesCommandNameProperly()
 {
     var request = new TestRequest();
     request.Command.ShouldBe(TestRequest.COMMANDNAME);
     request.Parameters["command"].ShouldBe(TestRequest.COMMANDNAME);
 }