test: Additional tests for the extension methods. (#59)

Author: adrianhall

src/CommunityToolkit.Datasync.Client/CommunityToolkit.Datasync.Client.csproj

@@ -5,6 +5,7 @@
 
   <ItemGroup>
     <InternalsVisibleTo Include="CommunityToolkit.Datasync.Client.Test" />
+    <InternalsVisibleTo Include="DynamicProxyGenAssembly2"/>
   </ItemGroup>
 
   <ItemGroup>

src/CommunityToolkit.Datasync.Client/Exceptions/EntityDoesNotExistException.cs

@@ -20,10 +20,10 @@ public class EntityDoesNotExistException(ServiceResponse serviceResponse, Uri en
     /// <summary>
     /// The endpoint of the table that was used for the entity.
     /// </summary>
-    public Uri Endpoint { get; set; } = endpoint;
+    public Uri Endpoint { get; } = endpoint;
 
     /// <summary>
     /// The ID of the entity that is missing.
     /// </summary>
-    public string Id { get; set; } = id;
+    public string Id { get; } = id;
 }

src/CommunityToolkit.Datasync.Client/Paging/ConcurrentObservableCollection.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using CommunityToolkit.Datasync.Client.Paging;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.ComponentModel;
@@ -151,34 +152,38 @@ public bool ReplaceIf(Func<T, bool> match, T replacement)
     /// </summary>
     /// <param name="e">The event arguments</param>
     protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
-    {
-        if (SynchronizationContext.Current == this.context)
-        {
-            RaiseCollectionChanged(e);
-        }
-        else
-        {
-            this.context.Send(RaiseCollectionChanged, e);
-        }
-    }
+        => DispatchCallback(new SynchronizationContextAdapter(this.context), RaiseCollectionChanged, e);
 
     /// <summary>
     /// Event trigger to indicate that a property has changed in a thread-safe way.
     /// </summary>
     /// <param name="e">The event arguments</param>
     protected override void OnPropertyChanged(PropertyChangedEventArgs e)
+        => DispatchCallback(new SynchronizationContextAdapter(this.context), RaisePropertyChanged, e);
+
+    /// <summary>
+    /// Dispatches the callback to the synchronization context.  If the synchronization context is
+    /// the current one, we can avoid a dispatch and just call the callback directly.
+    /// </summary>
+    /// <param name="context">The context to send the request to.</param>
+    /// <param name="callback">The callback method.</param>
+    /// <param name="param">The parameter for the callback method.</param>
+    internal static void DispatchCallback(ISynchronizationContext context, SendOrPostCallback callback, object? param)
     {
-        if (SynchronizationContext.Current == this.context)
+        if (context.IsCurrentContext())
         {
-            RaisePropertyChanged(e);
+            callback(param);
         }
         else
         {
-            this.context.Send(RaisePropertyChanged, e);
+            context.Send(callback, param);
         }
     }
 
-    [ExcludeFromCodeCoverage]
+    /// <summary>
+    /// Raises the <see cref="OnCollectionChanged(NotifyCollectionChangedEventArgs)"/> event on this collection.
+    /// </summary>
+    /// <param name="param"></param>
     private void RaiseCollectionChanged(object? param)
     {
         if (!this.suppressNotification)
@@ -187,7 +192,10 @@ private void RaiseCollectionChanged(object? param)
         }
     }
 
