/// <summary>
/// Apply issue types into RhinoConfiguration capabilities or default types if needed.
/// </summary>
/// <param name="configuration">RhinoConfiguration to apply issue types to</param>
public static void PutDefaultCapabilities(this RhinoConfiguration configuration)
{
// exit conditions
if (configuration == null || configuration.ConnectorConfiguration == null)
{
return;
}
if (string.IsNullOrEmpty(configuration.ConnectorConfiguration.Connector))
{
return;
}
// setup
var defaultMap = DefaultTypesMap();
var options = $"{configuration?.ConnectorConfiguration.Connector}:options";
var capabilities = configuration.Capabilities.ContainsKey(options)
? configuration.Capabilities[options] as IDictionary <string, object> ?? new Dictionary <string, object>()
: new Dictionary <string, object>();
// factor
foreach (var key in defaultMap.Keys)
{
if (capabilities.ContainsKey(key))
{
continue;
}
capabilities[key] = defaultMap[key];
}
configuration.Capabilities[options] = capabilities;
}
public void ConnectDataSourceContentFromFiles(int iteration, string firstName, string lastName)
{
// constants
const string TestKey = "DEMO-60727";
// setup
var configuration = new RhinoConfiguration
{
TestsRepository = new[] { "FullSpecJson.txt" },
Models = new[] { "InputsModel.txt", "TablesModel.txt" },
DriverParameters = new[]
{
ChromeDriver
}
};
// execute
var actual = new TextConnector(configuration, Utilities.Types)
.ProviderManager
.TestRun
.TestCases
.Where(i => i.Key == TestKey)
.ElementAt(iteration);
var asString = JsonConvert.SerializeObject(actual);
// assert
Assert.IsTrue(asString.Contains(firstName));
Assert.IsTrue(asString.Contains(lastName));
}
private static IConnector SetConnector(IEnumerable <Type> types, RhinoConfiguration configuration)
{
// constants
const StringComparison C = StringComparison.OrdinalIgnoreCase;
// types loading pipeline
var byContract = types.Where(t => typeof(IConnector).IsAssignableFrom(t) && !t.IsAbstract && !t.IsInterface);
var byAttribute = byContract.Where(t => t.GetCustomAttribute <ConnectorAttribute>() != null);
// exit conditions - will abort on azure devOps task as well
OnConnectorError(configuration, !byAttribute.Any());
// get connector type by it's name
var type = byAttribute
.FirstOrDefault(t => t.GetCustomAttribute <ConnectorAttribute>().Name.Equals(configuration.Connector, C));
// exit conditions - will abort on azure devops task as well
OnConnectorError(configuration, type == default);
// activate new connector instance
var connector = (IConnector)Activator.CreateInstance(type, new object[] { configuration, types });
// exit conditions
if (connector != default && arguments.ContainsKey(Connect))
{
Console.WriteLine("successfully connected");
Environment.Exit(0);
}
return(connector);
}
/// <summary>
/// Apply appsettings.json onto Rhino.Api.Contracts.Configuration.RhinoConfiguration instance.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to apply setting to.</param>
/// <param name="appSettings">Settings to apply from.</param>
/// <returns>Rhino.Api.Contracts.Configuration.RhinoConfiguration after settings applied.</returns>
public static RhinoConfiguration ApplySettings(this RhinoConfiguration configuration, IConfiguration appSettings)
{
// reporting
configuration.ReportConfiguration.ReportOut =
appSettings.GetValue <string>("rhino:reportConfiguration:reportOut");
configuration.ReportConfiguration.LogsOut =
appSettings.GetValue <string>("rhino:reportConfiguration:logsOut");
configuration.ReportConfiguration.Archive =
appSettings.GetValue <bool>("rhino:reportConfiguration:archive");
configuration.ReportConfiguration.Reporters = appSettings
.GetSection("rhino:reportConfiguration:reporters")
.GetChildren()
.Select(i => i.Value)
.ToArray();
// screenshots
configuration.ScreenshotsConfiguration.ScreenshotsOut =
appSettings.GetValue <string>("rhino:screenshotsConfiguration:screenshotsOut");
// updated state
return(configuration);
}
public void ConnectPageModelsCount()
{
// constants
const string TestKey = "MODELS-60727";
// setup
var configuration = new RhinoConfiguration
{
TestsRepository = GetSpecsByStub("ModelsNoDataSource"),
Models = new[] { RhinoModelStub.InputsModel, RhinoModelStub.TablesModel },
DriverParameters = new[]
{
ChromeDriver
}
};
// execute
var actual = new TextConnector(configuration, Utilities.Types)
.ProviderManager
.TestRun
.TestCases
.First(i => i.Key == TestKey)
.ModelEntries
.Count();
// assert
Assert.AreEqual(expected: 3, actual);
}
public void ConnectDataSourceCountFromFile()
{
// constants
const string TestKey = "DEMO-60727";
// setup
var configuration = new RhinoConfiguration
{
TestsRepository = new[] { "FullSpecJson.txt" },
Models = new[] { RhinoModelStub.InputsModel, RhinoModelStub.TablesModel },
DriverParameters = new[]
{
ChromeDriver
}
};
// execute
var actual = new TextConnector(configuration, Utilities.Types)
.ProviderManager
.TestRun
.TestCases
.Count(i => i.Key == TestKey);
// assert
Assert.AreEqual(expected: 3, actual);
}
public void ConnectPageModelsContentFromFiles(int step, string action, string expected)
{
// constants
const string TestKey = "MODELS-60727";
// setup
var configuration = new RhinoConfiguration
{
TestsRepository = new[] { "ModelsNoDataSource.txt" },
Models = new[] { "InputsModel.txt", "TablesModel.txt" },
DriverParameters = new[]
{
ChromeDriver
}
};
// execute
var actualTestStep = new TextConnector(configuration, Utilities.Types)
.ProviderManager
.TestRun
.TestCases
.First(i => i.Key == TestKey)
.Steps
.ElementAt(step);
// get actuals
var actualAction = actualTestStep.Action;
var actualExpected = string.Join(Environment.NewLine, actualTestStep.ExpectedResults.Select(i => i.ExpectedResult));
// assert
Assert.IsTrue(action.Contains(actualAction));
Assert.AreEqual(expected: expected, actual: actualExpected);
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Components.RhinoConnector.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this connector.</param>
/// <param name="types">A collection of <see cref="Type"/> to load for this repository.</param>
/// <param name="logger">Gravity.Abstraction.Logging.ILogger implementation for this connector.</param>
/// <param name="connect"><see cref="true"/> for immediately connect after construct <see cref="false"/> skip connection.</param>
/// <remarks>If you skip connection you must explicitly call Connect method.</remarks>
public GurockConnector(RhinoConfiguration configuration, IEnumerable <Type> types, ILogger logger, bool connect)
: base(configuration, types, logger)
{
// setup connector type (double check)
configuration.ConnectorConfiguration ??= new RhinoConnectorConfiguration();
configuration.ConnectorConfiguration.Connector = Connector.TestRail;
// setup provider manager
ProviderManager = new GurockAutomationProvider(configuration, types, logger);
// integration
var clientFactory = new ClientFactory(
testRailServer: configuration.ConnectorConfiguration.Collection,
user: configuration.ConnectorConfiguration.UserName,
password: configuration.ConnectorConfiguration.Password,
logger);
casesClient = clientFactory.Create <TestRailCasesClient>();
testsClient = clientFactory.Create <TestRailTestsClient>();
resultsClient = clientFactory.Create <TestRailResultsClient>();
attachmentsClient = clientFactory.Create <TestRailAttachmentsClient>();
// connect on constructing
if (connect)
{
Connect();
}
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Components.RhinoConnector.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this connector.</param>
/// <param name="types">A collection of <see cref="Type"/> to load for this repository.</param>
/// <param name="logger">Gravity.Abstraction.Logging.ILogger implementation for this connector.</param>
/// <param name="connect"><see cref="true"/> for immediately connect after construct <see cref="false"/> skip connection.</param>
/// <remarks>If you skip connection you must explicitly call Connect method.</remarks>
public TextConnector(RhinoConfiguration configuration, IEnumerable <Type> types, ILogger logger, bool connect)
: base(configuration, types, logger)
{
// setup provider manager
ProviderManager = new TextAutomationProvider(configuration, types, logger);
// connect on constructing
if (connect)
{
Connect();
}
}
/// <summary>
/// Gets a JiraAuthentication object.
/// </summary>
/// <param name="configuration">RhinoConfiguration to create JiraAuthentication by.</param>
/// <returns>JiraAuthentication object</returns>
public static JiraAuthentication GetJiraAuthentication(this RhinoConfiguration configuration)
{
return(new JiraAuthentication
{
AsOsUser = configuration.ConnectorConfiguration.AsOsUser,
Collection = configuration.ConnectorConfiguration.Collection,
Password = configuration.ConnectorConfiguration.Password,
UserName = configuration.ConnectorConfiguration.UserName,
Project = configuration.ConnectorConfiguration.Project,
Capabilities = configuration.Capabilities
});
}
public void ConnectNoDriverParams()
{
// setup
var configuration = new RhinoConfiguration
{
TestsRepository = GetSpecsByStub("FullSpecJson", "FullSpecMarkdownV1", "FullSpecMarkdownV2")
};
// execute
var testCases = new TextConnector(configuration).ProviderManager.TestRun.TestCases;
// assert
Assert.IsFalse(testCases.Any());
}
private static void OnConnectorError(RhinoConfiguration configuration, bool isError)
{
// constants: logging
const string M = "Connector [{0}] was not found. Please make sure to pass a valid connector.";
// exit conditions
if (!isError)
{
return;
}
// failure on getting connector
Console.Error.WriteLine(string.Format(M, configuration.Connector));
Environment.Exit(errorCode);
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Components.RhinoConnector.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this connector.</param>
/// <param name="types">A collection of <see cref="Type"/> to load for this repository.</param>
/// <param name="logger">Gravity.Abstraction.Logging.ILogger implementation for this connector.</param>
/// <param name="connect"><see cref="true"/> for immediately connect after construct <see cref="false"/> skip connection.</param>
/// <remarks>If you skip connection you must explicitly call Connect method.</remarks>
public XrayConnector(RhinoConfiguration configuration, IEnumerable <Type> types, ILogger logger, bool connect)
: base(configuration, types, logger)
{
// setup connector type (double check)
configuration.ConnectorConfiguration ??= new RhinoConnectorConfiguration();
configuration.ConnectorConfiguration.Connector = Connector.JiraXRay;
// setup provider manager
ProviderManager = new XrayAutomationProvider(configuration, types, logger);
// connect on constructing
if (connect)
{
Connect();
}
}
private static Type DoGetConnector(RhinoConfiguration configuration, IEnumerable <Type> types)
{
// constants
const StringComparison C = StringComparison.OrdinalIgnoreCase;
// types loading pipeline
var byContract = types.Where(t => typeof(IConnector).IsAssignableFrom(t) && !t.IsAbstract && !t.IsInterface);
var byAttribute = byContract.Where(t => t.GetCustomAttribute <ConnectorAttribute>() != null);
// get connector type by it's name
var type = byAttribute
.FirstOrDefault(t => t.GetCustomAttribute <ConnectorAttribute>().Value.Equals(configuration.ConnectorConfiguration.Connector, C));
if (type == default)
{
return(default);
/// <summary>
/// POST a new Rhino.Api.Contracts.Configuration.RhinoConfiguration into this domain collection.
/// </summary>
/// <param name="authentication">Authentication object by which to access the collection.</param>
/// <param name="data">The Rhino.Api.Contracts.Configuration.RhinoConfiguration to POST.</param>
/// <returns>Rhino.Api.Contracts.Configuration.RhinoConfiguration.Id.</returns>
public string Post(Authentication authentication, RhinoConfiguration data)
{
// validate
CreateCollection(authentication);
// get collection
var collection = LiteDb.GetCollection <RhinoConfiguration>(name: Collection);
// security
data.Authentication = authentication;
// insert
collection.Insert(entity: data);
// results
return($"{data.Id}");
}
public void ConnectTestsCount(string rhinoSpec, int expected)
{
// setup
var configuration = new RhinoConfiguration
{
TestsRepository = GetSpecsByStub(rhinoSpec),
DriverParameters = new[]
{
ChromeDriver
}
};
// execute
var testCases = new TextConnector(configuration, Utilities.Types).ProviderManager.TestRun.TestCases;
// assert
Assert.AreEqual(expected, actual: testCases.Count());
}
public void ConnectTestsCountLocalDataSource()
{
// setup
var configuration = new RhinoConfiguration
{
TestsRepository = GetSpecsByStub("FullSpecJson", "FullSpecMarkdownV1", "FullSpecMarkdownV2"),
DriverParameters = new[]
{
ChromeDriver
}
};
// execute
var testCases = new TextConnector(configuration, Utilities.Types).Connect().ProviderManager.TestRun.TestCases;
// assert
Assert.AreEqual(expected: 9, actual: testCases.Count());
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Simulator.Framework.XrayAutomationProvider.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this provider.</param>
/// <param name="types">A collection of <see cref="Type"/> to load for this repository.</param>
/// <param name="logger">Gravity.Abstraction.Logging.ILogger implementation for this provider.</param>
public XrayAutomationProvider(RhinoConfiguration configuration, IEnumerable <Type> types, ILogger logger)
: base(configuration, types, logger)
{
// setup
this.logger = logger?.Setup(loggerName: nameof(XrayAutomationProvider));
var authentication = configuration.GetJiraAuthentication();
jiraClient = new JiraClient(authentication);
jiraExecutor = new JiraCommandsExecutor(authentication);
// capabilities
BucketSize = configuration.GetBucketSize();
configuration.PutDefaultCapabilities();
capabilities = configuration.Capabilities.ContainsKey($"{Connector.JiraXRay}:options")
? configuration.Capabilities[$"{Connector.JiraXRay}:options"] as IDictionary <string, object>
: new Dictionary <string, object>();
// integration
bugsManager = new JiraBugsManager(jiraClient);
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Simulator.Framework.AutomationProvider.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this provider.</param>
/// <param name="types">A collection of <see cref="Type"/> to load for this repository.</param>
/// <param name="logger">Gravity.Abstraction.Logging.ILogger implementation for this provider.</param>
public GurockAutomationProvider(RhinoConfiguration configuration, IEnumerable <Type> types, ILogger logger)
: base(configuration, types, logger)
{
// setup
this.logger = logger?.Setup(loggerName: nameof(GurockAutomationProvider));
// capabilities
BucketSize = configuration.GetCapability(ProviderCapability.BucketSize, 15);
// jira
var jiraAuth = GetJiraAuthentication(configuration.Capabilities);
if (!string.IsNullOrEmpty(jiraAuth.Collection))
{
jiraClient = new JiraClient(jiraAuth);
bugsManager = new JiraBugsManager(jiraClient);
}
// integration
clientFactory = new ClientFactory(
configuration.ConnectorConfiguration.Collection,
configuration.ConnectorConfiguration.UserName,
configuration.ConnectorConfiguration.Password,
logger);
suitesClient = clientFactory.Create <TestRailSuitesClient>();
casesClient = clientFactory.Create <TestRailCasesClient>();
configuraionsClient = clientFactory.Create <TestRailConfiguraionsClient>();
milestoneClient = clientFactory.Create <TestRailMilestoneClient>();
plansClient = clientFactory.Create <TestRailPlansClient>();
usersClient = clientFactory.Create <TestRailUsersClient>();
prioritiesClient = clientFactory.Create <TestRailPrioritiesClient>();
templatesClient = clientFactory.Create <TestRailTemplatesClient>();
// meta data
project = suitesClient.Projects.FirstOrDefault(i => i.Name.Equals(configuration.ConnectorConfiguration.Project, Compare));
user = usersClient.GetUserByEmail(configuration.ConnectorConfiguration.UserName);
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Simulator.Framework.XrayAutomationProvider.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this provider.</param>
/// <param name="types">A collection of <see cref="Type"/> to load for this repository.</param>
/// <param name="logger">Gravity.Abstraction.Logging.ILogger implementation for this provider.</param>
public XrayCloudAutomationProvider(RhinoConfiguration configuration, IEnumerable <Type> types, ILogger logger)
: base(configuration, types, logger)
{
// setup
this.logger = logger?.Setup(loggerName: nameof(XrayCloudAutomationProvider));
jiraClient = new JiraClient(configuration.GetJiraAuthentication());
xpandClient = new XpandClient(configuration.GetJiraAuthentication());
executor = new JiraCommandsExecutor(configuration.GetJiraAuthentication());
// capabilities
BucketSize = configuration.GetBucketSize();
configuration.PutDefaultCapabilities();
capabilities = configuration.Capabilities.ContainsKey($"{Connector.JiraXryCloud}:options")
? configuration.Capabilities[$"{Connector.JiraXryCloud}:options"] as IDictionary <string, object>
: new Dictionary <string, object>();
// misc
options = new ParallelOptions {
MaxDegreeOfParallelism = BucketSize
};
// integration
bugsManager = new JiraBugsManager(jiraClient);
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Components.RhinoConnector.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this connector.</param>
/// <param name="types">A collection of <see cref="Type"/> to load for this repository.</param>
public XrayConnector(RhinoConfiguration configuration, IEnumerable <Type> types)
: this(configuration, types, Utilities.CreateDefaultLogger(configuration))
{
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Components.RhinoConnector.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this connector.</param>
public XrayConnector(RhinoConfiguration configuration)
: this(configuration, Utilities.Types)
{
}
/// <summary>
/// Gets a connector.
/// </summary>
/// <param name="configuration">RhinoConfiguration by which to factor RhinoConnector</param>
/// <param name="types">A collection of <see cref="Type>"/> in which to search for RhinoConnector.</param>
/// <returns>RhinoConnector implementation.</returns>
public static Type GetConnector(this RhinoConfiguration configuration, IEnumerable <Type> types)
{
return(DoGetConnector(configuration, types));
}
/// <summary>
/// Gets a connector.
/// </summary>
/// <param name="configuration">RhinoConfiguration by which to factor RhinoConnector</param>
/// <returns>RhinoConnector implementation.</returns>
public static Type GetConnector(this RhinoConfiguration configuration)
{
return(DoGetConnector(configuration, Api.Extensions.Utilities.Types));
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Simulator.Framework.TextAutomationProvider.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this provider.</param>
/// <param name="types">A collection of <see cref="Type"/> to load for this repository.</param>
public TextAutomationProvider(RhinoConfiguration configuration, IEnumerable <Type> types)
: this(configuration, types, Utilities.CreateDefaultLogger(configuration))
{
}
/// <summary>
/// Gets a markdown description of this configuration.
/// </summary>
/// <param name="configuration">RhinoConfiguration to parse.</param>
/// <returns>Markdown description of this configuration</returns>
public static string GetRunDescription(this RhinoConfiguration configuration)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Simulator.Framework.XrayAutomationProvider.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this provider.</param>
public XrayAutomationProvider(RhinoConfiguration configuration)
: this(configuration, Utilities.Types)
{
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Components.RhinoConnector.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this connector.</param>
/// <param name="types">A collection of <see cref="Type"/> to load for this repository.</param>
/// <param name="logger">Gravity.Abstraction.Logging.ILogger implementation for this connector.</param>
public XrayConnector(RhinoConfiguration configuration, IEnumerable <Type> types, ILogger logger)
: this(configuration, types, logger, connect : true)
{
}
/// <summary>
/// Creates a new instance of this Rhino.Api.Simulator.Framework.TextAutomationProvider.
/// </summary>
/// <param name="configuration">Rhino.Api.Contracts.Configuration.RhinoConfiguration to use with this provider.</param>
/// <param name="types">A collection of <see cref="Type"/> to load for this repository.</param>
/// <param name="logger">Gravity.Abstraction.Logging.ILogger implementation for this provider.</param>
public TextAutomationProvider(RhinoConfiguration configuration, IEnumerable <Type> types, ILogger logger)
: base(configuration, types, logger)
{
this.logger = logger?.Setup(loggerName: nameof(TextAutomationProvider));
testCaseFactory = new RhinoTestCaseFactory(logger);
}
/// <summary>
/// PUT a new Rhino.Api.Contracts.Configuration.RhinoConfiguration into this domain collection.
/// </summary>
/// <param name="authentication">Authentication object by which to access the collection.</param>
/// <param name="id">Rhino.Api.Contracts.Configuration.RhinoConfiguration.Id to PUT.</param>
/// <param name="data">The Rhino.Api.Contracts.Configuration.RhinoConfiguration to PUT.</param>
/// <returns>Status code and configuration (if any).</returns>
public (HttpStatusCode statusCode, RhinoConfiguration data) Put(Authentication authentication, string id, RhinoConfiguration data)
{
// validate
CreateCollection(authentication);
// get collection
var collection = LiteDb.GetCollection <RhinoConfiguration>(name: Collection);
// get configuration
var(statusCode, configuration) = Get(id, collection);
// not found
if (statusCode == HttpStatusCode.NotFound)
{
return(statusCode, configuration);
}
// update
data.Id = configuration.Id;
data.Authentication = authentication;
collection.Update(entity: data);
// results
return(HttpStatusCode.OK, data);
}
