PageRenderTime 50ms CodeModel.GetById 25ms RepoModel.GetById 1ms app.codeStats 0ms

/Labs/Microsoft.Activities.Extensions/Microsoft.Activities.Extensions.Tests/StateMachineInfoTest.cs

#
C# | 177 lines | 115 code | 11 blank | 51 comment | 0 complexity | 7b809874a99d97f367b8662f2b13d644 MD5 | raw file
  1. namespace Microsoft.Activities.Extensions.Tests
  2. {
  3. using System;
  4. using System.Activities;
  5. using Microsoft.Activities.Extensions.Tracking;
  6. using Microsoft.Activities.UnitTesting;
  7. using Microsoft.VisualStudio.TestTools.UnitTesting;
  8. /// <summary>
  9. /// Tests the StateMachineInfo class
  10. /// </summary>
  11. [TestClass]
  12. public class StateMachineInfoTest
  13. {
  14. /// <summary>
  15. /// Given
  16. /// * A StateTracker
  17. /// * An activity with one state machine
  18. /// When
  19. /// * The activity is run until the state machine is complete
  20. /// Then
  21. /// * The InstanceState returns Closed
  22. /// </summary>
  23. [TestMethod]
  24. public void InstanceStateIsClosedWhenClosed()
  25. {
  26. // Arrange
  27. var activity = new StateMachineExample();
  28. var host = WorkflowApplicationTest.Create(activity);
  29. var tracker = new StateTracker();
  30. host.Extensions.Add(tracker);
  31. try
  32. {
  33. // Act
  34. host.TestWorkflowApplication.RunUntilBookmark();
  35. host.TestWorkflowApplication.ResumeUntilBookmark(StateTrigger.T1, 1, StateTrigger.T5);
  36. host.TestWorkflowApplication.ResumeUntilBookmark(StateTrigger.T5, 1);
  37. var stateMachineInfo = tracker.StateMachines[0];
  38. var actual = stateMachineInfo.InstanceState;
  39. // Assert
  40. Assert.AreEqual(ActivityInstanceState.Closed, actual);
  41. }
  42. catch (Exception exception)
  43. {
  44. exception.Trace();
  45. throw;
  46. }
  47. finally
  48. {
  49. tracker.Trace();
  50. host.Tracking.Trace();
  51. }
  52. }
  53. /// <summary>
  54. /// Given
  55. /// * A StateTracker
  56. /// * An activity with one state machine
  57. /// When
  58. /// * The activity is run
  59. /// Then
  60. /// * The InstanceState returns the instance state of the StateMachine
  61. /// </summary>
  62. [TestMethod]
  63. public void InstanceStateIsExecutingWhenExecuting()
  64. {
  65. // Arrange
  66. var activity = new StateMachineExample();
  67. var host = WorkflowApplicationTest.Create(activity);
  68. var tracker = new StateTracker();
  69. host.Extensions.Add(tracker);
  70. try
  71. {
  72. // Act
  73. host.TestWorkflowApplication.RunUntilBookmark();
  74. var stateMachineInfo = tracker.StateMachines[0];
  75. var actual = stateMachineInfo.InstanceState;
  76. // Assert
  77. Assert.AreEqual(ActivityInstanceState.Executing, actual);
  78. }
  79. catch (Exception exception)
  80. {
  81. exception.Trace();
  82. throw;
  83. }
  84. finally
  85. {
  86. tracker.Trace();
  87. host.Tracking.Trace();
  88. }
  89. }
  90. /// <summary>
  91. /// Given
  92. /// * A StateTracker
  93. /// * An activity with one state machine
  94. /// When
  95. /// * The activity is run until the state machine is complete
  96. /// Then
  97. /// * The InstanceState returns Faulted
  98. /// </summary>
  99. [TestMethod]
  100. public void InstanceStateIsFaultedWhenFaulted()
  101. {
  102. // Arrange
  103. var activity = StateTrackerTest.CreateStateMachineThatFaults();
  104. var host = WorkflowApplicationTest.Create(activity);
  105. var tracker = new StateTracker();
  106. host.Extensions.Add(tracker);
  107. try
  108. {
  109. // Act
  110. AssertHelper.Throws<InvalidOperationException>(() => host.TestWorkflowApplication.RunUntilBookmark());
  111. var stateMachineInfo = tracker.StateMachines[0];
  112. var actual = stateMachineInfo.InstanceState;
  113. // Assert
  114. Assert.AreEqual(ActivityInstanceState.Faulted, actual);
  115. }
  116. catch (Exception exception)
  117. {
  118. exception.Trace();
  119. throw;
  120. }
  121. finally
  122. {
  123. tracker.Trace();
  124. host.Tracking.Trace();
  125. }
  126. }
  127. /// <summary>
  128. /// Given
  129. /// * A StateTracker
  130. /// * An activity with one state machine
  131. /// When
  132. /// * The activity is run until the state machine is complete
  133. /// Then
  134. /// * The InstanceState returns Canceled
  135. /// </summary>
  136. [TestMethod]
  137. public void InstanceStateIsCanceledWhenCanceled()
  138. {
  139. // Arrange
  140. var activity = new StateMachineExample();
  141. var host = WorkflowApplicationTest.Create(activity);
  142. var tracker = new StateTracker();
  143. host.Extensions.Add(tracker);
  144. try
  145. {
  146. // Act
  147. host.TestWorkflowApplication.RunUntilBookmark();
  148. host.Cancel();
  149. var stateMachineInfo = tracker.StateMachines[0];
  150. var actual = stateMachineInfo.InstanceState;
  151. // Assert
  152. Assert.AreEqual(ActivityInstanceState.Canceled, actual);
  153. }
  154. catch (Exception exception)
  155. {
  156. exception.Trace();
  157. throw;
  158. }
  159. finally
  160. {
  161. tracker.Trace();
  162. host.Tracking.Trace();
  163. }
  164. }
  165. }
  166. }