/*--------------------------------------------------------------------------------------------*/
private OauthMember GetOauthMember(IOperationData pData, Member pMemPath, string pName)
{
IWeaverVarAlias <Member> memAlias;
IWeaverQuery memQ = pMemPath.ToQueryAsVar("m", out memAlias);
IWeaverQuery appQ = Weave.Inst.FromVar(memAlias)
.DefinedByApp.ToApp
.Property(x => x.VertexId)
.ToQuery();
IDataAccess acc = pData.Build(null, true);
acc.AddSessionStart();
acc.AddQuery(memQ, true);
acc.AppendScriptToLatestCommand("(m?m=m.next():null);");
string memCmdId = acc.GetLatestCommandId();
acc.AddQuery(appQ, true);
acc.AddConditionsToLatestCommand(memCmdId);
acc.AddSessionClose();
IDataResult res = acc.Execute("OauthAccess-" + pName);
if (res.GetCommandResultCount(1) == 0)
{
return(null);
}
var om = new OauthMember();
om.Member = res.ToElementAt <Member>(1, 0);
om.AppId = res.ToLongAt(2, 0);
return(om);
}
public void Success()
{
FabOauthLogout result = ExecuteOperation();
Assert.AreEqual(1, result.Success, "Incorrect Success.");
Assert.AreEqual(vToken, result.AccessToken, "Incorrect AccessToken.");
VerificationQueryFunc = () => {
IWeaverQuery q1 = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.VertexId, (long)SetupMemberId.FabZach)
.AuthenticatedByOauthAccesses.ToOauthAccess
.Has(x => x.Token)
.ToQuery();
IWeaverQuery q2 = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.VertexId, (long)SetupMemberId.FabZach)
.AuthenticatedByOauthAccesses.ToOauthAccess
.Has(x => x.Refresh)
.ToQuery();
IDataResult dr1 = OpCtx.ExecuteForTest(q1, "OauthLogoutOperation-Token");
IDataResult dr2 = OpCtx.ExecuteForTest(q2, "OauthLogoutOperation-Refresh");
Assert.AreEqual(0, dr1.GetCommandResultCount(), "Tokens were not cleared.");
Assert.AreEqual(0, dr2.GetCommandResultCount(), "Refresh were not cleared.");
};
}
public void Success()
{
const long memId = (long)SetupMemberId.BookZach;
const MemberType.Id newType = MemberType.Id.Staff;
var op = new WebUpdateMemberTypeOperation();
Member result = op.Execute(OpCtx, memId, newType);
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(memId, result.VertexId, "Incorrect VertexId.");
Assert.AreEqual((byte)newType, result.MemberType, "Incorrect MemberType.");
IWeaverQuery memQ = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.VertexId, memId)
.Has(x => x.MemberType, WeaverStepHasOp.EqualTo, (byte)newType)
.ToQuery();
IWeaverQuery userDefMemQ = Weave.Inst.Graph
.V.ExactIndex <User>(x => x.VertexId, (byte)SetupUserId.Zach)
.DefinesMembers
.Has(x => x.AppId, WeaverStepHasOp.EqualTo, (byte)SetupAppId.Bookmarker)
.Has(x => x.MemberType, WeaverStepHasOp.EqualTo, (byte)newType)
.ToMember
.ToQuery();
IWeaverQuery appDefMemQ = Weave.Inst.Graph
.V.ExactIndex <App>(x => x.VertexId, (byte)SetupAppId.Bookmarker)
.DefinesMembers
.Has(x => x.UserId, WeaverStepHasOp.EqualTo, (byte)SetupUserId.Zach)
.Has(x => x.MemberType, WeaverStepHasOp.EqualTo, (byte)newType)
.ToMember
.ToQuery();
VerificationQueryFunc = () => {
IDataResult dr = OpCtx.ExecuteForTest(memQ, "UpdateMemType1-Verify");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New element not verified (1).");
dr = OpCtx.ExecuteForTest(userDefMemQ, "UpdateMemType2-Verify");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New element not verified (2).");
dr = OpCtx.ExecuteForTest(appDefMemQ, "UpdateMemType3-Verify");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New element not verified (3).");
};
}
public void Success()
{
const long appId = (long)SetupAppId.KinPhoGal;
var op = new WebUpdateAppSecretOperation();
SuccessResult result = op.Execute(OpCtx, appId);
Assert.NotNull(result, "Result should be filled.");
Assert.True(result.Success, "Incorrect Success.");
IWeaverQuery verify = Weave.Inst.Graph
.V.ExactIndex <App>(x => x.VertexId, appId)
.Has(x => x.Name, WeaverStepHasOp.NotEqualTo, SetupUsers.KinPhoGalSecret)
.ToQuery();
VerificationQueryFunc = () => {
IDataResult dr = OpCtx.ExecuteForTest(verify, "UpdateAppSecret-Verify");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New element not verified.");
};
}
public void Success()
{
const long userId = (long)SetupUserId.Zach;
const string newPass = "******";
var op = new WebUpdateUserPasswordOperation();
SuccessResult result = op.Execute(OpCtx, userId, "asdfasdf", newPass);
Assert.NotNull(result, "Result should be filled.");
Assert.True(result.Success, "Incorrect Success.");
IWeaverQuery verify = Weave.Inst.Graph
.V.ExactIndex <User>(x => x.VertexId, userId)
.Has(x => x.Password, WeaverStepHasOp.EqualTo, DataUtil.HashPassword(newPass))
.ToQuery();
VerificationQueryFunc = () => {
IDataResult dr = OpCtx.ExecuteForTest(verify, "UpdateUserPassword-Verify");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New element not verified.");
};
}
public void SuccessRemove()
{
const long appId = (long)SetupAppId.Bookmarker;
const string removeDom = SetupOauth.DomBook1;
const string expectDoms = SetupOauth.DomBook2;
var op = new WebUpdateAppDomainsOperation();
App result = op.ExecuteRemove(OpCtx, appId, removeDom);
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(appId, result.VertexId, "Incorrect VertexId.");
Assert.AreEqual(expectDoms, result.OauthDomains, "Incorrect OauthDomains.");
IWeaverQuery verify = Weave.Inst.Graph
.V.ExactIndex <App>(x => x.VertexId, result.VertexId)
.Has(x => x.OauthDomains, WeaverStepHasOp.EqualTo, expectDoms)
.ToQuery();
VerificationQueryFunc = () => {
IDataResult dr = OpCtx.ExecuteForTest(verify, "RemoveAppDomain-Verify");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New element not verified.");
};
}
public void Success()
{
CreateAppAccountOperation.Result result = ExecuteOperation();
Assert.AreEqual(CreateAppAccountOperation.ResultStatus.Success, result.Status,
"Incorrect Status.");
XCreateOperation.CheckNewVertex(result.NewApp, VertexType.Id.App);
XCreateOperation.CheckNewVertex(result.NewMember, VertexType.Id.Member);
Assert.AreEqual(vName, result.NewApp.Name, "Incorrect NewApp.Name.");
Assert.AreEqual((byte)MemberType.Id.DataProv, result.NewMember.MemberType,
"Incorrect NewMember.MemberType.");
NewVertexCount = 2;
NewEdgeCount = 6;
const WeaverStepHasOp eq = WeaverStepHasOp.EqualTo;
IWeaverStepAs <App> appAlias;
IWeaverStepAs <Member> memAlias;
IWeaverStepAs <Member> creMemAlias;
IWeaverStepAs <User> userAlias;
//Confirm new App and two edges
IWeaverQuery verifyApp = Weave.Inst.Graph
.V.ExactIndex <App>(x => x.VertexId, result.NewApp.VertexId)
.As(out appAlias)
.DefinesMembers
.Has(x => x.UserId, eq, vUserId)
.Has(x => x.MemberType, eq, (byte)MemberType.Id.DataProv)
.Has(x => x.Timestamp, eq, result.NewMember.Timestamp)
.ToMember
.Has(x => x.VertexId, eq, result.NewMember.VertexId)
.Back(appAlias)
.CreatedByMember.ToMember
.Has(x => x.VertexId, eq, vCreatorMemberId)
.Back(appAlias)
.ToQuery();
//Confirm new Member and two edges
IWeaverQuery verifyMem = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.VertexId, result.NewMember.VertexId)
.As(out memAlias)
.DefinedByApp.ToApp
.Has(x => x.VertexId, eq, result.NewApp.VertexId)
.Back(memAlias)
.DefinedByUser.ToUser
.Has(x => x.VertexId, eq, vUserId)
.Back(memAlias)
.ToQuery();
//Confirm creator Member and one new edge
IWeaverQuery verifyCreatorMem = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.VertexId, vCreatorMemberId)
.As(out creMemAlias)
.CreatesArtifacts
.Has(x => x.VertexType, eq, (byte)VertexType.Id.App)
.Has(x => x.Timestamp, eq, result.NewApp.Timestamp)
.ToArtifact
.Has(x => x.VertexId, eq, result.NewApp.VertexId)
.Back(creMemAlias)
.ToQuery();
//Confirm new Member's User and one new edge
IWeaverQuery verifyDataProvUser = Weave.Inst.Graph
.V.ExactIndex <User>(x => x.VertexId, vUserId)
.As(out userAlias)
.DefinesMembers
.Has(x => x.AppId, eq, result.NewApp.VertexId)
.Has(x => x.MemberType, eq, (byte)MemberType.Id.DataProv)
.Has(x => x.Timestamp, eq, result.NewMember.Timestamp)
.ToMember
.Has(x => x.VertexId, eq, result.NewMember.VertexId)
.Back(userAlias)
.ToQuery();
VerificationQueryFunc = () => {
IDataResult dr = OpCtx.ExecuteForTest(verifyApp, "CreateAppAccountOperation-VerifyA");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New App not verified.");
dr = OpCtx.ExecuteForTest(verifyMem, "CreateAppAccountOperation-VerifyM");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New Member not verified.");
dr = OpCtx.ExecuteForTest(verifyCreatorMem, "CreateAppAccountOperation-VerifyCM");
Assert.AreEqual(1, dr.GetCommandResultCount(), "Creator Member not verified.");
dr = OpCtx.ExecuteForTest(verifyDataProvUser, "CreateAppAccountOperation-VerifyDPU");
Assert.AreEqual(1, dr.GetCommandResultCount(), "DataProv User not verified.");
};
}
public void Success()
{
CreateUserAccountOperation.Result result = ExecuteOperation();
Assert.AreEqual(CreateUserAccountOperation.ResultStatus.Success, result.Status,
"Incorrect Status.");
XCreateOperation.CheckNewVertex(result.NewUser, VertexType.Id.User);
XCreateOperation.CheckNewVertex(result.NewMember, VertexType.Id.Member);
XCreateOperation.CheckNewVertex(result.NewEmail, VertexType.Id.Email);
Assert.AreEqual(vUsername, result.NewUser.Name, "Incorrect NewUser.Name.");
Assert.AreEqual((byte)MemberType.Id.Member, result.NewMember.MemberType,
"Incorrect NewMember.MemberType.");
Assert.AreEqual(vEmail, result.NewEmail.Address, "Incorrect NewEmail.Address.");
NewVertexCount = 3;
NewEdgeCount = 8;
const WeaverStepHasOp eq = WeaverStepHasOp.EqualTo;
IWeaverStepAs <User> userAlias;
IWeaverStepAs <Member> memAlias;
IWeaverStepAs <Member> creMemAlias;
IWeaverStepAs <App> appAlias;
IWeaverStepAs <Email> emailAlias;
//Confirm new User and three edges
IWeaverQuery verifyUser = Weave.Inst.Graph
.V.ExactIndex <User>(x => x.VertexId, result.NewUser.VertexId)
.As(out userAlias)
.DefinesMembers
.Has(x => x.AppId, eq, (long)SetupAppId.FabSys)
.Has(x => x.MemberType, eq, (byte)MemberType.Id.Member)
.Has(x => x.Timestamp, eq, result.NewMember.Timestamp)
.ToMember
.Has(x => x.VertexId, eq, result.NewMember.VertexId)
.Back(userAlias)
.CreatedByMember.ToMember
.Has(x => x.VertexId, eq, result.NewMember.VertexId)
.Back(userAlias)
.UsesEmails.ToEmail
.Has(x => x.Address, eq, vEmail)
.Back(userAlias)
.ToQuery();
//Confirm new Member and two edges
IWeaverQuery verifyMem = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.VertexId, result.NewMember.VertexId)
.As(out memAlias)
.DefinedByApp.ToApp
.Has(x => x.VertexId, eq, (long)SetupAppId.FabSys)
.Back(memAlias)
.DefinedByUser.ToUser
.Has(x => x.VertexId, eq, result.NewUser.VertexId)
.Back(memAlias)
.ToQuery();
//Confirm creator Member and one new edge
IWeaverQuery verifyCreatorMem = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.VertexId, result.NewMember.VertexId)
.As(out creMemAlias)
.CreatesArtifacts
.Has(x => x.VertexType, eq, (byte)VertexType.Id.User)
.Has(x => x.Timestamp, eq, result.NewUser.Timestamp)
.ToArtifact
.Has(x => x.VertexId, eq, result.NewUser.VertexId)
.Back(creMemAlias)
.ToQuery();
//Confirm new Member's App and one new edge
IWeaverQuery verifyCreatorUser = Weave.Inst.Graph
.V.ExactIndex <App>(x => x.VertexId, (long)SetupAppId.FabSys)
.As(out appAlias)
.DefinesMembers
.Has(x => x.UserId, eq, result.NewUser.VertexId)
.Has(x => x.MemberType, eq, (byte)MemberType.Id.Member)
.Has(x => x.Timestamp, eq, result.NewMember.Timestamp)
.ToMember
.Has(x => x.VertexId, eq, result.NewMember.VertexId)
.Back(appAlias)
.ToQuery();
//Confirm new Email and one edge
IWeaverQuery verifyEmail = Weave.Inst.Graph
.V.ExactIndex <Email>(x => x.VertexId, result.NewEmail.VertexId)
.As(out emailAlias)
.UsedByArtifact.ToArtifact
.Has(x => x.VertexId, eq, result.NewUser.VertexId)
.Back(emailAlias)
.ToQuery();
VerificationQueryFunc = () => {
IDataResult dr = OpCtx.ExecuteForTest(verifyUser, "CreateUserAccountOperation-VerifyU");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New User not verified.");
dr = OpCtx.ExecuteForTest(verifyMem, "CreateUserAccountOperation-VerifyM");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New Member not verified.");
dr = OpCtx.ExecuteForTest(verifyCreatorMem, "CreateUserAccountOperation-VerifyCM");
Assert.AreEqual(1, dr.GetCommandResultCount(), "Creator Member not verified.");
dr = OpCtx.ExecuteForTest(verifyCreatorUser, "CreateUserAccountOperation-VerifyCU");
Assert.AreEqual(1, dr.GetCommandResultCount(), "Creator User not verified.");
dr = OpCtx.ExecuteForTest(verifyEmail, "CreateUserAccountOperation-VerifyE");
Assert.AreEqual(1, dr.GetCommandResultCount(), "New Email not verified.");
};
}