public void Install_should_install_if_a_package_has_not_been_installed_yet()
        {
            // Arrange
            var fixture = new Fixture().Customize(new AutoMoqCustomization());

            var proj = fixture.Freeze<Project>();
            var pwPkg = new ProjectWidePackage("Prig", "2.0.0", proj);
            var mocks = new MockRepository(MockBehavior.Strict);
            {
                var m = mocks.Create<IVsPackageInstallerServices>();
                m.Setup(_ => _.IsPackageInstalledEx(proj, "Prig", "2.0.0")).Returns(false);
                m.Setup(_ => _.IsPackageInstalled(proj, "Prig")).Returns(false);
                fixture.Inject(m);
            }
            {
                var m = mocks.Create<IVsPackageUninstaller>();
                fixture.Inject(m);
            }
            {
                var m = mocks.Create<IVsPackageInstaller>();
                m.Setup(_ => _.InstallPackage(default(string), proj, "Prig", "2.0.0", false));
                fixture.Inject(m);
            }

            var pwInstllr = fixture.NewProjectWideInstaller();


            // Act
            pwInstllr.Install(pwPkg);


            // Assert
            mocks.VerifyAll();
        }
 private SchedulerTaskFactory Create(ATaskScheduler scheduler)
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     fixture.Inject(scheduler);
     var factory = fixture.Create<ITaskSchedulerFactory>();
     factory.Create().Returns(scheduler);
     fixture.Inject(factory);
     return fixture.Create<SchedulerTaskFactory>();
 }
 public void Get_CorrelationId()
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     var messageId = fixture.Create<IMessageId>();
     var id = fixture.Create<ICorrelationId>();
     fixture.Inject(messageId);
     fixture.Inject(id);
     var test = fixture.Create<SentMessage>();
     Assert.Equal(test.CorrelationId, id);
 }
Example #4
0
        public void Create_Default()
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            var headers = fixture.Create<IStandardHeaders>();
            var customHeaders = fixture.Create<ICustomHeaders>();
            fixture.Inject(headers);
            fixture.Inject(customHeaders);
            var test = fixture.Create<Headers>();

            Assert.Equal(headers, test.StandardHeaders);
            Assert.Equal(customHeaders, test.CustomHeaders);
        }
 public void DoubleParameterGetReturnsCorrectResult(
     int number,
     string text)
 {
     // Fixture setup
     var fixture = new Fixture();
     fixture.Inject(number);
     fixture.Inject(text);
     // Exercise system
     var actual = fixture.Get((int x, string y) => x + y);
     // Verify outcome
     Assert.Equal(number + text, actual);
     // Teardown
 }
Example #6
0
        private IHistogram Create(global::Metrics.Histogram histogram)
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            fixture.Inject(histogram);
            return(fixture.Create <Net.Histogram>());
        }
        private ConsumerMethodQueue CreateQueue()
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            fixture.Inject(CreateConsumerQueue());
            return(fixture.Create <ConsumerMethodQueue>());
        }
Example #8
0
        public async Task TestWithHttpMock()
        {
            var url = new Uri("https://test.com");

            var mockHttp = new MockHttpMessageHandler();
            var body     = "<html></html>";

            mockHttp.When(url.ToString())
            .Respond("text/html", body);

            var fixture = new Fixture();

            fixture.Customize(new AutoMoqCustomization {
                ConfigureMembers = true
            });
            fixture.Inject(mockHttp.ToHttpClient());

            IDocumentProvider uut = fixture.Create <DocumentProvider>();

            var document = await uut.FetchDocumentAsync(url);

            Assert.AreEqual(body.Length, document.Length);

            mockHttp.VerifyNoOutstandingRequest();
        }
        private QueueConfigurationReceive Create()
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            fixture.Inject <IConfiguration>(new AdditionalConfiguration());
            return(fixture.Create <QueueConfigurationReceive>());
        }
        public void When_calling_IsEnabled_Then_the_expected_result_is_returned()
        {
            var fixture = new Fixture();

            var dictionary = new Dictionary <string, bool>()
            {
                { "Key1", false },
                { "Key2", true }
            };
            var options = Substitute.For <IOptions <Dictionary <string, bool> > >();

            options.Value.Returns(dictionary);
            fixture.Inject(options);
            var sut = fixture.Create <ConfigFileFeatureFlagProvider>();

            Assert.Multiple(() =>
            {
                var result = sut.IsEnabled("Key1");
                Assert.That(result, Is.False);
                var result2 = sut.IsEnabled("Key2");
                Assert.That(result2);
                var result3 = sut.IsEnabled("Finnes ikke");
                Assert.That(result3, Is.False);
            });
        }
