public void Arrange()
{
_repo = new BadgeRepo();
_content = new BadgeContent(new List <string> {
"a1", "a2", "a3"
}, 1102);
}
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);
}
public void ClearBadgeTrue()
{
BadgeRepo badgeRepo = new BadgeRepo();
badgeRepo.AddBadge("Hallway");
Assert.IsTrue(badgeRepo.ClearBadge(1));
}
public void Arrange()
{
_badgeRepo = new BadgeRepo();
_badge = new Badge("TestBadge");
_badgeRepo.CreateNewBadge(_badge);
}
public void EditBadgeTrue()
{
BadgeRepo badgeRepo = new BadgeRepo();
badgeRepo.AddBadge("Hallway");
Assert.IsTrue(badgeRepo.EditBadge(1, "Main"));
}
public void Arrange()
{
_repo = new BadgeRepo();
_data = new BadgeAccessDir(12345, "A7");
_repo.AddDataToList(_data);
}
public void Arrange()
{
_repo = new BadgeRepo();
_badge = new Badge(101);
_repo.CreateNewBadge(101, _badge);
}
public void TestMethod1()
{
//Set test
var doors = new Dictionary <string, int>()
{
{ "A1", 1 },
{ "A2", 1 },
{ "A3", 1 }
};
Badge newBadge = new Badge(1, doors);
BadgeRepo newBadgeRepo = new BadgeRepo();
newBadgeRepo.AddBadgeToLists(newBadge);
//Try Update
var doors2 = new Dictionary <string, int>()
{
{ "B1", 1 },
{ "B2", 1 },
{ "B3", 1 }
};
Badge newBadge2 = new Badge(1, doors2);
newBadgeRepo.UpdateExistingBadge(1, newBadge2);
Badge newBadge3 = newBadgeRepo.GetBadgeItemById(1);
var actual = doors2;
var expected = newBadge3.Doors;
Assert.AreEqual(expected, actual); //Update without issue and added to list
}
public void UpdateBadge_ShouldUpdateBadge()
{
BadgeRepo repo = new BadgeRepo();
List <string> doors = new List <string>()
{
"door1", "door2", "door3"
};
Badge badge = new Badge()
{
DoorNames = doors,
ID = 1
};
List <string> doors2 = new List <string>()
{
"1door", "2door", "3door"
};
Badge badge2 = new Badge()
{
DoorNames = doors2,
ID = 1
};
repo.AddNewBadge(badge);
repo.UpdateExistingBadge(badge.ID, badge2);
List <string> actual = repo.GetBadges()[badge2.ID];
Assert.AreEqual(badge2.DoorNames, actual);
}
public void Arrange()
{
_badgeRepository = new BadgeRepo();
_badge = new Badge(100, new List <string> {
"A1", "A2", "A3"
});
}
public static Databases SetUpRepositories(BaseConfig baseConfig)
{
CustomSerializers.RegisterAll();
IMongoClient mongoClient = new MongoClient(baseConfig.MongoDbConnectionUri);
IMongoDatabase mongoDatabase = mongoClient.GetDatabase(baseConfig.MongoDbDatabaseName);
IUserRepo userRepo = new UserRepo(
database: mongoDatabase,
startingPokeyen: baseConfig.StartingPokeyen,
startingTokens: baseConfig.StartingTokens);
IBadgeRepo badgeRepo = new BadgeRepo(
database: mongoDatabase);
IBank <User> pokeyenBank = new Bank <User>(
database: mongoDatabase,
currencyCollectionName: UserRepo.CollectionName,
transactionLogCollectionName: "pokeyentransactions",
u => u.Pokeyen,
u => u.Id,
clock: SystemClock.Instance);
IBank <User> tokenBank = new Bank <User>(
database: mongoDatabase,
currencyCollectionName: UserRepo.CollectionName,
transactionLogCollectionName: "tokentransactions",
u => u.Tokens,
u => u.Id,
clock: SystemClock.Instance);
tokenBank.AddReservedMoneyChecker(
new PersistedReservedMoneyCheckers(mongoDatabase).AllDatabaseReservedTokens);
return(new Databases(
userRepo: userRepo,
badgeRepo: badgeRepo,
pokeyenBank: pokeyenBank,
tokensBank: tokenBank));
}
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 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 Arrange()
{
_repo = new BadgeRepo();
_badge = new Badge(500, new List <string> {
"B1", "Z2"
});
_repo.CreateNewBadge(500, _badge);
}
public void AddBadgeAddsBadge()
{
Badge badge = new Badge();
BadgeRepo badgeRepo = new BadgeRepo();
bool result = badgeRepo.AddBadge(badge);
Assert.IsTrue(result);
}
public void ListPokemonBadgeHasAccessToTest()
{
//Arrange
badgeRepo = new BadgeRepo();
//Act
//Assert
}
public void Arrange()
{
_badgeRepo = new BadgeRepo();
_badgeClass = new BadgeClass();
_badgeRepo.AddBadgeDB(_badgeClass);
}
public void AddBadgeAndShowTest_AddBadgeToListAndShow()
{
BadgeRepo repo = new BadgeRepo();
Badges badge = new Badges(badgeID, doors);
repo.AddBadge(badge);
Assert.IsTrue(repo.ShowAllBadges());
}
public void ListBadgesAndPokemonTest()
{
//Arrange
badgeRepo = new BadgeRepo();
//Act
//Assert
}
public void ShowBadgeTest_ShowsBadge()
{
BadgeRepo repo = new BadgeRepo();
Badges badge = new Badges(badgeID, doors);
repo.AddBadge(badge);
Assert.IsTrue(repo.ShowBadge(badgeID));
}
public void Arrange()
{
badgeRepo = new BadgeRepo();
badge = new Badge(1000, new List <string> {
"A7"
});
badgeRepo.AddBadge(badge);
}
public void Arrange()
{
_repo = new BadgeRepo();
_badge = new Badge(12345, new List <string> {
"A7"
});
_repo.AddBadge(_badge.BadgeID, _badge);
}
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 AddClaim()
{
BadgeProp claim = new BadgeProp();
BadgeRepo repoDirectory = new BadgeRepo();
bool addResult = repoDirectory.AddNewBadge(claim);
Assert.IsTrue(addResult);
}
public void CreateNewBadge()
{
Badge badgeID = new Badge();
BadgeRepo repository = new BadgeRepo();
bool addResult = repository.AddNewBadgeToDictionary(badgeID);
Assert.IsTrue(addResult);
}
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 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 DeleteAllDoorsTest_RemovesAllDoors()
{
BadgeRepo repo = new BadgeRepo();
Badges badge = new Badges(badgeID, doors);
repo.AddBadge(badge);
Assert.IsTrue(repo.DeleteAllDoors(badgeID));
repo.ShowAllBadges();
}
public void Arrange()
{
_repo = new BadgeRepo();
_badge = new Badge(22345, new List <string> {
"A1", "A4", "B1", "B2"
});
_repo.AddNewBadge(_badge);
}
public void Arrange()
{
_repo = new BadgeRepo();
_content = new Badge(27384, new List <string> {
"A2,", "B5,", "c4"
});
_repo.AddBadgeToDictionary(_content.BadgeID, _content);
}
