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; }
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)); }
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); }
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(); }
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 }); }
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); }
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()); }
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>()); }
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"])); }
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; }
/// <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(); }
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); }
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, }); }
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); }
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); } }
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); }
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)); }
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); }
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); }
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); }
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()); }
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); }
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")); }
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"); }
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()); }
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); }
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)); }
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); }