Example #11
0
        public void ReportPackageReferenceAddedProgress_should_report_the_progress_to_statusbar()
        {
            // Arrange
            var fixture = new Fixture().Customize(new AutoMoqCustomization());

            var prog = fixture.Create <uint>();
            var id   = fixture.Create <string>();
            {
                var m = new Mock <IVsPackageMetadata>(MockBehavior.Strict);
                m.Setup(_ => _.Id).Returns(id);
                fixture.Inject(m);
            }

            var vm = new PrigViewModel();

            // Act
            vm.ReportPackageReferenceAddedProgress(prog, fixture.Freeze <IVsPackageMetadata>());


            // Assert
            var progState = vm.Statusbar.ProgressState.Value;

            Assert.AreEqual(prog, progState.Value);
            Assert.That(progState.Label, Is.StringMatching(id));
        }
        public void sut_has_guard_clauses()
        {
            IFixture builder = new Fixture().Customize(new AutoMoqCustomization());

            builder.Inject(EventHubClient.CreateFromConnectionString(_connectionString));
            new GuardClauseAssertion(builder).Verify(typeof(EventHubMessageBus));
        }
Example #13
0
        public void StartSourcing_should_add_the_specified_source_if_it_has_not_existed_yet()
        {
            using (var nugetConfig = new FileInfo(Path.Combine(Environment.ExpandEnvironmentVariables("%APPDATA%"), @"NuGet\NuGet.Config")).BeginModifying())
            {
                // Arrange
                nugetConfig.Info.Delete();

                var fixture = new Fixture().Customize(new AutoMoqCustomization());
                {
                    var m = new Mock <IEnvironmentRepository>(MockBehavior.Strict);
                    m.Setup(_ => _.GetNuGetPath()).Returns(AppDomain.CurrentDomain.GetPathInBaseDirectory(@"tools\NuGet.exe"));
                    fixture.Inject(m);
                }

                var nugetExecutor = fixture.NewNuGetExecutor();


                // Act
                var result = nugetExecutor.StartSourcing("Prig Source", AppDomain.CurrentDomain.BaseDirectory);


                // Assert
                Assert.That(result, Is.StringMatching("Prig Source"));
            }
        }
Example #14
0
        private static void SetupLandisGyrContext(Fixture fix)
        {
            var dbOptions = new DbContextOptionsBuilder()
                            .UseInMemoryDatabase(Guid.NewGuid().ToString());

            fix.Inject(new LandisGyrContext(dbOptions.Options));
        }
Example #15
0
        private ITimer Create(App.Metrics.Timer.ITimer timer)
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            fixture.Inject(timer);
            return(fixture.Create <AppMetrics.Timer>());
        }
Example #16
0
        public void StartInstalling_should_do_nothing_if_it_will_be_executed_after_the_2nd_time()
        {
            using (var prigConfig = new FileInfo(AppDomain.CurrentDomain.GetPathInBaseDirectory(@"tools\Prig.config")).BeginModifying())
            {
                try
                {
                    // Arrange
                    prigConfig.Info.Delete();
                    Environment.SetEnvironmentVariable("URASANDESU_PRIG_PACKAGE_FOLDER", AppDomain.CurrentDomain.BaseDirectory);

                    var fixture = new Fixture().Customize(new AutoMoqCustomization());
                    {
                        var m = new Mock<IEnvironmentRepository>(MockBehavior.Strict);
                        m.Setup(_ => _.GetPrigPath()).Returns(AppDomain.CurrentDomain.GetPathInBaseDirectory(@"tools\prig.exe"));
                        fixture.Inject(m);
                    }

                    var source = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Guid.NewGuid().ToString("N"));
                    Directory.CreateDirectory(source);

                    var prigExecutor = fixture.NewPrigExecutor();

                    // Act
                    prigExecutor.StartInstalling("TestWindow", source);
                    var result = prigExecutor.StartInstalling("TestWindow", source);

                    // Assert
                    Assert.That(result, Is.StringMatching(@"The specified source:.* has already installed\."));
                }
                finally
                {
                    Environment.SetEnvironmentVariable("URASANDESU_PRIG_PACKAGE_FOLDER", null);
                }
            }
        }
