public async Task CanUpdateAccount()
        {
            var repo            = new DbPocketAccountsRepository(_postgresTestHelper.ConnectionFactory);
            var insertedAccount = await repo.InsertAsync(new PocketAccount
            {
                AccessToken  = "access-token",
                RedirectUrl  = "http://example.com",
                RequestToken = "request-token",
                Username     = "******"
            });

            var updatedAccount = new PocketAccount
            {
                Id           = insertedAccount.Id,
                AccessToken  = "access-token2",
                RedirectUrl  = "http://example.com",
                RequestToken = "request-token2",
                Username     = "******"
            };
            await repo.UpdateAsync(updatedAccount);

            var actualAccount = await _postgresTestHelper.Connection.QuerySingleAsync <PocketAccount>(
                @"select * from ""PocketAccounts"" where Id = @Id", updatedAccount);


            Assert.AreEqual(updatedAccount.Id, actualAccount.Id);
            Assert.AreEqual(updatedAccount.AccessToken, actualAccount.AccessToken);
            Assert.AreEqual(updatedAccount.RedirectUrl, actualAccount.RedirectUrl);
            Assert.AreEqual(updatedAccount.RequestToken, actualAccount.RequestToken);
            Assert.AreEqual(updatedAccount.Username, actualAccount.Username);
        }
        public async Task FindByUsernameReturnsNullIfNoneFound()
        {
            var repo = new DbPocketAccountsRepository(_postgresTestHelper.ConnectionFactory);

            var result = await repo.FindByUsernameAsync("user-name");

            Assert.IsNull(result);
        }
        public async Task FindsFeatureTogglesForAccount()
        {
            var account = new PocketAccount
            {
                AccessToken  = "access-token",
                RedirectUrl  = "http://example.com",
                RequestToken = "request-token",
                Username     = "******"
            };
            var toggles = new[]
            {
                new FeatureToggle
                {
                    Name        = "Sample Toggle 1",
                    Description = "First Toggle"
                },
                new FeatureToggle
                {
                    Name        = "Sample Toggle 2",
                    Description = "Second Toggle"
                }
            };
            var repo            = new DbPocketAccountsRepository(_postgresTestHelper.ConnectionFactory);
            var insertedAccount = await repo.InsertAsync(account);

            var insertedToggles = new List <FeatureToggle>(toggles.Length);

            foreach (var toggle in toggles)
            {
                var insertedToggle = await _postgresTestHelper.Connection.QuerySingleAsync <FeatureToggle>(
                    "INSERT INTO \"FeatureToggles\" (Name, Description) VALUES (@Name, @Description) RETURNING *",
                    toggle);

                insertedToggles.Add(insertedToggle);
            }
            // inserted our account and toggles, want to know link the last toggle to our account
            await _postgresTestHelper.Connection.ExecuteAsync(
                "INSERT INTO \"PocketAccountFeatureToggles\" (AccountId, ToggleId) VALUES (@AccountId, @ToggleId)",
                new { AccountId = insertedAccount.Id, ToggleId = insertedToggles[1].Id });

            var result = await repo.FindTogglesForAccountAsync(insertedAccount.Id);

            var resultList = result.ToList();

            Assert.IsNotNull(result);
            Assert.AreEqual(1, resultList.Count);
            Assert.AreEqual(insertedToggles[1].Id, resultList[0].Id);
            Assert.AreEqual(insertedToggles[1].Name, resultList[0].Name);
            Assert.AreEqual(insertedToggles[1].Description, resultList[0].Description);
        }
        public async Task CanDeleteAccount()
        {
            var repo            = new DbPocketAccountsRepository(_postgresTestHelper.ConnectionFactory);
            var insertedAccount = await repo.InsertAsync(new PocketAccount
            {
                AccessToken  = "access-token",
                RedirectUrl  = "http://example.com",
                RequestToken = "request-token"
            });

            await repo.DeleteAsync(insertedAccount);

            var actualAccount = await _postgresTestHelper.Connection.QuerySingleOrDefaultAsync <PocketAccount>(
                @"SELECT * FROM ""PocketAccounts"" WHERE Id = @Id", insertedAccount);

            Assert.IsNull(actualAccount);
        }
        public async Task CanInsertAccount()
        {
            var account = new PocketAccount
            {
                AccessToken  = "access-token",
                RedirectUrl  = "http://example.com",
                RequestToken = "request-token",
                Username     = "******"
            };
            var repo = new DbPocketAccountsRepository(_postgresTestHelper.ConnectionFactory);

            var result = await repo.InsertAsync(account);

            Assert.AreEqual(account.AccessToken, result.AccessToken);
            Assert.AreEqual(account.RedirectUrl, result.RedirectUrl);
            Assert.AreEqual(account.RequestToken, result.RequestToken);
            Assert.AreEqual(account.Username, result.Username);
        }
        public async Task InsertFailsIfUsernameIsNotUnique()
        {
            var account = new PocketAccount
            {
                AccessToken  = "access-token",
                RedirectUrl  = "http://example.com",
                RequestToken = "request-token",
                Username     = "******"
            };
            var repo = new DbPocketAccountsRepository(_postgresTestHelper.ConnectionFactory);
            await repo.InsertAsync(account);

            try
            {
                await repo.InsertAsync(account);

                Assert.Fail("Expected second insert to fail");
            }
            catch (DbException)
            {
            }
        }