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());
        }
Пример #5
0
        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());
        }
Пример #12
0
        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());
        }
Пример #14
0
 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);
 }
Пример #15
0
        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));
        }
Пример #16
0
			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;
			}
Пример #17
0
        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();
        }
Пример #19
0
        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);
        }
Пример #27
0
        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]);
        }
Пример #28
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;
        }
Пример #29
0
        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;
        }
Пример #30
0
        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);
        }
Пример #31
0
        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)));
        }
Пример #32
0
        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);
        }
Пример #34
0
        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());
        }
Пример #35
0
        /// <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));
        }
Пример #36
0
        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);
        }
Пример #39
0
        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));
            }
        }
Пример #40
0
        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);
            }
        }
Пример #41
0
        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);
        }
Пример #42
0
        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);
            });
        }
Пример #43
0
        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);
        }
Пример #44
0
        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);
        }
Пример #45
0
        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);
        }
Пример #46
0
        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));
        }
Пример #47
0
        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);
        }
Пример #50
0
        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);
        }
Пример #51
0
        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);
        }
Пример #54
0
        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);
        }
Пример #56
0
        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());
            }
        }
Пример #57
0
        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")));
        }
Пример #59
0
        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)));
        }