Beispiel #1
0
        public void CreateProcessWithActionRelationsShouldBeSuccessfull()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Start("s_1").Done().End("e_1");
            builder.Step("s_2").Action().Name("a_1").Skippable(false).Done();
            builder.Step("s_3").Action().Name("a_2").Skippable(false).Done();
            builder.Link().From("s_1").To("s_2").Done();
            builder.Link().From("s_1").To("s_3").Done();
            builder.Link().From("s_1").To("e_1").Done();
            builder.Link().From("s_2").To("e_1").Done();
            builder.Link().From("s_3").To("e_1").Done();
            builder.BuildActionRelations().If("a_1").RequiredOnStep("s_2").Then("a_2").RequiredOnStep("s_3").Done().Done();
            IReadOnlyList <ProcessValidationResult> erros;

            Assert.IsTrue(builder.TryValidate(out erros));
            Assert.AreEqual(0, erros.Count);
            var processDefinition = builder.Build();

            Assert.IsNotNull(processDefinition);
            Assert.IsNotNull(processDefinition.ActionsRelations);
            Assert.AreEqual(1, processDefinition.ActionsRelations.Length);
            Assert.AreEqual("s_2", processDefinition.ActionsRelations[0].SourceStepId);
            Assert.AreEqual("s_3", processDefinition.ActionsRelations[0].TargetStepId);
            Assert.AreEqual("a_1", processDefinition.ActionsRelations[0].SourceActionId);
            Assert.AreEqual("a_2", processDefinition.ActionsRelations[0].TargetActionId);
        }
Beispiel #2
0
        public void CreateProcessWithTagsShouldBuildProcessDefinitionWithTags()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Start("s_1").Done().End("e_1");
            builder.Step("s_2");
            builder.Step("s_3");
            builder.Link().From("s_1").To("s_2").Done();
            builder.Link().From("s_1").To("s_3").Done();
            builder.Link().From("s_1").To("e_1").Done();
            builder.Link().From("s_2").To("e_1").Done();
            builder.Link().From("s_3").To("e_1").Done();
            builder.Tag("LOB").Handler().IocService("lobService").Done().Name("Line of Business");
            IReadOnlyList <ProcessValidationResult> erros;

            Assert.IsTrue(builder.TryValidate(out erros));
            Assert.AreEqual(0, erros.Count);
            var processDefinition = builder.Build();

            Assert.IsNotNull(processDefinition);
            Assert.IsNotNull(processDefinition.Tags);
            Assert.AreEqual(1, processDefinition.Tags.Count());
            TagDefinition td = processDefinition.Tags[0];

            Assert.AreEqual("LOB", td.Id);
            Assert.AreEqual("Line of Business", td.DisplayName);
            Assert.IsNotNull(td.Handler);
            Assert.AreEqual("lobService", td.Handler.IocName);
        }
Beispiel #3
0
        public void TestBuildProcess()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "com.klaudwerk.workflow.renewal", name: "Renewal", description: "Policy Renewal");

            Assert.IsNotNull(builder);
        }
Beispiel #4
0
        public void TestCreateActionRelationBuilder()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");
            ActionRelationBuilder actionRelationBuilder = new ActionRelationBuilder(builder);

            Assert.AreEqual(builder, actionRelationBuilder.Done());
        }
Beispiel #5
0
 public void NullIdShouldThrowException()
 {
     Assert.Throws <ArgumentException>(() =>
     {
         var factory = new ProcessBuilderFactory();
         var builder = factory.CreateProcess(id: string.Empty, name: "Renewal", description: "Policy Renewal");
     });
 }
Beispiel #6
0
        public void TestLinkStepsInWorkflow()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");
            var pb      = builder.Start("s_1").Done().End("e_1").Done()
                          .Link().From("s_1").To("e_1").Name("Approved").Done();

            Assert.IsNotNull(pb);
        }
        public void TestBuildProcessVariables()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Variables().Name("PolicyNumber").Type(VariableTypeEnum.String)
            .Description("Associated Policy Number").Done();
            Assert.IsNotNull(builder.ProcessVariables);
            Assert.AreEqual(1, builder.ProcessVariables.Count);
        }
