public async Task When_a_condition_has_children()
{
var editor = EditorID.Parse("me");
_toggle.AddCondition(editor, Condition("all"));
_toggle.AddCondition(editor, Condition("enabled"), ConditionID.Parse(0));
_toggle.AddCondition(editor, Condition("disabled"), ConditionID.Parse(0));
using (var session = _storage.CreateSession())
await session.Save(_toggle);
await _system.Scenario(_ =>
{
_.Get
.Url($"/toggles/id/{_toggle.ID}/conditions");
_.StatusCodeShouldBeOk();
_.ContentShouldBe(@"[
{
""children"": [
{ ""conditionType"": ""Enabled"", ""id"": 1 },
{ ""conditionType"": ""Disabled"", ""id"": 2 }
],
""conditionType"": ""All"",
""id"": 0
}
]".Replace(" ", "").Replace("\r\n", ""));
});
}
public async Task <IActionResult> DeleteCondition(ToggleLocator id, ConditionID condition)
{
var request = new RemoveToggleConditionRequest(GetEditor(), id, condition);
var response = await _mediator.Send(request);
return(new JsonResult(response.Conditions));
}
public AddToggleConditionRequest(EditorID editor, ToggleLocator locator, ConditionID parentID, Dictionary <string, object> properties)
{
Editor = editor;
Locator = locator;
ParentID = parentID;
Properties = properties;
}
public void Child_conditions_can_be_removed()
{
var parent = new AnyCondition {
ID = ConditionID.Parse(0)
};
var childOne = new EnabledCondition {
ID = ConditionID.Parse(1)
};
var childTwo = new DisabledCondition {
ID = ConditionID.Parse(2)
};
_collection.Add(parent);
_collection.Add(childOne, parent.ID);
_collection.Add(childTwo, parent.ID);
_collection.Remove(conditionID: childOne.ID);
_collection
.All
.ShouldHaveSingleItem()
.ShouldBeOfType <AnyCondition>();
parent.Children.ShouldBe(new[] { childTwo });
}
public ConditionAdded(EditorID editor, ConditionID conditionID, ConditionID parentConditionID, Dictionary <string, object> properties)
{
Editor = editor;
ConditionID = conditionID;
ParentConditionID = parentConditionID;
Properties = properties;
}
private void Apply(ConditionAdded e)
{
var condition = _conditionBuilder.CreateCondition(e.ConditionID, e.Properties);
_currentConditionID = e.ConditionID;
_conditions.Add(condition, e.ParentConditionID);
}
public void RemoveChild(ConditionID childID)
{
if (_child?.ID == childID)
{
_child = null;
}
}
public async Task <IActionResult> GetConditions(ToggleLocator id, ConditionID condition)
{
var request = new GetToggleRequest(id);
var response = await _mediator.Send(request);
return(new JsonResult(response.Toggle?.Conditions?.SingleOrDefault(c => c.ID == condition)));
}
public EffectResult SetStatus(ConditionID conditionId)
{
//Check current status
if (Status != null)
{
return(EffectResult.AlreadyOne);
}
//Check invulnerability
//Poison
if (conditionId == ConditionID.psn && (Base.Type1 == PokemonType.Poison || Base.Type2 == PokemonType.Poison))
{
return(EffectResult.Inmune);
}
//Burn
if (conditionId == ConditionID.brn && (Base.Type1 == PokemonType.Fire || Base.Type2 == PokemonType.Fire))
{
return(EffectResult.Inmune);
}
//TODO: En el futuro quiza habria que add la resistencia de los tipo planta a ciertos ataques(drenadoras, somnifero, etc)
Status = ConditionsDB.Conditions[conditionId];
Status?.OnStart?.Invoke(this);
StatusChanges.Enqueue($"{Base.Name} {Status.StartMessage}");
OnStatusChanged?.Invoke();
return(EffectResult.Succes);
}
public Toggle()
{
_tags = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_conditions = new ConditionCollection();
_conditionBuilder = new ConditionBuilder();
_currentConditionID = ConditionID.Empty;
}
public void When_the_parent_condition_doesnt_exist()
{
_collection.Add(new AnyCondition());
Should.Throw <ConditionNotFoundException>(
() => _collection.Add(new EnabledCondition(), parentConditionID: ConditionID.Parse(13))
);
}
public void CanAdd_is_fales_when_parent_doesnt_support_children()
{
_collection.Add(new DisabledCondition {
ID = ConditionID.Parse(10)
});
_collection
.CanAdd(new EnabledCondition(), ConditionID.Parse(10))
.ShouldBeFalse();
}
public void CanAdd_is_false_if_a_parent_cannot_add_a_child()
{
_collection.Add(new CannotAddChildCondition {
ID = ConditionID.Parse(10)
});
_collection
.CanAdd(new EnabledCondition(), ConditionID.Parse(10))
.ShouldBeFalse();
}
public void CanAdd_is_true_if_parent_can_add_child()
{
_collection.Add(new AnyCondition {
ID = ConditionID.Parse(10)
});
_collection
.CanAdd(new EnabledCondition(), ConditionID.Parse(10))
.ShouldBeTrue();
}
private void Apply(ConditionRemoved e)
{
if (e.ConditionID.IsNewerThan(_currentConditionID))
{
_currentConditionID = e.ConditionID;
}
_conditions.Remove(e.ConditionID);
}
public void RemoveCondition(EditorID editor, ConditionID conditionID)
{
if (_conditions.HasCondition(conditionID) == false)
{
throw new ConditionNotFoundException(conditionID);
}
ApplyEvent(new ConditionRemoved(editor, conditionID));
}
/// <summary>
/// Initialize the DB.
/// </summary>
public static void Init()
{
foreach (KeyValuePair <ConditionID, ConditionObj> entry in Conditions)
{
ConditionID conditionId = entry.Key;
ConditionObj condition = entry.Value;
condition.Id = conditionId;
}
}
public static void Init()
{
foreach (KeyValuePair <ConditionID, Condition> kvp in Conditions)
{
ConditionID conditionID = kvp.Key;
Condition condition = kvp.Value;
condition.ID = conditionID;
}
}
public void When_adding_a_child_to_a_condition_which_doesnt_support_children()
{
_collection.Add(new EnabledCondition {
ID = ConditionID.Parse(0)
});
Should.Throw <ConditionException>(
() => _collection.Add(new EnabledCondition(), parentConditionID: ConditionID.Parse(0))
);
}
public void When_the_exception_is_a_condition_not_found_exception()
{
_context.Exception = new ConditionNotFoundException(ConditionID.Parse(123));
_filter.OnException(_context);
_context.ShouldSatisfyAllConditions(
() => _context.ExceptionHandled.ShouldBeTrue(),
() => _context.Result.ShouldBeOfType <NotFoundResult>()
);
}
public void SetVolatileStatus(ConditionID conditionId)
{
if (VolatileStatus != null)
{
return;
}
VolatileStatus = ConditionsDB.Conditions[conditionId];
VolatileStatus?.OnStart?.Invoke(this);
StatusChanges.Enqueue($"{Base.Name} {VolatileStatus.StartMessage}");
}
public void SetVolatileStatus(ConditionID conditionId)
{
if (VolatileStatus != null)
{
return; //si ya tiene un estado alterado no puede poner otro
}
//TODO: tal y como esta hecho ahora no puede tener mas de un status volatile, esto no es correcto
VolatileStatus = ConditionsDB.Conditions[conditionId];
VolatileStatus?.OnStart?.Invoke(this);
StatusChanges.Enqueue($"{Base.Name} {VolatileStatus.StartMessage}");
}
// sets the volatile status effect
public void SetVolatileStatus(ConditionID conditionID)
{
//prevents status from applying if alredy on
if (VolatileStatus != null)
{
return;
}
VolatileStatus = ConditionDB.Conditions[conditionID];
VolatileStatus?.OnStart?.Invoke(this);
statusChanges.Enqueue($"{Base.Name} {VolatileStatus.StartMessage}");
}
public void Conditions_can_have_a_parent_specified()
{
CreateToggle(t => { t.AddCondition(Editor, ConditionProperties("any")); });
var added = Toggle.AddCondition(Editor, ConditionProperties("enabled"), parentConditionID: ConditionID.Parse(0));
SingleEvent <ConditionAdded>(e => e.ShouldSatisfyAllConditions(
() => e.ConditionID.ShouldBe(added),
() => e.Editor.ShouldBe(Editor),
() => e.ParentConditionID.ShouldBe(ConditionID.Parse(0))
));
}
public void SetStatus(ConditionID conditionID)
{
if (Status != null)
{
return;
}
Status = ConditionsDB.Conditions[conditionID];
Status?.OnStart?.Invoke(this);
StatusChanges.Enqueue($"{MonsterBase.Name} {Status.StartMessage}");
OnStatusChanged?.Invoke();
}
public void SetStatus(ConditionID conditionId)
{
if (Status != null)
{
return;
}
Status = ConditionsDB.Conditions[conditionId];
Status?.OnStart?.Invoke(this);
StatusChanges.Enqueue($"{_baseTeras.Name} {Status.StatMessage}!");
OnStatusChange?.Invoke();
}
public async Task <IActionResult> AddConditionAsChild(ToggleLocator id, ConditionID parent, [FromBody] ConditionDto condition)
{
var request = new AddToggleConditionRequest(GetEditor(), id, parent, condition);
var response = await _mediator.Send(request);
var uri = Url.Action(nameof(GetCondition), new
{
id = response.ToggleID,
condition = response.AddedConditionID
});
return(Created(uri, response));
}
public void Multiple_conditions_can_be_added()
{
var conditionOne = ConditionProperties("Enabled");
var conditionTwo = ConditionProperties("Not");
CreateToggle();
Toggle.AddCondition(Editor, conditionOne);
Toggle.AddCondition(Editor, conditionTwo);
Events.Length.ShouldBe(2);
Event <ConditionAdded>(0).Data.ConditionID.ShouldBe(ConditionID.Parse(0));
Event <ConditionAdded>(1).Data.ConditionID.ShouldBe(ConditionID.Parse(1));
}
public void Trying_to_remove_a_non_existing_condition_throws()
{
var additions = 5;
var toRemove = additions + 3;
for (int i = 0; i < additions; i++)
{
_collection.Add(new EnabledCondition());
}
Should
.Throw <ConditionNotFoundException>(() => _collection.Remove(ConditionID.Parse(toRemove)))
.Message.ShouldContain(toRemove.ToString());
}
public void When_manipulating_the_backing_store()
{
_conditions.Add(new AnyCondition {
ID = ConditionID.Parse(14)
});
_conditions.Add(new AllCondition {
ID = ConditionID.Parse(15)
});
_collection.Add(new EnabledCondition(), ConditionID.Parse(14));
_collection.All.OfType <AnyCondition>().Single().Children
.ShouldHaveSingleItem()
.ShouldBeOfType <EnabledCondition>();
}
