public static TestableChat GetTestableChat(string connectionId, StateChangeTracker clientState, ChatUser user, IDictionary<string, Cookie> cookies)
        {
            // setup things needed for chat
            var repository = new InMemoryRepository();
            var resourceProcessor = new Mock<IResourceProcessor>();
            var chatService = new Mock<IChatService>();
            var connection = new Mock<IConnection>();
            var settings = new Mock<IApplicationSettings>();
            var mockPipeline = new Mock<IHubPipelineInvoker>();

            // add user to repository
            repository.Add(user);

            // create testable chat
            var chat = new TestableChat(settings, resourceProcessor, chatService, repository, connection);
            var mockedConnectionObject = chat.MockedConnection.Object;

            chat.Clients = new HubConnectionContext(mockPipeline.Object, mockedConnectionObject, "Chat", connectionId, clientState);

            var prinicipal = new Mock<IPrincipal>();

            var request = new Mock<IRequest>();
            request.Setup(m => m.Cookies).Returns(cookies);
            request.Setup(m => m.User).Returns(prinicipal.Object);

            // setup context
            chat.Context = new HubCallerContext(request.Object, connectionId);

            return chat;
        }

        public static TestableChat GetTestableChat(string clientId, TrackingDictionary clientState, ChatUser user, NameValueCollection cookies)
        {
            // setup things needed for chat
            var repository = new InMemoryRepository();
            var resourceProcessor = new Mock<IResourceProcessor>();
            var chatService = new Mock<IChatService>();
            var connection = new Mock<IConnection>();

            // add user to repository
            repository.Add(user);

            // create testable chat
            var chat = new TestableChat(resourceProcessor, chatService, repository, connection);
            var mockedConnectionObject = chat.MockedConnection.Object;

            // setup client agent
            chat.Agent = new ClientAgent(mockedConnectionObject, "Chat");

            var request = new Mock<IRequest>();
            request.Setup(m => m.Cookies).Returns(cookies);

            // setup signal agent
            var prinicipal = new Mock<IPrincipal>();
            chat.Caller = new SignalAgent(mockedConnectionObject, clientId, "Chat", clientState);

            // setup context
            chat.Context = new HubContext(new HostContext(request.Object, null, prinicipal.Object), clientId);

            return chat;
        }

            public void ThrowsIfNameIsInValid()
            {
                var repository = new InMemoryRepository();
                var service = new ChatService(new Mock<ICache>().Object, repository,new Mock<ICryptoService>().Object);

                Assert.Throws<InvalidOperationException>(() => service.AddUser("some in valid name", clientId: null, userAgent: null, password: null));
            }

        public void SharpRepository_Supports_Basic_Crud_Operations()
        {
            // Declare your generic InMemory Repository.
            // Check out HowToAbstractAwayTheGenericRepository.cs for cleaner ways to new up a repo.
            var repo = new InMemoryRepository<Order, int>();

            // Create
            var create = new Order { Name = "Big sale" };
            repo.Add(create);

            const int expectedOrderId = 1;
            create.OrderId.ShouldEqual(expectedOrderId);

            // Read
            var read = repo.Get(expectedOrderId);
            read.Name.ShouldEqual(create.Name);

            // Update
            read.Name = "Really big sale";
            repo.Update(read);

            var update = repo.Get(expectedOrderId);
            update.OrderId.ShouldEqual(expectedOrderId);
            update.Name.ShouldEqual(read.Name);

            // Delete
            repo.Delete(update);
            var delete = repo.Get(expectedOrderId);
            delete.ShouldBeNull();
        }

            public void ThrowsIfPasswordIsTooShort()
            {
                var repository = new InMemoryRepository();
                var service = new MembershipService(repository, new Mock<ICryptoService>().Object);

                Assert.Throws<InvalidOperationException>(() => service.AddUser("SomeUser", "email", password: "short"));
            }

            public void ThrowsIfNameIsInValid()
            {
                var repository = new InMemoryRepository();
                var service = new MembershipService(repository, new Mock<ICryptoService>().Object);

                Assert.Throws<InvalidOperationException>(() => service.AddUser("some in valid name", "email", password: null));
            }

        public void Should_return_matches_from_a_repository()
        {
            var users = new List<InstalledPlugin>
                               {
                                    new InstalledPlugin { Id = Guid.NewGuid(), Name = "Blog", Version = "1.0.0"},
                                    new InstalledPlugin { Id = Guid.NewGuid(), Name = "News", Version = "1.0.0"},
                                    new InstalledPlugin { Id = Guid.NewGuid(), Name = "Events", Version = "1.0.0"}
                               };

            IRepository<InstalledPlugin> repository = new InMemoryRepository<InstalledPlugin>(users);
            var matches = repository.Find(new OrderedPlugins());

            Assert.AreEqual(3, matches.Count);

            var count = 0;
            foreach (var item in matches)
            {
                if (count == 0)
                    Assert.AreEqual("Blog", item.Name);
                if (count == 1)
                    Assert.AreEqual("Events", item.Name);
                if (count == 2)
                    Assert.AreEqual("News", item.Name);

                count++;
            }
        }

        public void CanCreateInstanceOfRepository()
        {
            IRepository<SomeEntity> repo = new InMemoryRepository<SomeEntity>();

            Assert.IsNotNull(repo);
            Assert.IsInstanceOf<InMemoryRepository<SomeEntity>>(repo);
        }

            public void ThrowsIfPasswordIsTooShort()
            {
                var repository = new InMemoryRepository();
                var service = new ChatService(new Mock<ICache>().Object, repository,new Mock<ICryptoService>().Object);

                Assert.Throws<InvalidOperationException>(() => service.AddUser("SomeUser", clientId: null, userAgent: null, password: "short"));
            }

        public static InMemoryRepository<Message> GetMessageRepository(int numberOfMessage = 25)
        {
            var repo = new InMemoryRepository<Message>();
            var friendship = new Friendship()
            {
                 Id = 1,
                 IsFirstUserSender = true,
                 FirstUserId = "12345",
                 SecondUserId = "54321",
                 CreatedOn = DateTime.Now,
                 IsApproved = true
            };

            for (var i = 0; i < numberOfMessage; i++)
            {
                var date = new DateTime(2015, 11, 5, 23, 47, 12);
                date.AddDays(i);

                repo.Add(new Message
                {
                    Id = i,
                    Author = new User
                    {
                        FirstName = "FName" + i,
                        LastName = "LName" + i,
                        ProfilePhoto = new byte[i]
                    },
                    Content = "Content" + i,
                    SentOn = date,
                    FriendshipId = friendship.Id
                });
            }

            return repo;
        }

        public MainWindow()
        {
            InitializeComponent();

            // Use this as construction root for simplicity.
            // In real world app there should be good framework for this and this should be done
            // outside of main window for reason that then mainwindow is interchangeable too if required.
            var dataSource = new InMemoryRepository();

            // Dummy data for testing...
            dataSource.Add(new CarImage {Color="Black", RegisterPlate = "ABC-123", Speed = 140});

            var messenger = new MessageAggregator();
            var reportViewModel = new ReportViewModel(dataSource, messenger);
            var colorFilter = new ColorFilterViewModel();
            var filterViewModel = new FiltersViewModel(new List<IFilter> {colorFilter}, messenger);

            // Just for testing, apply dummy filter so that data is shown.
            messenger.Publish(new Messages.FiltersAppliedMessage());

            DataContext = new
            {
                Report = reportViewModel,
                Filters = filterViewModel
            };
        }

            public void MakesOwnerAllowedIfRoomLocked()
            {
                var repository = new InMemoryRepository();
                var user = new ChatUser
                {
                    Name = "foo"
                };
                var user2 = new ChatUser
                {
                    Name = "foo2"
                };
                repository.Add(user);
                repository.Add(user2);
                var room = new ChatRoom
                {
                    Name = "Room",
                    Creator = user,
                    Private = true
                };
                room.Owners.Add(user);
                user.OwnedRooms.Add(room);
                user.Rooms.Add(room);
                room.Users.Add(user);

                var service = new ChatService(repository, new Mock<ICryptoService>().Object);

                service.AddOwner(user, user2, room);

                Assert.True(user2.AllowedRooms.Contains(room));
                Assert.True(room.AllowedUsers.Contains(user2));
                Assert.True(room.Owners.Contains(user2));
                Assert.True(user2.OwnedRooms.Contains(room));
            }

            public void MakesUserOwner()
            {
                var repository = new InMemoryRepository();
                var user = new ChatUser
                {
                    Name = "foo"
                };
                var user2 = new ChatUser
                {
                    Name = "foo2"
                };
                repository.Add(user);
                repository.Add(user2);
                var room = new ChatRoom
                {
                    Name = "Room",
                    Creator = user
                };
                room.Owners.Add(user);
                user.OwnedRooms.Add(room);
                user.Rooms.Add(room);
                room.Users.Add(user);

                var service = new ChatService(repository);

                service.AddOwner(user, user2, room);

                Assert.True(room.Owners.Contains(user2));
                Assert.True(user2.OwnedRooms.Contains(room));
            }

        public void Should_return_matches_from_a_repository()
        {
            var users = new List<UserGroup>
                               {
                                    new UserGroup {Id = Guid.NewGuid(), Name = "First Group"},
                                    new UserGroup {Id = Guid.NewGuid(), Name = "Second Group"},
                                    new UserGroup {Id = Guid.NewGuid(), Name = "Third Group"},
                             		new UserGroup {Id = Guid.NewGuid(), Name = "News Editor Group"},
                             		new UserGroup {Id = Guid.NewGuid(), Name = "Publishing Group"},
                             		new UserGroup {Id = Guid.NewGuid(), Name = "Blogging Group"},
                             		new UserGroup {Id = Guid.NewGuid(), Name = "Product Editing Group"}
                               };

            IRepository<UserGroup> repository = new InMemoryRepository<UserGroup>(users);
            var matches = repository.Find(new PagedUserGroups(3, 3));

            Assert.AreEqual(3, matches.Count);

            var count = 0;
            foreach (var item in matches)
            {
                if (count == 0)
                    Assert.AreEqual("News Editor Group", item.Name);
                if (count == 1)
                    Assert.AreEqual("Publishing Group", item.Name);
                if (count == 2)
                    Assert.AreEqual("Blogging Group", item.Name);

                count++;
            }
        }

        public static TestableChat GetTestableChat(string connectionId, TrackingDictionary clientState, ChatUser user, NameValueCollection cookies)
        {
            // setup things needed for chat
            var repository = new InMemoryRepository();
            var resourceProcessor = new Mock<IResourceProcessor>();
            var chatService = new Mock<IChatService>();
            var connection = new Mock<IConnection>();
            var settings = new Mock<IApplicationSettings>();

            settings.Setup(m => m.AuthApiKey).Returns("key");

            // add user to repository
            repository.Add(user);

            // create testable chat
            var chat = new TestableChat(settings, resourceProcessor, chatService, repository, connection);
            var mockedConnectionObject = chat.MockedConnection.Object;

            // setup client agent
            chat.Clients = new ClientProxy(mockedConnectionObject, "Chat");

            // setup signal agent
            var prinicipal = new Mock<IPrincipal>();

            var request = new Mock<IRequest>();
            request.Setup(m => m.Cookies).Returns(new Cookies(cookies));
            request.Setup(m => m.User).Returns(prinicipal.Object);

            chat.Caller = new StatefulSignalProxy(mockedConnectionObject, connectionId, "Chat", clientState);

            // setup context
            chat.Context = new HubCallerContext(request.Object, connectionId);

            return chat;
        }

 public void CachingEnabled_Should_Be_True_When_CachingStrategy_Is_Changed_From_NoCachingStrategy()
 {
     var repository = new InMemoryRepository<Contact, Int32>(new NoCachingStrategy<Contact, int>());
     repository.CachingEnabled.ShouldBeFalse();
     repository.CachingStrategy = new TimeoutCachingStrategy<Contact, int>(60);
     repository.CachingEnabled.ShouldBeTrue();
 }

        public void Repository_Handles_Sorting()
        {
            var repo = new InMemoryRepository<Order>();
            repo.Add(OrdersToLoad());

            // there are 2 ways to handle sorting, there is an Expression based way
            //  and a "magic string" based approach.
            // Why the 2 approaches?
            //  For convenience really.  In a Web based applicaiton sometimes it is easier to
            //  post back a string that represents the properrty that you want to sort on.

            // First, the Expression way
            var descendingOrders = repo.GetAll(new SortingOptions<Order, DateTime>(x => x.OrderDate, isDescending: true));
            descendingOrders.First().OrderId.ShouldEqual(1);

            var ascendingOrders = repo.GetAll(new SortingOptions<Order, DateTime>(x => x.OrderDate, isDescending: false));
            ascendingOrders.First().OrderId.ShouldEqual(2);

            // You can also combine sortings and selectors (See HowToUseGetSelectors for more info)
            var descendingNames = repo.GetAll(x => x.Name, new SortingOptions<Order, DateTime>(x => x.OrderDate, isDescending: true));
            descendingNames.First().ShouldEqual("Order 1");

            // The Magic String approach to sorting
            //  you can see that you don't need the second generic type (the property type to sort on), just the name of the property
            ascendingOrders = repo.GetAll(new SortingOptions<Order>("OrderDate", isDescending: false));
            ascendingOrders.First().OrderId.ShouldEqual(2);

            // using sorting with FindAll
            var minDate = DateTime.Now.AddDays(-7);
            var ordersWithinAWeek = repo.FindAll(x => x.OrderDate > minDate, new SortingOptions<Order, double>(x => x.Total, true));
            ordersWithinAWeek.Count().ShouldEqual(2);
        }

 public When_a_user_is_successfully_logged_in()
 {
     var username = "[email protected]";
     var password = "a";
     Repository = new InMemoryRepository<User>(SecurityHelper.GetUserList());
     UserService = new UsersService(Repository);
     CurrentUser = UserService.LoginUser(username, password);
 }

        public void delete_removes_from_internal_list()
        {
            var list = new List<string> { "Apple", "Ball", "Cat", "Dog" };
            var repository = new InMemoryRepository<string>(list);
            repository.Delete("Apple");

            Assert.That(list.Contains("Apple"), Is.False);
        }

        public void Add_adds_to_internal_list()
        {
            var list = new List<string> { "Apple", "Ball", "Cat", "Dog" };
            var repository = new InMemoryRepository<string>(list);

            repository.Add("DoDo");
            Assert.That(list.Contains("DoDo"));
        }