public async Task multiple_updates_should_be_thread_safe_async()
        {
            var count     = 50;
            var dataProxy = new PersonDataProxy();

            dataProxy.Clear();
            Parallel.ForEach(Enumerable.Range(0, count), async(index) =>
            {
                await dataProxy.InsertAsync(new Person()
                {
                    Name = $"Jim Morrison{index}"
                });
            });
            Parallel.ForEach(Enumerable.Range(0, count), async(index) =>
            {
                var person  = await dataProxy.GetByIDAsync(index + 1);
                person.Name = $"Peter Frampton{index}";
                await dataProxy.UpdateAsync(person);
            });
            foreach (var i in Enumerable.Range(0, count))
            {
                var person = await dataProxy.GetByIDAsync(i + 1);

                person.Name.ShouldBe($"Peter Frampton{i}");
            }
        }
        public void clear_removes_all_data()
        {
            var dataProxy = new PersonDataProxy();

            dataProxy.Clear();
            dataProxy.GetAll().Count().ShouldBe(0);
        }
        public void multiple_deletes_should_be_thread_safe()
        {
            var count     = 50;
            var dataProxy = new PersonDataProxy();

            dataProxy.Clear();
            Parallel.ForEach(Enumerable.Range(0, count), (index) =>
            {
                dataProxy.Insert(new Person()
                {
                    Name = $"Jim Morrison{index}"
                });
            });
            Parallel.ForEach(Enumerable.Range(0, count), (index) =>
            {
                dataProxy.Delete(index + 1);
            });
            dataProxy.GetAll().Count().ShouldBe(0);
        }
        public void multiple_inserts_should_be_thread_safe()
        {
            var count     = 50;
            var dataProxy = new PersonDataProxy();

            dataProxy.Clear();
            Parallel.ForEach(Enumerable.Range(0, count), (index) =>
            {
                dataProxy.Insert(new Person()
                {
                    Name = $"Jim Morrison{index}"
                });
            });
            dataProxy.GetAll().Count().ShouldBe(count);
            foreach (var i in Enumerable.Range(0, count))
            {
                dataProxy.GetByID(i + 1).ShouldNotBe(null);
            }
        }
        public async Task multiple_deletes_should_be_thread_safe_async()
        {
            var count     = 50;
            var dataProxy = new PersonDataProxy();

            dataProxy.Clear();
            Parallel.ForEach(Enumerable.Range(0, count), async(index) =>
            {
                await dataProxy.InsertAsync(new Person()
                {
                    Name = $"Jim Morrison{index}"
                });
            });
            Parallel.ForEach(Enumerable.Range(0, count), async(index) =>
            {
                await dataProxy.DeleteAsync(index + 1);
            });
            var people = await dataProxy.GetAllAsync();

            people.Count().ShouldBe(0);
        }
        public async Task multiple_inserts_should_be_thread_safe_async()
        {
            var count     = 50;
            var dataProxy = new PersonDataProxy();

            dataProxy.Clear();
            Parallel.ForEach(Enumerable.Range(0, count), async(index) =>
            {
                await dataProxy.InsertAsync(new Person()
                {
                    Name = $"Jim Morrison{index}"
                });
            });
            dataProxy.GetAll().Count().ShouldBe(count);
            foreach (var i in Enumerable.Range(0, count))
            {
                var person = await dataProxy.GetByIDAsync(i + 1);

                person.ShouldNotBe(null);
            }
        }
        public void multiple_updates_should_be_thread_safe()
        {
            var count     = 50;
            var dataProxy = new PersonDataProxy();

            dataProxy.Clear();
            Parallel.ForEach(Enumerable.Range(0, count), (index) =>
            {
                dataProxy.Insert(new Person()
                {
                    Name = $"Jim Morrison{index}"
                });
            });
            Parallel.ForEach(Enumerable.Range(0, count), (index) =>
            {
                var person  = dataProxy.GetByID(index + 1);
                person.Name = $"Peter Frampton{index}";
                dataProxy.Update(person);
            });
            foreach (var i in Enumerable.Range(0, count))
            {
                dataProxy.GetByID(i + 1).Name.ShouldBe($"Peter Frampton{i}");
            }
        }