public void Test_Gets()
{
List <CMSGroup> records = new List <CMSGroup>();
CMSGroupManager manager = new CMSGroupManager(this.DataStore);
CMSGroupType groupType = DebugUtility.GetRandomEnum <CMSGroupType>(this.Random);
for (int i = 0; i < 10; i++)
{
records.Add(Create(this.DataStore, this.Random));
}
foreach (CMSGroup record in records)
{
record.CMSGroupType = groupType;
manager.Update(record);
}
List <CMSGroup> dsRecords = manager.GetAllGroups(groupType);
Assert.GreaterOrEqual(dsRecords.Count, records.Count);
foreach (CMSGroup record in records)
{
Assert.AreEqual(1, dsRecords.Count(c => c.CMSGroupId == record.CMSGroupId));
}
Assert.AreEqual(0, dsRecords.Count(c => c.CMSGroupType != groupType));
foreach (CMSGroup record in records)
{
Delete(this.DataStore, record);
}
}
internal static CMSSection Create(IDataStore dataStore, IApplicationSettings applicationSettings, IApplication application, CMSGroup group, Random random)
{
CMSSectionManager manager = new CMSSectionManager(dataStore);
CMSSectionType sectionType = DebugUtility.GetRandomEnum <CMSSectionType>(random);
CMSSection section = new CMSSection(
application.ApplicationId
, "TestSection " + random.Next(1000000, 10000000)
, true
, false
, sectionType);
if (group != null)
{
section.CMSGroupId = group.CMSGroupId;
}
BusinessObjectActionReport <DataRepositoryActionStatus> report = manager.Create(section);
Assert.AreEqual(DataRepositoryActionStatus.Success, report.Status);
Assert.Greater(section.CMSSectionId, 0);
CMSSection dsSection = manager.GetSection(sectionType, section.CMSSectionId);
Assert.IsNotNull(dsSection);
if (group != null)
{
Assert.AreEqual(section.CMSGroupId, group.CMSGroupId);
}
return(dsSection);
}
public void Test_Gets()
{
List <CMSSection> records = new List <CMSSection>();
CMSSectionManager manager = new CMSSectionManager(this.DataStore);
CMSSectionType sectionType = DebugUtility.GetRandomEnum <CMSSectionType>(this.Random);
for (int i = 0; i < 10; i++)
{
records.Add(Create(this.DataStore, Workmate.Components.InstanceContainer.ApplicationSettings, this.Application, null, this.Random));
}
foreach (CMSSection record in records)
{
record.CMSSectionType = sectionType;
manager.Update(record);
}
List <CMSSection> dsRecords = manager.GetAllSections(this.Application.ApplicationId, sectionType).ToList();
Assert.GreaterOrEqual(dsRecords.Count, records.Count);
foreach (CMSSection record in records)
{
Assert.AreEqual(1, dsRecords.Count(c => c.CMSSectionId == record.CMSSectionId));
}
Assert.AreEqual(0, dsRecords.Count(c => c.CMSSectionType != sectionType));
foreach (CMSSection record in records)
{
Delete(this.DataStore, record);
}
}
internal static Message Create(IDataStore dataStore, IApplicationSettings applicationSettings, IApplication application
, IUserBasic author, MessageBoardThread messageBoardThread, Random random)
{
MessageManager manager = new MessageManager(dataStore);
Message message = new Message(
author
, messageBoardThread
, "Message Subject" + random.Next(1000000, 10000000)
, "Message Body" + random.Next(1000000, 10000000));
message.MessageStatus = DebugUtility.GetRandomEnum <MessageStatus>(random);
BusinessObjectActionReport <DataRepositoryActionStatus> report = manager.Create(message);
Assert.AreEqual(DataRepositoryActionStatus.Success, report.Status);
Assert.Greater(message.MessageId, 0);
Message dsMessage = manager.GetMessage(message.MessageId);
Assert.IsNotNull(dsMessage);
return(dsMessage);
}
internal static void PopulateWithRandomValues(CMSSection record, DummyDataManager dtm, Random random)
{
record.Name = "TestSection " + random.Next(1000000, 10000000);
record.Description = "Description " + random.Next(1000000, 10000000);
record.CMSSectionType = DebugUtility.GetRandomEnum <CMSSectionType>(random);
record.IsActive = DebugUtility.FlipCoin(random);
record.IsModerated = DebugUtility.FlipCoin(random);
}
internal static void PopulateWithRandomValues(Message record, DummyDataManager dtm, Random random)
{
record.MessageStatus = DebugUtility.GetRandomEnum <MessageStatus>(random);
record.FormattedBody = "Message Body" + random.Next(1000000, 10000000);
record.IsApproved = DebugUtility.FlipCoin(random);
record.IsLocked = DebugUtility.FlipCoin(random);
record.Subject = "Message Status" + random.Next(1000000, 10000000);
record.UrlFriendlyName = record.Subject;
}
public void Test_CreateUpdateDelete()
{
IUserBasic userBasic = Test_WorkmateMembershipProvider.CreateUser(this.DataStore, Workmate.Components.InstanceContainer.ApplicationSettings, this.Application, this.DummyDataManager);
MessageBoard messageBoard = Test_MessageBoards.Create(this.DataStore, Workmate.Components.InstanceContainer.ApplicationSettings, this.Application, this.Random);
MessageBoardThread messageBoardThread = Test_MessageBoardThreads.Create(this.DataStore, Workmate.Components.InstanceContainer.ApplicationSettings, this.Application, messageBoard, this.Random);
Message message = Test_Messages.Create(this.DataStore, Workmate.Components.InstanceContainer.ApplicationSettings, this.Application, userBasic, messageBoardThread, this.Random);
MessageRatingManager messageRatingManager = new MessageRatingManager(this.DataStore);
BaseRatingInfo baseRatingInfo;
int totalThumbsUp = 0;
for (int i = 0; i < 10; i++)
{
userBasic = Test_WorkmateMembershipProvider.CreateUser(this.DataStore, Workmate.Components.InstanceContainer.ApplicationSettings, this.Application, this.DummyDataManager);
MessageRating record = new MessageRating(userBasic, message, DebugUtility.GetRandomEnum <MessageRatingType>(this.Random));
BusinessObjectActionReport <RatingDataRepositoryActionStatus> report = messageRatingManager.Create(record, out baseRatingInfo);
Assert.AreEqual(RatingDataRepositoryActionStatus.Success, report.Status);
totalThumbsUp += (short)record.MessageRatingType;
Assert.AreEqual(totalThumbsUp, baseRatingInfo.GetTotalThumbsUp());
Assert.AreEqual(i + 1 - totalThumbsUp, baseRatingInfo.GetTotalThumbsDown());
record = new MessageRating(userBasic, message, DebugUtility.GetRandomEnum <MessageRatingType>(this.Random, record.MessageRatingType));
messageRatingManager.CreateOrUpdateExisting(record, out baseRatingInfo);
Assert.AreEqual(RatingDataRepositoryActionStatus.Success, report.Status);
totalThumbsUp += record.MessageRatingType == MessageRatingType.ThumbsUp ? 1 : -1;
Assert.AreEqual(totalThumbsUp, baseRatingInfo.GetTotalThumbsUp());
Assert.AreEqual(i + 1 - totalThumbsUp, baseRatingInfo.GetTotalThumbsDown());
}
Test_MessageBoardThreads.Delete(this.DataStore, messageBoardThread);
MessageBoardThreadManager messageBoardThreadManager = new MessageBoardThreadManager(this.DataStore);
MessageManager messageManager = new MessageManager(this.DataStore);
Assert.IsNull(messageBoardThreadManager.GetMessageBoardThread(messageBoardThread.MessageBoardThreadId));
Assert.IsNull(messageManager.GetMessage(message.MessageId));
Assert.IsEmpty(messageRatingManager.GetAllRatingsForMessage(message));
Test_MessageBoards.Delete(this.DataStore, messageBoard);
}
internal static Article Create(IDataStore dataStore, IApplicationSettings applicationSettings, IApplication application
, IUserBasic author, ArticleGroupThread articleGroupThread
, MessageBoard messageBoard
, Random random)
{
ArticleManager manager = new ArticleManager(dataStore);
Article article = new Article(
author
, articleGroupThread
, DebugUtility.GetRandomEnum <ArticleStatus>(random)
, DebugUtility.GetRandomEnum <ArticleType>(random)
, "Article Subject" + random.Next(1000000, 10000000)
, "Article Body" + random.Next(1000000, 10000000)
, "URLName" + random.Next(1000000, 10000000)
, DebugUtility.FlipCoin(random));
int count = random.Next(0, 10);
for (int i = 0; i < count; i++)
{
article.ContentLevelNodeNames.Add("Category " + i + (DebugUtility.FlipRiggedCoin(random, .2) ? " " + random.Next(10000, 100000) : string.Empty));
}
BusinessObjectActionReport <DataRepositoryActionStatus> report = manager.Create(article, messageBoard.MessageBoardId, DebugUtility.FlipCoin(random));
Assert.AreEqual(DataRepositoryActionStatus.Success, report.Status);
Assert.Greater(article.ArticleId, 0);
Article dsArticle = manager.GetArticle(article.ArticleId);
Assert.IsNotNull(dsArticle);
IArticleModel articelModel = manager.GetArticleModel(dsArticle.ArticleId);
Assert.AreEqual(article.ContentLevelNodeNames.Count, articelModel.ContentLevelNodes.Count);
for (int i = 0; i < article.ContentLevelNodeNames.Count; i++)
{
Assert.AreEqual(article.ContentLevelNodeNames[i], articelModel.ContentLevelNodes[i]);
}
return(dsArticle);
}
public void Test_CreateUser()
{
IApplicationSettings applicationSettings = Workmate.Components.InstanceContainer.ApplicationSettings;
WorkmateRoleProvider roleProvider = new WorkmateRoleProvider();
WorkmateMembershipProvider membershipProvider = new WorkmateMembershipProvider();
DummyUser user = this.DummyDataManager.GetDummy();
string firstName = user.Firstname;
string lastName = user.Surname;
string password = "******";
AccountStatus accountStatus = AccountStatus.Valid;
TimeZoneInfo timeZoneInfo = TimeZoneUtility.GetGMTStandardTimeZone();
IUserBasic userBasic = new UserBasic(user.Email, user.Email, 1)
{
AccountStatus = accountStatus,
TimeZoneInfo = timeZoneInfo
};
Guid uniqueId;
List <UserRole> userRoles = new List <UserRole>()
{
UserRole.SystemAdministrator, UserRole.Registered
};
UserCreateStatus userCreateStatus = membershipProvider.CreateUser(ref userBasic, password, userRoles, UserNameDisplayMode.FullName
, firstName, lastName
, DebugUtility.GetRandomEnum <Workmate.Components.Contracts.Membership.Gender>(this.Random)
, out uniqueId, this.Application.ApplicationId).Status;
Assert.AreEqual(UserCreateStatus.Success, userCreateStatus);
Assert.Greater(userBasic.UserId, 0);
userBasic = membershipProvider.GetUserBasic(userBasic.UserId, false);
Assert.AreEqual(user.Email, userBasic.UserName);
Assert.AreEqual(user.Email, userBasic.Email);
Assert.AreEqual(accountStatus, userBasic.AccountStatus);
Assert.AreEqual(timeZoneInfo.Id, userBasic.TimeZoneInfoId);
}
internal static PrivateMessage Create(IDataStore dataStore, IApplicationSettings applicationSettings, IApplication application
, IUserBasic author, Folder folder, Random random)
{
PrivateMessageManager manager = new PrivateMessageManager(dataStore);
PrivateMessage privateMessage = new PrivateMessage(
author
, folder
, DebugUtility.GetRandomEnum <MessageStatus>(random)
, DebugUtility.GetRandomEnum <MessageType>(random)
, "PrivateMessage Subject" + random.Next(1000000, 10000000)
, "PrivateMessage Body" + random.Next(1000000, 10000000));
BusinessObjectActionReport <DataRepositoryActionStatus> report = manager.Create(privateMessage);
Assert.AreEqual(DataRepositoryActionStatus.Success, report.Status);
Assert.Greater(privateMessage.PrivateMessageId, 0);
PrivateMessage dsPrivateMessage = manager.GetPrivateMessage(privateMessage.PrivateMessageId);
Assert.IsNotNull(dsPrivateMessage);
return(dsPrivateMessage);
}
internal IEmail Create(IDataStore dataStore, Random random, IApplication application, IUserBasic user)
{
return(Create(dataStore, random, application, user, DebugUtility.GetRandomEnum <EmailPriority>(random)
, DebugUtility.GetRandomEnum <EmailStatus>(random)));
}
internal static void PopulateWithRandomValues(CMSGroup record, DummyDataManager dtm, Random random)
{
record.Name = "TestGroup " + random.Next(1000000, 10000000);
record.Description = "Description " + random.Next(1000000, 10000000);
record.CMSGroupType = DebugUtility.GetRandomEnum <CMSGroupType>(random);
}
internal CMSGroup Create(IDataStore dataStore, Random random)
{
CMSGroupManager manager = new CMSGroupManager(dataStore);
int groupId = random.Next(int.MinValue + 1, -100000);
CMSGroup group = new CMSGroup(groupId, "TestGroup " + random.Next(1000000, 10000000), "Description " + random.Next(1000000, 10000000), DebugUtility.GetRandomEnum <CMSGroupType>(random));
BusinessObjectActionReport <DataRepositoryActionStatus> report = manager.Create(group);
Assert.AreEqual(DataRepositoryActionStatus.Success, report.Status);
CMSGroup dsGroup = manager.GetGroup(groupId);
Assert.IsNotNull(dsGroup);
return(dsGroup);
}
