Exemple #1
0
        public async Task ViewModel_is_intercepted_as_expected()
        {
            // Arrange
            var previewHandler = new TestPreviewHandler();
            var client         = new SelfContainedWebApplicationFactoryWithWebHost <Get_with_2_handlers>
                                 (
                configureServices: services =>
            {
                services.AddSingleton <IViewModelPreviewHandler>(previewHandler);
                services.AddViewModelComposition(options =>
                {
                    options.AssemblyScanner.Disable();
                    options.RegisterCompositionHandler <TestGetHandler>();
                });
                services.AddRouting();
            },
                configure: app =>
            {
                app.UseRouting();
                app.UseEndpoints(builder => builder.MapCompositionHandlers());
            }
                                 ).CreateClient();

            // Act
            var response = await client.GetAsync("/sample/1");

            // Assert
            Assert.True(response.IsSuccessStatusCode);
            Assert.True(previewHandler.Invoked);
        }
        public void PreviewHandlerBase_ShouldCallPreviewControlSetrect_WhenSetRectCalled()
        {
            // Arrange
            var mockPreviewControl = new Mock <IPreviewHandlerControl>();
            var bounds             = GetRectangle(2, 2, 4, 4);

            var actualBounds = Rectangle.Empty;

            mockPreviewControl
            .Setup(_ => _.SetRect(It.IsAny <Rectangle>()))
            .Callback <Rectangle>((rect) =>
            {
                actualBounds = rect;
            });

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();

            // Act
            testPreviewHandler.SetRect(ref bounds);

            // Assert
            Assert.AreEqual(actualBounds, bounds.ToRectangle());
            mockPreviewControl.Verify(_ => _.SetRect(It.IsAny <Rectangle>()), Times.Once);
        }
        public void PreviewHandlerBase_ShouldThrowOnQueryFocus_WhenPreviewControlsReturnNotValidHandle()
        {
            // Arrange
            var hwnd = IntPtr.Zero;
            var mockPreviewControl = new Mock <IPreviewHandlerControl>();

            mockPreviewControl.Setup(x => x.QueryFocus(out hwnd));
            var actualHwnd = IntPtr.Zero;

            previewHandlerControl = mockPreviewControl.Object;
            var            testPreviewHandler = new TestPreviewHandler();
            Win32Exception exception          = null;

            // Act
            try
            {
                testPreviewHandler.QueryFocus(out actualHwnd);
            }
            catch (Win32Exception ex)
            {
                exception = ex;
            }

            // Assert
            Assert.IsNotNull(exception);
            mockPreviewControl.Verify(_ => _.QueryFocus(out hwnd), Times.Once);
        }
        public void PreviewHandlerBase_ShouldCallPreviewControlSetWindow_WhenSetWindowCalled()
        {
            // Arrange
            var mockPreviewControl = new Mock <IPreviewHandlerControl>();
            var handle             = new IntPtr(5);
            var bounds             = GetRectangle(2, 2, 4, 4);

            var actualHandle = IntPtr.Zero;
            var actualBounds = Rectangle.Empty;

            mockPreviewControl
            .Setup(_ => _.SetWindow(It.IsAny <IntPtr>(), It.IsAny <Rectangle>()))
            .Callback <IntPtr, Rectangle>((hwnd, rect) =>
            {
                actualHandle = hwnd;
                actualBounds = rect;
            });

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();

            // Act
            testPreviewHandler.SetWindow(handle, ref bounds);

            // Assert
            Assert.AreEqual(actualHandle, handle);
            Assert.AreEqual(actualBounds, bounds.ToRectangle());
            mockPreviewControl.Verify(_ => _.SetWindow(It.IsAny <IntPtr>(), It.IsAny <Rectangle>()), Times.Once);
        }
        public void PreviewHandlerBase_ShouldCallPreviewControlUnload_WhenUnloadCalled()
        {
            // Arrange
            var mockPreviewControl = new Mock <IPreviewHandlerControl>();

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();

            // Act
            testPreviewHandler.Unload();

            // Assert
            mockPreviewControl.Verify(_ => _.Unload(), Times.Once);
        }
Exemple #6
0
        public void PreviewHandlerBaseShouldCallPreviewControlSetFocusWhenSetFocusCalled()
        {
            // Arrange
            var mockPreviewControl = new Mock <IPreviewHandlerControl>();

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();

            // Act
            testPreviewHandler.SetFocus();

            // Assert
            mockPreviewControl.Verify(_ => _.SetFocus(), Times.Once);
        }
        public void PreviewHandlerBase_ShouldCallPreviewControlSetTextColor_WhenSetTextColorCalled()
        {
            // Arrange
            var mockPreviewControl = new Mock <IPreviewHandlerControl>();

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();
            var color = new COLORREF();

            // Act
            testPreviewHandler.SetTextColor(color);

            // Assert
            mockPreviewControl.Verify(_ => _.SetTextColor(It.Is <Color>(c => (c == color.Color))), Times.Once);
        }
        public void PreviewHandlerBase_ShouldReturnS_FALSE_IfIPreviewHandlerFrameIsNotSet()
        {
            // Arrange
            var  mockPreviewControl = new Mock <IPreviewHandlerControl>();
            var  msg     = new MSG();
            uint S_FALSE = 1;

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();

            // Act
            var result = testPreviewHandler.TranslateAccelerator(ref msg);

            // Assert
            Assert.AreEqual(result, S_FALSE);
        }
