public static async Task CreateUniversity(TestContext _)
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var nearbyResult = new NearByResult
{
Name = "Test",
Geometry = new Geometry {
Location = new Location(0.0, 0.0)
}
};
var templateService = new ChannelTemplateService(new SqlChannelTemplateRepository(context));
await templateService.CreateDefaultTemplatesAsync();
// Create a test university with default channels
var testUniversity = await repo.CreateAsync(nearbyResult, await templateService.GetAsync());
// Save a reference to one of the default channels and a new user
General = testUniversity.Server.Channels.Single(ch => ch.Name == "general");
Bob = new User {
UserName = "******"
};
// Add a test user to it
General.Memberships.Add(new Membership {
User = Bob
});
// Save it to the in-memory database for use in tests
await repo.SaveAsync();
}
}
public static async Task CreateUniversity(TestContext _)
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var nearbyResult = new NearByResult
{
Name = "Test",
Geometry = new Geometry {
Location = new Location(0.0, 0.0)
}
};
var templateService = new ChannelTemplateService(new SqlChannelTemplateRepository(context));
await templateService.CreateDefaultTemplatesAsync();
// Create a test university with default channels
var testUniversity = await repo.CreateAsync(nearbyResult, await templateService.GetAsync());
Test = testUniversity;
Bob = new User {
UserName = "******"
};
// Save it to the in-memory database for use in tests
await repo.SaveAsync();
}
}
public async Task LookupAsync_Should_Fail_With_Unknown_PlaceId()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
await repo.LookupAsync("Test");
}
}
public void AllQueryable_Should_Fail_With_Unknown_QueryDepth()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
repo.AllQueryable((QueryDepth)5);
}
}
public async Task AllQueryable_University_Should_Not_Get_Servers()
{
await SetUpSampleUniversity();
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var universities = repo
.AllQueryable(QueryDepth.University)
.ToList();
Assert.IsNull(universities.First().Server);
}
}
public async Task AllQueryable_Message_Should_Get_Everything()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var testUni = new UniversityService(repo);
var universities = await testUni.GetAllAsync();
Assert.IsNotNull(universities.First());
Assert.IsNotNull(universities.First().Server);
Assert.IsNotNull(universities.First().Server.Channels);
Assert.IsNotNull(universities.First().Server.Channels.First().Users);
Assert.IsNotNull(universities.First().Server.Channels.First().Messages);
}
}
public async Task AllQueryable_User_Should_Not_Get_Messages()
{
await SetUpSampleUniversity();
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var universities = repo
.AllQueryable(QueryDepth.User)
.ToList();
var channel = universities.First().Server.Channels.First();
Assert.IsNotNull(channel.Users);
Assert.IsNull(channel.Messages);
}
}
public async Task SaveASync_Should_Save_Changes_On_Context()
{
var saveChangesCalled = false;
// Create a fake WarblerDbContext
var mockContext = new Mock <WarblerDbContext>(Options);
// Watch its SaveChangesAsync() method to see if it gets called by the repo
mockContext.Setup(x => x.SaveChangesAsync(default(CancellationToken)))
.Callback(() => saveChangesCalled = true)
.ReturnsAsync(0);
// Attach it to the repo and call SaveAsync()
var repo = new SqlUniversityRepository(mockContext.Object);
await repo.SaveAsync();
Assert.IsTrue(saveChangesCalled);
}
public async Task JoinAsync_Should_Have_Users_Join_All_Channels_In_A_University()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var test = new UniversityService(repo);
var newUser = new User {
UserName = "******"
};
var testUni = await repo.LookupAsync
(context.Universities.FirstOrDefault
(u => u.Name == "Test").PlaceId);
//Assert.AreEqual(2, context.Universities.Count());
await test.JoinAsync(newUser, testUni);
var testUser = context.Users.FirstOrDefault(u => u.UserName == "Bill");
Assert.AreEqual(testUni.Server.Channels.Count(), testUser.Channels.Count());
}
}
private async Task SetUpSampleUniversity()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var nearbyResult = new NearByResult
{
Name = "Test",
Geometry = new Geometry {
Location = new Location(0.0, 0.0)
}
};
var templateService = new ChannelTemplateService(new SqlChannelTemplateRepository(context));
await templateService.CreateDefaultTemplatesAsync();
// Create a test university with default channels
await repo.CreateAsync(nearbyResult, await templateService.GetAsync());
}
}
public async Task GetOrCreateAsync_Should_Create_A_New_University()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var test = new UniversityService(repo);
var nearbyResult = new NearByResult
{
Name = "NewUni",
Geometry = new Geometry {
Location = new Location(1.0, 1.0)
}
};
var templateService = new ChannelTemplateService(new SqlChannelTemplateRepository(context));
await templateService.CreateDefaultTemplatesAsync();
var uniTest = await test.GetOrCreateAsync(nearbyResult, await templateService.GetAsync());
//Assert.AreEqual(2, context.Universities.Count());
Assert.AreEqual("NewUni", uniTest.Name);
}
}
