示例#1
0
            internal override bool NotifyTraces(ActualTrace instanceTraces)
            {
                bool foundTrace = false;

                foreach (IActualTraceStep step in instanceTraces.Steps)
                {
                    if (step.Equals(this.traceStep))
                    {
                        foundTrace           = true;
                        _successfulTraceStep = this.traceStep;
                    }
                    else if (step.Equals(_otherTraceStep))
                    {
                        foundTrace           = true;
                        _successfulTraceStep = _otherTraceStep;
                    }

                    if (foundTrace)
                    {
                        this.manualResetEvent.Set();
                        break;
                    }
                }

                return(foundTrace);
            }
        private bool TrackActivityStateRecord(ActivityStateRecord activityRecord, ActualTrace _trace)
        {
            TestTraceManager.OptionalLogTrace("[InMemoryTrackingParticipant]activityRecord.Name = {0}", activityRecord.Activity.Name);
            ActivityTrace activityTrace = new ActivityTrace(
                activityRecord.Activity.Name,
                (ActivityInstanceState)Enum.Parse(typeof(ActivityInstanceState), activityRecord.State), activityRecord);

            //to avoid the confusion b\w Executing & scheduling events, we always use scheduled
            if (activityTrace.ActivityStatus != ActivityInstanceState.Executing)
            {
                _trace.Add(activityTrace);
                return(true);
            }

            //for tracking test cases, it may be the scenario that the profile does not have a scheduled record.
            //in that scenario, we need to add that explicitly to the trace.
            if (TestTraceManager.IsDefaultTrackingConfiguration == false)//is a tracking test case
            {
                if (
                    (_trace.Steps.Count == 0) ||
                    (
                        (_trace.Steps.Count != 0) &&
                        (_trace.Steps[_trace.Steps.Count - 1].Equals(activityTrace) == false)
                    )
                    )
                {
                    _trace.Add(activityTrace);
                    return(true);
                }
            }

            return(false);
        }
示例#3
0
        private void CheckSubscriptions(Guid instanceId, ActualTrace instanceTraces)
        {
            lock (_thisLock)
            {
                List <Subscription> workflowInstanceSubscriptions = null;
                if (_allSubscriptions.TryGetValue(instanceId, out workflowInstanceSubscriptions))
                {
                    List <Subscription> subscriptionsPendingRemoval = new List <Subscription>();

                    foreach (Subscription subscription in workflowInstanceSubscriptions)
                    {
                        if (subscription.NotifyTraces(instanceTraces))
                        {
                            subscriptionsPendingRemoval.Add(subscription);
                        }
                    }

                    foreach (Subscription subscription in subscriptionsPendingRemoval)
                    {
                        workflowInstanceSubscriptions.Remove(subscription);
                    }
                    if (workflowInstanceSubscriptions.Count == 0)
                    {
                        _allSubscriptions.Remove(instanceId);
                    }
                }
            }
        }
示例#4
0
        public static void ValidateWorkflow(Guid workflowInstanceId, TestActivity testWorkflowDefinition)
        {
            ActualTrace   actualTrace   = TestTraceManager.Instance.GetInstanceActualTrace(workflowInstanceId);
            ExpectedTrace expectedTrace = testWorkflowDefinition.GetExpectedTrace();

            actualTrace.Validate(testWorkflowDefinition.GetExpectedTrace());
        }