Beispiel #8
0
        public void TryFindTestShouldReturnFalseForNonExistingStep()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");
            var sb      = builder.Start("123");
            Tuple <StepBuilder, StepTypeEnum> step;

            Assert.IsFalse(builder.TryFindStep("567", out step));
            Assert.IsNull(step);
        }
Beispiel #9
0
        public void LinkToNonExistingStepShouldThrowException()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Start("s_1").Done().End("e_1");
            Assert.Throws <ArgumentException>(() =>
            {
                builder.Link().From("s_1").To("s_2");
            });
        }
Beispiel #10
0
        public void FinalizingLinkWithIncompleteTotepShouldFail()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Start("s_1").Done().End("e_1");
            Assert.Throws <ArgumentException>(() =>
            {
                builder.Link().From("s_1").Done();
            });
        }
        public void FinalizationOfVariableBuilderWithoutNameShouldFail()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            Assert.Throws <ArgumentNullException>(() =>
            {
                builder.Variables().Type(VariableTypeEnum.String)
                .Description("Associated Policy Number").Done();
            });
        }
Beispiel #12
0
        public void TestActionRelationForSteps()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");
            ActionRelationBuilder actionRelationBuilder = new ActionRelationBuilder(builder);

            actionRelationBuilder.If("name").RequiredOnStep("step").Then("abc").RequiredOnStep("step1");
            Assert.AreEqual("name", actionRelationBuilder.SourceActionId);
            Assert.AreEqual("step", actionRelationBuilder.SourceStepId);
            Assert.AreEqual("abc", actionRelationBuilder.TargetActionId);
            Assert.AreEqual("step1", actionRelationBuilder.TargetStepId);
        }
        public void ValidationShouldFailForEmptyBuilder()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "123", name: "Renewal", description: "Policy Renewal");
            IReadOnlyList <ProcessValidationResult> validationResults;

            Assert.IsFalse(builder.TryValidate(out validationResults));
            Assert.IsNotNull(validationResults);
            Assert.AreEqual(1, validationResults.Count);
            Assert.AreEqual(ProcessValidationResult.ItemEnum.Process, validationResults[0].Artifact);
            Assert.AreEqual("123", validationResults[0].ArtifactId);
        }
Beispiel #14
0
        public void TryFindStepShouldReturnExistingStep()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");
            var sb      = builder.Start("123");
            Tuple <StepBuilder, StepTypeEnum> step;

            Assert.IsTrue(builder.TryFindStep("123", out step));
            Assert.IsNotNull(step);
            Assert.AreEqual("123", step.Item1.Id);
            Assert.AreEqual(StepTypeEnum.Start, step.Item2);
        }
        public void TestVariableBuilderGroupList()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Variables()
            .Name("users").Type(VariableTypeEnum.GroupsList).Constraints()
            .PossibeValues(new object[] { "g1", "g2" }).Done().Done();
            Assert.IsNotNull(builder.ProcessVariables);
            Assert.AreEqual(1, builder.ProcessVariables.Count);
            Assert.AreEqual(new object[] { "g1", "g2" }, builder.ProcessVariables[0].VariableConstraints.Values);
        }