Example #17
0
        /// <inheritdoc />
        public Mock <TMockType> Mock <TMockType>() where TMockType : class
        {
            var mockType = typeof(TMockType);

            return(!_mocks.ContainsKey(mockType) ? CreateNew() : _mocks[mockType] as Mock <TMockType>);

            Mock <TMockType> CreateNew()
            {
                var newMock = new Mock <TMockType>();

                _mocks.Add(mockType, newMock);
                _fixture.Inject(newMock.Object);

                return(newMock);
            }
        }
Example #18
0
        public void Setup()
        {
            fixture = new Fixture();
            fixture.Customize(new AutoMoqCustomization());

            var connection = new SqliteConnection("DataSource=:memory:");

            connection.Open();
            var options = new DbContextOptionsBuilder <DatabaseContext>().UseSqlite(connection).Options;
            var db      = new DatabaseContext(options);

            db.Database.EnsureCreated();
            fixture.Inject(new ObjectRepositoryEF(db) as IObjectRepository);
            fixture.Inject(fixture.Build <MeasureConverters>().OmitAutoProperties().Create() as IMeasureConverters);
            quiz = fixture.Create <QuizGenerator>();
        }
Example #19
0
        public void TestAtConstructorDannerBogføringsadvarselVedOvertrækPåKonto()
        {
            var fixture = new Fixture();

            fixture.Inject(DateTime.Now);

            var loebenr = fixture.Create <int>();
            var konto   = fixture.Create <Konto>();

            Assert.That(konto, Is.Not.Null);
            konto.TilføjKreditoplysninger(new Kreditoplysninger(fixture.Create <DateTime>().Year, fixture.Create <DateTime>().Month, 50000M));
            konto.TilføjBogføringslinje(new Bogføringslinje(loebenr, fixture.Create <DateTime>(), fixture.Create <string>(), fixture.Create <string>(), 0M, 48000M));

            var bogføringslinje = new Bogføringslinje(loebenr + 1, fixture.Create <DateTime>(), fixture.Create <string>(), fixture.Create <string>(), 0M, 5000M);

            Assert.That(bogføringslinje, Is.Not.Null);
            konto.TilføjBogføringslinje(bogføringslinje);

            var bogføringsresultat = new Bogføringsresultat(bogføringslinje);

            Assert.That(bogføringsresultat, Is.Not.Null);
            Assert.That(bogføringsresultat.Bogføringslinje, Is.Not.Null);
            Assert.That(bogføringsresultat.Bogføringslinje, Is.EqualTo(bogføringslinje));
            Assert.That(bogføringsresultat.Advarsler, Is.Not.Null);
            Assert.That(bogføringsresultat.Advarsler, Is.TypeOf(typeof(List <IBogføringsadvarsel>)));
            Assert.That(bogføringsresultat.Advarsler.Count(), Is.EqualTo(1));

            var bogføringsadvarsel = bogføringsresultat.Advarsler.ElementAt(0);

            Assert.That(bogføringsadvarsel, Is.Not.Null);
            Assert.That(bogføringsadvarsel.Advarsel, Is.Not.Null);
            Assert.That(bogføringsadvarsel.Konto, Is.Not.Null);
            Assert.That(bogføringsadvarsel.Konto, Is.EqualTo(konto));
            Assert.That(bogføringsadvarsel.Beløb, Is.EqualTo(3000M));
        }
Example #20
0
        public ReadyToRockInstrumentAttribute()
        {
            var instrument = Substitute.For <IInstrument>();

            instrument.Status = InstrumentStatus.ReadyToRock;
            Fixture.Inject(instrument);
        }
Example #21
0
        private ICounter Create(global::Metrics.Counter counter)
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            fixture.Inject(counter);
            return(fixture.Create <Counter>());
        }
Example #22
0
        public BrokenInstrumentAttribute()
        {
            var instrument = Substitute.For <IInstrument>();

            instrument.Status = InstrumentStatus.Broken;
            Fixture.Inject(instrument);
        }
