public static void SetUp(TestContext context)
{
Context = new TestDataContext();
blogId1 = Guid.NewGuid();
var posts1 = new List<Models.Post>()
{
new Models.Post { Id = Guid.NewGuid(), BlogId = blogId1, Title = "TestPost1", Content = "TestContent1", Author = new Models.Author() { Id = Guid.NewGuid(), FirstName = "AuthorFirst1", LastName = "AuthorLast1" } },
new Models.Post { Id = Guid.NewGuid(), BlogId = blogId1, Title = "TestPost2", Content = "TestContent2", Author = new Models.Author() { Id = Guid.NewGuid(), FirstName = "AuthorFirst2", LastName = "AuthorLast2" } },
new Models.Post { Id = Guid.NewGuid(), BlogId = blogId1, Title = "TestPost3", Content = "TestContent3", Author = new Models.Author() { Id = Guid.NewGuid(), FirstName = "AuthorFirst3", LastName = "AuthorLast3" } },
};
var blog1 = new Models.Blog { Id = blogId1, Name = "BlogName1", Posts = posts1 };
Context.Blogs.Add(blog1);
var blogQueryResult = new BlogQueryResult
{
Id = blogId1,
Name = "BlogName1",
CreatedDate = DateTime.Now,
UpdatedDate = DateTime.Now,
Posts = new List<PostListItem>()
{
new PostListItem() { Id = Guid.NewGuid(), Title = "TestPost1", Content = "TestContent1", AuthorName = "AuthorFirst1 AuthorLast1", NumberOfComments = 3, PostDate = DateTime.Now },
new PostListItem() { Id = Guid.NewGuid(), Title = "TestPost2", Content = "TestContent2", AuthorName = "AuthorFirst2 AuthorLast2", NumberOfComments = 2, PostDate = DateTime.Now },
new PostListItem() { Id = Guid.NewGuid(), Title = "TestPost3", Content = "TestContent3", AuthorName = "AuthorFirst3 AuthorLast3", NumberOfComments = 1, PostDate = DateTime.Now }
}
};
Mapper = new Mock<IMappingEngine>();
Mapper.Setup(m => m.Map<Models.Blog, BlogQueryResult>(It.IsAny<Models.Blog>(), It.IsAny<BlogQueryResult>())).Returns(blogQueryResult);
}
public void Operation_MarkAsHandled()
{
TestDataContext ctxt = new TestDataContext(new Uri(TestURIs.RootURI, "TestDomainServices-TestCatalog1.svc"));
var query = ctxt.CreateQuery<Product>("ThrowGeneralException", null, false, true);
LoadOperation lo = new LoadOperation<Product>(query, LoadBehavior.KeepCurrent, null, null, null);
EventHandler action = (o, e) =>
{
LoadOperation loadOperation = (LoadOperation)o;
if (loadOperation.HasError)
{
loadOperation.MarkErrorAsHandled();
}
};
lo.Completed += action;
DomainOperationException ex = new DomainOperationException("Operation Failed!", OperationErrorStatus.ServerError, 42, "StackTrace");
lo.Complete(ex);
// verify that calling MarkAsHandled again is a noop
lo.MarkErrorAsHandled();
lo.MarkErrorAsHandled();
// verify that calling MarkAsHandled on an operation not in error
// results in an exception
lo = new LoadOperation<Product>(query, LoadBehavior.KeepCurrent, null, null, null);
Assert.IsFalse(lo.HasError);
Assert.IsTrue(lo.IsErrorHandled);
ExceptionHelper.ExpectInvalidOperationException(delegate
{
lo.MarkErrorAsHandled();
}, Resource.Operation_HasErrorMustBeTrue);
}
/// <summary>
/// set The custom string to check if the LIst of users have changed
/// and consider the page
/// </summary>
/// <param name="context"></param>
/// <param name="arg"></param>
/// <returns></returns>
public override string GetVaryByCustomString(HttpContext context, string arg)
{
if (arg == "CountUsers")
{
IDataContext<Person> dt = new TestDataContext();
return context.Request.Url.Query + dt.CountUsers().ToString();
}
return "";
}
static void Main(string[] args)
{
PublicLogicManager.DataContextFactory = CoreIntegration.GetDataContext;
TestDataContext db = new TestDataContext();
db.TestInitDB();
TestHelperClientLogic<PublicLogicManager> testHelper = new TestHelperClientLogic<PublicLogicManager>();
testHelper.CreateDefaultClientData(CoreConstants.SUBSCRIPTION_LEVEL_SYSTEM);
}
public static void SetUp(TestContext context)
{
Context = new TestDataContext();
blogId1 = Guid.NewGuid();
blogId2 = Guid.NewGuid();
blogId3 = Guid.NewGuid();
var posts1 = new List<Post>()
{
new Post { Id = Guid.NewGuid(), BlogId = blogId1, Title = "TestPost1", Content = "TestContent1", Author = new Author() { Id = Guid.NewGuid(), FirstName = "AuthorFirst1", LastName = "AuthorLast1" } },
new Post { Id = Guid.NewGuid(), BlogId = blogId1, Title = "TestPost2", Content = "TestContent2", Author = new Author() { Id = Guid.NewGuid(), FirstName = "AuthorFirst2", LastName = "AuthorLast2" } },
new Post { Id = Guid.NewGuid(), BlogId = blogId1, Title = "TestPost3", Content = "TestContent3", Author = new Author() { Id = Guid.NewGuid(), FirstName = "AuthorFirst3", LastName = "AuthorLast3" } },
};
var posts2 = new List<Post>()
{
new Post { Id = Guid.NewGuid(), BlogId = blogId2, Title = "TestPost4", Content = "TestContent4", Author = new Author() { Id = Guid.NewGuid(), FirstName = "AuthorFirst4", LastName = "AuthorLast4" } },
new Post { Id = Guid.NewGuid(), BlogId = blogId2, Title = "TestPost5", Content = "TestContent5", Author = new Author() { Id = Guid.NewGuid(), FirstName = "AuthorFirst5", LastName = "AuthorLast5" } }
};
var posts3 = new List<Post>()
{
new Post { Id = Guid.NewGuid(), BlogId = blogId3, Title = "TestPost6", Content = "TestContent6", Author = new Author() { Id = Guid.NewGuid(), FirstName = "AuthorFirst6", LastName = "AuthorLast6" } }
};
var blog1 = new Models.Blog { Id = blogId1, Name = "BlogName1", Posts = posts1 };
var blog2 = new Models.Blog { Id = blogId2, Name = "BlogName2", Posts = posts2 };
var blog3 = new Models.Blog { Id = blogId3, Name = "BlogName3", Posts = posts3 };
Context.Blogs.Add(blog1);
Context.Blogs.Add(blog2);
Context.Blogs.Add(blog3);
var blogsQueryResult = new List<BlogListItem>
{
new BlogListItem { Id = blogId1, Name = "BlogName1", NumberOfPosts = 3, CreatedDate = DateTime.Now, UpdatedDate = DateTime.Now },
new BlogListItem { Id = blogId2, Name = "BlogName2", NumberOfPosts = 2, CreatedDate = DateTime.Now, UpdatedDate = DateTime.Now },
new BlogListItem { Id = blogId3, Name = "BlogName3", NumberOfPosts = 1, CreatedDate = DateTime.Now, UpdatedDate = DateTime.Now }
};
Mapper = new Mock<IMappingEngine>();
Mapper.Setup(m => m.Map<List<Models.Blog>, List<BlogListItem>>(It.IsAny<List<Models.Blog>>(), It.IsAny<List<BlogListItem>>()))
.Callback((List<Models.Blog> blogs, List<BlogListItem> queryResults) =>
{
queryResults.AddRange(blogsQueryResult);
});
}
public void InitializeTest()
{
AuthenticationDbContext.SetDefaultConnectionStringName("AuthDB");
CoreIntegration.Configure();
PublicConfigurationSettings.Configure(CoreIntegration.GetAuthManager,
CoreIntegration.GetApiProcessor, "MNoreke", "", "", "", "", null);
BaseCallController.MvcValidationIssue = false;
TestHelper = new TestHelperClientLogic<LogicManager>();
TestDataContext dataModel = new TestDataContext(null);
dataModel.TestInitDB();
TestHelper.CreateDefaultClientData(AppConstants.SUBSCRIPTION_LEVEL_BASIC);
}
public void TestCallExpression()
{
using (var context = new TestDataContext())
{
var result1 = context.ADbSet.Where(i => i.TestBProperty.Array.Count(it => it.Id == 3) > 0).Count();
Assert.AreEqual(1, result1);
var result2 = context.ADbSet.Where(i => i.List.Where(it => it != null).FirstOrDefault(it => it.Array.Length > 0) != null).Count();
Assert.AreEqual(1, result2);
var result3 = context.ADbSet.Where(i => i.L1[1] == 23).Count();
Assert.AreEqual(1, result3);
var array = new[] { 3 };
var result4 = context.ADbSet.Where(i => i.TestBProperty.Array.Count(it => it.Id == array[0]) > 0).Count();
Assert.AreEqual(1, result4);
array[0] = 5;
var result5 = context.ADbSet.Where(i => i.TestBProperty.Array.Count(it => it.Id == array[0]) > 0).Count();
Assert.AreEqual(0, result5);
var array2 = new[] { 4 };
var result6 = context.ADbSet.Where(i => array2.Intersect(i.L1).Count() > 0).Count();
Assert.AreEqual(1, result6);
var result7 = context.ADbSet.Where(i => i.C.Value.TestFunct(i.L1)).Count();
Assert.AreEqual(1, result7);
var result8 = context.ADbSet.Where(i => i.L1.Any()).Count();
Assert.AreEqual(1, result8);
var result9 = context.ADbSet.Where(i => i.List.Select(q => q.ToString().Count(r => r != '2') > 0).Count() > 0).Count();
Assert.AreEqual(1, result9);
var list = new List <int> {
3
};
var result10 = context.ADbSet.Where(i => list[0] == 3).Select(i => i.C).Count();
Assert.AreEqual(1, result10);
Assert.Throws <NullReferenceException>(() => context.ADbSet.Where(i => i.List.All(item => item.Array.Length > 0)).Count());
}
}
public void CustomerTest()
{
var filter = new Filter
{
Field = nameof(Customer.FirstName),
Operator = FilterOperator.Contains,
Value = "e"
};
var request = new PageAndFilterAndSortRequest
{
PageNumber = 3,
PageSize = 5,
Logic = FilterLogic.And,
Filters = new IFilter[]
{
filter
},
Sorts = new ISort[]
{
new Sort
{
Field = nameof(Customer.LastName),
Direction = SortDirection.Ascending
}
}
};
using (var dbContext = new TestDataContext())
{
var items = dbContext.Customers.ToList();
var filtered = dbContext.Customers.Filter(request);
var queryable = filtered
.Sort(request)
.Page(request);
var sql = "";//((DbQuery<Customer>)queryable).Sql;
var list = queryable.ToList();
Debug.WriteLine(sql);
Assert.AreEqual(request.PageSize, list.Count);
Assert.IsTrue(list.All(x => x.FirstName.Contains(filter.Value)));
}
}
public void TestComplexKey_EnumerableKey_Inserted()
{
using (var context = new TestDataContext())
{
var eTable1 = new TestE
{
Id = new List <TestC> {
new TestC {
Id = 5, Value = "5"
}, new TestC {
Id = 6, Value = "5"
}
}
};
context.EDbSet.InsertOnSubmit(eTable1);
var eTable2 = new TestE
{
Id = new List <TestC> {
new TestC {
Id = 5, Value = "5"
}, new TestC {
Id = 7, Value = "5"
}
}
};
context.EDbSet.InsertOnSubmit(eTable2);
context.SubmitChanges();
var count = context.EDbSet.Count();
Assert.AreEqual(2, count);
context.EDbSet.DeleteOnSubmit(eTable1);
context.EDbSet.DeleteOnSubmit(eTable2);
context.SubmitChanges();
count = context.EDbSet.Count();
Assert.AreEqual(0, count);
}
}
public void TestUpdateArray()
{
using (var context = new TestDataContext())
{
var array = new TestC[2, 1]
{
{ new TestC {
Id = 1
} },
{ new TestC {
Id = 5
} }
};
var data = context.BDbSet.Select(b => b).Single();
data.Array3 = array;
context.BDbSet.UpdateOnSubmit(data);
context.SubmitChanges();
Assert.AreEqual(5, context.BDbSet.Select(b => b.Array3[1, 0].Id).Single());
data.Array3 = null;
context.BDbSet.UpdateOnSubmit(data);
context.SubmitChanges();
Assert.AreEqual(null, context.BDbSet.Select(b => b.Array3).Single());
data.Array4[0][0, 0].Id = 15;
context.BDbSet.UpdateOnSubmit(data);
context.SubmitChanges();
Assert.AreEqual(15, context.BDbSet.Select(b => b.Array4[0][0, 0].Id).Single());
data.Array5[1, 1, 1].Id = 8;
context.BDbSet.UpdateOnSubmit(data);
context.SubmitChanges();
Assert.AreEqual(8, context.BDbSet.Select(b => b.Array5[1, 1, 1].Id).Single());
context.BDbSet.UpdateOnSubmit(_testEntity.TestBProperty);
context.SubmitChanges();
}
}
public void Setup()
{
sut = Entry.TcoDataTests.MAIN.dataTests;
Init();
sut.DataTests.DataManager.InitializeRepository <PlainstProcessData>(Repository as IRepository);
try
{
sut.DataTests.DataManager.InitializeRemoteDataExchange();
}
catch (Exception)
{
//throw;
}
Entry.TcoDataTests.Connector.BuildAndStart().ReadWriteCycleDelay = 100;
sut.ExecuteProbeRun(10, (int)eDataTests.RestoreTasks);
}
public void ClearData()
{
using (var context = new TestDataContext())
{
var aData3 = context.ADbSet.Select(a => a);
var bData3 = context.BDbSet.Select(b => b);
var dData3 = context.DDbSet.Select(d => d);
var eData3 = context.EDbSet.Select(e => e);
var eData4 = context.FDbSet.Select(f => f);
context.ADbSet.DeleteAllOnSubmit(aData3);
context.BDbSet.DeleteAllOnSubmit(bData3);
context.DDbSet.DeleteAllOnSubmit(dData3);
context.EDbSet.DeleteAllOnSubmit(eData3);
context.FDbSet.DeleteAllOnSubmit(eData4);
context.SubmitChanges();
}
}
public void DatabaseCreator_CreateIfNotExists_ExistsAndHasTables()
{
const string connectionString = "Data Source=:memory:";
var options = new DataContextOptionsBuilder().UseSqlite(connectionString).Options;
using (var context = new TestDataContext(options))
{
var result = context.Database.Connection.DbConnection.Database;
Assert.Equal("main", result);
Assert.True(context.Database.Exists());
Assert.False(context.Database.HasTables());
var createResult = context.Database.Creator.CreateIfNotExists();
Assert.True(createResult);
Assert.True(context.Database.Exists());
Assert.True(context.Database.HasTables());
}
}
public void TestSingle()
{
using (var context = new TestDataContext())
{
var result1 = context.ADbSet.Where(a => a.E == TestEnum.One).Single();
var result2 = context.ADbSet.Single();
Assert.AreEqual(result1.Id, result2.Id);
var result3 = context.ADbSet.Single(a => a.E == TestEnum.One);
Assert.AreEqual(result1.Id, result3.Id);
Assert.Throws <InvalidOperationException>(() => result1 = context.ADbSet.Single(a => a.Id < 0));
context.ADbSet.InsertOnSubmit(_testEntity);
context.SubmitChanges();
Assert.Throws <InvalidOperationException>(() => result1 = context.ADbSet.Single(a => a.Id >= 0));
}
}
public void MultiSortTest()
{
var request = new SortRequest
{
Sorts = new Sort[]
{
new Sort {
Direction = SortDirection.Ascending, Field = nameof(Track.AlbumId)
},
new Sort {
Direction = SortDirection.Descending, Field = nameof(Track.Bytes)
}
}
};
using (var dbContext = new TestDataContext())
{
var items = dbContext.Tracks
.Include(x => x.Album)
.ToList();
var queryable = dbContext.Tracks.Sort(request);
var sql = ""; // ((DbQuery<Track>)queryable).Sql;
var sorted = queryable.ToList();
Debug.WriteLine(sql);
Assert.AreEqual(items.Count, sorted.Count);
var albumId = int.MinValue;
foreach (var album in sorted.GroupBy(x => x.AlbumId))
{
Assert.IsFalse(albumId > album.Key);
albumId = album.Key;
var bytes = decimal.MaxValue;
foreach (var track in album)
{
Assert.IsFalse(bytes < track.Bytes);
bytes = track.Bytes;
}
}
}
}
public async Task Deve_Retornar_Lista_De_Pessoas_Com_Um_Item()
{
var pessoa = new Pessoa {
Nome = "Teste", Twitter = "@teste"
};
await TestDataContext.AddAsync(pessoa);
await TestDataContext.SaveChangesAsync();
var response = await Client.GetAsync(BASE_URL);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <List <Pessoa> >(responseString);
Assert.Equal(data.Count, 1);
}
public void TestComplexKey_EnumerableEmptyAndNull_Inserted()
{
using (var context = new TestDataContext())
{
var fTable1 = new TestF {
C = null, Value = new TestC {
Id = 3
}
};
var fTable2 = new TestF {
C = new List <TestC>(), Value = new TestC {
Id = 4
}
};
context.FDbSet.InsertOnSubmit(fTable1);
context.FDbSet.InsertOnSubmit(fTable2);
context.SubmitChanges();
var fData = context.FDbSet.ToList();
Assert.AreEqual(2, fData.Count);
Assert.AreEqual(3, fData[0].Value.Id);
Assert.AreEqual(null, fData[0].C);
Assert.AreEqual(4, fData[1].Value.Id);
Assert.AreEqual(0, fData[1].C.Count);
fData[0].Value = new TestC {
Id = 7
};
context.FDbSet.UpdateOnSubmit(fData[0]);
context.SubmitChanges();
fData = context.FDbSet.ToList();
Assert.AreEqual(7, fData[0].Value.Id);
}
}
public void TestContains()
{
using (var context = new TestDataContext())
{
var result1 = context.ADbSet.Contains(new TestA(0));
Assert.AreEqual(false, result1);
var result2 = context.ADbSet.Select(a => a.C.Value).OrderBy(a => a.Id).Contains(default(TestC));
Assert.AreEqual(false, result2);
var result3 = context.ADbSet.Select(a => a.C.Value).OrderBy(c => c.Id).Contains(default(TestC), new TestComparer());
Assert.AreEqual(true, result3);
var result4 = context.ADbSet.Select(a => a.C.Value.Id).Contains(5);
Assert.AreEqual(true, result4);
var result5 = context.ADbSet.Select(a => a.TestBProperty).Contains(new TestB(0));
Assert.AreEqual(true, result5);
}
}
private void AddProduct(TestDataContext context)
{
var supplier = new Supplier()
{
//Id is autogenerated
Name = "TrinketsRUS"
};
context.Suppliers.Add(supplier);
var product = new Product()
{
// Id = 1, Auto generated key
Name = "Banana",
Price = 4.75,
SupplierId = supplier.Id
};
context.Products.Add(product);
}
public static void Main()
{
using (var context = new TestDataContext())
{
context.Log = Console.Out; // to check it has worked
IQueryable <Order> lhs = context.Orders;
IQueryable <Order_Detail> rhs = context.Order_Details;
// how ever many predicates etc here
rhs = addBeforeJoin(rhs, 4);
var result = lhs.Join(rhs,
a => a.OrderID,
b => b.OrderID,
(a, b) => new { A = a, B = b }
);
// or add after
result = result.Where(row => row.B, addAfterJoin(100));
Console.WriteLine(result.Count());
}
}
public static void AddFolder(string folderName)
{
using (var ts = new TransactionScope())
{
using (var dc = new TestDataContext())
{
var folder = new Folder {
FolderName = folderName
};
AddFile(dc, "test1.xyz", folder);
AddFile(dc, "test2.xyz", folder);
AddFile(dc, "test3.xyz", folder);
dc.SubmitChanges();
}
ts.Complete();
}
}
public void CommandTimeoutTests([IncludeDataSources(false, TestProvName.AllSqlServer)] string context)
{
using (var db = new TestDataContext(context))
{
db.KeepConnectionAlive = true;
db.CommandTimeout = 10;
Assert.Null(db.DataConnection);
db.GetTable <Person>().ToList();
Assert.NotNull(db.DataConnection);
Assert.That(db.DataConnection !.CommandTimeout, Is.EqualTo(10));
db.CommandTimeout = -10;
Assert.That(db.DataConnection.CommandTimeout, Is.EqualTo(-1));
db.CommandTimeout = 11;
var record = db.GetTable <Child>().First();
Assert.That(db.DataConnection !.CommandTimeout, Is.EqualTo(11));
}
}
public void TestLongCount()
{
using (var context = new TestDataContext())
{
var result = context.ADbSet.LongCount();
Assert.AreEqual(1, result);
var result2 = context.ADbSet.LongCount(a => a.TestBProperty.Id > 0);
Assert.AreEqual(1, result2);
var result3 = context.ADbSet.OrderBy(a => a.Id).ThenBy(a => a.E).LongCount(a => a.Id >= 0);
Assert.AreEqual(1, result3);
var result4 = context.ADbSet.OrderBy(a => a.Id).ThenBy(a => a.E).Where(a => a.Id >= 0).LongCount();
Assert.AreEqual(1, result4);
var result5 = context.ADbSet.LongCount(a => a.Id < 0);
Assert.AreEqual(0, result5);
}
}
public void MultiFilterOrTest()
{
var request = new FilterRequest
{
Logic = FilterLogic.Or,
Filters = new IFilter[]
{
new Filter
{
Field = nameof(Track.Name),
Operator = FilterOperator.StartsWith,
Value = "C"
},
new Filter
{
Field = nameof(Track.Name),
Operator = FilterOperator.EndsWith,
Value = "y"
}
}
};
using (var dbContext = new TestDataContext())
{
var items = dbContext.Tracks.ToList();
var queryable = dbContext.Tracks.Filter(request);
var sql = ((DbQuery <Track>)queryable).Sql;
var filtered = queryable.ToList();
Debug.WriteLine(sql);
// assert that there were some items in the full set that didn't match the filter
Assert.IsFalse(items.All(x => x.Name.StartsWith("C") || x.Name.EndsWith("y")));
// assert that every item in the set matches the filter
Assert.IsTrue(filtered.All(x => x.Name.StartsWith("C") || x.Name.EndsWith("y")));
// assert that every item in the list didn't fulfill both criteria
Assert.IsFalse(filtered.All(x => x.Name.StartsWith("C") && x.Name.EndsWith("y")));
}
}
/// <summary>
/// Creates a test context
/// </summary>
/// <returns>The test context</returns>
private TestDataContext CreateContext()
{
var name = Guid.NewGuid().ToString("N");
var optionsBuilder = new DbContextOptionsBuilder <TestDataContext>();
optionsBuilder.UseInMemoryDatabase(name);
var context = new TestDataContext(optionsBuilder.Options);
// context.Database.Delete();
var users =
Enumerable.Range(1, 100).Select(n => new User {
Login = $"user{n:####}", Uid = Guid.NewGuid(), Roles = new List <RoleUser>()
}).ToList();
var roles =
Enumerable.Range(1, 10).Select(n => new Role {
Name = $"role{n:###}", Uid = Guid.NewGuid(), Users = new List <RoleUser>()
}).ToList();
for (var roleNum = 1; roleNum <= roles.Count; roleNum++)
{
var role = roles[roleNum - 1];
for (var userNum = 1; userNum <= users.Count; userNum++)
{
var user = users[userNum - 1];
if (userNum % roleNum == 0)
{
role.Users.Add(new RoleUser {
User = user
});
}
context.Users.Add(user);
}
context.Roles.Add(role);
}
context.SaveChanges();
return(new TestDataContext(optionsBuilder.Options));
}
public void TestAll()
{
using (var context = new TestDataContext())
{
var result1 = context.ADbSet.All(a => a.E == TestEnum.One);
Assert.AreEqual(true, result1);
var resul2 = context.ADbSet.All(a => a.Id < 0);
Assert.AreEqual(false, resul2);
var result3 = context.ADbSet.OrderBy(a => a.Id).All(a => a.Id >= 0);
Assert.AreEqual(true, result3);
context.ADbSet.InsertOnSubmit(_testEntity);
context.SubmitChanges();
var firstId = context.ADbSet.Select(a => a.Id).First();
var result4 = context.ADbSet.All(a => a.Id <= firstId);
Assert.AreEqual(false, result4);
}
}
public void GetPostsWithCommentsCreatedInRange_WhenAllInExclusiveRange_CorrectDataReturned()
{
// Arrange
var until = DateTime.Now.AddDays(-1);
var from = until.AddDays(-5);
var comment1 = RandomDataEntityGenerator.CreateCommentWithRandomData();
var comment2 = RandomDataEntityGenerator.CreateCommentWithRandomData();
var comment3 = RandomDataEntityGenerator.CreateCommentWithRandomData();
TestDataContext.Comments.AddRange(new[] { comment1, comment2, comment3 });
TestDataContext.SaveChanges();
// Act
var result = _SUT.GetPostsWithCommentsCreatedInRange(from, until);
// Assert
Assert.IsNotNull(result.FirstOrDefault(c => c.Id == comment1.PostId));
Assert.IsNotNull(result.FirstOrDefault(c => c.Id == comment2.PostId));
Assert.IsNotNull(result.FirstOrDefault(c => c.Id == comment3.PostId));
}
public void TestUpdateChildList()
{
using (var context = new TestDataContext())
{
var aData = context.ADbSet.Select(a => a).Single();
var listBCount = aData.List.Count;
aData.List.Add(new TestB(0)
{
Id = 15
});
context.ADbSet.UpdateOnSubmit(aData);
context.SubmitChanges();
aData.List.RemoveAll(b => b.Id == 15);
context.ADbSet.UpdateOnSubmit(aData);
context.SubmitChanges();
Assert.AreEqual(listBCount, context.ADbSet.Select(a => a).Single().List.Count);
}
}
public void TestNewExpression()
{
using (var context = new TestDataContext())
{
var result1 = context.ADbSet.Where(i => new TestA(0) != null).Count();
Assert.AreEqual(1, result1);
var result2 = context.ADbSet.Where(i => new TestA2() != null).Count();
Assert.AreEqual(1, result2);
var result3 = context.ADbSet.Where(i => new TestA(i.Id) != null).Count();
Assert.AreEqual(1, result3);
var result4 = context.ADbSet.Where(i => new TestA2((n) => n > 0, new TestA(2)) == null).Count();
Assert.AreEqual(0, result4);
var test = new TestA(0);
var result5 = context.ADbSet.Where(i => new TestA2((n) => n > 0, test) != null).Count();
Assert.AreEqual(1, result5);
}
}
public void Queries_Simple_CanReadList()
{
const string connectionString = "Data Source=:memory:";
var options = new DataContextOptionsBuilder().UseSqlite(connectionString).Options;
using (var context = new TestDataContext(options))
{
context.Initialize();
Assert.Equal(2, context.Products.Count());
var query = from p in context.Products
where p.Name == "Banana"
select p;
var products = query.ToList <Product>();
Assert.Single(products);
Assert.Equal("Banana", products[0].Name);
}
}
public void ShouldReturnFoo()
{
//Arrange
var context = new TestDataContext(Settings.Default.Connection, new FooMappingConfiguration(),
new ConsoleOutLogger("Test", LogLevel.All, true, true, true, string.Empty));
var item = new Foo();
context.Add(item);
context.Commit();
var target = Data.Queries.GetById <Foo>(item.Id);
//Act
var result = target.Execute(context);
//Assert
Assert.AreEqual(item.Id, result.Id);
context.Remove(result);
context.Commit();
}
public void TestConditionalExpression()
{
using (var context = new TestDataContext())
{
var a = true;
var result1 = context.ADbSet.Where(i => a ? false : true).Count();
Assert.AreEqual(0, result1);
var result2 = context.ADbSet.Where(i => a ? i.Id > 0 : false).Count();
Assert.AreEqual(1, result2);
var result3 = context.ADbSet.Where(i => i.Id > 0 ? false : true).Count();
Assert.AreEqual(0, result3);
var result4 = context.ADbSet.Where(i => i.Id > 0 ? i.Id > 0 : false).Count();
Assert.AreEqual(1, result4);
bool[] arr = null;
var result5 = context.ADbSet.Where(i => arr != null ? arr[0] : false).Count();
Assert.AreEqual(0, result5);
}
}
public IDatabaseContext GetContext()
{
if (!_dataContexts.ContainsKey(typeof(TestDataContext)))
{
lock (_lockObj)
{
if (!_dataContexts.ContainsKey(typeof(TestDataContext)))
{
DbContext dataContext;
// if (typeof(TContext) == typeof(TestDataContext))
dataContext = new TestDataContext();
//else if (typeof(TContext) == typeof(TaskQueueContext))
// dataContext = new TaskQueueContext();
//else
// throw new NotSupportedException(typeof(TContext).ToString());
_dataContexts.Add(typeof(TestDataContext), dataContext);
}
}
}
return((IDatabaseContext)_dataContexts[typeof(TestDataContext)]);
}
public void NavigationSortTest()
{
var navigationSort = new Sort
{
Field = nameof(Genre.Name),
Direction = SortDirection.Ascending
};
using (var dbContext = new TestDataContext())
{
var items = dbContext.Tracks.ToList();
var queryable = dbContext.Tracks.NavigationSort(navigationSort, nameof(Track.Genre));
var sql = ((DbQuery <Track>)queryable).Sql;
var sorted = queryable.ToList();
Debug.WriteLine(sql);
Assert.AreEqual(items.Count, sorted.Count);
Assert.AreNotEqual(items[0].Genre.Name, sorted[0].Genre.Name);
Assert.AreEqual("Alternative", sorted[0].Genre.Name);
}
}
public void Queries_Projections_CanProjectToDTO()
{
const string connectionString = "Data Source=:memory:";
var options = new DataContextOptionsBuilder().UseSqlite(connectionString).Options;
using (var context = new TestDataContext(options))
{
context.Initialize();
var q = from p in context.Products
select new ProductDto
{
ProductDescription = p.Name
};
var result = q.ToList();
Assert.Equal(2, result.Count());
Assert.Equal("Banana", result[0].ProductDescription);
Assert.Equal("Plum", result[1].ProductDescription);
}
}
public void Bound_SelectedItem_Should_Not_Be_Cleared_when_Changing_Selection()
{
using (Application())
{
var dataContext = new TestDataContext();
var target = new TreeView
{
Template = CreateTreeViewTemplate(),
DataContext = dataContext
};
target.Bind(TreeView.ItemsProperty, new Binding("Items"));
target.Bind(TreeView.SelectedItemProperty, new Binding("SelectedItem"));
var visualRoot = new TestRoot();
visualRoot.Child = target;
CreateNodeDataTemplate(target);
ApplyTemplates(target);
var selectedValues = new List <object>();
dataContext.PropertyChanged += (_, e) =>
{
if (e.PropertyName == nameof(TestDataContext.SelectedItem))
{
selectedValues.Add(dataContext.SelectedItem);
}
};
selectedValues.Add(dataContext.SelectedItem);
_mouse.Click((Interactive)target.Presenter.Panel.Children[0], MouseButton.Left);
_mouse.Click((Interactive)target.Presenter.Panel.Children[2], MouseButton.Left);
Assert.Equal(3, selectedValues.Count);
Assert.Equal(new[] { null, "Item 0", "Item 2" }, selectedValues.ToArray());
}
}
public void TestL2SProviderConstructorThrows()
{
// Test for a provider that derives from LinqToSqlDomainService, since LinqToSqlDomainService is instantiated differently
TestDataContext ctxt = new TestDataContext(new Uri(TestURIs.RootURI, "TestDomainServices-ThrowingDomainServiceL2S.svc"));
LoadOperation lo = ctxt.Load(ctxt.CreateQuery<Product>("GetProducts", null), false);
EnqueueConditional(delegate
{
return lo.IsComplete;
});
EnqueueCallback(delegate
{
DomainOperationException ex = (DomainOperationException)lo.Error;
Assert.IsNotNull(ex);
Assert.AreEqual(OperationErrorStatus.NotSupported, ex.Status);
Assert.AreEqual(string.Format(Resource.DomainContext_LoadOperationFailed, "GetProducts", "Couldn't construct this type."), ex.Message);
});
EnqueueTestComplete();
}
public void TestInvalidProviderName() {
// first test an invalid name
TestDataContext ctxt = new TestDataContext(new Uri(TestURIs.RootURI, "TestDomainServices-DNE.svc"));
LoadOperation lo = ctxt.Load(ctxt.CreateQuery<Product>("NonExistentMethod", null), false);
EnqueueConditional(delegate {
return lo.IsComplete;
});
EnqueueCallback(delegate {
Assert.IsNotNull(lo.Error);
Assert.IsTrue(lo.Error.Message.Contains("Load operation failed"));
});
// now test an empty name (just the service path is specified w/o a DomainService name)
EnqueueCallback(delegate {
ctxt = new TestDataContext(TestURIs.RootURI);
lo = ctxt.Load(ctxt.CreateQuery<Product>("NonExistentMethod", null), false);
});
EnqueueConditional(delegate {
return lo.IsComplete;
});
EnqueueCallback(delegate {
Assert.IsNotNull(lo.Error);
Assert.IsTrue(lo.Error.Message.Contains("Load operation failed"));
});
EnqueueTestComplete();
}
private void DoTest(
Action<MockBindingContext> action,
Func<MockBindingContext, object> findTargetObjectFunc,
MvxBindingDescription expectedDescription)
{
ClearAll();
MvxBindingSingletonCache.Initialize();
var dataContext = new TestDataContext();
var bindingContext = new Mock<IMvxBindingContext>();
bindingContext.Setup(x => x.RegisterBinding(It.IsAny<object>(), It.IsAny<IMvxUpdateableBinding>()));
bindingContext.SetupGet(x => x.DataContext).Returns(dataContext);
var callbacksSeen = new List<Callback>();
var binder = new Mock<IMvxBinder>();
binder.Setup(
b => b.Bind(It.IsAny<object>(), It.IsAny<object>(), It.IsAny<IEnumerable<MvxBindingDescription>>()))
.Callback((object source, object target, IEnumerable<MvxBindingDescription> descriptions) =>
{
if (descriptions.Count() != 1)
throw new Exception("Unexpected description count");
callbacksSeen.Add(new Callback
{
Source = source,
Target = target,
BindingDescription = descriptions.First()
});
});
Ioc.RegisterSingleton(binder.Object);
Ioc.RegisterSingleton<IMvxPropertyExpressionParser>(new MvxPropertyExpressionParser());
var converterLookup = new MvxValueConverterRegistry();
converterLookup.AddOrOverwrite("SampleConv", new SampleValueConverter());
Ioc.RegisterSingleton<IMvxValueConverterLookup>(converterLookup);
var testTarget = new MockBindingContext
{
Target = new TestTarget(),
BindingContext = bindingContext.Object
};
action(testTarget);
Assert.AreEqual(1, callbacksSeen.Count);
var callback = callbacksSeen[0];
var expectedTarget = findTargetObjectFunc(testTarget);
Assert.AreEqual(expectedTarget, callback.Target);
Assert.AreEqual(dataContext, callback.Source);
var desc = callback.BindingDescription;
Assert.IsTrue(expectedDescription.Source is MvxPathSourceStepDescription);
var path = desc.Source as MvxPathSourceStepDescription;
Assert.IsTrue(desc.Source is MvxPathSourceStepDescription);
var expectedPath = expectedDescription.Source as MvxPathSourceStepDescription;
Assert.AreEqual(expectedPath.ConverterParameter, path.ConverterParameter);
Assert.AreEqual(expectedPath.FallbackValue, path.FallbackValue);
Assert.AreEqual(expectedPath.SourcePropertyPath, path.SourcePropertyPath);
Assert.AreEqual(expectedDescription.Mode, desc.Mode);
Assert.AreEqual(expectedDescription.TargetName, desc.TargetName);
if (expectedPath.Converter == null)
Assert.IsNull(path.Converter);
else
Assert.AreEqual(expectedPath.Converter.GetType(), path.Converter.GetType());
}
public void TestInvalidMethodName() {
TestDataContext ctxt = new TestDataContext(TestURIs.LTS_Catalog);
ExceptionHelper.ExpectException<MissingMethodException>(delegate
{
ctxt.Load(ctxt.CreateQuery<Product>("DNE", null), false);
}, String.Format(Resource.WebDomainClient_OperationDoesNotExist, "DNE"));
}
public void TestNonDomainService() {
TestDataContext ctxt = new TestDataContext(new Uri(TestURIs.RootURI, "TestDomainServices-NonDomainService.svc"));
LoadOperation lo = ctxt.Load(ctxt.CreateQuery<Product>("GetProducts", null), false);
EnqueueConditional(delegate {
return lo.IsComplete;
});
EnqueueCallback(delegate {
Assert.IsNotNull(lo.Error);
// TODO: Assert proper error message... Note: WCF error messages differ between desktop and Silverlight.
//Assert.IsTrue(lo.Error.InnerException.Message.StartsWith("There was no endpoint listening"));
//Assert.AreEqual(OperationErrorStatus.NotFound, ex.Status);
//Assert.AreEqual(Resource.DomainClient_ResourceNotFound, ex.Message);
});
EnqueueTestComplete();
}
public void UnhandledLoadOperationError()
{
TestDataContext ctxt = new TestDataContext(new Uri(TestURIs.RootURI, "TestDomainServices-TestCatalog1.svc"));
var query = ctxt.CreateQuery<Product>("ThrowGeneralException", null, false, true);
LoadOperation lo = new LoadOperation<Product>(query, LoadBehavior.KeepCurrent, null, null, null);
DomainOperationException expectedException = null;
DomainOperationException ex = new DomainOperationException("Operation Failed!", OperationErrorStatus.ServerError, 42, "StackTrace");
try
{
lo.Complete(ex);
}
catch (DomainOperationException e)
{
expectedException = e;
}
// verify the exception properties
Assert.IsNotNull(expectedException);
Assert.AreEqual(string.Format(Resource.DomainContext_LoadOperationFailed, "ThrowGeneralException", ex.Message), expectedException.Message);
Assert.AreEqual(ex.StackTrace, expectedException.StackTrace);
Assert.AreEqual(ex.Status, expectedException.Status);
Assert.AreEqual(ex.ErrorCode, expectedException.ErrorCode);
Assert.AreEqual(false, lo.IsErrorHandled);
// now test again with validation errors
expectedException = null;
ValidationResult[] validationErrors = new ValidationResult[] { new ValidationResult("Foo", new string[] { "Bar" }) };
lo = new LoadOperation<Product>(query, LoadBehavior.KeepCurrent, null, null, null);
try
{
lo.Complete(validationErrors);
}
catch (DomainOperationException e)
{
expectedException = e;
}
// verify the exception properties
Assert.IsNotNull(expectedException);
Assert.AreEqual(string.Format(Resource.DomainContext_LoadOperationFailed_Validation, "ThrowGeneralException"), expectedException.Message);
}
