private static IDataStore PrepareIDataStore(OktaClientConfiguration apiClientConfiguration)
{
OktaClientConfiguration oktaClientConfiguration = PrepareOktaClientConfiguration(apiClientConfiguration);
Microsoft.Extensions.Logging.ILogger logger = Microsoft.Extensions.Logging.Abstractions.NullLogger.Instance;
HttpClient httpClient = DefaultHttpClient.Create(
oktaClientConfiguration.ConnectionTimeout,
oktaClientConfiguration.Proxy,
logger);
AbstractResourceTypeResolverFactory resourceTypeResolverFactory = null;
BaseOktaClient baseOktaClient = new BaseOktaClient();
dynamic resourceFactory = new ResourceFactory(baseOktaClient, logger, resourceTypeResolverFactory);
var requestExecutor = new DefaultRequestExecutor(oktaClientConfiguration, httpClient, logger);
UserAgentBuilder userAgentBuilder = new UserAgentBuilder(
"custom", typeof(CustomAuthnClient).GetTypeInfo().Assembly.GetName().Version);
IDataStore dataStore = new DefaultDataStore(
requestExecutor,
new DefaultSerializer(),
resourceFactory,
logger,
userAgentBuilder);
return(dataStore);
}
public async Task DoNotOvewriteUserAgentWhenProvided()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.GetAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null, null), NullLogger.Instance, new UserAgentBuilder("okta-sdk-dotnet", UserAgentHelper.SdkVersion));
var request = new HttpRequest {
Uri = "https://foo.dev"
};
request.Headers["User-Agent"] = "foo bar baz";
await dataStore.GetAsync <TestResource>(request, new RequestContext(), CancellationToken.None);
// Assert that the request sent to the RequestExecutor included the User-Agent header
await mockRequestExecutor.Received().GetAsync(
"https://foo.dev",
Arg.Is <IEnumerable <KeyValuePair <string, string> > >(
headers => headers.Any(kvp => kvp.Key == "User-Agent" && kvp.Value == "foo bar baz")),
CancellationToken.None);
}
public async Task AddContextXForwardedToRequests()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.GetAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var request = new HttpRequest {
Uri = "https://foo.dev"
};
var requestContext = new RequestContext
{
XForwardedFor = "myapp.com",
XForwardedPort = "1234",
XForwardedProto = "https",
};
await dataStore.GetAsync <TestResource>(request, requestContext, CancellationToken.None);
// Assert that the request sent to the RequestExecutor included the User-Agent header
await mockRequestExecutor.Received().GetAsync(
"https://foo.dev",
Arg.Is <IEnumerable <KeyValuePair <string, string> > >(headers =>
headers.Any(kvp => kvp.Key == "X-Forwarded-For" && kvp.Value == "myapp.com") &&
headers.Any(kvp => kvp.Key == "X-Forwarded-Port" && kvp.Value == "1234") &&
headers.Any(kvp => kvp.Key == "X-Forwarded-Proto" && kvp.Value == "https")),
CancellationToken.None);
}
public async Task SetPayloadHandlerContentTypeOnPostAsync()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.PostAsync(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var testPayloadHandler = new TestPayloadHandler();
PayloadHandler.TryRegister(testPayloadHandler);
var request = new TestHttpRequest();
request.ContentType.Should().Be("application/json");
request.GetPayloadHandler().ContentType.Should().Be("application/json");
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
await dataStore.PostAsync <TestResource>(request, new RequestContext { ContentType = "foo" }, CancellationToken.None);
request.ContentType.Should().Be("foo");
request.GetPayloadHandler().ContentType.Should().Be("foo");
}
public async Task ThrowApiExceptionWhenContentTypeIsJsonAndErrorDescriptionIsNotPresent()
{
var response = @"
{
""errorCode"": ""E0000022"",
""errorSummary"": ""The endpoint does not support the provided HTTP method"",
""errorLink"": ""E0000022"",
""errorId"": ""oaey24IvG9nTJCx8gqGeh8j4Q"",
""errorCauses"": []
}";
var mockResponseHeaders = new List <KeyValuePair <string, IEnumerable <string> > >();
mockResponseHeaders.Add(new KeyValuePair <string, IEnumerable <string> >("content-type", new List <string>()
{
"Accept: application/json"
}));
var mockRequestExecutor = new MockedStringRequestExecutor(response, statusCode: 400, mockResponseHeaders);
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null, null), NullLogger.Instance, new UserAgentBuilder("test", UserAgentHelper.SdkVersion));
var request = new HttpRequest {
Uri = "https://foo.dev"
};
OktaException exception = await Assert.ThrowsAsync <OktaApiException>(
() => dataStore.PostAsync <TestResource>(request, new RequestContext(), CancellationToken.None));
exception.Message.Should().Contain("The endpoint does not support the provided HTTP method");
}
public async Task GetAllItemsWithManualEnumeration()
{
var mockRequestExecutor = new MockedCollectionRequestExecutor <IUser>(pageSize: 2, items: TestUsers);
var dataStore = new DefaultDataStore(
mockRequestExecutor,
new DefaultSerializer(),
new ResourceFactory(null, null),
NullLogger.Instance);
var collection = new CollectionClient <User>(
dataStore,
new HttpRequest {
Uri = "http://mock-collection.dev"
},
new RequestContext());
var items = new List <IUser>();
var enumerator = collection.GetPagedEnumerator();
while (await enumerator.MoveNextAsync())
{
items.AddRange(enumerator.CurrentPage.Items);
}
items.Count.Should().Be(5);
}
public async Task GetCollection()
{
var testItems = new[]
{
new TestResource {
Foo = "foo1"
},
new TestResource {
Foo = "foo2", Bar = true
},
new TestResource {
Foo = "foo3", Bar = false
},
};
var mockRequestExecutor = new MockedCollectionRequestExecutor <TestResource>(pageSize: 2, items: testItems);
var dataStore = new DefaultDataStore(
mockRequestExecutor,
new DefaultSerializer(),
new ResourceFactory(null, null),
NullLogger.Instance);
var client = new TestableOktaClient(dataStore);
var items = await client.GetCollection <TestResource>("https://stuff").ToArray();
items.Count().Should().Be(3);
items.ElementAt(0).Foo.Should().Be("foo1");
items.ElementAt(0).Bar.Should().BeNull();
items.ElementAt(1).Foo.Should().Be("foo2");
items.ElementAt(1).Bar.Should().Be(true);
items.ElementAt(2).Foo.Should().Be("foo3");
items.ElementAt(2).Bar.Should().Be(false);
}
public async Task ThrowOAuthExceptionWhenErrorDescriptionIsPresent()
{
var response = @"
{
""error"": ""invalid_grant"",
""error_description"": ""The interaction code is invalid or has expired.""
}";
var mockResponseHeaders = new List <KeyValuePair <string, IEnumerable <string> > >();
mockResponseHeaders.Add(new KeyValuePair <string, IEnumerable <string> >("content-type", new List <string>()
{
"Accept: application/json"
}));
var mockRequestExecutor = new MockedStringRequestExecutor(response, statusCode: 400, mockResponseHeaders);
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null, null), NullLogger.Instance, new UserAgentBuilder("test", UserAgentHelper.SdkVersion));
var request = new HttpRequest {
Uri = "https://foo.dev"
};
OktaException exception = await Assert.ThrowsAsync <OktaOAuthException>(
() => dataStore.PostAsync <TestResource>(request, new RequestContext(), CancellationToken.None));
exception.Message.Should().Contain("The interaction code is invalid or has expired.");
}
public async Task DelegateAValidPostToRequestExecutorGivenACreateSessionRequest()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.PostAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <string>(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var createSessionRequest = new CreateSessionRequest()
{
SessionToken = "foo",
};
var client = new TestableOktaClient(mockRequestExecutor);
await client.Sessions.CreateSessionAsync(createSessionRequest);
await mockRequestExecutor.Received().PostAsync(
"/api/v1/sessions",
Arg.Any <IEnumerable <KeyValuePair <string, string> > >(),
"{\"sessionToken\":\"foo\"}",
CancellationToken.None);
}
public async Task AddContextUserAgentToRequests()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.GetAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var request = new HttpRequest {
Uri = "https://foo.dev"
};
var requestContext = new RequestContext {
UserAgent = "sdk-vanillajs/1.1"
};
await dataStore.GetAsync <TestResource>(request, requestContext, CancellationToken.None);
// Assert that the request sent to the RequestExecutor included the User-Agent header
await mockRequestExecutor.Received().GetAsync(
"https://foo.dev",
Arg.Is <IEnumerable <KeyValuePair <string, string> > >(
headers => headers.Any(kvp => kvp.Key == "User-Agent" && kvp.Value.StartsWith("sdk-vanillajs/1.1 okta-sdk-dotnet/"))),
CancellationToken.None);
}
public async Task DeserializeObjectUsingCustomSettings()
{
var mockResponse = @"{
""id"":""foo"",
""status"":""ACTIVE"",
""created"":""2019-05-09T15:37:44.000Z"",
""activated"":""2019-05-09T15:37:44.000Z"",
""statusChanged"":""2019-05-09T18:29:29.000Z"",
""lastLogin"":""2019-08-09T07:49:51.000Z"",
""lastUpdated"":""2019-08-09T17:20:28.000Z"",
""passwordChanged"":""2019-05-09T18:29:29.000Z"",
""profile"":{
""firstName"":""John"",
""lastName"":""Coder"",
""mobilePhone"":null,
""userType"":""test"",
""login"":""*****@*****.**"",
""startDate"":""2016-06-07T00:00:00.000"",
""email"":""*****@*****.**"",
""employeeNumber"":""000012345"",
""type"":""null"",
},
}";
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.GetAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200, Payload = mockResponse
});
// DateParseHandling.None: Date formatted strings are not parsed to a date type and are read as strings.
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(new JsonSerializerSettings()
{
DateParseHandling = DateParseHandling.None
}), new ResourceFactory(null, null), NullLogger.Instance);
var request = new HttpRequest {
Uri = "https://foo.dev", Payload = new { }
};
var response = await dataStore.GetAsync <User>(request, new RequestContext(), CancellationToken.None);
response.Payload.Profile["startDate"].GetType().Should().Be(typeof(string));
response.Payload.Profile["startDate"].Should().Be("2016-06-07T00:00:00.000");
// DateParseHandling.DateTimeOffset: Date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed to DateTimeOffset.
dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(new JsonSerializerSettings()
{
DateParseHandling = DateParseHandling.DateTimeOffset
}), new ResourceFactory(null, null), NullLogger.Instance);
response = await dataStore.GetAsync <User>(request, new RequestContext(), CancellationToken.None);
response.Payload.Profile["startDate"].GetType().Should().Be(typeof(DateTimeOffset));
var dateTimeOffset = DateTimeOffset.Parse("2016-06-07T00:00:00.000");
response.Payload.Profile["startDate"].Should().Be(dateTimeOffset);
}
public async Task ThrowForNullExecutorResponseDuringGetArray()
{
// If the RequestExecutor returns a null HttpResponse, throw an informative exception.
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var request = new HttpRequest {
Uri = "https://foo.dev"
};
await Assert.ThrowsAsync <InvalidOperationException>(
() => dataStore.GetArrayAsync <TestResource>(request, new RequestContext(), CancellationToken.None));
}
public async Task HandleEmptyPayloadDuringGet()
{
// If the API returns a null or empty payload, it shouldn't cause an error.
var requestExecutor = new MockedStringRequestExecutor(string.Empty, statusCode: 200);
var dataStore = new DefaultDataStore(requestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var request = new HttpRequest {
Uri = "https://foo.dev"
};
var response = await dataStore.GetAsync <TestResource>(request, new RequestContext(), CancellationToken.None);
response.StatusCode.Should().Be(200);
response.Payload.Should().NotBeNull();
response.Payload.Foo.Should().BeNullOrEmpty();
}
public async Task DelegateAValidPostToRequestExecutorWhenRefreshingSession()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.PostAsync(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var client = new TestableOktaClient(mockRequestExecutor);
await client.Sessions.RefreshSessionAsync("foo");
await mockRequestExecutor.Received().PostAsync(
Arg.Is <HttpRequest>(request => request.Uri.Equals("/api/v1/sessions/foo/lifecycle/refresh")), CancellationToken.None);
}
public async Task DeserializeDateCustomPropertyAsString()
{
var mockResponse = @"{
""id"":""foo"",
""status"":""ACTIVE"",
""created"":""2019-05-09T15:37:44.000Z"",
""activated"":""2019-05-09T15:37:44.000Z"",
""statusChanged"":""2019-05-09T18:29:29.000Z"",
""lastLogin"":""2019-08-09T07:49:51.000Z"",
""lastUpdated"":""2019-08-09T17:20:28.000Z"",
""passwordChanged"":""2019-05-09T18:29:29.000Z"",
""profile"":{
""firstName"":""John"",
""lastName"":""Coder"",
""mobilePhone"":null,
""userType"":""test"",
""login"":""*****@*****.**"",
""startDate"":""2016-06-07T00:00:00.000"",
""email"":""*****@*****.**"",
""employeeNumber"":""000012345"",
""type"":""null"",
},
}";
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.GetAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200, Payload = mockResponse
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var request = new HttpRequest {
Uri = "https://foo.dev", Payload = new { }
};
var response = await dataStore.GetAsync <User>(request, new RequestContext(), CancellationToken.None);
response.Payload.Profile["startDate"].GetType().Should().Be(typeof(string));
response.Payload.Profile["startDate"].Should().Be("2016-06-07T00:00:00.000");
}
public async Task GetAllItems()
{
var mockRequestExecutor = new MockedCollectionRequestExecutor <IUser>(pageSize: 2, items: TestUsers);
var dataStore = new DefaultDataStore(
mockRequestExecutor,
new DefaultSerializer(),
new ResourceFactory(null, null),
NullLogger.Instance);
var collection = new CollectionClient <User>(
dataStore,
new HttpRequest {
Uri = "http://mock-collection.dev"
},
new RequestContext());
var all = await collection.ToArrayAsync();
all.Length.Should().Be(5);
}
public async Task CountCollectionAsynchronously()
{
var mockRequestExecutor = new MockedCollectionRequestExecutor <IUser>(pageSize: 2, items: TestUsers);
var dataStore = new DefaultDataStore(
mockRequestExecutor,
new DefaultSerializer(),
new ResourceFactory(null, null),
NullLogger.Instance);
var collection = new CollectionClient <User>(
dataStore,
new HttpRequest {
Uri = "http://mock-collection.dev"
},
new RequestContext());
var count = await collection.CountAsync();
count.Should().Be(5);
}
public async Task FilterCollectionAsynchronously()
{
var mockRequestExecutor = new MockedCollectionRequestExecutor <IUser>(pageSize: 2, items: TestUsers);
var dataStore = new DefaultDataStore(
mockRequestExecutor,
new DefaultSerializer(),
new ResourceFactory(null, null),
NullLogger.Instance);
var collection = new CollectionClient <User>(
dataStore,
new HttpRequest {
Uri = "http://mock-collection.dev"
},
new RequestContext());
var activeUsers = await collection.Where(x => x.Status == "ACTIVE").ToListAsync();
activeUsers.Count.Should().Be(2);
}
public async Task CallRequestExecutorPostAsyncOnPostAsync()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.PostAsync(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var defaultDataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var testRequest = new HttpRequest();
var testRequestContext = new RequestContext();
await defaultDataStore.PostAsync <Resource>(testRequest, testRequestContext, CancellationToken.None);
await mockRequestExecutor
.Received(1)
.PostAsync(Arg.Is(testRequest), Arg.Any <CancellationToken>());
}
public async Task DelegateAValidDeleteToRequestExecutorWhenEndingSession()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.DeleteAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var client = new TestableOktaClient(mockRequestExecutor);
await client.Sessions.EndSessionAsync("foo");
await mockRequestExecutor.Received().DeleteAsync(
"/api/v1/sessions/foo",
Arg.Any <IEnumerable <KeyValuePair <string, string> > >(),
CancellationToken.None);
}
private static (IRequestExecutor MockRequestExecutor, IDataStore DataStore) SetUpMocks()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.GetAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
mockRequestExecutor
.PostAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <string>(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
mockRequestExecutor
.PutAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <string>(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
mockRequestExecutor
.DeleteAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(
mockRequestExecutor,
new DefaultSerializer(),
new ResourceFactory(null, null),
NullLogger.Instance);
return(mockRequestExecutor, dataStore);
}
public async Task RetrieveQuestionFactorAsInterface()
{
var mockRequestExecutor = new MockedCollectionRequestExecutor <IFactor>(pageSize: 2, items: AllFactors);
var dataStore = new DefaultDataStore(
mockRequestExecutor,
new DefaultSerializer(),
new ResourceFactory(null, null),
NullLogger.Instance);
var collection = new CollectionClient <Factor>(
dataStore,
new HttpRequest {
Uri = "http://mock-collection.dev"
},
new RequestContext());
var retrievedItems = await collection.ToArray();
var securityQuestionFactor = retrievedItems.OfType <ISecurityQuestionFactor>().FirstOrDefault();
securityQuestionFactor.Should().NotBeNull();
}
public async Task PostWithNullBody()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.PostAsync(Arg.Any <HttpRequest>(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var request = new HttpRequest {
Uri = "https://foo.dev"
}; // Payload = null
await dataStore.PostAsync <TestResource>(request, new RequestContext(), CancellationToken.None);
await mockRequestExecutor.Received().PostAsync(
request: Arg.Is <HttpRequest>(httpRequest => httpRequest.Uri.Equals("https://foo.dev")),
cancellationToken: CancellationToken.None);
}
public async Task ThrowIonApiExceptionWhenContentTypeIsJsonIon()
{
var response = @"{
""version"": ""1.0.0"",
""messages"": {
""type"": ""array"",
""value"": [
{
""message"": ""'stateHandle' is required."",
""i18n"": {
""key"": ""api.error.field_required"",
""params"": [
""stateHandle""
]
},
""class"": ""ERROR""
}
]
}
}";
var mockResponseHeaders = new List <KeyValuePair <string, IEnumerable <string> > >();
mockResponseHeaders.Add(new KeyValuePair <string, IEnumerable <string> >("content-type", new List <string>()
{
"Accept: application/ion+json; okta-version=1.0.0"
}));
var mockRequestExecutor = new MockedStringRequestExecutor(response, statusCode: 400, mockResponseHeaders);
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null, null), NullLogger.Instance, new UserAgentBuilder("test", UserAgentHelper.SdkVersion));
var request = new HttpRequest {
Uri = "https://foo.dev"
};
await Assert.ThrowsAsync <OktaIonApiException>(
() => dataStore.PostAsync <TestResource>(request, new RequestContext(), CancellationToken.None));
}
public async Task NotSendCloseConnectionHeaderWhenUsingTheDefaultClient()
{
var testOktaClient = TestClient.Create();
var configuration = testOktaClient.Configuration;
var httpClient = DefaultHttpClient.Create(configuration.ConnectionTimeout, configuration.Proxy, NullLogger.Instance);
var requestExecutor = new DefaultRequestExecutor(configuration, httpClient, NullLogger.Instance);
var resourceFactory = new ResourceFactory(testOktaClient, NullLogger.Instance);
var dataStore = new DefaultDataStore(requestExecutor, new DefaultSerializer(), resourceFactory, NullLogger.Instance);
var response = await dataStore.GetAsync <Resource>(
new HttpRequest
{
// Endpoint that returns a chunked response
Uri = $"/api/v1/meta/schemas/user/default",
},
null,
default(CancellationToken));
var connectionHeader = response.Headers.FirstOrDefault(x => x.Key.Equals("connection", StringComparison.OrdinalIgnoreCase));
connectionHeader.Value?.Any(s => s.Equals("close", StringComparison.OrdinalIgnoreCase)).Should().BeFalse();
}
public async Task DelegateGetToRequestExecutor()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.GetAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var request = new HttpRequest {
Uri = "https://foo.dev"
};
await dataStore.GetAsync <TestResource>(request, new RequestContext(), CancellationToken.None);
await mockRequestExecutor.Received().GetAsync(
"https://foo.dev",
Arg.Any <IEnumerable <KeyValuePair <string, string> > >(),
CancellationToken.None);
}
public async Task PostWithNullBody()
{
var mockRequestExecutor = Substitute.For <IRequestExecutor>();
mockRequestExecutor
.PostAsync(Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, string> > >(), Arg.Any <string>(), Arg.Any <CancellationToken>())
.Returns(new HttpResponse <string>()
{
StatusCode = 200
});
var dataStore = new DefaultDataStore(mockRequestExecutor, new DefaultSerializer(), new ResourceFactory(null, null), NullLogger.Instance);
var request = new HttpRequest {
Uri = "https://foo.dev"
}; // Payload = null
await dataStore.PostAsync <TestResource>(request, new RequestContext(), CancellationToken.None);
await mockRequestExecutor.Received().PostAsync(
href: "https://foo.dev",
headers: Arg.Any <IEnumerable <KeyValuePair <string, string> > >(),
body: null,
cancellationToken: CancellationToken.None);
}
