public ActionResult Edit(int id)
{
ViewBag.PageName = "Edit";
var badge = _badgeRepository.Get(id);
if (badge == null)
{
throw new HttpException((int)System.Net.HttpStatusCode.NotFound, $"badge with id {id} Not Found");
}
var badgeViewModel = Mapper.Map <Badge, BadgeEditViewModel>(badge);
return(View(badgeViewModel));
}
/// <summary>
/// Processes the user for the specified badge type
/// </summary>
/// <param name="badgeType"></param>
/// <param name="user"></param>
/// <returns>True if badge was awarded</returns>
public bool ProcessBadge(BadgeType badgeType, MembershipUser user)
{
var databaseUpdateNeeded = false;
var e = new BadgeEventArgs {
User = user, BadgeType = badgeType
};
EventManager.Instance.FireBeforeBadgeAwarded(this, e);
if (!e.Cancel)
{
if (_badges.ContainsKey(badgeType))
{
if (!RecentlyProcessed(badgeType, user))
{
databaseUpdateNeeded = true;
var badgeSet = _badges[badgeType];
foreach (var badgeMapping in badgeSet)
{
if (!BadgeCanBeAwarded(user, badgeMapping))
{
continue;
}
// Instantiate the badge and execute the rule
var badge = GetInstance <IBadge>(badgeMapping);
// Award badge?
if (badge != null && badge.Rule(user))
{
// Re-fetch the badge otherwise system will try and create new badges!
var dbBadge = _badgeRepository.Get(badgeMapping.DbBadge.Id);
if (dbBadge.AwardsPoints != null && dbBadge.AwardsPoints > 0)
{
var points = new MembershipUserPoints
{
DateAdded = DateTime.UtcNow,
Points = (int)dbBadge.AwardsPoints
};
user.Points.Add(points);
}
user.Badges.Add(dbBadge);
_activityService.BadgeAwarded(badgeMapping.DbBadge, user, DateTime.UtcNow);
EventManager.Instance.FireAfterBadgeAwarded(this,
new BadgeEventArgs
{
User = user,
BadgeType = badgeType
});
}
}
}
}
}
return(databaseUpdateNeeded);
}
public void AnniversaryTimeAwardBadge()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_api.Topic = Substitute.For <ITopicAPI>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
var now = DateTime.UtcNow;
var user = new MembershipUser
{
CreateDate = new DateTime(now.Year - 1, now.Month, now.Day),
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "MemberForAYear"
});
_badgeService.ProcessBadge(BadgeType.Time, user);
Assert.IsTrue(user.Badges.Count == 1);
Assert.IsTrue(user.Badges[0].Name == "MemberForAYear");
}
public void UserAlreadyHasBadge()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one vote no badges
var user = new MembershipUser
{
Votes = new List <Vote>
{
new Vote {
Id = Guid.NewGuid()
}
},
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
// Call twice but only one badge awarded
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "testbadge"
});
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 1);
}
public void UserVoteUpAwardBadge2()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with two votes no badges - will create a badge because no previous badge
var user = new MembershipUser
{
Votes = new List <Vote>
{
new Vote {
Id = Guid.NewGuid()
},
new Vote {
Id = Guid.NewGuid()
}
},
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "UserVoteUp"
});
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 1);
Assert.IsTrue(user.Badges[0].Name == "UserVoteUp");
}
public void BadgeAwardedActivityGet()
{
const string guidStr = "515b7240-3be1-43d4-8846-c0b589cd1cd2";
const string guidStrUser = "******";
var timestamp = DateTime.UtcNow;
var activityRepository = Substitute.For <IActivityRepository>();
var badgeActivitiesInDb = new List <Activity>
{
new Activity
{
Type = ActivityType.BadgeAwarded.ToString(),
Timestamp = timestamp,
Data = BadgeActivity.KeyBadgeId + "=" + guidStr + "," + BadgeActivity.KeyUserId + "=" + guidStrUser
}
};
var pagedBadgeActivities = new PagedList <Activity>(badgeActivitiesInDb, 1, 20, 1);
activityRepository.GetPagedGroupedActivities(1, 20).Returns(pagedBadgeActivities);
_badgeRepository.Get(new Guid(guidStr)).Returns(new Badge());
_membershipRepository.Get(new Guid(guidStrUser)).Returns(new MembershipUser());
IActivityService activityService = new ActivityService(activityRepository, _badgeRepository, _membershipRepository, _loggingService);
var badgeActivities = activityService.GetPagedGroupedActivities(1, 20);
Assert.IsTrue(badgeActivities[0] is BadgeActivity);
}
public void UserVoteUpAwardBadgeTwoUsers()
{
// Useful for testing badge service internal badge class instance cache is called
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one vote no badges, set time checking offset to be safe so badge will be processed
var user1 = new MembershipUser
{
Votes = new List <Vote>
{
new Vote {
Id = Guid.NewGuid()
}
},
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
// Create a user with one vote no badges, set time checking offset to be safe so badge will be processed
var user2 = new MembershipUser
{
Votes = new List <Vote>
{
new Vote {
Id = Guid.NewGuid()
}
},
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "UserVoteUp"
});
_badgeService.ProcessBadge(BadgeType.VoteUp, user1);
_badgeService.ProcessBadge(BadgeType.VoteUp, user2);
Assert.IsTrue(user1.Badges.Count == 1);
Assert.IsTrue(user1.Badges[0].Name == "UserVoteUp");
Assert.IsTrue(user2.Badges.Count == 1);
Assert.IsTrue(user2.Badges[0].Name == "UserVoteUp");
}
public void MarkAsSolutionAwardTwoBadges()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_api.Topic = Substitute.For <ITopicAPI>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one topic marked as solved
var id = Guid.NewGuid();
var user = new MembershipUser
{
Id = id,
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
var listPostsForMember = new List <Post> {
new Post
{
User = new MembershipUser
{
Id = user.Id,
Badges = new List <Badge>()
},
},
};
var listTopicsForMember = new List <Topic>
{
new Topic
{
Solved = true,
User = new MembershipUser
{
Id = user.Id,
Badges = new List <Badge>()
},
},
};
_api.Topic.GetSolvedTopicsByMember(id).Returns(listTopicsForMember);
_api.Post.GetSolutionsWrittenByMember(id).Returns(listPostsForMember);
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "testbadge"
});
_badgeService.ProcessBadge(BadgeType.MarkAsSolution, user);
Assert.IsTrue(user.Badges.Count == 2);
}
public ActionResult CoffeeMachine(string idBadge)
{
List <DrinkTypeDto> drinkTypesList = _drinkTypesRepository.Get();
CoffeeMachineViewModel model = new CoffeeMachineViewModel();
model.DrinkTypesList = new SelectList(drinkTypesList.OrderBy(x => x.Id), "Id", "Label", null, 1, null);
if (!string.IsNullOrEmpty(idBadge))
{
BadgeDto badge = _badgeRepository.Get(idBadge);
model.SugarQuantity = badge.Drink.Sugar.Quantity;
model.IsOwerMug = badge.IsOwerMug;
model.DrinkType = badge.Drink.Type.Id;
}
return(View(model));
}
public void PosterVoteUpRefuseBadge_TooSoon_ThenAward()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one post with one vote
var post = new Post
{
Id = Guid.NewGuid(),
Votes = new List <Vote> {
new Vote {
Id = Guid.NewGuid()
}
},
};
var user = new MembershipUser
{
Posts = new List <Post> {
post
},
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeDisAllowsBadgeUpdate()
}
}
};
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 0);
user.BadgeTypesTimeLastChecked[0].TimeLastChecked = GetTimeAllowsBadgeUpdate();
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "testbadge"
});
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 2);
}
/// <summary>
/// Make a badge activity object from the more generic database activity object
/// </summary>
/// <param name="activity"></param>
/// <returns></returns>
private BadgeActivity GenerateBadgeActivity(Activity activity)
{
// Get the corresponding badge
var dataPairs = ActivityBase.UnpackData(activity);
if (!dataPairs.ContainsKey(BadgeActivity.KeyBadgeId))
{
// Log the problem then skip
_loggingService.Error(string.Format("A badge activity record with id '{0}' has no badge id in its data.", activity.Id.ToString()));
return(null);
}
var badgeId = dataPairs[BadgeActivity.KeyBadgeId];
var badge = _badgeRepository.Get(new Guid(badgeId));
if (badge == null)
{
// Log the problem then skip
_loggingService.Error(string.Format("A badge activity record with id '{0}' has a badge id '{1}' that is not found in the badge table.",
activity.Id.ToString(), badgeId));
return(null);
}
var userId = dataPairs[BadgeActivity.KeyUserId];
var user = _membershipRepository.Get(Convert.ToInt32(userId));
if (user == null)
{
// Log the problem then skip
_loggingService.Error(string.Format("A badge activity record with id '{0}' has a user id '{1}' that is not found in the user table.",
activity.Id, userId));
return(null);
}
return(new BadgeActivity(activity, badge, user));
}
public void UserAlreadyHasBadge()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one vote no badges
var user = new MembershipUser
{
Votes = new List<Vote>
{
new Vote { Id = Guid.NewGuid() }
},
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
// Call twice but only one badge awarded
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "testbadge" });
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 1);
}
public void AnniversaryTimeAwardBadge()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_api.Topic = Substitute.For<ITopicAPI>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
var now = DateTime.UtcNow;
var user = new MembershipUser
{
CreateDate = new DateTime(now.Year - 1, now.Month, now.Day),
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "MemberForAYear" });
_badgeService.ProcessBadge(BadgeType.Time, user);
Assert.IsTrue(user.Badges.Count == 1);
Assert.IsTrue(user.Badges[0].Name == "MemberForAYear");
}
public void MarkAsSolutionAwardTwoBadges()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_api.Topic = Substitute.For<ITopicAPI>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one topic marked as solved
var id = Guid.NewGuid();
var user = new MembershipUser
{
Id = id,
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
var listPostsForMember = new List<Post> {
new Post
{
User = new MembershipUser
{
Id = user.Id,
Badges = new List<Badge>()
},
},
};
var listTopicsForMember = new List<Topic>
{
new Topic
{
Solved = true,
User = new MembershipUser
{
Id = user.Id,
Badges = new List<Badge>()
},
},
};
_api.Topic.GetSolvedTopicsByMember(id).Returns(listTopicsForMember);
_api.Post.GetSolutionsWrittenByMember(id).Returns(listPostsForMember);
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "testbadge" });
_badgeService.ProcessBadge(BadgeType.MarkAsSolution, user);
Assert.IsTrue(user.Badges.Count == 2);
}
public void VoteUpAwardOneBadgeOutOfTwo()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one post with one vote, and no badge, and one post with no votes
var user = new MembershipUser
{
Posts = new List<Post> {
new Post{
Id = Guid.NewGuid(),
Votes = new List<Vote> { new Vote { Id = Guid.NewGuid() } },
}
},
Badges = new List<Badge>(),
Votes = new List<Vote>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "testbadge" });
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 2);
}
public void VoteUpAwardTwoBadges()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one post with one vote, and no badge, and one post with one vote
var post = new Post
{
Id = Guid.NewGuid(),
Votes = new List<Vote> { new Vote { Id = Guid.NewGuid() } },
};
var user = new MembershipUser
{
Posts = new List<Post> { post },
Badges = new List<Badge>(),
Votes = new List<Vote>
{
new Vote { Id = Guid.NewGuid() }
},
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "testbadge" });
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 3);
// These tests can no longer work as we now fetch back the db badge records using a substitute
//var foundPosterVoteUp = false;
//var foundUserVoteUp = false;
//foreach (var badge in user.Badges)
//{
// if (badge.Name == "PosterVoteUp" || badge.Name == NameTestVoteUp)
// {
// foundPosterVoteUp = true;
// }
// else if (badge.Name == "UserVoteUp")
// {
// foundUserVoteUp = true;
// }
//}
//Assert.IsTrue(foundPosterVoteUp);
//Assert.IsTrue(foundUserVoteUp);
}
public void UserVoteUpAwardBadge2()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with two votes no badges - will create a badge because no previous badge
var user = new MembershipUser
{
Votes = new List<Vote>
{
new Vote { Id = Guid.NewGuid() },
new Vote { Id = Guid.NewGuid() }
},
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "UserVoteUp" });
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 1);
Assert.IsTrue(user.Badges[0].Name == "UserVoteUp");
}
public void UserVoteUpAwardBadgeTwoUsers()
{
// Useful for testing badge service internal badge class instance cache is called
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one vote no badges, set time checking offset to be safe so badge will be processed
var user1 = new MembershipUser
{
Votes = new List<Vote>
{
new Vote { Id = Guid.NewGuid() }
},
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
// Create a user with one vote no badges, set time checking offset to be safe so badge will be processed
var user2 = new MembershipUser
{
Votes = new List<Vote>
{
new Vote { Id = Guid.NewGuid() }
},
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "UserVoteUp" });
_badgeService.ProcessBadge(BadgeType.VoteUp, user1);
_badgeService.ProcessBadge(BadgeType.VoteUp, user2);
Assert.IsTrue(user1.Badges.Count == 1);
Assert.IsTrue(user1.Badges[0].Name == "UserVoteUp");
Assert.IsTrue(user2.Badges.Count == 1);
Assert.IsTrue(user2.Badges[0].Name == "UserVoteUp");
}
public Badge Get(long id)
{
return(Repo.Get(id));
}
/// <summary>
/// Processes the user for the specified badge type
/// </summary>
/// <param name="badgeType"></param>
/// <param name="user"></param>
/// <returns>True if badge was awarded</returns>
public bool ProcessBadge(BadgeType badgeType, MembershipUser user)
{
var databaseUpdateNeeded = false;
var e = new BadgeEventArgs {
User = user, BadgeType = badgeType
};
EventManager.Instance.FireBeforeBadgeAwarded(this, e);
if (!e.Cancel)
{
if (_badges.ContainsKey(badgeType))
{
if (!RecentlyProcessed(badgeType, user))
{
databaseUpdateNeeded = true;
var badgeSet = _badges[badgeType];
foreach (var badgeMapping in badgeSet)
{
if (!BadgeCanBeAwarded(user, badgeMapping))
{
continue;
}
// Instantiate the badge and execute the rule
var badge = GetInstance <IBadge>(badgeMapping);
if (badge != null)
{
var dbBadge = _badgeRepository.Get(badgeMapping.DbBadge.Id);
// Award badge?
if (badge.Rule(user))
{
// Re-fetch the badge otherwise system will try and create new badges!
if (dbBadge.AwardsPoints != null && dbBadge.AwardsPoints > 0)
{
var points = new MembershipUserPoints
{
Points = (int)dbBadge.AwardsPoints,
PointsFor = PointsFor.Badge,
PointsForId = dbBadge.Id,
User = user
};
_membershipUserPointsService.Add(points);
}
user.Badges.Add(dbBadge);
_activityService.BadgeAwarded(badgeMapping.DbBadge, user, DateTime.UtcNow);
EventManager.Instance.FireAfterBadgeAwarded(this,
new BadgeEventArgs
{
User = user,
BadgeType = badgeType
});
}
//else
//{
// // If we get here the user should not have the badge
// // Remove the badge if the user no longer has the criteria to be awarded it
// // and also remove any points associated with it.
// user.Badges.Remove(dbBadge);
// _membershipUserPointsService.Delete(user, PointsFor.Badge, dbBadge.Id);
//}
}
}
}
}
}
return(databaseUpdateNeeded);
}
public void VoteUpAwardTwoBadges()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one post with one vote, and no badge, and one post with one vote
var post = new Post
{
Id = Guid.NewGuid(),
Votes = new List <Vote> {
new Vote {
Id = Guid.NewGuid()
}
},
};
var user = new MembershipUser
{
Posts = new List <Post> {
post
},
Badges = new List <Badge>(),
Votes = new List <Vote>
{
new Vote {
Id = Guid.NewGuid()
}
},
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "testbadge"
});
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 3);
// These tests can no longer work as we now fetch back the db badge records using a substitute
//var foundPosterVoteUp = false;
//var foundUserVoteUp = false;
//foreach (var badge in user.Badges)
//{
// if (badge.Name == "PosterVoteUp" || badge.Name == NameTestVoteUp)
// {
// foundPosterVoteUp = true;
// }
// else if (badge.Name == "UserVoteUp")
// {
// foundUserVoteUp = true;
// }
//}
//Assert.IsTrue(foundPosterVoteUp);
//Assert.IsTrue(foundUserVoteUp);
}
