public void ErrDuplicateEmail()
{
IsReadOnlyTest = true;
vEmail = "*****@*****.**";
CreateUserAccountOperation.Result result = ExecuteOperation();
Assert.AreEqual(CreateUserAccountOperation.ResultStatus.DuplicateEmail, result.Status,
"Incorrect Status.");
}
public void ErrDuplicateUsername()
{
IsReadOnlyTest = true;
vUsername = "******";
CreateUserAccountOperation.Result result = ExecuteOperation();
Assert.AreEqual(CreateUserAccountOperation.ResultStatus.DuplicateUsername, result.Status,
"Incorrect Status.");
}
public void ErrUnexpected()
{
MockData
.Setup(x => x.Get <Email>(It.IsAny <IWeaverQuery>(), It.IsAny <string>()))
.Throws(new Exception("x"));
var op = new CreateUserAccountOperation();
CreateUserAccountOperation.Result result = op.Execute(MockOpCtx.Object, MockBuild.Object,
MockTasks.Object, "[email protected]", "user", "pass");
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(CreateUserAccountOperation.ResultStatus.UnexpectedError, result.Status,
"Incorrect Status");
}
public void ErrDuplicateUser()
{
//Note: the fault would actually come from a "Create" task
MockData
.Setup(x => x.Get <Email>(It.IsAny <IWeaverQuery>(), It.IsAny <string>()))
.Throws(new FabDuplicateFault("x"));
var op = new CreateUserAccountOperation();
CreateUserAccountOperation.Result result = op.Execute(MockOpCtx.Object, MockBuild.Object,
MockTasks.Object, "[email protected]", "user", "pass");
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(CreateUserAccountOperation.ResultStatus.DuplicateUsername, result.Status,
"Incorrect Status");
}
public void ErrDuplicateEmail()
{
const string email = "*****@*****.**";
MockData
.Setup(x => x.Get <Email>(It.IsAny <IWeaverQuery>(), It.IsAny <string>()))
.Returns(new Email());
var op = new CreateUserAccountOperation();
CreateUserAccountOperation.Result result = op.Execute(MockOpCtx.Object, MockBuild.Object,
MockTasks.Object, "[email protected]", "user", "pass");
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(CreateUserAccountOperation.ResultStatus.DuplicateEmail, result.Status,
"Incorrect Status");
}
public void Execute()
{
const string email = "*****@*****.**";
const string username = "******";
const string password = "******";
const long fabAppId = (long)SetupAppId.FabSys;
ICreateOperationBuilder build = MockBuild.Object;
CreateOperationTasks tasks = MockTasks.Object;
var expectUser = new User();
var expectMem = new Member();
var expectEmail = new Email();
IWeaverVarAlias <User> userAlias = new WeaverVarAlias <User>("userAlias");
IWeaverVarAlias <Member> memAlias = new WeaverVarAlias <Member>("memAlias");
IWeaverVarAlias <Email> emailAlias = new WeaverVarAlias <Email>("emailAlias");
MockData.Setup(x => x.Get <Email>(It.IsAny <IWeaverQuery>(),
typeof(CreateUserAccountOperation).Name + "-FindDuplicateEmail"))
.Returns((Email)null);
MockBuild
.Setup(x => x.StartSession())
.Callback(CheckCallIndex("StartSession"));
//// Add App
MockTasks
.Setup(x => x.FindDuplicateUserNameKey(build, ItIsVert <User>(vNewUserId)))
.Callback(CheckCallIndex("FindDuplicateUserNameKey"));
int addAppIndex = CallsAdded;
MockTasks
.Setup(x => x.AddUser(build, ItIsVert <User>(vNewUserId), out userAlias))
.Callback(CheckCallIndex("AddUser"));
//// Add Member
MockTasks
.Setup(x => x.FindDuplicateMember(build, vNewUserId, fabAppId))
.Callback(CheckCallIndex("FindDuplicateMember"));
int addMemIndex = CallsAdded;
MockTasks
.Setup(x => x.AddMember(build, ItIsVert <Member>(vNewMemId), out memAlias))
.Callback(CheckCallIndex("AddMember"));
//// Add Email
int addEmailIndex = CallsAdded;
MockTasks
.Setup(x => x.AddEmail(build, ItIsVert <Email>(vNewEmailId), out emailAlias))
.Callback(CheckCallIndex("AddEmail"));
//// Add App edges
MockTasks
.Setup(x => x.AddArtifactCreatedByMember(
build,
ItIsVert <User>(vNewUserId),
It.Is <CreateFabUser>(c => c.CreatedByMemberId == vNewMemId),
It.Is <IWeaverVarAlias <Artifact> >(a => a.Name == userAlias.Name)
))
.Callback(CheckCallIndex("AddArtifactCreatedByMember"));
//// Add Member edges
MockTasks
.Setup(x => x.AddMemberDefinedByApp(
build,
ItIsVert <Member>(vNewMemId),
It.Is <CreateFabMember>(c => c.DefinedByAppId == fabAppId),
It.Is <IWeaverVarAlias <Member> >(a => a.Name == memAlias.Name)
))
.Callback(CheckCallIndex("AddMemberDefinedByApp"));
MockTasks
.Setup(x => x.AddMemberDefinedByUser(
build,
ItIsVert <Member>(vNewMemId),
It.Is <CreateFabMember>(c => c.DefinedByUserId == vNewUserId),
It.Is <IWeaverVarAlias <Member> >(a => a.Name == memAlias.Name)
))
.Callback(CheckCallIndex("AddMemberDefinedByUser"));
//// Add Email edges
MockTasks
.Setup(x => x.AddEmailUsedByArtifact(
build,
ItIsVert <Email>(vNewEmailId),
It.Is <CreateFabEmail>(c => c.UsedByArtifactId == vNewUserId),
It.Is <IWeaverVarAlias <Email> >(a => a.Name == emailAlias.Name)
))
.Callback(CheckCallIndex("AddEmailUsedByArtifact"));
//// Finish setup
MockBuild
.Setup(x => x.CommitAndCloseSession())
.Callback(CheckCallIndex("CommitAndCloseSession"));
MockAcc.Setup(x => x.Execute(typeof(CreateUserAccountOperation).Name))
.Returns(MockRes.Object);
MockRes.Setup(x => x.GetCommandIndexByCmdId(vUserCmd)).Returns(addAppIndex);
MockRes.Setup(x => x.GetCommandIndexByCmdId(vMemCmd)).Returns(addMemIndex);
MockRes.Setup(x => x.GetCommandIndexByCmdId(vEmailCmd)).Returns(addEmailIndex);
MockRes.Setup(x => x.ToElementAt <User>(addAppIndex, 0)).Returns(expectUser);
MockRes.Setup(x => x.ToElementAt <Member>(addMemIndex, 0)).Returns(expectMem);
MockRes.Setup(x => x.ToElementAt <Email>(addEmailIndex, 0)).Returns(expectEmail);
//// Execute
var op = new CreateUserAccountOperation();
CreateUserAccountOperation.Result result = op.Execute(MockOpCtx.Object, build, tasks,
email, username, password);
Assert.NotNull(result, "Result should be filled.");
Assert.AreEqual(CreateUserAccountOperation.ResultStatus.Success, result.Status,
"Incorrect Status");
Assert.AreEqual(expectUser, result.NewUser, "Incorrect NewApp.");
Assert.AreEqual(expectMem, result.NewMember, "Incorrect NewMember.");
Assert.AreEqual(expectEmail, result.NewEmail, "Incorrect NewEmail.");
}
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.");
};
}