Example #23
0
            static TestCaseData should_set_false_if_null_is_passed()
            {
                var fixture = new Fixture().Customize(new AutoMoqCustomization());

                fixture.Inject(default(ProjectItem));
                return(new TestCaseData(fixture).Returns(false).SetName("should_set_false_if_null_is_passed"));
            }
Example #24
0
        public void StartPacking_should_create_nupkg()
        {
            // Arrange
            var fixture = new Fixture().Customize(new AutoMoqCustomization());
            {
                var m = new Mock <IEnvironmentRepository>(MockBehavior.Strict);
                m.Setup(_ => _.GetNuGetPath()).Returns(AppDomain.CurrentDomain.GetPathInBaseDirectory(@"tools\NuGet.exe"));
                fixture.Inject(m);
            }

            var nugetExecutor = fixture.NewNuGetExecutor();


            // Act
            var result = nugetExecutor.StartPacking(AppDomain.CurrentDomain.GetPathInBaseDirectory(@"tools\NuGet\Prig.nuspec"), AppDomain.CurrentDomain.BaseDirectory);


            // Assert
            var lines = result.Split(new[] { "\r\n" }, StringSplitOptions.None);

            Assert.LessOrEqual(2, lines.Length);
            var match = Regex.Match(lines[1], "'([^']+)'");

            Assert.IsTrue(match.Success);
            var nupkgPath = match.Groups[1].Value;

            Assert.IsTrue(File.Exists(nupkgPath));
            Assert.GreaterOrEqual(TimeSpan.FromSeconds(1), DateTime.Now - File.GetLastWriteTime(nupkgPath));
        }
Example #25
0
        public void AddNewGame()
        {
            var fixture = new Fixture();

            fixture.Customize(new AutoMoqCustomization());

            var newGame = new Game
            {
                Title = "DDD"
            };

            //Arrange
            using (var context = new GameManagementContext(ContextOptions))
            {
                fixture.Inject(context);

                var command = new Add.Command {
                    Title = newGame.Title
                };
                var handler = fixture.Create <Add.CommandHandler>();

                //Act
                var response = handler.Handle(command, new System.Threading.CancellationToken()).Result;

                var game = context.Games.SingleOrDefaultAsync(g => g.Title == newGame.Title).Result;

                //Assert
                Assert.True(response.Success);
                Assert.NotNull(game);
                Assert.Equal(newGame.Title, game.Title);
            }
        }
Example #26
0
        private IHistogram Create(App.Metrics.Histogram.IHistogram histogram)
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            fixture.Inject(histogram);
            return(fixture.Create <DotNetWorkQueue.AppMetrics.Histogram>());
        }
Example #27
0
        private Mock <T> Inject <T>() where T : class
        {
            var mock = new Mock <T>(_mockBehavior);

            Fixture.Inject(mock);
            return(mock);
        }
Example #28
0
        private IMeter Create(global::Metrics.Meter meter)
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            fixture.Inject(meter);
            return(fixture.Create <Net.Meter>());
        }
        public void TestThatGetTargetValueGetsUnmappedTargetValueWhereSourceValueIsNullAndTypeOfTargetIsNullable()
        {
            var fieldMock = MockRepository.GenerateMock <IField>();

            fieldMock.Expect(m => m.DatatypeOfSource)
            .Return(typeof(DateTime?))
            .Repeat.Any();
            fieldMock.Expect(m => m.Map)
            .Return(null)
            .Repeat.Any();
            Assert.That(fieldMock, Is.Not.Null);

            var fixture = new Fixture();

            fixture.Inject <DateTime?>(null);
            var dataObject = new MyDataObject(fieldMock, fixture);

            Assert.That(dataObject, Is.Not.Null);

            var targetValue = dataObject.GetTargetValue <DateTime?>();

            Assert.That(targetValue, Is.Null);

            fieldMock.AssertWasCalled(m => m.DatatypeOfSource);
            fieldMock.AssertWasCalled(m => m.Map);
        }
