Example #1
6
        public static TestableChat GetTestableChat(string connectionId, StateChangeTracker clientState, ChatUser user, IDictionary<string, Cookie> cookies)
        {
            // setup things needed for chat
            var repository = new InMemoryRepository();
            var resourceProcessor = new Mock<IResourceProcessor>();
            var chatService = new Mock<IChatService>();
            var connection = new Mock<IConnection>();
            var settings = new Mock<IApplicationSettings>();
            var mockPipeline = new Mock<IHubPipelineInvoker>();

            // add user to repository
            repository.Add(user);

            // create testable chat
            var chat = new TestableChat(settings, resourceProcessor, chatService, repository, connection);
            var mockedConnectionObject = chat.MockedConnection.Object;

            chat.Clients = new HubConnectionContext(mockPipeline.Object, mockedConnectionObject, "Chat", connectionId, clientState);

            var prinicipal = new Mock<IPrincipal>();

            var request = new Mock<IRequest>();
            request.Setup(m => m.Cookies).Returns(cookies);
            request.Setup(m => m.User).Returns(prinicipal.Object);

            // setup context
            chat.Context = new HubCallerContext(request.Object, connectionId);

            return chat;
        }
Example #2
1
        public void Home_Page_With_Custom_Action(string virtualUrl)
        {
            // Arrange
            var pathData = new PathData();
            var mapper = new Mock<IControllerMapper>();
            var container = new Mock<IContainer>();

            mapper.Setup(x => x.GetControllerName(typeof(DummyController))).Returns("Dummy");
            mapper.Setup(x => x.ControllerHasAction("Dummy", "myaction")).Returns(true);
            container.Setup(x => x.GetInstance<IDocumentSession>()).Returns(_store.OpenSession());

            mapper.Setup(m => m.ControllerHasAction("Content", "myaction")).Returns(true);

            // Act
            IPathData data;
            using (var session = _store.OpenSession()) {
                // create and store a new page model
                var pageModel = new DummyModel { Parent = null };
                session.Store(pageModel);
                session.SaveChanges();

                var resolver = new PathResolver(session, pathData, mapper.Object, container.Object);
                data = resolver.ResolvePath(new RouteData(), virtualUrl);
            }

            // Assert
            Assert.NotNull(data);
            Assert.AreEqual("myaction", data.Action);
            Assert.AreEqual("Dummy", data.Controller);
        }
 public void ConnectControlViewModel_AddNewServer_ResourceRepositoryReturnExistingServers_False()
 {
     //------------Setup for test--------------------------
     var mainViewModel = new Mock<IMainViewModel>();
     var connectControlSingleton = new Mock<IConnectControlSingleton>();
     var env1 = new TestEnvironmentModel(new Mock<IEventAggregator>().Object, Guid.NewGuid(), CreateConnection(true, false).Object, new Mock<IResourceRepository>().Object, false);
     var env2 = new TestEnvironmentModel(new Mock<IEventAggregator>().Object, Guid.NewGuid(), CreateConnection(true, false).Object, new Mock<IResourceRepository>().Object, false);
     var connectControlEnvironments = new ObservableCollection<IConnectControlEnvironment>();
     var controEnv1 = new Mock<IConnectControlEnvironment>();
     var controEnv2 = new Mock<IConnectControlEnvironment>();
     controEnv1.Setup(c => c.EnvironmentModel).Returns(env1);
     controEnv2.Setup(c => c.EnvironmentModel).Returns(env2);
     controEnv1.Setup(c => c.IsConnected).Returns(true);
     connectControlEnvironments.Add(controEnv2.Object);
     connectControlEnvironments.Add(controEnv1.Object);
     connectControlSingleton.Setup(c => c.Servers).Returns(connectControlEnvironments);
     var environmentRepository = new Mock<IEnvironmentRepository>();
     ICollection<IEnvironmentModel> environments = new Collection<IEnvironmentModel>
         {
             env1
         };
     environmentRepository.Setup(e => e.All()).Returns(environments);
     var viewModel = new ConnectControlViewModel(mainViewModel.Object, environmentRepository.Object, e => { }, connectControlSingleton.Object, "TEST : ", false);
     //------------Execution-------------------------------
     int serverIndex;
     var didAddNew = viewModel.AddNewServer(out serverIndex, i => { });
     //------------Assert----------------------------------
     Assert.IsNotNull(viewModel);
     Assert.IsFalse(didAddNew);
 }
        public async Task ExecuteAsync_calls_Commit_if_no_transaction()
        {
            var mockModificationCommandBatch = new Mock<ModificationCommandBatch>();
            mockModificationCommandBatch.Setup(m => m.ModificationCommands.Count).Returns(1);

            var mockRelationalConnection = new Mock<IRelationalConnection>();
            var transactionMock = new Mock<IDbContextTransaction>();

            IDbContextTransaction currentTransaction = null;
            mockRelationalConnection.Setup(m => m.BeginTransaction()).Returns(() => currentTransaction = transactionMock.Object);
            mockRelationalConnection.Setup(m => m.CurrentTransaction).Returns(() => currentTransaction);

            var cancellationToken = new CancellationTokenSource().Token;

            var batchExecutor = new BatchExecutor();

            await batchExecutor.ExecuteAsync(new[] { mockModificationCommandBatch.Object }, mockRelationalConnection.Object, cancellationToken);

            mockRelationalConnection.Verify(rc => rc.OpenAsync(cancellationToken));
            mockRelationalConnection.Verify(rc => rc.Close());
            transactionMock.Verify(t => t.Commit());

            mockModificationCommandBatch.Verify(mcb => mcb.ExecuteAsync(
                It.IsAny<IRelationalConnection>(),
                cancellationToken));
        }
Example #5
0
        public void LayoutRendererTests()
        {
            var host = new MemoryHost();

            //create a view engine
            var viewEngine = new ParrotViewEngine(host);

            host.DependencyResolver.Register(typeof(IViewEngine), () => viewEngine);

            var layout = "html > body > content";
            var testFile = "layout(\"layout\") { div > \"testing\" }";

            var pathResolver = new Mock<IPathResolver>();
            pathResolver.Setup(p => p.OpenFile("index.parrot")).Returns(new MemoryStream(Encoding.Default.GetBytes(testFile)));
            pathResolver.Setup(p => p.OpenFile("~/Views/Shared/layout.parrot")).Returns(new MemoryStream(Encoding.Default.GetBytes(layout)));
            pathResolver.Setup(p => p.FileExists(It.IsAny<string>())).Returns(false);
            pathResolver.Setup(p => p.FileExists("~/Views/Shared/layout.parrot")).Returns(true);
            pathResolver.Setup(p => p.VirtualFilePath("~/Views/Shared/layout.parrot")).Returns("~/Views/Shared/layout.parrot");

            host.DependencyResolver.Register(typeof(IPathResolver), () => pathResolver.Object);

            ////TODO: Figure this out later...
            var view = new ParrotView(host, "index.parrot");
            StringBuilder sb = new StringBuilder();
            view.Render(null, new StringWriter(sb));
            Assert.AreEqual("<html><body><div>testing</div></body></html>", sb.ToString());
        }
        public void Styles_client_retrieves_last_known_good_content_from_local_cache_if_service_throws_exception()
        {
            // Arrange
            var service = new Mock<IStylesService>();

            service.Setup(x => x.Get(ContentTypes.Intranet_FatFooter)).Throws(new Exception("Unit test exception"));
            var cache = new Mock<ILocalCache<List<ContentStyle>>>();
            cache.Setup(x => x.WriteToCache(ContentTypes.Intranet_FatFooter, It.IsAny<List<ContentStyle>>(), It.IsAny<DateTime>()));
            var styles = new List<ContentStyle>
            {
                new ContentStyle
                {
                    Url = new Uri("http://styles.com/1.css")
                }
            };
            cache.Setup(x => x.ReadFromCache(ContentTypes.Intranet_FatFooter)).Returns(styles);
            var client = new StylesClient(service.Object, cache.Object);

            // Act
            client.Get(ContentTypes.Intranet_FatFooter);

            // Assert
            service.Verify(x => x.Get(ContentTypes.Intranet_FatFooter), Times.Once);
            cache.Verify(x => x.ReadFromCache(ContentTypes.Intranet_FatFooter), Times.Once);
            cache.Verify(x => x.WriteToCache(ContentTypes.Intranet_FatFooter, It.IsAny<List<ContentStyle>>(), It.IsAny<DateTime>()), Times.Never);
        }
