public void PassingAdditionalOptionsToOverrideRunSettingsServerParamsPasses() { var context = new TestEnvironmentParameters { RS_BrowserName = "chrome", RS_ServerHost = "someHost", RS_ServerPort = "1234", RS_ServerResource = "/abd/def" }; DriverCapabilities cap = new DriverCapabilities(context); RunParameterUpdater options = new RunParameterUpdater(); options .Update(nameof(Constants.RS_ServerHost), Constants.RS_ServerHost) .Update(nameof(Constants.RS_ServerPort), Constants.RS_ServerPort) .Update(nameof(Constants.RS_ServerResource), Constants.RS_ServerResource); cap.OverrideRunSettingsParams(options); Assert.AreEqual(context.RS_ServerHost, Constants.RS_ServerHost, $"{nameof(Constants.RS_ServerHost)} should have been updated."); Assert.AreEqual(context.RS_ServerPort, Constants.RS_ServerPort, $"{nameof(Constants.RS_ServerPort)} should have been updated."); Assert.AreEqual(context.RS_ServerResource, Constants.RS_ServerResource, $"{nameof(Constants.RS_ServerResource)} should have been updated."); context.ServerUri = Helpers.CreateUri(context.RS_ServerHost, context.RS_ServerPort, context.RS_ServerResource); Assert.AreEqual(context.ServerUri.Host, Constants.RS_ServerHost, $"{nameof(context.ServerUri.Host)} should have been updated."); Assert.AreEqual(context.ServerUri.Port, Convert.ToInt32(Constants.RS_ServerPort), $"{nameof(context.ServerUri.Port)} should have been updated."); Assert.AreEqual(context.ServerUri.PathAndQuery, Constants.RS_ServerResource, $"{nameof(context.ServerUri.PathAndQuery)} should have been updated."); }
public void PassingAdditionalOptionsToOverrideRunSettingsDriverParamsPasses() { var context = new TestEnvironmentParameters { RS_BrowserName = "edge", RS_DeviceGroup = "edge;win10", RS_DriverServerExePath = "somePath", RS_ImplicitWaitTime = "100", RS_LocalExecution = true, RS_LocalExecutionAsService = true }; DriverCapabilities cap = new DriverCapabilities(context); RunParameterUpdater options = new RunParameterUpdater(); options.Update(nameof(Constants.RS_BrowserName), Constants.RS_BrowserName) .Update(nameof(Constants.RS_DeviceGroup), Constants.RS_DeviceGroup) .Update(nameof(Constants.RS_DriverServerExePath), Constants.RS_DriverServerExePath) .Update(nameof(Constants.RS_ImplicitWaitTime), Constants.RS_ImplicitWaitTime) .Update(nameof(Constants.RS_LocalExecution), Convert.ToBoolean(Constants.RS_LocalExecution)) .Update(nameof(Constants.RS_LocalExecutionAsService), Convert.ToBoolean(Constants.RS_LocalExecutionAsService)); cap.OverrideRunSettingsParams(options); Assert.AreEqual(context.RS_BrowserName, Constants.RS_BrowserName, $"{nameof(Constants.RS_BrowserName)} should have been updated."); Assert.AreEqual(context.RS_DeviceGroup, Constants.RS_DeviceGroup, $"{nameof(Constants.RS_DeviceGroup)} should have been updated."); Assert.AreEqual(context.RS_DriverServerExePath, Constants.RS_DriverServerExePath, $"{nameof(Constants.RS_DriverServerExePath)} should have been updated."); Assert.AreEqual(context.RS_ImplicitWaitTime, Constants.RS_ImplicitWaitTime, $"{nameof(Constants.RS_ImplicitWaitTime)} should have been updated."); Assert.AreEqual(context.RS_LocalExecution, Convert.ToBoolean(Constants.RS_LocalExecution), $"{nameof(Constants.RS_LocalExecution)} should have been updated."); Assert.AreEqual(context.RS_LocalExecutionAsService, Convert.ToBoolean(Constants.RS_LocalExecutionAsService), $"{nameof(Constants.RS_LocalExecutionAsService)} should have been updated."); }
public void SupplyingAcceptableCapabilitiesForDriverServiceLaunchesChromeBrowser() { TestEnvironmentParameters @params = new TestEnvironmentParameters() { RS_LocalExecution = true, RS_LocalExecutionAsService = true, RS_DriverServerExePath = TestContext.CurrentContext.TestDirectory, RS_BrowserName = "chrome", RS_ServerHost = "localhost", RS_ServerPort = "4278", RS_ImplicitWaitTime = "0" //Write unit test for testing empty properties }; DriverService.Start(@params); DriverCapabilities caps = new DriverCapabilities(@params); caps.GetDriverOptions <ChromeOptions>().AddArgument("--headless"); //Test this in unit test WebDriver.Initialize(caps); Assert.That(WebDriver.Instance != null, "Driver should have been instantiated successfully"); Assert.AreEqual("data:,", WebDriver.Instance.Url, "Empty url should have been opened"); WebDriver.Instance.Navigate().GoToUrl("https://google.com"); Assert.AreEqual("https://www.google.com/", WebDriver.Instance.Url, "Should have navigated to google.com"); WebDriver.Dispose(); DriverService.Dispose(); }
public void NoLocalExecutionSetShouldNotStartService() { TestEnvironmentParameters paramerters = new TestEnvironmentParameters { RS_LocalExecution = false }; DriverService.Start(paramerters); Assert.Null(paramerters.ServerUri, "Service should not be started when LocalExecution is not set."); }
public ServerCommandExecutor() : this(null, null) { //Check if the test context contains appropriate parameters, set them if true RemoteWebDriver driver = WebDriver.Instance; TestEnvironmentParameters parameters = WebTestContext.Get <TestEnvironmentParameters>(Constants.TestEnvironmentKey); Uri serverUri = parameters.ServerUri; sessionId = driver.SessionId; this.serverUri = serverUri; }
public void EmptyDeviceGroupParameterThrows() { TestEnvironmentParameters p = new TestEnvironmentParameters { RS_AppType = ApplicationType.HYBRID }; Assert.Throws <InvalidCapabilityException>(() => { DriverCapabilities caps = new DriverCapabilities(p); }, "DeviceGroup is a manadatory parameter and cannot be null or empty"); }
/// <summary> /// Initializes the Appium driver. Service can be set using .see AppiumServer /// for local execution and by setting the .seealso TestRunParameters.LocalExecution, /// nodeEXE and AppiumJS path in runsettings file. Set AppiumServerUri for grid or manual server test execution. /// To get the instance of the appropriate driver, use the .see "GetInstance" method /// </summary> /// <param name="capabilities">Capabilities expected of the driver</param> public static void Initialize(DriverCapabilities capabilities) { AppiumDriver <AppiumWebElement> instance; TestEnvironmentParameters TestRunParameters = capabilities.GetEnvironmentContext(); TimeSpan implicitWaitTimeSpan = TimeSpan.FromSeconds(Convert.ToInt32(TestRunParameters.RS_ImplicitWaitTime)); instance = InitializeDriver(capabilities); instance.Manage().Timeouts().ImplicitWait = implicitWaitTimeSpan; Instance = instance; }
public void AppiumServiceShouldNotStartIfLocalExecutionIsFalse() { TestEnvironmentParameters parameters = new TestEnvironmentParameters { RS_LocalExecution = "false", RS_LocalExecutionAsService = "true" }; AppiumServer.Start(parameters); Assert.False(MobileTestContext.ContainsKey(Constants.AppiumServiceKey), "Service should not have started"); }
public void NoBrowserNameShouldThrowOnLocalExecutionAsService() { TestEnvironmentParameters paramerters = new TestEnvironmentParameters { RS_LocalExecution = true, RS_LocalExecutionAsService = true, }; var exception = Assert.Catch <ArgumentNullException>(() => DriverService.Start(paramerters), "Service should not be started when browser name is not set."); Assert.That(exception.Message.Contains("RS_BrowserName"), Is.True, "Browser name exception should have been thrown."); }
public ServerCommandExecutor() : this(null, null) { //Check if the test context contains appropriate parameters, set them if true AppiumDriver <AppiumWebElement> driver = MobileTestContext.Get <AppiumDriver <AppiumWebElement> >(nameof(MobileDriver), false); TestEnvironmentParameters parameters = MobileTestContext.Get <TestEnvironmentParameters>(Constants.TestEnvironmentKey); Uri serverUri = parameters.ServerUri; this.sessionId = driver.SessionId; this.serverUri = serverUri; }
public void ProvidingDefaultOrNullSignInIdThrowsForIosNonWebApps() { TestEnvironmentParameters p = new TestEnvironmentParameters { RS_AppType = ApplicationType.HYBRID, RS_DeviceGroup = "iOS;Tablet" }; DriverCapabilities caps = new DriverCapabilities(p); Assert.Throws <InvalidCapabilityException>(() => caps.MergeCapabilities(new AdditionalDriverOptions()), "Providing null signIn capability should throw."); }
public void PassingIEBrowserNameCreatesIECapability() { TestEnvironmentParameters @params = new TestEnvironmentParameters() { RS_BrowserName = "ie" }; var cap = new DriverCapabilities(@params); Assert.NotNull(cap.GetDriverOptions <InternetExplorerOptions>(), "Should have created IE options."); Assert.Null(cap.GetDriverOptions <ChromeOptions>(), "Invalid option should not be resolved."); }
public void PassingValidBrowserPasses() { var context = new TestEnvironmentParameters { RS_BrowserName = "Chrome" }; Assert.DoesNotThrow(() => { DriverCapabilities cap = new DriverCapabilities(context); }, $"Valid browser should not throw"); }
public void PassingSafariBrowserNameCreatesSafariCapability() { TestEnvironmentParameters @params = new TestEnvironmentParameters() { RS_BrowserName = "safari" }; var cap = new DriverCapabilities(@params); Assert.NotNull(cap.GetDriverOptions <SafariOptions>(), "Should have created safari options."); Assert.Null(cap.GetDriverOptions <ChromeOptions>(), "Invalid option should not be resolved."); }
public void PassingCapabilityToIEPasses() { var context = new TestEnvironmentParameters { RS_BrowserName = "IE", ServerUri = Helpers.CreateUri("localhost", "1234", "/wd/hub/") }; DriverCapabilities cap = new DriverCapabilities(context); var c = cap.GetDriverOptions <InternetExplorerOptions>(); c.EnableNativeEvents = true; Assert.AreEqual(cap.GetDriverOptions <InternetExplorerOptions>().EnableNativeEvents, true, "Capabilitye should have been added for IEOptions"); }
public void NullBrowserNameOnOverridingShouldThrow() { TestEnvironmentParameters @params = new TestEnvironmentParameters() { RS_BrowserName = "chrome" }; var cap = new DriverCapabilities(@params); RunParameterUpdater opts = new RunParameterUpdater(); opts.Update(nameof(Constants.RS_BrowserName), ""); Assert.Throws <InvalidCapabilityException>(() => cap.MergeCapabilities(opts), "Should not be allowed to create instance if browser name is null or empty"); }
public void PassingCapabilityToEdgePasses() { var context = new TestEnvironmentParameters { RS_BrowserName = "edge", ServerUri = Helpers.CreateUri("localhost", "1234", "/wd/hub/") }; DriverCapabilities cap = new DriverCapabilities(context); var c = cap.GetDriverOptions <EdgeOptions>(); c.UseInPrivateBrowsing = true; Assert.AreEqual(cap.GetDriverOptions <EdgeOptions>().UseInPrivateBrowsing, true, "Capability should have been added/updated for Edge"); }
public void PassingCapabilityToChromePasses() { var context = new TestEnvironmentParameters { RS_BrowserName = "Chrome", ServerUri = Helpers.CreateUri("localhost", "1234", "/wd/hub/") }; DriverCapabilities cap = new DriverCapabilities(context); var c = cap.GetDriverOptions <ChromeOptions>(); c.PlatformName = "WIN10"; Assert.AreEqual(cap.GetDriverOptions <ChromeOptions>().PlatformName.ToUpper(), "WIN10", "Argument should have been added from Chrome"); }
public void PassingInvalidBrowserThrows() { var context = new TestEnvironmentParameters { RS_BrowserName = "blowfish" }; Assert.Throws <InvalidCapabilityException>(() => { DriverCapabilities cap = new DriverCapabilities(context); }, $" Browser {context.RS_BrowserName} is not supported"); }
public void NullServerHostOnOverridingShouldThrow() { TestEnvironmentParameters @params = new TestEnvironmentParameters() { RS_BrowserName = "chrome" }; var cap = new DriverCapabilities(@params); RunParameterUpdater opts = new RunParameterUpdater(); opts.Update(nameof(@params.ServerUri), null); Assert.Throws <ArgumentNullException>(() => cap.MergeCapabilities(opts), "Should not be allowed to create instance if host is null or empty"); }
public void PassingCapabilityToSafariPasses() { var context = new TestEnvironmentParameters { RS_BrowserName = "safari", ServerUri = Helpers.CreateUri("localhost", "1234", "/wd/hub/") }; DriverCapabilities cap = new DriverCapabilities(context); var c = cap.GetDriverOptions <SafariOptions>(); c.EnableAutomaticInspection = true; Assert.AreEqual(cap.GetDriverOptions <SafariOptions>().EnableAutomaticInspection, true, "Capability should have been added for Safari Options"); }
public void HostNameEmptyThrows() { TestEnvironmentParameters parameters = new TestEnvironmentParameters { RS_LocalExecution = "true", RS_LocalExecutionAsService = "true", RS_ServerHost = "", RS_NodeExePath = Constants.RS_NodeExePath, RS_AppiumJSPath = Constants.RS_AppiumJSPath }; Assert.Throws <ArgumentNullException>(() => AppiumServer.Start(parameters), "Empty Hostname should throw."); }
public void NoHostNameShouldThrowOnLocalExecutionAsService() { TestEnvironmentParameters paramerters = new TestEnvironmentParameters { RS_LocalExecution = true, RS_LocalExecutionAsService = true, RS_DriverServerExePath = "some random path", RS_BrowserName = "chrome" }; var exception = Assert.Catch <ArgumentNullException>(() => DriverService.Start(paramerters), "Service should not be started when LocalExecutionAsService is not set."); Assert.That(exception.Message.Contains("RS_ServerHost"), Is.True, "Host name exception should have been thrown."); }
public void TestSetup() { parameter = new TestEnvironmentParameters { RS_DriverServerExePath = Path.Combine(TestContext.CurrentContext.TestDirectory), RS_LocalExecution = true, RS_LocalExecutionAsService = true, RS_ServerHost = "localhost", RS_ServerResource = Constants.RS_ServerResource, RS_ServerPort = "5546", RS_ImplicitWaitTime = Constants.RS_ImplicitWaitTime, RS_BrowserName = "chrome" }; }
public void InvalidBrowserNameShouldThrowOnLocalExecutionAsService() { TestEnvironmentParameters paramerters = new TestEnvironmentParameters { RS_LocalExecution = true, RS_LocalExecutionAsService = true, RS_BrowserName = "Bionix", RS_DriverServerExePath = "Blah", RS_ServerHost = "Localhost", RS_ServerPort = "2334" }; var exception = Assert.Catch <DriverServiceException>(() => DriverService.Start(paramerters), "Service should not be started when invalid browser name is provided"); Assert.That(exception.Message.Contains("Bionix"), Is.True, "Browser name exception should have been thrown."); }
public void PassingArgumentToChromePasses() { var context = new TestEnvironmentParameters { RS_BrowserName = "Chrome", ServerUri = Helpers.CreateUri("localhost", "1234", "/wd/hub/") }; DriverCapabilities cap = new DriverCapabilities(context); RunParameterUpdater opt = new RunParameterUpdater(); string argumentToAdd = "--somerandomStuff"; cap.GetDriverOptions <ChromeOptions>().AddArgument(argumentToAdd); cap.MergeCapabilities(opt); Assert.True(cap.GetDriverOptions <ChromeOptions>().Arguments.IndexOf(argumentToAdd) > 0, "Argument should have been added"); }
public void SettingBrowserOptionForWebAppPassesPrereqChecksInIOS() { TestEnvironmentParameters p = new TestEnvironmentParameters { RS_AppType = ApplicationType.WEB, RS_BrowserName = MobileBrowserType.Safari, RS_DeviceGroup = "iOS;Tablet" }; DriverCapabilities caps = new DriverCapabilities(p); Dictionary <string, object> setOptions = caps.GetDriverOptions().ToDictionary(); Assert.NotNull(caps.GetDriverOptions(), "Options should be set."); Assert.AreEqual(MobileBrowserType.Safari, setOptions["browserName"], "Browser name should be set for web apps"); }
public void SettingDefaultAppPackageOnIOSThrows() { TestEnvironmentParameters p = new TestEnvironmentParameters { RS_AppType = ApplicationType.NATIVE, RS_DeviceGroup = "iOS;Tablet", RS_AppPackage = "io.android.testapp" }; DriverCapabilities caps = new DriverCapabilities(p); Dictionary <string, object> setOptions = caps.GetDriverOptions().ToDictionary(); Assert.NotNull(caps.GetDriverOptions(), "Options should be set."); Assert.Catch <InvalidCapabilityException>(() => caps.PreReqChecks(), "Invalid app name allowed to pass"); }
public void SettingDefaultAppActivityInHybridAppOnAndroidThrows() { TestEnvironmentParameters p = new TestEnvironmentParameters { RS_AppType = ApplicationType.NATIVE, RS_DeviceGroup = "Android;Tablet", RS_AppPackage = "some.random.app", RS_AppActivity = ".HomeScreenActivity" }; DriverCapabilities caps = new DriverCapabilities(p); Dictionary <string, object> setOptions = caps.GetDriverOptions().ToDictionary(); Assert.NotNull(caps.GetDriverOptions(), "Options should be set."); Assert.Catch <InvalidCapabilityException>(() => caps.PreReqChecks(), "Invalid app activity allowed to pass"); }
public void ProvidingBrowserNameAndNoAppPackageForHybridAppThrowsForAndroid() { TestEnvironmentParameters p = new TestEnvironmentParameters { RS_AppType = ApplicationType.HYBRID, RS_BrowserName = MobileBrowserType.Chrome, RS_DeviceGroup = "Android;Tablet", }; DriverCapabilities caps = new DriverCapabilities(p); Dictionary <string, object> setOptions = caps.GetDriverOptions().ToDictionary(); Assert.NotNull(caps.GetDriverOptions(), "Options should be set."); Assert.False(setOptions.ContainsKey("browserName"), "Browser name should be null for hybrid apps"); Assert.Throws <InvalidCapabilityException>(() => caps.PreReqChecks(), "Prereq checks should throw"); }