Example #30
0
        public void TestAtCompareReturnererMinusEnHvisSaldoForYErStørreEndSaldoForX()
        {
            var fixture = new Fixture();

            fixture.Inject(new DateTime(2011, 6, 30));
            var x = fixture.Create <Person>();

            x.TilføjBogføringslinje(new Bogføringslinje(fixture.Create <int>(),
                                                        fixture.Create <DateTime>(),
                                                        fixture.Create <string>(),
                                                        fixture.Create <string>(), 2500M, 0M));
            x.Calculate(fixture.Create <DateTime>());
            var y = fixture.Create <Person>();

            y.TilføjBogføringslinje(new Bogføringslinje(fixture.Create <int>(),
                                                        fixture.Create <DateTime>(),
                                                        fixture.Create <string>(),
                                                        fixture.Create <string>(), 5000M, 0M));
            y.Calculate(fixture.Create <DateTime>());

            var comparer = new AdressekontoSaldoComparer();

            Assert.That(comparer, Is.Not.Null);
            Assert.That(comparer.Compare(x, y), Is.EqualTo(-1));
        }
        public void Create()
        {
            var redisId = new GetRedisIncrId();
            var uuId = new GetUuidMessageId();

            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
            var container = Substitute.For<IContainer>();
            container.GetInstance<GetRedisIncrId>().Returns(redisId);
            container.GetInstance<GetUuidMessageId>().Returns(uuId);
            fixture.Inject(container);

            var factory = fixture.Create<IContainerFactory>();
            factory.Create().ReturnsForAnyArgs(container);

            var options = Helpers.CreateOptions();
            options.MessageIdLocation = MessageIdLocations.RedisIncr;
            var test = new GetMessageIdFactory(factory, options);
            var result = test.Create();
            Assert.IsAssignableFrom(typeof(GetRedisIncrId), result);

            options.MessageIdLocation = MessageIdLocations.Uuid;
            result = test.Create();
            Assert.IsAssignableFrom(typeof(GetUuidMessageId), result);

            options.MessageIdLocation = MessageIdLocations.Custom;
            test.Create();

            options.MessageIdLocation = (MessageIdLocations)99;
            Assert.Throws<DotNetWorkQueueException>(
           delegate
           {
               test.Create();
           });
        }
Example #32
0
        public void TestAtCompareReturnererVærdiFraAndenSorteringHvisSaldoForXErLigSaldoForY()
        {
            var fixture = new Fixture();

            fixture.Inject(new DateTime(2011, 6, 30));
            var x = fixture.Create <Person>();

            x.TilføjBogføringslinje(new Bogføringslinje(fixture.Create <int>(),
                                                        fixture.Create <DateTime>(),
                                                        fixture.Create <string>(),
                                                        fixture.Create <string>(), 5000M, 0M));
            x.Calculate(fixture.Create <DateTime>());
            var y = fixture.Create <Person>();

            y.TilføjBogføringslinje(new Bogføringslinje(fixture.Create <int>(),
                                                        fixture.Create <DateTime>(),
                                                        fixture.Create <string>(),
                                                        fixture.Create <string>(), 5000M, 0M));
            y.Calculate(fixture.Create <DateTime>());

            var comparer = new AdressekontoSaldoComparer();

            Assert.That(comparer, Is.Not.Null);
            Assert.That(comparer.Compare(x, y), Is.Not.EqualTo(0));
        }