示例#5
0
        public static void ValidateTracking(ExpectedTrace expectedTrace, ActualTrace actualTrace, TrackingProfile profile, TestProfileType profileType, TrackingParticipantType participantType)
        {
            //1. Filter the expected trace against the workFlow profile
            ExpectedTrace filteredExpectedTrace = TrackingFilter.ApplyTrackingProfile(expectedTrace, profile);

            ////2. Delete not supported trace steps by testObjects.
            ActualTrace modifiedActualTrace = TrackingFilter.DeleteNotSupportedTraceSteps(actualTrace);

            TestTraceManager.OptionalLogTrace("[TestTrackingDataManager]*****ValidateTracking()");
            ////3. Validate the expected & the actual trace
            TestTraceManager.OptionalLogTrace("[TestTrackingDataManager]Profile = {0}", profile);
            TestTraceManager.OptionalLogTrace("[TestTrackingDataManager]Actual Trace = {0}", actualTrace);
            TestTraceManager.OptionalLogTrace("[TestTrackingDataManager]Expected Trace = {0}", expectedTrace);
            TestTraceManager.OptionalLogTrace("[TestTrackingDataManager]Filtered Expected Trace (after applying tracking profile) = {0}", filteredExpectedTrace);
            TestTraceManager.OptionalLogTrace("[TestTrackingDataManager]Modified ActualTrace Trace = {0}", modifiedActualTrace);
            TestTraceManager.OptionalLogTrace("[TestTrackingDataManager]Invoking internally the trace validation...");

            ////if (!(TestProfileProvider.IsAllOrNullProfile(profileType) &&
            if (((participantType != TrackingParticipantType.SqlTrackingParticipant) &&
                 (participantType != TrackingParticipantType.ETWTrackingParticipant)))
            {
                modifiedActualTrace.Validate(filteredExpectedTrace, TestTraceManager.IsDefaultTrackingConfiguration);
            }

            //Log.TraceInternal("[TestTrackingDataManager]*****Validate method Succeeded...");
        }
        internal override bool NotifyTraces(ActualTrace instanceTraces)
        {
            // Dont want to modify the original numOccurances
            int countCopy = _numOccurences;

            foreach (IActualTraceStep step in instanceTraces.Steps)
            {
                if (step is WorkflowAbortedTrace)
                {
                    countCopy--;

                    // if this aborted is the last trace, we wont have a deleted
                    if (_waitingForDeleted && countCopy == 1)
                    {
                        countCopy--;
                    }

                    if (_expectedFinalState != WorkflowInstanceState.Aborted)
                    {
                        _error = string.Format("While waiting for a {0} trace, received an aborted trace - {1}", _expectedFinalState, ActualTracesAsString());
                    }
                }
                else if (step is WorkflowInstanceTrace)
                {
                    WorkflowInstanceTrace wit = (WorkflowInstanceTrace)step;

                    if (wit.InstanceStatus == WorkflowInstanceState.Deleted)
                    {
                        countCopy--;

                        // Deleted trace will always be last, if its not then this will hang, so instead complete it and throw exception
                        if (countCopy > 0)
                        {
                            _error    = string.Format("Received deleted trace, before the expected number of {0} - {1}.", _expectedFinalState, ActualTracesAsString());
                            countCopy = 0;
                        }
                    }
                    else if (wit.InstanceStatus == WorkflowInstanceState.Completed ||
                             wit.InstanceStatus == WorkflowInstanceState.Canceled ||
                             wit.InstanceStatus == WorkflowInstanceState.Terminated)
                    {
                        // reset error
                        countCopy--;

                        _error = (wit.InstanceStatus == _expectedFinalState) ? null :
                                 string.Format("While waiting for a {0} trace, received another terminal trace, {1} - {2}.",
                                               _expectedFinalState.ToString(), wit.InstanceStatus.ToString(), ActualTracesAsString());
                    }
                }
            }

            bool success = countCopy <= 0;

            if (success)
            {
                this.manualResetEvent.Set();
            }
            return(success);
        }
        private string ActualTracesAsString()
        {
            string      concatenatedSteps = string.Format("InstanceID {0} traces: ", _instanceId.ToString());
            ActualTrace actualTrace       = TestTraceManager.Instance.GetInstanceActualTrace(_instanceId);

            foreach (IActualTraceStep step in actualTrace.Steps)
            {
                concatenatedSteps = concatenatedSteps + "; " + step.ToString();
            }
            return(concatenatedSteps);
        }
        private void TrackCancelRequestedRecord(CancelRequestedRecord cancelRecord, ActualTrace _trace)
        {
            TestTraceManager.OptionalLogTrace("[InMemoryTrackingParticipant]cancelRequestedRecord.TargetName = {0}", cancelRecord.Child.Name);

            //this gets propogated twice by the product: ActivityStates.Fault information.
            {
                // WFCore - AT LEAST the DoWhile test cases that Cancel were failing because of these "extra"
                // Activity Canceled records in the trace. It's not clear if this is the right thing to do.
                //_trace.Add(new ActivityTrace(
                //    cancelRecord.Child.Name,
                //    (ActivityInstanceState)Enum.Parse(typeof(ActivityInstanceState), ActivityStates.Canceled)));
            }
        }