Example #7
0
        public void Insert_Poco()
        {
            //Just a few props as it is just to test that it runs
            var user = TestDataHelper.GetUserList().First();
            var newUser = new InsertUser
            {
                Id = Guid.NewGuid(),
                Name = user.Name
            };

            var sessionMock = new Mock<ISession>(MockBehavior.Strict);
            sessionMock
                .Setup(s => s.ExecuteAsync(It.IsAny<BoundStatement>()))
                .Returns(TestHelper.DelayedTask(new RowSet()))
                .Verifiable();
            sessionMock
                .Setup(s => s.PrepareAsync(It.IsAny<string>()))
                .Returns<string>(cql => TaskHelper.ToTask(GetPrepared(cql)))
                .Verifiable();
            var mappingClient = GetMappingClient(sessionMock);
            //Execute
            mappingClient.Insert(newUser);
            sessionMock.Verify(s => s.ExecuteAsync(It.Is<BoundStatement>(stmt =>
                stmt.QueryValues.Length == TestHelper.ToDictionary(newUser).Count &&
                stmt.PreparedStatement.Cql.StartsWith("INSERT INTO users (")
                )), Times.Exactly(1));
            sessionMock.Verify();
        }
        public void FoodItemAddedToChildrenWhenAddedToRepository()
        {
            var configurationMock = new Mock<IConfiguration>();
             configurationMock.Setup( x => x.DataSource ).Returns( DataSourceType.XMLFile );
             configurationMock.Setup( x => x.FileName ).Returns( FullTestData.DataFileName );

             FullTestData.Reset();
             DataRepository dataRepository = new DataRepository( configurationMock.Object );

             FoodItemNodeViewModel foodItemNodeViewModel = new FoodItemNodeViewModel( dataRepository, null );

             Int32 originalChildCount = foodItemNodeViewModel.Children.Count;

             FoodItem newFoodItem = new FoodItem( Guid.NewGuid(), "New Food Item", "Some Description", 92 );
             newFoodItem.FoodGroupsPerServing.Add( new Serving<FoodGroup>( dataRepository.GetAllFoodGroups()[0], 1 ) );
             dataRepository.SaveItem( newFoodItem );
             Assert.AreEqual( originalChildCount + 1, foodItemNodeViewModel.Children.Count );

             foreach (ClickableTreeNodeViewModel node in foodItemNodeViewModel.Children)
             {
            FoodItem foodItem = dataRepository.GetFoodItem( (Guid)node.Parameter );
            Assert.IsNotNull( foodItem );
            Assert.AreEqual( foodItem.Name, node.Name );
             }
        }
        public void GetOriginalFileLineExecutionCounts_AggregatesLineExecutionCountsViaMapping_ExcludesOtherFilesReferencedInSourceMap()
        {
            var sourceMapFilePath = "map";

            var mockFileSystem = new Mock<IFileSystemWrapper>();
            mockFileSystem
                .Setup(x => x.GetText(sourceMapFilePath))
                .Returns("{ file: 'other.file' }");
            mockFileSystem
                .Setup(x => x.FileExists(sourceMapFilePath))
                .Returns(true);
            mockFileSystem
                .Setup(x => x.GetFileName("other.file"))
                .Returns("other.file");

            var mapper = new TestableSourceMapDotNetLineCoverageMapper(mockFileSystem.Object, GetFakeMappings());
            // Line 1 executed never, line 2 never, line 3 once, line 4 never
            var result = mapper.GetOriginalFileLineExecutionCounts(new int?[] { null, 2, 1, null, null }, 3, new ReferencedFile() { Path  = @"other.file", SourceMapFilePath = sourceMapFilePath });

            var expected = new int?[]
            {
                null,
                null,
                1,
                null
            };

            Assert.Equal(expected.Length, result.Length);
            for (var i = 0; i < expected.Length; i++)
            {
                Assert.Equal(expected[i], result[i]);
            }
        }
		public void TestUseCombinedSkinsSchemaWhenNoDefaultTemplate()
		{
			var templateInfo = new StringTemplateInfo("test", "");
			var templateInfo2 = new StringTemplateInfo("test2", "");
			var schema1 = new JSchema();
            var schema2 = new JSchema();

			var templateSchemaProvider = new Mock<ISchemaProvider>();
			templateSchemaProvider.Setup(f => f.GetSchemaFromTemplateAsync(templateInfo)).Returns(Task.FromResult(schema1));
			templateSchemaProvider.Setup(f => f.GetSchemaFromTemplateAsync(templateInfo2)).Returns(Task.FromResult(schema2));

			var combiner = new Mock<SchemaCombiner>();
			combiner.Setup(c =>
                c.Apply(It.Is<JSchema>(s => s == schema1), It.Is<JSchema>(s => s == schema2), It.IsAny<SchemaComparisionReport>(), It.IsAny<string>()))
                .Returns(new JSchema());

			var moduleDefintion = new ModuleDefinition("testmod", null, new Dictionary<string, TemplateInfo>
            {
				{"skin1", templateInfo},
                {"skin2", templateInfo2}
            });

			var underTest = new DefaultModuleSchemaProvider(combiner.Object, templateSchemaProvider.Object);

			var result = underTest.GetSchemaFromModuleAsync(moduleDefintion);

			Assert.IsNotNull(result);

			combiner.Verify();
		}
Example #11
0
        public async void Register_ValidModelAndUserCreated_CallsIStripeServiceCreateCustomer()
        {
            Mock<VeilUserManager> userManagerStub = new Mock<VeilUserManager>(dbStub.Object, null /*messageService*/, null /*dataProtectionProvider*/);
            userManagerStub.
                Setup(um => um.CreateAsync(It.IsAny<User>(), It.IsAny<string>())).
                ReturnsAsync(IdentityResult.Success);
            userManagerStub.
                Setup(um => um.UpdateAsync(It.IsAny<User>())).
                ReturnsAsync(IdentityResult.Failed() /* Return a failed result to minimize the code executed */);

            Mock<IStripeService> stripeServiceMock = stripeServiceStub;
            stripeServiceMock.
                Setup(ss => ss.CreateCustomer(It.IsAny<User>())).
                Returns("customerString").
                Verifiable();

            RegisterViewModel viewModel = new RegisterViewModel();

            AccountController controller = new AccountController(userManagerStub.Object, null /*signInManager*/, stripeServiceMock.Object);

            await controller.Register(viewModel, null);

            Assert.That(
                () =>
                    stripeServiceMock.Verify(ss => ss.CreateCustomer(It.IsAny<User>()),
                    Times.Exactly(1)),
                Throws.Nothing);
        }
        public BrokerRouterProxy(MoqMockingKernel kernel)
        {
            _kernel = kernel;

            //setup mock IKafkaConnection
            _fakeConn0 = new FakeKafkaConnection(new Uri("http://localhost:1"));
            _fakeConn0.ProduceResponseFunction = async () => new ProduceResponse { Offset = _offset0++, PartitionId = 0, Topic = TestTopic };
            _fakeConn0.MetadataResponseFunction = () => MetadataResponse();
            _fakeConn0.OffsetResponseFunction = async () => new OffsetResponse { Offsets = new List<long> { 0, 99 }, PartitionId = 0, Topic = TestTopic };
            _fakeConn0.FetchResponseFunction = async () => { Thread.Sleep(500); return null; };

            _fakeConn1 = new FakeKafkaConnection(new Uri("http://localhost:2"));
            _fakeConn1.ProduceResponseFunction = async () => new ProduceResponse { Offset = _offset1++, PartitionId = 1, Topic = TestTopic };
            _fakeConn1.MetadataResponseFunction = () => MetadataResponse();
            _fakeConn1.OffsetResponseFunction = async () => new OffsetResponse { Offsets = new List<long> { 0, 100 }, PartitionId = 1, Topic = TestTopic };
            _fakeConn1.FetchResponseFunction = async () => { Thread.Sleep(500); return null; };

            _mockKafkaConnectionFactory = _kernel.GetMock<IKafkaConnectionFactory>();
            _mockKafkaConnectionFactory.Setup(x => x.Create(It.Is<KafkaEndpoint>(e => e.Endpoint.Port == 1), It.IsAny<TimeSpan>(), It.IsAny<IKafkaLog>(), It.IsAny<int>(), It.IsAny<TimeSpan?>(), It.IsAny<StatisticsTrackerOptions>())).Returns(() => _fakeConn0);
            _mockKafkaConnectionFactory.Setup(x => x.Create(It.Is<KafkaEndpoint>(e => e.Endpoint.Port == 2), It.IsAny<TimeSpan>(), It.IsAny<IKafkaLog>(), It.IsAny<int>(), It.IsAny<TimeSpan?>(), It.IsAny<StatisticsTrackerOptions>())).Returns(() => _fakeConn1);
            _mockKafkaConnectionFactory.Setup(x => x.Resolve(It.IsAny<Uri>(), It.IsAny<IKafkaLog>()))
                .Returns<Uri, IKafkaLog>((uri, log) => new KafkaEndpoint
                {
                    Endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), uri.Port),
                    ServeUri = uri
                });
        }
