Example #1
0
        public void VariableOutputProcedureReplacementWithAnyParam()
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };

            const string TEXT_MESSAGE = "This is a test and nothing but a test";

            dataMock.Setup( dc => dc.VariableOutputProcB( Param.IsAny<int>() ) )
                .Returns( new VariableOutputProcBResult
                {
                    Id = 5,
                    TextMessage = TEXT_MESSAGE
                } );

            dataMock.Execute( Settings.Default.DataMockConnectionString );

            var dataContext = new DataMockDataContext();

            var result = dataContext.VariableOutputProcA( 3 ).ToArray();

            Assert.AreEqual( 5, result[0].Id );
            Assert.AreEqual( 5, result[1].Id );
            Assert.AreEqual( 5, result[2].Id );
        }
        public async Task <ActionResult> GenerateItems()
        {
            // Generating random values
            var products = DataMock.MockProducts(50000);

            // Deleting Data
            _productRepository.RemoveRange(_productRepository.GetAll());
            await _uow.Commit();

            int i = 0;

            foreach (var product in products)
            {
                _productRepository.Add(product);

                i++;
                if (i % 100 == 0)
                {
                    await _uow.Commit();
                }
            }
            await _uow.Commit();

            return(RedirectToAction("Index"));
        }
 public TestEnvironmentBase()
 {
     dbFactory   = new DbFactory();
     dataContext = dbFactory.Get();
     unitOfWork  = new UnitOfWork(dbFactory);
     DataMock.Seed();
 }
Example #4
0
        private void _DoMockRemovalTest(string objectName, Action<DataMock<DataMockDataContext>> setupMock)
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };

            setupMock(dataMock);

            string dataMockConnectionString = Settings.Default.DataMockConnectionString;
            dataMock.Execute(dataMockConnectionString);
            dataMock.RemoveMocks(dataMockConnectionString);

            using (var connection = new SqlConnection(dataMockConnectionString))
            {
                connection.Open();
                SqlCommand command = connection.CreateCommand();

                command.CommandText =
                    @"select
                        1
                    WHERE NOT EXISTS ( SELECT NULL FROM sys.objects WHERE Name = @ObjectName )";

                command.Parameters.AddWithValue("@ObjectName", objectName);

                object result = command.ExecuteScalar();

                Assert.AreEqual(result, 1);
            }
        }
Example #5
0
        public void NoParameterProcedureReplacement()
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };

            const string TEXT_MESSAGE = "This is a test and nothing but a test";

            dataMock.Setup( dc => dc.NoParametersProcB() )
                .Returns( new NoParametersProcBResult
                {
                    ID = 5,
                    TextMessage = TEXT_MESSAGE
                } );

            dataMock.Execute( Settings.Default.DataMockConnectionString );

            var dataContext = new DataMockDataContext();

            var result = dataContext.NoParametersProcA().ToArray();

            Assert.AreEqual( result[0].TextMessage, TEXT_MESSAGE );
            Assert.AreEqual( result[0].Id, 5 );
            Assert.AreEqual( result[1].TextMessage, "Message from Proc A" );
            Assert.AreEqual( result[1].Id, 10 );
        }
 private void _InvalidMockTest( string expectedExceptionMessage, Action<DataMock<DataMockDataContext>> mockSetup )
 {
     var dataMock = new DataMock<DataMockDataContext>();
     try
     {
         mockSetup( dataMock );
     }
     catch( Exception exception )
     {
         Console.WriteLine( exception.Message );
         Assert.AreEqual( exception.Message, expectedExceptionMessage );
     }
 }
        public ProductModel AddNewProduct(AddProductModel product)
        {
            ProductModel addedProduct = new ProductModel()
            {
                ID    = _productsList.Max(x => x.ID) + 1,
                Name  = product.Name,
                Price = product.Price,
                Color = product.Color,
                IBAN  = DataMock.GenerateIBan()
            };

            _productsList.Add(addedProduct);
            return(addedProduct);
        }