Exemple #9
0
        public void PreviewHandlerBaseShouldReturnUintFalseIfIPreviewHandlerFrameIsNotSet()
        {
            // Arrange
            var  mockPreviewControl = new Mock <IPreviewHandlerControl>();
            var  msg    = default(MSG);
            uint sFalse = 1;

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();

            // Act
            var result = testPreviewHandler.TranslateAccelerator(ref msg);

            // Assert
            Assert.AreEqual(result, sFalse);
        }
        public void PreviewHandlerBase_ShouldDirectKeyStrokesToIPreviewHandlerFrame_IfIPreviewHandlerFrameIsSet()
        {
            // Arrange
            var mockPreviewControl      = new Mock <IPreviewHandlerControl>();
            var mockPreviewHandlerFrame = new Mock <IPreviewHandlerFrame>();
            var msg = new MSG();

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();

            testPreviewHandler.SetSite(mockPreviewHandlerFrame.Object);

            // Act
            testPreviewHandler.TranslateAccelerator(ref msg);

            // Assert
            mockPreviewHandlerFrame.Verify(_ => _.TranslateAccelerator(ref msg), Times.Once);
        }
Exemple #11
0
        public void PreviewHandlerBaseShouldReturnSiteWhenGetSiteCalled()
        {
            // Arrange
            var mockPreviewControl = new Mock <IPreviewHandlerControl>();

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();
            var site = new Mock <IPreviewHandlerFrame>().Object;

            testPreviewHandler.SetSite(site);
            var riid = Guid.Empty;

            // Act
            testPreviewHandler.GetSite(ref riid, out object actualSite);

            // Assert
            Assert.AreEqual(actualSite, site);
        }
        public void PreviewHandlerBase_ShouldReturnPreviewControlHandle_IfGetWindowCalled()
        {
            // Arrange
            var previewControlHandle = new IntPtr(5);
            var mockPreviewControl   = new Mock <IPreviewHandlerControl>();

            mockPreviewControl.Setup(x => x.GetHandle())
            .Returns(previewControlHandle);

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();
            var hwndReceived       = IntPtr.Zero;

            // Act
            testPreviewHandler.GetWindow(out hwndReceived);

            // Assert
            Assert.AreEqual(hwndReceived, previewControlHandle);
        }
        public void PreviewHandlerBase_ShouldSetHandleOnQueryFocus_WhenPreviewControlsReturnValidHandle()
        {
            // Arrange
            var hwnd = new IntPtr(5);
            var mockPreviewControl = new Mock <IPreviewHandlerControl>();

            mockPreviewControl.Setup(x => x.QueryFocus(out hwnd));
            var actualHwnd = IntPtr.Zero;

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();

            // Act
            testPreviewHandler.QueryFocus(out actualHwnd);

            // Assert
            Assert.AreEqual(actualHwnd, hwnd);
            mockPreviewControl.Verify(_ => _.QueryFocus(out hwnd), Times.Once);
        }
        public void PreviewHandlerBase_ShouldThrowNotImplementedException_IfContextSensitiveHelpCalled(bool fEnterMode)
        {
            // Arrange
            var mockPreviewControl = new Mock <IPreviewHandlerControl>();

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler            = new TestPreviewHandler();
            NotImplementedException exception = null;

            // Act
            try
            {
                testPreviewHandler.ContextSensitiveHelp(fEnterMode);
            }
            catch (NotImplementedException ex)
            {
                exception = ex;
            }

            // Assert
            Assert.IsNotNull(exception);
        }
        public void PreviewHandlerBase_ShouldReturnIPreviewHandlerFrameResponse_IfIPreviewHandlerFrameIsSet(uint resultCode)
        {
            // Arrange
            var mockPreviewControl      = new Mock <IPreviewHandlerControl>();
            var mockPreviewHandlerFrame = new Mock <IPreviewHandlerFrame>();
            var msg = new MSG();

            mockPreviewHandlerFrame
            .Setup(x => x.TranslateAccelerator(ref msg))
            .Returns(resultCode);

            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();

            testPreviewHandler.SetSite(mockPreviewHandlerFrame.Object);

            // Act
            var actualResultCode = testPreviewHandler.TranslateAccelerator(ref msg);

            // Assert
            Assert.AreEqual(resultCode, actualResultCode);
        }
        public void PreviewHandlerBase_ShouldCallPreviewControlSetFont_WhenSetFontCalled()
        {
            // Arrange
            Font actualFont         = null;
            var  mockPreviewControl = new Mock <IPreviewHandlerControl>();

            mockPreviewControl
            .Setup(x => x.SetFont(It.IsAny <Font>()))
            .Callback <Font>((font) =>
            {
                actualFont = font;
            });
            previewHandlerControl = mockPreviewControl.Object;
            var testPreviewHandler = new TestPreviewHandler();
            var logFont            = GetLogFont();

            // Act
            testPreviewHandler.SetFont(ref logFont);

            // Assert
            mockPreviewControl.Verify(_ => _.SetFont(It.IsAny <Font>()), Times.Once);
            Assert.AreEqual(Font.FromLogFont(logFont), actualFont);
        }