Example #13
0
        protected VimTest()
        {
            _factory = new MockRepository(MockBehavior.Strict);
            _globalSettings = new GlobalSettings();
            _fileSystem = _factory.Create<IFileSystem>(MockBehavior.Strict);
            _bufferFactory = VimBufferFactory;
            _simpleListener = new SimpleListener();
            var creationListeners = new [] { new Lazy<IVimBufferCreationListener>(() => _simpleListener) };

            var map = new Dictionary<string, VariableValue>();
            _keyMap = new KeyMap(_globalSettings, map);
            _vimHost = _factory.Create<IVimHost>(MockBehavior.Strict);
            _vimHost.Setup(x => x.CreateHiddenTextView()).Returns(CreateTextView());
            _vimHost.Setup(x => x.AutoSynchronizeSettings).Returns(true);
            _vimRaw = new Vim(
                _vimHost.Object,
                _bufferFactory,
                CompositionContainer.GetExportedValue<IVimInterpreterFactory>(),
                creationListeners.ToFSharpList(),
                _globalSettings,
                _factory.Create<IMarkMap>().Object,
                _keyMap,
                MockObjectFactory.CreateClipboardDevice().Object,
                _factory.Create<ISearchService>().Object,
                _fileSystem.Object,
                new VimData(_globalSettings),
                _factory.Create<IBulkOperations>().Object,
                map,
                new EditorToSettingSynchronizer());
            _vim = _vimRaw;
            _vim.AutoLoadVimRc = false;
        }
        public void json_collection_with_default_culture_test()
        {
            // Arrange
            var req = new Mock<HttpRequest>();
            req.Setup(x => x.Headers)
                .Returns(new HeaderDictionary(new Dictionary<string, StringValues> { }));
            req.Setup(x => x.Cookies)
                .Returns(new RequestCookiesCollection());
            var httpContext = new Mock<HttpContext>();
            httpContext.Setup(x => x.Request)
                .Returns(req.Object);
            var accessor = new Mock<IHttpContextAccessor>();
            accessor.Setup(x => x.HttpContext)
                .Returns(httpContext.Object);

            var collection = new ServiceCollection();
            collection.AddJsonLocalization()
                .AddCookieCulture()
                .AddInstance(accessor.Object)
                .AddInstance(CallContextServiceLocator.Locator.ServiceProvider.GetRequiredService<IApplicationEnvironment>());

            var service = collection.BuildServiceProvider();

            // Act
            var SR = service.GetService<ILocalizationStringCollection>();
            var actual_1 = SR["Hello world."];
            var actual_2 = SR["My name is {0}.", "Yuuko"];

            // Assert
            Assert.Equal("你好,世界。", actual_1);
            Assert.Equal("我的名字是Yuuko", actual_2);
        }
        public void GetOrCreateHttpRequestMessageFromHttpContextCopiesHeaders()
        {
            // Arrange
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            Dictionary<string, object> items = new Dictionary<string, object>();
            contextMock.Setup(o => o.Items).Returns(items);
            var requestMock = new Mock<HttpRequestBase>();
            requestMock.Setup(r => r.HttpMethod).Returns("GET");
            requestMock.Setup(r => r.InputStream).Returns(new MemoryStream());
            NameValueCollection col = new NameValueCollection();
            col.Add("customHeader", "customHeaderValue");
            requestMock.Setup(r => r.Headers).Returns(col);
            contextMock.Setup(o => o.Request).Returns(requestMock.Object);
            
            // Act
            contextMock.Object.GetOrCreateHttpRequestMessage();

            // Assert
            HttpRequestMessage request = contextMock.Object.GetHttpRequestMessage();
            Assert.NotNull(request);
            Assert.Equal(HttpMethod.Get, request.Method);
            IEnumerable<string> headerValues;
            Assert.True(request.Headers.TryGetValues("customHeader", out headerValues));
            Assert.Equal(1, headerValues.Count());
            Assert.Equal("customHeaderValue", headerValues.First());
        }
        public void Validate_Returns_Results_With_IsValid_Equals_True_When_Inbound_Pipe_Is_Null()
        {
            //Arrange
            var mockObj = new Mock<IBlob>();
            INeutralPipe pipe = null;
            var mockPort = new Mock<IInputNeutralPort>();

            #region set expectations

            mockPort.Setup(foo => foo.InputBlob).Returns(mockObj.Object);
            mockPort.Setup(foo => foo.InboundPipe).Returns(pipe);
            mockPort.Setup(foo => foo.InboundContentStatus).Returns(PayLoadStatus.Available);

            #endregion

            var validator = new InputNeutralPortValidator();

            //Act
            var results = validator.Validate(mockPort.Object);

            //Assert
            Assert.NotNull(results);
            Assert.False(results.IsValid);
            Assert.True(results.Errors.Count == 1);
        }
        public void Test_Authenticate()
        {
            //arrange
            var clusterMock = new Mock<ICluster>();
            clusterMock.Setup(x => x.OpenBucket(It.IsAny<string>())).Returns(new Mock<IBucket>().Object);
            clusterMock.Setup(x => x.Authenticate(It.IsAny<IClusterCredentials>()));
            var cluster = clusterMock.Object;

            var credentials = new ClusterCredentials
            {
                ClusterUsername = "******",
                ClusterPassword = "",
                BucketCredentials = new Dictionary<string, string>
                {
                    {"default", "" },
                    {"authenticated", "secret" },
                    {"memcached", "" },
                    {"travel-sample", "wayward1" }
                }
            };

            //act
            cluster.Authenticate(credentials);
            var bucket = cluster.OpenBucket("authenticated");

            //assert
            Assert.IsNotNull(bucket);
        }