Example #33
0
        public void DeleteGame()
        {
            var fixture = new Fixture();

            fixture.Customize(new AutoMoqCustomization());

            var gameId = 1;

            //Arrange
            using (var context = new GameManagementContext(ContextOptions))
            {
                fixture.Inject(context);

                var command = new Delete.Command
                {
                    Id = gameId
                };
                var handler = fixture.Create <Delete.CommandHandler>();

                //Act
                var response = handler.Handle(command, new System.Threading.CancellationToken()).Result;

                var game = context.Games.Find(gameId);

                //Assert
                Assert.True(response.Success);
                Assert.Null(game);
            }
        }
        private StopWorker Create(IQueueCancelWork cancelWork)
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            fixture.Inject(cancelWork);
            return(fixture.Create <StopWorker>());
        }
        public async Task CloseAll_ShouldRequestCloseForAllContainedViewModels(int viewModelCount)
        {
            var router = Fixture.Create <Internal.IRouter>();

            Fixture.Inject(router);

            var region = Fixture.Create <MultiItemsRegion>();
            IList <ReactiveViewModel> viewModels = new List <ReactiveViewModel>();

            for (int i = 0; i < viewModelCount; i++)
            {
                viewModels.Add(region.Add <ReactiveViewModel>());
            }

            Fixture.Inject <Region>(region);

            var sut = Fixture.Create <NavigableRegion>();

            await sut.CloseAll();

            foreach (var vm in viewModels)
            {
                A.CallTo(() => router.RequestCloseAsync(sut.Region, vm, NavigationParameters.CloseRegion)).MustHaveHappened();
            }
        }
        public void SetUp()
        {
            _rabbitMqConnectionFactoryMock = InjectMock <IRabbitMqConnectionFactory>();
            _rabbitMqConfigurationMock     = InjectMock <IRabbitMqConfiguration>();
            _logMock = InjectMock <ILog>();

            Fixture.Inject <ITransientFaultHandler <IRabbitMqRetryStrategy> >(new TransientFaultHandler <IRabbitMqRetryStrategy>(
                                                                                  _logMock.Object,
                                                                                  new RabbitMqRetryStrategy()));

            var basicPropertiesMock = new Mock <IBasicProperties>();

            _modelMock            = new Mock <IModel>();
            _rabbitConnectionMock = new Mock <IRabbitConnection>();

            _rabbitMqConnectionFactoryMock
            .Setup(f => f.CreateConnectionAsync(It.IsAny <Uri>(), It.IsAny <CancellationToken>()))
            .Returns(Task.FromResult(_rabbitConnectionMock.Object));
            _rabbitMqConfigurationMock
            .Setup(c => c.Uri)
            .Returns(new Uri("amqp://localhost"));
            _modelMock
            .Setup(m => m.CreateBasicProperties())
            .Returns(basicPropertiesMock.Object);
        }
            MessageProcessingRpcSend<FakeMessage> Create()
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            var sentMessage = fixture.Create<ISentMessage>();
            fixture.Inject(sentMessage);

            var output = fixture.Create<QueueOutputMessage>();
            var sendMessages = fixture.Create<ISendMessages>();
            sendMessages.Send(fixture.Create<IMessage>(),
                  fixture.Create<IAdditionalMessageData>()).ReturnsForAnyArgs(output);
            fixture.Inject(sendMessages);

            fixture.Inject(fixture.Create<ProducerQueue<FakeMessage>>());
            return fixture.Create<MessageProcessingRpcSend<FakeMessage>>();
        }