示例#9
0
        public ActualTrace GetInstanceActualTrace(Guid instanceId)
        {
            lock (_thisLock)
            {
                if (!_allTraces.TryGetValue(instanceId, out ActualTrace instanceTraces))
                {
                    instanceTraces = new ActualTrace();
                    _allTraces.Add(instanceId, instanceTraces);
                }

                return(instanceTraces);
            }
        }
        private void TrackFaultPropagationRecord(FaultPropagationRecord faultRecord, ActualTrace _trace)
        {
            string faultName = (faultRecord.FaultHandler == null) ? "<Unknown>" : faultRecord.FaultHandler.Name;

            TestTraceManager.OptionalLogTrace("[InMemoryTrackingParticipant]faultPropatationRecord.TargetName = {0}", faultName);
            //string status = "Faulted";

            // There is no Property called State in FaultPropagationRecord. Need to understand Fault propagation here
            //this gets propogated twice by the product: ActivityStates.Fault information.
            //if (faultRecord.State == ActivityStates.Schedule)
            //{
            //    _trace.Add(new ActivityTrace(
            //        faultName,
            //        (ActivityInstanceState)Enum.Parse(typeof(ActivityInstanceState), status)));
            //}
        }
示例#11
0
        public void AddTrace(Guid instanceId, IActualTraceStep trace)
        {
            if (trace == null)
            {
                throw new ArgumentNullException("trace");
            }

            //Log.TraceInternal("[TestTraceManager] " + instanceId + " - " + trace.ToString());

            lock (_thisLock)
            {
                ActualTrace instanceTraces = GetInstanceActualTrace(instanceId);
                instanceTraces.Add(trace);
                CheckSubscriptions(instanceId, instanceTraces);
            }
        }
        protected override void Track(TrackingRecord record, TimeSpan timeout)
        {
            try
            {
                TestTraceManager.OptionalLogTrace("[InMemoryTrackingParticipant]Track()::InMemory tracking participant = {0} ; Tracking record type = {1} ; Record Details = {2}", this.Name, record.GetType(), record.ToString());
                TestTraceManager.OptionalLogTrace("[InMemoryTrackingParticipant]TestTraceManager.IsDefaultTrackingConfiguration = {0}", TestTraceManager.IsDefaultTrackingConfiguration.ToString());
                bool IsPushDataToTraceManager = true;

                ActualTrace _trace = this.GetActualTrackingData(record.InstanceId);

                if (record is WorkflowInstanceRecord)
                {
                    TrackWorkflowInstanceRecord(record as WorkflowInstanceRecord, _trace);
                }
                else if (record is ActivityStateRecord)
                {
                    IsPushDataToTraceManager = TrackActivityStateRecord(record as ActivityStateRecord, _trace);
                }
                else if (record is ActivityScheduledRecord)
                {
                    TrackActivityScheduledRecord(record as ActivityScheduledRecord, _trace);
                }
                else if (record is BookmarkResumptionRecord)
                {
                    TrackBookmarkResumptionRecord(record as BookmarkResumptionRecord, _trace);
                }
                else if (record is CancelRequestedRecord)
                {
                    TrackCancelRequestedRecord(record as CancelRequestedRecord, _trace);
                }
                else if (record is FaultPropagationRecord)
                {
                    TrackFaultPropagationRecord(record as FaultPropagationRecord, _trace);
                }
                if (IsPushDataToTraceManager)
                {
                    PushDataToTraceManager(record);
                }
            }
            //This exception will be eaten by the product tracking code and not available for review
            //So the only chance we have to see it is if we log it.
            catch (Exception e)
            {
                //Log.WarnInternal("Exception thrown in Track() method\n" + e.ToString());
                throw;
            }
        }
        internal void ValidateTraces(ExpectedTrace expectedTrace, ActualTrace actualTrace)
        {
            //If no tracking participant tracks all events tracign validation will fail since it doesn't accoutn for the tracking profiles.
            //This is true ONLY for some trakcing test cases & not for runtime test cases which run with all tracking turned Off.
            //Hence we will not to tracing validation in this case & only do the tracking validation.
            //if (!TestTrackingDataManager.DoesAnyProfileTrackAllEvents(TestConfiguration.Current.TrackingServiceConfigurations))
            //{
            //    Log.TraceInternal("[TestTracingWatcher]No tracking participant tracks all events. Hece skipp tracing verification");
            //    return;
            //}

            foreach (TraceFilter filter in expectedTrace.Filters)
            {
                expectedTrace = filter.FilterExpectedTrace(expectedTrace);
                actualTrace   = filter.FilterActualTrace(actualTrace);
            }

            actualTrace.Validate(expectedTrace);
        }
        public Exception GetUnhandledException()
        {
            ActualTrace actualTrace = GetActualTrace();

            // Can shortcut in the workflowruntime case
            if (!IsHosted && _remoteworkflowRuntime.LastException != null)
            {
                return(_remoteworkflowRuntime.LastException);
            }

            foreach (IActualTraceStep traceStep in actualTrace.Steps)
            {
                if (traceStep is WorkflowExceptionTrace)
                {
                    return(((WorkflowExceptionTrace)traceStep).InstanceException);
                }
            }
            return(null);
        }
