public async Task FindByNameAsync_Should_Get_A_User_By_Username()
{
User foundUser;
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUserRepository(context);
var test = new UserService(repo);
foundUser = await test.FindByNameAsync("Bob");
}
Assert.AreEqual(Bob, foundUser);
}
public void SetUpDatabase()
{
Options = new DbContextOptionsBuilder <WarblerDbContext>()
.UseInMemoryDatabase(nameof(TestSqlUniversityRepository))
.Options;
using (var context = new WarblerDbContext(Options))
{
new ChannelTemplateService(new SqlChannelTemplateRepository(context))
.CreateDefaultTemplatesAsync().Wait();
}
}
public async Task IsNewAsync_Should_Be_True_If_User_Was_Recently_Created()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUserRepository(context);
var test = new UserService(repo);
var jimmy = new User {
UserName = "******"
};
Assert.IsTrue(await test.IsNewAsync(jimmy));
}
}
public async Task AllForUser_Should_Return_Channels_Where_User_Is_Member()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlMembershipRepository(context);
var bobMemberships = await repo.AllFor(Bob).ToList();
// Bob was only added to one channel (#general)
Assert.AreEqual(1, bobMemberships.Count);
Assert.IsTrue(bobMemberships.Single().Channel.Name == "general");
}
}
public async Task AllMembershipsForAsyncChannel_Should_Return_Users_That_Are_Members()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlMembershipRepository(context);
var test = new MembershipService(repo);
var generalMemberships = await test.AllMembershipsForAsync(General);
// General only had one member added (Bob)
Assert.AreEqual(1, generalMemberships.Count);
Assert.IsTrue(generalMemberships.Single().User.UserName == "Bob");
}
}
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 CreateAsync_Should_Create_A_New_Message()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlMessageRepository(context);
var test = new MessageService(repo);
var message = await test.CreateAsync("Hello", Bob, General);
Assert.AreEqual(1, context.Messages.Count());
Assert.IsNotNull(message);
Assert.AreEqual("Hello", message.Text);
Assert.AreEqual(Bob.Id, message.UserId);
Assert.AreEqual(General.Id, message.ChannelId);
}
}
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 ManageController(
UserManager <User> userManager,
SignInManager <User> signInManager,
IEmailSender emailSender,
ISmsSender smsSender,
ILoggerFactory loggerFactory,
WarblerDbContext context,
SamlConfigurations samlConfigurations)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_smsSender = smsSender;
_logger = loggerFactory.CreateLogger <ManageController>();
_dbContext = context;
_samlConfigurations = samlConfigurations;
}
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 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());
}
}
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);
}
}
public async Task LatestIn_Should_Return_Messages_In_Reverse_Chronological_Order()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlMessageRepository(context);
await repo.CreateAsync("foo", Bob, General);
await repo.CreateAsync("bar", Bob, General);
}
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlMessageRepository(context);
var messages = repo.LatestIn(General);
var firstMessage = messages.First().Result;
var lastMessage = messages.Last().Result;
Assert.AreEqual("bar", lastMessage.Text);
Assert.AreEqual("foo", firstMessage.Text);
Assert.IsTrue(lastMessage.SendDate > firstMessage.SendDate);
}
}
public SqlClaimRequestRepository(WarblerDbContext context)
{
Context = context;
}
/// <summary>
/// Automatically called each time SignalR receives a packet from a client.
/// Both parameters are injected automatically by ASP.NET DI.
/// </summary>
public ProximityHub(ProximityService service, WarblerDbContext context)
{
ProximityService = service.With(context);
UserService = new UserService(new SqlUserRepository(context));
}
public SqlServerRepository(WarblerDbContext context) => Context = context;
public SqlUserRepository(WarblerDbContext context)
{
Context = context;
}
public SqlMessageRepository(WarblerDbContext context)
{
Context = context;
}
public SqlAuthConfigRepository(WarblerDbContext context)
{
Context = context;
}
public SqlUniversityRepository(WarblerDbContext context) => Context = context;
public DevController(WarblerDbContext context)
{
UniversityService = new UniversityService(new SqlUniversityRepository(context));
ClaimRequestService = new ClaimRequestService(new SqlClaimRequestRepository(context));
}
/// <summary>
/// Automatically called each time SignalR receives a packet from a client.
/// </summary>
public ChatHub(WarblerDbContext context, ChatService service)
{
ChatService = service.With(context);
UserService = new UserService(new SqlUserRepository(context));
}
public SqlMembershipRepository(WarblerDbContext context)
{
Context = context;
}
public ProximityService With(WarblerDbContext context)
{
UniversityService = new UniversityService(new SqlUniversityRepository(context));
ChannelTemplateService = new ChannelTemplateService(new SqlChannelTemplateRepository(context));
return(this);
}
public SqlChannelTemplateRepository(WarblerDbContext context)
{
Context = context;
}
