public void GetScratchVersesFromASpecificPoemForASpecificUser()
{
IVerseRepository verseRepository = GetRepositoryWithEnrolledUnitOfWork();
AuthorityType authorityType = new LegendAuthorityType();
RegisterDataStoreObject(authorityType);
UserProfile profile1 = CreateUserProfile(authorityType);
RegisterDataStoreObject(profile1);
UserProfile profile2 = CreateUserProfile(authorityType);
RegisterDataStoreObject(profile2);
Poem poem = CreatePoem<ClassicalPoem>(profile1.Id);
RegisterDataStoreObject(poem);
VerseType verseType = new ScratchVerseType();
RegisterDataStoreObject(verseType);
int numberOfVersesWrittenForOneUser = Rand.Next(10, 20);
int numberOfVersesWrittenByAnotherUser = Rand.Next(10, 20);
DateTime date = DateTime.Now;
for (int i = 0; i < numberOfVersesWrittenForOneUser; i++)
{
Verse verse = new Verse
{
AuthorProfileId = profile1.Id,
FromIpAddress = "127.0.0.1",
LastEdit = DateTime.UtcNow,
Location = "Chisinau",
OrderNr = 1,
PoemId = poem.Id,
Text = Guid.NewGuid().ToString(),
VerseTypeId = verseType.Id,
WrittenAt = date - TimeSpan.FromDays(10)
};
RegisterDataStoreObject(verse);
}
for (int i = 0; i < numberOfVersesWrittenByAnotherUser; i++)
{
Verse verse = new Verse
{
AuthorProfileId = profile2.Id,
FromIpAddress = "127.0.0.1",
LastEdit = DateTime.UtcNow,
Location = "Chisinau",
OrderNr = 1,
PoemId = poem.Id,
Text = Guid.NewGuid().ToString(),
VerseTypeId = verseType.Id,
WrittenAt = date - TimeSpan.FromDays(10)
};
RegisterDataStoreObject(verse);
}
var versesForProfile1 = verseRepository.GetVersesFromPoemForUser(poem.Id, profile1.Id);
var versesForProfile2 = verseRepository.GetVersesFromPoemForUser(poem.Id, profile2.Id);
var allVerses = verseRepository.GetVersesFromPoem(poem.Id);
Assert.AreEqual(numberOfVersesWrittenForOneUser, versesForProfile1.Count());
Assert.AreEqual(numberOfVersesWrittenByAnotherUser, versesForProfile2.Count());
Assert.AreEqual(numberOfVersesWrittenByAnotherUser + numberOfVersesWrittenForOneUser, allVerses.Count());
}
protected override VerseData OnUpdateVerseFromPoem(Verse verse, string verseText, VerseEngineeringUser user)
{
if (verse.AuthorProfileId != user.UserId)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden) { Content = new StringContent("You are not allowed to update verse which wasn't written by you") });
}
verseService.UpdateVerseText(verse, verseText);
return Mapper.Map<VerseData>(verse);
}
protected override VerseData OnPostVerseForPoem(Poem poem, AddVerseModel verseModel, VerseEngineeringUser user)
{
Verse verse = new Verse
{
AuthorProfileId = user.UserId,
FromIpAddress = string.Empty,
LastEdit = DateTime.UtcNow,
WrittenAt = DateTime.UtcNow,
Location = string.Empty,
OrderNr = 0,
PoemId = poem.Id,
Text = verseModel.Text,
};
verseService.Insert<ScratchVerseType>(verse);
return Mapper.Map<VerseData>(verse);
}
public void EditVerseSuccessful()
{
const int PoemId = 123456;
const long AuthorProfileId = 123;
const long VerseId = 1001;
var requestUser = new VerseEngineeringUser(AuthorProfileId, "TestUser", "TestFacebookAccessToken");
var verseToEdit = new Verse
{
AuthorProfileId = AuthorProfileId,
Id = VerseId,
PoemId = PoemId,
Text = "Sample verse text",
VerseType = new ScratchVerseType()
};
verseService.Setup(service => service.GetById(VerseId)).Returns(verseToEdit);
verseService.Setup(service => service.UpdateVerseText(verseToEdit, "This is text to edit")).Callback(
(Verse verse, string text) => { verse.Text = text; });
var response = scratchPadVersesController.PutVerse(
VerseId, new UpdateVerseModel { Text = "This is text to edit" }, requestUser);
Assert.IsNotNull(response);
Assert.IsTrue(response.Id == VerseId);
Assert.IsTrue(response.PoemId == PoemId);
Assert.IsTrue(response.Text == "This is text to edit");
}
public void EditVerseFailedBecauseTheUserIsNotTheAuthor()
{
const int PoemId = 123456;
const long AuthorProfileId = 123;
const long VerseId = 1001;
var requestUser = new VerseEngineeringUser(AuthorProfileId, "TestUser", "TestFacebookAccessToken");
var verseToDelete = new Verse
{
AuthorProfileId = 321,
Id = VerseId,
PoemId = PoemId,
Text = "Sample verse text",
VerseType = new ScratchVerseType()
};
verseService.Setup(service => service.GetById(VerseId)).Returns(verseToDelete);
try
{
scratchPadVersesController.PutVerse(VerseId, new UpdateVerseModel { Text = "This is an edited verse" }, requestUser);
}
catch (HttpResponseException exception)
{
Assert.IsTrue(exception.Response.StatusCode == HttpStatusCode.Forbidden);
return;
}
Assert.Fail();
}
public void DeleteVerseSuccessful()
{
const int PoemId = 123456;
const long AuthorProfileId = 123;
const long VerseId = 1001;
var requestUser = new VerseEngineeringUser(AuthorProfileId, "TestUser", "TestFacebookAccessToken");
var verseToDelete = new Verse
{
AuthorProfileId = AuthorProfileId,
Id = VerseId,
PoemId = PoemId,
Text = "Sample verse text",
VerseType = new ScratchVerseType()
};
verseService.Setup(service => service.GetById(VerseId)).Returns(verseToDelete);
verseService.Setup(service => service.Delete<ScratchVerseType>(verseToDelete));
var response = scratchPadVersesController.DeleteVerseFromPoem(VerseId, requestUser);
Assert.IsNotNull(response);
Assert.IsTrue(response.Id == VerseId);
Assert.IsTrue(response.PoemId == PoemId);
Assert.IsTrue(response.Text == "Sample verse text");
}
protected override VerseData OnUpdateVerseFromPoem(Verse verse, string verseText, VerseEngineeringUser user)
{
throw new System.NotImplementedException();
}
private void UpdateGameMaster(Poem poem, Verse verse)
{
if (poem.CurrentGm != verse.AuthorProfileId)
{
poem.CurrentGm = verse.AuthorProfileId;
poemService.Update(poem);
}
}
public static bool AlreadyVoted(this UserProfile profile, Verse verse)
{
return verse.VerseVotes.Any(vote => vote.UserProfileId == profile.Id);
}
public void GetVersesWrittenEarlierFromDate()
{
IVerseRepository verseRepository = GetRepositoryWithEnrolledUnitOfWork();
var prepared = PreparePoem<NoviceAuthorityType, HaikuPoem>();
VerseType verseType = new CandidateVerseType();
RegisterDataStoreObject(verseType);
int numberOfVersesWrittenBeforeThreshold = Rand.Next(10, 20);
int numberOfVersesWrittenAfterThreshold = Rand.Next(10, 20);
DateTime date = new DateTime(2011, 10, 10);
for (int i = 0; i < numberOfVersesWrittenBeforeThreshold; i++)
{
Verse verse = new Verse
{
AuthorProfileId = prepared.Item1.Id,
FromIpAddress = "127.0.0.1",
LastEdit = DateTime.UtcNow,
Location = "Chisinau",
OrderNr = 1,
PoemId = prepared.Item2.Id,
Text = Guid.NewGuid().ToString(),
VerseTypeId = verseType.Id,
WrittenAt = date - TimeSpan.FromDays(10)
};
RegisterDataStoreObject(verse);
}
for (int i = 0; i < numberOfVersesWrittenAfterThreshold; i++)
{
Verse verse = new Verse
{
AuthorProfileId = prepared.Item1.Id,
FromIpAddress = "127.0.0.1",
LastEdit = DateTime.UtcNow,
Location = "Chisinau",
OrderNr = 1,
PoemId = prepared.Item2.Id,
Text = Guid.NewGuid().ToString(),
VerseTypeId = verseType.Id,
WrittenAt = date + TimeSpan.FromDays(10)
};
RegisterDataStoreObject(verse);
}
var afterThreshold = verseRepository.GetVersesWrittenFrom(date);
var allItems = verseRepository.GetVersesFromPoem(prepared.Item2.Id);
Assert.AreEqual(numberOfVersesWrittenAfterThreshold, afterThreshold.Count());
Assert.AreEqual(
numberOfVersesWrittenAfterThreshold + numberOfVersesWrittenBeforeThreshold, allItems.Count());
}
private void AssertVersesAreEqual(Verse expectedVerse, Verse actualVerse)
{
Assert.AreEqual(expectedVerse.Id, actualVerse.Id);
Assert.AreEqual(expectedVerse.AuthorProfileId, actualVerse.AuthorProfileId);
Assert.AreEqual(expectedVerse.FromIpAddress, actualVerse.FromIpAddress);
Assert.AreEqual(expectedVerse.LastEdit, actualVerse.LastEdit);
Assert.AreEqual(expectedVerse.Location, actualVerse.Location);
Assert.AreEqual(expectedVerse.OrderNr, actualVerse.OrderNr);
Assert.AreEqual(expectedVerse.PoemId, actualVerse.PoemId);
Assert.AreEqual(expectedVerse.Text, actualVerse.Text);
Assert.AreEqual(expectedVerse.VerseTypeId, actualVerse.VerseTypeId);
Assert.AreEqual(expectedVerse.WrittenAt, actualVerse.WrittenAt);
}
public void SuccessfulCreationAndInsertionOfVerses()
{
IVerseRepository verseRepository = GetRepositoryWithEnrolledUnitOfWork();
var preparedTupple = PreparePoem<LegendAuthorityType, ClassicalPoem>();
VerseType verseType = new CandidateVerseType();
RegisterDataStoreObject(verseType);
Verse verse = new Verse
{
AuthorProfileId = preparedTupple.Item1.Id,
FromIpAddress = "127.0.0.1",
LastEdit = DateTime.UtcNow,
Location = "Chisinau",
OrderNr = 1,
PoemId = preparedTupple.Item2.Id,
Text = Guid.NewGuid().ToString(),
VerseTypeId = verseType.Id,
WrittenAt = DateTime.UtcNow
};
RegisterDataStoreObject(verse);
var actualVerse = verseRepository.GetById(verse.Id);
AssertVersesAreEqual(verse, actualVerse);
}
private Verse InsertCandidateVerseWithNoPreviousScratchVerseDefined(long poemId, AddVerseModel verseModel, long userId)
{
Verse verse = new Verse
{
AuthorProfileId = userId,
FromIpAddress = string.Empty,
LastEdit = DateTime.UtcNow,
WrittenAt = DateTime.UtcNow,
Location = string.Empty,
OrderNr = 0,
PoemId = poemId,
Text = verseModel.Text,
};
verseService.Insert<CandidateVerseType>(verse);
return verse;
}
protected override VerseData OnDeleteVerseFromPoem(Verse verse, VerseEngineeringUser user)
{
throw new NotImplementedException();
}
protected abstract VerseData OnDeleteVerseFromPoem(Verse verse, VerseEngineeringUser user);
protected abstract VerseData OnUpdateVerseFromPoem(Verse verse, string verseText, VerseEngineeringUser user);
public void CreateNewPoemVerseSuccessfulWithGameMasterChanged()
{
const int PoemId = 123456;
const long AuthorProfileId = 123;
const long VerseId = 1234567;
Poem poem = new ClassicalPoem
{
Id = PoemId,
Players =
new Collection<Player>(
new[] { new Player { UserProfileId = AuthorProfileId }, new Player { UserProfileId = 1 } }),
CurrentGm = AuthorProfileId,
CurrentGameMasterUserProfile = new UserProfile { Id = AuthorProfileId }
};
poemService.Setup(service => service.GetPoemById(PoemId)).Returns(poem);
Verse verse = new Verse
{
Id = VerseId,
PoemId = PoemId,
VerseType = new CandidateVerseType(),
AuthorProfileId = AuthorProfileId + 1,
Text = "This is a verse to be updated"
};
verseService.Setup(service => service.GetById(VerseId)).Returns(verse);
verseService.Setup(service => service.UpdateVerse(verse, It.IsAny<PoemVerseType>()));
verseService.Setup(service => service.GetVerseType<PoemVerseType>()).Returns(new PoemVerseType());
poemService.Setup(service => service.Update(poem)).Callback(
(Poem updated) => Assert.AreEqual(AuthorProfileId + 1, updated.CurrentGm));
signalizerFactory.Setup(factory => factory.GetSignal<PoemVerseAddedSignal<Raw>>()).Returns(
new PoemVerseAddedSignal<Raw>(logger.Object));
signalizerFactory.Setup(factory => factory.GetSignal<PoemGameMasterChangedSignal<Raw>>()).Returns(
new PoemGameMasterChangedSignal<Raw>(logger.Object));
VerseEngineeringUser requestUser = new VerseEngineeringUser(
AuthorProfileId, "TestUser", "TestFacebookAccessToken");
VerseData verseData =
poemVersesController.PostVerseForPoem(new AddVerseModel { Id = VerseId, PoemId = PoemId }, requestUser);
Assert.AreEqual(VerseId, verseData.Id);
Assert.AreEqual("This is a verse to be updated", verseData.Text);
Assert.AreEqual(PoemId, verseData.PoemId);
}
