misc-deps
/
inth-oauth2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove mock tests

This commit is contained in:
Curtis McEnroe 2017-08-23 15:43:21 -04:00
parent aae91e1481
commit ae94fb2169
No known key found for this signature in database
GPG Key ID: CEA2F97ADCFCD77C
7 changed files with 0 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

191
tests/mock.rs
View File

@ -1,191 +0,0 @@
extern crate chrono;
extern crate hyper;
extern crate inth_oauth2;
#[macro_use]
extern crate yup_hyper_mock;
use chrono::{Utc, Duration};
use inth_oauth2::{Client, ClientError, Token, Lifetime};
use inth_oauth2::error::OAuth2ErrorCode;
mod provider {
use inth_oauth2::token::{Bearer, Static, Expiring, Refresh};
use inth_oauth2::provider::Provider;
pub struct BearerStatic;
impl Provider for BearerStatic {
type Lifetime = Static;
type Token = Bearer<Static>;
fn auth_uri(&self) -> &str { "https://example.com/oauth/auth" }
fn token_uri(&self) -> &str { "https://example.com/oauth/token" }
}
pub struct BearerExpiring;
impl Provider for BearerExpiring {
type Lifetime = Expiring;
type Token = Bearer<Expiring>;
fn auth_uri(&self) -> &str { "https://example.com/oauth/auth" }
fn token_uri(&self) -> &str { "https://example.com/oauth/token" }
}
pub struct BearerRefresh;
impl Provider for BearerRefresh {
type Lifetime = Refresh;
type Token = Bearer<Refresh>;
fn auth_uri(&self) -> &str { "https://example.com/oauth/auth" }
fn token_uri(&self) -> &str { "https://example.com/oauth/token" }
}
}
mod connector {
use hyper;
mock_connector_in_order!(BearerStatic {
include_str!("response/request_token_bearer_static.http")
});
mock_connector_in_order!(BearerExpiring {
include_str!("response/request_token_bearer_expiring.http")
});
mock_connector_in_order!(BearerRefresh {
include_str!("response/request_token_bearer_refresh.http")
include_str!("response/refresh_token_bearer_full.http")
});
mock_connector_in_order!(BearerRefreshPartial {
include_str!("response/request_token_bearer_refresh.http")
include_str!("response/refresh_token_bearer_partial.http")
});
mock_connector_in_order!(InvalidRequest {
include_str!("response/invalid_request.http")
});
mock_connector_in_order!(RefreshInvalidRequest {
include_str!("response/request_token_bearer_refresh.http")
include_str!("response/invalid_request.http")
});
}
macro_rules! mock_client {
($p:path, $c:ty) => {
(Client::new(
$p,
String::from("client_id"),
String::from("client_secret"),
None,
),
hyper::Client::with_connector(<$c>::default()))
}
}
#[test]
fn request_token_bearer_static_success() {
let (client, http_client) = mock_client!(provider::BearerStatic, connector::BearerStatic);
let token = client.request_token(&http_client, "code").unwrap();
assert_eq!("aaaaaaaa", token.access_token());
assert_eq!(Some("example"), token.scope());
}
#[test]
fn request_token_bearer_expiring_success() {
let (client, http_client) = mock_client!(provider::BearerExpiring, connector::BearerExpiring);
let token = client.request_token(&http_client, "code").unwrap();
assert_eq!("aaaaaaaa", token.access_token());
assert_eq!(Some("example"), token.scope());
assert_eq!(false, token.lifetime().expired());
assert!(token.lifetime().expires() > &Utc::now());
assert!(token.lifetime().expires() <= &(Utc::now() + Duration::seconds(3600)));
}
#[test]
fn request_token_bearer_refresh_success() {
let (client, http_client) = mock_client!(provider::BearerRefresh, connector::BearerRefresh);
let token = client.request_token(&http_client, "code").unwrap();
assert_eq!("aaaaaaaa", token.access_token());
assert_eq!(Some("example"), token.scope());
assert_eq!("bbbbbbbb", token.lifetime().refresh_token());
assert_eq!(false, token.lifetime().expired());
assert!(token.lifetime().expires() > &Utc::now());
assert!(token.lifetime().expires() <= &(Utc::now() + Duration::seconds(3600)));
}
#[test]
fn refresh_token_bearer_full() {
let (client, http_client) = mock_client!(provider::BearerRefresh, connector::BearerRefresh);
let token = client.request_token(&http_client, "code").unwrap();
let token = client.refresh_token(&http_client, token, None).unwrap();
assert_eq!("cccccccc", token.access_token());
assert_eq!(Some("example"), token.scope());
assert_eq!("dddddddd", token.lifetime().refresh_token());
assert_eq!(false, token.lifetime().expired());
assert!(token.lifetime().expires() > &Utc::now());
assert!(token.lifetime().expires() <= &(Utc::now() + Duration::seconds(3600)));
}
#[test]
fn refresh_token_bearer_partial() {
let (client, http_client) = mock_client!(provider::BearerRefresh, connector::BearerRefreshPartial);
let token = client.request_token(&http_client, "code").unwrap();
let token = client.refresh_token(&http_client, token, None).unwrap();
assert_eq!("cccccccc", token.access_token());
assert_eq!(Some("example"), token.scope());
assert_eq!("bbbbbbbb", token.lifetime().refresh_token());
assert_eq!(false, token.lifetime().expired());
assert!(token.lifetime().expires() > &Utc::now());
assert!(token.lifetime().expires() <= &(Utc::now() + Duration::seconds(3600)));
}
#[test]
fn request_token_bearer_static_wrong_lifetime() {
let (client, http_client) = mock_client!(provider::BearerStatic, connector::BearerRefresh);
let err = client.request_token(&http_client, "code").unwrap_err();
assert!(match err { ClientError::Parse(..) => true, _ => false });
}
#[test]
fn request_token_bearer_expiring_wrong_lifetime() {
let (client, http_client) = mock_client!(provider::BearerExpiring, connector::BearerRefresh);
let err = client.request_token(&http_client, "code").unwrap_err();
assert!(match err { ClientError::Parse(..) => true, _ => false });
}
#[test]
fn request_token_bearer_refresh_wrong_lifetime() {
let (client, http_client) = mock_client!(provider::BearerRefresh, connector::BearerStatic);
let err = client.request_token(&http_client, "code").unwrap_err();
assert!(match err { ClientError::Parse(..) => true, _ => false });
}
#[test]
fn request_token_invalid_request() {
let (client, http_client) = mock_client!(provider::BearerStatic, connector::InvalidRequest);
let err = client.request_token(&http_client, "code").unwrap_err();
assert!(match err {
ClientError::OAuth2(err) => {
assert_eq!(OAuth2ErrorCode::InvalidRequest, err.code);
assert_eq!("example", err.description.unwrap());
assert_eq!("https://example.com/error", err.uri.unwrap());
true
},
_ => false,
});
}
#[test]
fn refresh_token_invalid_request() {
let (client, http_client) = mock_client!(provider::BearerRefresh, connector::RefreshInvalidRequest);
let token = client.request_token(&http_client, "code").unwrap();
let err = client.refresh_token(&http_client, token, None).unwrap_err();
assert!(match err {
ClientError::OAuth2(err) => {
assert_eq!(OAuth2ErrorCode::InvalidRequest, err.code);
assert_eq!("example", err.description.unwrap());
assert_eq!("https://example.com/error", err.uri.unwrap());
true
},
_ => false,
});
}

