public async Task CreateAnObserverAndNotifyJSInterop()
        {
            var mockJsRuntime = new Mock <IJSRuntime>();

            var testOptions = new IntersectionObserverOptions {
                RootMargin = "10px 10px 10px 10px",
                Threshold  = new List <double> {
                    0.25, 0.5, 1
                }
            };

            var observerService = new IntersectionObserverService(mockJsRuntime.Object);
            var observer        = await observerService.Create(
                It.IsAny <Action <IList <IntersectionObserverEntry> > >(),
                testOptions
                );

            mockJsRuntime
            .Verify(v => v.InvokeAsync <object>(
                        Constants.CREATE,
                        It.IsAny <DotNetObjectRef>(),
                        It.IsAny <string>(),
                        testOptions
                        ), Times.Once());
        }
Beispiel #2
0
        public async Task ObserveAnElementAndNotifyJSInterop()
        {
            var mockJsRuntime = new Mock <IJSRuntime>();
            var testOptions   = new IntersectionObserverOptions
            {
                RootMargin = "10px 10px 10px 10px",
                Threshold  = new List <double> {
                    0.25, 0.5, 1
                }
            };
            var testElementRef = new ElementRef();

            var observerService = new IntersectionObserverService(mockJsRuntime.Object);
            var observer        = await observerService.Observe(
                testElementRef,
                It.IsAny <Action <IList <IntersectionObserverEntry> > >(),
                testOptions
                );

            var observerId = observer.Id;

            mockJsRuntime
            .Verify(v => v.InvokeAsync <object>(
                        Constants.OBSERVE,
                        It.IsAny <DotNetObjectRef>(),
                        observerId,
                        testElementRef,
                        testOptions
                        ), Times.Once());
        }
Beispiel #3
0
        public async Task FromJSInteropTriggerObserverCallback()
        {
            var mockJsRuntime   = new Mock <IJSRuntime>();
            var mockOnIntersect = new Mock <Action <IList <IntersectionObserverEntry> > >();
            var testEntries     = new List <IntersectionObserverEntry> {
                new IntersectionObserverEntry {
                    IsVisible = true
                },
                new IntersectionObserverEntry {
                    IsIntersecting     = true,
                    IsVisible          = true,
                    IntersectionRatio  = 1.0,
                    BoundingClientRect = new DOMRectReadOnly(),
                    RootBounds         = new DOMRectReadOnly(),
                    //Target = new ElementReference()
                }
            };

            var mockOptions = new IntersectionObserverOptions();

            var observerService = new IntersectionObserverService(mockJsRuntime.Object);

            var observer = await observerService.Observe(
                It.IsAny <ElementReference>(),
                mockOnIntersect.Object,
                mockOptions
                );

            observerService.OnCallback(observer.Id, testEntries);

            mockOnIntersect
            .Verify(v => v.Invoke(testEntries), Times.Once());
        }
Beispiel #4
0
        public async Task DisconnectAnObserverCallbackAndNotifyJSInterop()
        {
            var mockJsRuntime = new Mock <IJSRuntime>();

            mockJsRuntime
            .Setup(x => x.InvokeAsync <bool>(
                       Constants.DISCONNECT,
                       It.IsAny <string>()
                       ))
            .ReturnsAsync(true);

            var mockOptions = new IntersectionObserverOptions();

            var observerService = new IntersectionObserverService(mockJsRuntime.Object);
            var observer        = await observerService.Observe(
                It.IsAny <ElementReference>(),
                It.IsAny <Action <IList <IntersectionObserverEntry> > >(),
                mockOptions
                );

            var observerId = observer.Id;

            observer.Disconnect();

            mockJsRuntime
            .Verify(v => v.InvokeAsync <bool>(
                        Constants.DISCONNECT,
                        observerId
                        ), Times.Once());
        }
Beispiel #5
0
        public async Task UnobserveAnElementAndNotifyJSInterop()
        {
            var mockJsRuntime = new Mock <IJSRuntime>();

            mockJsRuntime
            .Setup(x => x.InvokeAsync <bool>(
                       Constants.UNOBSERVE,
                       It.IsAny <string>(),
                       It.IsAny <ElementReference>()
                       ))
            .ReturnsAsync(true);

            var mockOptions = new IntersectionObserverOptions
            {
                RootMargin = "10px 10px 10px 10px",
                Threshold  = new List <double> {
                    0.25, 0.5, 1
                }
            };
            var testElementRef = new ElementReference();

            var observerService = new IntersectionObserverService(mockJsRuntime.Object);
            var observer        = await observerService.Observe(
                testElementRef,
                It.IsAny <Action <IList <IntersectionObserverEntry> > >(),
                mockOptions
                );

            var observerId = observer.Id;

            observer.Unobserve(It.IsAny <ElementReference>());

            mockJsRuntime
            .Verify(v => v.InvokeAsync <bool>(
                        Constants.UNOBSERVE,
                        observerId,
                        testElementRef
                        ), Times.Once());
        }
        public async Task CreateMultipleObserversAndNotifyJSInterop()
        {
            var mockJsRuntime = new Mock <IJSRuntime>();
            var testOptions   = new List <IntersectionObserverOptions>
            {
                new IntersectionObserverOptions {
                    Threshold = new List <double> {
                        0.25
                    }
                },
                new IntersectionObserverOptions {
                    Threshold = new List <double> {
                        0.1
                    }
                }
            };

            var observerService = new IntersectionObserverService(mockJsRuntime.Object);

            var createTasks = testOptions.Select(option =>
            {
                return(observerService.Create(
                           It.IsAny <Action <IList <IntersectionObserverEntry> > >(),
                           option
                           ));
            });

            await Task.WhenAll(createTasks);

            mockJsRuntime
            .Verify(v => v.InvokeAsync <object>(
                        Constants.CREATE,
                        It.IsAny <DotNetObjectRef>(),
                        It.IsAny <string>(),
                        It.IsAny <IntersectionObserverOptions>()
                        ), Times.Exactly(2));
        }
        public async Task CreateAnObserverAndObserveMultipleElements()
        {
            var mockJsRuntime = new Mock <IJSRuntime>();

            var testOptions = new IntersectionObserverOptions
            {
                RootMargin = "10px 10px 10px 10px"
            };
            var testElement      = new ElementRef();
            var otherTestElement = new ElementRef();

            var observerService = new IntersectionObserverService(mockJsRuntime.Object);
            var observer        = await observerService.Create(
                It.IsAny <Action <IList <IntersectionObserverEntry> > >(),
                testOptions
                );

            var observerId = observer.Id;

            observer.Observe(testElement);
            observer.Observe(otherTestElement);

            mockJsRuntime
            .Verify(v => v.InvokeAsync <object>(
                        Constants.CREATE,
                        It.IsAny <DotNetObjectRef>(),
                        It.IsAny <string>(),
                        testOptions
                        ), Times.Once());

            mockJsRuntime
            .Verify(v => v.InvokeAsync <object>(
                        Constants.OBSERVE_ELEMENT,
                        observerId,
                        testElement
                        ), Times.Exactly(2));
        }