Example #38
0
        public void StartPacking_should_create_nupkg()
        {
            // Arrange
            var fixture = new Fixture().Customize(new AutoMoqCustomization());
            {
                var m = new Mock<IEnvironmentRepository>(MockBehavior.Strict);
                m.Setup(_ => _.GetNuGetPath()).Returns(AppDomain.CurrentDomain.GetPathInBaseDirectory(@"tools\NuGet.exe"));
                fixture.Inject(m);
            }

            var nugetExecutor = fixture.NewNuGetExecutor();


            // Act
            var result = nugetExecutor.StartPacking(AppDomain.CurrentDomain.GetPathInBaseDirectory(@"tools\NuGet\Prig.nuspec"), AppDomain.CurrentDomain.BaseDirectory);


            // Assert
            var lines = result.Split(new[] { "\r\n" }, StringSplitOptions.None);
            Assert.LessOrEqual(2, lines.Length);
            var match = Regex.Match(lines[1], "'([^']+)'");
            Assert.IsTrue(match.Success);
            var nupkgPath = match.Groups[1].Value;
            Assert.IsTrue(File.Exists(nupkgPath));
            Assert.GreaterOrEqual(TimeSpan.FromSeconds(1), DateTime.Now - File.GetLastWriteTime(nupkgPath));
        }
        private WaitForEventOrCancelThreadPool Create()
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            fixture.Inject(fixture.Create <WaitForEventOrCancelFactory>());
            return(fixture.Create <WaitForEventOrCancelThreadPool>());
        }
 private SqLiteCommandStringCache Create()
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     var connection = fixture.Create<IConnectionInformation>();
     connection.QueueName.Returns("TestQueue");
     fixture.Inject(connection);
     return fixture.Create<SqLiteCommandStringCache>();
 }
 public void Create()
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     var providers = new List<IQueueStatusProvider> {fixture.Create<QueueStatusProviderNoOp>()};
     fixture.Inject(providers);
     var test = fixture.Create<DotNetWorkQueue.QueueStatus.QueueStatus>();
     Assert.NotEqual(0, test.Queues.Count());
 }
 private IWorkerHeartBeatNotificationFactory Create(bool enabled)
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     var configuration = fixture.Create<IHeartBeatConfiguration>();
     configuration.Enabled.Returns(enabled);
     fixture.Inject(configuration);
     return fixture.Create<WorkerHeartBeatNotificationFactory>();
 }
 private IAbortWorkerThread Create(bool enableAbort)
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     var configuration = fixture.Create<IWorkerConfiguration>();
     configuration.AbortWorkerThreadsWhenStopping.Returns(enableAbort);
     fixture.Inject(configuration);
     return fixture.Create<AbortWorkerThread>();
 }
 public IHeartBeatThreadPoolFactory Create()
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     var container = fixture.Create<IContainer>();
     fixture.Inject(container);
     container.GetInstance<IHeartBeatThreadPool>().Returns(fixture.Create<HeartBeatThreadPool>());
     return fixture.Create<HeartBeatThreadPoolFactory>();
 }
 private WorkerNotification Create(bool enableRollback = false)
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     var configuration = fixture.Create<TransportConfigurationReceive>();
     configuration.MessageRollbackSupported = enableRollback;
     fixture.Inject(configuration);
     return fixture.Create<WorkerNotification>();
 }
 public void GetData()
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     var factory = fixture.Create<ISqlServerMessageQueueTransportOptionsFactory>();
     factory.Create().Returns(fixture.Create<SqlServerMessageQueueTransportOptions>());
     fixture.Inject(factory);
     var test = fixture.Create<SqlServerQueueStatusProvider>();
     Assert.Equal(5, test.Current.Data.Count());
 }
        public void GenerateMessage()
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
            IGenerateReceivedMessage gen = fixture.Create<GenerateReceivedMessage>();
            var inputMessage = fixture.Create<IMessage>();
            inputMessage.Body.Returns(new FakeMessage());
            fixture.Inject(gen);
            fixture.Inject(inputMessage);
            var test = fixture.Create<MessageHandlerRegistrationAsync>();
            Func<IReceivedMessage<FakeMessage>, IWorkerNotification, Task> action = (recmessage, worker) => null;
            test.Set(action);

            IReceivedMessageInternal rec = fixture.Create<ReceivedMessageInternal>();

            dynamic message = test.GenerateMessage(rec);

            Assert.IsAssignableFrom<FakeMessage>(message.Body);
        }
        private WorkerCollection Create(int workerCount)
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
            var configuration = fixture.Create<IWorkerConfiguration>();
            configuration.WorkerCount.Returns(workerCount);
            fixture.Inject(configuration);

            return fixture.Create<WorkerCollection>();
        }
 private IWorkerFactory Create()
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     var container = fixture.Create<IContainer>();
     var mode = fixture.Create<MessageProcessingMode>();
     container.GetInstance<MessageProcessingMode>().Returns(mode);
     fixture.Inject(container);
     return fixture.Create<WorkerFactory>();
 }
    public void CustomizeCreatesItem(AutoContentItemCustomization sut)
    {
      var fixture = new Fixture();
      fixture.Inject(Database.GetDatabase("master"));

      sut.Customize(fixture);

      fixture.Create<Item>().Should().NotBeNull();
    }
 public void SingleParameterGetReturnsCorrectResult(int number)
 {
     // Fixture setup
     var fixture = new Fixture();
     fixture.Inject(number);
     // Exercise system
     var actual = fixture.Get((int x) => -1 * x);
     // Verify outcome
     Assert.Equal(-1 * number, actual);
     // Teardown
 }
        public void DoubleParameterDoWillInvokeMethodWithCorrectParameters(
            int expectedNumber,
            string expectedText)
        {
            // Fixture setup
            var fixture = new Fixture();
            fixture.Inject(expectedNumber);
            fixture.Inject(expectedText);

            var verified = false;
            var mock = new CommandMock<int, string>();
            mock.OnCommand = (x, y) => verified =
                expectedNumber == x &&
                expectedText == y;
            // Exercise system
            fixture.Do((int x, string y) => mock.Command(x, y));
            // Verify outcome
            Assert.True(verified, "Mock wasn't verified.");
            // Teardown
        }
    public void CreateAddsItemToDb()
    {
      var fixture = new Fixture();
      var db = fixture.Freeze<Db>();
      fixture.Inject(db.Database);
      var item = fixture.Freeze<Item>(x => x.OmitAutoProperties());
      var sut = new AddContentItemCommand();

      sut.Execute(item, new SpecimenContext(fixture));

      db.GetItem(item.ID).Should().NotBeNull();
    }
        private QueueConsumerConfiguration GetConfiguration(bool enabled)
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
            var configuration = fixture.Create<TransportConfigurationReceive>();
            fixture.Inject(configuration);

            var config = fixture.Create<QueueConsumerConfiguration>();
            if (!enabled) return config;
            config.TransportConfiguration.QueueDelayBehavior.Add(TimeSpan.Zero);
            config.TransportConfiguration.FatalExceptionDelayBehavior.Add(TimeSpan.Zero);
            return config;
        }
 public void DiscountPriceCanBeNull()
 {
     // Fixture setup
     var fixture = new Fixture();
     fixture.Inject((Money)null);
     var sut = fixture.CreateAnonymous<CampaignItem>();
     // Exercise system
     var result = sut.DiscountPrice;
     // Verify outcome
     Assert.Null(result);
     // Teardown
 }
