public void Arrange()
{
_badgeRepo = new BadgeRepository();
_badgeRepo.AddBadge(12345, new List <string> {
"A7"
});
}
public void Arrange()
{
_badge = new Badge(22, new List <string> {
"C3", "P0"
});
_badgeRepo = new BadgeRepository();
}
public async Task <ActionResult> Badges()
{
var badgeRepository = new BadgeRepository();
var badge = await badgeRepository.GetBadge(User.Identity.Name);
if (badge == null)
{
var userProfileRepo = new UserProfileRepository();
var user = await userProfileRepo.GetUserProfile(User.Identity.Name);
var code = user.Id.ToString().Substring(user.Id.ToString().Length - 6, 6);
badge = new Badge
{
User = User.Identity.Name,
Code = code,
IsAddressVerified = false,
IsDriversLicenseVerified = false,
IsPhoneVerified = false,
IsVehicleVerified = false
};
var badgeRepo = new BadgeRepository();
await badgeRepo.CreateSync(badge);
}
return(View(badge));
}
public void Arrange()
{
_badgeRepository = new BadgeRepository();
_badge = new Badge(100, new List <string> {
"A1", "A2", "A3"
});
}
public void TestAddBadgeToDictionary()
{
//Arrange
Badge badgeItems = new Badge();
BadgeRepository badgeRepo = new BadgeRepository();
badgeItems.BadgeID = 12345;
string doorInput = "A6";
badgeItems.Doors.Add(doorInput);
//Act
badgeRepo.AddBadgeToDictionary(badgeItems.BadgeID, badgeItems.Doors);
//Assert
Dictionary <int, List <string> > dictionary = badgeRepo.ShowBadgesAndAccess();
bool IsEqual = false;
foreach (KeyValuePair <int, List <string> > pair in dictionary)
{
if (pair.Key == badgeItems.BadgeID && pair.Value == badgeItems.Doors)
{
IsEqual = true;
}
}
Assert.IsTrue(IsEqual);
}
public async Task <bool> Register(UserProfile userprofile)
{
try
{
var userProfileRepo = new UserProfileRepository();
await userProfileRepo.CreateSync(userprofile);
var userId = userprofile.Id.ToString();
if (!string.IsNullOrEmpty(userId))
{
var code = userId.Substring(userId.Length - 6, 6);
var badge = new Badge
{
User = userprofile.Username,
Code = code,
IsAddressVerified = false,
IsDriversLicenseVerified = false,
IsPhoneVerified = false,
IsVehicleVerified = false
};
var badgeRepo = new BadgeRepository();
await badgeRepo.CreateSync(badge);
return(true);
}
return(false);
}
catch (Exception ex)
{
return(false);
}
}
public void UpdateMethodTestShouldGetTrue()
{
//Arrange
Badge badge = new Badge();
badge.DoorNames.Add("D4");
badge.DoorNames.Add("stupid");
badge.BadgeNumber = 3;
BadgeRepository repository = new BadgeRepository();
repository.AddBadgeToDictionary(3, badge);
Badge newBadge = new Badge();
newBadge.DoorNames.Add("hello");
newBadge.DoorNames.Add("IKEA");
newBadge.BadgeNumber = 1000;
//Act
bool updateResult = repository.UpdateBadge(3, newBadge);
//Assert
Assert.IsTrue(updateResult);
}
public async Task<bool> Register(UserProfile userprofile)
{
try
{
var userProfileRepo = new UserProfileRepository();
await userProfileRepo.CreateSync(userprofile);
var userId = userprofile.Id.ToString();
if (!string.IsNullOrEmpty(userId))
{
var code = userId.Substring(userId.Length - 6, 6);
var badge = new Badge
{
User = userprofile.Username,
Code = code,
IsAddressVerified = false,
IsDriversLicenseVerified = false,
IsPhoneVerified = false,
IsVehicleVerified = false
};
var badgeRepo = new BadgeRepository();
await badgeRepo.CreateSync(badge);
return true;
}
return false;
}
catch(Exception ex)
{
return false;
}
}
public void AddBadgeToDictionaryTest()
{
{
BadgeRepository _badgeRepo = new BadgeRepository();
List <string> _doorList = new List <string>();
Dictionary <int, List <string> > _badgeDict = _badgeRepo.GetAllBadges();
_doorList.Add("B6");
Badge badge1 = new Badge(1, _doorList);
Badge badge2 = new Badge(2, _doorList);
Badge badge3 = new Badge(3, _doorList);
_badgeRepo.AddBadgeToDictionary(badge1);
_badgeRepo.AddBadgeToDictionary(badge2);
_badgeRepo.AddBadgeToDictionary(badge3);
var actual = _badgeDict.Keys.Count;
var expected = 3;
Assert.AreEqual(expected, actual);
}
}
public void Repo_CreateBadge_ShouldAddNewBadgeToDictionary()
{
//-- Arrange
BadgeRepository repo = new BadgeRepository();
string badgeID1 = "12345";
string badgeID2 = "22345";
var doors = new List <string>();
doors.Add("A1");
doors.Add("A5");
var badges = repo.GetBadges();
//-- Act
repo.CreateBadge(badgeID1, doors); // Tested method
repo.CreateBadge(badgeID2, doors); // Tested method
int actual = badges.Count;
int expected = 2;
//-- Assert
Assert.AreEqual(expected, actual);
}
public UnitOfWork(MakersOfDenmarkDbContext context)
{
_context = context;
Makerspaces = new MakerspaceRepository(context);
Badges = new BadgeRepository(context);
Events = new EventRepository(context);
Users = new UserRepository(context);
}
public void CreateANewBadge()
{
Badge badge = new Badge();
BadgeRepository repository = new BadgeRepository();
bool addResult = repository.CreateNewBadge(badge);
Assert.IsTrue(addResult);
}
public void Arrange()
{
_badgeRepo = new BadgeRepository();
_badge = new Badge(12345, new List <string> {
"A2", "A3", "B7"
});
_badgeRepo.AddBadgetoList(_badge);
}
public void GetDoor_ShouldReturnCorrectCollection()
{
_repo = new BadgeRepository(); // arrange
int badgenum = 35;
string doorlist = _repo.GetBadgeRooms(badgenum); // act
Assert.AreEqual("a1, c1", doorlist); // assert
}
public PersonController(ApplicationDbContext context, BadgeRepository badgeRepo,
PersonRepository personRepo, RecognitionRepository recognitionRepo)
{
_personRepository = personRepo;
_recognitionRepository = recognitionRepo;
_badgeRepository = badgeRepo;
_badgeRepository.SetAppContext(context);
}
public void Test_GetBadgeByID()
{
BadgeRepository br = new BadgeRepository();
Badge b1 = new Badge(123, "Cool Guy Badge.");
b1.doorNames.Add("A1");
br.Add(b1.badgeID, b1);
Assert.IsTrue(br._badges.ContainsKey(123));
}
public void Arrange()
{
_badgeRepo = new BadgeRepository();
_badge = new Badge(61, new List <string>()
{
"D2", "D4", "D6"
});
_badgeRepo.AddBadge(_badge);
}
public PersonController()
{
var dbContext = new ApplicationDbContext();
_personRepository = new PersonRepository(dbContext);
_recognitionRepository = new RecognitionRepository(dbContext);
_badgeRepository = new BadgeRepository();
_badgeRepository.SetAppContext(dbContext);
}
public void Arrange()
{
//Door one = new Door("one");
//Door two = new Door("two");
_badgeRepository = new BadgeRepository();
_badge = new Badge();
_badgeRepository.AddBadgeToDictionary(1, _badge);
//_badgeRepository
}
public void CheckIfBadgeExists()
{
BadgeRepository repository = new BadgeRepository();
Dictionary <int, List <Doors> > dictionary = repository.ReturnDictionary();
Badge newBadge = new Badge(101);
List <Doors> doors = new List <Doors>();
repository.AddBadgeToDictionary(newBadge);
Assert.IsTrue(repository.CheckIfBadgeExists(101));
}
public void GetDoorsByBadgeId()
{
BadgeRepository repository = new BadgeRepository();
Dictionary <int, List <Doors> > dictionary = repository.ReturnDictionary();
Badge newBadge = new Badge(101);
List <Doors> doors = new List <Doors>();
repository.AddBadgeToDictionary(newBadge);
Assert.IsTrue(doors.GetType() == repository.GetDoorsByBadgeId(101).GetType());
}
//Helper Functions
public void SetContent()
{
_testBadgeRepo = new BadgeRepository();
var badge1 = new Badge(1, new List <string> {
"A5", "A6", "A7"
});
_testBadgeRepo.AddContent(badge1.BadgeID, badge1);
}
public void Test_IsDoorValidTrue()
{
BadgeRepository br = new BadgeRepository();
Badge b1 = new Badge(123, "Cool Guy Badge.");
b1.doorNames.Add("A1");
br.Add(b1.badgeID, b1);
Assert.IsTrue(br.IsVaildBadgeID(123));
Assert.IsFalse(br.IsVaildBadgeID(456));
}
public void Test_EditAddDoor()
{
BadgeRepository br = new BadgeRepository();
Badge b1 = new Badge(123, "Cool Guy Badge.");
b1.doorNames.Add("A1");
br.Add(b1.badgeID, b1);
br.Edit(123, "B1", "add");
Assert.IsTrue(b1.doorNames.Count == 2);
}
public void Test_DeleteAllDoors()
{
BadgeRepository br = new BadgeRepository();
Badge b1 = new Badge(123, "Cool Guy Badge.");
b1.doorNames.Add("A1");
br.Add(b1.badgeID, b1);
br.DeleteAllDoors(123);
Assert.IsTrue(b1.doorNames.Count == 0);
}
public void AddBadgeToRepository()
{
BadgeRepository repository = new BadgeRepository();
Dictionary <int, List <Doors> > dictionary = repository.ReturnDictionary();
int x = dictionary.Count;
Badge newBadge = new Badge(101);
repository.AddBadgeToDictionary(newBadge);
Assert.AreEqual(x + 1, dictionary.Count);
}
public void GetBadgeCount_ShouldReturnCorrectCount()
{
//Arrange
_repo = new BadgeRepository(); // arrange
int badges = 2;
//ACT
int badgeCount = _repo.GetBadgeCount();
//Assert!
Assert.AreEqual(badges, badgeCount); // assert
}
public void SeeAllBadgesTest()
{
BadgeRepository testRepo = new BadgeRepository();
testRepo.AddBadge(12345, new List <string> {
"A7"
});
Dictionary <int, List <string> > testDict = testRepo.SeeAllBadges();
bool dictionaryHasBadges = testDict.ContainsKey(12345);
}
public void Arrange()
{
List <string> doors = new List <string>();
doors.Add("A12");
doors.Add("B7");
_badgeRepo = new BadgeRepository();
_badge = new Badge(35, doors);
_badgeIdAndDoors = new Dictionary <int, Badge>();
_badgeRepo.AddBadgeToDictionary(_badge);
}
public void Arrange()
{
_badgeRepository = new BadgeRepository();
List <string> doorNameOne = new List <string> ();
doorNameOne.Add("A1");
doorNameOne.Add("A2");
doorNameOne.Add("A3");
_badge = new Badge(12345, doorNameOne);
_badgeRepository.CreateNewBadge(12345, doorNameOne);
}
public void TestMethod1()
{
Badges badges = new Badges();
badges.BadgeID = "1,2,3,4,5";
BadgeRepository repo = new BadgeRepository();
repo.AddBadgesToList(badges);
List <Badges> localList = repo.RetrunList();
}
public async Task<ActionResult> Badges()
{
var badgeRepository = new BadgeRepository();
var badge = await badgeRepository.GetBadge(User.Identity.Name);
if (badge == null)
{
var userProfileRepo = new UserProfileRepository();
var user = await userProfileRepo.GetUserProfile(User.Identity.Name);
var code = user.Id.ToString().Substring(user.Id.ToString().Length - 6, 6);
badge = new Badge
{
User = User.Identity.Name,
Code = code,
IsAddressVerified = false,
IsDriversLicenseVerified = false,
IsPhoneVerified = false,
IsVehicleVerified = false
};
var badgeRepo = new BadgeRepository();
await badgeRepo.CreateSync(badge);
}
return View(badge);
}
public void BadgeRepository()
{
Mock<IDbSetFactory> factory = new Mock<IDbSetFactory>();
Mock<DbSet<Badge>> dbSet = new Mock<DbSet<Badge>>();
factory.Setup(m => m.CreateDbSet<Badge>()).Returns(dbSet.Object);
BadgeRepository repo = new BadgeRepository(factory.Object);
var badge = new Badge();
var sequence = new MockSequence();
dbSet.InSequence(sequence).Setup(e => e.Add(badge));
dbSet.InSequence(sequence).Setup(e => e.Find(badge.Id));
dbSet.InSequence(sequence).Setup(e => e.Find(badge.Id));
dbSet.InSequence(sequence).Setup(e => e.Find(badge.Id));
repo.Create(badge);
repo.Get(badge.Id);
repo.Update(badge);
repo.Delete(badge.Id);
}
public async Task<ActionResult> SubmitCodeBadge(string code)
{
try
{
var badgeRepo = new BadgeRepository();
var result = await badgeRepo.SubmitCode(code, User.Identity.Name);
if (result)
return Json(new { success = true, responseText = "Added." }, JsonRequestBehavior.AllowGet);
else
{
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
return Json(new { success = false, responseText = "Error processing action" }, JsonRequestBehavior.AllowGet);
}
}
catch (Exception ex)
{
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
return Json(new { success = false, responseText = ex.Message }, JsonRequestBehavior.AllowGet);
}
}
