public void TestAddPosts()
{
var dbFactory = new OrmLiteConnectionFactory(
System.Configuration.ConfigurationManager.ConnectionStrings["Test"].ConnectionString,
PostgreSqlDialect.Provider);
var postRepository = new EntityRepository <Post>(dbFactory);
var random = new Random();
var ids = new List <long>();
ids.Add(postRepository.Insert(new Post()
{
Message = $@"TEST MESSAGE {random.Next()}",
UserId = 1,
ParentId = 1
}));
for (int i = 0; i < 10; ++i)
{
var pId = ids[random.Next(0, ids.Count)];
var postStart = random.Next(TestData.BaconIpsum.Length - 30);
var length = random.Next(TestData.BaconIpsum.Length - postStart);
ids.Add(postRepository.Insert(new Post()
{
Message = $@"TEST MESSAGE Parent: {pId}, Text: {TestData.BaconIpsum.Substring(postStart, length)}",
UserId = 1,
ParentId = pId
}));
}
}
public void TestUpdate()
{
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
repo.Insert(new Entity()
{
Name = "Naam"
});
}
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
repo.Update(new Entity()
{
Id = 1,
Name = "Aangepast"
});
}
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
Assert.AreEqual(1, repo.Count());
Assert.AreEqual("Aangepast", repo.Find(1).Name);
}
}
public void Insert_SessionNotReadOnly_SessionMethodCalled()
{
var session = new Mock <ISession>();
var repository = new EntityRepository <TestEntity>(session.Object);
var entity = new TestEntity();
repository.Insert(entity);
session.Verify(x => x.Persist(entity), Times.Once);
}
private static void Main(string[] args)
{
var repository = new EntityRepository <User>();
var u = new User();
Console.WriteLine("User实体新增");
Console.WriteLine(repository.Insert(u));
Console.WriteLine("User实体查询");
Console.WriteLine(repository.GetById <User>(1));
Console.Read();
}
public void Insert_SessionReadOnly_ExceptionThrown()
{
var session = new Mock <ISession>();
session.Setup(x => x.DefaultReadOnly)
.Returns(true);
var repository = new EntityRepository <TestEntity>(session.Object);
var entity = new TestEntity();
Assert.Throws <EntityRepositoryException>(() => repository.Insert(entity), "The Repository is read-only");
}
public void TestFindAll()
{
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
var pen = new Entity()
{
Name = "Entity"
};
repo.Insert(pen);
pen = new Entity()
{
Name = "Name"
};
repo.Insert(pen);
}
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
Assert.AreEqual(2, repo.Count());
}
}
//[Explicit]
public void TestInsert()
{
var dbFactory = new OrmLiteConnectionFactory(
System.Configuration.ConfigurationManager.ConnectionStrings["Test"].ConnectionString,
PostgreSqlDialect.Provider);
var entityRepository = new EntityRepository <User>(dbFactory);
var random = new Random();
System.Console.WriteLine($@"New USER ID: {entityRepository.Insert(new User() { Email = $@"test{random.Next()}@geemail.com" })}");
}
public void TestAdd()
{
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
repo.Insert(new Entity()
{
Name = "Naam"
});
}
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
Assert.AreEqual(1, repo.Count());
}
}
public void CreateNewProblemWithoutTag()
{
IRepository <Problem> repository = new EntityRepository <Problem>(GetDbContext());
var problem = new Problem
{
Title = "Test",
Description = "This is a test Problem",
IsResolved = false
};
Assert.True(repository.Insert(problem));
var result = repository.GetAll(p => p.Title == "Test");
Assert.True(result.Count() > 0);
}
public void TestDelete()
{
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
var pen = new Entity()
{
Name = "Name"
};
repo.Insert(pen);
repo.Delete(1);
}
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
Assert.AreEqual(0, repo.Count());
}
}
public void TestFind()
{
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
repo.Insert(new Entity()
{
Name = "Name"
});
}
using (var repo = new EntityRepository(new DatabaseContext(_options)))
{
var result = repo.Find(1);
Assert.AreEqual(1, result.Id);
Assert.AreEqual("Name", result.Name);
}
}
public void WhenInsertingEmployeeShouldSaveIt()
{
// Arrange
const string ExpectedFirstName = "FirstName";
const string ExpectedLastName = "LastName";
var employeeRepository = new EntityRepository<Employee>(this.Context);
var employee = CreateEmployee(ExpectedFirstName, ExpectedLastName);
// Act
var insertedEmployee = employeeRepository.Insert(employee);
this.Context.SaveChanges();
var query = new EmployeeIdQuery(insertedEmployee.Id);
var actual = employeeRepository.Single(query);
// Assert
Assert.IsNotNull(actual);
Assert.AreEqual(ExpectedFirstName, actual.FirstName);
Assert.AreEqual(ExpectedLastName, actual.LastName);
}
/// <summary>
/// Добавляет данные сущности
/// </summary>
/// <param name="entity">Сущность</param>
/// <param name="onSuccess">Действие, выполняемое в случае успешного обновления</param>
/// <param name="onException">Действие, выполняемое в случае исключения</param>
public async Task Insert(T entity, Action onSuccess = null, Action <Exception> onException = null)
{
await Task.Factory.StartNew(() =>
{
using (var repo = new EntityRepository <T>(_connection))
{
repo.Insert(entity);
}
}, TaskCreationOptions.LongRunning)
.ContinueWith(result =>
{
if (result.Exception != null)
{
onException?.Invoke(result.Exception.InnerException);
}
else
{
onSuccess?.Invoke();
}
}, TaskScheduler.FromCurrentSynchronizationContext());
}
public void CreateNewProblemWithTag()
{
IRepository <Problem> repository = new EntityRepository <Problem>(GetDbContext());
var problem = new Problem
{
Title = "Test",
Description = "This is a test Problem",
IsResolved = false,
Tag = new Tag
{
Name = "Project #1"
}
};
Assert.True(repository.Insert(problem));
var result = repository.GetAll(p => p.Title == "Test");
Assert.True(result.Count() > 0);
var insertedProblem = result.ToArray()[0];
Assert.NotNull(insertedProblem.Tag);
}
//[Explicit]
public void TestCreateDbTables()
{
var dbFactory = new OrmLiteConnectionFactory(
System.Configuration.ConfigurationManager.ConnectionStrings["Test"].ConnectionString,
PostgreSqlDialect.Provider);
var userRepository = new EntityRepository <User>(dbFactory);
var anchorRepository = new EntityRepository <Anchor>(dbFactory);
var postRepository = new EntityRepository <Post>(dbFactory);
var anchorLinkRepository = new EntityRepository <AnchorLink>(dbFactory);
var userLinkRepository = new EntityRepository <UserLink>(dbFactory);
var postLinkRepository = new EntityRepository <PostLink>(dbFactory);
var random = new Random();
using (var db = dbFactory.Open())
{
if (db.CreateTableIfNotExists <User>())
{
Assert.Greater(userRepository.Insert(new User()
{
Email = $@"test{random.Next()}@geemail.com"
}), 0);
}
if (db.CreateTableIfNotExists <Anchor>())
{
Assert.Greater(anchorRepository.Insert(new Anchor()
{
Name = $@"#TestAnchor.{random.Next()}", UserId = 1
}), 0);
}
if (db.CreateTableIfNotExists <Post>())
{
Assert.Greater(postRepository.Insert(new Post()
{
Message = $@"TEST MESSAGE {random.Next()}", UserId = 1
}), 0);
}
if (db.CreateTableIfNotExists <UserLink>())
{
Assert.Greater(userLinkRepository.Insert(new UserLink()
{
PostId = 1, UserId = 1
}), 0);
}
if (db.CreateTableIfNotExists <AnchorLink>())
{
Assert.Greater(anchorLinkRepository.Insert(new AnchorLink()
{
PostId = 1, AnchorId = 1
}), 0);
}
if (db.CreateTableIfNotExists <PostLink>())
{
Assert.Greater(postRepository.Insert(new Post()
{
Message = $@"TEST MESSAGE {random.Next()}", UserId = 1, ParentId = 1
}), 0);
Assert.Greater(postLinkRepository.Insert(new PostLink()
{
ReferencePostId = 1, SourcePostId = 2
}), 0);
}
}
}
public void Insert(User obj)
{
Repository.Insert(obj);
}
public virtual void Insert(T domainModel)
{
_listOfTTypeInserted.Add(domainModel);
EventAggregator.Publish(this, new EntityCreatingArgs <T>(domainModel));
EntityRepository.Insert(domainModel);
}