-    [ExcludeFromCodeCoverage]
+    /// <summary>
+    /// Raises the <see cref="OnPropertyChanged(PropertyChangedEventArgs)"/> event on this collection.
+    /// </summary>
+    /// <param name="param"></param>
     private void RaisePropertyChanged(object? param)
     {
         base.OnPropertyChanged((PropertyChangedEventArgs)param!);

src/CommunityToolkit.Datasync.Client/Paging/SynchronizationContextAdapter.cs

@@ -0,0 +1,31 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace CommunityToolkit.Datasync.Client.Paging;
+
+/// <summary>
+/// An abstraction layer for the <see cref="SynchronizationContext"/> that we use
+/// for mocking out context calls.
+/// </summary>
+internal interface ISynchronizationContext
+{
+    bool IsCurrentContext();
+    void Send(SendOrPostCallback callback, object? state);
+}
+
+/// <summary>
+/// A concrete implementation of the <see cref="ISynchronizationContext"/> that handles 
+/// a real synchronization context.
+/// </summary>
+[ExcludeFromCodeCoverage]
+internal class SynchronizationContextAdapter(SynchronizationContext context) : ISynchronizationContext
+{
+    public bool IsCurrentContext()
+        => SynchronizationContext.Current == context;
+
+    public void Send(SendOrPostCallback callback, object? state)
+        => context.Send(callback, state);
+}

src/CommunityToolkit.Datasync.Client/Query/IAsyncEnumerableExtensions.cs

@@ -72,40 +72,6 @@ internal static async ValueTask<Dictionary<TKey, TSource>> ToDatasyncDictionaryA
         return d;
     }
 
-    /// <summary>
-    /// Converts an async-enumerable sequence to an enumerable sequence.
-    /// </summary>
-    /// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
-    /// <param name="source">An async-enumerable sequence to convert to an enumerable sequence.</param>
-    /// <returns>The enumerable sequence containing the elements in the async-enumerable sequence.</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
-    internal static IEnumerable<TSource> ToDatasyncEnumerable<TSource>(this IAsyncEnumerable<TSource> source)
-    {
-        ArgumentNullException.ThrowIfNull(source, nameof(source));
-        return Core(source);
-
-        static IEnumerable<TSource> Core(IAsyncEnumerable<TSource> source)
-        {
-            IAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(default);
-            try
-            {
-                while (true)
-                {
-                    if (!DatasyncWait(e.MoveNextAsync()))
-                    {
-                        break;
-                    }
-
-                    yield return e.Current;
-                }
-            }
-            finally
-            {
-                DatasyncWait(e.DisposeAsync());
-            }
-        }
-    }
-
     /// <summary>
     /// Creates a hash set from an async-enumerable sequence.
     /// </summary>
@@ -187,32 +153,5 @@ internal static async ValueTask<ConcurrentObservableCollection<TSource>> ToDatas
         existingCollection.ReplaceAll(list);
         return existingCollection;
     }
-
-    // NB: ValueTask and ValueTask<T> do not have to support blocking on a call to GetResult when backed by
-    //     an IValueTaskSource or IValueTaskSource<T> implementation. Convert to a Task or Task<T> to do so
-    //     in case the task hasn't completed yet.
-
-    private static void DatasyncWait(ValueTask task)
-    {
-        ValueTaskAwaiter awaiter = task.GetAwaiter();
-        if (!awaiter.IsCompleted)
-        {
-            task.AsTask().GetAwaiter().GetResult();
-            return;
-        }
-
-        awaiter.GetResult();
-    }
-
-    private static T DatasyncWait<T>(ValueTask<T> task)
-    {
-        ValueTaskAwaiter<T> awaiter = task.GetAwaiter();
-        if (!awaiter.IsCompleted)
-        {
-            return task.AsTask().GetAwaiter().GetResult();
-        }
-
-        return awaiter.GetResult();
-    }
 }
 

src/CommunityToolkit.Datasync.Client/Query/IDatasyncQueryableExtensions.cs

@@ -18,7 +18,6 @@ public static class IDatasyncQueryableExtensions
     /// <returns>A task that represents the asynchronous operation. The task result contains the number of elements that would be returned by the query.</returns>
     public static async ValueTask<int> CountAsync<TSource>(this IDatasyncQueryable<TSource> query, CancellationToken cancellationToken = default) where TSource : class
     {
-        ArgumentNullException.ThrowIfNull(query, nameof(query));
         ServiceResponse<int> response = await query.ServiceClient.CountAsync(query, new DatasyncServiceOptions(), cancellationToken).ConfigureAwait(false);
         return response.Value;
     }
