public void CloneWithDefaults()
{
var settings = new TestSettings();
var clonedSettings = settings.Clone();
Assert.Null(clonedSettings.CallSettings);
Assert.Null(clonedSettings.Clock);
Assert.Equal(settings.UserAgent, clonedSettings.UserAgent);
}
public void TestInflator()
{
var handler = new EasySettingsHandler();
var testSettings = new TestSettings();
var result = handler.InflateSettingsViewModel(new SettingsClassHelper(testSettings));
Assert.AreEqual(5, result.Count());
//TODO: assure the viewmodel are the same
}
public void Bob()
{
var settings = new TestSettings();
settings.Bob = "dru";
settings.Environment = "PROD";
HUB.Settings = settings;
_proto = new ProtoCopyFileTask(new DotNetPath(), "C:\\from\\here");
_proto.ToDirectory("C:\\to\\there\\{{Environment}}");
_serv = new DeploymentServer("bob");
_proto.RegisterRealTasks(_serv);
}
public void MethodArgumentsTest()
{
var provider = new SettingsProvider();
var settings = new TestSettings() { Test = "Test1" };
AssertHelper.ExpectedException<ArgumentNullException>(() => provider.SaveSettings(testSettingsPath, null));
AssertHelper.ExpectedException<ArgumentException>(() => provider.SaveSettings(null, settings));
AssertHelper.ExpectedException<ArgumentException>(() => provider.SaveSettings("MockSettings.xml", settings));
AssertHelper.ExpectedException<ArgumentException>(() => provider.LoadSettings<TestSettings>(null));
AssertHelper.ExpectedException<ArgumentException>(() => provider.LoadSettings<TestSettings>("MockSettings.xml"));
}
public void ShareKcy()
{
var settings = new TestSettings();
var kcyConnector = new KarmakracyConnector(settings);
var keyExtractor = new KeyWordExtractor();
var kcyService = new KarmakracyService(kcyConnector, keyExtractor);
string kcy = kcyService.Short("http://www.katayunos.com");
kcyService.Share("Hola Katayuners", kcy);
}
public void Test_SettingsBase()
{
string directoryPath = "Test_SettingsBase";
TestSettings testSettings = new TestSettings();
testSettings.Text = "test";
testSettings.Save(directoryPath);
testSettings.Text = "";
testSettings.Load(directoryPath);
Assert.AreEqual(testSettings.Text, "test", "SettingsBase");
Directory.Delete("Test_SettingsBase", true);
}
private static string GetKey(string propertyName, string attributeMemberName)
{
var test = new TestSettings();
var defaultProperty = test.GetType().GetProperty(propertyName);
var appSettingAttribute = defaultProperty.CustomAttributes
.Where(a => a.AttributeType == typeof(AppSettingAttribute))
.FirstOrDefault();
var nameArgument = appSettingAttribute.NamedArguments
.Where(arg => arg.MemberName == attributeMemberName)
.FirstOrDefault();
return nameArgument.TypedValue.Value != null ?
nameArgument.TypedValue.Value.ToString() :
null;
}
public void BasicSaveAndLoadTest()
{
var provider = new SettingsProvider();
var defaultSettings = provider.LoadSettings<TestSettings>(testSettingsPath);
Assert.AreEqual("Default", defaultSettings.Test);
var settings1 = new TestSettings() { Test = "Test1" };
provider.SaveSettings(testSettingsPath, settings1);
var settings2 = provider.LoadSettings<TestSettings>(testSettingsPath);
Assert.AreNotEqual(settings1, settings2);
Assert.AreEqual(settings1.Test, settings2.Test);
}
protected listener_test_base(
TestSettings settings = null)
{
Settings = settings ?? new TestSettings();
var ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
_ipAddress = ipHostInfo.AddressList[1];
_manager = new BufferManager(Settings.MaxConnections, Settings.BufferSize);
var workerFactory = new WorkerManager(_manager, Settings.Timeout, null);
_listener = new Listener(
new ListenerSettings(_ipAddress, ++_port),
s => workerFactory.Get(new WorkerSocket(s)));
_listener.Start();
}
public void Clone()
{
var clock = new Mock<IClock>();
var callSettings = new CallSettings(new CancellationTokenSource().Token, null, null, null, null, null);
var settings = new TestSettings
{
CallSettings = callSettings,
Clock = clock.Object,
};
var clonedSettings = settings.Clone();
Assert.NotSame(settings, clonedSettings);
// CallSettings is immutable, so just a reference copy is fine.
Assert.Same(callSettings, clonedSettings.CallSettings);
Assert.Equal(settings.UserAgent, clonedSettings.UserAgent);
Assert.Equal(clock.Object, clonedSettings.Clock);
}
public ClientResult(int allBalls, int clientBalls, TestSettings settings)
{
this.ClientBalls = clientBalls;
this.AllBalls = allBalls;
this.Percent = ((float)this.ClientBalls)/((float)this.AllBalls) * 100;
if (this.Percent >= 0 && this.Percent < (float)settings.Min3) { this.Mark = 2; }
if (this.Percent >= (float)settings.Min3 && this.Percent < (float)settings.Min4) { this.Mark = 3; }
if (this.Percent >= (float)settings.Min4 && this.Percent < (float)settings.Min5) { this.Mark = 4; }
if (this.Percent >= (float)settings.Min5 && this.Percent <= 100) { this.Mark = 5; }
if (this.Percent > 100)
{
this.Mark = 5;
}
}
static void Main(string[] args)
{
var handled = false;
var showHelp = false;
var settings = new TestSettings();
var p = new OptionSet
{
{ "u|url=", "Url to generate results from", value => { handled = true; settings.Url = value; } },
{ "l|location=", "Location to run tests from [optional]", value => { settings.TestLocation = value; } },
{ "b|browser=", "Browser to test with (Default=chrome) [optional]", value => { settings.Browser = value; } },
{ "s|speed=", "Connections speed [optional]", value => { settings.Speed = value; } },
{ "p|private", "Keep test results private [optional]", _ => { settings.IsPrivate = true; } },
{ "t|timeout=", "Timeout, in seconds, while waiting for results (Default=300) [optional]", (int value) => { settings.Timeout = value; } },
{ "username="******"Username for HTTP Basic Authentication [optional]", value => { settings.Username = value; } },
{ "password="******"Password for HTTP Basic Authentication [optional]", value => { settings.Password = value; } },
{ "prefix=", "Prefix to use for metric names [optional]", value => { handled = true; settings.Prefix = value; } },
{ "h|?|help", "Show this message", x => showHelp = true }
};
try
{
p.Parse(args);
if (!handled || showHelp)
{
Console.WriteLine("Usage: WebpageTestReporter [OPTIONS]");
Console.WriteLine("Options:");
p.WriteOptionDescriptions(Console.Out);
}
else
{
RunPageTest(settings);
}
}
catch (OptionException ex)
{
Console.Write("Error: ");
Console.WriteLine(ex.Message);
Console.WriteLine("Try 'WebpageTestReporter --help' for more information.");
}
}
public void Can_List_Fingerprint_Templates()
{
using (var client = TestSettings.Connect())
using (var p = client.Terminal.Programming())
{
// Arrange
p.Fingerprint.DeleteAllTemplates();
p.Fingerprint.PutTemplate(1, TestTemplate.Data);
p.Fingerprint.PutTemplate(1, TestTemplate.Data);
p.Fingerprint.PutTemplate(2, TestTemplate.Data);
// Act
var list = p.Fingerprint.ListTemplates();
// Assert
Assert.AreEqual(2, list.Count);
Assert.IsTrue(list.ContainsKey(1));
Assert.IsTrue(list.ContainsKey(2));
Assert.AreEqual(2, list[1]);
Assert.AreEqual(1, list[2]);
}
}
public async Task OnRedirectToIdentityProviderEventCanSetState(string userState)
{
var stateFormat = new PropertiesDataFormat(new EphemeralDataProtectionProvider(NullLoggerFactory.Instance).CreateProtector("OIDCTest"));
var settings = new TestSettings(opt =>
{
opt.StateDataFormat = stateFormat;
opt.ClientId = "Test Id";
opt.Authority = TestServerBuilder.DefaultAuthority;
opt.Events = new OpenIdConnectEvents()
{
OnRedirectToIdentityProvider = context =>
{
context.ProtocolMessage.State = userState;
return(Task.FromResult(0));
}
};
});
var server = settings.CreateTestServer();
var transaction = await server.SendAsync(ChallengeEndpoint);
var res = transaction.Response;
Assert.Equal(HttpStatusCode.Redirect, res.StatusCode);
Assert.NotNull(res.Headers.Location);
var values = settings.ValidateChallengeRedirect(res.Headers.Location);
var actualState = values[OpenIdConnectParameterNames.State];
var actualProperties = stateFormat.Unprotect(actualState);
if (userState != null)
{
Assert.Equal(userState, actualProperties.Items[OpenIdConnectDefaults.UserstatePropertiesKey]);
}
else
{
Assert.False(actualProperties.Items.ContainsKey(OpenIdConnectDefaults.UserstatePropertiesKey));
}
}
public async Task OnRedirectToIdentityProviderEventCanReplaceValues()
{
var newClientId = Guid.NewGuid().ToString();
var settings = new TestSettings(
opts =>
{
opts.ClientId = "Test Id";
opts.Authority = TestServerBuilder.DefaultAuthority;
opts.Events = new OpenIdConnectEvents()
{
OnRedirectToIdentityProvider = context =>
{
context.ProtocolMessage.ClientId = newClientId;
return(Task.FromResult(0));
}
};
}
);
var server = settings.CreateTestServer();
var transaction = await server.SendAsync(ChallengeEndpoint);
var res = transaction.Response;
Assert.Equal(HttpStatusCode.Redirect, res.StatusCode);
Assert.NotNull(res.Headers.Location);
settings.ValidateChallengeRedirect(
res.Headers.Location,
OpenIdConnectParameterNames.ResponseType,
OpenIdConnectParameterNames.ResponseMode,
OpenIdConnectParameterNames.Scope,
OpenIdConnectParameterNames.RedirectUri);
var actual = res.Headers.Location.Query.Trim('?').Split('&').Single(seg => seg.StartsWith($"{OpenIdConnectParameterNames.ClientId}=", StringComparison.Ordinal));
Assert.Equal($"{OpenIdConnectParameterNames.ClientId}={newClientId}", actual);
}
public async void MakeRequestForFitbitIntradayHeartRate()
{
var credentials = TestSettings.GetToken <Fitbit, OAuth2Credentials>();
if (credentials.IsTokenExpired)
{
throw new Exception("Expired credentials!!!");
}
var request = new FitbitIntradayHeartRate()
{
Startdate = DateTime.Today,
Enddate = DateTime.Today,
Starttime = DateTime.Now.Subtract(TimeSpan.FromHours(5)),
Endtime = DateTime.Now
};
var response = await new OAuthRequester(credentials)
.MakeOAuthRequestAsync <FitbitIntradayHeartRate, string>(request)
.ConfigureAwait(false);
Assert.NotNull(response);
}
public void CanCrawlPopulatedTableWithEventTable()
{
var settings = new TestSettings();
var db = new TestDatabase(settings, new PopulatedTable(), new PopulatedEventTable());
db.Setup();
try
{
var connector = CreateConnector();
connector.ResetConnector("CrawlPopulatedTableWithEventTable");
var configuration = GetTestConfiguration(
"CrawlPopulatedTableWithEventTable",
settings.TestSqlDatabaseConnection.ToString(),
PopulatedTable.TableName,
new List <TableDetail>(),
new List <EventTable>()
{
new EventTable()
{
EventSequenceColumnName = "Id",
MainTableIdColumnName = "Name",
EventTypeColumnName = PopulatedEventTable.EventTypeColumnName,
DeleteEventTypeValue = "delete",
TableName = PopulatedEventTable.TableName
}
});
var sourceChanges = connector.ExecuteFetch(configuration);
sourceChanges.Adds.Count.Should().Be(2);
sourceChanges = connector.ExecuteFetch(configuration);
sourceChanges.Adds.Count.Should().Be(0);
sourceChanges.Deletes.Count.Should().Be(0);
}
finally
{
db.Destroy();
}
}
public void UCITestUpdateActiveOpportunity()
{
var client = new WebClient(TestSettings.Options);
using (var xrmApp = new XrmApp(client))
{
xrmApp.OnlineLogin.Login(_xrmUri, _username, _password, _mfaSecretKey);
xrmApp.Navigation.OpenApp(UCIAppName.Sales);
xrmApp.Navigation.OpenSubArea("Sales", "Opportunities");
xrmApp.Grid.SwitchView("Open Opportunities");
xrmApp.Grid.OpenRecord(0);
xrmApp.ThinkTime(3000);
xrmApp.Entity.SetValue("name", TestSettings.GetRandomString(10, 15));
xrmApp.Entity.Save();
}
}
public async Task RemoteSignOut_WithInvalidIssuer()
{
var settings = new TestSettings(o =>
{
o.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
o.Authority = TestServerBuilder.DefaultAuthority;
o.ClientId = "Test Id";
});
var server = settings.CreateTestServer(handler: async context =>
{
var claimsIdentity = new ClaimsIdentity("Cookies");
claimsIdentity.AddClaim(new Claim("iss", "test"));
await context.SignInAsync(new ClaimsPrincipal(claimsIdentity));
});
var signInTransaction = await server.SendAsync(DefaultHost);
var remoteSignOutTransaction = await server.SendAsync(DefaultHost + "/signout-oidc?iss=invalid", signInTransaction.AuthenticationCookieValue);
Assert.Equal(HttpStatusCode.OK, remoteSignOutTransaction.Response.StatusCode);
Assert.DoesNotContain(remoteSignOutTransaction.Response.Headers, h => h.Key == "Set-Cookie");
}
public async Task EndSessionRequestDoesNotIncludeTelemetryParametersWhenDisabled()
{
var configuration = TestServerBuilder.CreateDefaultOpenIdConnectConfiguration();
var setting = new TestSettings(opt =>
{
opt.ClientId = "Test Id";
opt.Configuration = configuration;
opt.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
opt.DisableTelemetry = true;
});
var server = setting.CreateTestServer();
var transaction = await server.SendAsync(DefaultHost + TestServerBuilder.Signout);
var res = transaction.Response;
Assert.Equal(HttpStatusCode.Redirect, res.StatusCode);
Assert.DoesNotContain(OpenIdConnectParameterNames.SkuTelemetry, res.Headers.Location.Query);
Assert.DoesNotContain(OpenIdConnectParameterNames.VersionTelemetry, res.Headers.Location.Query);
setting.ValidateSignoutRedirect(transaction.Response.Headers.Location);
}
public void UCITestUpdateActiveContact()
{
var client = new WebClient(TestSettings.Options);
using (var xrmApp = new XrmApp(client))
{
xrmApp.OnlineLogin.Login(_xrmUri, _username, _password, _mfaSecrectKey);
xrmApp.Navigation.OpenApp(UCIAppName.Sales);
xrmApp.Navigation.OpenSubArea("Sales", "Contacts");
xrmApp.Grid.OpenRecord(0);
xrmApp.ThinkTime(3000);
xrmApp.Entity.SetValue("firstname", TestSettings.GetRandomString(5, 10));
xrmApp.Entity.SetValue("lastname", TestSettings.GetRandomString(5, 10));
xrmApp.Entity.Save();
}
}
public async Task Challenge_HasOverwrittenPromptParam()
{
var settings = new TestSettings(opt =>
{
opt.ClientId = "Test Id";
opt.Authority = TestServerBuilder.DefaultAuthority;
opt.Prompt = "consent";
});
var properties = new OpenIdConnectChallengeProperties()
{
Prompt = "login",
};
var server = settings.CreateTestServer(properties);
var transaction = await server.SendAsync(TestServerBuilder.TestHost + TestServerBuilder.ChallengeWithProperties);
var res = transaction.Response;
Assert.Equal(HttpStatusCode.Redirect, res.StatusCode);
settings.ValidateChallengeRedirect(res.Headers.Location);
Assert.Contains("prompt=login", res.Headers.Location.Query);
}
private TraceListener GetListener(string name)
{
object value = TestSettings.Get(name);
if (value == null)
{
return(null);
}
if (value is string)
{
return(LookupListener((string)value));
}
if (value is bool)
{
if ((bool)value)
{
return(new TextWriterTraceListener(System.Console.Out));
}
return(null);
}
throw new InvalidCastException("The '" + name + "' setting has invalid data type.");
}
public JoggingViewModel(ITesterService testerService, IValveManager valveManager, IDriver driver, TestSettings testSettings, ConfigurationSettings configurationSettings, IDigitalIO digitalIO)
{
this.digitalIO = digitalIO;
this.driver = driver;
this.testerService = testerService;
this.testSettings = testSettings;
this.configurationSettings = configurationSettings;
this.valveManager = valveManager;
valveTypes.Add(new ValveModel("", "Sprawdzanie obecności"));
valveTypes.Add(new ValveModel("2Up", "GM MBM 2UP LIN"));
valveTypes.Add(new ValveModel("3_5Up", "JLR 3,5UP LIN"));
valveTypes.Add(new ValveModel("6Up", "GM MBM 6UP LIN"));
SelectedType = valveTypes[0];
IsLogInDataSelected = true;
valveManager.ActiveErrorsChanged += ValveManager_ActiveErrorsChanged;
valveManager.OccuredErrorsChanged += ValveManager_OccuredErrorsChanged;
valveManager.ResultChanged += ValveManager_ResultChanged;
valveManager.CommunicationLogChanged += CommunicationLogChanged;
testerService.ProgramStateChanged += TesterService_ProgramStateEventHandler_Change;
driver.CommunicationLogChanged += CommunicationLogChanged;
digitalIO.CommunicationLogChanged += CommunicationLogChanged;
}
protected CommandResult RunTest(
DotNetCli dotnet,
TestApp app,
TestSettings settings,
Action <CommandResult> resultAction = null,
bool multiLevelLookup = false)
{
using (DotNetCliExtensions.DotNetCliCustomizer dotnetCustomizer = settings.DotnetCustomizer == null ? null : dotnet.Customize())
{
settings.DotnetCustomizer?.Invoke(dotnetCustomizer);
if (settings.RuntimeConfigCustomizer != null)
{
settings.RuntimeConfigCustomizer(RuntimeConfig.Path(app.RuntimeConfigJson)).Save();
}
settings.WithCommandLine(app.AppDll);
Command command = dotnet.Exec(settings.CommandLine.First(), settings.CommandLine.Skip(1).ToArray());
if (settings.WorkingDirectory != null)
{
command = command.WorkingDirectory(settings.WorkingDirectory);
}
CommandResult result = command
.EnvironmentVariable("COREHOST_TRACE", "1")
.EnvironmentVariable("DOTNET_MULTILEVEL_LOOKUP", multiLevelLookup ? "1" : "0")
.Environment(settings.Environment)
.CaptureStdOut()
.CaptureStdErr()
.Execute();
resultAction?.Invoke(result);
return(result);
}
}
private static void TestMatrixVectorMultiplicationIntoResult(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
// The result vectors will first be set to some non zero values to make sure that the result overwrites
// them instead of being added to them.
// MultiplyIntoResult() - untransposed
var A1 = Matrix.CreateFromArray(RectangularFullRank10by5.Matrix);
var x1 = Vector.CreateFromArray(RectangularFullRank10by5.Lhs5);
var b1Expected = Vector.CreateFromArray(RectangularFullRank10by5.Rhs10);
Vector b1Computed = Vector.CreateWithValue(A1.NumRows, 1.0);
A1.MultiplyIntoResult(x1, b1Computed, false);
comparer.AssertEqual(b1Expected, b1Computed);
// MultiplyIntoResult() - transposed
var x2 = Vector.CreateFromArray(RectangularFullRank10by5.Lhs10);
var b2Expected = Vector.CreateFromArray(RectangularFullRank10by5.Rhs5);
Vector b2Computed = Vector.CreateWithValue(A1.NumColumns, 1.0);
A1.MultiplyIntoResult(x2, b2Computed, true);
comparer.AssertEqual(b2Expected, b2Computed);
});
}
public async Task RegularGetRequestToCallbackPathSkips()
{
// Arrange
var settings = new TestSettings(
opt =>
{
opt.Authority = TestServerBuilder.DefaultAuthority;
opt.CallbackPath = new PathString("/");
opt.SkipUnrecognizedRequests = true;
opt.ClientId = "Test Id";
});
var server = settings.CreateTestServer(handler: async context =>
{
await context.Response.WriteAsync("Hi from the callback path");
});
// Act
var transaction = await server.SendAsync("/");
// Assert
Assert.Equal("Hi from the callback path", transaction.ResponseText);
}
public static SettingsProvider CreateProvider()
{
var provider = new SettingsProvider("Project/Hinode Test Settings", SettingsScope.Project)
{
label = "Hinode Test Settings",
keywords = new HashSet <string>(new[] { "Test", "Hinode" }),
guiHandler = (searchContext) =>
{
var settings = TestSettings.CreateOrGet();
var SO = new SerializedObject(settings);
EditorGUILayout.PropertyField(SO.FindProperty("_doTakeSnapshot"), new GUIContent("Do Take Snapshot"));
EditorGUILayout.PropertyField(SO.FindProperty("_enableABTest"), new GUIContent("Enable A/B Test"));
EditorGUILayout.PropertyField(SO.FindProperty("_defaultABTestLoopCount"), new GUIContent("Default A/B Test Loop Count"));
if (SO.ApplyModifiedPropertiesWithoutUndo())
{
TestSettings.Save(SO.targetObject as TestSettings);
}
}
};
return(provider);
}
public override void Step(TestSettings settings)
{
if (m_go && settings.hz > 0.0f)
{
m_time += 1.0f / settings.hz;
}
Vec2 linearOffset;
linearOffset.X = 6.0f * (float)Math.Sin(2.0f * m_time);
linearOffset.Y = 8.0f + 4.0f * (float)Math.Sin(1.0f * m_time);
float angularOffset = 4.0f * m_time;
m_joint.SetLinearOffset(linearOffset);
m_joint.SetAngularOffset(angularOffset);
m_debugDraw.DrawPoint(linearOffset, 4.0f, Color.FromArgb(225, 225, 225));
base.Step(settings);
m_debugDraw.DrawString("Keys: (s) pause");
m_textLine += 15;
}
public async void CanGetValidAccessTokenFromFacebook()
{
var credentials = _settings
.GetClientCredentials <Facebook, OAuth2Credentials>();
var token = await new OAuth2App <Facebook>(
credentials.ClientId,
credentials.ClientSecret,
credentials.CallbackUrl)
.AddScope <FacebookEvent>()
.AddScope <FacebookFeed>()
.AddScope <FacebookFriend>()
.AddScope <FacebookPageLike>()
.GetCredentialsAsync()
.ConfigureAwait(false);
Assert.True(IsValidOAuth2Token(token));
Assert.Equal(0, token.AdditionalParameters.Count);
if (TestSettings.ShouldPersistCredentials)
{
TestSettings.WriteCredentials <Facebook>(token);
}
}
public async Task ChallengeDoesNotIncludePkceForOtherResponseTypes(string responseType)
{
var settings = new TestSettings(
opt =>
{
opt.Authority = TestServerBuilder.DefaultAuthority;
opt.AuthenticationMethod = OpenIdConnectRedirectBehavior.RedirectGet;
opt.ResponseType = responseType;
opt.ClientId = "Test Id";
opt.UsePkce = true;
});
var server = settings.CreateTestServer();
var transaction = await server.SendAsync(ChallengeEndpoint);
var res = transaction.Response;
Assert.Equal(HttpStatusCode.Redirect, res.StatusCode);
Assert.NotNull(res.Headers.Location);
Assert.DoesNotContain("code_challenge=", res.Headers.Location.Query);
Assert.DoesNotContain("code_challenge_method=", res.Headers.Location.Query);
}
public async Task Challenge_HasOverwrittenScopeParamFromBaseAuthenticationProperties()
{
var settings = new TestSettings(opt =>
{
opt.ClientId = "Test Id";
opt.Authority = TestServerBuilder.DefaultAuthority;
opt.Scope.Clear();
opt.Scope.Add("foo");
opt.Scope.Add("bar");
});
var properties = new AuthenticationProperties();
properties.SetParameter(OpenIdConnectChallengeProperties.ScopeKey, new string[] { "baz", "qux" });
var server = settings.CreateTestServer(properties);
var transaction = await server.SendAsync(TestServerBuilder.TestHost + TestServerBuilder.ChallengeWithProperties);
var res = transaction.Response;
Assert.Equal(HttpStatusCode.Redirect, res.StatusCode);
settings.ValidateChallengeRedirect(res.Headers.Location);
Assert.Contains("scope=baz%20qux", res.Headers.Location.Query);
}
public void UCITestCreateLead()
{
var client = new WebClient(TestSettings.Options);
using (var xrmApp = new XrmApp(client))
{
xrmApp.OnlineLogin.Login(_xrmUri, _username, _password, _mfaSecrectKey);
xrmApp.Navigation.OpenApp(UCIAppName.Sales);
xrmApp.Navigation.OpenSubArea("Sales", "Leads");
xrmApp.CommandBar.ClickCommand("New");
xrmApp.ThinkTime(5000);
xrmApp.Entity.SetValue("subject", TestSettings.GetRandomString(5, 15));
xrmApp.Entity.SetValue("firstname", TestSettings.GetRandomString(5, 10));
xrmApp.Entity.SetValue("lastname", TestSettings.GetRandomString(5, 10));
xrmApp.Entity.Save();
}
}
private void WriteTestSettingsJson(string configDirectory, TestSettings testSettings)
{
if (!Directory.Exists(configDirectory))
{
Directory.CreateDirectory(configDirectory);
}
var configFilePath = Path.Combine(configDirectory, String.Format("{0}.json", testSettings.GetType().Name));
if (File.Exists(configFilePath))
{
File.Delete(configFilePath);
}
var serializerSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
};
var settingsJson = JsonConvert.SerializeObject(testSettings, serializerSettings);
File.WriteAllText(configFilePath, settingsJson);
}
public void SaveSettings_SupplyValueForNonExistingParameter_SuccessfullyUpdatesValue()
{
// arrange
TestSettings existingValue = new TestSettings {
TestValue = 44
};
string existingJsonValue = JsonConvert.SerializeObject(existingValue);
SettingsStub settingsStub = new SettingsStub();
settingsStub["Test"] = existingJsonValue;
SettingsService service = new SettingsService(settingsStub);
existingValue.TestValue = 55;
existingJsonValue = JsonConvert.SerializeObject(existingValue);
// act
service.SaveSettings <TestSettings>("Test", existingValue);
// assert
Assert.AreEqual(existingJsonValue, settingsStub["Test"]);
}
protected RepositoryTests(DatabaseFixture fixture)
{
var webHost = WebHost.CreateDefaultBuilder()
.UseEnvironment("SapIntegrationTesting")
.UseStartup <Startup>()
.Build();
var configuration = (IConfiguration)webHost.Services.GetService(typeof(IConfiguration));
var settings = new TestSettings();
configuration.Bind(nameof(TestSettings), settings);
var sapServerSettings = new SapServerSettings();
configuration.Bind(nameof(SapServerSettings), sapServerSettings);
fixture.SetBackupPath(settings.SqlBackupPath);
DalService = (IDalService)webHost.Services.GetService(typeof(IDalService));
//Clear tests after dispose
fixture.SetConnectionString(sapServerSettings.SapServerSql);
fixture.BackupDatabase();
fixture.RestoreDatabaseOnDispose(true);
}
public void SettingsLoadSaveTest()
{
string dir = Path.Combine(this.TestContext.TestRunDirectory, this.TestContext.TestName + DateTime.UtcNow.Ticks, "Settings Test Sub Directory");
string file = Path.Combine(dir, "Settings Test File.xml");
string key = "hello";
string value = "world !";
TestSettings s1 = new TestSettings();
Assert.IsTrue(!Directory.Exists(dir));
s1.LoadSettings(file);
s1[key] = value;
s1.SaveSettings(file);
Assert.IsTrue(File.Exists(file));
TestSettings s2 = new TestSettings();
s2.LoadSettings(file);
Assert.AreEqual(value, s2[key]);
File.Delete(file);
}
public void UCITestQuickCreateCase()
{
using (var xrmApp = CreateApp())
{
xrmApp.Navigation.OpenApp(UCIAppName.CustomerService);
xrmApp.Navigation.QuickCreate("case");
xrmApp.QuickCreate.SetValue(new LookupItem {
Name = "customerid", Value = "Adventure"
});
xrmApp.QuickCreate.SetValue("title", TestSettings.GetRandomString(5, 10));
xrmApp.QuickCreate.SetValue(new OptionSet {
Name = "casetypecode", Value = "Problem"
});
xrmApp.QuickCreate.Save();
xrmApp.ThinkTime(5.Seconds());
}
}
public void HttpClientFactory_TryCreateProxy_ProxyWithBypass_ReturnsTrueOutProxyWithBypassedHosts()
{
const string proxyUrl = "https://proxy.example.com/git";
const string repoPath = "/tmp/repos/foo";
const string repoRemote = "https://remote.example.com/foo.git";
var bypassList = new List <string> {
"https://contoso.com", ".*fabrikam\\.com"
};
var repoRemoteUri = new Uri(repoRemote);
var proxyConfig = new ProxyConfiguration(
new Uri(proxyUrl),
userName: null,
password: null,
bypassHosts: bypassList);
var settings = new TestSettings
{
RemoteUri = repoRemoteUri,
RepositoryPath = repoPath,
ProxyConfiguration = proxyConfig
};
var httpFactory = new HttpClientFactory(Mock.Of <IFileSystem>(), Mock.Of <ITrace>(), settings, Mock.Of <IStandardStreams>());
bool result = httpFactory.TryCreateProxy(out IWebProxy proxy);
Assert.True(result);
Assert.NotNull(proxy);
Uri configuredProxyUrl = proxy.GetProxy(repoRemoteUri);
Assert.Equal(proxyUrl, configuredProxyUrl?.ToString());
Assert.True(proxy.IsBypassed(new Uri("https://contoso.com")));
Assert.True(proxy.IsBypassed(new Uri("http://fabrikam.com")));
Assert.True(proxy.IsBypassed(new Uri("https://subdomain.fabrikam.com")));
Assert.False(proxy.IsBypassed(repoRemoteUri));
}
public void HttpClientFactory_TryCreateProxy_ProxyWithCredentials_ReturnsTrueOutProxyWithUrlConfiguredCredentials()
{
const string proxyUser = "******";
const string proxyPass = "******";
const string proxyUrl = "https://proxy.example.com/git";
const string repoPath = "/tmp/repos/foo";
const string repoRemote = "https://remote.example.com/foo.git";
var repoRemoteUri = new Uri(repoRemote);
var proxyConfig = new ProxyConfiguration(
new Uri(proxyUrl),
proxyUser,
proxyPass);
var settings = new TestSettings
{
RemoteUri = repoRemoteUri,
RepositoryPath = repoPath,
ProxyConfiguration = proxyConfig
};
var httpFactory = new HttpClientFactory(Mock.Of <IFileSystem>(), Mock.Of <ITrace>(), settings, Mock.Of <IStandardStreams>());
bool result = httpFactory.TryCreateProxy(out IWebProxy proxy);
Assert.True(result);
Assert.NotNull(proxy);
Uri configuredProxyUrl = proxy.GetProxy(repoRemoteUri);
Assert.Equal(proxyUrl, configuredProxyUrl?.ToString());
Assert.NotNull(proxy.Credentials);
Assert.IsType <NetworkCredential>(proxy.Credentials);
var configuredCredentials = (NetworkCredential)proxy.Credentials;
Assert.Equal(proxyUser, configuredCredentials.UserName);
Assert.Equal(proxyPass, configuredCredentials.Password);
}
public async Task MigrateNewest()
{
TestSettings.SkipTestIfNecessary();
var now = DateTime.UtcNow;
await using var container = CreateContainer();
var engine = container.GetRequiredService <MigrationEngine>();
using var session = container.GetRequiredService <IDocumentStore>().OpenAsyncSession();
session.Advanced.WaitForIndexesAfterSaveChanges();
await session.StoreAsync(new MigrationInfo { Id = "migrationInfos/1.0.0", Name = nameof(FirstMigration), Version = "1.0.0", AppliedAt = now.AddDays(-1) });
await session.SaveChangesAsync();
var summary = await engine.MigrateAsync(now, new[] { GetType().Assembly });
summary.TryGetAppliedMigrations(out var appliedMigrations).Should().BeTrue();
var expectedMigrationInfo = new MigrationInfo {
Id = "migrationInfos/2.0.0", Name = nameof(SecondMigration), Version = "2.0.0", AppliedAt = now
};
var expectedMigrationInfos = new List <MigrationInfo> {
expectedMigrationInfo
};
appliedMigrations.Should().BeEquivalentTo(expectedMigrationInfos);
var storedEntities = await session.Query <Entity>().ToListAsync();
var expectedStoredEntities = new List <Entity> {
new () { Id = "entities/1-A", Value = "Bar" }
};
storedEntities.Should().BeEquivalentTo(expectedStoredEntities);
var storedMigrationInfo = await session.LoadAsync <MigrationInfo?>(expectedMigrationInfo.Id);
storedMigrationInfo.Should().BeEquivalentTo(expectedMigrationInfo);
}
public async Task OnRedirectToIdentityProviderEventCanReplaceMessage()
{
var newMessage = new MockOpenIdConnectMessage
{
IssuerAddress = "http://example.com/",
TestAuthorizeEndpoint = $"http://example.com/{Guid.NewGuid()}/oauth2/signin"
};
var settings = new TestSettings(
opts =>
{
opts.ClientId = "Test Id";
opts.Authority = TestServerBuilder.DefaultAuthority;
opts.Events = new OpenIdConnectEvents()
{
OnRedirectToIdentityProvider = context =>
{
context.ProtocolMessage = newMessage;
return(Task.FromResult(0));
}
};
}
);
var server = settings.CreateTestServer();
var transaction = await server.SendAsync(ChallengeEndpoint);
var res = transaction.Response;
Assert.Equal(HttpStatusCode.Redirect, res.StatusCode);
Assert.NotNull(res.Headers.Location);
// The CreateAuthenticationRequestUrl method is overridden MockOpenIdConnectMessage where
// query string is not generated and the authorization endpoint is replaced.
Assert.Equal(newMessage.TestAuthorizeEndpoint, res.Headers.Location.AbsoluteUri);
}
public RequestEvaluatorTestFixture()
{
var settings = new TestSettings {
Mode = Mode.On,
IgnoreAjaxRequests = true,
IgnoreImages = true,
IgnoreStyleSheets = true,
IgnoreSystemHandlers = true,
Paths = {
new TestPathSetting("/Info/ContactUs.aspx", PathMatchType.StartsWith, true, RequestSecurity.Insecure),
new TestPathSetting("/Login.aspx"),
new TestPathSetting("/Admin/ViewOrders.aspx"),
new TestPathSetting("/info/contactus", PathMatchType.StartsWith, true, RequestSecurity.Insecure),
new TestPathSetting("/login/"),
new TestPathSetting("/admin/vieworders/"),
new TestPathSetting("/Manage")
}
};
settings.CallPostDeserialize();
Settings = settings;
}
public void AttemptToSetTheUnsettableResultsInAnException()
{
var settingsSource = new NameValueCollection();
settingsSource["Test:Unsettable"] = "Bang";
var reader = new SimpleSettingsReader(settingsSource);
var injector = new SimpleSettingsInjector();
var settings = new TestSettings();
injector.Inject(settings, reader);
}
private static void RunPageTest(TestSettings settings)
{
string url;
using (var browser = new IE(ConfigurationManager.AppSettings["WebpageTestUrl"]))
{
browser.TextField(Find.ById("url")).Value = settings.Url;
if (!string.IsNullOrEmpty(settings.TestLocation))
browser.SelectList(Find.ById("location")).SelectByValue(settings.TestLocation);
if (!string.IsNullOrEmpty(settings.Browser))
browser.SelectList(Find.ById("browser")).SelectByValue(settings.Browser);
browser.Link(Find.ById("advanced_settings")).ClickNoWait();
if (!string.IsNullOrEmpty(settings.Speed))
browser.SelectList(Find.ById("connection")).SelectByValue(settings.Speed);
if (settings.IsPrivate)
browser.CheckBox(Find.ById("keep_test_private")).Change();
if (!string.IsNullOrEmpty(settings.Username))
browser.TextField(Find.ById("username")).TypeText(settings.Username);
if (!string.IsNullOrEmpty(settings.Password))
browser.TextField(Find.ById("password")).TypeText(settings.Password);
browser.Button(Find.ByName("submit")).Click();
browser.WaitUntilContainsText("First View", settings.Timeout);
if (browser.ContainsText("partially complete"))
{
Thread.Sleep(10000);
browser.Refresh();
}
browser.WaitUntilContainsText("Raw page data", settings.Timeout);
url = browser.Link(Find.ByText("Raw page data")).Url;
}
var csvRequest = (HttpWebRequest) WebRequest.Create(url);
csvRequest.Accept = "text/csv";
var data = new List<PageData>();
using (var stream = csvRequest.GetResponse().GetResponseStream())
{
if (stream != null)
{
using (var reader = new StreamReader(stream))
{
using (var context = new CsvReader(reader))
{
while (context.Read())
{
var counter = data.Count;
var item = new PageData();
item.EventName = counter == 0 ? "Empty Cache" : "Cached Run " + counter;
item.Url = context.GetField<string>(3);
item.LoadTime = TimeSpan.FromMilliseconds(context.GetField<int>(4));
item.TimeToFirstByte = TimeSpan.FromMilliseconds(context.GetField<int>(5));
item.Requests = context.GetField<int>(11);
data.Add(item);
}
}
}
}
}
var host = ConfigurationManager.AppSettings["MetricTracking:Host"];
var port = int.Parse(ConfigurationManager.AppSettings["MetricTracking:Port"]);
using (var metric = new MetricTracker(host, port))
{
foreach (var run in data)
{
Console.WriteLine(run.EventName + "\t" + run.LoadTime);
var prefix = settings.Prefix + run.EventName.Replace(" ", string.Empty) + ".";
metric.Timing(prefix + "LoadTime", run.LoadTime.TotalMilliseconds);
metric.Timing(prefix + "TimeToFirstByte", run.TimeToFirstByte.TotalMilliseconds);
metric.Value(prefix + "Requests", run.Requests);
}
}
}
public ComparisonTestCases(TestSettings testSettings)
{
_testSettings = testSettings;
_collection = Enumerable.Range(0, _testSettings.TestCollectionSize);
}
public async void PostingAJsonObject_ParsingTheLocationHeader_SupplyingResponseParserViaSettings()
{
var settings = new TestSettings().OverrideContentDeserializer(new ExtendedContentDeserializer(new JsonSerializer()));
var customerApi = Api.For<ICustomerApi>(Host, settings);
var result = await customerApi.CreateDriverWithLocation(new Customer { Id = 1, Name = "Mighty Gazelle" });
Assert.AreEqual("Mighty Gazelle", result.Name);
Assert.AreEqual("api/customer/1", result.Location);
Assert.AreEqual(1, result.Id);
}
public void Initialize()
{
_settings = new TestSettings();
_container = ApplicationData.Current.LocalSettings;
}
public TestNode(TestSettings testSettings) : base(testSettings) {
packetQueue = new Queue<Packet>();
nodeStateQueue = new Queue<TestNodeState>();
}
public async void PostingAJsonObjectModifyingContentWithResolver()
{
var settings = new TestSettings();
settings.ListTransformers.Add(new ContentExtender());
var customerApi = Api.For<ICustomerApi>(Host, settings);
var result = await customerApi.CreateCustomer2(new Customer { Id = 1, Name = "Placeholder" });
Assert.AreEqual("Mighty Gazelle", result.Name);
Assert.AreEqual(1, result.Id);
}
private TestSettings(TestSettings existing) : base(existing) { }
public void DefaultToNulls()
{
var settings = new TestSettings();
Assert.Null(settings.CallSettings);
Assert.Null(settings.Clock);
}