public void should_retrieve_all_posts()
{
// Arrange
var mockPosts = PostsHelper.GetDefaultMockData();
var db = new InMemoryDatabase();
db.Insert <Post>(mockPosts);
_connectionFactory.GetConnection().Returns(db.OpenConnection());
// Act
var posts = _sut.GetAll();
var postsList = posts.ToList();
// Assert
Assert.IsNotNull(posts);
Assert.AreEqual(posts.Count(), mockPosts.Count);
mockPosts = mockPosts.OrderBy(o => o.Id).ToList();
postsList = postsList.OrderBy(o => o.Id).ToList();
for (var i = 0; i < mockPosts.Count; i++)
{
var mockPost = mockPosts[0];
var post = postsList[0];
Assert.IsTrue(mockPost.Id == post.Id);
Assert.IsTrue(mockPost.Title == post.Title);
Assert.IsTrue(mockPost.Text == post.Text);
}
}
private void btn_enter_Click(object sender, EventArgs e)
{
//Remove()
//Add()
//Exists()
//Update()
//GetById()
//GetAll()
//bele bir kart var mi?
// kart varsa onu istifade olunmush qeyd et
// melumatlari update ele
// yeni istifadechi yarat
Card card = new Card()
{
Number = txbx_card_number.Text
};
using (Database db = new InMemoryDatabase())
{
db.Cards.Add(new Card
{
Id = 1,
Number = "12345",
IsUsed = false,
CurrencyType = CurrencyType.USD,
Balance = 45,
AddedDate = DateTime.Now
});
Card existsCard = db.Cards.Exists(card);
if (existsCard != null)
{
string n = new NameGenerator().Generate();
AppUser appuser = new AppUser()
{
Email = new EmailGenerator().Generate(),
MobileNumber = "",
Name = n,
Password = n,
RoleType = RoleType.User,
Balance = existsCard.Balance
};
AppUser addeduser = db.Users.Add(appuser);
if (addeduser != null)
{
existsCard.ActivatedBy = addeduser;
existsCard.ActivatedById = addeduser.Id;
existsCard.IsUsed = true;
existsCard.ActivatedDate = DateTime.Now;
db.Cards.Update(existsCard);
}
}
}
}
public ActionResult Create(User user)
{
user.Id = InMemoryDatabase.NextId();
InMemoryDatabase.Users.Add(user);
return(RedirectToAction("List"));
}
public CustomersTests()
{
_context = InMemoryDatabase.GetContextWithMockedData();
_unitOfWork = new UnitOfWork(_context);
_driversRepository = new DriversRepository(_context);
_identityProvider = new FakeIdentityProvider();
}
private void SeedData()
{
var context = InMemoryDatabase.GetDbContext();
context.Addresses.AddRange(GetTestData);
context.SaveChanges();
}
public void SetUpEach()
{
db = new InMemoryDatabase ();
phrase1 = new Phrase ("Das Restaurant", "Ресторан", "audio/lesson1/00_Das_Restaurant.mp3");
phrase2 = new Phrase ("Ich bin sehr mude", "Я очень устал,", "audio/lesson1/01_Ich_bin_sehr_mude.mp3");
phrase3 = new Phrase ("1", "2", "3");
}
public void SetUp()
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("config.json")
.Build();
testDBType = Convert.ToInt32(configuration.GetSection("TestDBType").Value);
switch (testDBType)
{
case 1: // SQLite In-Memory
TestDatabase = new InMemoryDatabase();
break;
case 2: // SQL Local DB
var dataSource = configuration.GetSection("TestDbDataSource").Value;
TestDatabase = new SQLLocalDatabase(dataSource);
break;
case 3: // SQL Server
case 4: // SQL CE
case 5: // MySQL
case 6: // Oracle
case 7: // Postgres
Assert.Fail("Database platform not supported for unit testing");
return;
case 8: // Firebird
TestDatabase = new FirebirdDatabase();
break;
default:
Assert.Fail("Unknown database platform specified: " + testDBType);
return;
}
}
protected RepositoryTests()
{
InMemoryDatabase.CreateTable();
this.Context = Substitute.For <IDatabaseContext>();
this.Context.Connection.Returns(InMemoryDatabase.Connection);
}
public async Task test_get_widgets_ormlite()
{
//
// Mock data
var table = new Widget
{
WidgetId = 1,
WidgetName = "test hell homer"
};
var table2 = new Widget
{
WidgetId = 2,
WidgetName = "test hell homer the second"
};
var db = new InMemoryDatabase();
db.OpenConnection();
db.Insert(new List <Widget> {
table, table2
});
//
// Test
var repository = CreateMockRepository(db);
var result = await repository.GetWidgets();
// Assert.Single(result);
Assert.Equal(2, result.Count());
}
public IDataReaderExtensionsTests()
{
connection = new SqliteConnection("Data Source=:memory:");
connection.Open();
InMemoryDatabase.Setup(connection);
}
public void OnGet()
{
this.Intance = InMemoryDatabase.Intance;
InMemoryDatabase.IncrementValue();
this.InstanceVisits = InMemoryDatabase.GetIntegerValue();
this.TotalVisits = InMemoryDatabase.GetIntegerValue();
}
public void SetUp()
{
db = new InMemoryDatabase();
measurementDAO = new Measurements(db);
m1 = new Measurement(1)
{
Result = 3.14, Beginning = s1, End = s2
};
m2 = new Measurement(2)
{
Result = 6.28, Beginning = s4, End = s6
};
m3 = new Measurement(3)
{
Result = 0, Beginning = s7, End = s8
};
m1.Add(new List <Sample> {
s1, s2, s3
});
m2.Add(new List <Sample> {
s4, s5, s6
});
m3.Add(new List <Sample> {
s7, s8
});
}
public ConsumerKafkaTopic(
InMemoryDatabase database,
ILogger <ConsumerKafkaTopic> logger)
{
this.database = database;
_logger = logger;
}
public static void Main(string[] args)
{
var store = new InMemoryDatabase();
//from the kafka loader side
var writer = (IInMemoryDatabaseWriter)store;
writer.ModelA.Update(1, new ModelA {
A = 1, B = "b", C = true
}); //create
writer.ModelA.Update(1, new ModelA {
A = 1, B = "b2", C = false
}); //update
writer.ModelA.Update(2, new ModelA {
A = 2, B = "z", C = true
});
writer.ModelA.Delete(2); //delete
writer.ModelB.Update(1, new ModelB {
A = 1, StructField = new StrKey(1, 2)
});
//from the client side
var reader = (IInMemoryDatabaseReader)store;
var m0 = reader.ModelA.FindByKey(1);
var m1 = reader.ModelA.FindByA(1).Run();
var m2 = reader.ModelA.FindByB("b2").AndByC(false).Run();
var complex = reader.ModelB.FindByStructField(new StrKey(1, 2)).Run();
}
private IWidgetRepository CreateMockRepository(InMemoryDatabase db)
{
var widgetDbMock = new Mock <IDatabaseConnectionFactory>();
widgetDbMock.Setup(c => c.GetConnection()).Returns(db.OpenConnection());
return(new WidgetRepository(widgetDbMock.Object));
}
private void SeedData()
{
var context = InMemoryDatabase.GetDbContext();
context.BuildingTypes.AddRange(TestData);
context.SaveChanges();
}
public async Task GetOrderByStatusWithCorrectStatusShouldReturnTheOrder()
{
var context = InMemoryDatabase.GetDbContext();
await SeedData(context);
var methodResult = new List <OrderByStatusViewModel>();
var orderFromDb = GetTestData().FirstOrDefault();
var expectedResult = Mapper.Map <Order, OrderByStatusViewModel>(orderFromDb,
opt => opt.ConfigureMap()
.ForMember(dest => dest.IssuerName, m => m.MapFrom(src => src.Issuer.UserName)));
methodResult.Add(expectedResult);
var orderStatus = orderFromDb.Status;
var orderUser = orderFromDb.Issuer.UserName;
var orderService = new Mock <IOrderService>();
orderService.Setup(g => g.GetOrdersByStatus <OrderByStatusViewModel>(orderStatus, orderUser)).Returns(methodResult);
var actualResult = orderService.Object.GetOrdersByStatus <OrderByStatusViewModel>(orderStatus, orderUser).FirstOrDefault();
Assert.Same(expectedResult.IssuerName, actualResult.IssuerName);
Assert.Same(expectedResult.OrderStatus, actualResult.OrderStatus);
}
public void ProductRepository_GetAllValues()
{
Mock <IDatabaseConnectionFactory> connectionFactoryMock = new Mock <IDatabaseConnectionFactory>();
var products = new List <Product>
{
new Product {
BrandId = 1, Description = "açıklama", DiscountPrice = 10, Name = "test ürünü", Price = 100, Quantitiy = 1, Status = true, Id = 1
}
};
var brands = new List <Brands>
{
new Brands {
Name = "Marka1", Status = true, Id = 1
}
};
var db = new InMemoryDatabase();
db.Insert(products);
db.Insert(brands);
connectionFactoryMock.Setup(c => c.GetConnection()).Returns(db.OpenConnection());
var result = new ProductRepository(connectionFactoryMock.Object).GetAllValues();
Assert.AreEqual(1, result.Count());
}
/*=================================================================================================
* CONSTANTS
*================================================================================================*/
/*PUBLIC******************************************************************************************/
/*PRIVATE*****************************************************************************************/
/*=================================================================================================
* FIELDS
*================================================================================================*/
/*PUBLIC******************************************************************************************/
/*PRIVATE*****************************************************************************************/
/*=================================================================================================
* PROPERTIES
*================================================================================================*/
/*PUBLIC******************************************************************************************/
/*PRIVATE*****************************************************************************************/
/*=================================================================================================
* CONSTRUCTORS
*================================================================================================*/
/*=================================================================================================
* PUBLIC METHODS
*================================================================================================*/
/*************************************************************************************************/
public static IDatabase GetDatabase(Database database)
{
IDatabase result = null;
switch (database)
{
case Database.InMemory:
result = new InMemoryDatabase();
break;
case Database.CSV:
result = new CsvDatabase(
new CSVUserManager(
new CSVReader(),
new CSVWriter()
),
new CSVPasswordManager(
new CSVReader(),
new CSVWriter()
)
);
break;
case Database.MySQL:
result = new MySQLDatabase();
break;
case Database.SQLLite:
result = new SQLiteDatabase();
break;
}
return(result);
}
public async Task GetAllAsync_ShouldReturnElements()
{
// Arrange
var sites = new List <Sites>
{
new Sites
{
Id = 1
},
new Sites
{
Id = 2
}
};
var db = new InMemoryDatabase();
db.Insert(sites);
var connectionFactoryMock = new Mock <IDatabaseConnectionFactory>();
connectionFactoryMock.Setup(c => c.GetConnection()).Returns(db.OpenConnection());
// Act
var result = await new SitesRepository(connectionFactoryMock.Object).GetAllAsync();
// Assert
Assert.Equal(sites, result.ToList());
}
public async Task BasicTest()
{
var store = new InMemoryDatabase();
var model = new DataModel {
Id = Guid.NewGuid(), X = 1, Y = 2
};
await store.AddAsync(model);
Assert.AreEqual(1, model.X);
Assert.AreEqual(2, model.Y);
var model2 = await store.GetOneAsync <DataModel>();
Assert.IsNotNull(model2);
Assert.AreEqual(1, model.X);
Assert.AreEqual(2, model.Y);
Assert.AreEqual(1, model2.X);
Assert.AreEqual(2, model2.Y);
model2.X = 1000;
Assert.AreEqual(1, model.X);
await store.UpdateAsync(model2);
Assert.AreEqual(1, model.X);
Assert.AreEqual(2, model.Y);
Assert.AreEqual(1000, model2.X);
Assert.AreEqual(2, model2.Y);
}
public void Can_Find_By_Index()
{
var store = new InMemoryDatabase();
//from the kafka loader side
var writer = (IInMemoryDatabaseWriter)store;
writer.ModelA.Update(1, new ModelA {
A = 1, B = "b", C = true
}); // create 1st
writer.ModelA.Update(1, new ModelA {
A = 1, B = "b2", C = false
}); //update 1st
writer.ModelA.Update(2, new ModelA {
A = 2, B = "z", C = true
}); // create 2nd
writer.ModelA.Delete(2); //delete 2nd
writer.ModelB.Update(1, new ModelB {
A = 1, StructField = new StrKey(1, 2)
}); //create 3rd
//from the client side
var reader = (IInMemoryDatabaseReader)store;
reader.ModelA.FindByKey(1).Should().NotBeNull(); //PK
reader.ModelA.FindByA(1).Run().Should().HaveCount(1); //IX
reader.ModelA.FindByB("b2").AndByC(false).Run().Should().HaveCount(1); //Composite IX
reader.ModelB.FindByStructField(new StrKey(1, 2)).Run().Should().HaveCount(1); //Complex type IX
}
public async Task GetAllOrdersSortedByUserThenByCompanyShouldReturnAllOrdersInTheDataBase()
{
var context = InMemoryDatabase.GetDbContext();
await SeedData(context);
var methodResults = new List <AdminOrderViewModel>();
var ordersFromDb = GetTestData();
foreach (var order in ordersFromDb)
{
var mappedOrder = Mapper.Map <Order, AdminOrderViewModel>(order,
opt => opt.ConfigureMap()
.ForMember(dest => dest.IssuerName, m => m.MapFrom(src => src.Issuer.UserName)));
methodResults.Add(mappedOrder);
}
var orderService = new Mock <IOrderService>();
orderService.Setup(g => g.GetAllOrdersSortedByUserThenByCompany <AdminOrderViewModel>()).Returns(methodResults);
var actualResults = orderService.Object.GetAllOrdersSortedByUserThenByCompany <AdminOrderViewModel>();
for (int i = 0; i < methodResults.Count; i++)
{
Assert.Same(methodResults[i].IssuerName, actualResults[i].IssuerName);
Assert.Same(methodResults[i].OrderStatus, actualResults[i].OrderStatus);
}
}
public DetailsViewModel()
{
inMemoryDatabase = new InMemoryDatabase();
AddCommand = new DelegateCommand(Add, CanAdd);
SaveCommand = new DelegateCommand(Save, CanSave);
DeleteCommand = new DelegateCommand(Delete, CanDelete);
}
public void SetUp()
{
testDBType = Convert.ToInt32(ConfigurationManager.AppSettings["TestDBType"]);
switch (testDBType)
{
case 1: // SQLite In-Memory
TestDatabase = new InMemoryDatabase();
break;
case 2: // SQL Local DB
TestDatabase = new SQLLocalDatabase();
break;
case 3: // SQL Server
case 4: // SQL CE
case 5: // MySQL
case 6: // Oracle
case 7: // Postgres
Assert.Fail("Database platform not supported for unit testing");
return;
case 8: // Firebird
TestDatabase = new FirebirdDatabase();
break;
default:
Assert.Fail("Unknown database platform specified: " + testDBType);
return;
}
}
private void NewStorage()
{
var db = new InMemoryDatabase();
StateStore = new StateStore(db);
_dataStore = new DataStore(db);
}
public AdoNetFlusher(InMemoryDatabase inMemoryDatabase, String connectionString)
{
/* _inMemoryDatabase = inMemoryDatabase;
* _connectionString = connectionString;
*
* _dbFactory = new OrmLiteConnectionFactory(connectionString, MySqlDialectProvider.Instance);
* _connection = _dbFactory.OpenDbConnection();*/
}
public override void Load()
{
var database = new InMemoryDatabase();
var gameService = new GameService();
Kernel.Bind<IDatabase>().ToMethod(_ => database);
Kernel.Bind<IGameService>().ToMethod(_ => gameService);
}
public void InMemoryDatabaseTests_GetEconomyDataForPlayer_NewPlayerNoMoney()
{
IDatabase database = new InMemoryDatabase();
EconomyData data = database.GetEconomyDataForPlayer("mock1");
Assert.AreEqual(0ul, data.Money);
}
private void SetupMockDatabase(InMemoryDatabase db)
{
var mockCreateTableSql = "CREATE TABLE Mock (id INT PRIMARY KEY, name VARCHAR(30))";
var firstMockInsertSql = $"INSERT INTO Mock (id, name) VALUES (1, '{MOCK_FIRST_ROW}')";
var secondMockInsertSql = $"INSERT INTO Mock (id, name) VALUES (2, '{MOCK_SECOND_ROW}')";
db.SetupTable(mockCreateTableSql, firstMockInsertSql, secondMockInsertSql);
}
/// <summary>
/// Initializes a new instance of the <see cref="InMemoryQueries{TModel}"/> class.
/// </summary>
/// <param name="database">The database.</param>
internal InMemoryQueries(InMemoryDatabase database)
{
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
this.database = database;
}
public void Uses_persistent_database_by_default()
{
var configuration = CreateConfiguration();
var persistentDatabase = new InMemoryDatabase(new[] { new NullLoggerFactory() });
var inMemoryDataStore = new InMemoryDataStore(configuration, persistentDatabase);
Assert.Same(persistentDatabase, inMemoryDataStore.Database);
}
public void GetAllOrdersSortedByUserThenByCompanyWithNoOrdersInDataBaseShouldReturnEmpyList()
{
var context = InMemoryDatabase.GetDbContext();
var service = new OrderService(context);
var actualResult = service.GetAllOrdersSortedByUserThenByCompany <AdminOrderViewModel>();
Assert.Empty(actualResult);
}
public MongodbFlusher(InMemoryDatabase inMemoryDatabase, String connectionString)
{
_inMemoryDatabase = inMemoryDatabase;
var mongoUrl = MongoUrl.Create(connectionString);
_databaseName = mongoUrl.DatabaseName;
var mongoClient = new MongoClient(mongoUrl);
_server = mongoClient.GetServer();
Database.Drop();
}
public void Uses_persistent_database_if_configured_as_persistent()
{
var options = CreateConfiguration(new DbContextOptions().UseInMemoryStore(persist: true));
var persistentDatabase = new InMemoryDatabase(new[] { new NullLoggerFactory() });
var inMemoryDataStore = new InMemoryDataStore(options, persistentDatabase);
Assert.Same(persistentDatabase, inMemoryDataStore.Database);
}
public InMemoryQueryContext(
[NotNull] IModel model,
[NotNull] ILogger logger,
[NotNull] StateManager stateManager,
[NotNull] InMemoryDatabase database)
: base(model, logger, stateManager)
{
Check.NotNull(database, "database");
_database = database;
}
public void GameIsSaved()
{
var database = new InMemoryDatabase();
var game = new Game(2, "Test game");
game.GiveBirth(0, 0);
game.GiveBirth(0, 1);
new GameService().Save(game, database);
var session = database.OpenSession();
var gameFromDb = session.Query<Infrastructure.DataObjects.Game>().Single(_ => _.Name == "Test game");
Assert.AreEqual(2, gameFromDb.Cells.Count());
Assert.AreEqual(0, gameFromDb.Cells.First().X);
Assert.AreEqual(0, gameFromDb.Cells.First().Y);
Assert.AreEqual(1, gameFromDb.Cells.Last().X);
Assert.AreEqual(0, gameFromDb.Cells.Last().Y);
}
public InMemoryDatabaseProvider(InMemoryDatabase inMemoryDatabase)
{
_inMemoryDatabase = inMemoryDatabase;
}
public void Drop()
{
Database = new InMemoryDatabase();
}
public CustomerDirectory(InMemoryDatabase databaseContext)
{
// replace database context with a technology of your choice
}
protected MvcApplication()
{
Database = new InMemoryDatabase();
}
public InMemoryDbCommandFactory(InMemoryDatabase inMemoryDatabase)
{
_inMemoryDatabase = inMemoryDatabase;
}
public InMemoryTransactionScope(InMemoryDatabase inMemoryDatabase)
{
_inMemoryDatabase = inMemoryDatabase;
}
public static void FlushToMongoDb(InMemoryDatabase inMemoryDatabase, String connectionString)
{
Console.WriteLine("Flushing started...");
var stopwatch = Stopwatch.StartNew();
new MongodbFlusher(inMemoryDatabase, connectionString)
.Flush();
stopwatch.Stop();
Console.WriteLine("Done in {0:n0} ms.", stopwatch.ElapsedMilliseconds);
Console.ReadKey();
}
