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.");
};
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private Tuple <int, int> CountVerticesAndEdges()
{
var q = new WeaverQuery();
q.FinalizeQuery("[g.V.count(),g.E.count()]");
IDataResult data = OpCtx.ExecuteForTest(q, "Base-Count");
return(new Tuple <int, int>(data.ToIntAt(0, 0), data.ToIntAt(0, 1)));
}
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.");
};
}
public void TearDown()
{
#if LIVE
Assert.Fail("Skipping TearDown in LIVE mode.");
#endif
TestPreTearDown();
Log.Info("");
Log.Info("=====================================");
Log.Info("");
Log.Info("Core test time: " + vWatch2.ElapsedMilliseconds + "ms");
Log.Info("TearDown started at T = " + GetTime());
////
AssertionException verifEx = null;
if (VerificationQueryFunc != null)
{
try {
VerificationQueryFunc();
}
catch (AssertionException e) {
verifEx = e;
}
}
Tuple <int, int> c = CountVerticesAndEdges();
Log.Info("Counts { V = " + c.Item1 + ", E = " + c.Item2 + " }");
int vertexDiff = c.Item1 - vCounts.Item1;
int edgeDiff = c.Item2 - vCounts.Item2;
if (IsReadOnlyTest &&
(vertexDiff != 0 || edgeDiff != 0 || NewVertexCount != 0 || NewEdgeCount != 0))
{
Log.Info("");
Log.Info("WARNING: Overriding read-only mode due to counts: " +
vertexDiff + ", " + edgeDiff + ", " + NewVertexCount + ", " + NewEdgeCount);
Log.Info("");
IsReadOnlyTest = false;
}
if (!IsReadOnlyTest)
{
var q = new WeaverQuery();
q.FinalizeQuery("g.V.remove();1");
IDataResult remAllData = OpCtx.ExecuteForTest(q, "Remove-All");
q = new WeaverQuery();
q.FinalizeQuery("g.loadGraphSON('../db/FabricBackups/FabricTest.json');1");
IDataResult reloadData = OpCtx.ExecuteForTest(q, "Reset-Data");
Assert.AreEqual("1", remAllData.ToStringAt(0, 0),
"There was an issue with the RemoveAll query!");
Assert.AreEqual("1", reloadData.ToStringAt(0, 0),
"There was an issue with the Reload query!");
Log.Info("");
}
else
{
Log.Info("READ ONLY MODE: skipped database reset");
}
Assert.AreEqual(NewVertexCount, vertexDiff, "Incorrect new vertex count.");
Assert.AreEqual(NewEdgeCount, edgeDiff, "Incorrect new edge count.");
if (IsReadOnlyTest)
{
Assert.AreEqual(0, NewVertexCount, "NewVertexCount should be zero!");
Assert.AreEqual(0, NewEdgeCount, "NewEdgeCount should be zero!");
}
if (verifEx != null)
{
throw verifEx;
}
////
TestPostTearDown();
OpCtx = null;
Log.Info("TearDown complete at T = " + GetTime());
}
