public async Task GetAllSpeakerProfile_ReturnsEmpty_IfSpeakerProfileEntity_IsEmptyAsync()
{
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
try
{
var options = new DbContextOptionsBuilder <PlanificatorDbContext>()
.UseSqlite(connection)
.Options;
using (var context = new PlanificatorDbContext(options))
{
context.Database.EnsureCreated();
var query = new SpeakerRepository(context);
Assert.Empty(await query.GetAllSpeakersProfilesAsync());
}
}
finally
{
connection.Close();
}
}
public void ItHasGetAllMethod()
{
// Arrange
var repo = new SpeakerRepository();
// Act
var result = repo.GetAll();
}
public void ItIsARepository()
{
// Arrange / Act
var repo = new SpeakerRepository();
// Assert
Assert.IsAssignableFrom <IRepository <Speaker> >(repo);
}
public async Task GetAllSpeakerProfile_returns_all_speaker_profilesAsync()
{
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
List <SpeakerProfile> speakerProfiles = new List <SpeakerProfile>
{
new SpeakerProfile
{
SpeakerId = Guid.NewGuid().ToString(),
FirstName = "Test FN",
LastName = "Test LN",
Email = "*****@*****.**",
Bio = "Test Bio",
Company = "Test Compnay",
PhotoPath = "testPath.jpg"
},
new SpeakerProfile
{
SpeakerId = Guid.NewGuid().ToString(),
FirstName = "Test2 FN",
LastName = "Test2 LN",
Email = "*****@*****.**",
Bio = "Test2 Bio",
Company = "Test2 Compnay",
PhotoPath = "test2Path.jpg"
}
};
try
{
var options = new DbContextOptionsBuilder <PlanificatorDbContext>()
.UseSqlite(connection)
.Options;
using (var context = new PlanificatorDbContext(options))
{
context.Database.EnsureCreated();
var service = new SpeakerManager(context);
var query = new SpeakerRepository(context);
foreach (SpeakerProfile speakerProfile in speakerProfiles)
{
await service.AddSpeakerProfileAsync(speakerProfile);
}
context.SaveChanges();
Assert.Equal(speakerProfiles, await query.GetAllSpeakersProfilesAsync());
}
}
finally
{
connection.Close();
}
}
public void ItHasDeleteMethod()
{
// Arrange
IRepository <Speaker> repo = new SpeakerRepository();
var speaker = new Speaker();
// Act
repo.Delete(speaker);
}
private void ModifySpeaker(long entityId, string propertyName, string value)
{
var speaker = SpeakerRepository.Get(entityId);
if (speaker != null)
{
speaker.UpdateProperty(propertyName, value);
}
}
public void ItHasUpdateMethod()
{
// Arrange
IRepository <Speaker> repo = new SpeakerRepository();
var speaker = repo.Create(new Speaker());
// Act
var result = repo.Update(speaker);
}
private void DeleteSpeaker(long entityId)
{
var speaker = SpeakerRepository.Get(entityId);
if (speaker != null)
{
speaker.MarkAsDeleted();
}
}
public void GetAllSpeakerProfiles_ReturnsOnlyUsersWhoHaveSubmittedSessions()
{
var sessionRespository = new SessionRepositoryBuilder().WithSessionSubmittedBy("fred").Build();
var userProfileRepository = new UserProfileRepositoryBuilder().WithUser("fred").WithUser("bob").Build();
var speakerRepository = new SpeakerRepository(sessionRespository, userProfileRepository);
var allSpeakers = speakerRepository.GetAllSpeakerProfiles();
Assert.That(allSpeakers.Select(s => s.UserName), Is.EqualTo(new[] { "fred" }));
}
public void GetAllSpeakerProfiles_DoesNotReturnAUserWhoHasNotSubmittedASession()
{
var sessionRespository = new SessionRepositoryBuilder().Build();
var userProfileRepository = new UserProfileRepositoryBuilder().WithUser("fred").Build();
var speakerRepository = new SpeakerRepository(sessionRespository, userProfileRepository);
var allSpeakers = speakerRepository.GetAllSpeakerProfiles();
Assert.That(allSpeakers, Is.Empty);
}
public DataService()
{
ConferenceStart = DateTime.Parse("2013/11/04");
ConferenceEnd = DateTime.Parse("2013/11/06");
TopicRepository = new TopicRepository(LoadJsonArray("topics.json"));
SessionRepository = new SessionRepository(LoadJsonArray("sessions.json"));
SpeakerRepository = new SpeakerRepository(LoadJsonArray("speakers.json"));
SessionTopicRepository = new SessionTopicRepository(LoadJsonArray("sessiontopics.json"));
}
public void ItDoesNothingWhenDeletingANonexistingSpeaker()
{
// Arrange
var repo = new SpeakerRepository();
var speaker = new Speaker();
// Act
var result = Record.Exception(() => repo.Delete(speaker));
// Assert
Assert.Null(result);
}
public void ItThrowsNotFoundExceptionWhenSpeakerDoesNotExist()
{
// Arrange
var repo = new SpeakerRepository();
var speaker = new Speaker {
Id = 5, Name = "Test Name"
};
// Act
var result = Record.Exception(() => repo.Update(speaker));
// Assert
Assert.IsAssignableFrom <SpeakerNotFoundException>(result.GetBaseException());
}
public void ItReturnsNoSpeakersWhenThereAreNoSpeakers()
{
// Arrange
var repo = new SpeakerRepository();
// Act
var result = repo.GetAll();
// Assert
Assert.NotNull(result);
Assert.NotNull(result);
Assert.IsAssignableFrom <IQueryable <Speaker> >(result);
Assert.Equal(0, result.Count());
}
public void ItProtectsAgainstPassedObjectChanges()
{
// Arrange
var repo = new SpeakerRepository();
var speaker = repo.Create(new Speaker {
Name = "Test Name"
});
// Act
repo.Delete(speaker);
// Assert
Assert.False(speaker.IsDeleted);
}
public void ItReturnsManySpeakersWhenManySpeakersExists()
{
// Arrange
var repo = new SpeakerRepository();
repo.Create(new Speaker());
repo.Create(new Speaker());
repo.Create(new Speaker());
// Act
var result = repo.GetAll().ToList();
// Assert
Assert.Equal(3, result.Count);
}
public void ItUpdatesASpeaker()
{
// Arrange
var repo = new SpeakerRepository();
var speaker = repo.Create(new Speaker {
Name = "Test Name"
});
speaker.Name = "New Name";
// Act
var result = repo.Update(speaker);
// Assert
Assert.Equal(speaker.Name, result.Name);
}
public void ItReturnsASingleSpeakerWhenOnlyOneSpeakerExists()
{
// Arrange
var repo = new SpeakerRepository();
repo.Create(new Speaker {
Name = "Test Speaker"
});
// Act
// Act
var result = repo.GetAll().ToList();
// Assert
Assert.Single(result);
Assert.Equal("Test Speaker", result.First().Name);
}
public void ItMarksTheGivenSpeakerAsDeleted()
{
// Arrange
var repo = new SpeakerRepository();
var speaker = repo.Create(new Speaker {
Name = "Test Name"
});
// Act
repo.Delete(speaker);
// Audit
var result = repo.Get(speaker.Id);
// Assert
Assert.True(result.IsDeleted);
}
public void ItProtectsAgainstObjectChanges()
{
// Arrange
var repo = new SpeakerRepository();
repo.Create(new Speaker {
Name = "Test Name"
});
var speakers = repo.GetAll().ToList();
speakers.First().Name = "New Name";
// Act
var result = repo.GetAll();
// Assert
Assert.NotEqual(speakers.First().Name, result.First().Name);
}
public async Task <bool> AddUserAsync()
{
HttpContext.Request.Headers.TryGetValue("id", out StringValues id);
HttpContext.Request.Headers.TryGetValue("name", out StringValues name);
HttpContext.Request.Headers.TryGetValue("password", out StringValues password);
SpeakerRepository speakerApi = new SpeakerRepository();
CreateVerificationProfileModel profile = await speakerApi.CreateVerificationProfile(SpeakerApiKey);
FaceRepository faceApi = new FaceRepository();
Person person = await faceApi.CreatePerson("authorized", name);
UserEntity user = new UserEntity(Int32.Parse(id), name, password, profile.VerificationProfileId.ToString(), person.PersonId.ToString(), 0, 0);
table.AddorReplaceUser(user);
return(true);
}
private void AddSpeaker(long entityId, IEnumerable <Change> changes)
{
// ensure that the entityId does NOT already exist in the Repository
var speaker = SpeakerRepository.Get(entityId);
if (speaker == null)
{
// this speaker does not exist - create it
speaker = new Speaker {
SpeakerId = entityId
};
foreach (var change in changes)
{
speaker.UpdateProperty(change.Key, change.Value);
}
SpeakerRepository.Add(speaker);
}
}
public void ItProtectsAgainstOriginalObjectChanges()
{
// Arrange
var repo = new SpeakerRepository();
var speaker = repo.Create(new Speaker {
Name = "Test Name"
});
speaker.Name = "New Name";
var updatedSpeaker = repo.Update(speaker);
// Act
speaker.Name = "Updated Name";
// Audit
var result = repo.Get(updatedSpeaker.Id);
// Assert
Assert.NotEqual("Updated Name", result.Name);
}
// methods
private async Task <bool> LoadRepositoriesAsync()
{
LoadStatus = "Loading Speakers...";
await SpeakerRepository.LoadAsync();
LoadStatus = "Loading Sessions...";
await SessionRepository.LoadAsync();
LoadStatus = "Getting Changes...";
await ChangeRepository.LoadAsync();
var changes = ChangeRepository.GetAll();
if (changes.Count > 0)
{
LoadStatus = "Applying Changes...";
ChangeService.ApplyChanges(changes);
}
return(true);
}
/// <summary>
/// Apply changes
/// </summary>
/// <param name="changeList"></param>
public void ApplyChanges(ChangeList changeList)
{
// clear the log provider
ChangeLogProvider.Clear();
// separate out the changes
var speakerChanges = changeList.SpeakerChanges;
var sessionChanges = changeList.SessionChanges;
// apply the changes
ApplySpeakerChanges(speakerChanges);
ApplySessionChanges(sessionChanges);
// save the changes
SpeakerRepository.SaveChanges();
SessionRepository.SaveChanges();
// indicate to the service that we are up to date (we will not work on the response to this)
if (changeList.Count > 0)
{
int changeSet = changeList.Max(c => c.Changeset);
UpdateClientChangesetToLatest(changeSet);
}
}
public SpeakersController(ApplicationDbContext context, SpeakerRepository speakerRepository)
{
_context = context;
_speakerRepository = speakerRepository;
}
public SpeakerService(SpeakerRepository speakerRepo, AddressRepository addressRepo, SlotRepository slotRepo)
{
_speakerRepo = speakerRepo;
_addressRepo = addressRepo;
_slotRepo = slotRepo;
}
public Get()
{
_repo = new SpeakerRepository();
}
public void ItExists()
{
var repo = new SpeakerRepository();
}
public SpeakersModel(SpeakerRepository speakerRepository)
{
this.speakerRepository = speakerRepository;
}
public SpeakerController()
{
api = new SpeakerRepository();
}
