private static QueryExecutorFactory QueryExecutorFactory()
        {
            var containerMock = new Mock <IWindsorContainer>();

            var factory = new QueryExecutorFactory(containerMock.Object);

            return(factory);
        }
        private static QueryExecutorFactory Factory()
        {
            var resolverMock     = new Mock <IResolver>();
            var queryHandlerMock = new Mock <IQueryHandler <SomeQuery, SomeObject> >();

            resolverMock.Setup(p => p.Resolve(typeof(QueryExecutor <SomeQuery, SomeObject>)))
            .Returns(new QueryExecutor <SomeQuery, SomeObject>(queryHandlerMock.Object));

            var executorFactory = new QueryExecutorFactory(resolverMock.Object);

            return(executorFactory);
        }
Example #3
0
        public async Task HelloQuery_Test()
        {
            //arrange
            IQueryExecutor        queryExecutor = QueryExecutorFactory.Create <HelloQuery>();
            IReadOnlyQueryRequest request       = QueryRequestBuilder.New()
                                                  .SetQuery("{hello}")
                                                  .AddProperty("key", "value")
                                                  .Create();
            //act
            IExecutionResult result = await queryExecutor.ExecuteAsync(request);

            //assert
            result.MatchSnapshot();
        }
Example #4
0
        /// <summary>
        /// Compares the specified comparer.
        /// </summary>
        /// <param name="comparer">The comparer.</param>
        /// <param name="currentItem">The current item.</param>
        /// <returns></returns>
        private string Compare(DataComparer comparer, ValidationAction currentItem)
        {
            StringBuilder summary = new StringBuilder();

            Console.WriteLine("Currently executing : " + currentItem.SourceQueryFileName);

            IQueryExecutor sqlQueryExecutor = QueryExecutorFactory.GetQueryExecutor();

            IQueryReader qReader = QueryReaderFactory.GetQueryReader();

            DataTable dt1 = new DataTable();
            DataTable dt2 = new DataTable();

            dt1 = sqlQueryExecutor.Execute(qReader.GetQuery(currentItem.SourceQueryFileName), DatabaseType.Source);
            dt2 = sqlQueryExecutor.Execute(qReader.GetQuery(currentItem.DestinationQueryFileName), DatabaseType.Destination);

            Stopwatch sw = new Stopwatch();

            sw.Start();

            comparer.Compare(dt1, dt2);

            sw.Stop();

            Console.WriteLine(sw.ElapsedMilliseconds.ToString() + " ms");
            Console.WriteLine("--------------------------------------------------------");

            summary.AppendLine(currentItem.SourceQueryFileName);

            summary.Append("Number of records in Source table : ").Append(dt1.Rows.Count);
            summary.AppendLine();
            summary.Append("Number of records in Destination table : ").Append(dt2.Rows.Count);
            summary.AppendLine();
            summary.Append("Time taken : ").Append(sw.ElapsedMilliseconds);
            summary.AppendLine();
            summary.AppendLine("-----------------------------------------------------------------");

            return(summary.ToString());
        }
Example #5
0
        public async Task GetCinema_With_Results()
        {
            //arrange

            Mock <ICinemaLogic> cinemaLogicMock = new Mock <ICinemaLogic>();

            cinemaLogicMock.Setup(p => p.GetCinemas()).Returns(_GetCinemaList());
            Mock <IServiceProvider> serviceProvider = new Mock <IServiceProvider>();

            serviceProvider.Setup(p => p.GetService(typeof(ICinemaLogic))).Returns(cinemaLogicMock.Object);

            IQueryExecutor        queryExecutor = QueryExecutorFactory.Create <CinemaQuery>();
            IReadOnlyQueryRequest queryRequest  = QueryRequestBuilder.New()
                                                  .SetQuery(@"query GetAllCinemas{
                          cinemas{
                            edges{
                              cursor
                            }
                            nodes{
                              title
                              description
                              iD
                              duration
                            }
                          }
                        }")
                                                  .AddProperty("Key", "value")
                                                  .SetServices(serviceProvider.Object)
                                                  .Create();

            //act
            IExecutionResult result = await queryExecutor.ExecuteAsync(queryRequest);

            //assert
            result.MatchSnapshot();
        }