Example #18
0
        public void InvokeWithStateCopiesStateToHubProxy()
        {
            var hubResult = new HubResult
            {
                State = new Dictionary<string, JToken>
                {
                    { "state", JToken.FromObject(1) }
                }
            };

            var connection = new Mock<IHubConnection>();
            connection.Setup(m => m.RegisterCallback(It.IsAny<Action<HubResult>>()))
                      .Callback<Action<HubResult>>(callback =>
                      {
                          callback(hubResult);
                      });

            connection.Setup(m => m.Send(It.IsAny<string>()))
                      .Returns(TaskAsyncHelper.Empty);

            connection.SetupGet(x => x.JsonSerializer).Returns(new JsonSerializer());

            var hubProxy = new HubProxy(connection.Object, "foo");

            hubProxy.Invoke("Anything").Wait();

            Assert.Equal(1, hubProxy["state"]);
        }
        public void LoadInvalidDataTest()
        {
            const string json1 = "{\"ProcessId\":7024,\"ProcessName\":\"test1.exe\",\"ProcessPath\":\"test1.exe\",\"ProcessUser\":\"TEST1\",\"ServerName\":\"\",\"IsAttached\":false,\"IsLocal\":true,\"Engine\":null}";
            const string json2 = "{\"ProcessId\":7025,\"ProcessName\":\"test2.exe\",\"ProcessPath\":\"test2.exe\",\"ProcessUser\":\"TEST2\",\"ServerName\":\"\",\"IsAttached\":false,\"IsLocal\":true,\"Engine\":null}";

            var key = new Mock<IRegistryKey>();
            var subkey = new Mock<IRegistryKey>();
            key.Setup(k => k.OpenSubKey(ReAttachConstants.ReAttachRegistryKeyName)).Returns(subkey.Object);

            subkey.Setup(k => k.GetValue(ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + 1)).Returns(json1);
            subkey.Setup(k => k.GetValue(ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + 2)).Returns("invalid-json-item");
            subkey.Setup(k => k.GetValue(ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + 3)).Returns(json2);

            var package = new Mock<IReAttachPackage>();
            package.Setup(p => p.OpenUserRegistryRoot()).Returns(key.Object);
            var repository = new ReAttachRegistryRepository(package.Object);

            var result = repository.LoadTargets();

            Assert.IsNotNull(result, "Empty set loaded resulted in null result, should result in empty list.");
            Assert.AreEqual(2, result.Count, "Invalid number of results loaded.");

            for (var i = 1; i <= 2; i++)
                subkey.Verify(k => k.GetValue(ReAttachConstants.ReAttachRegistryHistoryKeyPrefix + i));
        }
        public async void StatisticsHomePage_ValidateReportStructureAndAvailability()
        {
            var fakePackageReport = "[{\"PackageId\":\"A\",\"Downloads\":1},{\"PackageId\":\"B\",\"Downloads\":2}]";
            var fakePackageVersionReport = "[{\"PackageId\":\"A\",\"PackageVersion\":\"1.0\",\"Downloads\":3},{\"PackageId\":\"A\",\"PackageVersion\":\"1.1\",\"Downloads\":4},{\"PackageId\":\"B\",\"PackageVersion\":\"1.0\",\"Downloads\":5}]";

            var fakeReportService = new Mock<IReportService>();

            fakeReportService.Setup(x => x.Load("RecentPopularity.json")).Returns(Task.FromResult(fakePackageReport));
            fakeReportService.Setup(x => x.Load("RecentPopularityDetail.json")).Returns(Task.FromResult(fakePackageVersionReport));

            var controller = new StatisticsController(new JsonStatisticsService(fakeReportService.Object));

            var model = (StatisticsPackagesViewModel)((ViewResult) await controller.Index()).Model;

            int sum = 0;

            if (model.IsDownloadPackageAvailable)
            {
                foreach (var item in model.DownloadPackagesSummary)
                {
                    sum += item.Downloads;
                }
            }

            if (model.IsDownloadPackageDetailAvailable)
            {
                foreach (var item in model.DownloadPackageVersionsSummary)
                {
                    sum += item.Downloads;
                }
            }

            Assert.Equal<int>(15, sum);
        }
        public void ListAll_PerformsCorrectRequest()
        {
            //Setup
            var request = new CategoriesStub("DevKey", "api.careerbuilder.com", "", "");

            //Mock crap
            var response = new RestResponse<List<Category>> {Data = new List<Category>()};

            var restReq = new Mock<IRestRequest>();
            restReq.Setup(x => x.AddParameter("DeveloperKey", "DevKey"));
            restReq.Setup(x => x.AddParameter("CountryCode", "NL"));
            restReq.SetupSet(x => x.RootElement = "Categories");

            var restClient = new Mock<IRestClient>();
            restClient.SetupSet(x => x.BaseUrl = "https://api.careerbuilder.com/v1/categories");
            restClient.Setup(x => x.Execute<List<Category>>(It.IsAny<IRestRequest>())).Returns(response);

            request.Request = restReq.Object;
            request.Client = restClient.Object;

            //Assert
            List<Category> cats = request.WhereCountryCode(CountryCode.NL).ListAll();
            Assert.IsTrue(cats.Count == 0);
            restReq.VerifyAll();
            restClient.VerifyAll();
        }
        public void Setup()
        {
            _genericEditSummaryViewModel = new EditSummaryViewModel()
            {
                CompanyId = 123L,
                RiskAssessmentId = 789L,
                DateOfAssessment = DateTime.Now,
                HazardousSubstanceId = 456L,
                Title = "title",
                Reference = "reference",
                RiskAssessorId = 567L
            };
            _viewModelFactory = new Mock<IEditHazardousSubstanceRiskAssessmentSummaryViewModelFactory>();
            _viewModelFactory
                .Setup(x => x.WithRiskAssessmentId(It.IsAny<long>()))
                .Returns(_viewModelFactory.Object);
            _viewModelFactory
                .Setup(x => x.WithCompanyId(It.IsAny<long>()))
                .Returns(_viewModelFactory.Object);
            _viewModelFactory
                .Setup(x => x.GetViewModel())
                .Returns(new EditSummaryViewModel());

            _riskAssessmentService = new Mock<IHazardousSubstanceRiskAssessmentService>();
            _riskAssessmentService.Setup(x => x.UpdateRiskAssessmentSummary(It.IsAny<SaveHazardousSubstanceRiskAssessmentRequest>()));

            target = GetTarget();
        }
        public void ServiceCallbackHandlerSaveWithValidArgsExpectedPublishesUpdateResourceMessage()
        {
            Guid resourceId = Guid.NewGuid();

            var showDependencyProvider = new Mock<IShowDependencyProvider>();

            var resourceModel = new Mock<IResourceModel>();
            resourceModel.Setup(r => r.ResourceName).Returns("Some Testing Display Name");
            resourceModel.Setup(r => r.ID).Returns(resourceId);

            var resourceRepo = new Mock<IResourceRepository>();
            resourceRepo.Setup(r => r.ReloadResource(It.IsAny<Guid>(), It.IsAny<ResourceType>(), It.IsAny<IEqualityComparer<IResourceModel>>(), true))
                .Returns(new List<IResourceModel> { resourceModel.Object });

            var envModel = new Mock<IEnvironmentModel>();
            envModel.Setup(e => e.ResourceRepository).Returns(resourceRepo.Object);

            var aggregator = new Mock<IEventAggregator>();
            var envRepo = new Mock<IEnvironmentRepository>();
            var handler = new ServiceCallbackHandlerMock(aggregator.Object, envRepo.Object, showDependencyProvider.Object);

            aggregator.Setup(e => e.Publish(It.IsAny<UpdateResourceMessage>()))
                .Callback<Object>(m =>
                {
                    var msg = (UpdateResourceMessage)m;
                    Assert.AreEqual(resourceId, msg.ResourceModel.ID);
                })
                .Verifiable();

            var jsonObj = JObject.Parse("{ 'ResourceID': '" + resourceId + "','ResourceType':'Service'}");
            handler.TestSave(envModel.Object, jsonObj);

            aggregator.Verify(e => e.Publish(It.IsAny<UpdateResourceMessage>()), Times.Once());
        }
Example #24
0
        public void Setup()
        {
            _userSearchViewModelFactory = new Mock<IUserSearchViewModelFactory>();
            _userSearchViewModel = new UserSearchViewModel();
            _viewUserViewModelFactory = new Mock<IViewUserViewModelFactory>();
            _viewUserViewModel = new ViewUserViewModel();
            _userService = new Mock<IUserService>();

            _userSearchViewModelFactory
                .Setup(x => x.WithCompanyId(_companyId))
                .Returns(_userSearchViewModelFactory.Object);

            _userSearchViewModelFactory
                .Setup(x => x.WithForeName(It.IsAny<string>()))
                .Returns(_userSearchViewModelFactory.Object);

            _userSearchViewModelFactory
                .Setup(x => x.WithSurname(It.IsAny<string>()))
                .Returns(_userSearchViewModelFactory.Object);

            _userSearchViewModelFactory
                .Setup(x => x.WithSiteId(It.IsAny<long>()))
                .Returns(_userSearchViewModelFactory.Object);

            _userSearchViewModelFactory
                .Setup(x => x.WithSiteGroupId(It.IsAny<long>()))
                .Returns(_userSearchViewModelFactory.Object);

            _userSearchViewModelFactory
                .Setup(x => x.WithShowDeleted(It.IsAny<bool>()))
                .Returns(_userSearchViewModelFactory.Object);

            _userSearchViewModelFactory
                .Setup(x => x.WithAllowedSiteIds(It.IsAny<IList<long>>()))
                .Returns(_userSearchViewModelFactory.Object);

            _userSearchViewModelFactory
                .Setup(x => x.WithCurrentUser(It.IsAny<IPrincipal>()))
                .Returns(_userSearchViewModelFactory.Object);

            _userSearchViewModelFactory
                .Setup(x => x.GetViewModel())
                .Returns(_userSearchViewModel);

            _viewUserViewModelFactory
                .Setup(x => x.WithCompanyId(It.IsAny<long>()))
                .Returns(_viewUserViewModelFactory.Object);

            _viewUserViewModelFactory
                .Setup(x => x.WithEmployeeId(It.IsAny<Guid>()))
                .Returns(_viewUserViewModelFactory.Object);

            _viewUserViewModelFactory
                .Setup(x => x.GetViewModel())
                .Returns(_viewUserViewModel);

            _userService
                .Setup(x => x.Search(CreateUserSearchRequest()))
                .Returns(new List<UserDto>());
        }
