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; }
protected void SetupSubject() { MockUpdatableAuth = new Mock<IUpdatable<UserAuthentication>>(); _passwords = new Passwords(); _translateUserUserAuth = new DataUserToAccountUserTranslator(); _userAuthProvider = new UserAuthenticationProvider( _translateUserUserAuth , MockRetrievableUserByEmail.Object , MockRetrievableAuthyId.Object , MockUpdatableAuth.Object , MockCreatableAuth.Object , _passwords , MockDeletableAuth.Object); Subject = new UserAccountProvider( _userAuthProvider , MockCreateableUser.Object , MockRetrievableUserById.Object , MockRetrievableUserByEmail.Object , MockDeletableUser.Object , MockUpdateableUser.Object , _translateUserUserAuth , MockSystemTime.Object); }
public void GetAllShouldReturnTodos() { var data = new List<Todo> { new Todo {Id = 1}, new Todo {Id = 2}, new Todo {Id = 3}, }.AsQueryable(); var mockSet = new Mock<DbSet<Todo>>(); mockSet.As<IQueryable<Todo>>().Setup(m => m.Provider).Returns(data.Provider); mockSet.As<IQueryable<Todo>>().Setup(m => m.Expression).Returns(data.Expression); mockSet.As<IQueryable<Todo>>().Setup(m => m.ElementType).Returns(data.ElementType); mockSet.As<IQueryable<Todo>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator()); var mockContext = new Mock<ApplicationDbContext>(); mockContext.Setup(c => c.Todos).Returns(mockSet.Object); var service = new TodoRepository(mockContext.Object); var todos = service.GetAll().ToList(); Assert.AreEqual(3, todos.Count); Assert.AreEqual(1, todos[0].Id); Assert.AreEqual(2, todos[1].Id); Assert.AreEqual(3, todos[2].Id); }
public void CallTest() { //Arrange var domainStatProjectState1 = new DomainStatProjectState() { Producer = ProductName.TaggerIPhone, IsSuccessfulUpload = true }; var domainStatProjectState2 = new DomainStatProjectState() { Producer = ProductName.TaggerIPhone, IsSuccessfulUpload = false }; var domainStatProjectState3 = new DomainStatProjectState() { Producer = "ProductName", IsSuccessfulUpload = true }; var domainReport = new DomainReport(); var statProjectDeletionFilter = new Mock<IStatProjectDeletionFilter>(); var taggerIPhoneDeletionsFilter = new TaggerIPhoneDeletionsFilter(); taggerIPhoneDeletionsFilter.Set(statProjectDeletionFilter.Object); //Act taggerIPhoneDeletionsFilter.Call(domainStatProjectState1, domainReport); taggerIPhoneDeletionsFilter.Call(domainStatProjectState2, domainReport); taggerIPhoneDeletionsFilter.Call(domainStatProjectState3, domainReport); //Assert Assert.AreEqual(1, domainReport.TaggerIPhoneDeletions); statProjectDeletionFilter.Verify(m => m.Call(domainStatProjectState1, domainReport), Times.Once()); statProjectDeletionFilter.Verify(m => m.Call(domainStatProjectState2, domainReport), Times.Once()); statProjectDeletionFilter.Verify(m => m.Call(domainStatProjectState3, domainReport), Times.Once()); }
public void IsInvalidWhen_UserName_MatchesExistingUser() { const string userName = "******"; const string userDisplayName = "Bruce Wayne"; const string personDisplayName = "Adam West"; var command = new CreatePersonCommand { DisplayName = personDisplayName, UserName = userName, }; var queryProcessor = new Mock<IProcessQueries>(MockBehavior.Strict); queryProcessor.Setup(m => m.Execute(It.Is<GetUserByNameQuery>(q => q.Name == command.UserName))) .Returns(new User { Person = new Person { DisplayName = userDisplayName, } }); var validator = new CreatePersonValidator(queryProcessor.Object); var results = validator.Validate(command); results.IsValid.ShouldBeFalse(); results.Errors.Count.ShouldBeInRange(1, int.MaxValue); var error = results.Errors.SingleOrDefault(e => e.PropertyName == "UserName"); error.ShouldNotBeNull(); // ReSharper disable PossibleNullReferenceException error.ErrorMessage.ShouldEqual(string.Format( ValidateUser.FailedBecauseNameMatchedEntity, userName)); // ReSharper restore PossibleNullReferenceException }
public void TestInitialize() { IFhirModel _fhirModel; FhirPropertyIndex _propIndex; ResourceVisitor _resourceVisitor; ElementIndexer _elementIndexer; var _indexStoreMock = new Mock<IIndexStore>(); var spPatientName = new SearchParamDefinition() { Resource = "Patient", Name = "name", Description = @"A portion of either family or given name of the patient", Type = SearchParamType.String, Path = new string[] { "Patient.name", } }; var searchParameters = new List<SearchParamDefinition> { spPatientName }; var resources = new Dictionary<Type, string> { { typeof(Patient), "Patient" }, { typeof(HumanName), "HumanName" } }; var enums = new List<Type>(); //CK: I use real objects: saves me a lot of mocking and provides for a bit of integration testing. _fhirModel = new FhirModel(resources, searchParameters, enums); _propIndex = new FhirPropertyIndex(_fhirModel, new List<Type> { typeof(Patient), typeof(HumanName) }); _resourceVisitor = new ResourceVisitor(_propIndex); _elementIndexer = new ElementIndexer(_fhirModel); //_indexStoreMock.Setup(ixs => ixs.Save(It.IsAny<IndexValue>)) sutLimited = new IndexService(_fhirModel, _propIndex, _resourceVisitor, _elementIndexer, _indexStoreMock.Object); _fhirModel = new FhirModel(); //For this test I want all available types and searchparameters. _propIndex = new FhirPropertyIndex(_fhirModel); _resourceVisitor = new ResourceVisitor(_propIndex); _elementIndexer = new ElementIndexer(_fhirModel); sutFull = new IndexService(_fhirModel, _propIndex, _resourceVisitor, _elementIndexer, _indexStoreMock.Object); }
public void GetUnitOfWorkFactory_uses_same_session_factory_as_provider() { var factory = new Mock<ISessionFactory>(); var provider = new HibernateDataServicesProvider(factory.Object); var unitOfWorkFactory = (HibernateUnitOfWorkFactory)provider.GetUnitOfWorkFactory(); Assert.AreEqual(factory.Object, unitOfWorkFactory.SessionFactory); }
public void scenario_10() { var propertyUpgradeUoW = new Mock<IPropertyUpgradeUoW>(); propertyUpgradeUoW.Setup(x => x.ProductTypeRepository.Get()) .Returns(GetDomainProductTypes()); var calculator = new CityStorageCalculator(propertyUpgradeUoW.Object); var cityStorage = GetCityStorage(); cityStorage.CurrentInventory.First(x => x.ProductTypeId == 1).Quantity = 8; cityStorage.CurrentInventory.First(x => x.ProductTypeId == 2).Quantity = 8; cityStorage.CurrentInventory.First(x => x.ProductTypeId == 3).Quantity = 8; cityStorage.CurrentInventory.First(x => x.ProductTypeId == 4).Quantity = 8; var request = new CalculateStorageRequest { CityStorage = cityStorage, NewProductQuantities = new[] { new SimGame.Handler.Entities.Product { ProductTypeId = 3, Quantity = 2 }, } }; var ret = calculator.CalculateNewStorageAmounts(request); ret.CityStorage.CurrentInventory.First(x => x.ProductTypeId == 4).Quantity.ShouldEqual(6); ret.CityStorage.CurrentInventory.First(x => x.ProductTypeId == 3).Quantity.ShouldEqual(10); ret.CityStorage.CurrentInventory.First(x => x.ProductTypeId == 2).Quantity.ShouldEqual(8); ret.CityStorage.CurrentInventory.First(x => x.ProductTypeId == 1).Quantity.ShouldEqual(8); }
public void ShouldReturnNameOfLogFactory() { var logFactoryRegistry = new LogFactoryRegistry(); var mylogger = new Mock<ITaskLogFactory>().Object; logFactoryRegistry.RegisterLogFactory("mylogger", mylogger); Assert.That(logFactoryRegistry.FindNameForLogFactory(mylogger), Is.EqualTo("mylogger")); }
public void ShouldReturnLogFactoryByName() { var logFactoryRegistry = new LogFactoryRegistry(); var mylogger = new Mock<ITaskLogFactory>().Object; logFactoryRegistry.RegisterLogFactory("mylogger", mylogger); Assert.That(logFactoryRegistry.GetLogFactoryByName("mylogger"), Is.SameAs(mylogger)); }
public void ResolveDependenciesForInstallPackageResolvesDependencyUsingDependencyProvider() { // Arrange IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("B") }); IPackage packageB = PackageUtility.CreatePackage("B"); var repository = new Mock<PackageRepositoryBase>(); repository.Setup(c => c.GetPackages()).Returns(new[] { packageA }.AsQueryable()); var dependencyProvider = repository.As<IDependencyResolver>(); dependencyProvider.Setup(c => c.ResolveDependency(It.Is<PackageDependency>(p => p.Id == "B"), It.IsAny<IPackageConstraintProvider>(), false, true, DependencyVersion.Lowest)) .Returns(packageB).Verifiable(); var localRepository = new MockPackageRepository(); IPackageOperationResolver resolver = new InstallWalker(localRepository, repository.Object, NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false); // Act var operations = resolver.ResolveOperations(packageA).ToList(); // Assert Assert.Equal(2, operations.Count); Assert.Equal(PackageAction.Install, operations.First().Action); Assert.Equal(packageB, operations.First().Package); Assert.Equal(PackageAction.Install, operations.Last().Action); Assert.Equal(packageA, operations.Last().Package); dependencyProvider.Verify(); }
public void When_a_navigation_button_is_clicked_the_associated_page_should_be_displayed() { this.testContainer = new UnityContainer(); this.autoMocker = new AutoMoq.AutoMoqer(this.testContainer); var mockPageViewModel = new Mock<IPageViewModel>(); mockPageViewModel.SetupGet(page => page.Title).Returns("Page1"); IPageViewModel pageViewModel = mockPageViewModel.Object; var viewModelFactoryMock = new Mock<IViewModelFactory>(); viewModelFactoryMock.Setup(f => f.Get<StartPageViewModel>()).Returns(() => new StartPageViewModel(new Mock<INavigationService>().Object)); this.autoMocker.SetInstance(viewModelFactoryMock.Object); var navigationServiceMock = this.navigationServiceMock; navigationServiceMock.Setup(vm => vm.GetDefaultPagesByNames()) .Returns( new Dictionary<string, Func<IPageViewModel>> { { "page1", () => pageViewModel }, { "page2", () => null }, { "page3", () => null }, { "page4", () => null }, }); INavigationService navigationService = navigationServiceMock.Object; this.autoMocker.SetInstance(navigationService); var applicationViewModel = this.autoMocker.Resolve<ApplicationViewModel>(); applicationViewModel.LeftNavigationButtonCollection.Single(btn => btn.DisplayText == "page1").ExecuteAsync(null); navigationServiceMock.VerifySet(ns => ns.CurrentPage = pageViewModel); }
public async Task Run_WhenCheckerThrows_FailureResult() { // Arrange var checkerMocks = Enumerable .Range(1, 3) .Select(x => { var mock = new Mock<IChecker>(); mock.SetupGet(y => y.Name).Returns(x.ToString()); mock.Setup(y => y.Check()).ThrowsAsync(new Exception("error " + mock.Object.Name)); return mock; }) .ToArray(); var healthCheck = new HealthCheck(checkerMocks.Select(x => x.Object)); // Act var result = await healthCheck.Run(); // Assert Assert.That(result.Passed, Is.False); Assert.That(result.Status, Is.EqualTo("failure")); Assert.That(result.Results.Length, Is.EqualTo(checkerMocks.Length)); foreach (var checkerMock in checkerMocks) { var checkResult = result.Results.Single(x => x.Checker == checkerMock.Object.Name); Assert.That(checkResult.Checker, Is.EqualTo(checkerMock.Object.Name)); Assert.That(checkResult.Passed, Is.False); Assert.That(checkResult.Output, Is.EqualTo("error " + checkerMock.Object.Name)); } }
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); }
protected void Arrange() { var random = new Random(); _subsystemName = random.Next().ToString(CultureInfo.InvariantCulture); _operationTimeout = TimeSpan.FromSeconds(30); _encoding = Encoding.UTF8; _disconnectedRegister = new List<EventArgs>(); _errorOccurredRegister = new List<ExceptionEventArgs>(); _channelDataEventArgs = new ChannelDataEventArgs( (uint)random.Next(0, int.MaxValue), new[] { (byte)random.Next(byte.MinValue, byte.MaxValue) }); _sessionMock = new Mock<ISession>(MockBehavior.Strict); _channelMock = new Mock<IChannelSession>(MockBehavior.Strict); _sequence = new MockSequence(); _sessionMock.InSequence(_sequence).Setup(p => p.CreateChannelSession()).Returns(_channelMock.Object); _channelMock.InSequence(_sequence).Setup(p => p.Open()); _channelMock.InSequence(_sequence).Setup(p => p.SendSubsystemRequest(_subsystemName)).Returns(true); _subsystemSession = new SubsystemSessionStub( _sessionMock.Object, _subsystemName, _operationTimeout, _encoding); _subsystemSession.Disconnected += (sender, args) => _disconnectedRegister.Add(args); _subsystemSession.ErrorOccurred += (sender, args) => _errorOccurredRegister.Add(args); _subsystemSession.Connect(); }
public void GetAnonymousCompetitions() { var repository = new RepositoryForTests<Competition>(); repository.TheContent.Add(new Competition { CompetitionType = CompetitionType.Field, Id = Guid.NewGuid(), IsPublic = true, Name = "Public1", StartDate = DateTime.Now, UseNorwegianCount = false }); repository.TheContent.Add(new Competition { CompetitionType = CompetitionType.Field, Id = Guid.NewGuid(), IsPublic = false, Name = "Private1", StartDate = DateTime.Now, UseNorwegianCount = false }); var rightsHelperMock = new Mock<IRightsHelper>(); var userRolesInfoMock = new Mock<IRepository<UserRolesInfo>>(); var competitions = new CompetitionsLogic(repository, userRolesInfoMock.Object, rightsHelperMock.Object); var result = competitions.GetCompetitions(); Assert.AreEqual(1, result.Count()); }
public static TestableChat GetTestableChat(string clientId, TrackingDictionary clientState, ChatUser user, NameValueCollection 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>(); // add user to repository repository.Add(user); // create testable chat var chat = new TestableChat(resourceProcessor, chatService, repository, connection); var mockedConnectionObject = chat.MockedConnection.Object; // setup client agent chat.Agent = new ClientAgent(mockedConnectionObject, "Chat"); var request = new Mock<IRequest>(); request.Setup(m => m.Cookies).Returns(cookies); // setup signal agent var prinicipal = new Mock<IPrincipal>(); chat.Caller = new SignalAgent(mockedConnectionObject, clientId, "Chat", clientState); // setup context chat.Context = new HubContext(new HostContext(request.Object, null, prinicipal.Object), clientId); return chat; }
public void MessagePassedToConstructorIsReturned() { const string Msg = "msg"; var innerRule = new Mock<IRule<string>>(); var rule = new NotRule<string>(innerRule.Object, Msg); Assert.AreEqual(Msg, rule.Message); }
public void GetCurrentSession_delegates_to_session_factory() { var factory = new Mock<ISessionFactory>(); var provider = new HibernateDataServicesProvider(factory.Object); provider.GetCurrentSession(); factory.Verify(sessionFactory => sessionFactory.GetCurrentSession()); }
public void Should_Return_Page_Html_Content() { // Create html content var htmlContent = TestDataProvider.CreateNewHtmlContent(); var pageContent = TestDataProvider.CreateNewPageContent(htmlContent); htmlContent.Status = ContentStatus.Published; // Create command var command = new GetPageHtmlContentCommand(); command.UnitOfWork = new Mock<IUnitOfWork>().Object; command.Repository = new Mock<IRepository>().Object; // Mock content service var serviceMock = new Mock<IContentService>(); serviceMock .Setup(f => f.GetPageContentForEdit(pageContent.Id)) .Returns(new Tuple<PageContent, Content>(pageContent, htmlContent)); command.ContentService = serviceMock.Object; // Execute command var result = command.Execute(pageContent.Id); Assert.IsNotNull(result); Assert.AreEqual(result.Id, pageContent.Id); Assert.AreEqual(result.ContentId, htmlContent.Id); Assert.AreEqual(result.ContentName, htmlContent.Name); Assert.AreEqual(result.ContentVersion, htmlContent.Version); Assert.AreEqual(result.CurrentStatus, htmlContent.Status); Assert.AreEqual(result.PageId, pageContent.Page.Id); Assert.AreEqual(result.RegionId, pageContent.Region.Id); Assert.AreEqual(result.LiveFrom, htmlContent.ActivationDate); Assert.AreEqual(result.LiveTo, htmlContent.ExpirationDate); }
public void Init() { connectionMock = new Mock<IConnectionChecker>(); loginMock = new Mock<IAuthorizer>(); converterMock = new Mock<IUrlConverter>(); dataProviderMock = new Mock<IDatabaseProvider>(); }
public Task TestFileSave() { var response = new FileState { Name = "newBekti.png", Url = new Uri("https://www.parse.com/newBekti.png"), MimeType = "image/png" }; var mockController = new Mock<IParseFileController>(); mockController.Setup(obj => obj.SaveAsync(It.IsAny<FileState>(), It.IsAny<Stream>(), It.IsAny<string>(), It.IsAny<IProgress<ParseUploadProgressEventArgs>>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult(response)); var mockCurrentUserController = new Mock<IParseCurrentUserController>(); ParseCorePlugins.Instance.FileController = mockController.Object; ParseCorePlugins.Instance.CurrentUserController = mockCurrentUserController.Object; ParseFile file = new ParseFile("bekti.jpeg", new MemoryStream(), "image/jpeg"); Assert.AreEqual("bekti.jpeg", file.Name); Assert.AreEqual("image/jpeg", file.MimeType); Assert.True(file.IsDirty); return file.SaveAsync().ContinueWith(t => { Assert.False(t.IsFaulted); Assert.AreEqual("newBekti.png", file.Name); Assert.AreEqual("image/png", file.MimeType); Assert.AreEqual("https://www.parse.com/newBekti.png", file.Url.AbsoluteUri); Assert.False(file.IsDirty); }); }
public void TestAddInterviewerToFieldworkOfficesAsync_WhenExecuted_CallsClientPostAsJsonAsyncWithCorrectArgs() { const string interviewerId = "interviewerId"; const string fieldworkOfficeId = "Barcelona"; var expectedUrl = string.Format(CultureInfo.InvariantCulture, "{0}interviewers/{1}/Offices", ServiceAddress, interviewerId); var mockedNfieldConnection = new Mock<INfieldConnectionClient>(); var mockedHttpClient = CreateHttpClientMock(mockedNfieldConnection); mockedHttpClient .Setup(client => client.PostAsJsonAsync(It.IsAny<string>(), It.IsAny<InterviewerFieldworkOfficeModel>())) .Returns(CreateTask(HttpStatusCode.OK)); var target = new NfieldInterviewersService(); target.InitializeNfieldConnection(mockedNfieldConnection.Object); target.AddInterviewerToFieldworkOfficesAsync(interviewerId, fieldworkOfficeId); mockedHttpClient.Verify( h => h.PostAsJsonAsync(expectedUrl, It.Is<InterviewerFieldworkOfficeModel>(f => f.OfficeId == fieldworkOfficeId)), Times.Once()); }
protected void Arrange() { var random = new Random(); _path = random.Next().ToString(CultureInfo.InvariantCulture); _handle = new[] { (byte)random.Next(byte.MinValue, byte.MaxValue) }; _fileAttributes = SftpFileAttributes.Empty; _bufferSize = (uint)random.Next(0, 1000); _readBufferSize = (uint)random.Next(0, 1000); _writeBufferSize = (uint)random.Next(0, 1000); _sftpSessionMock = new Mock<ISftpSession>(MockBehavior.Strict); var sequence = new MockSequence(); _sftpSessionMock.InSequence(sequence) .Setup(p => p.RequestOpen(_path, Flags.Write | Flags.Truncate, true)) .Returns(_handle); _sftpSessionMock.InSequence(sequence).Setup(p => p.RequestFStat(_handle)).Returns(_fileAttributes); _sftpSessionMock.InSequence(sequence) .Setup(p => p.CalculateOptimalReadLength(_bufferSize)) .Returns(_readBufferSize); _sftpSessionMock.InSequence(sequence) .Setup(p => p.CalculateOptimalWriteLength(_bufferSize, _handle)) .Returns(_writeBufferSize); _sftpSessionMock.InSequence(sequence) .Setup(p => p.IsOpen) .Returns(true); _sftpSessionMock.InSequence(sequence) .Setup(p => p.RequestClose(_handle)); _sftpFileStream = new SftpFileStream(_sftpSessionMock.Object, _path, FileMode.Create, FileAccess.Write, (int)_bufferSize); }
private ExecuteMessage RunOutput(bool expectCorrectInput) { var esbMethod = new DeleteScheduledResource(); var factory = new Mock<IServerSchedulerFactory>(); var model = new Mock<IScheduledResourceModel>(); var ws = new Mock<IWorkspace>(); var trigger = new ScheduleTrigger(TaskState.Disabled, new Dev2DailyTrigger(new TaskServiceConvertorFactory(), new DailyTrigger(21)), new Dev2TaskService(new TaskServiceConvertorFactory()), new TaskServiceConvertorFactory()); var res = new ScheduledResource("a", SchedulerStatus.Enabled, DateTime.Now, trigger, "dave"); var security = new Mock<ISecurityWrapper>(); esbMethod.SecurityWrapper = security.Object; Dictionary<string, StringBuilder> inp = new Dictionary<string, StringBuilder>(); factory.Setup( a => a.CreateModel(GlobalConstants.SchedulerFolderId, It.IsAny<ISecurityWrapper>())).Returns(model.Object); Dev2JsonSerializer serialiser = new Dev2JsonSerializer(); if(expectCorrectInput) { model.Setup(a => a.DeleteSchedule(It.IsAny<ScheduledResource>())).Verifiable(); inp.Add("Resource", serialiser.SerializeToBuilder(res)); } esbMethod.SchedulerFactory = factory.Object; var output = esbMethod.Execute(inp, ws.Object); if(expectCorrectInput) model.Verify(a => a.DeleteSchedule(It.IsAny<ScheduledResource>())); return serialiser.Deserialize<ExecuteMessage>(output); }
public void ShouldReturnDependenciesMarkedWithAttribute() { ITask dep = new Mock<ITask>().Object; var task = new ATask {A = dep}; Assert.That(task.Dependencies.Select(d => d.Task), Is.EquivalentTo(new[] {dep})); }
public void Initialise() { _blogRepo = new SimpleRepository<Data.Blog>(new InMemoryRepositoryDataSource<Data.Blog>(new List<Data.Blog> { new Data.Blog { Id = 1, AuthoritiveUrl = "http://blog.test.con" } })); _templateRepo = new SimpleRepository<BlogTemplate>(new InMemoryRepositoryDataSource<BlogTemplate>()); _mockHttpContext = new Mock<IHttpContextService>(); _mockHttpContext.Setup(h => h.RequestUrl).Returns(new Uri("http://blog.test.con/blah")); }
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 SelectTests() { var html = @" <div> <span class=""center"">here</span> <a href=""http://google.com"">link</a> <div class=""dollar"">$6,566.00</div> <span class=""address"">4332 Forest Hill Blvd<br>West Palm Beach, FL 33406</span> <div id=""match-tests""> <li>6,566</li> <li>6</li> <li>8,975</li> <li>6,566,888</li> </div> <div id=""match-tests""> <li>10,566</li> <li>3</li> <li>1,975</li> <li>2,566,888</li> </div> </div> "; var httpRequest = new Mock<IHttpRequest>(); httpRequest.Setup(x => x.Download()).Returns(System.Text.Encoding.UTF8.GetBytes(html)); var requestFactory = new Mock<IHttpRequestFactory>(); requestFactory.Setup(x => x.Create(It.IsAny<IHttpWire>())).Returns(httpRequest.Object); _requestFactory = requestFactory.Object; }
private static IPackageService CreateService( Mock<IEntityRepository<PackageRegistration>> packageRegistrationRepository = null, Mock<IEntityRepository<Package>> packageRepository = null, Mock<IEntityRepository<PackageStatistics>> packageStatsRepo = null, Mock<IEntityRepository<PackageOwnerRequest>> packageOwnerRequestRepo = null, Mock<IIndexingService> indexingService = null, Action<Mock<PackageService>> setup = null) { packageRegistrationRepository = packageRegistrationRepository ?? new Mock<IEntityRepository<PackageRegistration>>(); packageRepository = packageRepository ?? new Mock<IEntityRepository<Package>>(); packageStatsRepo = packageStatsRepo ?? new Mock<IEntityRepository<PackageStatistics>>(); packageOwnerRequestRepo = packageOwnerRequestRepo ?? new Mock<IEntityRepository<PackageOwnerRequest>>(); indexingService = indexingService ?? new Mock<IIndexingService>(); var packageService = new Mock<PackageService>( packageRegistrationRepository.Object, packageRepository.Object, packageStatsRepo.Object, packageOwnerRequestRepo.Object, indexingService.Object); packageService.CallBase = true; if (setup != null) { setup(packageService); } return packageService.Object; }