public void SpellsRepository_GetIdsOfClassesThatCanCastSpell_ValidCall()
{
//Arrange
List <Spell_Class> castableByList = CreateTestData.GetListOfCastableByRecords();
var mockSet = new Mock <DbSet <Spell_Class> >()
.SetupData(castableByList, o =>
{
return(castableByList.Single(x => x.Spell_id.CompareTo(o.First()) == 0));
});
var expected = new Spell_Class
{
Spell_id = Guid.Parse("46d10bb8-84d2-408d-a928-5847ff99461f"),
Class_id = Guid.Parse("b74e228f-015d-45b4-af0f-a6781976535a")
};
using (var mockContext = AutoMock.GetLoose())
{
mockContext.Mock <SpellsContext>()
.Setup(x => x.CastableByRecords).Returns(mockSet.Object);
//Act
ISpellsRepository toTest = mockContext.Create <SpellsRepository>();
var actual = toTest.GetIdsOfClassesThatCanCastSpell(expected.Spell_id);
//Assert
actual.Should().Contain(expected.Class_id);
}
}
public void CharacterCommons_spellCanBeCastByClass_returnFalse()
{
List <Spell_Class> spell_Classes = CreateTestData.GetListOfCastableByRecords();
List <Spell> spells = CreateTestData.GetListOfSpells();
var spellMockSet = new Mock <DbSet <Spell> >()
.SetupData(spells, o =>
{
return(spells.Single(x => x.Spell_id.CompareTo(o.First()) == 0));
});
var castableByMockSet = new Mock <DbSet <Spell_Class> >()
.SetupData(spell_Classes, o =>
{
return(spell_Classes.Single(x => x.Spell_id.CompareTo(o.First()) == 0));
});
var realSpellID = CreateTestData.GetSampleSpell().Spell_id;
var falseClassID = Guid.Parse("16310468-2345-460f-a408-d9f7c908ad2a");
using (var mockContext = AutoMock.GetLoose())
{
mockContext.Mock <SpellsContext>()
.Setup(x => x.Spells).Returns(spellMockSet.Object);
mockContext.Mock <SpellsContext>()
.Setup(x => x.Set <Spell>()).Returns(spellMockSet.Object);
mockContext.Mock <SpellsContext>()
.Setup(x => x.CastableByRecords).Returns(castableByMockSet.Object);
mockContext.Mock <SpellsContext>()
.Setup(x => x.Set <Spell_Class>()).Returns(castableByMockSet.Object);
IUnitOfWork uow = UoW_Factory.getUnitofWork(mockContext);
IBaseUserAccess access = UserAccessFactory.getBaseUserAccess(uow);
//act
ICharacterCommonFunctions toTest = ProcessorFactory.GetCharacterCommonFunctions(access);
var actual = toTest.spellCanBeCastByClass(realSpellID, falseClassID);
//Assert
actual.Should().BeFalse();
}
}
public void CharacterServices_ExistingCharacterLearnsSpell_ValidCall()
{
//Arrange
List <Spell> listOfSpells = CreateTestData.GetListOfSpells();
List <Spell_Class> listOfCastableBy = CreateTestData.GetListOfCastableByRecords();
List <Character_Class_Subclass> listofKnownClasses = CreateTestData.GetListOfCharacter_Class_Subclass();
List <Spell_Character> listOfKnownSpells = new List <Spell_Character>();
//Caleb should learn how to cast his tower spell.
Spell_Character expected = CreateTestData.GetSampleKnownSpell();
Guid Caleb_id = expected.Character_id;
Guid User_id = Guid.Parse("5f0d6374-fe3e-4337-9a0a-787db1f7b628");
Guid Tower_id = expected.Spell_id;
var spellMockSet = new Mock <DbSet <Spell> >()
.SetupData(listOfSpells, o =>
{
return(listOfSpells.Single(x => x.Spell_id.CompareTo(o.First()) == 0));
});
var castableByMockSet = new Mock <DbSet <Spell_Class> >()
.SetupData(listOfCastableBy, o =>
{
return(listOfCastableBy.Single(x => x.Class_id.CompareTo(o.First()) == 0));
});
var knownClassesMockSet = new Mock <DbSet <Character_Class_Subclass> >()
.SetupData(listofKnownClasses, o =>
{
return(listofKnownClasses.Single(x => x.Character_id.CompareTo(o.First()) == 0));
});
var knownSpellsMockSet = new Mock <DbSet <Spell_Character> >()
.SetupData(listOfKnownSpells, o =>
{
return(listOfKnownSpells.Single(x => x.Spell_id.CompareTo(o.First()) == 0));
});
using (var mockContext = AutoMock.GetLoose())
{
mockContext.Mock <SpellsContext>()
.Setup(x => x.Spells).Returns(spellMockSet.Object);
mockContext.Mock <SpellsContext>()
.Setup(x => x.Set <Spell>()).Returns(spellMockSet.Object);
mockContext.Mock <SpellsContext>()
.Setup(x => x.CastableByRecords).Returns(castableByMockSet.Object);
mockContext.Mock <SpellsContext>()
.Setup(x => x.Set <Spell_Class>()).Returns(castableByMockSet.Object);
mockContext.Mock <SpellsContext>()
.Setup(x => x.KnownSpells).Returns(knownSpellsMockSet.Object);
mockContext.Mock <SpellsContext>()
.Setup(x => x.Set <Spell_Character>()).Returns(knownSpellsMockSet.Object);
mockContext.Mock <PlayableClassContext>()
.Setup(x => x.KnownClasses).Returns(knownClassesMockSet.Object);
mockContext.Mock <PlayableClassContext>()
.Setup(x => x.Set <Character_Class_Subclass>()).Returns(knownClassesMockSet.Object);
//Act
ICharacterServices toTest = mockContext.Create <CharacterServices>();
toTest.ExistingCharacterLearnsSpell(User_id, Caleb_id, Tower_id);
//Assert
listOfKnownSpells.Should().ContainEquivalentOf(expected);
listOfKnownSpells.Where(x => x.Spell_id == expected.Spell_id && x.Character_id == expected.Character_id).Count().Should().Be(1);
}
}
public void SpellsRepository_GetSpellsCastableBy_ValidCall()
{
//Arrange
List <Spell> spells = CreateTestData.GetListOfSpells();
List <Spell_Class> CastableByRecords = CreateTestData.GetListOfCastableByRecords();
//I expect three spells - Web of Fire, Voltaic Bolt, and the Tower, all of which can be cast by a wizard.
List <Spell> expected = new List <Spell>();
Spell NineSidedTower = new Spell
{
Spell_id = Guid.Parse("46d10bb8-84d2-408d-a928-5847ff99461f"),
Name = "Widogast's Nascent Nine-sided Tower",
Description = "A flavored Magnificent Mansion",
Level = 7,
School_id = Guid.Parse("361bd911-0702-437f-ab59-a29da0f9fba4"),
CastingTime = "1 minute",
Range = "100 feet",
Duration = "24 hours",
RequiresVerbal = true,
RequiresSomantic = true,
RequiresMaterial = false,
RequiresConcentration = true
};
expected.Add(NineSidedTower);
Spell WebOfFire = new Spell
{
Spell_id = Guid.Parse("51b4c563-2040-4c7d-a23e-cab8d5d3c73b"),
Name = "Widogast's Web Of Fire",
Description = "The caster deals a shitton of fire damage to the target.",
Level = 4,
School_id = Guid.Parse("11111111-2222-3333-4444-555555555555"),
CastingTime = "1 Action",
Duration = "Instant",
Range = "120 feet",
RequiresVerbal = true,
RequiresSomantic = true,
RequiresMaterial = true,
RequiresConcentration = false
};
expected.Add(WebOfFire);
Spell VoltaicBolt = new Spell
{
Spell_id = Guid.Parse("a9756f3d-55d0-40cd-8083-6b547e4932ab"),
Name = "Brenatto's Voltaic Bolt",
Description = "The caster's next ranged attack deals an additional 3d6 lightning damage",
Level = 1,
School_id = Guid.Parse("11111111-2222-3333-4444-555555555555"),
CastingTime = "1 Bonus Action",
Duration = "1 round",
Range = "30 feet",
RequiresVerbal = false,
RequiresSomantic = true,
RequiresMaterial = true,
RequiresConcentration = false
};
expected.Add(VoltaicBolt);
var spellMockSet = new Mock <DbSet <Spell> >()
.SetupData(spells, o =>
{
return(spells.Single(x => x.Spell_id.CompareTo(o.First()) == 0));
});
var SpellCastableByMockSet = new Mock <DbSet <Spell_Class> >()
.SetupData(CastableByRecords, o =>
{
return(CastableByRecords.Single(x => x.Class_id.CompareTo(o.First()) == 0));
});
using (var mockContext = AutoMock.GetLoose())
{
mockContext.Mock <SpellsContext>()
.Setup(x => x.Spells).Returns(spellMockSet.Object);
mockContext.Mock <SpellsContext>()
.Setup(x => x.CastableByRecords).Returns(SpellCastableByMockSet.Object);
//Act
ISpellsRepository toTest = mockContext.Create <SpellsRepository>();
Guid WIzard_id = Guid.Parse("b74e228f-015d-45b4-af0f-a6781976535a");
var actual = toTest.GetSpellsCastableBy(WIzard_id).ToList();
//Assert
actual.Should().NotBeEmpty();
actual.Should().NotBeNull();
actual.Should().BeOfType <List <Spell> >();
actual.Should().BeEquivalentTo(expected);
}
}