Example #25
0
        public void RuntimeControllerReturnsNodeVersions()
        {
            // Arrange
            var nodeDir = new Mock<DirectoryInfoBase>();
            nodeDir.Setup(d => d.Exists).Returns(true);
            nodeDir.Setup(d => d.GetDirectories()).Returns(new[] { 
                CreateDirectory("0.8.19", CreateFile("npm.txt", "1.2.8")), 
                CreateDirectory("0.10.5", CreateFile("npm.txt", "1.3.11")), 
                CreateDirectory("0.10.18"), 
                CreateDirectory("node_modules"), 
                CreateDirectory("docs") 
            });
            var directoryInfo = new Mock<IDirectoryInfoFactory>();
            directoryInfo.Setup(d => d.FromDirectoryName(_nodeDir)).Returns(nodeDir.Object);
            var fileSystem = new Mock<IFileSystem>();
            fileSystem.Setup(f => f.DirectoryInfo).Returns(directoryInfo.Object);
            FileSystemHelpers.Instance = fileSystem.Object;
            var controller = new RuntimeController(Mock.Of<ITracer>());

            // Act
            var nodeVersions = controller.GetRuntimeVersions().NodeVersions.ToList();

            // Assert
            Assert.Equal(new[] { "0.8.19", "0.10.5", "0.10.18" }, nodeVersions.Select(v => v["version"]));
            Assert.Equal(new[] { "1.2.8", "1.3.11", null }, nodeVersions.Select(v => v["npm"]));
        }
Example #26
0
        public void XmlLoggerBasicTest()
        {
            var path = @"x:\deployments\1234\log.xml";
            var fileSystem = new Mock<IFileSystem>();
            var file = new Mock<FileBase>();
            var id = Guid.NewGuid().ToString();
            var message = Guid.NewGuid().ToString();
            var doc = new XDocument(new XElement("entries", 
                new XElement("entry",
                    new XAttribute("time", "2013-12-08T01:58:24.0247841Z"),
                    new XAttribute("id", id),
                    new XAttribute("type", "0"),
                    new XElement("message", message)
                )
            ));
            var mem = new MemoryStream();
            doc.Save(mem);

            // Setup
            fileSystem.SetupGet(f => f.File)
                      .Returns(file.Object);
            file.Setup(f => f.Exists(path))
                .Returns(true);
            file.Setup(f => f.OpenRead(path))
                .Returns(() => { mem.Position = 0; return mem; });

            // Test
            var logger = new XmlLogger(fileSystem.Object, path, Mock.Of<IAnalytics>());
            var entries = logger.GetLogEntries();

            // Assert
            Assert.Equal(1, entries.Count());
            Assert.Equal(id, entries.First().Id);
            Assert.Equal(message, entries.First().Message);
        }
        public void TestExecuteWhenPageIsFoundAndUrlMatchesReturnsSuccess()
        {
            var page = new Mock<IPage>(MockBehavior.Strict);

            var pageMapper = new Mock<IPageMapper>(MockBehavior.Strict);
            pageMapper.Setup(p => p.GetTypeFromName("SamplePage")).Returns(typeof(SamplePage));

            var browser = new Mock<IBrowser>(MockBehavior.Strict);
            browser.Setup(b => b.Page(typeof(SamplePage))).Returns(page.Object);
            browser.Setup(b => b.EnsureOnPage(page.Object));

            var logger = new Mock<ILogger>();

            var action = new WaitForPageAction(pageMapper.Object, browser.Object, logger.Object);
            var context = new WaitForPageAction.WaitForPageActionContext("SamplePage", TimeSpan.FromSeconds(1));

            var result = action.Execute(context);

            Assert.AreEqual(true, result.Success);
            Assert.AreSame(page.Object, result.Result);

            pageMapper.VerifyAll();
            browser.VerifyAll();
            page.VerifyAll();
        }
        public void WillCorrectlySetContentType(string path, string contentType, bool contentInStore)
        {
            var module = new RequestReduceModule();
            var context = new Mock<HttpContextBase>();
            var response = new Mock<HttpResponseBase>();
            response.SetupProperty(x => x.ContentType);
            response.Setup(x => x.Headers).Returns(new NameValueCollection());
            response.Setup(x => x.Cache).Returns(new Mock<HttpCachePolicyBase>().Object);
            context.Setup(x => x.Request.Headers).Returns(new NameValueCollection());
            context.Setup(x => x.Response).Returns(response.Object);
            context.Setup(x => x.Request.RawUrl).Returns(path);
            context.Setup(x => x.Server).Returns(new Mock<HttpServerUtilityBase>().Object);
            var config = new Mock<IRRConfiguration>();
            config.Setup(x => x.SpriteVirtualPath).Returns("/RRContent");
            var store = new Mock<IStore>();
            store.Setup(
                x => x.SendContent(It.IsAny<string>(), response.Object)).
                Returns(contentInStore);
            RRContainer.Current = new Container(x =>
            {
                x.For<IRRConfiguration>().Use(config.Object);
                x.For<IStore>().Use(store.Object);
                x.For<IUriBuilder>().Use(new UriBuilder(config.Object));
            });

            module.HandleRRContent(context.Object);

            Assert.Equal(contentType, response.Object.ContentType);
            RRContainer.Current = null;
        }
Example #29
0
 /// <summary>
 /// Set up the command runtime to return true for all confirmation prompts
 /// </summary>
 /// <param name="mock">The mock command runtiem to set up</param>
 public static void SetupConfirmation(Mock<ICommandRuntime> mock)
 {
     mock.Setup(f => f.ShouldProcess(It.IsAny<string>())).Returns(true);
     mock.Setup(f => f.ShouldProcess(It.IsAny<string>(), It.IsAny<string>())).Returns(true);
     mock.Setup(f => f.ShouldProcess(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())).Returns(true);
     mock.Setup(f => f.ShouldContinue(It.IsAny<string>(), It.IsAny<string>())).Returns(true);
 }
        public void WillDelegateContentNotInMyDirectoryFriendHandlers()
        {
            var module = new RequestReduceModule();
            var handler = new DefaultHttpHandler();
            var config = new Mock<IRRConfiguration>();
            config.Setup(x => x.SpriteVirtualPath).Returns("/RRContent");
            var context = new Mock<HttpContextBase>();
            context.Setup(x => x.Request.RawUrl).Returns("/content/someresource.less");
            context.Setup(x => x.Request.Url).Returns(new Uri("http://host/content/someresource.less"));
            context.Setup(x => x.Request.Headers).Returns(new NameValueCollection());
            context.Setup(x => x.Server).Returns(new Mock<HttpServerUtilityBase>().Object);
            context.Setup(x => x.Items).Returns(new Hashtable());
            RRContainer.Current = new Container(x =>
            {
                x.For<IRRConfiguration>().Use(config.Object);
                x.For<IUriBuilder>().Use<UriBuilder>();
            });
            Registry.HandlerMaps.Add(x => x.AbsolutePath.EndsWith(".less") ? handler : null);
            Registry.HandlerMaps.Add(x => x.AbsolutePath.EndsWith(".les") ? new DefaultHttpHandler() : null);

            module.HandleRRContent(context.Object);

            //context.Verify(x => x.RemapHandler(handler), Times.Once());
            Assert.Equal(handler, context.Object.Items["remapped handler"]);
            RRContainer.Current = null;
            Registry.HandlerMaps.Clear();
        }
Example #31
0
        public async Task NullGetAdminData()
        {
            getAllAdminRepositoryMock
            ?.Setup((r) => r.GetAllAsync())
            ?.ReturnsAsync((IReadOnlyList <AdminModel>)null);

            var data = await getAllAdminQuery?.HandleAsync();

            Assert.AreEqual <String>("No data found", ((dynamic)data).Message);
        }
        public void VerifyCid_Fail()
        {
            // Arrange
            var citizen = CreateCitizen();

            _personService?.Setup(x => x.VerifyCid(It.IsAny <Citizen>())).Throws <WebException>();

            // Act
            var result = _personServiceHelper?.VerifyId(citizen);

            // Assert
            result.Should().BeFalse();
        }
        public static void SetupPropertyValue(Mock <IPublishedContent> publishedContentMock, string alias, object value, string culture = null, string segment = null)
        {
            var property = new Mock <IPublishedProperty>();

            property.Setup(x => x.Alias).Returns(alias);
            property.Setup(x => x.GetValue(culture, segment)).Returns(value);
            property.Setup(x => x.HasValue(culture, segment)).Returns(value != null);
            publishedContentMock?.Setup(x => x.GetProperty(alias)).Returns(property.Object);
        }
