private void Then_the_contact_book_should_contains_all_other_contacts(ScenarioContext ctx)
 {
     Assert.AreElementsEqualIgnoringOrder(
         ctx.ContactBook.Contacts.ToArray(),
         ctx.AddedContacts.Except(ctx.RemovedContacts).ToArray(),
         "All contacts that has not been explicitly removed should be still present in contact book");
 }
 private void Then_all_contacts_should_be_available_in_the_contact_book(ScenarioContext ctx)
 {
     Assert.That(
         ctx.ContactBook.Contacts.ToArray(),
         Is.EquivalentTo(ctx.AddedContacts),
         "Contacts should be added to contact book");
 }
 private void Then_all_contacts_should_be_available_in_the_contact_book(ScenarioContext ctx)
 {
     Assert.AreElementsEqualIgnoringOrder(
         ctx.AddedContacts,
         ctx.ContactBook.Contacts.ToArray(),
         "Contacts should be added to contact book");
 }
 private void Then_all_contacts_should_be_available_in_the_contact_book(ScenarioContext ctx)
 {
     CollectionAssert.AreEquivalent(
         ctx.AddedContacts,
         ctx.ContactBook.Contacts.ToArray(),
         "Contacts should be added to contact book");
 }
 public void Initialize()
 {
     featureContext = new FeatureContext(null);
     scenarioContext = new ScenarioContext(featureContext, null);
     stepContext = new StepContext(featureContext, scenarioContext);
     sut = new ContextHandler(featureContext, scenarioContext, stepContext);
 }
 private void Then_the_contact_book_should_contains_all_other_contacts(ScenarioContext ctx)
 {
     Assert.That(
         ctx.AddedContacts.Except(ctx.RemovedContacts).ToArray(),
         Is.EquivalentTo(ctx.ContactBook.Contacts.ToArray()),
         "All contacts that has not been explicitly removed should be still present in contact book");
 }
 private void Then_the_contact_book_should_not_contain_removed_contact_any_more(ScenarioContext ctx)
 {
     Assert.AreEqual(
         Enumerable.Empty<Contact>(),
         ctx.ContactBook.Contacts.Where(c => ctx.RemovedContacts.Contains(c)).ToArray(),
         "Contact book should not contain removed books");
 }
        public void Setup()
        {
            skeletonProviders = new Dictionary<ProgrammingLanguage, IStepDefinitionSkeletonProvider>();
            skeletonProviders.Add(ProgrammingLanguage.CSharp, new Mock<IStepDefinitionSkeletonProvider>().Object);

            var culture = new CultureInfo("en-US");
            contextManagerStub = new Mock<IContextManager>();
            scenarioContext = new ScenarioContext(new ScenarioInfo("scenario_title"), null, null);
            contextManagerStub.Setup(cm => cm.ScenarioContext).Returns(scenarioContext);
            contextManagerStub.Setup(cm => cm.FeatureContext).Returns(new FeatureContext(new FeatureInfo(culture, "feature_title", "", ProgrammingLanguage.CSharp), culture));

            runtimeBindingRegistryBuilderStub = new Mock<IRuntimeBindingRegistryBuilder>();

            bindingRegistryStub = new Mock<IBindingRegistry>();
            bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeStep)).Returns(beforeStepEvents);
            bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterStep)).Returns(afterStepEvents);
            bindingRegistryStub.Setup(br => br.GetHooks(HookType.BeforeScenarioBlock)).Returns(beforeScenarioBlockEvents);
            bindingRegistryStub.Setup(br => br.GetHooks(HookType.AfterScenarioBlock)).Returns(afterScenarioBlockEvents);

            runtimeConfiguration = new RuntimeConfiguration();
            errorProviderStub = new Mock<IErrorProvider>();
            testTracerStub = new Mock<ITestTracer>();
            stepDefinitionMatcherStub = new Mock<IStepDefinitionMatchService>();
            methodBindingInvokerMock = new Mock<IBindingInvoker>();

            stepErrorHandlers = new Dictionary<string, IStepErrorHandler>();
        }
        public void SetUp()
        {
            // ScenarioContext is needed, because the [Binding]-instances live there
            var scenarioContext = new ScenarioContext(null,new ObjectContainer());
            contextManagerStub.Setup(cm => cm.ScenarioContext).Returns(scenarioContext);

            bindingRegistryStub.Setup(br => br.GetStepTransformations()).Returns(stepTransformations);
        }
        public void SetUp()
        {
            // ScenarioContext is needed, because the [Binding]-instances live there
            var scenarioContext = new ScenarioContext(null, null, null);
            contextManagerStub.Setup(cm => cm.ScenarioContext).Returns(scenarioContext);

            List<StepTransformationBinding> stepTransformations = new List<StepTransformationBinding>();
            bindingRegistryStub.Setup(br => br.StepTransformations).Returns(stepTransformations);
        }
 void RegisterInheritanceHierarchyOfContextInSettings(ScenarioContext context)
 {
     var type = context.GetType();
     while (type != typeof(object))
     {
         endpointConfiguration.GetSettings().Set(type.FullName, scenarioContext);
         type = type.BaseType;
     }
 }