Example #8
0
        public void Add_sale()
        {
            var conn = new SqliteConnection("DataSource=:memory:");

            conn.Open();

            try
            {
                var options = new DbContextOptionsBuilder <DatabaseContext>()
                              .UseSqlite(conn)
                              .Options;

                using (var context = new DatabaseContext(options))
                {
                    context.Database.EnsureCreated();
                }

                using (var context = new DatabaseContext(options))
                {
                    CashbackService cashbackService = new CashbackService(new CashbackRepository(context));
                    cashbackService.InitializeCashbackDatabase();

                    AlbumService albumService = new AlbumService(new AlbumRepository(context));

                    DataMock
                    .GenerateAlbums()
                    .ToList()
                    .ForEach(album => albumService.Add(album));

                    var albums = albumService.GetPaged(1, 5).ToList();

                    List <AlbumDTO> dtos = new List <AlbumDTO>();

                    albums.ForEach(x => dtos.Add(x.ConvertTo(typeof(AlbumDTO))));

                    SaleService saleService = new SaleService(new SaleRepository(context), cashbackService, albumService);

                    int insertedId = saleService.RegisterSale(dtos);

                    Assert.Equal(1, insertedId);
                }
            }
            finally
            {
                conn.Close();
            }
        }
Example #9
0
        public void MockFunctionWithExactParameters()
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };

            const int QUERY_INT = 10;
            const string QUERY_STRING = "TEST";
            var queryGuid = Guid.NewGuid();
            var queryDate = DateTime.Today;
            const bool QUERY_BIT = true;
            const char QUERY_CHAR = ' ';

            const int RESULT_INT = 1;
            const string RESULT_STRING = "12345";
            var resultGuid = Guid.Empty;
            var resultDate = new DateTime(2012, 1, 1);
            const bool RESULT_BIT = true;
            const char RESULT_CHAR = 'A';

            dataMock
                .Setup(context => context.DataTypesFunction(QUERY_INT, QUERY_STRING, queryGuid, queryDate, QUERY_BIT, QUERY_CHAR))
                .Returns(new DataTypesFunctionResult
                {
                    c1 = RESULT_INT,
                    c2 = RESULT_STRING,
                    c3 = resultGuid,
                    c4 = resultDate,
                    c5 = RESULT_BIT,
                    c6 = RESULT_CHAR
                });
            dataMock.Execute(Settings.Default.DataMockConnectionString);

            using (var context = new DataMockDataContext(Settings.Default.DataMockConnectionString))
            {
                DataTypesFunctionResult result = context.DataTypesFunction(QUERY_INT, QUERY_STRING, queryGuid, queryDate, QUERY_BIT, QUERY_CHAR).Single();
                Assert.AreEqual(RESULT_INT, result.c1);
                Assert.AreEqual(RESULT_STRING, result.c2);
                Assert.AreEqual(resultGuid, result.c3);
                Assert.AreEqual(resultDate, result.c4);
                Assert.AreEqual(RESULT_BIT, result.c5);
                Assert.AreEqual(RESULT_CHAR, result.c6);
            }
        }
Example #10
0
        public void MockBooleanScalarFunction()
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };

            using (var context = new DataMockDataContext(Settings.Default.DataMockConnectionString))
            {
                Assert.AreEqual(true, context.ScalarFunctionBoolean(1));

                dataMock
                    .Setup(ctx => ctx.ScalarFunctionBoolean(Param.IsAny<int?>()))
                    .Returns(false);

                dataMock.Execute(Settings.Default.DataMockConnectionString);

                Assert.AreEqual(false, context.ScalarFunctionBoolean(1));
            }
        }
        public void Get_albums_through_pagination()
        {
            var conn = new SqliteConnection("DataSource=:memory:");

            conn.Open();

            try
            {
                var options = new DbContextOptionsBuilder <DatabaseContext>()
                              .UseSqlite(conn)
                              .Options;

                using (var context = new DatabaseContext(options))
                {
                    context.Database.EnsureCreated();
                }

                using (var context = new DatabaseContext(options))
                {
                    var repository = new AlbumRepository(context);

                    DataMock
                    .GenerateAlbums()
                    .ToList()
                    .ForEach(album => repository.Insert(album));
                }

                using (var context = new DatabaseContext(options))
                {
                    AlbumService service = new AlbumService(new AlbumRepository(context));
                    Assert.Equal(10, service.GetPaged(2, 10, "rock").Count());
                    Assert.Equal(10, service.GetPaged(2, 10).Count());
                }
            }
            finally
            {
                conn.Close();
            }
        }
        public void Get_albums_through_id(int id, int no_id)
        {
            var conn = new SqliteConnection("DataSource=:memory:");

            conn.Open();

            try
            {
                var options = new DbContextOptionsBuilder <DatabaseContext>()
                              .UseSqlite(conn)
                              .Options;

                using (var context = new DatabaseContext(options))
                {
                    context.Database.EnsureCreated();
                }

                using (var context = new DatabaseContext(options))
                {
                    var repository = new AlbumRepository(context);

                    DataMock
                    .GenerateAlbums()
                    .ToList()
                    .ForEach(album => repository.Insert(album));
                }

                using (var context = new DatabaseContext(options))
                {
                    AlbumService service = new AlbumService(new AlbumRepository(context));
                    Assert.NotNull(service.FindById(id));
                    Assert.Null(service.FindById(no_id));
                }
            }
            finally
            {
                conn.Close();
            }
        }
