public void Init_SpendingNotEditing_PropertiesSetupCorrectly() { Mvx.RegisterSingleton(() => new Mock<IMvxMessenger>().Object); var paymentRepoSetup = new Mock<IPaymentRepository>(); paymentRepoSetup.SetupGet(x => x.Selected).Returns(new Payment {ChargedAccountId = 3}); var paymentManager = new PaymentManager(paymentRepoSetup.Object, new Mock<IAccountRepository>().Object, new Mock<IDialogService>().Object); var accountRepoMock = new Mock<IAccountRepository>(); accountRepoMock.Setup(x => x.Load(It.IsAny<Expression<Func<Account, bool>>>())); accountRepoMock.SetupAllProperties(); var accountRepo = accountRepoMock.Object; accountRepo.Data = new ObservableCollection<Account> {new Account {Id = 3}}; var defaultManager = new DefaultManager(accountRepo); var viewmodel = new ModifyPaymentViewModel(paymentRepoSetup.Object, accountRepo, new Mock<IDialogService>().Object, paymentManager, defaultManager); //Execute and Assert viewmodel.Init("Income", true); viewmodel.SelectedPayment.Type.ShouldBe((int) PaymentType.Expense); viewmodel.SelectedPayment.IsTransfer.ShouldBeFalse(); viewmodel.SelectedPayment.IsRecurring.ShouldBeFalse(); }
public void Init_SpendingNotEditing_PropertiesSetupCorrectly() { //Setup var transactionRepositorySetup = new Mock<ITransactionRepository>(); transactionRepositorySetup.SetupProperty(x => x.Selected); var transactionManager = new TransactionManager(transactionRepositorySetup.Object, new Mock<IAccountRepository>().Object, new Mock<IDialogService>().Object); var accountRepoMock = new Mock<IAccountRepository>(); accountRepoMock.Setup(x => x.Load(It.IsAny<Expression<Func<Account, bool>>>())); accountRepoMock.SetupAllProperties(); var accountRepo = accountRepoMock.Object; accountRepo.Data = new ObservableCollection<Account>(); var defaultManager = new DefaultManager(accountRepo, new SettingDataAccess(new Mock<IRoamingSettings>().Object)); var viewmodel = new ModifyTransactionViewModel(transactionRepositorySetup.Object, accountRepo, new Mock<IDialogService>().Object, transactionManager, defaultManager); //Execute and Assert viewmodel.SelectedTransaction.ShouldBeNull(); viewmodel.Init(false, "Spending"); viewmodel.SelectedTransaction.Type.ShouldBe((int) TransactionType.Spending); viewmodel.SelectedTransaction.IsTransfer.ShouldBeFalse(); viewmodel.SelectedTransaction.IsRecurring.ShouldBeFalse(); }
public Task<PartialViewResult> GetInspectionResults(string code) { //Arrange var builder = new MockVbeBuilder(); VBComponent component; // ensure line endings are \r\n code = code.Replace("\r\n", "\n").Replace("\n", "\r\n"); var vbe = builder.BuildFromSingleStandardModule(code, out component); var mockHost = new Mock<IHostApplication>(); mockHost.SetupAllProperties(); var parser = MockParser.Create(vbe.Object, _state); Task.Run(() => parser.Parse(new System.Threading.CancellationTokenSource())).Wait(); if (parser.State.Status >= ParserState.Error) { throw new ArgumentException(parser.State.Status.ToString()); } var results = _inspector.Inspect(parser.State); if (results.Any()) { return Task.FromResult(PartialView("~/Views/Home/InspectionResults.cshtml", results)); } return Task.FromResult(PartialView("~/Views/Home/NoInspectionResults.cshtml", results)); }
public void ImplicitPublicMember_ReturnsResult_MultipleSubs() { const string inputCode = @"Sub Foo() End Sub Sub Goo() End Sub"; //Arrange var builder = new MockVbeBuilder(); VBComponent component; var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock<IHostApplication>(); mockHost.SetupAllProperties(); var parser = MockParser.Create(vbe.Object, new RubberduckParserState()); parser.Parse(); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); } var inspection = new ImplicitPublicMemberInspection(parser.State); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(2, inspectionResults.Count()); }
public void test_setup() { currentChainMock = new Mock<ICurrentChain>(); currentChainMock.SetupAllProperties(); handler = new Home.GetHandler(currentChainMock.Object); }
public void ReloadData_SelectedNotNull_SelectedSetToNull() { var accountRepoSetup = new Mock<IAccountRepository>(); accountRepoSetup.SetupAllProperties(); var transactionRepoSetup = new Mock<ITransactionRepository>(); transactionRepoSetup.SetupAllProperties(); var categoryRepoSetup = new Mock<IRepository<Category>>(); categoryRepoSetup.SetupAllProperties(); var accountRepo = accountRepoSetup.Object; var transactionRepo = transactionRepoSetup.Object; var categoryRepo = categoryRepoSetup.Object; accountRepo.Selected = new Account(); transactionRepo.Selected = new FinancialTransaction(); categoryRepo.Selected = new Category(); new RepositoryManager(accountRepo, transactionRepo, categoryRepo, new TransactionManager(transactionRepo, accountRepo, new Mock<IDialogService>().Object)).ReloadData(); accountRepo.Selected.ShouldBeNull(); transactionRepo.Selected.ShouldBeNull(); categoryRepo.Selected.ShouldBeNull(); }
public void ReloadData_CollectionNull_CollectionInstantiated() { var accountsLoaded = false; var transactionsLoaded = false; var categoryLoaded = false; var accountRepoSetup = new Mock<IAccountRepository>(); accountRepoSetup.SetupAllProperties(); accountRepoSetup.Setup(x => x.Load(It.IsAny<Expression<Func<Account, bool>>>())) .Callback(() => accountsLoaded = true); var transactionRepoSetup = new Mock<ITransactionRepository>(); transactionRepoSetup.SetupAllProperties(); transactionRepoSetup.Setup(x => x.Load(It.IsAny<Expression<Func<FinancialTransaction, bool>>>())) .Callback(() => transactionsLoaded = true); var categoryRepoSetup = new Mock<IRepository<Category>>(); categoryRepoSetup.SetupAllProperties(); categoryRepoSetup.Setup(x => x.Load(It.IsAny<Expression<Func<Category, bool>>>())) .Callback(() => categoryLoaded = true); var accountRepo = accountRepoSetup.Object; var transactionRepo = transactionRepoSetup.Object; new RepositoryManager(accountRepo, transactionRepo, categoryRepoSetup.Object, new TransactionManager(transactionRepo, accountRepo, new Mock<IDialogService>().Object)) .ReloadData(); accountsLoaded.ShouldBeTrue(); transactionsLoaded.ShouldBeTrue(); categoryLoaded.ShouldBeTrue(); }
public void ObsoleteLetStatement_ReturnsResult_MultipleLets() { const string inputCode = @"Public Sub Foo() Dim var1 As Integer Dim var2 As Integer Let var2 = var1 Let var1 = var2 End Sub"; //Arrange var builder = new MockVbeBuilder(); VBComponent component; var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock<IHostApplication>(); mockHost.SetupAllProperties(); var parser = MockParser.Create(vbe.Object, new RubberduckParserState()); parser.Parse(); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); } var inspection = new ObsoleteLetStatementInspection(parser.State); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(2, inspectionResults.Count()); }
public void UseMeaningfulName_ReturnsResult_NameEndsWithDigit() { const string inputCode = @"Sub Foo1() End Sub"; //Arrange var builder = new MockVbeBuilder(); var project = builder.ProjectBuilder("VBAProject", vbext_ProjectProtection.vbext_pp_none) .AddComponent("MyClass", vbext_ComponentType.vbext_ct_ClassModule, inputCode) .Build(); var vbe = builder.AddProject(project).Build(); var mockHost = new Mock<IHostApplication>(); mockHost.SetupAllProperties(); var parser = MockParser.Create(vbe.Object, new RubberduckParserState()); parser.Parse(); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); } var inspection = new UseMeaningfulNameInspection(null, parser.State); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(1, inspectionResults.Count()); }
public void ProcedureShouldBeFunction_ReturnsResult_MultipleSubs() { const string inputCode = @"Private Sub Foo(ByRef foo As Boolean) End Sub Private Sub Goo(ByRef foo As Integer) End Sub"; //Arrange var builder = new MockVbeBuilder(); VBComponent component; var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock<IHostApplication>(); mockHost.SetupAllProperties(); var parser = MockParser.Create(vbe.Object, new RubberduckParserState()); parser.Parse(); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); } var inspection = new ProcedureCanBeWrittenAsFunctionInspection(parser.State); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(2, inspectionResults.Count()); }
public void FunctionReturnValueNotUsed_ReturnsResult_AddressOf() { const string inputCode = @"Public Function Foo(ByVal bar As String) As Integer Foo = 42 End Function Public Sub Bar() Bar AddressOf Foo End Sub"; //Arrange var builder = new MockVbeBuilder(); VBComponent component; var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock<IHostApplication>(); mockHost.SetupAllProperties(); var parser = MockParser.Create(vbe.Object, new RubberduckParserState()); parser.Parse(); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); } var inspection = new FunctionReturnValueNotUsedInspection(parser.State); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(1, inspectionResults.Count()); }
public void DefaultFilterProvider_UsesFilterFactory_WithIFilterContainer() { // Arrange var filter = new Mock<IFilterContainer>(); filter.SetupAllProperties(); var filterFactory = new Mock<IFilterFactory>(); filterFactory .Setup(ff => ff.CreateInstance(It.IsAny<IServiceProvider>())) .Returns(filter.As<IFilterMetadata>().Object); var context = CreateFilterContext(new List<FilterItem>() { new FilterItem(new FilterDescriptor(filterFactory.Object, FilterScope.Global)), }); var provider = CreateProvider(); // Act provider.OnProvidersExecuting(context); provider.OnProvidersExecuted(context); var results = context.Results; // Assert var item = Assert.Single(results); Assert.Same(filter.Object, item.Filter); Assert.Same(filterFactory.Object, ((IFilterContainer)item.Filter).FilterDefinition); Assert.Same(filterFactory.Object, item.Descriptor.Filter); Assert.Equal(0, item.Descriptor.Order); }
public void UnassignedVariable_DoesNotReturnResult() { const string inputCode = @"Function Foo() As Boolean Dim var1 as String var1 = ""test"" Goo var1 End Function Sub Goo(ByVal arg1 As String) End Sub"; //Arrange var builder = new MockVbeBuilder(); VBComponent component; var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock<IHostApplication>(); mockHost.SetupAllProperties(); var parser = MockParser.Create(vbe.Object, new RubberduckParserState()); parser.Parse(); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); } var inspection = new VariableNotUsedInspection(parser.State); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(0, inspectionResults.Count()); }
protected override void OnStartup(StartupEventArgs e) { base.OnStartup(e); // init stubs var fakeExplorer = new Mock<Explorer>(); fakeExplorer.SetupAllProperties(); var fakeMailItem = new Mock<MailItem>(); fakeMailItem.SetupAllProperties(); fakeMailItem.Object.Subject = "test subj"; fakeMailItem.Object.Body = "test body"; var atts = new Mock<Attachments>(); atts.Setup(a => a.GetEnumerator()).Returns(ProductList); fakeMailItem.SetupGet(m => m.Attachments).Returns(atts.Object); var _container = new SimpleContainer() .RegisterSingle(fakeExplorer) .Register<IView>(container => new NewWorkItem()) .Register<AppViewModel>(container => new AppViewModel()) .Register<IPresenter>(container => new Presenter { View = container.Create<IView>(), ViewModel = container.Create<AppViewModel>() }); var form = _container.Create<IPresenter>(); form.Initialize(fakeMailItem.Object); }
public void BasicCase2ShouldReturnBasicTriangles() { var vol1 = new Mock<IVolume>(); vol1.SetupAllProperties(); vol1.Setup(x => x.Height).Returns(1); vol1.Setup(x => x.Depth).Returns(1); vol1.Setup(x => x.Width).Returns(1); vol1.Setup(x => x.GetVoxelValueAt(0, 0, 0)).Returns(FullBlack); vol1.Setup(x => x.GetVoxelValueAt(0, 1, 0)).Returns(FullBlack); var t1 = new Triangle { Edge1 = new Point3D { X = 0.5, Y = 0.0, Z = 0.0 }, Edge2 = new Point3D { X = 0.0, Y = 0.5, Z = 1.0 }, Edge3 = new Point3D { X = 0.5, Y = 1.0, Z = 0.5 } }; var t2 = new Triangle { Edge1 = new Point3D { X = 0.5, Y = 0.0, Z = 0.0 }, Edge2 = new Point3D { X = 0.0, Y = 0.0, Z = 0.5 }, Edge3 = new Point3D { X = 0.5, Y = 1.0, Z = 0.5 } }; var expected = new List<ITriangle> { t1, t2 }; Assert.AreEqual(expected, MarchingCubes.Instance.GetTriangles(vol1.Object, Threshold, GridSize)); }
public IHttpWebRequest GetWebRequest(Uri url) { var mock = new Mock<IHttpWebRequest>(); mock.SetupAllProperties(); mock.Setup(m => m.GetResponse()) .Returns(() => { var mockResponse = new Mock<IHttpWebResponse>(); mockResponse.SetupAllProperties(); mockResponse.SetupProperty(m => m.Headers, new WebHeaderCollection()); byte[] responseContent = new byte[0]; if (mock.Object.Method == "GET") { if (url.AbsolutePath == "/movies/") responseContent = Encoding.UTF8.GetBytes(GetFromResources("SimpleBrowser.UnitTests.SampleDocs.movies1.htm")); if (url.AbsolutePath == "/movies/Movies/Create") responseContent = Encoding.UTF8.GetBytes(GetFromResources("SimpleBrowser.UnitTests.SampleDocs.movies2.htm")); } else if (mock.Object.Method == "POST") { if (url.AbsolutePath == "/movies/Movies/Create") { mockResponse.Object.StatusCode = HttpStatusCode.Moved; mockResponse.Object.Headers.Add(HttpResponseHeader.Location, "http://localhost/movies/"); } } mockResponse.Setup(r => r.GetResponseStream()).Returns(new MemoryStream(responseContent)); return mockResponse.Object; }); mock.SetupProperty(m => m.Headers, new WebHeaderCollection()); mock.Setup(m => m.GetRequestStream()).Returns(new MemoryStream(new byte[20000])); return mock.Object; }
public ISessionDataService Build() { var mock = new Mock<ISessionDataService>(); mock.SetupAllProperties(); mock.Setup(s => s.SessionExists(It.IsAny<Guid>(), It.IsAny<IUser>(), It.IsAny<bool>())) .Returns( (Guid identifier, IUser user, bool includeExpired) => Sessions.Any( x => x.Identifier == identifier && x.User.Active && x.User.Email == user.Email && (includeExpired || x.ExpiresOn > DateTime.UtcNow )) ); mock.Setup(s => s.CreateSession(It.IsAny<IUser>())) .Returns((IUser user) => _sessionBuilder .Build(s => { s.User = user; })); mock.Setup(s => s.InsertSession(It.IsAny<ISession>())) .Callback((ISession session) => Sessions.Add(session)); return mock.Object; }
public void DeleteAccountCommand_UserReturnTrue_ExecuteDeletion() { var deleteCalled = false; var accountRepoSetup = new Mock<IAccountRepository>(); accountRepoSetup.SetupAllProperties(); accountRepoSetup.Setup(x => x.Delete(It.IsAny<Account>())).Callback(() => deleteCalled = true); var accountRepo = accountRepoSetup.Object; var paymentRepoSetup = new Mock<IPaymentRepository>(); paymentRepoSetup.SetupAllProperties(); var dialogServiceSetup = new Mock<IDialogService>(); dialogServiceSetup.Setup(x => x.ShowConfirmMessage(It.IsAny<string>(), It.IsAny<string>(), null, null)) .Returns(Task.FromResult(true)); var viewModel = new AccountListViewModel(accountRepo, paymentRepoSetup.Object, dialogServiceSetup.Object ); viewModel.DeleteAccountCommand.Execute(new Account {Id = 3}); deleteCalled.ShouldBeTrue(); }
public IUserDataService Build() { var mock = new Mock<IUserDataService>(); mock.SetupAllProperties(); mock.Setup(s => s.TryGetUser(It.IsAny<string>())) .Returns((string email) => Users.Single(u => u.Email == email)); mock.Setup(s => s.UserExists(It.IsAny<string>())) .Returns((string email) => Users.Any(u => u.Email == email)); mock.Setup(s => s.InsertUser(It.IsAny<IUser>())) .Callback((IUser user) => Users.Add(user)); mock.Setup(s => s.CreateUser(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>())) .Returns(( string name, string email, string passwordHash) => _userBuilder .Build(u => { u.Email = email; u.PasswordHash = passwordHash; u.Name = name; }) ); return mock.Object; }
public void ReloadData_SelectedNotNull_SelectedSetToNull() { var accountRepoSetup = new Mock<IAccountRepository>(); accountRepoSetup.SetupAllProperties(); var paymentRepoSetup = new Mock<IPaymentRepository>(); paymentRepoSetup.SetupAllProperties(); var categoryRepoSetup = new Mock<IRepository<Category>>(); categoryRepoSetup.SetupAllProperties(); var accountRepo = accountRepoSetup.Object; var paymentRepository = paymentRepoSetup.Object; var categoryRepo = categoryRepoSetup.Object; accountRepo.Selected = new Account(); paymentRepository.Selected = new Payment(); categoryRepo.Selected = new Category(); new RepositoryManager(accountRepo, paymentRepository, categoryRepo, new PaymentManager(paymentRepository, accountRepo, new Mock<IDialogService>().Object)).ReloadData(); Assert.IsNull(accountRepo.Selected); Assert.IsNull(paymentRepository.Selected); Assert.IsNull(categoryRepo.Selected); }
public void ReloadData_CollectionNull_CollectionInstantiated() { var accountsLoaded = false; var paymentsLoaded = false; var categoryLoaded = false; var accountRepoSetup = new Mock<IAccountRepository>(); accountRepoSetup.SetupAllProperties(); accountRepoSetup.Setup(x => x.Load(It.IsAny<Expression<Func<Account, bool>>>())) .Callback(() => accountsLoaded = true); var paymentRepoSetup = new Mock<IPaymentRepository>(); paymentRepoSetup.SetupAllProperties(); paymentRepoSetup.Setup(x => x.Load(It.IsAny<Expression<Func<Payment, bool>>>())) .Callback(() => paymentsLoaded = true); var categoryRepoSetup = new Mock<IRepository<Category>>(); categoryRepoSetup.SetupAllProperties(); categoryRepoSetup.Setup(x => x.Load(It.IsAny<Expression<Func<Category, bool>>>())) .Callback(() => categoryLoaded = true); var accountRepo = accountRepoSetup.Object; var paymentRepository = paymentRepoSetup.Object; new RepositoryManager(accountRepo, paymentRepository, categoryRepoSetup.Object, new PaymentManager(paymentRepository, accountRepo, new Mock<IDialogService>().Object)) .ReloadData(); Assert.IsTrue(accountsLoaded); Assert.IsTrue(paymentsLoaded); Assert.IsTrue(categoryLoaded); }
public void HeaderModuleTestInitialize() { _mockRequest = new Mock<HttpRequestBase>(); _mockRequest.Setup(r => r.UserAgent).Returns("Ninja CSP browser"); _responseHeaders = new NameValueCollection(); _mockResponse = new Mock<HttpResponseBase>(); _mockResponse.Setup(r => r.Headers).Returns(_responseHeaders); var mockedContext = new Mock<HttpContextBase>(); mockedContext.SetupAllProperties(); mockedContext.Setup(c => c.Request).Returns(_mockRequest.Object); mockedContext.Setup(c => c.Response).Returns(_mockResponse.Object); _expectedHeaderResult = new HeaderResult(HeaderResult.ResponseAction.Set, "SomeHeader", "SomeValue"); _mockHeaderGenerator = new Mock<IHeaderGenerator>(MockBehavior.Strict); _mockHeaderResultHandler = new Mock<IHeaderResultHandler>(MockBehavior.Strict); _mockHeaderResultHandler.Setup(h => h.HandleHeaderResult(It.IsAny<HttpResponseBase>(), _expectedHeaderResult)); _mockHandlerHelper = new Mock<IHandlerTypeHelper>(); _mockCspReportHelper = new Mock<ICspReportHelper>(MockBehavior.Strict); _mockContext = mockedContext.Object; _config = new HttpHeaderSecurityConfigurationSection(); _configHeaderSetter = new ConfigurationHeaderSetter(_config, _mockHeaderGenerator.Object, _mockHeaderResultHandler.Object, _mockHandlerHelper.Object, _mockCspReportHelper.Object); _nwebsecContext = new NWebsecContext(); }
public void Loaded_NoConnectivity_NothingCalled() { // Setup var connectivitySetup = new Mock<IConnectivity>(); connectivitySetup.Setup(x => x.IsConnected).Returns(false); var settingsManagerMock = new Mock<ISettingsManager>(); settingsManagerMock.SetupAllProperties(); var checkBackupCalled = false; var getBackupDateCalled = false; var backupManagerSetup = new Mock<IBackupManager>(); backupManagerSetup.Setup(x => x.IsBackupExisting()).Callback(() => checkBackupCalled = true); backupManagerSetup.Setup(x => x.GetBackupDate()).Callback(() => getBackupDateCalled = true); //execute var vm = new BackupViewModel(backupManagerSetup.Object, null, connectivitySetup.Object, settingsManagerMock.Object); vm.LoadedCommand.Execute(); //assert vm.IsLoadingBackupAvailability.ShouldBeFalse(); checkBackupCalled.ShouldBeFalse(); getBackupDateCalled.ShouldBeFalse(); }
public void InitFromModel_WhenCalled_InitializesViewFromModelValue() { Mock<IPatientHeaderView> mockHeaderView = new Mock<IPatientHeaderView>(); mockHeaderView.SetupAllProperties(); var headerViewObject = mockHeaderView.Object; var patient = TestUtilities.GetPatient(); var patientHeaderPresenter = new PatientHeaderPresenter(headerViewObject, patient); patientHeaderPresenter.InitViewFromModel(); Assert.AreEqual(patient.AgeMonths,headerViewObject.AgeMonths); Assert.AreEqual(patient.AgeYear,headerViewObject.AgeYears); Assert.AreEqual(patient.AtPost,headerViewObject.AtPost); Assert.AreEqual(patient.District,headerViewObject.District); Assert.AreEqual(patient.Email, headerViewObject.Email); Assert.AreEqual(patient.GuNumber,headerViewObject.GUId); Assert.AreEqual(patient.Mobile, headerViewObject.Mobile); Assert.AreEqual(patient.Name, headerViewObject.PatientName); Assert.AreEqual(patient.Occupation.ToString(), headerViewObject.Ocupation); Assert.AreEqual(patient.PhoneNumber, headerViewObject.Phone); Assert.AreEqual(patient.ReferenceDoctor, headerViewObject.ReferalDoctor); Assert.AreEqual(patient.RegistrationDate, headerViewObject.RegisterationDate); Assert.AreEqual(patient.Salutation, headerViewObject.Salutation); Assert.AreEqual(patient.Sex, headerViewObject.Sex); Assert.AreEqual(patient.State, headerViewObject.State); Assert.AreEqual(patient.Town, headerViewObject.Town); }
public void EmptyStringLiteral_ReturnsResult_PassToProcedure() { const string inputCode = @"Public Sub Bar() Foo """" End Sub Public Sub Foo(ByRef arg1 As String) End Sub"; //Arrange var builder = new MockVbeBuilder(); VBComponent component; var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock<IHostApplication>(); mockHost.SetupAllProperties(); var parser = MockParser.Create(vbe.Object, new RubberduckParserState()); parser.Parse(); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); } var inspection = new EmptyStringLiteralInspection(parser.State); var inspectionResults = inspection.GetInspectionResults(); Assert.AreEqual(1, inspectionResults.Count()); }
public void ContactPersonalInfoHydrator_File_Test() { var collection = new NameValueCollection(); var fields = new string[] {"dob", "first", "gender", "job", "middle", "nickname", "suffix", "last", "title"}; foreach (var field in fields) { collection[field] = (string)this.TestContext.DataRow[field]; } var list = new List<string>(); foreach (string key in collection.Keys) { list.Add(string.Format("{0}={1}", HttpUtility.UrlEncode(key), HttpUtility.UrlEncode(collection[key]))); } var queryString = string.Join("&", list.ToArray()); var path = Path.GetTempFileName(); File.WriteAllText(path, queryString); var mockPersonalInfo = new Mock<IContactPersonalInfo>(); mockPersonalInfo.SetupAllProperties(); Assert.IsNull(mockPersonalInfo.Object.BirthDate); var hydrator = new ContactPersonalInfoHydrator(mockPersonalInfo.Object); hydrator.Hydrate(File.OpenRead(path)); ConfirmContactPersonalInfo(collection, mockPersonalInfo.Object); }
public void FindMixedCaseFileWIthLowerCaseSearch() { var fileNameToFind = "caseSensitiveFile.gpg"; var anotherFile = "somefile.gpg"; var fileMockOne = new Mock<IFileProvider>(); var fileMockTwo = new Mock<IFileProvider>(); fileMockOne.SetupAllProperties(); fileMockOne.Object.Name = fileNameToFind; fileMockOne.Object.FullName = fileNameToFind; fileMockTwo.SetupAllProperties(); fileMockTwo.Object.Name = anotherFile; fileMockTwo.Object.FullName = anotherFile; var fileProviderMockList = new List<IFileProvider> { fileMockOne.Object, fileMockTwo.Object }; var directoryProviderMock = Setup.Scope.Resolve<Mock<IDirectoryProvider>>(); directoryProviderMock.Setup( m => m.GetFiles(It.IsAny<string>(), It.Is<SearchOption>(so => so == SearchOption.AllDirectories))) .Returns(fileProviderMockList.ToArray()); var fsi = Setup.Scope.Resolve<FileSystemInterface>(); fsi.Search(fileNameToFind.ToLower()); Assert.AreEqual(1, fsi.SearchList.Count); Assert.AreEqual(fileNameToFind, fsi.SearchList[0]); }
public void FixtureSetup() { mfs = new MediaFileSet (); mfs.Add (new MediaFile { FilePath = "test1", VideoWidth = 320, VideoHeight = 240, Par = 1 }); mfs.Add (new MediaFile { FilePath = "test2", VideoWidth = 320, VideoHeight = 240, Par = 1 }); mockAnalysisWindow = new Mock<IAnalysisWindowBase> (); mockPlayerController = new Mock<IPlayerController> (); mockPlayerController.SetupAllProperties (); mockPlayerController.SetupGet (x => x.CurrentTime).Returns (new Time (1000)); MediaFileSet mf = new MediaFileSet (); mf.Add (new MediaFile ("path", 34000, 25, true, true, "mp4", "h264", "aac", 320, 240, 1.3, null, "Test asset")); mockPlayerController.SetupGet (m => m.FileSet).Returns (mf); mockAnalysisWindow.SetupGet (m => m.Player).Returns (mockPlayerController.Object); mockVideoRenderer = new Mock<IJobsManager> (); mockDiaklogs = new Mock<IDialogs> (); playerMock = new Mock<IPlayer> (); playerMock.SetupAllProperties (); Mock<IMultiPlayer> multiplayerMock = new Mock<IMultiPlayer> (); multimediaToolkitMock = new Mock<IMultimediaToolkit> (); multimediaToolkitMock.Setup (m => m.GetPlayer ()).Returns (playerMock.Object); App.Current.MultimediaToolkit = multimediaToolkitMock.Object; App.Current.LowerRate = 1; App.Current.UpperRate = 30; App.Current.RatePageIncrement = 3; App.Current.RateList = new List<double> { 0.04, 0.08, 0.12, 0.16, 0.20, 0.24, 0.28, 0.32, 0.36, 0.40, 0.44, 0.48, 0.52, 0.56, 0.60, 0.64, 0.68, 0.72, 0.76, 0.80, 0.84, 0.88, 0.92, 0.96, 1, 2, 3, 4, 5 }; App.Current.DefaultRate = 25; }
public static HttpContextBase MockHttpContext() { var context = new Mock<HttpContextBase>(); var request = new Mock<HttpRequestBase>(); var response = new Mock<HttpResponseBase>(); var session = new Mock<HttpSessionStateBase>(); var server = new Mock<HttpServerUtilityBase>(); var genericCollection = new Mock<NameValueCollection>(); var items = new Mock<IDictionary>(); response.SetupAllProperties(); request.SetupGet(x => x.Headers).Returns(genericCollection.Object); request.SetupGet(x => x.QueryString).Returns(genericCollection.Object); request.SetupGet(x => x.Form).Returns(genericCollection.Object); request.SetupGet(x => x.ServerVariables).Returns(genericCollection.Object); context.SetupGet(x => x.Items).Returns(items.Object); context.SetupGet(x => x.Request).Returns(request.Object); context.SetupGet(x => x.Response).Returns(response.Object); context.SetupGet(x => x.Session).Returns(session.Object); context.SetupGet(x => x.Server).Returns(server.Object); context.SetupProperty(x => x.User, (IPrincipal)null); return context.Object; }
public void FixtureSetup() { playerMock = new Mock<IPlayer> (); playerMock.SetupAllProperties (); /* Mock properties without setter */ playerMock.Setup (p => p.CurrentTime).Returns (() => currentTime); playerMock.Setup (p => p.StreamLength).Returns (() => streamLength); playerMock.Setup (p => p.Play ()).Raises (p => p.StateChange += null, this, true); playerMock.Setup (p => p.Pause ()).Raises (p => p.StateChange += null, this, false); mtkMock = new Mock<IMultimediaToolkit> (); mtkMock.Setup (m => m.GetPlayer ()).Returns (playerMock.Object); mtkMock.Setup (m => m.GetMultiPlayer ()).Throws (new Exception ()); Config.MultimediaToolkit = mtkMock.Object; var ftk = new Mock<IGUIToolkit> (); ftk.Setup (m => m.Invoke (It.IsAny<EventHandler> ())).Callback<EventHandler> (e => e (null, null)); Config.GUIToolkit = ftk.Object; Config.EventsBroker = new EventsBroker (); mfs = new MediaFileSet (); mfs.Add (new MediaFile { FilePath = "test1", VideoWidth = 320, VideoHeight = 240, Par = 1 }); mfs.Add (new MediaFile { FilePath = "test2", VideoWidth = 320, VideoHeight = 240, Par = 1 }); evt = new TimelineEvent { Start = new Time (100), Stop = new Time (200), CamerasConfig = new List<CameraConfig> { new CameraConfig (0) } }; plImage = new PlaylistImage (Utils.LoadImageFromFile (), new Time (5)); playlist = new Playlist (); playlist.Elements.Add (new PlaylistPlayElement (evt)); playlist.Elements.Add (plImage); }
public void CreateThreadPresenter_ThreadsRepositoryShouldTransferTo500_IfSomethingGoesWrong() { var view = new Mock <ICreateThreadView>(); view.SetupAllProperties(); var forumData = new Mock <IForumData>(); var threadsRepository = new Mock <IThreadsRepository>(); var section = new Section() { Name = "TestSection" }; forumData.Setup(s => s.SectionsRepository.GetSectionByName(It.IsAny <string>())).Returns(section); forumData.Setup(f => f.ThreadsRepository).Returns(threadsRepository.Object); threadsRepository.Setup(t => t.CreateThread(It.IsAny <Thread>())).Throws(new Exception()); var presenter = new CreateThreadPresenter(view.Object, forumData.Object); var testContent = "TestContent Should be at least 50 characters long!!!"; Assert.Throws <HttpException>(() => view.Raise(v => v.Create += null, new ThreadEventArgs("TestTitle", testContent, "TestSection", 1))); }
private ITrader CreateTrader(State playerState) { var trader = new Mock <ITrader>(); trader.SetupAllProperties(); trader.Setup(t => t.PlayerState).Returns(new StateMachine(playerState)); var inventory = new Mock <IInventoryStorage>(); var itemStorage = new Mock <ItemStorage>(); itemStorage.Setup(i => i.Items).Returns(new List <Item>()); inventory.Setup(i => i.ItemStorage).Returns(itemStorage.Object); trader.Setup(t => t.Inventory).Returns(inventory.Object); trader.Object.BackupInventory = new BackupItemStorage(itemStorage.Object) { Items = new List <Item>() }; var temporaryStorage = new Mock <IStorage>(); temporaryStorage.Setup(t => t.Items).Returns(new List <Item>()); trader.Setup(t => t.TemporaryStorage).Returns(temporaryStorage.Object); trader.Setup(t => t.ViewPlugIns).Returns(new MockViewPlugInContainer()); return(trader.Object); }
public void CuentaBancariaLoggerGeneral_LogMockingPropiedadPrioridadTipoCallBacks_ReturnsTrue() { var loggerGeneralMock = new Mock <ILoggerGeneral>(); loggerGeneralMock.SetupAllProperties(); loggerGeneralMock.Setup(x => x.TipoLogger).Returns("warning"); loggerGeneralMock.Setup(x => x.PrioridadLogger).Returns(10); loggerGeneralMock.Object.PrioridadLogger = 100; Assert.Equal("warning", loggerGeneralMock.Object.TipoLogger); Assert.Equal(100, loggerGeneralMock.Object.PrioridadLogger); string textoTemporal = "axel"; loggerGeneralMock.Setup(x => x.LogDatabase(It.IsAny <string>())) .Returns(true) .Callback((string parametro) => textoTemporal += parametro); loggerGeneralMock.Object.LogDatabase("vasquez"); Assert.Equal("axelvasquez", textoTemporal); }
public void Discovery_IgnoresNonAnnotatedTestMethods() { var testMethods = @"Public Sub TestMethod1() End Sub"; var builder = new MockVbeBuilder(); var project = builder.ProjectBuilder("TestProject1", vbext_ProjectProtection.vbext_pp_none) .AddComponent("TestModule1", vbext_ComponentType.vbext_ct_StdModule, GetTestModuleInput + testMethods); var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock <IHostApplication>(); mockHost.SetupAllProperties(); var parser = MockParser.Create(vbe.Object, new RubberduckParserState()); parser.Parse(); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } Assert.IsFalse(UnitTestHelpers.GetAllTests(vbe.Object, parser.State).Any()); }
/// <summary> /// Gets the player. /// </summary> /// <returns>The test player.</returns> public static Player GetPlayer() { var gameConfig = new Mock <GameConfiguration>(); gameConfig.SetupAllProperties(); gameConfig.Setup(c => c.Maps).Returns(new List <GameMapDefinition>()); gameConfig.Setup(c => c.Items).Returns(new List <ItemDefinition>()); gameConfig.Setup(c => c.Skills).Returns(new List <Skill>()); gameConfig.Setup(c => c.PlugInConfigurations).Returns(new List <PlugInConfiguration>()); var map = new Mock <GameMapDefinition>(); map.SetupAllProperties(); map.Setup(m => m.DropItemGroups).Returns(new List <DropItemGroup>()); map.Setup(m => m.MonsterSpawns).Returns(new List <MonsterSpawnArea>()); map.Object.TerrainData = new byte[ushort.MaxValue + 3]; gameConfig.Object.RecoveryInterval = int.MaxValue; gameConfig.Object.Maps.Add(map.Object); var mapInitializer = new MapInitializer(gameConfig.Object, new NullLogger <MapInitializer>()); var gameContext = new GameContext(gameConfig.Object, new InMemoryPersistenceContextProvider(), mapInitializer, new NullLoggerFactory(), new PlugInManager(null, new NullLoggerFactory(), null)); return(GetPlayer(gameContext)); }
public void LanguageSelectedCommand_AlreadyIsLanguageChange_ShouldNotSetLanguage() { // Arrange var languageBeforeChange = "English"; var commons = new Mock <ICommons>(); commons.SetupAllProperties(); commons.Object.SelectedLanguage = languageBeforeChange; var viewModel = GetViewModel(commons.Object, null); viewModel.IsLanguageChange = true; var languageToSet = new SupportedLanguage("Deutsch"); // Act var ex = Record.Exception(() => viewModel.LanguageSelectedCommand.Execute(languageToSet)); // Assert Assert.Null(ex); Assert.Equal(languageBeforeChange, commons.Object.SelectedLanguage); }
public void Does_Not_Clone_When_Connection_Is_Not_Cloneable() { using (GlobalSettings.UseTestInstance()) { var db = new Mock <IDbConnection>(); var cmd = new Mock <IDbCommand>(); cmd.SetupAllProperties(); db.Setup(d => d.CreateCommand()).Returns(cmd.Object); IDbConnection outConn; var res = db.Object.CreateCommand("foo", "bar", 20, out outConn); outConn.Should().BeNull(); res.Should().NotBeNull(); res.CommandText.Should().Be("[foo].[bar]"); res.CommandTimeout.Should().Be(20); res.CommandType.Should().Be(CommandType.StoredProcedure); db.Verify(d => d.CreateCommand(), Times.Once()); db.Verify(d => d.Open(), Times.Never()); } }
public void ContinueCommand_IsExecuted_ShouldSetSelectedLanguageInAppSettings() { // Arrange var commons = new Mock <ICommons>(); commons.SetupAllProperties(); var appSettings = new Mock <IAppSettings>(); appSettings.SetupAllProperties(); var viewModel = GetViewModel(commons.Object, appSettings.Object); viewModel.SelectedItem = viewModel.Languages[1]; var expectedLanguage = viewModel.SelectedItem.Name; // Act viewModel.ContinueCommand.Execute(null); // Assert Assert.Equal(expectedLanguage, appSettings.Object.SelectedLanguage); }
public void Impl_Input_Should_Pass_Input_To_InputManager() { var inputManagerMock = new Mock <IInputManager>(); var services = TestServices.StyledWindow.With(inputManager: inputManagerMock.Object); using (UnitTestApplication.Start(services)) { var impl = new Mock <ITopLevelImpl>(); impl.SetupAllProperties(); var target = new TestTopLevel(impl.Object); var input = new RawKeyEventArgs( new Mock <IKeyboardDevice>().Object, 0, target, RawKeyEventType.KeyDown, Key.A, RawInputModifiers.None); impl.Object.Input(input); inputManagerMock.Verify(x => x.ProcessInput(input)); } }
public void Impl_Close_Should_Raise_DetachedFromLogicalTree_Event() { using (UnitTestApplication.Start(TestServices.StyledWindow)) { var impl = new Mock <ITopLevelImpl>(); impl.SetupAllProperties(); var target = new TestTopLevel(impl.Object); var raised = 0; target.DetachedFromLogicalTree += (s, e) => { Assert.Same(target, e.Root); Assert.Same(target, e.Source); Assert.Null(e.Parent); ++raised; }; impl.Object.Closed(); Assert.Equal(1, raised); } }
public async void ContinueConversationAsync_Should_Succeed() { bool callbackInvoked = false; var options = new Mock <ITwilioAdapterOptions>(); options.SetupAllProperties(); options.Object.AuthToken = "Test"; options.Object.TwilioNumber = "Test"; options.Object.AccountSid = "Test"; var twilioAdapter = new TwilioAdapter(options.Object, new Mock <ITwilioClient>().Object); var conversationReference = new ConversationReference(); Task BotsLogic(ITurnContext turnContext, CancellationToken cancellationToken) { callbackInvoked = true; return(Task.CompletedTask); } await twilioAdapter.ContinueConversationAsync(conversationReference, BotsLogic, default); Assert.True(callbackInvoked); }
public async void SendActivitiesAsync_Should_Fail_With_ActivityType_Not_Message() { var options = new Mock <ITwilioAdapterOptions>(); options.SetupAllProperties(); options.Object.AuthToken = "Test"; options.Object.TwilioNumber = "Test"; options.Object.AccountSid = "Test"; var twilioAdapter = new TwilioAdapter(options.Object, new Mock <ITwilioClient>().Object); var activity = new Activity() { Type = ActivityTypes.Event, }; Activity[] activities = { activity }; await Assert.ThrowsAsync <Exception>(async() => { await twilioAdapter.SendActivitiesAsync(new TurnContext(twilioAdapter, activity), activities, default); }); }
public void BackupSyncRecurrence(int passedValue, int expectedValue) { // Arrange var settingsManagerMock = new Mock <ISettingsManager>(); settingsManagerMock.SetupAllProperties(); var taskStarted = false; var backgroundTaskManager = new Mock <IBackgroundTaskManager>(); backgroundTaskManager.Setup(x => x.StartBackupSyncTask(It.IsAny <int>())).Callback(() => taskStarted = true); // Act var vm = new SettingsBackgroundJobViewModel(settingsManagerMock.Object, backgroundTaskManager.Object, new Mock <IMvxLogProvider>().Object, new Mock <IMvxNavigationService>().Object); vm.BackupSyncRecurrence = passedValue; // Assert Assert.True(taskStarted); Assert.Equal(expectedValue, vm.BackupSyncRecurrence); }
public ProdutoEditTeste() { _viewMock = new Mock <IProdutoEditView>(); _viewMock.SetupAllProperties(); _repo = new Mock <IProdutoRepository>(); _repo.Setup(f => f.IncluirAsync(It.IsAny <Produto>())) .ReturnsAsync(new Resultado()); _eventAggregator = new Mock <IEventAggregator>(); _eventAggregator.SetupAllProperties(); var dialogMock = new DialogMock(); var arquivoServiceMock = new Mock <IArquivoService>(); arquivoServiceMock.SetupAllProperties(); _presenter = new ProdutoEditPresenter( _viewMock.Object, dialogMock, arquivoServiceMock.Object, _repo.Object, _eventAggregator.Object); }
public void SetCspHeaders_Override_CreatesAndHandlesHeaderResult(bool reportOnly) { //Get ASP.NET stuff in order var request = new Mock <HttpRequest>(); request.SetupAllProperties(); Mock.Get(_mockContext).Setup(c => c.Request).Returns(request.Object); //const string reportUri = "/cspreport"; var contextConfig = new CspConfiguration(); var overrideConfig = new CspConfiguration(); _contextHelper.Setup(h => h.GetCspConfiguration(It.IsAny <HttpContext>(), reportOnly)).Returns(contextConfig); _cspConfigurationOverrideHelper.Setup(h => h.GetCspConfigWithOverrides(It.IsAny <HttpContext>(), reportOnly)).Returns(overrideConfig); //_reportHelper.Setup(h => h.GetBuiltInCspReportHandlerRelativeUri()).Returns(reportUri); //TODO reporthelper _headerGenerator.Setup(g => g.CreateCspResult(overrideConfig, reportOnly, null, contextConfig)).Returns(_expectedHeaderResult); _overrideHelper.SetCspHeaders(_mockContext, reportOnly); _headerResultHandler.Verify(h => h.HandleHeaderResult(It.IsAny <HttpResponse>(), _expectedHeaderResult), Times.Once); }
public void HandleMessage_MustRefireEventOnHostedEventBroker() { const string ExpectedTopic = "topic://testtopic"; const HandlerRestriction HandlerRestriction = HandlerRestriction.Asynchronous; CancelEventArgs cancelEventArgs = new CancelEventArgs(true); var serializer = this.GetSerializer(); var eventFired = new Mock <IEventFired>(); eventFired.SetupAllProperties(); eventFired.Object.EventArgsType = typeof(CancelEventArgs).AssemblyQualifiedName; eventFired.Object.Topic = ExpectedTopic; eventFired.Object.HandlerRestriction = HandlerRestriction; serializer.Setup(s => s.Deserialize(typeof(CancelEventArgs), It.IsAny <string>())).Returns(cancelEventArgs); this.SetupManagedEventBroker(); this.testee.TestHandleMessage(eventFired.Object); this.eventBroker.Verify(eb => eb.Fire(ExpectedTopic, this.testee, HandlerRestriction, this.testee, cancelEventArgs)); }
public void Setup() { _mockCheckSpecialPrice = new Mock <ICheckSpecialPrice>(); _mockProduct = new Mock <IProduct>(); _mockSpecialPrice = new Mock <ISpecialPrice>(); _mockProduct.SetupAllProperties(); _mockSpecialPrice.SetupAllProperties(); _mockCheckSpecialPrice.SetupAllProperties(); _mockSpecialPrice.Object.SpecialPriceID = 1; _mockSpecialPrice.Object.SpecialPriceOffer = 130; _mockSpecialPrice.Object.SpecialPriceQuantity = 3; _mockProduct.Object.ProdID = 1; _mockProduct.Object.ProdName = "A"; _mockProduct.Object.ProdPrice = 50; _mockProduct.Object.SpecialPrice = _mockSpecialPrice.Object; _mockCheckSpecialPrice.Setup(x => x.GetTotalOfferPrice(3, _mockProduct.Object)).Returns(20); _checkout = new Checkout(_mockCheckSpecialPrice.Object); }
public void SaveCategory_UpdateTimeStamp() { var category = new Category { Id = 0, Name = "category", Notes = "" }; var categoryRepositorySetup = new Mock <ICategoryRepository>(); categoryRepositorySetup.SetupAllProperties(); categoryRepositorySetup.Setup(x => x.Save(category)).Returns(true); categoryRepositorySetup.Setup(x => x.GetList(null)).Returns(() => new ObservableCollection <Category>()); var viewmodel = new ModifyCategoryViewModel(categoryRepositorySetup.Object, new Mock <IDialogService>().Object) { IsEdit = false, SelectedCategory = category }; viewmodel.SaveCommand.Execute(); localDateSetting.ShouldBeGreaterThan(DateTime.Now.AddSeconds(-1)); localDateSetting.ShouldBeLessThan(DateTime.Now.AddSeconds(1)); }
public void LocalAndRemoteFilesAreSavedAsEqualIfTheContentIsEqual() { var fileInfo = new Mock <IFileInfo>(); var parentDir = Mock.Of <IDirectoryInfo>(d => d.FullName == Path.GetTempPath()); fileInfo.SetupAllProperties(); fileInfo.Setup(f => f.FullName).Returns(this.path); fileInfo.Setup(f => f.Name).Returns(this.objectName); fileInfo.Setup(f => f.Directory).Returns(parentDir); fileInfo.Setup(f => f.Exists).Returns(true); byte[] content = Encoding.UTF8.GetBytes("content"); fileInfo.SetupStream(content); byte[] expectedHash = SHA1Managed.Create().ComputeHash(content); Mock <IDocument> remoteObject = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, this.id, this.objectName, this.parentId, content.Length, content, this.lastChangeToken); remoteObject.SetupContentStreamHash(expectedHash); remoteObject.Setup(f => f.LastModificationDate).Returns((DateTime?)this.creationDate); this.underTest.Solve(fileInfo.Object, remoteObject.Object); fileInfo.VerifySet(f => f.Uuid = It.Is <Guid?>(uuid => uuid != null && !uuid.Equals(Guid.Empty)), Times.Once()); this.storage.VerifySavedMappedObject(MappedObjectType.File, this.id, this.objectName, this.parentId, this.lastChangeToken, true, this.creationDate, this.creationDate, expectedHash, content.Length); }
public ApplicationInitializeCommandHandlerTests() { _fakeLogger = new Mock <ILogger <ApplicationInitializeCommandHandler> >(); // Init stores _applicationStore = new Mock <IApplicationState>(); _browserState = new Mock <IBrowserState>(); _applicationStore.SetupAllProperties(); _browserState.SetupAllProperties(); // Init services _persistAndRestoreService = new Mock <IPersistAndRestoreService>(); _browserService = new Mock <IBrowserService>(); // Init handler //_handler = new ApplicationInitializeCommandHandler( // _fakeLogger.Object, // _applicationStore.Object, // _browserState.Object, // _persistAndRestoreService.Object, // _browserService.Object); }
public void Generate_The_Correct_Prefix_For_Switches() { // arrange var mock = new Mock <IInlineSequence>(); mock.SetupAllProperties(); var builder = DefaultBuilder.CreateDefaultBuilder(); var parameter = new ValuesSwitch(builder.Context.ParserRepository.Get("util"), 'v', "value", (o, strings) => { }, 1, 3); parameter.Help.ValueAlias = "val"; var vm = new ParameterViewModel(parameter, Theme.Default); var usage = new ParameterUsage { ViewModel = vm }; // act usage.GenerateSequence(mock.Object); // assert usage.GeneratedText.Should().Be("[-v, --value val1..val3]"); }
private void SetUpMocks() { var mockRepo = new Mock <IPatientService>(); IList <PatientModel> patientDetails = new List <PatientModel>() { new PatientModel { Name = "Venkat", SurName = "Swami", CityId = 1, DOB = DateTime.Now, Gender = "M" } }; mockRepo .Setup(repo => repo.GetPatientListAsync()) .ReturnsAsync(patientDetails.ToList()); mockRepo.SetupAllProperties(); _patientService = mockRepo.Object; }
public void SendAfterOpenDoesBehavesCorrectlyForConfiguredQueuingBehavior(QueuingBehavior queuingBehavior, int expectedCounter) { var logger = new Mock <ILogger>(); var perfCounters = new Mock <IPerformanceCounterManager>(); var queueLengthCounter = new Mock <IPerformanceCounter>(); var counterIncrementCount = 0; queueLengthCounter.Setup(c => c.Increment()).Callback(() => counterIncrementCount++); perfCounters.DefaultValue = DefaultValue.Mock; perfCounters.SetReturnsDefault(new NoOpPerformanceCounter()); perfCounters.SetupAllProperties(); perfCounters.Setup(pc => pc.ScaleoutSendQueueLength).Returns(queueLengthCounter.Object); var stream = new ScaleoutStream(logger.Object, "0", queuingBehavior, 1000, perfCounters.Object); stream.Send(_ => TaskAsyncHelper.Empty, null); stream.Open(); stream.Send(_ => TaskAsyncHelper.Empty, null).Wait(); Assert.Equal(expectedCounter, counterIncrementCount); }
public void Generate_The_Correct_Output_For_A_Separated_Switch_With_No_Word() { // arrange var mock = new Mock <IInlineSequence>(); mock.SetupAllProperties(); var builder = DefaultBuilder.CreateDefaultBuilder(); var parameter = new SeparatedSwitch(builder.Context.ParserRepository.Get("util"), 'v', null, (o, s) => { }); parameter.Help.ValueAlias = "val"; var vm = new ParameterViewModel(parameter, Theme.Default); var usage = new ParameterUsage { ViewModel = vm }; // act usage.GenerateSequence(mock.Object); // assert usage.StringBuilder.ToString().Should().Be("[-v:val]"); }
public async Task CallOnAppearingAsync() { var mokB = new Mock<IWatcher>(); mokB.SetupAllProperties(); var mockA = new Mock<ITimeWatcher>(); mockA.Setup(x => x.StartWatcher(It.IsAny<string>(),It.IsAny<bool>())).Returns(() => mokB.Object); LocalAutoMock = AutoMock.GetLoose(cfg => cfg.RegisterMock(mockA)); SetMockContainer(); var token = new CancellationToken(false); LoadingContext.FromUser = LoadingContext.Create(LoadingContext.FromUser, token, mockA.Object); LoadingContext.OnAppearing = LoadingContext.Create(LoadingContext.OnAppearing, token, mockA.Object); LoadingContext.RefreshVisual = LoadingContext.Create(LoadingContext.RefreshVisual, token, mockA.Object); var obj = (ViewModel)new ViewModelWhithState(); Assert.IsNotNull(obj); Assert.IsFalse(obj.IsVisible); await obj.OnAppearingAsync(); Assert.IsTrue(obj.IsVisible); Assert.IsFalse(obj.IsLoading); mockA.Verify(x => x.StartWatcher(It.IsAny<string>(), It.IsAny<bool>()),Times.Once); }
public void AddHmacHeadersTest() { const string requestedResource = "http://0.0.0.0/stuff?param=4&fun=2"; HttpMethod method = HttpMethod.Post; const string appId = "dfjksdfsdfjlsdfkjldfsej"; const string secretKey = "GVsVLyUq3U2+7bOdkdCTBemtSM8So98G+5EzunOJEcw="; const string content = "a blob of text that constitues content"; const string customNameSpace = "sds"; const string signatureValue = "a signature"; const string customHeaderName = "Authorization"; Mock <HmacSignatureGenerator> signatureGenerator = new Mock <HmacSignatureGenerator>(MockBehavior.Strict, customNameSpace); signatureGenerator.SetupAllProperties(); signatureGenerator.Setup(x => x.GenerateFullHmacSignature(requestedResource, method.ToString(), appId, secretKey, content, It.IsAny <string>(), It.IsAny <DateTime?>())).Returns(signatureValue); HmacHeaderGenerator generator = new HmacHeaderGenerator(customNameSpace, appId, secretKey, signatureGenerator.Object, customHeaderName); using (HttpClient client = new HttpClient()) { generator.AddHmacHeaders(client, new Uri(requestedResource), HttpMethod.Post, content); Assert.Equal(signatureValue, client.DefaultRequestHeaders.GetValues(customHeaderName).Single()); } }
private TestHostContext CreateTestContext([CallerMemberName] String testName = "") { var hc = new TestHostContext(this, testName); var expressionManager = new ExpressionManager(); expressionManager.Initialize(hc); hc.SetSingleton <IExpressionManager>(expressionManager); Dictionary <string, VariableValue> variablesToCopy = new Dictionary <string, VariableValue>(); variablesToCopy.Add(Constants.Variables.Agent.RetainDefaultEncoding, new VariableValue("true", false)); List <string> warnings; _variables = new Variables( hostContext: hc, copy: variablesToCopy, warnings: out warnings); _ec = new Mock <IExecutionContext>(); _ec.SetupAllProperties(); _ec.Setup(x => x.Variables).Returns(_variables); _stepsRunner = new StepsRunner(); _stepsRunner.Initialize(hc); return(hc); }
public void EditUsersPresenter_EditUser_ShouldEditLastName() { var view = new Mock <IEditUserView>(); view.SetupAllProperties(); var usersData = new Mock <IUsersData>(); var user = new AspNetUser() { Id = 1 }; usersData.Setup(u => u.UsersRepository.GetUserById(It.IsAny <int>())).Returns(user); var presenter = new EditUserPresenter(view.Object, usersData.Object); view.Raise(v => v.GetUser += null, view.Object, new GetUserByIdEventArgs(1)); var editedUserEventArgs = new EditUserEventArgs(1); editedUserEventArgs.LastName = "Ivanov"; view.Raise(v => v.UserEdit += null, view.Object, editedUserEventArgs); usersData.Verify(x => x.UsersRepository.UpdateUser(It.Is <AspNetUser>(u => u.LastName == "Ivanov"))); }
public async Task When_occur_error_on_Save_in_EventStore_Then_rollback_should_be_called() { var eventStoreMock = new Mock <IEventStore>(); eventStoreMock.SetupAllProperties(); eventStoreMock.Setup(e => e.SaveAsync(It.IsAny <IEnumerable <ISerializedEvent> >())) .Callback(DoThrowExcetion) .Returns(Task.CompletedTask); var session = _sessionFactory(eventStoreMock.Object, _eventPublisherMock.Object); session.Add(StubAggregate.Create("Test")); try { await session.CommitAsync(); } catch (Exception) { eventStoreMock.Verify(e => e.Rollback(), Times.Once); _eventPublisherMock.Verify(e => e.Rollback(), Times.Once); } }
public void ThreadEditPresenter_EditThreadShouldThrowIfDbSectionsFail() { var view = new Mock <IThreadEditView>(); view.SetupAllProperties(); var forumData = new Mock <IForumData>(); var threadsRepository = new Mock <IThreadsRepository>(); var thread = new Thread() { Id = 1, IsVisible = true }; forumData.Setup(f => f.ThreadsRepository).Returns(threadsRepository.Object); forumData.Setup(f => f.ThreadsRepository.GetThreadById(It.IsAny <int>())).Returns(thread); forumData.Setup(f => f.SectionsRepository).Throws(new Exception()); var presenter = new ThreadEditPresenter(view.Object, forumData.Object); var testContent = "TestContent Should be at least 50 characters long!!"; Assert.Throws <HttpException>(() => view.Raise(v => v.EditThread += null, new ThreadEditEventArgs("TestTitle", testContent, "TestSection", 1))); }