@@ -32,7 +31,6 @@ public static async ValueTask<int> CountAsync<TSource>(this IDatasyncQueryable<T
     /// <returns>A task that represents the asynchronous operation. The task result contains the number of elements that would be returned by the query.</returns>
     public static async ValueTask<long> LongCountAsync<TSource>(this IDatasyncQueryable<TSource> query, CancellationToken cancellationToken = default) where TSource : class
     {
-        ArgumentNullException.ThrowIfNull(query, nameof(query));
         ServiceResponse<long> response = await query.ServiceClient.LongCountAsync(query, new DatasyncServiceOptions(), cancellationToken ).ConfigureAwait(false);
         return response.Value;
     }
@@ -54,10 +52,7 @@ public static ValueTask<TSource[]> ToArrayAsync<TSource>(this IDatasyncQueryable
     /// <param name="query">The query to execute on the remote service..</param>
     /// <returns>The async-enumerable sequence whose elements are pulled from the result set.</returns>
     public static IAsyncEnumerable<TSource> ToAsyncEnumerable<TSource>(this IDatasyncQueryable<TSource> query) where TSource : class
-    {
-        ArgumentNullException.ThrowIfNull(query, nameof(query));
-        return query.ServiceClient.Query(query);
-    }
+        => query.ServiceClient.Query(query);
 
     /// <summary>
     /// Executes a query on the remote service, returning the results as an async-enumerable sequence.
@@ -136,7 +131,7 @@ public static ValueTask<List<TSource>> ToListAsync<TSource>(this IDatasyncQuerya
     /// <param name="query">The source table query.</param>
     /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
     /// <returns>A <see cref="ConcurrentObservableCollection{T}"/> containing all the elements of the source sequence.</returns>
-    public static ValueTask<ConcurrentObservableCollection<TSource>> ToObservableCollection<TSource>(this IDatasyncQueryable<TSource> query, CancellationToken cancellationToken = default) where TSource : class
+    public static ValueTask<ConcurrentObservableCollection<TSource>> ToObservableCollectionAsync<TSource>(this IDatasyncQueryable<TSource> query, CancellationToken cancellationToken = default) where TSource : class
         => query.ToAsyncEnumerable().ToDatasyncObservableCollectionAsync(cancellationToken);
 
     /// <summary>
@@ -147,6 +142,6 @@ public static ValueTask<ConcurrentObservableCollection<TSource>> ToObservableCol
     /// <param name="collection">The <see cref="ConcurrentObservableCollection{T}"/> to update.</param>
     /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
     /// <returns>The <see cref="ConcurrentObservableCollection{T}"/> passed in containing all the elements of the source sequence (replacing the old content).</returns>
-    public static ValueTask<ConcurrentObservableCollection<TSource>> ToObservableCollection<TSource>(this IDatasyncQueryable<TSource> query, ConcurrentObservableCollection<TSource> collection, CancellationToken cancellationToken = default) where TSource : class
+    public static ValueTask<ConcurrentObservableCollection<TSource>> ToObservableCollectionAsync<TSource>(this IDatasyncQueryable<TSource> query, ConcurrentObservableCollection<TSource> collection, CancellationToken cancellationToken = default) where TSource : class
         => query.ToAsyncEnumerable().ToDatasyncObservableCollectionAsync(collection, cancellationToken);
 }

src/CommunityToolkit.Datasync.Client/Service/IDatasyncServiceClientExtensions.cs

@@ -154,7 +154,7 @@ public static ValueTask<List<TSource>> ToListAsync<TSource>(this IReadOnlyDatasy
     /// <param name="source">The source service client.</param>
     /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
     /// <returns>A <see cref="ConcurrentObservableCollection{T}"/> containing all the elements of the source sequence.</returns>
-    public static ValueTask<ConcurrentObservableCollection<TSource>> ToObservableCollection<TSource>(this IReadOnlyDatasyncServiceClient<TSource> source, CancellationToken cancellationToken = default) where TSource : class
+    public static ValueTask<ConcurrentObservableCollection<TSource>> ToObservableCollectionAsync<TSource>(this IReadOnlyDatasyncServiceClient<TSource> source, CancellationToken cancellationToken = default) where TSource : class
         => source.ToAsyncEnumerable().ToDatasyncObservableCollectionAsync(cancellationToken);
 
     /// <summary>
@@ -165,7 +165,7 @@ public static ValueTask<ConcurrentObservableCollection<TSource>> ToObservableCol
     /// <param name="collection">The <see cref="ConcurrentObservableCollection{T}"/> to update.</param>
     /// <param name="cancellationToken">The optional cancellation token to be used for cancelling the sequence at any time.</param>
     /// <returns>The <see cref="ConcurrentObservableCollection{T}"/> passed in containing all the elements of the source sequence (replacing the old content).</returns>
-    public static ValueTask<ConcurrentObservableCollection<TSource>> ToObservableCollection<TSource>(this IReadOnlyDatasyncServiceClient<TSource> source, ConcurrentObservableCollection<TSource> collection, CancellationToken cancellationToken = default) where TSource : class
+    public static ValueTask<ConcurrentObservableCollection<TSource>> ToObservableCollectionAsync<TSource>(this IReadOnlyDatasyncServiceClient<TSource> source, ConcurrentObservableCollection<TSource> collection, CancellationToken cancellationToken = default) where TSource : class
         => source.ToAsyncEnumerable().ToDatasyncObservableCollectionAsync(collection, cancellationToken);
 
     /// <summary>

tests/CommunityToolkit.Datasync.Client.Test/Paging/ConcurrentObservableCollection_Tests.cs

@@ -2,8 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using CommunityToolkit.Datasync.TestCommon.Databases;
+#pragma warning disable IDE0028 // Simplify collection initialization
+#pragma warning disable IDE0305 // Simplify collection initialization
 
+using CommunityToolkit.Datasync.Client.Paging;
+using CommunityToolkit.Datasync.TestCommon.Databases;
+using NSubstitute;
 using TestData = CommunityToolkit.Datasync.TestCommon.TestData;
 
 namespace CommunityToolkit.Datasync.Client.Test.Paging;
@@ -21,6 +25,13 @@ public ConcurrentObservableCollection_Tests()
         this.movies.CollectionChanged += (sender, e) => this.collectionChangedCallCount++;
     }
 
+    [Fact]
+    public void DefaultCtor_Creates_EmptyCollection()
+    {
+        ConcurrentObservableCollection<InMemoryMovie> sut = new();
+        sut.Should().BeEmpty();
+    }
+
     [Fact]
     public void ReplaceAll_Null_Throws()
     {
@@ -169,4 +180,40 @@ public void ReplaceIf_False_IfNoMatch()
         actual.Should().BeFalse();
         this.movies.Should().HaveCount(count).And.NotContain(item);
     }
+
+    [Fact]
+    public void DispatchCallback_DispatchesToSynchronizationContext()
+    {
+        int contextCaller = 0;
+        int functionCaller = 0;
+
+        void dispatcher(object p) { functionCaller++; }
+
+        ISynchronizationContext context = Substitute.For<ISynchronizationContext>();
+        context.IsCurrentContext().Returns(false);
+        context.When(x => x.Send(Arg.Any<SendOrPostCallback>(), Arg.Any<object>())).Do(x => contextCaller++);
+
+        ConcurrentObservableCollection<InMemoryMovie>.DispatchCallback(context, dispatcher, new object());
+
+        contextCaller.Should().Be(1);
+        functionCaller.Should().Be(0);
+    }
+
+    [Fact]
+    public void DispatchCallback_DispatchesLocally()
+    {
+        int contextCaller = 0;
+        int functionCaller = 0;
+
+        void dispatcher(object p) { functionCaller++; }
+
+        ISynchronizationContext context = Substitute.For<ISynchronizationContext>();
+        context.IsCurrentContext().Returns(true);
+        context.When(x => x.Send(Arg.Any<SendOrPostCallback>(), Arg.Any<object>())).Do(x => contextCaller++);
+
+        ConcurrentObservableCollection<InMemoryMovie>.DispatchCallback(context, dispatcher, new object());
+
+        contextCaller.Should().Be(0);
+        functionCaller.Should().Be(1);
+    }
 }