示例#15
0
        //for workflow tracking records not yet supported by testObjects.
        public static ActualTrace DeleteNotSupportedTraceSteps(ActualTrace actualTrace)
        {
            ActualTrace modifiedTrace = new ActualTrace(actualTrace);

            List <IActualTraceStep> stepsToBeRemoved = new List <IActualTraceStep>();

            foreach (IActualTraceStep actualTraceStep in modifiedTrace.Steps)
            {
                if (actualTraceStep is WorkflowInstanceTrace || actualTraceStep is BookmarkResumptionTrace)
                {
                    stepsToBeRemoved.Add(actualTraceStep);
                }
            }

            foreach (IActualTraceStep traceStepToBeRemoved in stepsToBeRemoved)
            {
                modifiedTrace.Steps.Remove(traceStepToBeRemoved);
            }

            return(modifiedTrace);
        }
示例#16
0
            internal virtual bool NotifyTraces(ActualTrace instanceTraces)
            {
                bool removeSubscription = false;

                int currentCount = this.count;

                foreach (IActualTraceStep step in instanceTraces.Steps)
                {
                    if (step.Equals(this.traceStep))
                    {
                        currentCount--;
                    }
                    if (currentCount == 0)
                    {
                        removeSubscription = true;
                        this.manualResetEvent.Set();
                        break;
                    }
                }

                return(removeSubscription);
            }
        public Exception GetAbortedReason()
        {
            ActualTrace actualTrace = GetActualTrace();

            // Can shortcut in the workflowruntime case
            if (!IsHosted && _remoteworkflowRuntime.LastException != null)
            {
                return(_remoteworkflowRuntime.LastException);
            }

            //With unhandled exceptions, the workflow running in standalone is aborted with AbortedTrace and it having the right exception message
            //But when hosted as a service, it gets the aborted trace with a generic system.exception message.
            //To make HostWFAsService compatible with WFRuntime, we should check for the WorkflowExceptionTrace instead of WorkflowAbortedTrace.

            foreach (IActualTraceStep traceStep in actualTrace.Steps)
            {
                if (traceStep is WorkflowAbortedTrace)
                {
                    return(((WorkflowAbortedTrace)traceStep).AbortedReason);
                }
            }

            return(null);
        }
        private void TrackWorkflowInstanceRecord(WorkflowInstanceRecord workflowInstanceRecord, ActualTrace _trace)
        {
            WorkflowInstanceState workflowInstanceState = (WorkflowInstanceState)Enum.Parse(typeof(WorkflowInstanceState), workflowInstanceRecord.State);
            WorkflowInstanceTrace workflowInstanceTrace = new WorkflowInstanceTrace(workflowInstanceRecord.InstanceId, workflowInstanceRecord.WorkflowDefinitionIdentity, workflowInstanceState);

            _trace.Add(workflowInstanceTrace);
        }
        private void TrackBookmarkResumptionRecord(BookmarkResumptionRecord bookmarkResumptionRecord, ActualTrace _trace)
        {
            TestTraceManager.OptionalLogTrace("[InMemoryTrackingParticipant]BookmarkName = {0}, bookmarkResumptionRecord = {1} ", bookmarkResumptionRecord.BookmarkName, bookmarkResumptionRecord.ToString());
            _trace.Add(new BookmarkResumptionTrace(
                           bookmarkResumptionRecord.BookmarkName,
                           bookmarkResumptionRecord.BookmarkScope,
                           bookmarkResumptionRecord.Owner.Name));

            //_trace.Add(new ActivityTrace(bookmarkResumptionRecord.ToString(),
            //    ActivityInstanceState.Executing));
        }
 private void TrackActivityScheduledRecord(ActivityScheduledRecord activityScheduledRecord, ActualTrace _trace)
 {
     //the scheduling record simply states that i am scheduled blah. Currently we do not have any support in TO for this.
     //Hence, turning it off for now. we will have the tracking tests cover the validation.
     TestTraceManager.OptionalLogTrace("[InMemoryTrackingParticipant]activityScheduledRecord.TargetName = {0}", activityScheduledRecord.Child.Name);
     _trace.Add(new ActivityTrace(activityScheduledRecord.Child.Name,
                                  ActivityInstanceState.Executing, activityScheduledRecord));
 }