10
tests/response/invalid_request.http
View File

@ -1,10 +0,0 @@
HTTP/1.1 400 Bad Request
Content-Type: application/json;charset=UTF-8
Cache-Control: no-store
Pragma: no-cache
{
"error":"invalid_request",
"error_description":"example",
"error_uri":"https://example.com/error"
}

12
tests/response/refresh_token_bearer_full.http
View File

@ -1,12 +0,0 @@
HTTP/1.1 200 OK
Content-Type: application/json;charset=UTF-8
Cache-Control: no-store
Pragma: no-cache
{
"access_token":"cccccccc",
"token_type":"bearer",
"expires_in":3600,
"refresh_token":"dddddddd",
"scope":"example"
}

11
tests/response/refresh_token_bearer_partial.http
View File

@ -1,11 +0,0 @@
HTTP/1.1 200 OK
Content-Type: application/json;charset=UTF-8
Cache-Control: no-store
Pragma: no-cache
{
"access_token":"cccccccc",
"token_type":"bearer",
"expires_in":3600,
"scope":"example"
}

11
tests/response/request_token_bearer_expiring.http
View File

@ -1,11 +0,0 @@
HTTP/1.1 200 OK
Content-Type: application/json;charset=UTF-8
Cache-Control: no-store
Pragma: no-cache
{
"access_token":"aaaaaaaa",
"token_type":"bearer",
"expires_in":3600,
"scope":"example"
}

12
tests/response/request_token_bearer_refresh.http
View File

@ -1,12 +0,0 @@
HTTP/1.1 200 OK
Content-Type: application/json;charset=UTF-8
Cache-Control: no-store
Pragma: no-cache
{
"access_token":"aaaaaaaa",
"token_type":"bearer",
"expires_in":3600,
"refresh_token":"bbbbbbbb",
"scope":"example"
}

10
tests/response/request_token_bearer_static.http
View File

@ -1,10 +0,0 @@
HTTP/1.1 200 OK
Content-Type: application/json;charset=UTF-8
Cache-Control: no-store
Pragma: no-cache
{
"access_token":"aaaaaaaa",
"token_type":"bearer",
"scope":"example"
}