Example #34
0
        public IMsBuildElementBuilder <T> SetName(string name)
        {
            if (typeof(T) == typeof(IMsBuildTarget))
            {
                Mock <IMsBuildTarget> msBuildTargetMock = _msBuildElementMock as Mock <IMsBuildTarget>;
                msBuildTargetMock?.Setup(t => t.Name).Returns(name);
            }

            return(this);
        }
 public static void SetupLuis <TDialog>(
     Mock <ILuisService> luis,
     Expression <Func <TDialog, Task> > expression,
     double?score,
     params EntityRecommendation[] entities)
 {
     luis?.Setup(l => l.QueryAsync(It.IsAny <Uri>(), It.IsAny <CancellationToken>()))
     .ReturnsAsync(new LuisResult
     {
         Intents  = IntentsFor(expression, score),
         Entities = entities,
     });
 }
Example #36
0
        public async Task ReturnCorrectViewModel_WhenLoginModelIsValidAndLoginUnsuccessfull()
        {
            //Arrange
            var userManagerMock = new Mock <IUserManager <User> >();

            var signInManagerMock = new Mock <ISignInManager <User> >();

            signInManagerMock
            .Setup(simm => simm.PasswordSignInAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), false))
            .ReturnsAsync(Microsoft.AspNetCore.Identity.SignInResult.Failed);

            var memoryCache          = new MemoryCache(new MemoryCacheOptions());
            var userServicesMock     = new Mock <IUserServices>();
            var currencyServicesMock = new Mock <ICurrencyServices>();

            var sut = new AccountController(userManagerMock.Object, signInManagerMock.Object, memoryCache, userServicesMock.Object, currencyServicesMock.Object);

            //Acts
            var result = await sut.Login(new LoginViewModel()) as ViewResult;

            //Assert
            Assert.IsInstanceOfType(result.Model, typeof(LoginViewModel));
        }
        public void When_authentication_factory_returns_value_then_authorization_header_is_set()
        {
            var expectedToken = _fixture.Create<string>();

            var authorizationHeaderFactory = new Mock<IAuthorizationHeaderFactory>();

            authorizationHeaderFactory
                .Setup(factory => factory.Get(It.IsAny<RestAuthorizeRequestData>()))
                .Returns(expectedToken);

            _restClientWrapper.Authenticator = new RestSharpAuthenticator(authorizationHeaderFactory.Object);

            _restClientWrapper.Authenticator.Authenticate(_restClient, _restRequest);

            var authorizationHeader = _restRequest
                                      .Parameters
                                      .FirstOrDefault(p => 
                                                          p.Type == ParameterType.HttpHeader && 
                                                          p.Name == "Authorization" &&
                                                          p.Value.Equals(expectedToken));

            Assert.NotNull(authorizationHeader);
        }
Example #38
0
        public void AddBookAlreadyExists()
        {
            // Arrange
            var bookID            = 5;
            var entites           = MockDataGenerator.CreateBookEntities(10);
            var entitiesQueryable = entites.AsQueryable();
            var viewModel         = MockDataGenerator.CreateBookViewModel(bookID);

            var mockDbContext = new Mock <DatabaseContext>();
            var mockBookSet   = new Mock <DbSet <BookEntity> >();
            var mockMapper    = new Mock <IMapper>();

            mockBookSet.As <IQueryable <BookEntity> >().Setup(m => m.Provider).Returns(entitiesQueryable.Provider);
            mockBookSet.As <IQueryable <BookEntity> >().Setup(m => m.Expression).Returns(entitiesQueryable.Expression);
            mockBookSet.As <IQueryable <BookEntity> >().Setup(m => m.ElementType).Returns(entitiesQueryable.ElementType);
            mockBookSet.As <IQueryable <BookEntity> >().Setup(m => m.GetEnumerator()).Returns(entitiesQueryable.GetEnumerator()); mockBookSet.As <IQueryable <BookEntity> >().Setup(m => m.GetEnumerator()).Returns(entitiesQueryable.GetEnumerator());
            mockDbContext.Setup(f => f.Books).Returns(mockBookSet.Object);

            var repository = new BookRepository(mockDbContext.Object, mockMapper.Object);

            // Act
            repository.AddBook(viewModel);
        }
        public void VirtualPathRootGet_ReturnsFirstObservedContextRequestPathBase()
        {
            // Arrange
            string expectedVirtualPathRoot      = "/expected";
            string currentVirtualPathRoot       = expectedVirtualPathRoot;
            Mock <IOwinRequest> owinRequestMock = new Mock <IOwinRequest>(MockBehavior.Strict);

            owinRequestMock.Setup(r => r.PathBase).Returns(() => new PathString(currentVirtualPathRoot));
            IOwinContext owinContext = CreateStubOwinContext(owinRequestMock.Object);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                string             ignore  = context.VirtualPathRoot;
                currentVirtualPathRoot = "/other";

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }
Example #40
0
        public void Given_SyncActionIsCalled_When_HeightNotOnChain_Then_ABadRequestErrorIsReturned()
        {
            // Set up
            var chain = new Mock <ConcurrentChain>();

            chain.Setup(c => c.GetBlock(15)).Returns((ChainedBlock)null);
            var blockNotification = new Mock <BlockNotification>(this.LoggerFactory.Object, chain.Object, new Mock <ILookaheadBlockPuller>().Object, new Signals.Signals(), new AsyncLoopFactory(new LoggerFactory()), new NodeLifetime());

            // Act
            var notificationController = new NotificationsController(blockNotification.Object, chain.Object);

            // Assert
            IActionResult result = notificationController.SyncFrom("15");

            ErrorResult   errorResult   = Assert.IsType <ErrorResult>(result);
            ErrorResponse errorResponse = Assert.IsType <ErrorResponse>(errorResult.Value);

            Assert.Single(errorResponse.Errors);

            ErrorModel error = errorResponse.Errors[0];

            Assert.Equal(400, error.Status);
        }
Example #41
0
        public void Create_With_Secondary_Index()
        {
            var createQueries = new List <string>();
            var sessionMock   = new Mock <ISession>();

            sessionMock
            .Setup(s => s.Execute(It.IsAny <string>()))
            .Returns(() => new RowSet())
            .Callback <string>(createQueries.Add);
            var typeDefinition = new Map <AllTypesDecorated>()
                                 .PartitionKey(t => t.UuidValue)
                                 .Column(t => t.UuidValue, cm => cm.WithName("user_id"))
                                 .Column(t => t.StringValue, cm => cm.WithName("name"))
                                 .Column(t => t.IntValue, cm => cm.WithName("city_id").WithSecondaryIndex())
                                 .TableName("USERS")
                                 .CaseSensitive()
                                 .ExplicitColumns();
            var table = GetTable <AllTypesDecorated>(sessionMock.Object, typeDefinition);

            table.Create();
            Assert.AreEqual(@"CREATE TABLE ""USERS"" (""city_id"" int, ""name"" text, ""user_id"" uuid, PRIMARY KEY (""user_id""))", createQueries[0]);
            Assert.AreEqual(@"CREATE INDEX ON ""USERS"" (""city_id"")", createQueries[1]);
        }
        public void Validate_Error()
        {
            var learner = new MessageLearner()
            {
                ULN = 1000000042,
            };

            var dd01Mock = new Mock <IDD01>();

            dd01Mock.Setup(dd => dd.Derive(1000000042)).Returns("N");

            var validationErrorHandlerMock = new Mock <IValidationErrorHandler <MessageLearner> >();

            Expression <Action <IValidationErrorHandler <MessageLearner> > > handle = veh => veh.Handle(learner, "ULN_04");

            validationErrorHandlerMock.Setup(handle);

            var rule = new ULN_04Rule(dd01Mock.Object, validationErrorHandlerMock.Object);

            rule.Validate(learner);

            validationErrorHandlerMock.Verify(handle, Times.Exactly(1));
        }
Example #43
0
        public async Task OnGetAsync_InvalidModel()
        {
            // Arrange
            var identityResource = new IdentityResource {
                Id = Random.Next()
            };
            var identityResources = new Mock <DbSet <IdentityResource> >();

            identityResources.Setup(x => x.FindAsync(identityResource.Id)).ReturnsAsync(identityResource);
            var context = new Mock <IConfigurationDbContext>();

            context.Setup(x => x.IdentityResources).Returns(identityResources.Object);
            var id    = Random.Next();
            var index = new IndexModel(context.Object);

            // Act
            var get = await index.OnGetAsync(id).ConfigureAwait(false);

            // Assert
            identityResources.Verify(x => x.FindAsync(id), Times.Once);
            Assert.Null(index.IdentityResource);
            Assert.IsType <NotFoundResult>(get);
        }