Beispiel #12
0
        public Result Initialize(RunDescriptor run, EndpointBehaviour endpointBehaviour, IDictionary<Type, string> routingTable, string endpointName)
        {
            try
            {
                behaviour = endpointBehaviour;
                scenarioContext = run.ScenarioContext;
                configuration = ((IEndpointConfigurationFactory)Activator.CreateInstance(endpointBehaviour.EndpointBuilderType)).Get();
                configuration.EndpointName = endpointName;

                if (!string.IsNullOrEmpty(configuration.CustomMachineName))
                {
                    NServiceBus.Support.RuntimeEnvironment.MachineNameAction = () => configuration.CustomMachineName;
                }

                //apply custom config settings
                endpointBehaviour.CustomConfig.ForEach(customAction => customAction(config));
                config = configuration.GetConfiguration(run, routingTable);

                if (scenarioContext != null)
                {
                    config.Configurer.RegisterSingleton(scenarioContext.GetType(), scenarioContext);
                    scenarioContext.ContextPropertyChanged += scenarioContext_ContextPropertyChanged;
                }

                bus = config.CreateBus();

                Configure.Instance.ForInstallationOn<Windows>().Install();

                Task.Factory.StartNew(() =>
                    {
                        while (!stopped)
                        {
                            contextChanged.WaitOne(TimeSpan.FromSeconds(5)); //we spin around each 5 s since the callback mechanism seems to be shaky

                            lock (behaviour)
                            {

                                foreach (var when in behaviour.Whens)
                                {
                                    if (executedWhens.Contains(when.Id))
                                        continue;

                                    if(when.ExecuteAction(scenarioContext, bus))
                                        executedWhens.Add(when.Id);
                                }
                            }
                        }
                    });

                return Result.Success();
            }
            catch (Exception ex)
            {
                Logger.Error("Failed to initalize endpoint " + endpointName, ex);
                return Result.Failure(ex);
            }
        }
        private void AddSomeContacts(ScenarioContext ctx)
        {
            ctx.AddedContacts = new[]
            {
                new Contact("Jack", "123-456-789"),
                new Contact("Samantha", "321-654-987"),
                new Contact("Josh", "132-465-798")
            };

            foreach (var contact in ctx.AddedContacts)
                ctx.ContactBook.AddContact(contact.Name, contact.PhoneNumber);
        }
Beispiel #14
0
        void ProcessStep(Step step, Criterion criterion, ScenarioContext scenarioContext,
            IExecutionContextFactory executionContextFactory)
        {
            dynamic executionContext = executionContextFactory.Create(scenarioContext.Scenario, step);

            _progressReporter.Report(new StepStartedReport(scenarioContext.Scenario.ScenarioId, criterion.CriterionId,
                step.StepId, executionContext.ExecutionContextId));

            StepExecutionResult result = executionContext.Execute(step as dynamic, scenarioContext);

            _progressReporter.Report(new StepStoppedReport(scenarioContext.Scenario.ScenarioId, criterion.CriterionId,
                step.StepId, executionContext.ExecutionContextId, result));
        }
