static partial void RegisterCommands(IObjectContainer container)
{
var serviceProvider = container.Resolve<IServiceProvider>();
container.RegisterInstanceAs<MenuCommandHandler>(new DelegateMenuCommandHandler(serviceProvider, container.Resolve<DTE>(),
(_1, _2) => System.Windows.MessageBox.Show("generate skeleton")), SpecFlowCmdSet.GenerateStepDefinitionSkeleton.ToString());
container.RegisterTypeAs<RunScenariosCommand, MenuCommandHandler>(SpecFlowCmdSet.RunScenarios.ToString());
container.RegisterTypeAs<DebugScenariosCommand, MenuCommandHandler>(SpecFlowCmdSet.DebugScenarios.ToString());
container.RegisterTypeAs<ReGenerateAllCommand, MenuCommandHandler>(SpecFlowCmdSet.ReGenerateAll.ToString());
}
public override void OnData(IObjectContainer container,AppSocketSession session, AppSocketData data)
{
try
{
container.Resolve<IRawDataService>().Log(session, Encoding.UTF8.GetString(data.RawData));
}
catch (Exception ex)
{
container.Resolve<ILogger>().Error("记录原始数据错误", ex);
}
}
public override void OnData(IObjectContainer container,AppSocketSession session, AppSocketData data)
{
try
{
container.Resolve<IRawDataService>().Log(session, ByteHelper.ConvertBytesToStringByHex(data.RawData, ","));
}
catch (Exception ex)
{
container.Resolve<ILogger>().Error("记录原始数据错误", ex);
}
}
public virtual void RegisterDefaults(IObjectContainer container)
{
var serviceProvider = container.Resolve<IServiceProvider>();
RegisterVsDependencies(container, serviceProvider);
container.RegisterTypeAs<InstallServices, InstallServices>();
container.RegisterTypeAs<VsBrowserGuidanceNotificationService, IGuidanceNotificationService>();
container.RegisterTypeAs<WindowsFileAssociationDetector, IFileAssociationDetector>();
container.RegisterTypeAs<RegistryStatusAccessor, IStatusAccessor>();
container.RegisterTypeAs<IntegrationOptionsProvider, IIntegrationOptionsProvider>();
container.RegisterInstanceAs<IIdeTracer>(VsxHelper.ResolveMefDependency<IVisualStudioTracer>(serviceProvider));
container.RegisterInstanceAs(VsxHelper.ResolveMefDependency<IProjectScopeFactory>(serviceProvider));
container.RegisterTypeAs<TestRunnerEngine, ITestRunnerEngine>();
container.RegisterTypeAs<TestRunnerGatewayProvider, ITestRunnerGatewayProvider>();
container.RegisterTypeAs<MsTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.VisualStudio2010MsTest.ToString());
container.RegisterTypeAs<ReSharper5TestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper5.ToString());
container.RegisterTypeAs<ReSharper6TestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper.ToString());
container.RegisterTypeAs<SpecRunTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.SpecRun.ToString());
container.RegisterTypeAs<VS2012RunnerGateway, ITestRunnerGateway>(TestRunnerTool.VisualStudio2012.ToString());
container.RegisterTypeAs<AutoTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.Auto.ToString());
container.RegisterTypeAs<StepDefinitionSkeletonProvider, IStepDefinitionSkeletonProvider>();
container.RegisterTypeAs<DefaultSkeletonTemplateProvider, ISkeletonTemplateProvider>();
container.RegisterTypeAs<StepTextAnalyzer, IStepTextAnalyzer>();
RegisterCommands(container);
}
static internal TestRunner CreateTestRunner(out IObjectContainer container, Action<IObjectContainer> registerMocks = null)
{
container = TestRunContainerBuilder.CreateContainer();
if (registerMocks != null)
registerMocks(container);
return (TestRunner)container.Resolve<ITestRunner>();
}
public override void OnData(IObjectContainer container,AppSocketSession session, AppSocketData data)
{
try
{
var log = string.Empty;
if (data.RawData[0] == 0x2a)
{
log = Encoding.ASCII.GetString(data.RawData);
}
else
{
log = ByteHelper.ConvertBytesToStringByHex(data.RawData, ",");
}
container.Resolve<IRawDataService>().Log(session, log);
}
catch (Exception ex)
{
container.Resolve<ILogger>().Error("记录原始数据错误", ex);
}
}
private static IMessageBus BuildMessageBus(AbstractConfiguration cfg)
{
ISubscriptionService subscriptionService = MessageBusConfigurationExtensions.GetSubscriptionService(cfg);
IMessageSink messageSink = MessageBusConfigurationExtensions.GetMessageSink(cfg);
IObjectContainer container = ObjectContainerConfigurationExtensions.GetObjectContainer(cfg);
IRouteManager routeManager = container.Resolve <IRouteManager>();
Xyperico.Agres.MessageBus.Implementation.MessageBus bus = new Agres.MessageBus.Implementation.MessageBus(subscriptionService, routeManager, messageSink);
container.RegisterInstance <IMessageBus>(bus);
return(bus);
}
private ITaskItem[] GenerateCodeBehindFilesForProject(IObjectContainer container, List <string> featureFiles)
{
var generator = container.Resolve <IFeatureFileCodeBehindGenerator>();
var generatedFiles = generator.GenerateFilesForProject(
featureFiles,
ProjectFolder,
OutputPath);
return(generatedFiles.Select(file => new TaskItem {
ItemSpec = file
}).ToArray());
}
public void GivenTheFollowingRoatpProvidersAreAvailable(Table table)
{
var stubrepo = _objectContainer.Resolve <StubProviderRepository>("StubRepo");
stubrepo.roatpProviderDocuments.AddRange(ToRoatpProviders(table));
var availableroatpdata = stubrepo.roatpProviderDocuments;
}
public void MakeScreenshot(string name)
{
var path = _container.Resolve <Artifacts>().GetPath(name + ".png");
var screenshot = WebDriver.TakeScreenshot();
screenshot.SaveAsFile(path);
}
private void RegisterSpecflowDependencies(IObjectContainer objectContainer, IWindsorContainer windsorContainer)
{
windsorContainer.Register(Component.For <IObjectContainer>()
.UsingFactoryMethod(() => objectContainer)
.LifestyleTransient()
.OnlyNewServices());
windsorContainer.Register(Component.For <ScenarioContext>()
.UsingFactoryMethod(() => objectContainer.Resolve <ScenarioContext>())
.LifestyleTransient()
.OnlyNewServices());
windsorContainer.Register(Component.For <FeatureContext>()
.UsingFactoryMethod(() => objectContainer.Resolve <FeatureContext>())
.LifestyleTransient()
.OnlyNewServices());
windsorContainer.Register(Component.For <TestThreadContext>()
.UsingFactoryMethod(() => objectContainer.Resolve <TestThreadContext>())
.LifestyleTransient()
.OnlyNewServices());
}
public PropertyBasedTestRunner(ITestExecutionEngine executionEngine, IObjectContainer container)
{
this.normalExecutionEngine = executionEngine;
var nullContainer = new ObjectContainer(container);
nullContainer.RegisterInstanceAs((IBindingInvoker) new NullBindingInvoker());
nullContainer.RegisterTypeAs <TestExecutionEngine, ITestExecutionEngine>();
this.nullExecutionEngine = nullContainer.Resolve <ITestExecutionEngine>();
//TODO: check with newer SpecFlow if this is still necessary
container.RegisterTypeAs <PropertyBasedTestContext, PropertyBasedTestContext>();
propertyBasedTestContext = container.Resolve <PropertyBasedTestContext>();
}
public static IObjectContainer AddAutoMapper(this IObjectContainer builder, params Assembly[] assemblies)
{
if (builder is null)
{
return(null);
}
var configurationProvider = new MapperConfiguration(config => config.AddMaps(assemblies));
builder.RegisterInstanceAs <IConfigurationProvider>(configurationProvider);
builder.RegisterInstanceAs <IMapper>(new Mapper(builder.Resolve <IConfigurationProvider>()));
return(builder);
}
public void AfterScenario()
{
//TODO: implement logic that has to run after executing each scenario
Console.WriteLine("Calling after scenario");
var featureTitle = FeatureContext.Current.FeatureInfo.Title;
var scenarioTitle = ScenarioContext.Current.ScenarioInfo.Title;
var scenarioTag = ScenarioContext.Current.ScenarioInfo.Tags;
Console.WriteLine($"FeatureTitle: {featureTitle} and ScenarioTitle = {scenarioTitle} with scenarioTag {scenarioTag}");
_driver = _objectContainer.Resolve <IWebDriver>();
_driver.Close();
_driver.Dispose();
_driver.Quit();
}
public ITestRunnerGateway GetTestRunnerGateway()
{
TestRunnerTool testRunnerTool = integrationOptionsProvider.GetOptions().TestRunnerTool;
try
{
return(container.Resolve <ITestRunnerGateway>(testRunnerTool.ToString()));
}
catch (Exception ex)
{
tracer.Trace("Unable to resolve test runner gateway: " + ex, GetType().Name);
return(null);
}
}
private void SetupCallAction(CodeStatementCollection statements)
{
//action();
var callActionStatement = new CodeDelegateInvokeExpression(
new CodeVariableReferenceExpression(NamingHelper.TestActionParameterName));
JsonConfig config = _container.Resolve <JsonConfig>();
if (string.Equals(config.UnitTestProvider, "nunit", StringComparison.InvariantCultureIgnoreCase))
{
/*
* var testExecutionContext = new TestExecutionContext.IsolatedContext();
* try
* {
* action();
* }
* finally
* {
* testExecutionContext.Dispose();
* }
*/
statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(NunitTestExecutionContextClassName),
NamingHelper.TestExecutionContextVariableName,
new CodeObjectCreateExpression(new CodeTypeReference(NunitTestExecutionContextClassName))));
var tryFinallyStatement = new CodeTryCatchFinallyStatement();
tryFinallyStatement.TryStatements.Add(callActionStatement);
tryFinallyStatement.FinallyStatements.Add(new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(NamingHelper.TestExecutionContextVariableName),
nameof(IDisposable.Dispose)));
statements.Add(tryFinallyStatement);
}
else
{
statements.Add(callActionStatement);
}
}
public void BeforeScenario(ScenarioContext scenarioContext)
{
Console.WriteLine("BeforeScenario called");
DriverFactory driverFactory = _objectContainer.Resolve <DriverFactory>();
_driver = driverFactory.CreateDriver();
_objectContainer.RegisterInstanceAs(_driver);
string fileName = scenarioContext.ScenarioInfo.Title.Replace(" ", string.Empty);
fileName += DateTime.UtcNow.ToString("-yyyyMMdd_Hmm");
string outputDirectoryName = ApplicationSettings.TestsVideoDirectory;
}
public static void loadReporter(FeatureContext context, IObjectContainer container)
{
var config = container.Resolve <IConfiguration>();
if (config["appSettings:Reporter"] == "extent")
{
container.RegisterInstanceAs <IReportHelper>(new ExtentReportHelper());
ExtentReportHelper.startReporter(context);
}
else
{
container.RegisterInstanceAs <IReportHelper>(new XmlReportHelper());
XmlReportHelper.startReporter(context);
}
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initilaization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
Container = VsContainerBuilder.CreateContainer(this);
OleMenuCommandService menuCommandService = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (menuCommandService != null)
{
foreach (var menuCommandHandler in Container.Resolve<IDictionary<SpecFlowCmdSet, MenuCommandHandler>>())
{
menuCommandHandler.Value.RegisterTo(menuCommandService, menuCommandHandler.Key);
}
}
}
public void Build()
{
_objectContainer.RegisterTypeAs <ScenarioExecutionConsumer, IScenarioExecutionConsumer>();
_objectContainer.RegisterTypeAs <DriverService, IDriverService>();
_objectContainer.RegisterTypeAs <ElementSelectionService, IElementSelectionService>();
_objectContainer.RegisterTypeAs <AutomationIdProvider, IAutomationIdProvider>();
_objectContainer.RegisterTypeAs <ScopeMarkupStorageContainer, IScopeMarkupStorageContainer>();
_objectContainer.RegisterTypeAs <ScopeMarkupMapper, IScopeMarkupMapper>();
_objectContainer.RegisterTypeAs <UriToPageScopeMapper, IUriToPageScopeMapper>();
_objectContainer.RegisterTypeAs <ScopeContextManager, IScopeContextManager>();
_objectContainer.RegisterTypeAs <ScopeContextRuntime, IScopeContextRuntime>();
var builder = _objectContainer.Resolve <IUserInterfaceBuilder>();
builder.Build();
}
public void CaptureScreenshotsOnError()
{
if (scenarioContext?.TestError == null)
{
return;
}
try
{
var session = objectContainer.Resolve <ISession>();
session.CaptureScreenShot(Path.Combine(Path.GetTempPath(), scenarioContext.ScenarioInfo.Title + ".png"));
}
catch (Exception e)
{
Console.WriteLine($"Could not capture screenshot: '{e.Message}'");
}
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initilaization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));
base.Initialize();
Container = VsContainerBuilder.CreateContainer(this);
OleMenuCommandService menuCommandService = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (menuCommandService != null)
{
foreach (var menuCommandHandler in Container.Resolve <IDictionary <SpecFlowCmdSet, MenuCommandHandler> >())
{
menuCommandHandler.Value.RegisterTo(menuCommandService, menuCommandHandler.Key);
}
}
}
private void TryLog(Exception ex)
{
try
{
IObjectContainer objectContainer = ObjectContainerFactory.GetObjectContainer();
if (!objectContainer.IsRegistered(typeof(ILogger)))
{
objectContainer.RegisterType <ILogger, WcfLogger>(new object[0]);
}
objectContainer.Resolve <ILogger>().Error(ex, null);
}
catch (Exception exception)
{
Debug.WriteLine("WCF log exception error:");
Debug.WriteLine(exception.Message);
}
}
public void AfterScenario(IObjectContainer container, ScenarioContext context, ScenarioInfo info)
{
Console.WriteLine($"### AfterScenario: {info.Title}");
if (context.TestError != null)
{
Console.WriteLine($"### Scenario Error: {context.TestError.Message}");
var screenshotName = new StringBuilder(info.Title);
foreach (var invalidFileNameChar in Path.GetInvalidFileNameChars())
{
screenshotName.Replace(invalidFileNameChar, ' ');
}
container.Resolve <AnyPage>().MakeScreenshot(screenshotName.ToString());
}
}
public void TearDown()
{
IWebDriver driver = container.Resolve <IWebDriver>();
// Screenshot
string img = SaveScreenShotClass.SaveScreenshot(Driver.driver, "Report");
// test.Log(LogStatus.Info, "Snapshot below: " + test.AddScreenCapture(img));
//Close the browser
Close();
// end test. (Reports)
// CommonMethods.Extent.EndTest(test);
// calling Flush writes everything to the log file (Reports)
// CommonMethods.Extent.Flush();
}
/// <summary>
/// Get the web driver initialiser for the configured browser type.
/// </summary>
/// <param name="arg">The object container.</param>
/// <returns>The web driver intialiser.</returns>
private static IWebDriverInitialiser GetWebDriverInitialiser(IObjectContainer arg)
{
var testConfiguration = arg.Resolve <ITestConfiguration>();
switch (testConfiguration.BrowserType)
{
case BrowserType.Chrome: return(new ChromeWebDriverInitialiser());
case BrowserType.Edge: return(new EdgeWebDriverInitialiser());
case BrowserType.InternetExplorer: return(new InternetExporerWebDriverInitialiser());
case BrowserType.Firefox: return(new FirefoxWebDriverInitialiser());
default: throw new Exception($"Browser type {testConfiguration.BrowserType} is not configured.");
}
}
public void Initialize(IObjectContainer container, IEnumerable <Type> types)
{
types.Where(type => type.IsClass && !type.IsAbstract && typeof(IResult).IsAssignableFrom(type))
.ForEach(resultType => {
var handler = container.Resolve(typeof(IEnvelopedMessageHandler <>).MakeGenericType(resultType));
if (handler == null)
{
var errorMessage =
string.Format("not found the handler of this type('{0}') with IEnvelopedMessageHandler<>.",
resultType.FullName);
LogManager.Default.Fatal(errorMessage);
throw new SystemException(errorMessage);
}
_resultHandlers[resultType] = handler;
});
}
public void WhenASubmissionEventHasRaisedWithEmpRefAAAndNINOQQCAndULN(string apprenticeshipId, string nino, string uln, string ukprn)
{
_uln = long.Parse(uln);
var providereventsApiMessageHandlers = _objectContainer.Resolve <ProviderEventsApiMessageHandler>();
var submissionEvents = _objectCreator.Create <SubmissionEvent>(x => { x.ActualStartDate = new DateTime(2017, 12, 14); x.ApprenticeshipId = long.Parse(apprenticeshipId); x.Ukprn = long.Parse(ukprn); x.NiNumber = nino; x.Id = 1; x.Uln = _uln; });
providereventsApiMessageHandlers.SetupGetSubmissionEvents(1, new PageOfResults <SubmissionEvent> {
Items = new[] { submissionEvents }, PageNumber = 1, TotalNumberOfPages = 1
});
}
public virtual void RegisterDefaults(IObjectContainer container)
{
var serviceProvider = container.Resolve<IServiceProvider>();
RegisterVsDependencies(container, serviceProvider);
container.RegisterTypeAs<IntegrationOptionsProvider, IIntegrationOptionsProvider>();
container.RegisterInstanceAs<IIdeTracer>(VsxHelper.ResolveMefDependency<IVisualStudioTracer>(serviceProvider));
container.RegisterInstanceAs(VsxHelper.ResolveMefDependency<IProjectScopeFactory>(serviceProvider));
container.RegisterTypeAs<TestRunnerEngine, ITestRunnerEngine>();
container.RegisterTypeAs<TestRunnerGatewayProvider, ITestRunnerGatewayProvider>();
container.RegisterTypeAs<MsTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.MsTest.ToString());
container.RegisterTypeAs<ReSharperTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper.ToString());
container.RegisterTypeAs<SpecRunTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.SpecRun.ToString());
container.RegisterTypeAs<AutoTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.Auto.ToString());
RegisterCommands(container);
}
private static ITestRunner CreateTestRunner(Assembly testAssembly)
{
var testRunContainerBuilderType = typeof(ITestRunner).Assembly
.GetType("TechTalk.SpecFlow.Infrastructure.TestRunContainerBuilder", true);
var testRunContainerBuilder =
testRunContainerBuilderType.ReflectionCreateInstance <object>(
new[] { typeof(IDefaultDependencyProvider) }, new object[] { null });
IObjectContainer container = testRunContainerBuilder.ReflectionCallMethod <IObjectContainer>(
"CreateContainer", new[] { typeof(IRuntimeConfigurationProvider) }, new object[] { null });
// reset IBindingInvoker to avoid invoking hooks (Issue #27)
container.RegisterTypeAs <NoInvokeDependencyProvider.NullBindingInvoker, IBindingInvoker>();
var testRunnerManager = container.Resolve <ITestRunnerManager>();
testRunnerManager.Initialize(testAssembly);
return(testRunnerManager.GetTestRunner(0));
}
protected override object DoGetInstance(Type serviceType, string key)
{
if (!string.IsNullOrWhiteSpace(key))
{
throw new NotImplementedException("DoGetInstance when key has a value has not been implemented.");
}
try
{
var value = _objectContainer.Resolve(serviceType);
return(value);
}
catch (Exception exception)
{
throw new Exception(string.Format("{0} has not been registered with IObjectContainer. See {1}.BeforeScenario().", serviceType, typeof(SetupSteps)), exception);
}
}
/// <summary>
/// No more configuration needed for message bus - now configure something else or start the bus.
/// </summary>
/// <param name="cfg"></param>
/// <returns></returns>
public static BaseConfiguration Done(this MessageBusConfiguration cfg)
{
IObjectContainer container = ObjectContainerConfigurationExtensions.GetObjectContainer(cfg);
IDocumentStoreFactory subscriptionStoreFactory = GetSubscriptionStore(cfg);
if (!container.HasComponent(typeof(IRouteManager)))
{
container.AddComponent <IRouteManager, RouteManager>();
}
IRouteManager routeManager = container.Resolve <IRouteManager>();
ISubscriptionService subscriptionService = new SubscriptionService(subscriptionStoreFactory, routeManager);
cfg.Set(SubscriptionService_SettingsKey, subscriptionService);
container.RegisterInstance <ISubscriptionService>(subscriptionService);
return(new BaseConfiguration(cfg));
}
public void TakeScreenshot(IWebDriver driver, IObjectContainer objectContainer)
{
var screenshot = ((ITakesScreenshot)driver).GetScreenshot();
var screenshotTitle = DateTime.Now.ToString("yyyy-MM-dd-HH_mm_ss");
var scenarioInfo = objectContainer.Resolve <ScenarioInfo>();
var scenarioTitle = scenarioInfo.Title;
string screenshotfilename = scenarioTitle + "_" + screenshotTitle + ".jpg";
string folder = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
string specificFolder = Path.Combine(folder, "Temp", "AutomatedTests", "Screenshots");
if (!Directory.Exists(specificFolder))
{
Directory.CreateDirectory(specificFolder);
}
string filePath = Path.Combine(specificFolder, screenshotfilename);
screenshot.SaveAsFile(filePath, OpenQA.Selenium.ScreenshotImageFormat.Jpeg);
}
public virtual void RegisterDefaults(IObjectContainer container)
{
var serviceProvider = container.Resolve <IServiceProvider>();
RegisterVsDependencies(container, serviceProvider);
container.RegisterTypeAs <IntegrationOptionsProvider, IIntegrationOptionsProvider>();
container.RegisterInstanceAs <IIdeTracer>(VsxHelper.ResolveMefDependency <IVisualStudioTracer>(serviceProvider));
container.RegisterInstanceAs(VsxHelper.ResolveMefDependency <IProjectScopeFactory>(serviceProvider));
container.RegisterTypeAs <TestRunnerEngine, ITestRunnerEngine>();
container.RegisterTypeAs <TestRunnerGatewayProvider, ITestRunnerGatewayProvider>();
container.RegisterTypeAs <MsTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.MsTest.ToString());
container.RegisterTypeAs <ReSharper5TestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper5.ToString());
container.RegisterTypeAs <ReSharper6TestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper.ToString());
container.RegisterTypeAs <SpecRunTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.SpecRun.ToString());
container.RegisterTypeAs <AutoTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.Auto.ToString());
RegisterCommands(container);
}
/// <summary>
/// Initializes a new instance of the <see cref="BeforeReleaseCallCommand"/> class.
/// </summary>
/// <param name="container">The container.</param>
public MarkDoneCommand(IObjectContainer container)
{
this.container = container;
// Initialize the trace system
this.log = container.Resolve <ILogger>();
// Create a child trace section
this.log = log.CreateChildLogger("MarkDoneLog");
var contextDictionary = Context as IDictionary <string, object>;
object caseObject;
if (contextDictionary != null && contextDictionary.TryGetValue("Case", out caseObject))
{
var theCase = caseObject as ICase;
_caseIdentifier = theCase;
}
}
/// <summary>
/// 获取格式化器
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
//public async static Task<FormatterBase> GetFormatterAsync(String data)
public static FormatterBase GetFormatter(string data)
{
// var protocal = await GetDataProtocalTypeAsync(data);
//var protocal = GetDataProtocalType(data);
const DataProtocalType protocal = DataProtocalType.Json;
//switch (protocal)
//{
// case DataProtocalType.Json:
// formatter = new JsonFormatter();
// break;
// case DataProtocalType.Xml:
// formatter = new XmlFormatter();
// break;
// default:
// formatter = new NotSupportFormatter();
// break;
//}
var formatter = Container.Resolve <FormatterBase>(protocal.ToString());
return(formatter);
}
public CiscoVoiceView(ICiscoVoiceModel ciscoVoiceModel, IObjectContainer container)
{
Model = ciscoVoiceModel;
Model.FinAgent = FinesseEventListener.Instance.FinAgent;
this.container = container;
var interactionManager = container.Resolve <IInteractionManager>();
if (interactionManager != null)
{
interactionManager.InteractionEvent += InteractionManager_InteractionEvent;
}
InitializeComponent();
Width = Double.NaN;
Height = Double.NaN;
MinSize = new MSize()
{
Width = 600, Height = 400.0
};
}
public virtual void RegisterDefaults(IObjectContainer container)
{
var serviceProvider = container.Resolve <IServiceProvider>();
RegisterVsDependencies(container, serviceProvider);
container.RegisterTypeAs <InstallServices, InstallServices>();
container.RegisterTypeAs <InstallServicesHelper, InstallServicesHelper>();
container.RegisterTypeAs <VsBrowserGuidanceNotificationService, IGuidanceNotificationService>();
container.RegisterTypeAs <WindowsFileAssociationDetector, IFileAssociationDetector>();
container.RegisterTypeAs <RegistryStatusAccessor, IStatusAccessor>();
container.RegisterTypeAs <WindowsRegistry, IWindowsRegistry>();
container.RegisterTypeAs <FileService, IFileService>();
container.RegisterTypeAs <DirectoryService, IDirectoryService>();
container.RegisterInstanceAs <IIdeTracer>(VsxHelper.ResolveMefDependency <IVisualStudioTracer>(serviceProvider));
container.RegisterInstanceAs(VsxHelper.ResolveMefDependency <IProjectScopeFactory>(serviceProvider));
container.RegisterTypeAs <StepDefinitionSkeletonProvider, IStepDefinitionSkeletonProvider>();
container.RegisterTypeAs <DefaultSkeletonTemplateProvider, ISkeletonTemplateProvider>();
container.RegisterTypeAs <StepTextAnalyzer, IStepTextAnalyzer>();
container.RegisterTypeAs <TelemetryClientWrapper, TelemetryClientWrapper>();
container.RegisterTypeAs <AppInsightsEventConverter, IAppInsightsEventConverter>();
container.RegisterTypeAs <AppInsightsAnalyticsTransmitterSink, IAnalyticsTransmitterSink>();
container.RegisterTypeAs <VisualStudioProjectTargetFrameworksProvider, IProjectTargetFrameworksProvider>();
container.RegisterTypeAs <VisualStudioIdeInformationStore, IIdeInformationStore>();
container.RegisterTypeAs <AnalyticsTransmitter, IAnalyticsTransmitter>();
container.RegisterTypeAs <EnableAnalyticsChecker, IEnableAnalyticsChecker>();
container.RegisterTypeAs <FileUserIdStore, IUserUniqueIdStore>();
container.RegisterTypeAs <EnvironmentSpecFlowTelemetryChecker, IEnvironmentSpecFlowTelemetryChecker>();
container.RegisterTypeAs <CurrentExtensionVersionProvider, ICurrentExtensionVersionProvider>();
container.RegisterTypeAs <DevBuildChecker, IDevBuildChecker>();
RegisterCommands(container);
}
public void Setup()
{
container = GeneratorContainerBuilder.CreateContainer(new SpecFlowConfigurationHolder(), new ProjectSettings());
container.RegisterInstanceAs<IUnitTestGeneratorProvider>(container.Resolve<XUnitTestGeneratorProvider>());
}
public FeatureGeneratorRegistry(IObjectContainer objectContainer)
{
providers = objectContainer.Resolve<IDictionary<string, IFeatureGeneratorProvider>>().OrderBy(item => item.Value.Priority).ToList();
}
/// <summary>
/// 创建一个可用于缓存的拦截器
/// </summary>
public override IInterceptor CreateInterceptor(IObjectContainer container)
{
var cacheProvider = container.Resolve<ICacheProvider>();
return new CachingInterceptor(this, cacheProvider);
}
public BindingFactory(IObjectContainer container)
{
this.runtimeConfiguration = container.Resolve<RuntimeConfiguration>();
this.errorProvider = container.Resolve<IErrorProvider>();
}
public PostSteps(IObjectContainer objectContainer) {
_lazyOrchardClientForMarkus = new Lazy<IOrchardClient>(() =>objectContainer.Resolve<IOrchardClient>(ExampleUser.MarkusMachado.Username));
_lazyOrchardClientForVasundhara = new Lazy<IOrchardClient>(() => objectContainer.Resolve<IOrchardClient>(ExampleUser.VasundharaAraya.Username));
}
public ITestRunnerGateway CreateTestRunner(IObjectContainer container)
{
return container.Resolve<ITestRunnerGateway>(tool.ToString());
}
public virtual IObjectContainer CreateScenarioContainer(IObjectContainer testThreadContainer, ScenarioInfo scenarioInfo)
{
if (testThreadContainer == null)
throw new ArgumentNullException(nameof(testThreadContainer));
var scenarioContainer = new ObjectContainer(testThreadContainer);
scenarioContainer.RegisterInstanceAs(scenarioInfo);
var contextManager = testThreadContainer.Resolve<IContextManager>();
var featureContext = contextManager.FeatureContext;
if (featureContext != null)
scenarioContainer.RegisterInstanceAs(featureContext);
scenarioContainer.ObjectCreated += obj =>
{
var containerDependentObject = obj as IContainerDependentObject;
if (containerDependentObject != null)
containerDependentObject.SetObjectContainer(scenarioContainer);
};
var runtimePluginEvents = testThreadContainer.Resolve<RuntimePluginEvents>();
runtimePluginEvents.RaiseCustomizeScenarioDependencies(scenarioContainer);
return scenarioContainer;
}
public void Invoke(IObjectContainer dependencyResolver, object message)
{
object handlerInstance = dependencyResolver.Resolve(Method.DeclaringType);
Method.Invoke(handlerInstance, new object[] { message });
}
public override void OnStoped(IObjectContainer container)
{
container.Resolve<IQueueService>().Stop();
container.Resolve<IRawDataService>().Stop();
container.Resolve<IInstructionService>().Stop();
}
internal static TestRunner CreateTestRunner(out IObjectContainer createThreadContainer, Action<IObjectContainer> registerTestThreadMocks = null, Action<IObjectContainer> registerGlobalMocks = null)
{
createThreadContainer = CreateDefaultTestThreadContainer(registerTestThreadMocks: registerTestThreadMocks, registerGlobalMocks: registerGlobalMocks);
return (TestRunner)createThreadContainer.Resolve<ITestRunner>();
}
public object ResolveBindingInstance(Type bindingType, IObjectContainer scenarioContainer)
{
return scenarioContainer.Resolve(bindingType);
}
public virtual IObjectContainer CreateTestThreadContainer(IObjectContainer globalContainer)
{
var testThreadContainer = new ObjectContainer(globalContainer);
defaultDependencyProvider.RegisterTestThreadContainerDefaults(testThreadContainer);
var runtimePluginEvents = globalContainer.Resolve<RuntimePluginEvents>();
runtimePluginEvents.RaiseCustomizeTestThreadDependencies(testThreadContainer);
testThreadContainer.Resolve<IBindingInstanceResolver>();
return testThreadContainer;
}