Beispiel #16
0
        public void CallRemoveOnStepShouldRemoveStepAndLinksFromProcessor()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Start("s_1").Done().End("e_1");
            builder.Link().From("s_1").To("e_1").Done();
            Assert.AreEqual(2, builder.Steps.Count);
            Assert.AreEqual(1, builder.Links.Count);
            builder.Steps[0].Item1.Remove();
            Assert.AreEqual(1, builder.Steps.Count);
            Assert.AreEqual(0, builder.Links.Count);
        }
        public void CreateTagBuilder()
        {
            var factory    = new ProcessBuilderFactory();
            var builder    = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");
            var tagBuilder = builder.Tag("Lob").Name("Line of Business");

            Assert.IsNotNull(tagBuilder);
            Assert.IsNotNull(builder.Tags);
            Assert.AreEqual(1, builder.Tags.Count);
            Assert.AreEqual("Lob", builder.Tags[0].Id);
            Assert.AreEqual("Line of Business", builder.Tags[0].DisplayName);
            Assert.AreEqual(builder, tagBuilder.Done());
        }
        public void CreateTagBuilderHandler()
        {
            var factory    = new ProcessBuilderFactory();
            var builder    = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");
            var tagBuilder = builder.Tag("Lob");
            var handler    = tagBuilder.Handler();

            Assert.IsNotNull(handler);
            var iochandler = handler.IocService("LineOfBusinessService");

            Assert.AreEqual(handler, iochandler);
            Assert.IsNotNull(tagBuilder.TagHandler);
            Assert.AreEqual(handler, tagBuilder.TagHandler);
        }
        public void ValidationShouldFailForMappedStepVArsNotDefinedInProcess()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "123", name: "Renewal", description: "Policy Renewal");

            builder.Start("start").Done().Step("s_1").Vars().Name("policyNumber").OnEntry().Done().Done().End("e_1").Done()
            .Link().From("start").To("s_1").Done()
            .Link().From("s_1").To("e_1").Done();
            IReadOnlyList <ProcessValidationResult> validationResults;

            Assert.IsFalse(builder.TryValidate(out validationResults));
            Assert.IsNotNull(validationResults);
            Assert.AreEqual(1, validationResults.Count);
        }
        public void FullLnkedFlowShouldBeValidated()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "123", name: "Renewal", description: "Policy Renewal");

            builder.Start("start").Done().Step("s_1").Done().End("e_1").Done()
            .Link().From("start").To("s_1").Done()
            .Link().From("s_1").To("e_1").Done();
            IReadOnlyList <ProcessValidationResult> validationResults;

            Assert.IsTrue(builder.TryValidate(out validationResults));
            Assert.IsNotNull(validationResults);
            Assert.AreEqual(0, validationResults.Count);
        }
        public void ValidationShouldFailWhenNoEndStemPresent()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "123", name: "Renewal", description: "Policy Renewal");

            builder.Start("start").Done().Step("s_1").Done().Link().From("start").To("s_1").Done()
            .Link().From("s_1").To("start").Done();
            IReadOnlyList <ProcessValidationResult> validationResults;

            Assert.IsFalse(builder.TryValidate(out validationResults));
            Assert.IsNotNull(validationResults);
            Assert.AreEqual(1, validationResults.Count);
            Assert.AreEqual(ProcessValidationResult.ItemEnum.Process, validationResults[0].Artifact);
            Assert.AreEqual("123", validationResults[0].ArtifactId);
        }
        public void TestVariableBuilderSetDisplayHint()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Variables()
            .Name("users")
            .Type(VariableTypeEnum.GroupsList)
            .Constraints()
            .Hint(DisplayHintEnum.Number)
            .Done()
            .Done();
            Assert.IsNotNull(builder.ProcessVariables);
            Assert.AreEqual(1, builder.ProcessVariables.Count);
            Assert.AreEqual(DisplayHintEnum.Number, builder.ProcessVariables[0].VariableConstraints.DisplayHint);
        }
        public void CreateRetrieveRemoveTag()
        {
            var factory    = new ProcessBuilderFactory();
            var builder    = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");
            var tagBuilder = builder.Tag("Lob");

            Assert.IsNotNull(tagBuilder);
            var newTagBuilder = builder.Tag("NewTag");

            Assert.IsNotNull(builder.Tags);
            Assert.AreEqual(2, builder.Tags.Count);
            Assert.AreNotEqual(tagBuilder, newTagBuilder);
            newTagBuilder.Remove();
            Assert.AreEqual(1, builder.Tags.Count);
            Assert.AreEqual(tagBuilder, builder.Tags[0]);
            Assert.AreEqual(builder, tagBuilder.Done());
        }
