public void CreatePocketAccount(string firstName, string lastName, string userId, decimal initialBalance)
{
var accountNo = (1234 + db.PocketAccounts.Count().ToString().PadLeft(10, '0'));
var pocketAccount = new PocketAccount
{
FirstName = firstName,
LastName = lastName,
PocketAccountNumber = accountNo,
Balance = initialBalance,
ApplicationUserId = userId
};
try
{
db.PocketAccounts.Add(pocketAccount);
db.SaveChanges();
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
System.Console.WriteLine("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
}
}
}
}
public void Setup()
{
_article = new PocketArticle(ArticleId, ArticleUrl, ArticleTitle);
_mockService = new Mock <IPocketService>();
_mockService.Setup(s => s.GenerateAuthUrlAsync(It.IsAny <Uri>(), It.IsAny <Uri>())).Returns(Task.FromResult(PocketUrl));
_mockUrlHelper = new Mock <IUrlHelper>();
_mockUrlHelper.Setup(s => s.Action(It.Is <UrlActionContext>(c => c.Action == "CompleteAuth"))).Returns(ActionUrl.ToString());
_mockUrlHelper.Setup(s => s.Action(It.Is <UrlActionContext>(c => c.Action == "DeleteArticleAsync"))).Returns(DeleteUrl);
_mockUrlHelper.Setup(s => s.Action(It.Is <UrlActionContext>(c => c.Action == "ArchiveArticleAsync"))).Returns(ArchiveUrl);
_account = new PocketAccount {
RedirectUrl = CallerUrl, AccessToken = PocketAccessToken
};
_mockService.Setup(s => s.UpgradeRequestTokenAsync(AccessToken)).ReturnsAsync(UrlWithAccessToken);
_mockService.Setup(s => s.GetNextArticleAsync(AccessToken)).ReturnsAsync(_article);
_controller = new PocketController(Mock.Of <ILogger <PocketController> >(), _mockService.Object)
{
Url = _mockUrlHelper.Object,
// Set a HttpContext so that the Request property is not null when tests are running
ControllerContext = { HttpContext = new DefaultHttpContext() }
};
}
public async Task DeleteAsync(PocketAccount account)
{
using (var conn = Connection)
{
await conn.ExecuteAsync($"DELETE FROM {TableName} WHERE Id = @Id", account);
}
}
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 void BalanceAfterAddToPocket()
{
var fakeDb = new FakeApplicationDbContext();
fakeDb.PocketAccounts = new FakeDbSet <PocketAccount>();
var pocketAccount = new PocketAccount
{
Id = 1,
PocketAccountNumber = "0001234567",
Balance = 0
};
fakeDb.PocketAccounts.Add(pocketAccount);
fakeDb.Transactions = new FakeDbSet <Transaction>();
var transactionController = new TransactionController(fakeDb);
// Act
transactionController.AddToPocket(new Transaction {
PocketAccountId = 1, Amount = 73.8m
});
// hardcode check the test for TDD
//pocketAccount.Balance = 73.8m;
//pocketAccount.Balance = 0.8m;
// Assert
Assert.AreEqual(73.8m, pocketAccount.Balance);
}
public async Task UpdateAsync(PocketAccount account)
{
using (var conn = Connection)
{
await conn.ExecuteAsync($"UPDATE {TableName} " +
"SET AccessToken = @AccessToken, RequestToken = @RequestToken, RedirectUrl = @RedirectUrl, Username = @Username " +
"WHERE Id = @Id", account);
}
}
public async Task <PocketAccount> InsertAsync(PocketAccount account)
{
using (var conn = Connection)
{
return(await conn.QuerySingleAsync <PocketAccount>(
$"INSERT INTO {TableName} (AccessToken, RequestToken, RedirectUrl, Username) " +
"VALUES (@AccessToken, @RequestToken, @RedirectUrl, @Username) returning *", account));
}
}
public async Task DeletesNewAccountIfAccountAlreadyExistsForUsername()
{
var existingAccount = new PocketAccount();
_mockRepo.Setup(r => r.FindByUsernameAsync(PocketUserName)).ReturnsAsync(existingAccount);
await _service.UpgradeRequestTokenAsync(AccessToken);
_mockRepo.Verify(r => r.DeleteAsync(_account), Times.Exactly(1));
}
public async Task UpdatesRedirectUrlForExistingAccount()
{
var existingAccount = new PocketAccount();
_mockRepo.Setup(r => r.FindByUsernameAsync(PocketUserName)).ReturnsAsync(existingAccount);
await _service.UpgradeRequestTokenAsync(AccessToken);
Assert.AreEqual(CallerCallbackUrl, existingAccount.RedirectUrl);
}
public async Task <ActionResult> AuthPocket()
{
var pocket = new PocketAccount();
pocket.CallbackUri = Url.AbsoluteUrl("~/List/AuthPocket");
var reqCode = await pocket.GetRequestCode();
var callbackUri = Url.AbsoluteUrl("~/List/AuthPocketResult?reqCode=") + reqCode;
var uri = pocket.Auth(callbackUri);
return(Redirect(uri.ToString()));
}
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 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 UsesProtectedIdOfExistingAccountInUrl()
{
var existingAccount = new PocketAccount {
Id = Guid.NewGuid()
};
var existingTokenBytes = Encoding.UTF8.GetBytes(existingAccount.Id.ToString());
_mockDataProtector.Setup(p => p.Protect(It.IsAny <byte[]>())).Returns(existingTokenBytes);
var expectedToken = _mockDataProtector.Object.Protect(existingAccount.Id.ToString());
var uriBuilder = new UriBuilder(CallerCallbackUrl);
uriBuilder.AppendToQuery("xAccessToken", expectedToken);
_mockRepo.Setup(r => r.FindByUsernameAsync(PocketUserName)).ReturnsAsync(existingAccount);
var result = await _service.UpgradeRequestTokenAsync(AccessToken);
Assert.AreEqual(uriBuilder.Uri, result);
}
public async Task <ActionResult> AuthPocketResult(string reqCode)
{
var pocket = new PocketAccount();
var pocketUser = await pocket.GetUser(reqCode);
if (pocketUser == null)
{
ViewBag.Message = "認証に失敗しました。";
return(View());
}
else
{
var user = GetUser();
await _UserHandler.AddUserDataAsync(user.Id, CoreConsts.PocketAccessCodeUserDataKey, pocketUser.AccessCode);
ViewBag.Message = "認証に成功しました。";
return(View());
}
}
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)
{
}
}
public void Setup()
{
_accountId = Guid.NewGuid();
_emailUserId = Guid.NewGuid();
_code = new PocketRequestCode(BaseUri, RedirectUri, RequestCode);
_accessTokenResult = new PocketAccessToken(PocketUserName, PocketAccessToken);
_account = new PocketAccount
{
Id = _accountId,
RequestToken = RequestCode,
AccessToken = PocketAccessToken,
RedirectUrl = CallerCallbackUrl.ToString()
};
_article = new PocketArticle(ArticleId, ArticleUrl, ArticleTitle);
_mockRepo = new Mock <IPocketAccountsRepository>();
_mockRepo.Setup(r => r.InsertAsync(It.IsAny <PocketAccount>())).ReturnsAsync((PocketAccount account) => {
account.Id = _accountId;
return(account);
});
_mockRepo.Setup(r => r.FindByIdAsync(_accountId)).ReturnsAsync(_account);
_mockClient = new Mock <IPocketClient>();
_mockClient.Setup(c => c.CreateRequestCodeAsync(It.IsAny <Uri>())).ReturnsAsync(_code);
_mockClient.Setup(c => c.CreateAccessTokenAsync(RequestCode)).ReturnsAsync(_accessTokenResult);
_mockClient.Setup(c => c.GetRandomArticleAsync(PocketAccessToken, 200)).ReturnsAsync(_article);
_mockDataProtector = new Mock <IDataProtector>();
_mockDataProtector.Setup(p => p.Protect(It.IsAny <byte[]>())).Returns(AccessTokenBytes);
_mockDataProtector.Setup(p => p.Unprotect(It.IsAny <byte[]>())).Returns(Encoding.UTF8.GetBytes(_accountId.ToString()));
_mockDataProtectionProvider = new Mock <IDataProtectionProvider>();
_mockDataProtectionProvider.Setup(p => p.CreateProtector(It.IsAny <string>())).Returns(_mockDataProtector.Object);
_service = new PocketService(_mockRepo.Object, _mockClient.Object, _mockDataProtectionProvider.Object);
}
public async Task <ActionResult> GetPocketItems()
{
var user = GetUser();
var pocketAccessCode = await _UserHandler.GetUserDataAsync(user.Id, CoreConsts.PocketAccessCodeUserDataKey);
if (pocketAccessCode != null)
{
try
{
var pocket = new PocketAccount(pocketAccessCode.Value);
var items = await pocket.GetItems();
return(JsonNet(items, JsonRequestBehavior.AllowGet));
}
catch (Exception)
{
return(JsonNet(false, JsonRequestBehavior.AllowGet));
}
}
else
{
return(JsonNet(false, JsonRequestBehavior.AllowGet));
}
}