Example #44
0
        public void SelfDiagnosticsEventListener_EmitEvent_CaptureAsConfigured()
        {
            // Arrange
            var    configRefresherMock = new Mock <SelfDiagnosticsConfigRefresher>();
            var    memoryMappedFile    = MemoryMappedFile.CreateFromFile(LOGFILEPATH, FileMode.Create, null, 1024);
            Stream stream = memoryMappedFile.CreateViewStream();

            configRefresherMock.Setup(configRefresher => configRefresher.TryGetLogStream(It.IsAny <int>(), out stream, out It.Ref <int> .IsAny))
            .Returns(true);
            var listener = new SelfDiagnosticsEventListener(EventLevel.Error, configRefresherMock.Object);

            // Act: emit an event with severity equal to configured
            OpenTelemetrySdkEventSource.Log.TracerProviderException("TestEvent", "Exception Details");

            // Assert
            configRefresherMock.Verify(refresher => refresher.TryGetLogStream(It.IsAny <int>(), out stream, out It.Ref <int> .IsAny));
            stream.Dispose();
            memoryMappedFile.Dispose();

            var expectedLog = "Unknown error in TracerProvider '{0}': '{1}'.{TestEvent}{Exception Details}";

            AssertFileOutput(LOGFILEPATH, expectedLog);
        }
Example #45
0
        private IHttpClientFactory CreateRemoteSchemas()
        {
            TestServer server_contracts = TestServerFactory.Create(
                ContractSchemaFactory.ConfigureSchema,
                ContractSchemaFactory.ConfigureServices,
                new QueryMiddlewareOptions());

            TestServer server_customers = TestServerFactory.Create(
                CustomerSchemaFactory.ConfigureSchema,
                CustomerSchemaFactory.ConfigureServices,
                new QueryMiddlewareOptions());

            var httpClientFactory = new Mock <IHttpClientFactory>();

            httpClientFactory.Setup(t => t.CreateClient(It.IsAny <string>()))
            .Returns(new Func <string, HttpClient>(n =>
            {
                return(n.Equals("contract")
                        ? server_contracts.CreateClient()
                        : server_customers.CreateClient());
            }));
            return(httpClientFactory.Object);
        }
Example #46
0
        public void MainViewModelTest_TotalePrijs_Succes()
        {
            //Arrange
            Mock <ICarRepository> moq = new Mock <ICarRepository>();

            moq.Setup(m => m.GetAllCars())
            .Returns(new List <Car>()
            {
                new Car {
                    Actief = true, Bijtelling = 100, Prijs = 20,
                }
            });


            var mainVM = new MainViewModel(moq.Object);


            //Act
            var result = mainVM.TotalePrijs;

            //Assert
            Assert.AreEqual(20, result);
        }
        public async Task FetchCoinPriceAsync_Success()
        {
            // Arrange
            var fixture            = new Fixture();
            var inputCoinType      = CoinType.ETH;
            var expectedResponse   = fixture.Build <PriceResponse>().Create();
            var mockCointreeClient = new Mock <ICointreeClient>();

            mockCointreeClient.Setup(client => client.GetPriceAsync(inputCoinType)).ReturnsAsync(expectedResponse);

            fixture.Register(() => mockCointreeClient.Object);

            var target = fixture.Create <CoinPriceGateway>();

            // Act
            PriceResponse actual = await target.FetchCoinPriceAsync(inputCoinType);

            // Assert
            Assert.Equal(expectedResponse, actual); // expect same instance to return

            mockCointreeClient.Verify(client => client.GetPriceAsync(inputCoinType), Times.Once);
            mockCointreeClient.VerifyNoOtherCalls();
        }
        public static void GetPackageReferencesMarkedForReinstallationReturnsEmptyListWhenNuGetIsNotInUseInAProject()
        {
            // Arrange
            Mock<Project> mockProject = new Mock<Project>();
            mockProject.SetupGet(p => p.FullName).Returns(@"c:\a\b\c.csproj");

            // Setup project kind to a supported value. This makes sure that the check for existence of packages.config happens
            mockProject.Setup(p => p.Kind).Returns(CsharpProjectTypeGuid);

            var mockServices = new Dictionary<Type, object>();
            Mock<IVsSolution> mockSolution = new Mock<IVsSolution>();
            mockServices.Add(typeof(IVsSolution), mockSolution.Object);
            Mock<IVsHierarchy> mockHier = new Mock<IVsHierarchy>();
            IVsHierarchy hier = mockHier.Object;
            mockSolution.Setup(m => m.GetProjectOfUniqueName(It.IsAny<string>(), out hier)).Returns(0);
            ServiceLocator.TestServiceCache = mockServices;

            // Act
            var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackageReferencesMarkedForReinstallation(mockProject.Object);

            // Assert
            Assert.True(packagesToBeReinstalled.IsEmpty());
        }
Example #49
0
        public void Create_With_Fully_Qualified_Table_Name_Case_Sensitive()
        {
            string createQuery = null;
            var    sessionMock = new Mock <ISession>();

            sessionMock
            .Setup(s => s.Execute(It.IsAny <string>()))
            .Returns(() => new RowSet())
            .Callback <string>(q => createQuery = q);
            var typeDefinition = new Map <AllTypesDecorated>()
                                 .PartitionKey(t => t.UuidValue)
                                 .Column(t => t.UuidValue, cm => cm.WithName("user_id"))
                                 .Column(t => t.StringValue, cm => cm.WithName("name"))
                                 .Column(t => t.IntValue, cm => cm.WithName("city_id"))
                                 .TableName("TBL1")
                                 .KeyspaceName("ks1")
                                 .CaseSensitive()
                                 .ExplicitColumns();
            var table = GetTable <AllTypesDecorated>(sessionMock.Object, typeDefinition);

            table.Create();
            Assert.AreEqual(@"CREATE TABLE ""ks1"".""TBL1"" (""city_id"" int, ""name"" text, ""user_id"" uuid, PRIMARY KEY (""user_id""))", createQuery);
        }
Example #50
0
        public async Task GetTagsNoDataTest()
        {
            //Arrange
            var mockCache = new Mock <ICacheAccessor>();
            var mockDb    = new Mock <IBlogAccessor>();

            mockDb.Setup(m => m.GetTagList())
            .ReturnsAsync(() => new MetaTag[0]);

            var engine = new BlogEngine(mockDb.Object, mockCache.Object);

            //Act
            var results = await engine.GetTagList();

            //Assert
            Assert.IsNotNull(results, "Should never be null");
            Assert.IsInstanceOfType(results, typeof(IEnumerable <MetaTag>));
            Assert.IsFalse(results.Any(), "Should be no tags");

            mockCache.Verify(m =>
                             m.CacheEnt(It.IsAny <string>(), It.IsAny <IEnumerable <MetaTag> >(), It.IsAny <TimeSpan?>()),
                             Times.Never, "Should be skipped because of null");
        }
        public void ExecuteTool_GivenNoFromPath_ShouldAddError()
        {
            //---------------Set up test pack-------------------
            var mockExecutor = new Mock <IDropboxSingleExecutor <IDropboxResult> >();

            mockExecutor.Setup(executor => executor.ExecuteTask(TestConstant.DropboxClientInstance.Value))
            .Returns(new DropboxDownloadSuccessResult(TestConstant.FileDownloadResponseInstance.Value));
            var dropBoxDownloadActivityMock = new DsfDropBoxDownloadActivityMock(mockExecutor.Object);

            //---------------Assert Precondition----------------
            Assert.IsNotNull(dropBoxDownloadActivityMock);
            //---------------Execute Test ----------------------
            var datObj = new Mock <IDSFDataObject>();
            var executionEnvironment = new Mock <IExecutionEnvironment>();

            datObj.Setup(o => o.Environment).Returns(executionEnvironment.Object);
            // ReSharper disable once RedundantAssignment
            IDSFDataObject dataObject = datObj.Object;

            dropBoxDownloadActivityMock.Execute(dataObject, 0);
            //---------------Test Result -----------------------
            executionEnvironment.Verify(environment => environment.AddError("Please confirm that the correct file location has been entered"));
        }
Example #52
0
        public async Task GetHeadersPageTaggedNoDataTest()
        {
            //Arrange
            var mockCache = new Mock <ICacheAccessor>();
            var mockDb    = new Mock <IBlogAccessor>();

            mockDb.Setup(m => m.GetPostHeaderPageByTag(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>()))
            .ReturnsAsync(() => new PostHeader[0]);

            var engine = new BlogEngine(mockDb.Object, mockCache.Object);

            //Act
            var results = await engine.GetPageOfHeadersByTag(0, 2, TestConstants.GuidString);

            //Assert
            Assert.IsNotNull(results, "Should never be null");
            Assert.IsInstanceOfType(results, typeof(IEnumerable <PostHeader>));
            Assert.IsFalse(results.Any(), "Should be no headers on this page");

            mockCache.Verify(m =>
                             m.CacheEnt(It.IsAny <string>(), It.IsAny <IEnumerable <PostHeader> >(), It.IsAny <TimeSpan?>()),
                             Times.Never, "Should be skipped because of null");
        }
