public virtual void RefreshTokenIfNecessary(bool pHasRefresh, int pAddSeconds,
string pApiPath, bool pExpectRefresh)
{
string refresh = (pHasRefresh ? "OldRefreshToken" : null);
DateTime expiry = DateTime.UtcNow.AddSeconds(pAddSeconds);
PersonSess.RefreshToken = refresh;
PersonSess.Expiration = expiry;
FabOauthAccess expectResult = NewFabOauthAccess();
MockOauth
.Setup(x => x.AccessTokenRefresh.Get(
refresh,
MockConfig.Object.AppSecret,
MockConfig.Object.GetOauthRedirectUri(),
SessionType.Person
))
.Returns(expectResult);
bool result = PersonSess.RefreshTokenIfNecessary(pApiPath);
Assert.AreEqual(pExpectRefresh, result, "Incorrect result.");
if (pExpectRefresh)
{
CheckSessionProperties(expectResult);
}
else
{
Assert.AreEqual(refresh, PersonSess.RefreshToken, "Incorrect RefreshToken.");
CheckExpiration(expiry);
}
}
public void RefreshTokenIfNecessary(bool pHasBearer, int pAddSeconds,
string pApiPath, bool pExpectRefresh)
{
string bearer = (pHasBearer ? "OldBearerToken" : null);
DateTime expiry = DateTime.UtcNow.AddSeconds(pAddSeconds);
AppSess.BearerToken = bearer;
AppSess.Expiration = expiry;
FabOauthAccess expectResult = NewFabOauthAccess();
SetupMockAccessToken(expectResult);
bool result = AppSess.RefreshTokenIfNecessary(pApiPath);
Assert.AreEqual(pExpectRefresh, result, "Incorrect result.");
if (pExpectRefresh)
{
CheckSessionProperties(expectResult);
}
else
{
Assert.AreEqual(bearer, AppSess.BearerToken, "Incorrect BearerToken.");
CheckExpiration(expiry);
}
}
public virtual void HandleGrantCodeRedirect()
{
const string grantCode = "GrantCode1234";
var q = new NameValueCollection();
q.Add("code", grantCode);
q.Add("state", PersonSess.SessionId);
var mockReq = new Mock <HttpRequestBase>(MockBehavior.Strict);
mockReq.SetupGet(x => x.QueryString).Returns(q);
var expectResult = NewFabOauthAccess();
MockOauth
.Setup(x => x.AccessTokenAuthCode.Get(
grantCode,
MockConfig.Object.AppSecret,
MockConfig.Object.GetOauthRedirectUri(),
SessionType.Person
))
.Returns(expectResult);
FabOauthAccess result = PersonSess.HandleGrantCodeRedirect(mockReq.Object);
Assert.AreEqual(expectResult, result, "Incorrect result.");
Assert.AreEqual(grantCode, PersonSess.GrantCode, "Incorrect GrantCode.");
}
public void CcSuccess()
{
vGrantType = OauthAccessOperation.GrantTypeCc;
var app = new App {
OauthDomains = "test|my.redirect.uri|another"
};
var mem = new Member {
VertexId = 41252325
};
var fabOa = new FabOauthAccess();
vMockTasks
.Setup(x => x.GetApp(vMockData.Object, long.Parse(vClientId), vSecret))
.Returns(app);
vMockTasks
.Setup(x => x.GetDataProvMemberByApp(vMockData.Object, long.Parse(vClientId)))
.Returns(mem);
vMockTasks
.Setup(x => x.AddAccess(vMockOpCtx.Object,
It.IsAny <CreateOauthAccessOperation>(), mem.VertexId, true))
.Returns(fabOa);
DoExecute();
Assert.AreEqual(fabOa, vExecuteResult, "Incorrect result.");
}
public void RtSuccess()
{
vGrantType = OauthAccessOperation.GrantTypeRt;
var om = new OauthMember();
om.AppId = 12344162346;
om.Member = new Member {
VertexId = 623146134
};
var fabOa = new FabOauthAccess();
vMockTasks
.Setup(x => x.GetMemberByRefresh(vMockData.Object, vRefresh))
.Returns(om);
vMockTasks
.Setup(x => x.GetApp(vMockData.Object, om.AppId, vSecret))
.Returns(new App());
vMockTasks
.Setup(x => x.AddAccess(vMockOpCtx.Object,
It.IsAny <CreateOauthAccessOperation>(), om.Member.VertexId, false))
.Returns(fabOa);
DoExecute();
Assert.AreEqual(fabOa, vExecuteResult, "Incorrect result.");
}
public void AcSuccess()
{
vGrantType = OauthAccessOperation.GrantTypeAc;
var om = new OauthMember();
om.AppId = 12344162346;
om.Member = new Member();
om.Member.VertexId = 463462346;
om.Member.OauthGrantRedirectUri = vRedirUri.ToLower();
var fabOa = new FabOauthAccess();
vMockTasks
.Setup(x => x.GetMemberByGrant(vMockData.Object, vCode))
.Returns(om);
vMockTasks
.Setup(x => x.GetApp(vMockData.Object, om.AppId, vSecret))
.Returns(new App());
vMockTasks
.Setup(x => x.AddAccess(vMockOpCtx.Object,
It.IsAny <CreateOauthAccessOperation>(), om.Member.VertexId, false))
.Returns(fabOa);
DoExecute();
Assert.AreEqual(fabOa, vExecuteResult, "Incorrect result.");
}
/*--------------------------------------------------------------------------------------------*/
protected FabOauthAccess NewFabOauthAccess()
{
var oa = new FabOauthAccess();
oa.token_type = "Bearer";
oa.access_token = "AccessToken1234";
oa.refresh_token = "RefreshToken1234";
oa.expires_in = 3600;
return(oa);
}
public void RequestAuthentication()
{
FabOauthAccess expectResult = NewFabOauthAccess();
SetupMockAccessToken(expectResult);
FabOauthAccess result = AppSess.RequestAuthentication();
Assert.AreEqual(expectResult, result, "Incorrect result.");
CheckSessionProperties(expectResult);
}
/*--------------------------------------------------------------------------------------------*/
protected void SetupMockAccessToken(FabOauthAccess pResult, Action pCallback = null)
{
IReturnsResult <IOauthService> rr = MockOauth
.Setup(x => x.AccessTokenClientCredentials.Get(
MockConfig.Object.AppId,
MockConfig.Object.AppSecret,
MockConfig.Object.GetOauthRedirectUri(),
SessionType.App
))
.Returns(pResult);
if (pCallback != null)
{
rr.Callback(pCallback);
}
}
public void Atcc()
{
var query = new Dictionary <string, string>();
query.Add("client_id", (long)SetupAppId.KinPhoGal + "");
query.Add("client_secret", SetupUsers.KinPhoGalSecret);
query.Add("redirect_uri", SetupOauth.GrantUrlGalLoc);
BrowserResponse br = Get("oauth/accessTokenClientCredentials", query);
FabOauthAccess result = AssertFabObject <FabOauthAccess>(br);
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual("bearer", result.TokenType, "Incorrect TokenType.");
NewVertexCount = 1;
NewEdgeCount = 2;
}
public void At()
{
UpdateGrant();
var query = new Dictionary <string, string>();
query.Add("grant_type", "authorization_code");
query.Add("code", vGrantCode);
query.Add("client_secret", SetupUsers.KinPhoGalSecret);
query.Add("redirect_uri", SetupOauth.GrantUrlGalLoc);
BrowserResponse br = Get("oauth/accessToken", query);
FabOauthAccess result = AssertFabObject <FabOauthAccess>(br);
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual("bearer", result.TokenType, "Incorrect TokenType.");
NewVertexCount = 1;
NewEdgeCount = 2;
}
/*--------------------------------------------------------------------------------------------*/
public ActionResult FabricRedirect()
{
FabOauthAccess result = vFab.PersonSession.HandleGrantCodeRedirect(Request);
//close the login popup if authentication was successful
if (vFab.PersonSession.IsAuthenticated)
{
Response.Write(
"<script type='text/javascript'>" +
"window.opener.location.reload();" +
"window.close();" +
"</script>"
);
Response.Write("Success!<br/><br/>" + JsonSerializer.SerializeToString(result));
return(null);
}
ViewBag.Message = JsonSerializer.SerializeToString(result);
return(View());
}
/*--------------------------------------------------------------------------------------------*/
private void CheckSuccess(FabOauthAccess pResult)
{
Assert.NotNull(pResult, "Result should be filled.");
NewVertexCount = 1;
NewEdgeCount = 2;
}
public void AddAccess(bool pClientMode, bool pHasActiveMem)
{
const long memId = 763462332;
const string code0 = "12351252sadfasdf";
const string code1 = "362343fsdfsdfasd";
const long utcNowTicks = 6423156122345252;
const long utcExpireTicks = utcNowTicks + 3600 * TimeSpan.TicksPerSecond;
var mockAuth = new Mock <IOperationAuth>(MockBehavior.Strict);
mockAuth.SetupGet(x => x.ActiveMemberId).Returns(pHasActiveMem ? 1234 : (long?)null);
if (!pHasActiveMem)
{
mockAuth.Setup(x => x.SetFabricActiveMember());
mockAuth.Setup(x => x.RemoveFabricActiveMember());
}
vMockOpCtx.SetupGet(x => x.Auth).Returns(mockAuth.Object);
var codeQueue = new Queue <string>();
codeQueue.Enqueue(code0);
codeQueue.Enqueue(code1);
var oa = new OauthAccess();
oa.Token = "6512361236134fvaslkdjfds";
oa.Refresh = "94856928345ksdljlsdkfuasd";
vMockData
.Setup(x => x.Execute(It.IsAny <IWeaverQuery>(), "OauthAccess-ClearOldTokens"))
.Returns((IDataResult)null);
vMockData
.Setup(x => x.Build(null, true, true))
.Returns(new DataAccess());
vMockOpCtx
.SetupGet(x => x.Code32)
.Returns(codeQueue.Dequeue);
vMockOpCtx
.SetupGet(x => x.UtcNow)
.Returns(new DateTime(utcNowTicks));
var mockMemCache = new Mock <IMemCache>(MockBehavior.Strict);
mockMemCache.Setup(x => x.RemoveOauthMembers(memId));
var mockCacheMan = new Mock <ICacheManager>(MockBehavior.Strict);
mockCacheMan.SetupGet(x => x.Memory).Returns(mockMemCache.Object);
vMockOpCtx.SetupGet(x => x.Cache).Returns(mockCacheMan.Object);
var mockCreOp = new Mock <CreateOauthAccessOperation>(MockBehavior.Strict);
mockCreOp
.Setup(x => x.Execute(vMockOpCtx.Object, It.IsAny <ICreateOperationBuilder>(),
It.IsAny <CreateOperationTasks>(), It.IsAny <CreateFabOauthAccess>()))
.Callback((IOperationContext opCtx, ICreateOperationBuilder build,
CreateOperationTasks tasks, CreateFabOauthAccess cre) => {
Assert.NotNull(cre, "Create should be filled.");
Assert.AreEqual(code0, cre.Token, "Incorrect Create.Token.");
Assert.AreEqual((pClientMode ? null : code1), cre.Refresh,
"Incorrect Create.Refresh.");
Assert.AreEqual(utcExpireTicks, cre.Expires, "Incorrect Create.Expires.");
Assert.AreEqual(memId, cre.AuthenticatesMemberId,
"Incorrect Create.AuthenticatesMemberId.");
})
.Returns(oa);
FabOauthAccess result = vTasks.AddAccess(
vMockOpCtx.Object, mockCreOp.Object, memId, pClientMode);
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(oa.Token, result.AccessToken, "Incorrect AccessToken.");
Assert.AreEqual(oa.Refresh, result.RefreshToken, "Incorrect RefreshToken.");
Assert.AreEqual(3600, result.ExpiresIn, "Incorrect ExpiresIn.");
Assert.AreEqual("bearer", result.TokenType, "Incorrect TokenType.");
var times = (pHasActiveMem ? Times.Never() : Times.Once());
mockAuth.Verify(x => x.SetFabricActiveMember(), times);
mockAuth.Verify(x => x.RemoveFabricActiveMember(), times);
mockMemCache.Verify(x => x.RemoveOauthMembers(memId), Times.Once);
}
/*--------------------------------------------------------------------------------------------*/
protected void CheckSessionProperties(FabOauthAccess pAccess)
{
Assert.AreEqual(pAccess.access_token, OauthSess.BearerToken, "Incorrect BearerToken.");
Assert.AreEqual(pAccess.refresh_token, OauthSess.RefreshToken, "Incorrect RefreshToken.");
CheckExpiration(DateTime.UtcNow.AddSeconds(3600 - 60));
}
/*--------------------------------------------------------------------------------------------*/
private void DoExecute()
{
vExecuteResult = vOper.Execute(vMockOpCtx.Object, vMockTasks.Object, vGrantType,
vClientId, vSecret, vCode, vRefresh, vRedirUri);
}
