Пример #1
0
        protected void RunStep(Action action, string stepName, ValidateTypeFault validateFunction)
        {
            BeginStep(stepName);
            try
            {
                action();
                string reason;

                if (!validateFunction(null, out reason))
                {
                    AssertException ex = new AssertException(reason);
                    throw ex;
                }
            }
            catch (FaultException exc)
            {
                LogStepEvent("Validate fault...");
                string reason;
                bool   faultOK = validateFunction(exc, out reason);

                if (faultOK)
                {
                    SaveStepFault(exc);
                }
                else
                {
                    AssertException ex = new AssertException(reason);
                    throw ex;
                }
            }
            StepPassed();
        }
Пример #2
0
        void CustomValidateFault(ValidateTypeFault validateTypeFault, FaultException exc)
        {
            // other faults are -may be- caught
            string reason;
            bool   faultOK = validateTypeFault(exc, out reason);

            //
            // if other faults are accepted, handle this in validateTypeFault and return TRUE
            //

            if (!faultOK)
            {
                string          dump = string.Format("The SOAP FAULT returned from the DUT is invalid: {0}", reason);
                AssertException ex   = new AssertException(dump);
                throw ex;
            }
        }
Пример #3
0
        /// <summary>
        /// Run step with more flexible fault validation.
        /// </summary>
        /// <param name="action">Action to be performed.</param>
        /// <param name="stepName">Step name.</param>
        /// <param name="validateFunction">Fault validation function.</param>
        /// <remarks>When no fault is received, validateFunction is called with null parameter.</remarks>
        protected void RunStep(Action action, string stepName, ValidateTypeFault validateFunction)
        {
            BeginStep(stepName);
            try
            {
                action();
                string reason;

                if (!validateFunction(null, out reason))
                {
                    AssertException ex = new AssertException(reason);
                    throw ex;
                }
            }
            catch (FaultException exc)
            {
                LogStepEvent("SOAP fault returned");
                LogStepEvent(string.Format("Code: {0}", exc.Code.Name));
                System.ServiceModel.FaultCode subCode = exc.Code.SubCode;
                while (subCode != null)
                {
                    LogStepEvent(string.Format("Subcode: {0}", subCode.Name));
                    subCode = subCode.SubCode;
                }

                string faultReason = string.Format("Reason: {0}", exc.Reason).Replace("\n", Environment.NewLine);
                LogStepEvent(faultReason);

                LogStepEvent("Validate fault...");
                string reason;
                bool   faultOK = validateFunction(exc, out reason);

                if (faultOK)
                {
                    SaveStepFault(exc);
                }
                else
                {
                    AssertException ex = new AssertException(reason);
                    throw ex;
                }
            }
            StepPassed();
        }
        void TestErrorStep(Action Step, ValidateTypeFault validateFunction)
        {
            FaultException excTest = null;

            try
            {
                Step();
            }
            catch (FaultException exc)
            {
                excTest = exc;
            }
            string reason;

            if (validateFunction(excTest, out reason))
            {
                if (excTest != null)
                {
                    SaveStepFault(excTest);
                    StepPassed();
                }
            }
            else
            {
                if (excTest != null)
                {
                    AssertException ex = new AssertException(reason);
                    throw ex;
                }
                else
                {
                    Assert(false,
                           reason,
                           "Checking expected fault");
                }
            }
        }
Пример #5
0
        /// <summary>
        /// Perform a step.
        /// </summary>
        /// <param name="action">Action to be performed in a step.</param>
        /// <param name="stepName">Step name</param>
        protected bool RunStepHandleNotSupported(Action action,
                                                 string stepName,
                                                 ValidateTypeFault validateTypeFault,
                                                 ValidateNoFault validateNoFault)
        {
            bool ok = false; // easier to set "true" if action supported

            BeginStep(stepName);
            try
            {
                action();
                if (validateNoFault == null)
                {
                    ok = true; // OK, action supported
                }
                else
                {
                    string reason;
                    bool   noFaultOk = validateNoFault(out reason);
                    if (!noFaultOk)
                    {
                        AssertException ex = new AssertException(reason);
                        throw ex;
                    }
                }
            }
            catch (FaultException exc)
            {
                ok = false; // action not supported, except cases of some "Reasonable" fault

                LogStepEvent("SOAP fault returned");
                LogStepEvent(string.Format("Code: {0}", exc.Code.Name));
                System.ServiceModel.FaultCode subCode = exc.Code.SubCode;
                while (subCode != null)
                {
                    LogStepEvent(string.Format("Subcode: {0}", subCode.Name));
                    subCode = subCode.SubCode;
                }

                string faultReason = string.Format("Reason: {0}", exc.Reason).Replace("\n", Environment.NewLine);
                LogStepEvent(faultReason);


                if (!exc.IsValidOnvifFault("Receiver/ActionNotSupported/NoImagingForSource"))
                {
                    if (!exc.IsValidOnvifFault("Receiver/ActionNotSupported"))
                    {
                        //ok = true; // action supported
                        if (validateTypeFault != null)
                        {
                            CustomValidateFault(validateTypeFault, exc);
                        }
                        else
                        {
                            // other faults are also OK
                            LogStepEvent("Warning: fault received is neither Receiver/ActionNotSupported, nor Receiver/ActionNotSupported/NoImagingForSource");
                        }
                    }
                }
            }
            StepPassed();
            return(ok);
        }
Пример #6
0
 protected bool RunStepHandleNotSupported(Action action, string stepName, ValidateTypeFault validateTypeFault)
 {
     return(RunStepHandleNotSupported(action, stepName, validateTypeFault, null));
 }
 protected void DoubleLockDoor(string token, string stepName, ValidateTypeFault validate)
 {
     RunStep(() => { Client.DoubleLockDoor(token); }, stepName, validate);
     DoRequestDelay();
 }
 protected void LockOpenReleaseDoor(string token, string stepName, ValidateTypeFault validate)
 {
     RunStep(() => { Client.LockOpenReleaseDoor(token); }, stepName, validate);
     DoRequestDelay();
 }