Beispiel #15
0
        public void Run(Criterion criterion, ScenarioContext scenarioContext,
            IExecutionContextFactory executionContextFactory)
        {
            _progressReporter.Report(new CriterionStartedReport(scenarioContext.Scenario.ScenarioId,
                criterion.CriterionId));

            foreach (Step step in criterion.Steps)
            {
                ProcessStep(step, criterion, scenarioContext, executionContextFactory);
            }

            _progressReporter.Report(new CriterionStoppedReport(scenarioContext.Scenario.ScenarioId,
                criterion.CriterionId));
        }
        public async Task Initialize(RunDescriptor run, EndpointBehavior endpointBehavior,
            IDictionary<Type, string> routingTable, string endpointName)
        {
            try
            {
                behavior = endpointBehavior;
                scenarioContext = run.ScenarioContext;
                runSettings = run.Settings;
                var endpointConfigurationFactory = (IEndpointConfigurationFactory)Activator.CreateInstance(endpointBehavior.EndpointBuilderType);
                endpointConfigurationFactory.ScenarioContext = run.ScenarioContext;
                configuration = endpointConfigurationFactory.Get();
                configuration.EndpointName = endpointName;

                if (!string.IsNullOrEmpty(configuration.CustomMachineName))
                {
                    RuntimeEnvironment.MachineNameAction = () => configuration.CustomMachineName;
                }

                //apply custom config settings
                if (configuration.GetConfiguration == null)
                {
                    throw new Exception($"Missing EndpointSetup<T> in the constructor of {endpointName} endpoint.");
                }
                endpointConfiguration = await configuration.GetConfiguration(run, routingTable).ConfigureAwait(false);
                RegisterInheritanceHierarchyOfContextInSettings(scenarioContext);

                endpointBehavior.CustomConfig.ForEach(customAction => customAction(endpointConfiguration, scenarioContext));

                if (configuration.SendOnly)
                {
                    endpointConfiguration.SendOnly();
                }

                startable = await Endpoint.Create(endpointConfiguration).ConfigureAwait(false);

                if (!configuration.SendOnly)
                {
                    var transportInfrastructure = endpointConfiguration.GetSettings().Get<TransportInfrastructure>();
                    scenarioContext.HasNativePubSubSupport = transportInfrastructure.OutboundRoutingPolicy.Publishes == OutboundRoutingType.Multicast;
                }
            }
            catch (Exception ex)
            {
                Logger.Error("Failed to initialize endpoint " + endpointName, ex);
                throw;
            }
        }
 public ContextAppender(ScenarioContext context)
 {
     this.context = context;
 }
Beispiel #18
0
 protected override void SetupContextTags()
 {
     var f = new FeatureContext(null, new string[0]);
     Tiny.TinyIoCContainer.Current.Register(f);
     var c = new ScenarioContext(f, null, new[] { "DontRun" });
     Tiny.TinyIoCContainer.Current.Register(c);
 }
Beispiel #19
0
 protected override void SetupContextTags()
 {
     var f = new FeatureContext(null, new[] { "tag1" });
     Tiny.TinyIoCContainer.Current.Register(f);
     var c = new ScenarioContext(f, null, new[] { "tag2", "tag5" });
     Tiny.TinyIoCContainer.Current.Register(c);
 }
 private void Then_the_contact_book_should_contains_all_other_contacts(ScenarioContext ctx)
 {
     Assert.Equal(
         ctx.ContactBook.Contacts.ToArray(),
         ctx.AddedContacts.Except(ctx.RemovedContacts).ToArray());
 }
Beispiel #21
0
 public ContextAppender(ScenarioContext context, EndpointConfiguration endpointConfiguration)
 {
     this.context = context;
     this.endpointConfiguration = endpointConfiguration;
 }
 private void Given_my_contact_book_is_filled_with_contacts(ScenarioContext ctx)
 {
     ctx.ContactBook = new ContactBook();
     AddSomeContacts(ctx);
 }
 private void Then_the_contact_book_should_be_empty(ScenarioContext ctx)
 {
     Assert.IsEmpty(ctx.ContactBook.Contacts, "Contact book should be empty");
 }
 private void Given_my_contact_book_is_empty(ScenarioContext ctx)
 {
     ctx.ContactBook = new ContactBook();
 }
 private void When_I_clear_it(ScenarioContext ctx)
 {
     foreach (var contact in ctx.ContactBook.Contacts.ToArray())
         ctx.ContactBook.Remove(contact.Name);
     StepExecution.Bypass("Contact book clearing is not implemented yet. Contacts are removed one by one.");
 }
 private void Given_my_contact_book_is_filled_with_many_contacts(ScenarioContext ctx)
 {
     for (int i = 0; i < 10000; ++i)
         ctx.ContactBook.AddContact(i.ToString(CultureInfo.InvariantCulture), i.ToString(CultureInfo.InvariantCulture));
 }
 private void When_I_add_new_contacts(ScenarioContext ctx)
 {
     AddSomeContacts(ctx);
 }
 private void Then_all_contacts_should_be_available_in_the_contact_book(ScenarioContext ctx)
 {
     Assert.Equal(
         ctx.AddedContacts,
         ctx.ContactBook.Contacts.ToArray());
 }
Beispiel #29
0
 public ContextHandler(FeatureContext featureContext, ScenarioContext scenarioContext, StepContext stepContext)
 {
     this.featureContext = featureContext;
     this.scenarioContext = scenarioContext;
     this.stepContext = stepContext;
 }
 private void When_I_remove_one_contact(ScenarioContext ctx)
 {
     ctx.RemovedContacts = ctx.ContactBook.Contacts.Take(1).ToArray();
     foreach (var contact in ctx.RemovedContacts)
         ctx.ContactBook.Remove(contact.Name);
 }