public void Slot_ExpectedBehavior()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Slot(1);
Assert.AreEqual(true, builder.Pointer is TaskRoot);
var domain = builder.Build();
var subDomain = new DomainBuilder <MyContext>("sub-domain").Build();
Assert.IsTrue(domain.TrySetSlotDomain(1, subDomain)); // Its valid to add a sub-domain to a slot we have defined in our domain definition, and that is not currently occupied.
Assert.IsTrue(domain.TrySetSlotDomain(1, subDomain) == false); // Need to clear slot before we can attach sub-domain to a currently occupied slot.
Assert.IsTrue(domain.TrySetSlotDomain(99, subDomain) == false); // Need to define slotId in domain definition before we can attach sub-domain to that slot.
Assert.IsTrue(domain.Root.Subtasks.Count == 1);
Assert.IsTrue(domain.Root.Subtasks[0] is Slot);
var slot = (Slot)domain.Root.Subtasks[0];
Assert.IsTrue(slot.Subtask != null);
Assert.IsTrue(slot.Subtask is TaskRoot);
Assert.IsTrue(slot.Subtask.Name == "sub-domain");
domain.ClearSlot(1);
Assert.IsTrue(slot.Subtask == null);
}
//[Test]
public void T()
{
var bclTypesParser = new BclTypesParser();
var domainBuilder = new DomainBuilder("Test.Dto", type => bclTypesParser.GetParser(type) == null);
var foo = new EntityModel("Foo", new[] { new PropertyModel("Index", typeof(int)), });
var bar = new EntityModel("Bar", new List<PropertyModel>(){
new PropertyModel("Foo", foo, new List<object>())
}, new List<object>());
domainBuilder
.AddEntity(foo)
.AddEntity(bar);
domainBuilder
.Transform(
model => model.Name == foo.Name,
new Transformation<EntityModel>().Map(
model => model.Properties,
model => model.Properties.Concat(new[]
{
new PropertyModel<string>("Name", null, Visibility.Public)
}).ToList()))
.ToList();
var transformedDomain = domainBuilder.GetDomain();
var csCodeGenerator = new CsCodeGenerator(transformedDomain);
var barCode = string.Join(Environment.NewLine, csCodeGenerator.GetClass(bar.Name));
var fooCode = string.Join(Environment.NewLine, csCodeGenerator.GetClass(foo.Name));
}
private DomainBuilder CreateDomainBuilder()
{
var domainBuilder = new DomainBuilder();
DomainConfigurations.ForEach(c => domainBuilder.Register(c));
return(domainBuilder);
}
public void InvertStatus_ExpectedBehavior()
{
var domain = new DomainBuilder <MyContext>("test")
.InvertStatusSelect <DomainBuilder <MyContext>, MyContext>("test")
.Action("get a")
.Condition("has not A", context => !context.HasState(MyWorldState.HasA))
.Do(context => TaskStatus.Success)
.End()
.End()
.Sequence("test sequence")
.InvertStatusSelect <DomainBuilder <MyContext>, MyContext>("test")
.Action("always fail")
.Condition("always fail", context => context.HasState(MyWorldState.HasB))
.Do(context => TaskStatus.Failure)
.End()
.End()
.Action("get c")
.Condition("has not C", context => !context.HasState(MyWorldState.HasC))
.Do(context => TaskStatus.Success)
.End()
.End()
.Build();
var ctx = new MyContext();
ctx.Init();
var status = domain.FindPlan(ctx, out var plan);
Assert.IsTrue(status == DecompositionStatus.Succeeded);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 1);
Assert.IsTrue(plan.Peek().Name == "get c");
}
public async Task should_broadcast_mutations_to_processor()
{
long viewCounter = 0;
var strangerStreams = new DomainBuilder()
.PersistOn(() => _memory)
.WithSnapshotsOn(() => new DefaultSnapshotStore(new InMemoryPersistence(new InMemoryPersistenceOptions())))
.CreateAggregatesWith(() => new DefaultAggregateFactory())
.BroadcastTo(Watcher)
.Build();
Task <bool> Watcher(IChunk c)
{
if (c.PartitionId == "views")
{
viewCounter++;
}
return(Task.FromResult(true));
}
await strangerStreams.PushAsync("views", 1).ConfigureAwait(false);
await Task.Delay(500);
await strangerStreams.ShutdownAsync().ConfigureAwait(false);
Assert.Equal(1, viewCounter);
}
public void RepeatSequence_ExpectedBehavior()
{
var domain = new DomainBuilder <MyContext>("test")
.Repeat <DomainBuilder <MyContext>, MyContext>("repeat", (uint)MyWorldState.HasA)
.Action("increment b")
.Do(context =>
{
var b = context.GetState(MyWorldState.HasB);
context.SetState(MyWorldState.HasB, b + 1, EffectType.Permanent);
return(TaskStatus.Success);
})
.End()
.End()
.Build();
var ctx = new MyContext();
ctx.Init();
ctx.SetState(MyWorldState.HasA, 3, EffectType.Permanent);
var status = domain.FindPlan(ctx, out var plan);
Assert.IsTrue(status == DecompositionStatus.Succeeded);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 3);
Assert.IsTrue(plan.Peek().Name == "increment b");
plan.Dequeue();
Assert.IsTrue(plan.Peek().Name == "increment b");
plan.Dequeue();
Assert.IsTrue(plan.Peek().Name == "increment b");
}
public void Do_ThrowsIfNotPrimitiveTaskPointer()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Do((ctx) => TaskStatus.Success);
}
public void PausePlanThrowsWhenPointerIsNotDecomposeAll()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.PausePlan();
}
public void Effect_ThrowsIfNotPrimitiveTaskPointer()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Effect("test", EffectType.Permanent, (ctx, t) => { });
}
public void ExecutingCondition_ThrowsIfNotPrimitiveTaskPointer()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.ExecutingCondition("test", (ctx) => true);
}
public void RandomSelect_ExpectedBehavior()
{
var domain = new DomainBuilder <MyContext>("test")
.RandomSelect <DomainBuilder <MyContext>, MyContext>("random")
.Action("get a")
.Condition("has not A", context => !context.HasState(MyWorldState.HasA))
.Do(context => TaskStatus.Success)
.End()
.Action("get b")
.Condition("has not B", context => !context.HasState(MyWorldState.HasB))
.Do(context => TaskStatus.Success)
.End()
.Action("get c")
.Condition("has not C", context => !context.HasState(MyWorldState.HasC))
.Do(context => TaskStatus.Success)
.End()
.End()
.Build();
var ctx = new MyContext();
ctx.Init();
int aCount = 0;
int bCount = 0;
int cCount = 0;
for (var i = 0; i < 1000; i++)
{
var status = domain.FindPlan(ctx, out var plan);
Assert.IsTrue(status == DecompositionStatus.Succeeded);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 1);
var name = plan.Peek().Name;
if (name == "get a")
{
aCount++;
}
if (name == "get b")
{
bCount++;
}
if (name == "get c")
{
cCount++;
}
Assert.IsTrue(
name == "get a" ||
name == "get b" ||
name == "get c");
plan.Clear();
}
// With 1000 iterations, the chance of any of these counts being 0 is suuuper slim.
Assert.IsTrue(aCount > 0 && bCount > 0 && cCount > 0);
}
public void Slot_ThrowsIfNotCompoundPointer()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Action("test");
builder.Slot(1);
}
public void SelectorBuild_ForgotEnd()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Select("select test");
var domain = builder.Build();
}
public void Slot_ThrowsIfSlotIdAlreadyDefined()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Slot(1);
builder.Slot(1);
}
public void Condition_ExpectedBehaviour()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Condition("test", (ctx) => true);
Assert.AreEqual(true, builder.Pointer is TaskRoot);
}
public void AllRegistrationsMustBeResolvable()
{
var container = new ContainerBuilder();
var cfg = new ShopDomainConfiguration();
var domainBuilder = new DomainBuilder();
domainBuilder.Register(cfg);
domainBuilder.Configure(container);
ResolveAll(container.Build());
}
public void BuildInvalidatesPointer_ForgotEnd()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
var domain = builder.Build();
Assert.IsTrue(builder.Pointer == domain.Root);
}
private void DemandDomain()
{
lock (sync) {
if (domain != null)
{
return;
}
domain = DomainBuilder.BuildDomain();
}
}
public void PausePlan_ForgotEnd()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Sequence("sequence test");
builder.PausePlan();
Assert.AreEqual(true, builder.Pointer is Sequence);
}
public void Action_PrimitiveTask()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.PrimitiveTask <PrimitiveTask>("sequence test");
// Assert
Assert.AreEqual(true, builder.Pointer is IPrimitiveTask);
}
public void ExecutingCondition_ForgotEnd()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Action("test");
builder.ExecutingCondition("test", (ctx) => true);
Assert.AreEqual(true, builder.Pointer is IPrimitiveTask);
}
public void Splice_ThrowsIfNotCompoundPointer()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
var domain = new DomainBuilder <MyContext>("sub-domain").Build();
builder.Action("test");
builder.Splice(domain);
}
public void Sequence_CompoundTask()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.CompoundTask <Sequence>("sequence test");
// Assert
Assert.AreEqual(true, builder.Pointer is Sequence);
}
public void Action_ForgotEnd()
{
// Arrange
var builder = new DomainBuilder <MyContext, byte>("Test");
// Act
builder.Action("sequence test");
// Assert
Assert.AreEqual(true, builder.Pointer is IPrimitiveTask <byte>);
}
public void Do_ForgotEnd()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Action("test");
builder.Do((ctx) => TaskStatus.Success);
Assert.AreEqual(true, builder.Pointer is IPrimitiveTask);
}
public void Sequence_ForgotEnd()
{
// Arrange
var builder = new DomainBuilder <MyContext, byte>("Test");
// Act
builder.Sequence("sequence test");
// Assert
Assert.AreEqual(true, builder.Pointer is Sequence <byte>);
}
public void Effect_ForgotEnd()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Action("test");
builder.Effect("test", EffectType.Permanent, (ctx, t) => { });
Assert.AreEqual(true, builder.Pointer is IPrimitiveTask);
}
public void Slot_ForgotEnd()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Select("test");
builder.Slot(1);
Assert.AreEqual(true, builder.Pointer is Selector);
}
public void Splice_ExpectedBehavior()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
var domain = new DomainBuilder <MyContext>("sub-domain").Build();
builder.Splice(domain);
Assert.AreEqual(true, builder.Pointer is TaskRoot);
}
public void Selector_CompoundTask()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.CompoundTask <Selector>("select test");
// Assert
Assert.AreEqual(false, builder.Pointer is TaskRoot);
Assert.AreEqual(true, builder.Pointer is Selector);
}
public void Sequence_ExpectedBehavior()
{
// Arrange
var builder = new DomainBuilder <MyContext>("Test");
// Act
builder.Sequence("sequence test");
builder.End();
// Assert
Assert.AreEqual(true, builder.Pointer is TaskRoot);
}