Example #56
0
 private IWorker Create()
 {
     var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
     var container = fixture.Create<IContainer>();
     fixture.Inject(container);
     var fact = fixture.Create<MessageProcessingFactory>();
     var wrapper = new MessageProcessingTests.MessageProcessingWrapper();
     var processing = wrapper.Create();
     fact.Create().Returns(processing);
     fixture.Inject(fact);
     return fixture.Create<Worker>();
 }
 public void QuadrupleParameterGetReturnsCorrectResult(
     Type type,
     bool logical,
     int number,
     string text)
 {
     // Fixture setup
     var fixture = new Fixture();
     fixture.Inject(type);
     fixture.Inject(logical);
     fixture.Inject(number);
     fixture.Inject(text);
     // Exercise system
     var actual = fixture.Get((Type x, bool y, int z, string æ) =>
         x.ToString() + y + z + æ);
     // Verify outcome
     Assert.Equal(
         type.ToString() + logical + number + text,
         actual);
     // Teardown
 }
        public void Register()
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());

            var messageHandlerRegistration = fixture.Create<IMessageHandlerRegistrationAsync>();
            fixture.Inject(messageHandlerRegistration);
            var test = fixture.Create<RegisterMessagesAsync>();

            Func<IReceivedMessage<FakeMessage>, IWorkerNotification, Task> action = (message, worker) => null;
            test.Register(action);

            messageHandlerRegistration.Received(1).Set(action);
        }       
 public void DoStuffWillThrowOnNullValue()
 {
     // Fixture setup
     var fixture = new Fixture();
     fixture.Inject(Enumerable.Empty<IAddIn>());
     var sut = fixture.CreateAnonymous<AddInClient>();
     SomeValue nullValue = null;
     // Exercise system
     Assert.Throws<ArgumentNullException>(() => 
         sut.DoStuff(nullValue));
     // Verify outcome (expected exception)
     // Teardown
 }
        public MessageProcessingRpcReceive<FakeMessage> Create()
        {
            var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
            IReceiveMessagesFactory receiveMessages = fixture.Create<IReceiveMessagesFactory>();
            fixture.Inject(receiveMessages);
            var fakeMessage = fixture.Create<IMessage>();
            fakeMessage.Body.Returns(new FakeMessage());
            fixture.Inject(fakeMessage);
            ICommitMessage commitMessage = fixture.Create<CommitMessage>();
            fixture.Inject(commitMessage);

            IReceivedMessageInternal message = fixture.Create<ReceivedMessageInternal>();

            IMessageHandlerRegistration messageHandlerRegistration = fixture.Create<IMessageHandlerRegistration>();
            messageHandlerRegistration.GenerateMessage(message)
                   .Returns(new ReceivedMessage<FakeMessage>(message));
            fixture.Inject(messageHandlerRegistration);

            receiveMessages.Create().ReceiveMessage(null).ReturnsForAnyArgs(message);

            return fixture.Create<MessageProcessingRpcReceive<FakeMessage>>();
        }