Example #53
0
            public void FlashesSuccessMessage_UsingModelProperty_EmailAddress()
            {
                var form = new ForgotPasswordForm
                {
                    EmailAddress = "*****@*****.**",
                };
                var commandHandler = new Mock<IHandleCommands<SendConfirmEmailMessageCommand>>
                    (MockBehavior.Strict);
                commandHandler.Setup(m => m.Handle(It.Is(SendCommandBasedOn(form))));
                var services = new ForgotPasswordServices(commandHandler.Object);
                var controller = new ForgotPasswordController(services);
                ReuseMock.TestControllerBuilder(ControllerCustomization.ForUrlHelper)
                    .InitializeController(controller);

                controller.Post(form);

                controller.TempData.ShouldNotBeNull();
                var message = controller.TempData.FeedbackMessage();
                message.ShouldNotBeNull();
                message.ShouldEqual(string.Format(
                    ForgotPasswordController.SuccessMessageFormat,
                        form.EmailAddress));
            }
        public void Moq_DbSet_can_be_used_for_async_SqlQuery()
        {
            var mockSqlQuery = new Mock <DbSqlQuery>();
            var products     = new[] { new Product {
                                           Id = 1
                                       }, new Product {
                                           Id = 2
                                       } };

            mockSqlQuery.As <IDbAsyncEnumerable>()
            .Setup(m => m.GetAsyncEnumerator())
            .Returns(new InMemoryDbAsyncEnumerator <Product>(((IEnumerable <Product>)products).GetEnumerator()));

            var mockSet    = new Mock <DbSet>();
            var query      = "not a real query";
            var parameters = new object[] { 1, 2 };

            mockSet.Setup(m => m.SqlQuery(query, parameters)).Returns(mockSqlQuery.Object);

            Assert.Equal(
                new[] { 1, 2 }, mockSet.Object.SqlQuery(query, parameters).ToListAsync().Result.OfType <Product>().Select(p => p.Id));
            mockSet.Verify(m => m.SqlQuery(query, parameters), Times.Once());
        }
Example #55
0
        public void DeleteBookNotFound()
        {
            // Arrange
            var bookID            = 20;
            var entites           = MockDataGenerator.CreateBookEntities(10);
            var entitiesQueryable = entites.AsQueryable();
            var BookEntity        = MockDataGenerator.CreateBookEntity(bookID);

            var mockDbContext = new Mock <DatabaseContext>();
            var mockBookSet   = new Mock <DbSet <BookEntity> >();
            var mockMapper    = new Mock <IMapper>();

            mockBookSet.As <IQueryable <BookEntity> >().Setup(m => m.Provider).Returns(entitiesQueryable.Provider);
            mockBookSet.As <IQueryable <BookEntity> >().Setup(m => m.Expression).Returns(entitiesQueryable.Expression);
            mockBookSet.As <IQueryable <BookEntity> >().Setup(m => m.ElementType).Returns(entitiesQueryable.ElementType);
            mockBookSet.As <IQueryable <BookEntity> >().Setup(m => m.GetEnumerator()).Returns(entitiesQueryable.GetEnumerator()); mockBookSet.As <IQueryable <BookEntity> >().Setup(m => m.GetEnumerator()).Returns(entitiesQueryable.GetEnumerator());
            mockDbContext.Setup(f => f.Books).Returns(mockBookSet.Object);

            var repository = new BookRepository(mockDbContext.Object, mockMapper.Object);

            // Act
            repository.DeleteBookByID(bookID);
        }
        public void Moq_DbSet_can_be_used_for_SqlQuery_with_AsStreaming()
        {
            var mockSqlQuery = new Mock <DbSqlQuery>();

            mockSqlQuery.Setup(m => m.AsStreaming()).Returns(mockSqlQuery.Object);
            var products = new[] { new Product {
                                       Id = 1
                                   }, new Product {
                                       Id = 2
                                   } };

            mockSqlQuery.Setup(m => m.GetEnumerator()).Returns(((IEnumerable)products).GetEnumerator());

            var mockSet    = new Mock <DbSet>();
            var query      = "not a real query";
            var parameters = new object[] { 1, 2 };

            mockSet.Setup(m => m.SqlQuery(query, parameters)).Returns(mockSqlQuery.Object);

            Assert.Equal(new[] { 1, 2 }, mockSet.Object.SqlQuery(query, parameters).AsStreaming().OfType <Product>().Select(p => p.Id));
            mockSet.Verify(m => m.SqlQuery(query, parameters), Times.Once());
            mockSqlQuery.Verify(m => m.AsStreaming(), Times.Once());
        }
        private IImprovement BuildImprovement(ImprovementTestData testData) {
            var mockImprovement = new Mock<IImprovement>();

            var mockTemplate = new Mock<IImprovementTemplate>();

            mockTemplate.Setup(template => template.name).Returns(testData.TemplateName);

            mockImprovement.Setup(improvement => improvement.Template)     .Returns(mockTemplate.Object);
            mockImprovement.Setup(improvement => improvement.WorkInvested) .Returns(testData.WorkInvested);
            mockImprovement.Setup(improvement => improvement.IsConstructed).Returns(testData.IsConstructed);
            mockImprovement.Setup(improvement => improvement.IsPillaged)   .Returns(testData.IsPillaged);

            var newImprovement = mockImprovement.Object;

            var location = BuildHexCell(testData.LocationCoordinates);

            MockImprovementLocationCanon.Setup(canon => canon.GetOwnerOfPossession(newImprovement))
                                        .Returns(location);

            AllImprovements.Add(newImprovement);

            return newImprovement;
        }
        public void ExecuteShouldReturnExceptionMessageIfCourseAlreadyNrolled()
        {
            // CourseAlreadyEnrolledException

            //Arrange
            var state = new Mock<ISessionState>();
            var builder = new Mock<IStringBuilderWrapper>();
            var service = new Mock<ICourseService>();

            var command = new EnrollStudentCommand(state.Object, builder.Object, service.Object);

            state.SetupGet(s => s.IsLogged).Returns(true);
            state.SetupGet(s => s.RoleId).Returns(3);
            state.SetupGet(s => s.UserName).Returns("Pesho");

            service.Setup(s => s.EnrollStudent("Pesho", "Coursename"))
                .Throws(new CourseAlreadyEnrolledException("You are already enrolled for the course Coursename."));

            var parameters = new string[] { "Coursename" };
            var result = command.Execute(parameters);

            Assert.AreEqual("You are already enrolled for the course Coursename.", result);
        }
Example #59
0
        public void Can_Delete_Valid_Products() {

            // Arrange - create a Product
            Product prod = new Product { ProductID = 2, Name = "Test" };

            // Arrange - create the mock repository
            Mock<IProductRepository> mock = new Mock<IProductRepository>();
            mock.Setup(m => m.Products).Returns(new Product[] {
                new Product {ProductID = 1, Name = "P1"},
                prod,
                new Product {ProductID = 3, Name = "P3"},
            }.AsQueryable());

            // Arrange - create the controller
            AdminController target = new AdminController(mock.Object);

            // Act - delete the product
            target.Delete(prod.ProductID);

            // Assert - ensure that the repository delete method was 
            // called with the correct Product 
            mock.Verify(m => m.DeleteProduct(prod.ProductID));
        }
Example #60
0
        public void Can_Edit_Product() {

            // Arrange - create the mock repository
            Mock<IProductRepository> mock = new Mock<IProductRepository>();
            mock.Setup(m => m.Products).Returns(new Product[] {
                new Product {ProductID = 1, Name = "P1"},
                new Product {ProductID = 2, Name = "P2"},
                new Product {ProductID = 3, Name = "P3"},
            }.AsQueryable());

            // Arrange - create the controller
            AdminController target = new AdminController(mock.Object);

            // Act
            Product p1 = target.Edit(1).ViewData.Model as Product;
            Product p2 = target.Edit(2).ViewData.Model as Product;
            Product p3 = target.Edit(3).ViewData.Model as Product;

            // Assert
            Assert.AreEqual(1, p1.ProductID);
            Assert.AreEqual(2, p2.ProductID);
            Assert.AreEqual(3, p3.ProductID);
        }