Beispiel #24
0
        public void BuildWorkflowWithStartAndEndStep()
        {
            var factory     = new ProcessBuilderFactory();
            var builder     = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");
            var sb          = builder.Start("123");
            var doneBuilder = sb.Done();

            Assert.AreEqual(builder, doneBuilder);
            builder.End("End_1");
            Assert.IsNotNull(sb);
            Assert.IsNotNull(builder.StartSteps);
            Assert.AreEqual(1, builder.StartSteps.Count);
            Assert.IsNotNull(builder.EndSteps);
            Assert.AreEqual(1, builder.EndSteps.Count);
            Assert.IsNotNull(builder.Steps);
            Assert.AreEqual(2, builder.Steps.Count);
        }
        public void VariableWithTheSameNameShouldBeReplaced()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Variables().Name("PolicyNumber").Type(VariableTypeEnum.String)
            .Description("Associated Policy Number").Done();
            Assert.IsNotNull(builder.ProcessVariables);
            Assert.AreEqual(1, builder.ProcessVariables.Count);
            Assert.AreEqual("PolicyNumber", builder.ProcessVariables[0].VariableName);
            Assert.AreEqual(VariableTypeEnum.String, builder.ProcessVariables[0].VariableType);
            builder.Variables().Name("PolicyNumber").Type(VariableTypeEnum.Int).Done();
            Assert.IsNotNull(builder.ProcessVariables);
            Assert.AreEqual(1, builder.ProcessVariables.Count);
            Assert.AreEqual("PolicyNumber", builder.ProcessVariables[0].VariableName);
            Assert.AreEqual(VariableTypeEnum.Int, builder.ProcessVariables[0].VariableType);
        }
        public void TestSettingConstraintsForVariable()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Variables().Name("PolicyNumber").Type(VariableTypeEnum.String)
            .Description("Associated Policy Number")
            .Constraints().MaxValue(100).MinValue(10).DefaultValue("DEFAULT").PossibeValues("1", "2", "3").Done().Done();
            Assert.IsNotNull(builder.ProcessVariables);
            Assert.AreEqual(1, builder.ProcessVariables.Count);
            var builderProcessVariable = builder.ProcessVariables[0];

            Assert.IsNotNull(builderProcessVariable.VariableConstraints);
            Assert.AreEqual("DEFAULT", builderProcessVariable.VariableConstraints.Default);
            Assert.AreEqual(10, builderProcessVariable.VariableConstraints.Min);
            Assert.AreEqual(100, builderProcessVariable.VariableConstraints.Max);
        }
Beispiel #27
0
        public void TestActionRelationCreateThroughProcessBuilder()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.BuildActionRelations().If("name").RequiredOnStep("step").Then("abc").RequiredOnStep("step1")
            .Done()
            .Done();
            Assert.IsNotNull(builder.ActionRelations);
            Assert.AreEqual(1, builder.ActionRelations.Count);
            ActionRelationBuilder actionRelationBuilder = builder.ActionRelations[0];

            Assert.AreEqual("name", actionRelationBuilder.SourceActionId);
            Assert.AreEqual("step", actionRelationBuilder.SourceStepId);
            Assert.AreEqual("abc", actionRelationBuilder.TargetActionId);
            Assert.AreEqual("step1", actionRelationBuilder.TargetStepId);
        }
Beispiel #28
0
        public void TestSameSouceActionDifferentTargetActionCanBeAddedMultipleTimes()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.BuildActionRelations().If("name").RequiredOnStep("step").Then("abc1").RequiredOnStep("step1")
            .Done()
            .Done();
            builder.BuildActionRelations().If("name").RequiredOnStep("step").Then("abc2").RequiredOnStep("step1")
            .Done()
            .Done();
            builder.BuildActionRelations().If("name").RequiredOnStep("step").Then("abc3").RequiredOnStep("step1")
            .Done()
            .Done();
            Assert.IsNotNull(builder.ActionRelations);
            Assert.AreEqual(3, builder.ActionRelations.Count);
        }
        public void TestSettingPossibleValueOnVariable()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");

            builder.Variables()
            .Name("List")
            .Type(VariableTypeEnum.String)
            .Constraints()
            .PossibeValues("1", "2", "3", "4").Done().Done();
            Assert.IsNotNull(builder.ProcessVariables);
            Assert.AreEqual(1, builder.ProcessVariables.Count);
            var vars = builder.ProcessVariables;

            Assert.IsNotNull(vars[0].VariableConstraints);
            Assert.IsNotNull(vars[0].VariableConstraints.Values);
            Assert.AreEqual(4, vars[0].VariableConstraints.Values.Length);
        }
Beispiel #30
0
        public void AddStepsWithTheSameIdShouldFail()
        {
            var factory = new ProcessBuilderFactory();
            var builder = factory.CreateProcess(id: "p_001", name: "Renewal", description: "Policy Renewal");
            var sb      = builder.Step("123");

            Assert.Throws <ArgumentException>(() =>
            {
                builder.Step("123");
            });
            Assert.Throws <ArgumentException>(() =>
            {
                builder.Start("123");
            });
            Assert.Throws <ArgumentException>(() =>
            {
                builder.End("123");
            });
        }