public void Should_fail_to_get_unsupported_verb()
{
_routeConvention.Should().Throw <InvalidOperationException>(
x => x.GetRouteDescriptors(new RouteContext(ActionMethod
.From <VerbHandler>(h => h.NotASupportedVerb()))))
.Message.ShouldContainAll(typeof(VerbHandler).FullName,
nameof(VerbHandler.NotASupportedVerb));
}
public ActionParameter(ActionMethod action, ParameterDescriptor parameter)
{
Descriptor = parameter;
Name = parameter.Name;
IsParameter = true;
Action = action;
ParameterDescriptor = parameter;
TypeDescriptor = parameter?.ParameterType;
}
public void MultiMethodsTestInvalid2()
{
TypeDefinition <IMultiMethods1> typeDefinition =
new TypeDefinition <IMultiMethods1>(
ActionMethod.Create("Foo", (short value) => { }));
IMultiMethods1 instance = typeDefinition.Create();
instance.Foo(5);
}
public void Should_get_all_common_http_verbs(Expression <Action <VerbHandler> > action)
{
var descriptors = _routeConvention.GetRouteDescriptors(
new RouteContext(ActionMethod.From(action)));
descriptors.Count.ShouldEqual(1);
descriptors.First().Method.ShouldEqual(action.GetMethodInfo()
.Name.Replace("_Segment", "").ToUpper());
}
public void MultiMethodsTest2()
{
TypeDefinition <IMultiMethods1> typeDefinition =
new TypeDefinition <IMultiMethods1>(
ActionMethod.Create("Foo", (int a) => { }));
IMultiMethods1 instance = typeDefinition.Create();
instance.Foo(5);
}
public GatherVerb(string action = "", ActionMethod method = ActionMethod.POST, uint timeout = 5, char finishOnKey = '#', int numDigits = 1000)
: base(Verb.Gather)
{
this.Action = action;
this.Method = method;
this.Timeout = timeout;
this.FinishOnKey = finishOnKey;
this.NumDigits = numDigits;
}
/// <summary>
/// Adds a Redirect Element to the Response.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="method">The method.</param>
public TwiMLBuilder Redirect(string url, ActionMethod method = ActionMethod.POST)
{
return(AddVerb(Verb.Redirect,
url,
new
{
method = method
}));
}
private ActionDescriptor AddRoute(List <ActionDescriptor> actions, string route)
{
var descriptor = new ActionDescriptor(ActionMethod.From <Handler>(x => x.Get()),
new RouteDescriptor("GET", route, null, null, null, null),
null, null, null, null, null, null, new TypeCache());
actions.Add(descriptor);
return(descriptor);
}
public ActionParameter(ActionMethod action, PropertyDescriptor property)
{
Descriptor = property;
Name = property.Name;
IsProperty = true;
Action = action;
PropertyDescriptor = property;
TypeDescriptor = property?.PropertyType;
}
public void MultiMethodsTestInvalid1()
{
TypeDefinition <IMultiMethods1> typeDefinition =
TypeDefinition <IMultiMethods1> .Create(ActionMethod.Create("Foo", (string value) => { }));
IMultiMethods1 instance = typeDefinition.CreateNew();
instance.Foo(5);
}
protected virtual void ValidateUrlParameters(ActionMethod action,
List <UrlParameter> urlParameters)
{
if (urlParameters.Count(x => x.IsWildcard) > 1)
{
throw new InvalidOperationException("Multiple wildcard parameters found on " +
$"action {action.HandlerTypeDescriptor.FriendlyFullName}." +
$"{action.MethodDescriptor.FriendlyName}.");
}
}
private static void Add <T>(IList <string> source, ActionMethod action,
Func <T, string[]> items) where T : Attribute
{
var attribute = action.GetActionOrHandlerAttribute <T>();
if (attribute != null && items(attribute).Any())
{
source.AddRange(items(attribute));
}
}
public void Should_build_url(Expression <Action <UrlHandler> > action, string url)
{
var descriptors = _routeConvention.GetRouteDescriptors(
new RouteContext(ActionMethod.From(action)));
descriptors.Count.ShouldEqual(1);
var descriptor = descriptors.First();
descriptor.Url.ShouldEqual($"Unit/Routing/{url}".Trim('/'));
}
public void Setup()
{
_requestMessage = new HttpRequestMessage(HttpMethod.Post, "http://www.fark.com");
_requestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MimeTypes.ApplicationAtomXml));
_actionMethod = ActionMethod.From <Handler>(x => x.Post());
_urlTemplate = "http://www.fark.com/{fark}";
_actionDescriptor = new ActionDescriptor(_actionMethod,
new RouteDescriptor("POST", _urlTemplate, null, null, null, null),
null, null, null, null, null, null, null);
}
public void Should_fail_to_bind_parameter()
{
var action = ActionMethod.From <PropertyBinderHandler>(x => x.Action(null));
var parameter = action.MethodDescriptor.Parameters.First();
var actionParameter = new ActionParameter(action, parameter);
var model = new PropertyBinderHandler.Model();
actionParameter.Should().Throw <InvalidOperationException>(
x => x.BindProperty(model, "fark"));
}
public void Should_get_value_from_argument()
{
var action = ActionMethod.From <ArgumentHandler>(x => x.Action(null, null));
var parameter = action.MethodDescriptor.Parameters
.First(x => x.Name == "value");
var actionParameter = new ActionParameter(action, parameter);
var arguments = new object[] { null, "fark" };
actionParameter.GetArgument(arguments).ShouldEqual("fark");
}
public static IEnumerable <IRouteConvention> ThatApplyTo(
this IEnumerable <IRouteConvention> routeConventions,
ActionMethod actionMethod, Configuration configuration,
HttpConfiguration httpConfiguration)
{
return(configuration.RouteConventions
.ThatAppliesTo(routeConventions, new RouteConfigurationContext(
configuration, httpConfiguration, actionMethod),
new RouteContext(actionMethod)));
}
public void Should_override_no_response_code(
[Values(null, "fark")] string reasonPhrase)
{
_configuration.DefaultNoResponseReasonPhrase = reasonPhrase;
CreateStatus(ActionMethod.From <Handler>(x => x.OverrideCodePost()))
.SetStatus(CreateContext(ResponseState.NoResponse));
_response.StatusCode.ShouldEqual(HttpStatusCode.Created);
_response.ReasonPhrase.ShouldEqual(reasonPhrase ?? "Created");
}
public void Should_set_default_no_response_status(
[Values(null, "fark")] string reasonPhrase)
{
_configuration.DefaultNoResponseReasonPhrase = reasonPhrase;
CreateStatus(ActionMethod.From <Handler>(x => x.Post()))
.SetStatus(CreateContext(ResponseState.NoResponse));
_response.StatusCode.ShouldEqual(_configuration.DefaultNoResponseStatusCode);
_response.ReasonPhrase.ShouldEqual(reasonPhrase ?? "No Content");
}
public void Should_fail_if_multiple_wildcards_specified()
{
var action = ActionMethod.From <WildcardHandler>(t => t
.GetWildcardAttributeMultiple_Values1_Values2(null, null));
var message = _routeConvention.Should().Throw <InvalidOperationException>(x => x
.GetRouteDescriptors(
new RouteContext(action))).Message;
message.ShouldContain(action.MethodDescriptor.FriendlyName);
}
public void Should_return_null_if_property_argument_is_null()
{
var action = ActionMethod.From <ArgumentHandler>(x => x.Action(null, null));
var parameter = action.MethodDescriptor.Parameters
.First(x => x.Name == "value");
var property = parameter.ParameterType.Properties.First();
var actionParameter = new ActionParameter(action, parameter, property);
var arguments = new object[2];
actionParameter.GetArgument(arguments).ShouldBeNull();
}
public void Should_fail_to_bind_property_to_arguments()
{
var action = ActionMethod.From <ArgumentHandler>(x => x.Action(null, null));
var property = action.MethodDescriptor.Parameters
.First(x => x.Name == "model").ParameterType.Properties.First();
var actionParameter = new ActionParameter(action, property);
var arguments = new object[2];
actionParameter.Should().Throw <InvalidOperationException>(
x => x.BindArgument(arguments, "fark"));
}
public ValueMapperConfigurationContext(Configuration configuration,
HttpConfiguration httpConfiguration,
ActionMethod actionMethod, RouteDescriptor routeDescriptor,
ActionParameter parameter, object[] values)
: base(parameter, values)
{
Configuration = configuration;
HttpConfiguration = httpConfiguration;
Action = actionMethod;
Route = routeDescriptor;
}
/// <summary>
/// condition CANNOT be null!
/// </summary>
/// <param name="condition"></param>
/// <param name="action"></param>
public Coroutine(ConditionMethod condition, ActionMethod action)
: this()
{
if (condition == null)
{
throw new ArgumentNullException("condition");
}
ID = null;
Condition = condition;
Action = action;
}
public static List <Type> ThatApplyTo(this ConditionalPlugins
<IBehavior, ActionConfigurationContext> behaviors,
ActionMethod actionMethod, RouteDescriptor routeDescriptor,
Configuration configuration, HttpConfiguration httpConfiguration)
{
var context = new ActionConfigurationContext(configuration,
httpConfiguration, actionMethod, routeDescriptor);
return(behaviors.ThatApplyTo(context)
.Select(x => x.Type).ToList());
}
internal static void Invoke(object thisObject, ActionMethod method, object param)
{
if (param.GetType().IsArray)
{
method.MethodInfo.Invoke(thisObject, param.CastToType <object[]>());
}
else
{
Invoke(thisObject, method.Method, param);
}
}
private void RegisterController(Type type)
{
var query = from a in System.Attribute.GetCustomAttributes(type)
where a is attribute.Controller
select a.CastToType <attribute.Controller>();
attribute.Controller controlerAttribute = query.FirstOrDefault();
if (controlerAttribute.IsNotNull())
{
Controller controller = _controllers.FirstOrDefault(c => c.Name == controlerAttribute.ControllerName);
if (controller.IsNull() || controller.Object.IsNull())
{
type.GetMethods().AsEnumerable().Where(m => !m.IsConstructor && !m.IsGenericMethod && m.IsPublic &&
!m.IsStatic && m.IsVirtual).SelectMany(m => System.Attribute.GetCustomAttributes(m).Where(a => a.IsTypeOf <ActionMethod>()),
(m, a) => new { Method = m, Attribute = a.CastToType <ActionMethod>() }).
ToList().ForEach((ma) =>
{
ActionMethod action = ma.Attribute;
controller = controller.IfNullDefault <Controller>(() =>
{
Controller c = new Controller()
{
Name = controlerAttribute.ControllerName,
Type = type,
};
return(c);
});
AddActionMethod(controller, type, action.ActionName, ma.Method.Name, ma.Method);
});
if (controller.IsNotNull())
{
_controllers.AddIfNotContains(controller);
if (controller.Object.IsNull())
{
var options = new ProxyGenerationOptions(new ControllerInterceptorGenerationHook())
{
Selector = new ControllerInterceptorSelector()
};
controller.Object = _generator.CreateClassProxy(type, options, new ControllerInterceptor(controlerAttribute.ControllerName));
}
}
}
else
{
throw new ControllerRegistrationException(controlerAttribute.ControllerName + " already register ");
}
}
else
{
throw new ControllerRegistrationException("Type[" + type.FullName + "] it cann't be recognise as valid Controller. Controller Attribute on class level is required.");
}
}
public static string GetActionName( ActionMethod method )
{
string action_name = null;
if ( m_methods.Contains( method ) )
{
int index = m_methods.IndexOfValue( method );
action_name = (string)m_methods.GetKey(index);
}
return action_name;
}
public void Should_exclude_diagnostics_pages_if_configured(
[Values(true, false)] bool excludeDiagnostics)
{
var actionDescriptor = new ActionDescriptorFactory(_configuration, null, new TypeCache())
.CreateDescriptor(ActionMethod.From <GraphiteHandler>(x => x.Post()), null);
var behavior = new AuthenticationBehavior(_behaviorChain, _requestMessage,
_responseMessage, _authenticators, _configuration, actionDescriptor);
_configuration.ExcludeDiagnosticsFromAuthentication = excludeDiagnostics;
behavior.ShouldRun().ShouldEqual(!excludeDiagnostics);
}
public ParameterBinder(Configuration configuration,
HttpConfiguration httpConfiguration,
ActionMethod actionMethod,
RouteDescriptor routeDescriptor,
IEnumerable <IValueMapper> mappers)
{
_configuration = configuration;
_httpConfiguration = httpConfiguration;
_mappers = mappers;
_actionMethod = actionMethod;
_routeDescriptor = routeDescriptor;
}
public MethodAction(ActionMethod actionMethod)
: base()
{
m_actionMethod = actionMethod;
}
public OpenFile(ActionMethod method)
{
openfileAction = method;
}
public StopVirtualHardware(ActionMethod method)
{
stopVirtualHardwareAction = method;
}
/// <summary>
/// Adds a Gather Element with a nested Playing Element.
/// </summary>
/// <param name="fileUrl">The file URL.</param>
/// <param name="timesToLoop">The times to loop.</param>
/// <param name="actionUrl">The action URL.</param>
/// <param name="actionMethod">The action method.</param>
/// <param name="timeoutSeconds">The timeout seconds.</param>
/// <param name="keyThatFinishes">The key that finishes.</param>
/// <param name="numDigitsToCollect">The num digits to collect.</param>
public TwiMLBuilder GatherWhilePlaying(string fileUrl, uint timesToLoop = 1,
string actionUrl = "", ActionMethod actionMethod = ActionMethod.POST, uint timeoutSeconds = 5,
char keyThatFinishes = '#', uint numDigitsToCollect = 1000)
{
var playChild = Tuple.Create(Verb.Play,
fileUrl,
(object)new
{
loop = timesToLoop
});
return Gather(actionUrl, actionMethod, timeoutSeconds, keyThatFinishes, numDigitsToCollect, playChild);
}
/// -------------------------------------------------------------------
/// <summary>Helper: Press button</summary>
/// -------------------------------------------------------------------
void HelperPressButton(AutomationElement element, ActionMethod actionBY, CheckType checkType)
{
Library.ValidateArgumentNonNull(element, "Button AutomationElement");
string name = element.Current.Name;
switch (actionBY)
{
case ActionMethod.KeyPadOnly:
{
string buffer = element.Current.AccessKey;
if (!string.IsNullOrEmpty(buffer))
{
// There is an access key so use it
Comment("Pressing keyboard access key \"" + element.Current.AccessKey + "\"");
Input.SendKeyboardInput(element.Current.AccessKey);
}
else
{
// No access key so set focus and press enter
Comment("Setting focus to \"{0}\" and pressing ENTER", element.Current.Name);
element.SetFocus();
Input.SendKeyboardInput(System.Windows.Input.Key.Enter);
}
}
break;
case ActionMethod.MouseClick:
{
Comment("Moving mouse to \"" + element.Current.Name + "\" and left clicking");
Input.MoveToAndClick(element);
}
break;
default:
{
if (!(bool)element.GetCurrentPropertyValue(AutomationElement.IsInvokePatternAvailableProperty))
ThrowMe(checkType, "Button \"" + name + "\" does not support Invoke pattern");
Comment("Calling InvokePattern.Invoke() on \"" + name + "\"");
((InvokePattern)element.GetCurrentPattern(InvokePattern.Pattern)).Invoke();
}
break;
}
}
/// -------------------------------------------------------------------
/// <summary></summary>
/// -------------------------------------------------------------------
void TS_DialogAboutBoxOpen(ActionMethod actionMethod, CheckType checkType)
{
switch (actionMethod)
{
case ActionMethod.Menu:
{
Comment("Opening \"About dialog\" by clicking on the menu item");
HelperExpandMenuUsingAccessKey(MainForm.ApplicationMenuBar.HelpMenu.AutomationElement, checkType);
HelperInvokeMenuItemUsingAccessKey(MainForm.ApplicationMenuBar.HelpMenu.HelpAbout, CheckType.Verification);
}
break;
default:
ThrowMe(checkType, "Invalid argument");
break;
}
Wait(WaitForAboutBoxDialogToBeVisible, _WAIT_NORMAL_MILLISECONDS, checkType);
m_TestStep++;
}
/// -------------------------------------------------------------------
/// <summary></summary>
/// -----------------------`--------------------------------------------
private void TSM_MainDialogSettings(
ActionMethod actionMethod,
string keyName,
GetElement subMenu,
GetElement checkBox,
WaitTestState callbackCheckBoxIsChecked,
WaitTestState callbackCheckBoxIsUnChecked,
CheckType checkType)
{
// "Step: Toggle the \"\" menu",
TS_ToggleMainFormSettingsByMenu(
ActionMethod.Menu,
MainForm.ApplicationMenuBar.PreferencesMenu.AutomationElement,
subMenu,
callbackCheckBoxIsChecked, callbackCheckBoxIsUnChecked,
CheckType.Verification);
HelperPersistKeyNameValuesToTable(_keyNameValuesCurrent);
// "Step: Close Narrator",
TS_NarratorClose(ActionMethod.UIAutomation, true, CheckType.Verification);
// "Step: Restart Narrator",
TS_NarratorStart(WindowVisualState.Normal, CheckType.Verification);
// "Step: Verify current \"\" registry setting to previous runs value set",
// "Step: Verify current \"\" check box setting to previous runs value set",
// "Step: Verify the ToggleState of the sub menu",
TS3_VerifyMainFormSetting(keyName, checkBox, MainForm.ApplicationMenuBar.PreferencesMenu.AutomationElement, subMenu, CheckType.Verification);
}
/// <summary>
/// Adds a Dial and Number Element with the specified details.
/// </summary>
/// <param name="numberToDial">The number to dial.</param>
/// <param name="digitsToSendAfterConnect">The digits to send after connect.</param>
/// <param name="numberUrl">The number URL.</param>
/// <param name="actionUrl">The action URL.</param>
/// <param name="actionMethod">The action method.</param>
/// <param name="timeoutSeconds">The timeout seconds.</param>
/// <param name="hangupOnStar">if set to <c>true</c> [hangup on star].</param>
/// <param name="timeLimitMilliseconds">The time limit milliseconds.</param>
/// <param name="statusCallbackUrl">The status callback URL.</param>
/// <param name="callerIdNumber">The caller id number.</param>
/// <returns></returns>
public TwiMLBuilder DialNumber(string numberToDial, string digitsToSendAfterConnect = "", string numberUrl = "",
string actionUrl = "", ActionMethod actionMethod = ActionMethod.POST, uint timeoutSeconds = 30,
bool hangupOnStar = false, uint timeLimitMilliseconds = 14400,
string statusCallbackUrl = "", string callerIdNumber = "")
{
return AddVerb(Verb.Dial,
string.Empty,
new
{
action = actionUrl,
method = actionMethod,
timeout = timeoutSeconds,
hangupOnStar = hangupOnStar,
timeLimit = timeLimitMilliseconds,
callerId = callerIdNumber
},
Tuple.Create(Verb.Number, numberToDial, (object)new { sendDigits = digitsToSendAfterConnect, url = numberUrl }));
}
/// <summary>
/// Adds a Dial and Conference Element with the specified details.
/// </summary>
/// <param name="conferenceName">Name of the conference.</param>
/// <param name="participantMuted">if set to <c>true</c> [participant muted].</param>
/// <param name="beepOnEnterOrExit">if set to <c>true</c> [beep on enter or exit].</param>
/// <param name="startConferenceOnEnter">if set to <c>true</c> [start conference on enter].</param>
/// <param name="endConferenceOnExit">if set to <c>true</c> [end conference on exit].</param>
/// <param name="waitMusicUrl">The wait music URL.</param>
/// <param name="waitMusicMethod">The wait music method.</param>
/// <param name="maxParticipants">The max participants.</param>
/// <param name="actionUrl">The action URL.</param>
/// <param name="methodUrl">The method URL.</param>
/// <param name="timeoutSeconds">The timeout seconds.</param>
/// <param name="hangupOnStar">if set to <c>true</c> [hangup on star].</param>
/// <param name="timeLimitMilliseconds">The time limit milliseconds.</param>
/// <param name="statusCallbackUrl">The status callback URL.</param>
/// <param name="callerIdNumber">The caller id number.</param>
/// <param name="record">UNDOCUMENTED: Whether to record this conference or not.</param>
public TwiMLBuilder DialConference(string conferenceName, bool participantMuted = false, bool beepOnEnterOrExit = true, bool startConferenceOnEnter = true, bool endConferenceOnExit = false,
string waitMusicUrl = "", ActionMethod waitMusicMethod = ActionMethod.POST, uint maxParticipants = 40,
string actionUrl = "", ActionMethod methodUrl = ActionMethod.POST, uint timeoutSeconds = 30,
bool hangupOnStar = false, uint timeLimitMilliseconds = 14400,
string statusCallbackUrl = "", string callerIdNumber = "", bool? record = null)
{
return AddVerb(Verb.Dial,
string.Empty,
new
{
action = actionUrl,
method = methodUrl,
timeout = timeoutSeconds,
hangupOnStar = hangupOnStar,
timeLimit = timeLimitMilliseconds,
callerId = callerIdNumber
},
Tuple.Create(Verb.Conference,
conferenceName,
(object)new
{
muted = participantMuted,
beep = beepOnEnterOrExit,
startConferenceOnEnter = startConferenceOnEnter,
endConferenceOnExit = endConferenceOnExit,
waitUrl = waitMusicUrl,
waitMethod = waitMusicMethod,
record = record
})
);
}
/// <summary>
/// Adds an Sms Element with the specified details.
/// </summary>
/// <param name="messageText">The message text.</param>
/// <param name="toNumber">To number.</param>
/// <param name="fromNumber">From number.</param>
/// <param name="actionUrl">The action URL.</param>
/// <param name="actionMethod">The action method.</param>
public TwiMLBuilder Sms(string messageText, string toNumber = "", string fromNumber = "",
string actionUrl = "", ActionMethod actionMethod = ActionMethod.POST)
{
return AddVerb(Verb.Sms,
messageText,
new
{
to = toNumber,
from = fromNumber,
action = actionUrl,
method = actionMethod,
});
}
/// <summary>
/// Adds a Redirect Element to the Response.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="method">The method.</param>
public TwiMLBuilder Redirect(string url, ActionMethod method = ActionMethod.POST)
{
return AddVerb(Verb.Redirect,
url,
new
{
method = method
});
}
/// <summary>
/// Adds a Record Element with the specified details.
/// </summary>
/// <param name="actionUrl">The action URL.</param>
/// <param name="actionMethod">The action method.</param>
/// <param name="timeoutSeconds">The timeout seconds.</param>
/// <param name="keyThatFinishes">The key that finishes.</param>
/// <param name="maxLengthMilliseconds">The max length milliseconds.</param>
/// <param name="transcribeAudio">if set to <c>true</c> [transcribe audio].</param>
/// <param name="transcribeCallbackUrl">The transcribe callback URL.</param>
/// <param name="playBeepBeforeStart">if set to <c>true</c> [play beep before start].</param>
public TwiMLBuilder Record(string actionUrl = "", ActionMethod actionMethod = ActionMethod.POST, uint timeoutSeconds = 5,
char keyThatFinishes = '#', uint maxLengthMilliseconds = 3600,
bool transcribeAudio = false, string transcribeCallbackUrl = "", bool playBeepBeforeStart = true)
{
return AddVerb(Verb.Record,
string.Empty,
new
{
action = actionUrl,
method = actionMethod,
timeout = timeoutSeconds,
finishOnKey = keyThatFinishes,
maxLength = maxLengthMilliseconds,
transcribe = transcribeAudio,
transcribeCallback = transcribeCallbackUrl,
playBeep = playBeepBeforeStart
});
}
/// <summary>
/// Adds a Gather element with a nested say element.
/// </summary>
/// <param name="textToSay">The text to say.</param>
/// <param name="actionUrl">The action URL.</param>
/// <param name="actionMethod">The action method.</param>
/// <param name="timeoutSeconds">The timeout seconds.</param>
/// <param name="keyThatFinishes">The key that finishes.</param>
/// <param name="numDigitsToCollect">The num digits to collect.</param>
public TwiMLBuilder GatherWhileSaying(string textToSay, SayVoice voiceSex = SayVoice.man, SayLanguage voiceLanguage = SayLanguage.en, int loopTimes = 1,
string actionUrl = "", ActionMethod actionMethod = ActionMethod.POST, uint timeoutSeconds = 5,
char keyThatFinishes = '#', uint numDigitsToCollect = 1000)
{
var textChild = Tuple.Create(Verb.Say, textToSay,
(object)new
{
voice = voiceSex,
language = voiceLanguage,
loop = loopTimes
});
return Gather(actionUrl, actionMethod, timeoutSeconds, keyThatFinishes, numDigitsToCollect, textChild);
}
protected CollectionDefinition(Type collectionType, Type itemType, ActionMethod addMethod)
: base(collectionType, itemType)
{
adder = addMethod;
}
/// -------------------------------------------------------------------
/// <summary></summary>
/// -------------------------------------------------------------------
private void TS_ToggleMainFormSettingsByMenu(
ActionMethod actionMethod,
AutomationElement menu,
GetElement subMenu,
WaitTestState checkBoxOnCallBack,
WaitTestState checkBoxOffCallBack,
CheckType checkType)
{
switch (actionMethod)
{
case ActionMethod.Menu:
{
HelperExpandMenuUsingAccessKey(menu, checkType);
AutomationElement subMenuItem = subMenu();
ToggleState ts = GetMenuToggleState(subMenuItem);
HelperInvokeMenuItemUsingAccessKey(subMenuItem, CheckType.Verification);
if (ts == ToggleState.Off)
Wait(checkBoxOnCallBack, _WAIT_NORMAL_MILLISECONDS, checkType);
else
Wait(checkBoxOffCallBack, _WAIT_NORMAL_MILLISECONDS, checkType);
}
break;
default:
throw new ArgumentException();
}
m_TestStep++;
}
public MethodAction(ActionMethod actionMethod, bool loop)
: base()
{
m_loop = loop;
m_actionMethod = actionMethod;
}
/// -------------------------------------------------------------------
/// <summary>Test step: Close Narrator</summary>
/// -------------------------------------------------------------------
void TS_NarratorClose(ActionMethod actionMethod, bool pressYes, CheckType checkType)
{
HelperCloseAllDialogs();
// "Step: Start closing Narrator, which will open the \"Do you want to exit Narrator\" dialog",
HelperCloseNarrator(actionMethod, pressYes, checkType);
m_TestStep++;
}
/// -------------------------------------------------------------------
/// <summary>Test step: Close the application by calling WindowPattern.Close()</summary>
/// -------------------------------------------------------------------
void HelperCloseNarrator(ActionMethod actionMethod, bool pressYes, CheckType checkType)
{
AutomationElement narrator = MainForm.AutomationElement;
if (null == narrator)
return;
switch (actionMethod)
{
case ActionMethod.UIAutomation:
{
Comment("Closing \"" + narrator.Current.Name + "\" window using WindowPattern.Close()");
if (!(bool)narrator.GetCurrentPropertyValue(AutomationElement.IsWindowPatternAvailableProperty))
ThrowMe(checkType, "\"" + narrator.Current.Name + "\" window does not support WindowPatternAvailableProperty and should");
((WindowPattern)narrator.GetCurrentPattern(WindowPattern.Pattern)).Close();
}
break;
case ActionMethod.KeyPadOnly:
{
Comment("Closing \"" + narrator.Current.Name + "\" by pressing \"Close\" button");
HelperPressButton(MainForm.ButtonExit, ActionMethod.KeyPadOnly, checkType);
}
break;
case ActionMethod.CloseXButton:
{
Comment("Closing \"" + narrator.Current.Name + "\" by pressing \"Alt+F4\" button");
HelperPressButton(MainForm.TitleBar.ButtonClose, ActionMethod.MouseClick, checkType);
}
break;
case ActionMethod.KillProcess:
{
Comment("Closing \"" + narrator.Current.Name + "\" by call Process.Kill()");
try
{
Process.GetProcessesByName("Narrator")[0].Kill();
}
catch (IndexOutOfRangeException)
{
// There is no process with that name so referencing [0] is invalid
}
}
break;
case ActionMethod.AltF4:
{
Comment("Closing \"" + narrator.Current.Name + "\" by pressing \"Alt+F4\" button");
Input.SendKeyboardInput(System.Windows.Input.Key.LeftAlt, true);
Input.SendKeyboardInput(System.Windows.Input.Key.F4, true);
Input.SendKeyboardInput(System.Windows.Input.Key.F4, false);
Input.SendKeyboardInput(System.Windows.Input.Key.LeftAlt, false);
}
break;
default:
ThrowMe(CheckType.Verification, "Incorrect argument");
break;
}
if (actionMethod != ActionMethod.KillProcess)
{
Wait(WaitForExitDialogToBeVisible, _WAIT_NORMAL_MILLISECONDS, checkType);
HelperCloseExitDialog(ActionMethod.KeyPadOnly, pressYes, checkType);
}
// If we closed it, then wait till everything is closed down
if (pressYes || actionMethod == ActionMethod.KillProcess)
{
Wait(WaitForNarratorToBeNotVisible, _WAIT_NORMAL_MILLISECONDS, checkType);
Wait(WaitForNarratorProcessToCeaseToExists, _WAIT_STARTUP_MILLISECONDS, checkType);
}
else
{
// nop, we cancelled the dialog
}
}
/// -------------------------------------------------------------------
/// <summary></summary>
/// -------------------------------------------------------------------
void TS_HelpDocumentOpen(ActionMethod actionMethod, CheckType checkType)
{
switch (actionMethod)
{
case ActionMethod.Menu:
{
Comment("Opening \"Help Document\" by clicking on the menu item");
HelperExpandMenuUsingAccessKey(MainForm.ApplicationMenuBar.HelpMenu.AutomationElement, checkType);
HelperInvokeMenuItemUsingAccessKey(MainForm.ApplicationMenuBar.HelpMenu.Documentation, CheckType.Verification);
}
break;
case ActionMethod.F1:
{
Comment("Opening \"Help Document\" by pressing F1");
Input.SendKeyboardInput(System.Windows.Input.Key.F1, true);
Input.SendKeyboardInput(System.Windows.Input.Key.F1, false);
}
break;
default:
ThrowMe(checkType, "Invalid argument");
break;
}
Wait(WaitForHelpDocumentDialogToBeVisible, _WAIT_NORMAL_MILLISECONDS, checkType);
m_TestStep++;
}
protected CollectionDefinition(Type collectionType, Type itemType, ActionMethod addMethod)
: base(collectionType, itemType)
{
_adder = addMethod;
_concreteListType = typeof(List<>).MakeGenericType(itemType);
}
/// -------------------------------------------------------------------
/// <summary>Test step: Close Exit dialog</summary>
/// -------------------------------------------------------------------
private void HelperCloseExitDialog(ActionMethod actionMethod, bool pressYes, CheckType checkType)
{
if (pressYes)
{
// Step: Press the Yes button
HelperPressButton(MainForm.DialogExit.ButtonYes, actionMethod, CheckType.Verification);
}
else
{
// Step: Press the No button
HelperPressButton(MainForm.DialogExit.ButtonNo, actionMethod, CheckType.Verification);
}
// Wait for the dialog to go away
Wait(WaitForExitDialogToBeNotVisible, _WAIT_NORMAL_MILLISECONDS, checkType);
}
/// <summary>
/// Adds a Gather Element to the response.
/// </summary>
/// <param name="actionUrl">The action URL.</param>
/// <param name="actionMethod">The action method.</param>
/// <param name="timeoutSeconds">The timeout seconds.</param>
/// <param name="keyThatFinishes">The key that finishes collection.</param>
/// <param name="numDigitsToCollect">The num digits to collect.</param>
/// <param name="children">The children of this element (Can be Say or Play Elements).</param>
public TwiMLBuilder Gather(string actionUrl = "", ActionMethod actionMethod = ActionMethod.POST, uint timeoutSeconds = 5,
char keyThatFinishes = '#', uint numDigitsToCollect = 1000, params Tuple<Verb, string, object>[] children)
{
var validChildren = new Tuple<Verb, string, object>[] { };
if (children != null)
validChildren = children.Where(x => x.Item1 == Verb.Say || x.Item1 == Verb.Play).ToArray();
return AddVerb(Verb.Gather,
string.Empty,
new
{
action = actionUrl,
method = actionMethod,
timeout = timeoutSeconds,
finishOnKey = keyThatFinishes,
numDigits = numDigitsToCollect
}, validChildren);
}
private DictionaryDefinition(Type collectionType, Type keyType, Type valueType, ActionMethod addMethod)
: base(collectionType, typeof(KeyValuePair<,>).MakeGenericType(keyType, valueType), addMethod)
{
_concreteDictionaryType = typeof(Dictionary<,>).MakeGenericType(keyType, valueType);
}
public Transition(ActionMethod actionMethod, State nextState)
{
this.ActionMethod = actionMethod;
this.NextState = nextState;
}
