public async Task Single_item_data_is_deserialized_properly()
{
var dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Account).Object);
var account = await dataStore.GetResourceAsync <IAccount>("/account", CancellationToken.None);
// Verify against data from FakeJson.Account
account.CreatedAt.ShouldBe(Iso8601.Parse("2015-07-21T23:50:49.078Z"));
account.Email.ShouldBe("*****@*****.**");
account.FullName.ShouldBe("Han Solo");
account.GivenName.ShouldBe("Han");
account.Href.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount");
account.MiddleName.ShouldBeNull();
account.ModifiedAt.ShouldBe(Iso8601.Parse("2015-07-21T23:50:49.078Z"));
account.Status.ShouldBe(AccountStatus.Enabled);
account.Surname.ShouldBe("Solo");
account.Username.ShouldBe("*****@*****.**");
(account as DefaultAccount).AccessTokens.Href.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount/accessTokens");
(account as DefaultAccount).ApiKeys.Href.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount/apiKeys");
(account as DefaultAccount).Applications.Href.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount/applications");
(account as DefaultAccount).CustomData.Href.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount/customData");
(account as DefaultAccount).Directory.Href.ShouldBe("https://api.stormpath.com/v1/directories/foobarDirectory");
(account as DefaultAccount).EmailVerificationToken.Href.ShouldBeNull();
(account as DefaultAccount).GroupMemberships.Href.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount/groupMemberships");
(account as DefaultAccount).Groups.Href.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount/groups");
(account as DefaultAccount).ProviderData.Href.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount/providerData");
(account as DefaultAccount).RefreshTokens.Href.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount/refreshTokens");
(account as DefaultAccount).Tenant.Href.ShouldBe("https://api.stormpath.com/v1/tenants/foobarTenant");
}
public void Updating_custom_data_with_proxy_updates_cache()
{
var cacheProvider = Caches.NewInMemoryCacheProvider().Build();
var requestExecutor = Substitute.For <IRequestExecutor>();
this.dataStore = TestDataStore.Create(requestExecutor, cacheProvider);
// GET returns expanded request
requestExecutor
.Execute(Arg.Is <IHttpRequest>(req => req.Method == HttpMethod.Get))
.Returns(new DefaultHttpResponse(200, "OK", new HttpHeaders(), FakeJson.AccountWithExpandedCustomData, "application/json", transportError: false));
// Save is not an expanded request
requestExecutor
.Execute(Arg.Is <IHttpRequest>(req => req.Method == HttpMethod.Post))
.Returns(new DefaultHttpResponse(201, "Created", new HttpHeaders(), FakeJson.Account, "application/json", transportError: false));
var account = this.dataStore.GetResource <IAccount>("/accounts/foobarAccount?expand=customData");
account.CustomData.Put("isAdmin", true);
account.CustomData.Put("writeAccess", "yes");
account.Save();
var customData = account.GetCustomData();
customData["isAdmin"].ShouldBe(true);
customData["writeAccess"].ShouldBe("yes");
this.dataStore.RequestExecutor.Received(1).Execute(
Arg.Is <IHttpRequest>(x => x.Method == HttpMethod.Get));
}
public async Task When_saving_returns_empty_response_without_status_202_throws_error()
{
// Expected behavior: Saving should always return the updated data unless we get back HTTP 202 (Accepted for Processing).
var dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Account).Object) as IInternalAsyncDataStore;
dataStore.RequestExecutor
.ExecuteAsync(Arg.Any <IHttpRequest>(), Arg.Any <CancellationToken>())
.Returns(Task.FromResult <IHttpResponse>(new DefaultHttpResponse(200, "OK", null, null, null, transportError: false)));
var account = dataStore.Instantiate <IAccount>();
account.SetMiddleName("Test");
account.SetUsername("newusername");
bool erroredAsExpected = false;
try
{
await dataStore.CreateAsync("http://api.foo.bar/accounts", account, CancellationToken.None);
}
catch (ResourceException rex)
{
rex.DeveloperMessage.ShouldBe("Unable to obtain resource data from the API server.");
erroredAsExpected = true;
}
erroredAsExpected.ShouldBeTrue();
}
public void Does_not_cache_password_reset_tokens()
{
var cacheProvider = Caches.NewInMemoryCacheProvider().Build();
var requestExecutor = Substitute.For <IRequestExecutor>();
this.dataStore = TestDataStore.Create(requestExecutor, cacheProvider);
var passwordResetTokenResponse = @"
{
""href"": ""https://api.stormpath.com/v1/applications/foo/passwordResetTokens/bar"",
""email"": ""*****@*****.**"",
""account"": {
""href"": ""https://api.stormpath.com/v1/accounts/cJoiwcorTTmkDDBsf02bAb""
}
}
";
// POST returns token response
requestExecutor
.Execute(Arg.Is <IHttpRequest>(req => req.Method == HttpMethod.Post))
.Returns(new DefaultHttpResponse(200, "OK", new HttpHeaders(), passwordResetTokenResponse, "application/json", transportError: false));
// GET also returns token response
requestExecutor
.Execute(Arg.Is <IHttpRequest>(req => req.Method == HttpMethod.Get))
.Returns(new DefaultHttpResponse(200, "OK", new HttpHeaders(), passwordResetTokenResponse, "application/json", transportError: false));
this.dataStore.GetResource <IPasswordResetToken>("https://api.stormpath.com/v1/applications/foo/passwordResetTokens/bar");
this.dataStore.GetResource <IPasswordResetToken>("https://api.stormpath.com/v1/applications/foo/passwordResetTokens/bar");
// Not cached
this.dataStore.RequestExecutor.Received(2).Execute(
Arg.Any <IHttpRequest>());
}
public async Task Updating_resource_updates_cache()
{
var cacheProvider = Caches.NewInMemoryCacheProvider().Build();
var requestExecutor = Substitute.For <IRequestExecutor>();
this.dataStore = TestDataStore.Create(requestExecutor, cacheProvider);
// GET returns original
requestExecutor
.ExecuteAsync(Arg.Is <IHttpRequest>(req => req.Method == HttpMethod.Get), Arg.Any <CancellationToken>())
.Returns(Task.FromResult(new DefaultHttpResponse(200, "OK", new HttpHeaders(), FakeJson.Account, "application/json", transportError: false) as IHttpResponse));
// Save returns update data
requestExecutor
.ExecuteAsync(Arg.Is <IHttpRequest>(req => req.Method == HttpMethod.Post), Arg.Any <CancellationToken>())
.Returns(Task.FromResult(new DefaultHttpResponse(201, "Created", new HttpHeaders(), FakeJson.Account.Replace("*****@*****.**", "*****@*****.**"), "application/json", transportError: false) as IHttpResponse));
var account1 = await this.dataStore.GetResourceAsync <IAccount>("/accounts/foobarAccount");
account1.Email.ShouldBe("*****@*****.**");
account1.SetEmail("*****@*****.**");
await account1.SaveAsync();
account1.Email.ShouldBe("*****@*****.**");
var account2 = await this.dataStore.GetResourceAsync <IAccount>("/accounts/foobarAccount");
account2.Email.ShouldBe("*****@*****.**");
// Only one GET; second is intercepted by the cache (but the updated data is returned!) #magic
await this.dataStore.RequestExecutor.Received(1).ExecuteAsync(
Arg.Is <IHttpRequest>(x => x.Method == HttpMethod.Get),
Arg.Any <CancellationToken>());
}
public async Task Does_not_cache_email_verification_tokens()
{
var cacheProvider = Caches.NewInMemoryCacheProvider().Build();
var requestExecutor = Substitute.For <IRequestExecutor>();
this.dataStore = TestDataStore.Create(requestExecutor, cacheProvider);
var emailVerificationTokenResponse = @"
{
""href"": ""https://api.stormpath.com/v1/accounts/foobarAccount""
}
";
// POST returns email verification token response
requestExecutor
.ExecuteAsync(Arg.Is <IHttpRequest>(req => req.Method == HttpMethod.Post), Arg.Any <CancellationToken>())
.Returns(Task.FromResult(new DefaultHttpResponse(200, "OK", new HttpHeaders(), emailVerificationTokenResponse, "application/json", transportError: false) as IHttpResponse));
var href = $"/accounts/emailVerificationTokens/fooToken";
await(this.dataStore as IInternalAsyncDataStore).CreateAsync <IResource, IEmailVerificationToken>(href, null, CancellationToken.None);
await(this.dataStore as IInternalAsyncDataStore).CreateAsync <IResource, IEmailVerificationToken>(href, null, CancellationToken.None);
// Not cached
await this.dataStore.RequestExecutor.Received(2).ExecuteAsync(
Arg.Any <IHttpRequest>(),
Arg.Any <CancellationToken>());
}
public void GetTest()
{
ISponsor Expected = new TestSponsor {
Id = 1,
DisplayName = "Test Sponsor",
LogoLarge = "Logo Large",
LogoSmall = "Logo Small",
Website = "Test Website",
Level = new TestSponsorLevel {
Id = 1,
DisplayName = "Test Sponsor Level",
DisplayOrder = 1,
DisplayInEmails = false,
DisplayInSidebar = false
}
};
TestDataStore testDataStore = new TestDataStore();
testDataStore.GetFunction = (id) => {
return(Task.FromResult <ISponsor>(Expected));
};
SponsorController ControllerToTest = new SponsorController(testDataStore);
HttpResponseMessage Actual = ControllerToTest.Get(1).Result;
Assert.IsNotNull(Actual);
Assert.AreEqual(HttpStatusCode.OK, Actual.StatusCode);
AssertSponorsAreEqual(Expected, Newtonsoft.Json.JsonConvert.DeserializeObject <Common.Sponsor>(Actual.Content.ReadAsStringAsync().Result));
}
public async Task Does_not_cache_login_attempts()
{
var cacheProvider = Caches.NewInMemoryCacheProvider().Build();
var requestExecutor = Substitute.For <IRequestExecutor>();
this.dataStore = TestDataStore.Create(requestExecutor, cacheProvider);
var authResponse = @"
{
""account"": {
""href"" : ""https://api.stormpath.com/v1/accounts/5BedLIvyfLjdKKEEXAMPLE""
}
}";
// POST returns auth response
requestExecutor
.ExecuteAsync(Arg.Is <IHttpRequest>(req => req.Method == HttpMethod.Post), Arg.Any <CancellationToken>())
.Returns(Task.FromResult(new DefaultHttpResponse(200, "OK", new HttpHeaders(), authResponse, "application/json", transportError: false) as IHttpResponse));
var request = new UsernamePasswordRequest("foo", "bar", null, null) as IAuthenticationRequest;
var authenticator = new BasicAuthenticator(this.dataStore);
var result1 = await authenticator.AuthenticateAsync("/loginAttempts", request, null, CancellationToken.None);
var result2 = await authenticator.AuthenticateAsync("/loginAttempts", request, null, CancellationToken.None);
// Not cached
await this.dataStore.RequestExecutor.Received(2).ExecuteAsync(
Arg.Any <IHttpRequest>(),
Arg.Any <CancellationToken>());
}
public EmployerIncentivesHubSteps(TestContext testContext) : base(testContext)
{
_testContext = testContext;
_testDataStore = testContext.TestDataStore;
_fixture = new Fixture();
_applicationId = Guid.NewGuid();
}
public async Task Handle_error(string id_, string jwtResponse, Type expectedExceptionType, int expectedCode, int expectedStatus, string expectedMessage, string expectedDeveloperMessage)
{
var testApiKey = ClientApiKeys.Builder()
.SetId("2EV70AHRTYF0JOA7OEFO3SM29")
.SetSecret("goPUHQMkS4dlKwl5wtbNd91I+UrRehCsEDJrIrMruK8")
.Build();
var fakeRequestExecutor = Substitute.For <IRequestExecutor>();
fakeRequestExecutor.ApiKey.Returns(testApiKey);
this.dataStore = TestDataStore.Create(fakeRequestExecutor, Caches.NewInMemoryCacheProvider().Build());
var request = new DefaultHttpRequest(HttpMethod.Get, new CanonicalUri($"https://foo.bar?{IdSiteClaims.JwtResponse}={jwtResponse}"));
IIdSiteAsyncCallbackHandler callbackHandler = new DefaultIdSiteAsyncCallbackHandler(this.dataStore, request);
try
{
var accountResult = await callbackHandler.GetAccountResultAsync(CancellationToken.None);
throw new Exception("Should not reach here. Proper exception was not thrown.");
}
catch (IdSiteRuntimeException e) when(expectedExceptionType.IsAssignableFrom(e.GetType()))
{
e.Code.ShouldBe(expectedCode);
e.HttpStatus.ShouldBe(expectedStatus);
e.Message.ShouldBe(expectedMessage);
e.DeveloperMessage.ShouldBe(expectedDeveloperMessage);
}
catch (Exception e) when(expectedExceptionType.IsAssignableFrom(e.GetType()))
{
e.Message.ShouldStartWith(expectedMessage);
}
}
public async Task Saving_resource_posts_changed_values_only()
{
string savedHref = null;
string savedJson = null;
var dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Account).Object);
dataStore.RequestExecutor
.When(x => x.ExecuteAsync(Arg.Any <IHttpRequest>(), Arg.Any <CancellationToken>()))
.Do(call =>
{
savedHref = call.Arg <IHttpRequest>().CanonicalUri.ToString();
savedJson = call.Arg <IHttpRequest>().Body;
});
var account = await dataStore.GetResourceAsync <IAccount>("/account", CancellationToken.None);
account.Href.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount");
account.SetMiddleName("Test");
account.SetUsername("newusername");
await account.SaveAsync();
savedHref.ShouldBe("https://api.stormpath.com/v1/accounts/foobarAccount");
var savedMap = Newtonsoft.Json.JsonConvert.DeserializeObject <Dictionary <string, string> >(savedJson);
savedMap.Count.ShouldBe(2);
savedMap["middleName"].ShouldBe("Test");
savedMap["username"].ShouldBe("newusername");
}
async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Notes.Clear();
var notes = await TestDataStore.GetNotesAsync();
foreach (var note in notes)
{
Notes.Add(note);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public async Task Embedded_custom_data_is_cleared_for_all_instances_after_save()
{
var dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Account).Object);
var account = await dataStore.GetResourceAsync <IAccount>("/account", CancellationToken.None);
var account2 = await dataStore.GetResourceAsync <IAccount>("/account", CancellationToken.None);
account.CustomData.Put("foo", 123);
await account.SaveAsync();
var expectedBody = @"{""customData"":{""foo"":123}}";
var body = dataStore.RequestExecutor
.ReceivedCalls()
.Last()
.GetArguments()
.OfType <IHttpRequest>()
.First()
.Body;
body.ShouldBe(expectedBody);
dataStore.RequestExecutor.ClearReceivedCalls();
await account2.SaveAsync();
// Empty save, should not POST anything
await dataStore.RequestExecutor.DidNotReceive().ExecuteAsync(
Arg.Is <IHttpRequest>(req =>
req.Method == HttpMethod.Post),
Arg.Any <CancellationToken>());
}
public DefaultResourceFactory_tests()
{
var dataStore = TestDataStore.Create();
var identityMap = new MemoryCacheIdentityMap <ResourceData>(TimeSpan.FromSeconds(10), Substitute.For <ILogger>()); // arbitrary expiration time
this.factory = new DefaultResourceFactory(dataStore, identityMap);
}
public async Task Cancellation_token_is_passed_down_to_low_level_operations()
{
var dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Account).Object) as IInternalAsyncDataStore;
dataStore.RequestExecutor
.ExecuteAsync(Arg.Any <IHttpRequest>(), Arg.Any <CancellationToken>())
.Returns(async callInfo =>
{
// Will pause for 1 second, unless CancellationToken has been passed through to us
await Task.Delay(1000, callInfo.Arg <CancellationToken>());
return(new DefaultHttpResponse(204, "No Content", new HttpHeaders(), null, null, transportError: false) as IHttpResponse);
});
var fakeAccount = dataStore.InstantiateWithHref <IAccount>("http://api.foo.bar/accounts/1");
var alreadyCanceledSource = new CancellationTokenSource();
alreadyCanceledSource.Cancel();
var stopwatch = Stopwatch.StartNew();
var deleted = false;
try
{
await dataStore.DeleteAsync(fakeAccount, alreadyCanceledSource.Token);
}
catch (TaskCanceledException)
{
deleted = true;
}
stopwatch.Stop();
stopwatch.ElapsedMilliseconds.ShouldBeLessThan(1000);
deleted.ShouldBeTrue();
}
public void Post_Update()
{
try {
TestUser testUser = new TestUser {
Id = 1,
EmailAddress = "*****@*****.**",
DisplayName = "Test Display Name",
PasswordHash = "TestPassword"
};
TestDataStore testDataStore = new TestDataStore();
testDataStore.data.Add(1, testUser);
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("*****@*****.**"), null);
UserController objectUnderTest = new UserController(testDataStore);
HttpResponseMessage actual = objectUnderTest.Post(testUser).Result;
Assert.AreEqual(HttpStatusCode.OK, actual.StatusCode);
IUser savedUser = testDataStore.data.Values.FirstOrDefault();
Assert.IsNotNull(savedUser);
Assert.AreEqual(testUser.EmailAddress, savedUser.EmailAddress);
Assert.AreEqual(testUser.DisplayName, savedUser.DisplayName);
Assert.AreNotEqual("TestPassword", savedUser.PasswordHash);
Assert.AreNotEqual(0, savedUser.Id);
} finally {
Thread.CurrentPrincipal = null;
}
}
public async Task Deleting_custom_data_with_proxy_updates_cache()
{
var cacheProvider = Caches.NewInMemoryCacheProvider().Build();
var requestExecutor = Substitute.For <IRequestExecutor>();
this.dataStore = TestDataStore.Create(requestExecutor, cacheProvider);
// GET returns expanded request
requestExecutor
.ExecuteAsync(Arg.Is <IHttpRequest>(req => req.Method == HttpMethod.Get), Arg.Any <CancellationToken>())
.Returns(Task.FromResult(new DefaultHttpResponse(200, "OK", new HttpHeaders(), FakeJson.AccountWithExpandedCustomData, "application/json", transportError: false) as IHttpResponse));
// Save is not an expanded request
requestExecutor
.ExecuteAsync(Arg.Is <IHttpRequest>(req => req.Method == HttpMethod.Post), Arg.Any <CancellationToken>())
.Returns(Task.FromResult(new DefaultHttpResponse(201, "Created", new HttpHeaders(), FakeJson.Account, "application/json", transportError: false) as IHttpResponse));
var account = await this.dataStore.GetResourceAsync <IAccount>("/accounts/foobarAccount?expand=customData");
account.CustomData.Remove("isAdmin");
await account.SaveAsync();
var customData = await account.GetCustomDataAsync();
customData["isAdmin"].ShouldBe(null);
await this.dataStore.RequestExecutor.Received(1).ExecuteAsync(
Arg.Is <IHttpRequest>(x => x.Method == HttpMethod.Get),
Arg.Any <CancellationToken>());
}
public CancelApprenticeshipSteps(TestContext testContext) : base(testContext)
{
_testContext = testContext;
_testData = _testContext.TestDataStore;
_hashingService = _testContext.HashingService;
_data = new TestData.Account.WithPreviousApprenticeshipIncentiveForFirstLegalEntity();
}
public void Instantiated_resources_contain_reference_to_client()
{
var fakeClient = Substitute.For <IClient>();
var dataStore = TestDataStore.Create(client: fakeClient);
var account = dataStore.Instantiate <IAccount>();
account.Client.ShouldBe(fakeClient);
}
public void GetValue_returns_token_value()
{
var dataStore = TestDataStore.Create();
var href = "https://api.foobar.com/v1/applications/WpM9nyZ2TbaEzfbRvLk9KA/passwordResetTokens/my-token-value-here";
var passwordResetToken = dataStore.InstantiateWithHref <IPasswordResetToken>(href);
passwordResetToken.GetValue().ShouldBe("my-token-value-here");
}
public void SetupData()
{
ObjectFactory.Initialize(x =>
{
x.For <ILogging>().Use <TraceLogger>();
x.For <IConfiguration>().Use <MockConfig>();
x.For <IDataStore>().Use <TestDataStore>();
});
TestDataStore.Reset();
}
public async Task Default_headers_are_applied_to_all_requests()
{
var dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Account).Object);
var account = await dataStore.GetResourceAsync <IAccount>("/account", CancellationToken.None);
// Verify the default headers
await dataStore.RequestExecutor.Received().ExecuteAsync(
Arg.Is <IHttpRequest>(request =>
request.Headers.Accept == "application/json"),
Arg.Any <CancellationToken>());
}
public AuthenticationSteps(TestContext testContext) : base(testContext)
{
_testContext = testContext;
_testDataStore = _testContext.TestDataStore;
var hook = _testContext.Hooks.SingleOrDefault(h => h is Hook<AuthorizationHandlerContext>) as Hook<AuthorizationHandlerContext>;
hook.OnProcessed = (c) => {
if (_authContext == null)
{
_authContext = c;
}
};
}
public void GetTest_NotFound()
{
TestDataStore testDataStore = new TestDataStore();
testDataStore.GetFunction = (id) => {
return(Task.FromResult <ISponsor>(null));
};
SponsorController ControllerToTest = new SponsorController(testDataStore);
HttpResponseMessage Actual = ControllerToTest.Get(1).Result;
Assert.IsNotNull(Actual);
Assert.AreEqual(HttpStatusCode.NotFound, Actual.StatusCode);
}
public void GetAllTest()
{
IList <ISponsor> Expected = new List <ISponsor>(2);
Expected.Add(new TestSponsor {
Id = 1,
DisplayName = "Test Sponsor",
LogoLarge = "Logo Large",
LogoSmall = "Logo Small",
Website = "Test Website",
Level = new TestSponsorLevel {
Id = 1,
DisplayName = "Test Sponsor Level",
DisplayOrder = 1,
DisplayInEmails = false,
DisplayInSidebar = false
},
EventId = DateTime.Now.Year
});
Expected.Add(new TestSponsor {
Id = 2,
DisplayName = "Test Sponsor 2",
LogoLarge = "Logo Large 2",
LogoSmall = "Logo Small 2",
Website = "Test Website 2",
Level = new TestSponsorLevel {
Id = 1,
DisplayName = "Test Sponsor Level",
DisplayOrder = 1,
DisplayInEmails = false,
DisplayInSidebar = false
},
EventId = DateTime.Now.Year
});
TestDataStore testDataStore = new TestDataStore();
testDataStore.GetAllFunction = () => {
return(Task.FromResult <IList <ISponsor> >(Expected));
};
SponsorController ControllerToTest = new SponsorController(testDataStore);
HttpResponseMessage Actual = ControllerToTest.Get().Result;
Assert.IsNotNull(Actual);
Assert.AreEqual(HttpStatusCode.OK, Actual.StatusCode);
AssertSponorsAreEqual(Expected[0], Newtonsoft.Json.JsonConvert.DeserializeObject <List <Common.Sponsor> >(Actual.Content.ReadAsStringAsync().Result)[0]);
AssertSponorsAreEqual(Expected[1], Newtonsoft.Json.JsonConvert.DeserializeObject <List <Common.Sponsor> >(Actual.Content.ReadAsStringAsync().Result)[1]);
}
private static IInternalDataStore GetFakeDataStore()
{
var fakeApiKey = ClientApiKeys.Builder()
.SetId("fake_api_key")
.SetSecret("fake_secret")
.Build();
var stubClient = Clients.Builder()
.SetApiKey(fakeApiKey)
.Build();
var fakeDataStore = TestDataStore.Create(
requestExecutor: new StubRequestExecutor(FakeJson.Application, fakeApiKey).Object,
client: stubClient);
return(fakeDataStore);
}
public void Init()
{
//manually set up the dataStore
dataStore = new TestDataStore();
tokenInfoObj = new OAuth2TokenInfo()
{
token = tokenResponseObj,
tokenString = tokenStringString
};
tokenResponseObj = new TokenResponse()
{
AccessToken = accessTokenString
};
clientSecretsObj = new ClientSecrets()
{
ClientId = clientIdString, ClientSecret = clientSecretString
};
domainUserObj = new OAuth2DomainUser()
{
clientSecrets = clientSecretsObj, domain = domainNameString, userName = userNameString
};
domainUserObj.tokenAndScopesByApi.Add(apiString, tokenInfoObj);
domainObj = new OAuth2Domain()
{
defaultUser = userNameString
};
domainObj.users.Add(userNameString, domainUserObj);
var internalInfo = new OAuth2Info()
{
defaultDomain = domainNameString, defaultClientSecrets = clientSecretsObj
};
internalInfo.domains.Add(domainNameString, domainObj);
dataStore.internalInfo = internalInfo;
consumer = new OAuth2InfoConsumer(dataStore);
}
public async Task Trace_log_is_sent_to_logger()
{
var fakeLog = new List <LogEntry>();
var stubLogger = Substitute.For <ILogger>();
stubLogger.When(x => x.Log(Arg.Any <LogEntry>())).Do(call =>
{
fakeLog.Add(call.Arg <LogEntry>());
});
var dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Account).Object, logger: stubLogger);
var account = await dataStore.GetResourceAsync <IAccount>("account", CancellationToken.None);
await account.DeleteAsync();
fakeLog.Count.ShouldBeGreaterThanOrEqualTo(2);
}
public async Task When_getting_account()
{
var dataStore = TestDataStore.Create(new StubRequestExecutor(FakeJson.Account).Object);
var accountResult = dataStore.InstantiateWithData <IAccountResult>(
new Dictionary <string, object>()
{
["account"] = new LinkProperty("https://foo.bar/account1")
});
var account = await accountResult.GetAccountAsync();
account.FullName.ShouldBe("Han Solo");
await dataStore.RequestExecutor.Received().ExecuteAsync(
Arg.Is <IHttpRequest>(x => x.CanonicalUri.ToString() == "https://foo.bar/account1"),
Arg.Any <CancellationToken>());
}
public void GetAllTest_NotFound()
{
TestDataStore testDataStore = new TestDataStore();
testDataStore.GetAllFunction = () => {
return(Task.FromResult <IList <ISponsor> >(new List <ISponsor>()));
};
SponsorController ControllerToTest = new SponsorController(testDataStore);
HttpResponseMessage Actual = ControllerToTest.Get().Result;
Assert.IsNotNull(Actual);
Assert.AreEqual(HttpStatusCode.OK, Actual.StatusCode);
IList <Common.Sponsor> ReturnedList = Newtonsoft.Json.JsonConvert.DeserializeObject <List <Common.Sponsor> >(Actual.Content.ReadAsStringAsync().Result);
Assert.AreEqual(0, ReturnedList.Count);
}
