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 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 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();
}
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 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 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>();
}
public void Trying_to_remove_a_non_existing_condition_throws()
{
CreateToggle();
var additions = 5;
var toRemove = additions + 3;
for (int i = 0; i < additions; i++)
{
Toggle.AddCondition(Editor, ConditionProperties("enabled"));
}
Should
.Throw <ConditionNotFoundException>(() => Toggle.RemoveCondition(Editor, ConditionID.Parse(toRemove)))
.Message.ShouldContain(toRemove.ToString());
}
public void Conditions_can_be_added_to_conditions_supporting_children()
{
_collection.Add(new AnyCondition {
ID = ConditionID.Parse(0)
});
_collection.Add(new EnabledCondition(), parentConditionID: ConditionID.Parse(0));
var parent = _collection
.All
.ShouldHaveSingleItem()
.ShouldBeOfType <AnyCondition>();
parent
.Children
.ShouldHaveSingleItem()
.ShouldBeOfType <EnabledCondition>();
}
public void When_processing_conditions_on_a_toggle()
{
_view.Apply(new StatisticReceived(_user, _now, active: true, conditionStates: new Dictionary <ConditionID, bool>
{
{ ConditionID.Parse(0), true },
{ ConditionID.Parse(1), false },
{ ConditionID.Parse(2), true },
{ ConditionID.Parse(3), false }
}));
_view.Conditions.Keys.ShouldBe(new[]
{
ConditionID.Parse(0),
ConditionID.Parse(1),
ConditionID.Parse(2),
ConditionID.Parse(3)
});
}
public void Conditions_cannot_be_added_to_conditions_supporting_a_single_child_which_have_a_child_already()
{
_collection.Add(new NotCondition {
ID = ConditionID.Parse(0)
});
_collection.Add(new EnabledCondition(), parentConditionID: ConditionID.Parse(0));
Should.Throw <ConditionException>(() => _collection.Add(new DisabledCondition(), parentConditionID: ConditionID.Parse(0)));
var parent = _collection
.All
.ShouldHaveSingleItem()
.ShouldBeOfType <NotCondition>();
parent
.Children
.ShouldHaveSingleItem()
.ShouldBeOfType <EnabledCondition>();
}
public void Adding_a_condition_generates_a_well_formed_event()
{
var condition = new Dictionary <string, object>
{
{ ConditionBuilder.TypeKey, "InGroup" },
{ "GroupName", "testGroup" },
{ "SearchKey", "searchValue" }
};
CreateToggle();
Toggle.AddCondition(Editor, condition);
SingleEvent <ConditionAdded>(e => e.ShouldSatisfyAllConditions(
() => e.Properties.ShouldBe(condition),
() => e.Editor.ShouldBe(Editor),
() => e.ConditionID.ShouldBe(ConditionID.Parse(0)),
() => e.ParentConditionID.ShouldBeNull()
));
}
public void Next_condition_id_is_correct_when_adding_a_new_condition_after_load()
{
CreateToggle(
new ConditionAdded(Editor, ConditionID.Parse(0), null, ConditionProperties("enabled")).AsAct(),
new ConditionRemoved(Editor, ConditionID.Parse(0)).AsAct(),
new ConditionAdded(Editor, ConditionID.Parse(1), null, ConditionProperties("enabled")).AsAct()
);
Toggle.AddCondition(Editor, ConditionProperties("disabled"));
var expected = ConditionID.Parse(2);
Toggle
.Conditions
.OfType <DisabledCondition>()
.Last()
.ID
.ShouldBe(expected);
}
public void Conditions_can_be_removed()
{
var one = new EnabledCondition {
ID = ConditionID.Parse(0)
};
var two = new EnabledCondition {
ID = ConditionID.Parse(1)
};
var three = new EnabledCondition {
ID = ConditionID.Parse(2)
};
_collection.Add(one);
_collection.Add(two);
_collection.Add(three);
_collection.Remove(two.ID);
_collection.All.ShouldBe(new[] { one, three });
}
public void Conditions_can_be_removed()
{
var one = ConditionProperties("Enabled");
var two = ConditionProperties("Enabled");
var three = ConditionProperties("Enabled");
CreateToggle(
new ConditionAdded(Editor, ConditionID.Parse(0), null, one).AsAct(),
new ConditionAdded(Editor, ConditionID.Parse(1), null, two).AsAct(),
new ConditionAdded(Editor, ConditionID.Parse(2), null, three).AsAct()
);
Toggle.RemoveCondition(Editor, ConditionID.Parse(1));
SingleEvent <ConditionRemoved>(e => e.ShouldSatisfyAllConditions(
() => e.ConditionID.ShouldBe(ConditionID.Parse(1)),
() => e.Editor.ShouldBe(Editor)
));
Toggle.Conditions.Select(c => c.ID).ShouldBe(new[] { ConditionID.Parse(0), ConditionID.Parse(2) });
}
public void Condition_ids_always_increment_when_removals_happen()
{
CreateToggle();
var additions = 12;
for (int i = 0; i < additions; i++)
{
Toggle.AddCondition(Editor, ConditionProperties("enabled"));
}
Toggle.RemoveCondition(Editor, ConditionID.Parse(5));
Toggle.RemoveCondition(Editor, ConditionID.Parse(2));
Toggle.AddCondition(Editor, ConditionProperties("enabled"));
Events
.OfType <Event <ConditionAdded> >()
.Last()
.Data
.ConditionID.ShouldBe(ConditionID.Parse(additions));
}
public ConditionBuilderTests()
{
_builder = new ConditionBuilder();
_props = new Dictionary <string, object>();
_conditionID = ConditionID.Parse(new Random().Next(17, 2345));
}
public void When_adding_a_child_to_a_condition_which_doesnt_support_children()
{
CreateToggle(t => { t.AddCondition(Editor, ConditionProperties("enabled")); });
Should.Throw <ConditionException>(
() => Toggle.AddCondition(Editor, ConditionProperties("enabled"), parentConditionID: ConditionID.Parse(0))
);
}
public void When_the_parent_condition_doesnt_exist()
{
CreateToggle(t => { t.AddCondition(Editor, ConditionProperties("any")); });
Should.Throw <ConditionNotFoundException>(
() => Toggle.AddCondition(Editor, ConditionProperties("enabled"), parentConditionID: ConditionID.Parse(13))
);
}
public void Conditions_can_be_added_to_conditions_supporting_children()
{
CreateToggle(t => { t.AddCondition(Editor, ConditionProperties("any")); });
Toggle.AddCondition(Editor, ConditionProperties("enabled"), parentConditionID: ConditionID.Parse(0));
var parent = Toggle
.Conditions
.ShouldHaveSingleItem()
.ShouldBeOfType <AnyCondition>();
parent
.Children
.ShouldHaveSingleItem()
.ShouldBeOfType <EnabledCondition>();
}
public void CanAdd_is_false_when_parent_condition_doesnt_exist()
{
_collection
.CanAdd(new EnabledCondition(), ConditionID.Parse(1324))
.ShouldBeFalse();
}