Example #13
0
        public void FinalizeExistingOrder()
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };

            const int NEXT_SEQUENCE = 3;
            dataMock
                .Setup( context => context.GetNextOrderSequence())
                .Returns(NEXT_SEQUENCE);

            using (var context = new DataMockDataContext(Settings.Default.DataMockConnectionString))
            {
                //Disable all check constraints on the Order table to simplify inserting test data
                context.DisableAllCheckConstraints<DataMockDataContext, Order>();

                //Create an Order object, and set its properties to sensible default values
                var orderToUpdate = new Order();
                DataMockHelper.DefaultValues(orderToUpdate);

                //add the order to the database
                context.Orders.InsertOnSubmit(orderToUpdate);
                context.SubmitChanges();

                //create the mocked implementation of GetNextOrderSequence()
                dataMock.Execute(Settings.Default.DataMockConnectionString);

                //execute the FinalizeOrder procedure and verify its results
                FinalizeOrderResult finalizeOrderResult = context.FinalizeOrder(orderToUpdate.OrderId).SingleOrDefault();

                Assert.IsNotNull(finalizeOrderResult);
                Assert.AreEqual(NEXT_SEQUENCE, finalizeOrderResult.Sequence);

                //verify that the procedure updated the order table
                context.Refresh(RefreshMode.OverwriteCurrentValues, orderToUpdate);
                Assert.AreEqual(NEXT_SEQUENCE, orderToUpdate.OrderSequenceNumber);
            }
        }
        public void Create_Data_CreatedUsingDataIdentifier()
        {
            var descriptor     = new Mock <ITerminalDescriptor>().Object;
            var dataIdentifier = new object();

            DataMock
            .Setup(_ => _.DataIdentifier)
            .Returns(dataIdentifier)
            .Verifiable();

            TestInstanceMock
            .Setup(_ => _.Create(dataIdentifier))
            .Returns(descriptor)
            .Verifiable();

            var result = TestInstance.Create(Data);

            DataMock.Verify();
            TestInstanceMock.Verify();

            Assert.AreSame(descriptor, result);
        }
 public void SetupCookie() => DataMock.Setup(d => d.GetSession()).Returns(cookie);
Example #16
0
        public void MockViewWithOneRow()
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };
            const string CHILD = "Robert";
            const string PARENT = "Maude";
            dataMock
                .Setup( context => context.Peoples )
                .Returns( new People
                {
                    Child = CHILD,
                    Parent = PARENT
                } );
            dataMock.Execute( Settings.Default.DataMockConnectionString );

            using( var context = new DataMockDataContext() )
            {
                People person = context.Peoples.Single();
                Assert.IsTrue( person.Child == CHILD );
                Assert.IsTrue( person.Parent == PARENT );
            }
        }
