public void TestCreateSingleItem(Enums.ResourceType resourceType, InvalidPhaseOption valueType, int expectedCode)
        {
            object fieldValue = GetOptionValue(valueType, resourceType);

            Phase phase = PhaseHelper.CreatePhaseInstance(creatingRecords, resourceType);

            phase.PhaseObject = fieldValue;

            var error = PhaseHelper.WritePhaseFail(phase);

            Assert.That(error, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
            Assert.That(error.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
        }
        public void TestUpdateSingleItem(Enums.ResourceType resourceType, InvalidPhaseOption valueType, int expectedCode)
        {
            object fieldValue = GetOptionValue(valueType, resourceType);

            var phase = new Phase {
                Id = ReadPhaseBasedOnResource(resourceType, 0), Date = Util.ToString(DateTime.Now)
            };

            phase.PhaseObject = fieldValue;

            var error = PhaseHelper.WritePhaseFail(phase);

            Assert.That(error, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
        }
        public void TestUpdateListItem(Enums.ResourceType resourceType, InvalidPhaseOption valueType, int expectedCode)
        {
            object fieldValue = GetOptionValue(valueType, resourceType);
            var    resourceList = new[] { 0, 1 }.Select(depKey =>
            {
                var phase = new Phase {
                    Id = ReadPhaseBasedOnResource(resourceType, depKey), Date = Util.ToString(DateTime.Now)
                };
                phase.PhaseObject = fieldValue;
                return(phase);
            });

            ErrorCode result = PhaseHelper.WritePhasesFail(resourceList);

            Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
        }
        public void TestCreateListItem(Enums.ResourceType resourceType, InvalidPhaseOption valueType, int expectedCode)
        {
            object fieldValue = GetOptionValue(valueType, resourceType);

            var resourceList = new[] { 0, 1 }.Select(depKey =>
            {
                var phase = PhaseHelper.CreatePhaseInstance(creatingRecords, resourceType, depKey);

                phase.PhaseObject = fieldValue;

                return(phase);
            }).ToList();

            ErrorCode result = PhaseHelper.WritePhasesFail(resourceList);

            Assert.That(result, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
            Assert.That(result.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
        }
        private object GetOptionValue(InvalidPhaseOption valueType, Enums.ResourceType resourceType)
        {
            List <string> aliasList    = null;
            List <Option> optionList   = null;
            Option        result       = null;
            string        optionMaster = $"Option.P_{resourceType.ToResourceName()}Phase";

            switch (valueType)
            {
            case InvalidPhaseOption.RandomData: return(new Option {
                    ActualXMLTag = "Option.P_NothingPhase" + Util.GetUniqueString(5, false)
                });

            case InvalidPhaseOption.Duplicated:
                aliasList = OptionFieldHelper.GetOptionList(optionMaster);
                Assume.That(aliasList, Is.Not.Null.And.Not.Empty, "Cannot get the option list!");
                string duplicatedOption = aliasList.Random();
                return(new ArrayList
                {
                    new Option {
                        ActualXMLTag = duplicatedOption
                    },
                    new Option {
                        ActualXMLTag = duplicatedOption
                    }
                });

            case InvalidPhaseOption.OneSelectionUsingId:
                optionList = GetOptionList(optionMaster);
                return(new Option()
                {
                    Id = optionList.Random().Id
                });

            case InvalidPhaseOption.MultiSelectionUsingId:
                optionList = GetOptionList(optionMaster);
                return(new ArrayList
                {
                    new Option {
                        Id = optionList.First().Id
                    },
                    new Option {
                        Id = optionList.Last().Id
                    }
                });

            case InvalidPhaseOption.WrongOptionMaster:
                if (optionMaster.EndsWith("Phase"))
                {
                    return new Option()
                           {
                               ActualXMLTag = OptionFieldHelper.GetOptionList(Enums.Options.Area).Random()
                           }
                }
                ;
                return(new Option()
                {
                    ActualXMLTag = OptionFieldHelper.GetOptionList(Enums.Options.ProcessPhase).Random()
                });

            case InvalidPhaseOption.Attribute:
                optionList = GetOptionList(optionMaster);
                result     = new Option {
                    ActualXMLTag = optionList.First().Alias
                };
                result.Attributes.Add("Id", optionList.First().Id);
                return(result);

            case InvalidPhaseOption.Nesting:
                optionList = GetOptionList(optionMaster);
                result     = new Option {
                    ActualXMLTag = optionList.First().Alias
                };
                result.Items = new ArrayList()
                {
                    new Option {
                        ActualXMLTag = optionList.Last().Alias
                    }
                };
                return(result);

            case InvalidPhaseOption.MultiSelection:
                aliasList = OptionFieldHelper.GetOptionList(optionMaster);
                return(new ArrayList
                {
                    new Option {
                        Id = aliasList.First()
                    },
                    new Option {
                        Id = aliasList.Last()
                    }
                });
            }
            return(result);
        }