private void AddBadge()
{
Console.Clear();
Badge content = new Badge();
content.DoorAccess = new List <string>();
Console.WriteLine("What is the number on the badge?");
content.BadgeID = int.Parse(Console.ReadLine());
Console.WriteLine($"Enter a door that Badge#{content.BadgeID} needs access to: \n\n");
content.DoorAccess.Add(Console.ReadLine().ToUpper());
Console.WriteLine("Would you like to add another door access to this badge? Y/N");
bool answer = GetYesNoAnswer();
if (answer)
{
Console.WriteLine($"Enter another door that Badge#{content.BadgeID} needs access to: \n\n");
content.DoorAccess.Add(Console.ReadLine().ToUpper());
}
else
{
Console.WriteLine("Ok you can always add at a later time");
}
_badgeInfo.AddBadge(content);
Console.Clear();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine($"Badge #{content.BadgeID} was created successfully!");
Console.ResetColor();
}
public async Task can_find_by_user()
{
var badgeRepo = new BadgeRepo(CreateTemporaryDatabase());
// given
Badge badgeUserA1 = await badgeRepo.AddBadge("userA", PkmnSpecies.OfId("1"), Badge.BadgeSource.Pinball);
Badge badgeUserA2 = await badgeRepo.AddBadge("userA", PkmnSpecies.OfId("2"), Badge.BadgeSource.Pinball);
Badge badgeUserB = await badgeRepo.AddBadge("userB", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
Badge badgeNobody = await badgeRepo.AddBadge(null, PkmnSpecies.OfId("4"), Badge.BadgeSource.Pinball);
// when
List <Badge> resultUserA = await badgeRepo.FindByUser("userA");
List <Badge> resultUserB = await badgeRepo.FindByUser("userB");
List <Badge> resultNobody = await badgeRepo.FindByUser(null);
// then
Assert.AreEqual(new List <Badge> {
badgeUserA1, badgeUserA2
}, resultUserA);
Assert.AreEqual(new List <Badge> {
badgeUserB
}, resultUserB);
Assert.AreEqual(new List <Badge> {
badgeNobody
}, resultNobody);
}
public void AddbadgesToBadgeList_ShouldSucceed()
{
//Arrange
var aBadge = new ABadge();
var bBadge = new BBadge();
var cBadge = new CBadge();
var badgeRepo = new BadgeRepo();
//Act
badgeRepo.AddBadge(aBadge);
badgeRepo.AddBadge(bBadge);
badgeRepo.AddBadge(cBadge);
var expected = new List <Badge>
{
aBadge,
bBadge,
cBadge
};
var actual = badgeRepo.ReturnBadgeList();
//Assert
CollectionAssert.AreEqual(expected, actual);
}
private void AddBadge()
{
Console.Clear();
// Create new Badge
Badge badge = new Badge();
// Get user input Badge Number
Console.WriteLine("What is the number on the badge:");
bool keepRunning = true;
while (keepRunning)
{
try
{
badge.BadgeID = int.Parse(Console.ReadLine());
keepRunning = false;
}
catch
{
Console.WriteLine("Please enter numbers only");
}
}
// Get list of doors
List <string> doors = new List <string>();
keepRunning = true;
while (keepRunning)
{
Console.WriteLine("List a door that it needs access to:");
string input = Console.ReadLine();
doors.Add(input);
Console.WriteLine("Any other doors(y/n)?");
bool keepRunning2 = true;
while (keepRunning2)
{
input = Console.ReadLine();
if (input.ToLower() == "n")
{
keepRunning = false;
keepRunning2 = false;
}
else if (input.ToLower() == "y")
{
keepRunning = true;
keepRunning2 = false;
}
else
{
Console.WriteLine("Please enter valid y or n");
}
}
}
badge.DoorNames = doors;
_badgeRepo.AddBadge(badge.BadgeID, badge);
}
public void ListAllBadgesTrue()
{
BadgeRepo badgeRepo = new BadgeRepo();
badgeRepo.AddBadge("Hallway");
badgeRepo.AddBadge("Hallway");
badgeRepo.AddBadge("Hallway");
Assert.AreEqual(3, badgeRepo.ListAllBadges().Count);
}
private void AddBadge()
{
Console.Clear();
Badge badge = new Badge();
Console.WriteLine("Enter Badge Number:");
badge.BadgeID = double.Parse(Console.ReadLine());
Console.WriteLine("List a door that badge needs access to");
string userinput = Console.ReadLine();
badge.DoorNames.Add(userinput);
Console.WriteLine("Any other doors? y/n");
string seconduserinput = Console.ReadLine().ToLower();
if (seconduserinput == "y")
{
do
{
Console.WriteLine("List a door that badge needs access to");
string additionalDoor = Console.ReadLine().ToLower();
badge.DoorNames.Add(additionalDoor);
Console.WriteLine("Any other doors? y/n");
seconduserinput = Console.ReadLine().ToLower();
}while (seconduserinput == "y");
if (seconduserinput == "n")
{
_repo.AddBadge(badge);
Console.Clear();
Console.WriteLine("Select Option:\n" +
"1.Add a badge \n" +
"2.Edit a badge \n" +
"3.List all badges\n" +
"4.Exit");
}
}
else if (seconduserinput == "n")
{
_repo.AddBadge(badge);
Console.Clear();
Console.WriteLine("Select Option:\n" +
"1.Add a badge \n" +
"2.Edit a badge \n" +
"3.List all badges\n" +
"4.Exit");
}
else
{
Console.WriteLine("Please enter y/n");
seconduserinput = Console.ReadLine().ToLower();
}
}
public void ListMatchingDoorTrue()
{
BadgeRepo badgeRepo = new BadgeRepo();
badgeRepo.AddBadge("Hallway");
badgeRepo.AddBadge("Hallway");
badgeRepo.AddBadge("Main");
badgeRepo.AddBadge("Hallway");
Assert.AreEqual(1, badgeRepo.ListMatchingDoor("Main").Count);
}
public void ClearBadgeTrue()
{
BadgeRepo badgeRepo = new BadgeRepo();
badgeRepo.AddBadge("Hallway");
Assert.IsTrue(badgeRepo.ClearBadge(1));
}
public void EditBadgeTrue()
{
BadgeRepo badgeRepo = new BadgeRepo();
badgeRepo.AddBadge("Hallway");
Assert.IsTrue(badgeRepo.EditBadge(1, "Main"));
}
public void Arrange()
{
_repo = new BadgeRepo();
_badge = new Badge(12345, new List <string> {
"A7"
});
_repo.AddBadge(_badge.BadgeID, _badge);
}
public void Arrange()
{
badgeRepo = new BadgeRepo();
badge = new Badge(1000, new List <string> {
"A7"
});
badgeRepo.AddBadge(badge);
}
public void AddBadgeAddsBadge()
{
Badge badge = new Badge();
BadgeRepo badgeRepo = new BadgeRepo();
bool result = badgeRepo.AddBadge(badge);
Assert.IsTrue(result);
}
public void AddBadgeAndShowTest_AddBadgeToListAndShow()
{
BadgeRepo repo = new BadgeRepo();
Badges badge = new Badges(badgeID, doors);
repo.AddBadge(badge);
Assert.IsTrue(repo.ShowAllBadges());
}
public void ShowBadgeTest_ShowsBadge()
{
BadgeRepo repo = new BadgeRepo();
Badges badge = new Badges(badgeID, doors);
repo.AddBadge(badge);
Assert.IsTrue(repo.ShowBadge(badgeID));
}
public void AddBadge_ShouldAddBadge()
{
Badge badge = new Badge();
// _repo = new BadgeRepo();
badge.BadgeID = 5;
badge.DoorNames = new List <string>()
{
"A5"
};
_repo.AddBadge(badge);
bool badgeadded = _repo.AddBadge(badge);
Assert.IsTrue(badgeadded);
}
public async Task can_count_by_user_and_species()
{
var badgeRepo = new BadgeRepo(CreateTemporaryDatabase());
// given
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("2"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("userOther", PkmnSpecies.OfId("1"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("userOther", PkmnSpecies.OfId("2"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("userOther", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
// when
long countHasNone = await badgeRepo.CountByUserAndSpecies("user", PkmnSpecies.OfId("1"));
long countHasOne = await badgeRepo.CountByUserAndSpecies("user", PkmnSpecies.OfId("2"));
long countHasThree = await badgeRepo.CountByUserAndSpecies("user", PkmnSpecies.OfId("3"));
// then
Assert.AreEqual(0, countHasNone);
Assert.AreEqual(1, countHasOne);
Assert.AreEqual(3, countHasThree);
}
public void CreatBadgeTestShouldWork()
{
Badge badge = new Badge();
BadgeRepo repo = new BadgeRepo();
bool add = repo.AddBadge(badge);
Assert.IsTrue(add);
}
public void TestAddBadge()
{
BadgeRepo badgeRepo = new BadgeRepo();
Badge testBadge = new Badge();
Assert.AreEqual(0, badgeRepo.AllBadges().Count);
badgeRepo.AddBadge(testBadge);
Assert.AreEqual(1, badgeRepo.AllBadges().Count);
}
public void AddDoorsTest_AddDoorToBadge()
{
BadgeRepo repo = new BadgeRepo();
Badges badge = new Badges(badgeID, doors);
repo.AddBadge(badge);
Assert.IsTrue(repo.AddDoor(badgeID, "CD21"));
repo.ShowAllBadges();
}
public void RemoveDoorsTest_RemoveDoorFromList()
{
BadgeRepo repo = new BadgeRepo();
Badges badge = new Badges(badgeID, doors);
repo.AddBadge(badge);
Assert.IsTrue(repo.RemoveDoor(badgeID, "C3"));
repo.ShowAllBadges();
}
public void DeleteAllDoorsTest_RemovesAllDoors()
{
BadgeRepo repo = new BadgeRepo();
Badges badge = new Badges(badgeID, doors);
repo.AddBadge(badge);
Assert.IsTrue(repo.DeleteAllDoors(badgeID));
repo.ShowAllBadges();
}
public void TestAddUniqueKey()
{
// arrange
List <string> testDoors = new List <string>();
testDoors.Add("A1");
testDoors.Add("D3");
testDoors.Add("F4");
// act and assert
Assert.IsTrue(testBadgeRepo.AddBadge(1, testDoors));
}
public void AddBadgeTest()
{
//Arrange
badgeRepo = new BadgeRepo();
//Act
badgeRepo.AddBadge("city", new List <int> {
01
});
//Assert
Assert.IsNotNull(badgeRepo.leaderAccess);
}
public void AddBadge_ShouldGetNotNull()
{
Badge item = new Badge();
item.BadgeID = 246;
BadgeRepo repo = new BadgeRepo();
repo.AddBadge(item);
Assert.IsNotNull(repo.GetBadgeDict()[item.BadgeID]);
}
private void SeedContent()
{
List <DoorAccess> listOne = new List <DoorAccess>
{
DoorAccess.A1,
DoorAccess.B1,
DoorAccess.B3
};
List <DoorAccess> listTwo = new List <DoorAccess>
{
DoorAccess.A2,
DoorAccess.A3,
DoorAccess.B3
};
Badge bOne = new Badge(1234, listOne);
Badge bTwo = new Badge(2341, listTwo);
_repo.AddBadge(bOne);
_repo.AddBadge(bTwo);
}
public void AddBadgeShouldReturnTrue()
{
//BadgeRepo _repos = new BadgeRepo();
// arrange
Badge second = new Badge(22345, new List <string> {
"A1", "A4", "B1", "B2"
});
bool wasAdded = _repo.AddBadge(second.BadgeID, second);
// act/assert
Assert.IsTrue(wasAdded);
}
public void ReadBadges()
{
BadgeRepo repo = new BadgeRepo();
Badge badge = new Badge();
repo.AddBadge(badge);
Dictionary <int, Badge> dict = repo.GetFullDictionary();
bool newDict = dict.ContainsValue(badge);
Assert.IsTrue(newDict);
}
public async Task insert_sets_current_timestamp_as_creation_date()
{
Mock <IClock> clockMock = new();
Instant createdAt = Instant.FromUnixTimeSeconds(123);
clockMock.Setup(c => c.GetCurrentInstant()).Returns(createdAt);
IBadgeRepo badgeRepo = new BadgeRepo(
CreateTemporaryDatabase(), Mock.Of <IMongoBadgeLogRepo>(), clockMock.Object);
Badge badge = await badgeRepo.AddBadge(null, PkmnSpecies.OfId("16"), Badge.BadgeSource.ManualCreation);
Assert.AreEqual(createdAt, badge.CreatedAt);
}
public async Task insert_then_read_are_equal()
{
BadgeRepo badgeRepo = CreateBadgeRepo();
// when
Badge badge = await badgeRepo.AddBadge(null, PkmnSpecies.OfId("16"), Badge.BadgeSource.ManualCreation);
// then
Assert.AreNotEqual(string.Empty, badge.Id);
Badge badgeFromDatabase = await badgeRepo.Collection.Find(b => b.Id == badge.Id).FirstOrDefaultAsync();
Assert.NotNull(badgeFromDatabase);
Assert.AreNotSame(badgeFromDatabase, badge);
Assert.AreEqual(badgeFromDatabase, badge);
}
public void SeedTestMethod()
{
List <DoorAccess> listOne = new List <DoorAccess>
{
DoorAccess.A1,
DoorAccess.B1,
DoorAccess.B3
};
_repo = new BadgeRepo();
_badge = new Badge(1234, listOne);
_repo.AddBadge(_badge);
}