Example #17
0
        public void MockViewWithMultipleSetupCalls()
        {
            var dataMock = new DataMock<DataMockDataContext>();

            const string MARY = "Mary";
            const string TRACY = "Tracy";
            const string CATHERINE = "Catherine";
            const string JOE = "Joe";
            const string JOHN = "John";

            var parents = new[] { MARY, TRACY };
            var children = new [] { JOHN, JOE, CATHERINE };

            dataMock
                .Setup( context => context.Peoples )
                .Returns(
                    new People
                    {
                        Child = CATHERINE,
                        Parent = MARY
                    },
                    new People
                    {
                        Child = JOE,
                        Parent = MARY
                    },
                    new People
                    {
                        Child = JOHN,
                        Parent = MARY
                    } );

            dataMock
                .Setup( context => context.Peoples )
                .Returns(
                    new People
                    {
                        Child = CATHERINE,
                        Parent = TRACY
                    },
                    new People
                    {
                        Child = JOE,
                        Parent = TRACY
                    },
                    new People
                    {
                        Child = JOHN,
                        Parent = TRACY
                    } );
            dataMock.Execute(Settings.Default.DataMockConnectionString);

            People[] people;
            using( var context = new DataMockDataContext() )
            {
                people = context.Peoples
                    .OrderBy( person => person.Parent )
                    .ThenBy( person => person.Child )
                    .ToArray();
            }

            Assert.AreEqual( 6, people.Length );
            int counter = 0;
            foreach( string parent in parents.OrderBy( a => a ) )
            {
                foreach( var child in children.OrderBy( a => a ) )
                {
                    People person = people[counter++];
                    Assert.AreEqual(parent, person.Parent);
                    Assert.AreEqual(child, person.Child);
                }
            }
        }
Example #18
0
        public void MockViewWithSeveralRows()
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };

            dataMock
                .Setup( context => context.Peoples )
                .Returns( new People
                {
                    Child = "Owen",
                    Parent = "Michelle"
                },
                new People
                {
                    Child = "Owen",
                    Parent = "Jacob"
                } );
            dataMock.Execute( Settings.Default.DataMockConnectionString );

            using( var context = new DataMockDataContext() )
            {
                Assert.IsTrue( context.Peoples.Count() == 2 );
            }
        }
Example #19
0
        public void NullParameterValue()
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };

            dataMock
                .Setup(context => context.DataTypesFunction(null, null, null, null, null, null))
                .Returns(new DataTypesFunctionResult
                {
                    c1 = 1,
                    c2 = "<NULL>",
                    c3 = Guid.Empty,
                    c4 = DateTime.Today,
                    c5 = true
                });
            dataMock.Execute(Settings.Default.DataMockConnectionString);

            using (var context = new DataMockDataContext(Settings.Default.DataMockConnectionString))
            {
                DataTypesFunctionResult result = context.DataTypesFunction(null, null, null, null, null, null).SingleOrDefault();
                Assert.IsNotNull(result);
                Assert.AreEqual(1, result.c1);
            }
        }
Example #20
0
        public void MockScalarFunctionReturnsConstantValue()
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };

            dataMock
                .Setup(context => context.ScalarFunction(Param.IsAny<int?>(), Param.IsAny<int?>()))
                .Returns(1);

            dataMock.Execute(Settings.Default.DataMockConnectionString);

            using (var context = new DataMockDataContext(Settings.Default.DataMockConnectionString))
            {
                int? result = context.ScalarFunction(1, 1);
                Assert.AreEqual(result, 1);
            }
        }
Example #21
0
        public void MockFunctionWithNewGuidExpression()
        {
            var dataMock = new DataMock<DataMockDataContext>
            {
                Log = Console.Out
            };

            const int QUERY_INT = 10;
            const string QUERY_STRING = "TEST";
            var queryGuid = new Guid("F255039E-7809-E211-BDD9-08002704F29D");

            const int RESULT_INT = 1;
            const string RESULT_STRING = "12345";
            var resultGuid = Guid.Empty;

            dataMock
                .Setup(context => context.DataTypesFunction(QUERY_INT, QUERY_STRING, new Guid("F255039E-7809-E211-BDD9-08002704F29D"), DateTime.Today, Param.IsAny<bool>(), Param.IsAny<char>()))
                .Returns(new DataTypesFunctionResult
                {
                    c1 = RESULT_INT,
                    c2 = RESULT_STRING,
                    c3 = resultGuid
                });
            dataMock.Execute(Settings.Default.DataMockConnectionString);

            using (var context = new DataMockDataContext(Settings.Default.DataMockConnectionString))
            {
                DataTypesFunctionResult result = context.DataTypesFunction(QUERY_INT, QUERY_STRING, queryGuid, DateTime.Today, true, ' ').Single();
                Assert.AreEqual(RESULT_INT, result.c1);
                Assert.AreEqual(RESULT_STRING, result.c2);
                Assert.AreEqual(resultGuid, result.c3);
            }
        }
Example #22
0
 public Startup(IConfiguration configuration)
 {
     Configuration = configuration;
     DataMock.InitData();
 }