示例#1
0
        public void UploadenBestandFaalendBestandCursusStartdatum()
        {
            //Arrange
            using (var ms = new MemoryStream())
            {
                using (var writer = new StreamWriter(ms))
                {
                    var fileMock = new Mock <IFormFile>();
                    writer.WriteLine("Titel: C# Programmeren");
                    writer.WriteLine("Cursuscode: CNETIN");
                    writer.WriteLine("Duur: 5 dagen");
                    writer.WriteLine("11/10/2014 ");
                    writer.WriteLine("");

                    writer.Flush();
                    ms.Position = 0;
                    fileMock.Setup(m => m.OpenReadStream()).Returns(ms);
                    fileMock.Setup(m => m.Length).Returns(5);


                    MockAgent mockAgent = new MockAgent();
                    var       target    = new CursusController(mockAgent);

                    //Act
                    var result = target.Create(fileMock.Object);
                    // Assert
                    CursusCreateMessageViewModel viewModel = (CursusCreateMessageViewModel)(result as ViewResult).Model;
                    Assert.IsNotNull(viewModel);
                    Assert.AreEqual(4, viewModel.ErrorAtLine);
                }
            }
        }
示例#2
0
        public void TestenFileUploadOntvangenBijController()
        {
            //Arrange
            using (var ms = new MemoryStream())
            {
                using (var writer = new StreamWriter(ms))
                {
                    var fileMock = new Mock <IFormFile>();
                    writer.WriteLine("Titel: C# Programmeren");
                    writer.WriteLine("Cursuscode: CNETIN");
                    writer.WriteLine("Duur: 5 dagen");
                    writer.WriteLine("Startdatum: 11/10/2014 ");
                    writer.WriteLine("");

                    writer.Flush();
                    ms.Position = 0;
                    fileMock.Setup(m => m.OpenReadStream()).Returns(ms);
                    fileMock.Setup(m => m.Length).Returns(5);


                    MockAgent mockAgent = new MockAgent();
                    var       target    = new CursusController(mockAgent);

                    //Act
                    var result = target.Create(fileMock.Object);
                    //Assert
                    Assert.IsInstanceOfType(result, typeof(IActionResult));
                }
            }
        }
示例#3
0
        public void UploadenBestandTestAddContentVolledigeCursusTitelCheck()
        {
            //Arrange
            using (var ms = new MemoryStream())
            {
                using (var writer = new StreamWriter(ms))
                {
                    var fileMock = new Mock <IFormFile>();
                    writer.WriteLine("Titel: C# Programmeren");
                    writer.WriteLine("Cursuscode: CNETIN");
                    writer.WriteLine("Duur: 5 dagen");
                    writer.WriteLine("Startdatum: 11/10/2014 ");
                    writer.WriteLine("");

                    writer.Flush();
                    ms.Position = 0;
                    fileMock.Setup(m => m.OpenReadStream()).Returns(ms);
                    fileMock.Setup(m => m.Length).Returns(5);


                    MockAgent mockAgent = new MockAgent();
                    var       target    = new CursusController(mockAgent);

                    //Act
                    var result = target.Create(fileMock.Object);

                    //Assert
                    Assert.AreEqual(1, mockAgent.NumberOfTimesAddCalled);
                    Assert.AreEqual("C# Programmeren", mockAgent.LijstCursusAddToevoeging[0].Cursus.Titel);
                }
            }
        }
        public static async Task ProofProtocolConnectionlessAsync(MockAgent requestor, MockAgent holder, ProofRequest proofRequest, bool useDidKeyFormat)
        {
            var proofService = requestor.GetService <IProofService>();

            var(requestMsg, requestorRecord) = await proofService.CreateRequestAsync(requestor.Context, proofRequest, useDidKeyFormat : useDidKeyFormat);

            var requestAttachment = requestMsg.Requests.FirstOrDefault(x => x.Id == "libindy-request-presentation-0")
                                    ?? throw new ArgumentException("Presentation request attachment not found.");

            var requestJson = requestAttachment.Data.Base64.GetBytesFromBase64().GetUTF8String();
            var request     = JsonConvert.DeserializeObject <ProofRequest>(requestJson);

            var requestedCredentials =
                await ProofServiceUtils.GetAutoRequestedCredentialsForProofCredentials(holder.Context, proofService,
                                                                                       request);

            var holderRecord = await proofService.CreatePresentationAsync(holder.Context, requestMsg, requestedCredentials);

            var requestorProofRecord = await proofService.GetAsync(requestor.Context, requestorRecord.Id);

            var holderProofRecord = await proofService.GetAsync(holder.Context, holderRecord.Id);

            Assert.True(requestorProofRecord.State == ProofState.Accepted);
            Assert.True(holderProofRecord.State == ProofState.Accepted);

            var isProofValid = await proofService.VerifyProofAsync(requestor.Context, requestorProofRecord.Id);

            Assert.True(isProofValid);
        }
示例#5
0
        public void UploadenBestandTestVerwijzingMessagePage()
        {
            // Arrange
            var fileMock = new Mock <IFormFile>();
            var lines    = File.ReadLines(@"TestFile\goedvoorbeeld.txt").ToList();

            using (var memoryStream = new MemoryStream())
            {
                using (var streamWriter = new StreamWriter(memoryStream))
                {
                    for (var i = 0; i < lines.Count; i++)
                    {
                        streamWriter.WriteLine(lines[i]);
                    }
                    streamWriter.Flush();
                    memoryStream.Position = 0;

                    fileMock.Setup(m => m.OpenReadStream()).Returns(memoryStream);
                    fileMock.Setup(m => m.Length).Returns(5);

                    MockAgent mockAgent = new MockAgent();
                    var       target    = new CursusController(mockAgent);

                    //Act
                    var result = target.Create(fileMock.Object);
                    // Assert
                    Assert.IsInstanceOfType(result, typeof(IActionResult));
                    Assert.AreEqual("CursusCreateMessage", (result as ViewResult).ViewName);
                }
            }
        }
示例#6
0
        public void UploadenBestandTestVerwijzingMessagePageModelContentInsertCount4()
        {
            // Arrange
            var fileMock = new Mock <IFormFile>();
            var lines    = File.ReadLines(@"TestFile\goedvoorbeeld.txt").ToList();

            using (var memoryStream = new MemoryStream())
            {
                using (var streamWriter = new StreamWriter(memoryStream))
                {
                    for (var i = 0; i < lines.Count; i++)
                    {
                        streamWriter.WriteLine(lines[i]);
                    }
                    streamWriter.Flush();
                    memoryStream.Position = 0;

                    fileMock.Setup(m => m.OpenReadStream()).Returns(memoryStream);
                    fileMock.Setup(m => m.Length).Returns(5);

                    MockAgent mockAgent = new MockAgent();
                    var       target    = new CursusController(mockAgent);

                    //Act
                    var result = target.Create(fileMock.Object);
                    // Assert
                    CursusCreateMessageViewModel viewModel = (CursusCreateMessageViewModel)(result as ViewResult).Model;
                    Assert.IsNotNull(viewModel);
                    Assert.AreEqual(4, viewModel.SuccesInsertCount);
                }
            }
        }
        public static string CreateBasicMessageWithHttpsType(MockAgent HttpsMessageAgent)
        {
            var basicMessage = new BasicMessage(HttpsMessageAgent.Context.UseMessageTypesHttps);

            Assert.Equal(MessageTypesHttps.BasicMessageType, basicMessage.Type);

            return(basicMessage.Type);
        }
        public async Task InitializeAsync()
        {
            _agent1 = await MockUtils.CreateAsync("agent1", config1, cred, new MockAgentHttpHandler((cb) => _router.RouteMessage(cb.name, cb.data)));

            _router.RegisterAgent(_agent1);
            _agent2 = await MockUtils.CreateAsync("agent2", config2, cred, new MockAgentHttpHandler((cb) => _router.RouteMessage(cb.name, cb.data)));

            _router.RegisterAgent(_agent2);
        }
示例#9
0
	public void testAddObjectTwice() {
		Assert.assertEquals(1, env.getAgents().size());
		XYLocation loc = new XYLocation(5, 5);
		AbstractAgent b = new MockAgent();
		env.addObjectToLocation(b, loc);
		Assert.assertEquals(2, env.getAgents().size());

		Assert.assertEquals(loc, env.getCurrentLocationFor(b));
	}
        public async Task InitializeAsync()
        {
            _issuerAgent = await MockUtils.CreateAsync("issuer", config1, cred, new MockAgentHttpHandler((cb) => _router.RouteMessage(cb.name, cb.data)), TestConstants.StewartDid);

            _router.RegisterAgent(_issuerAgent);
            _holderAgent = await MockUtils.CreateAsync("holder", config2, cred, new MockAgentHttpHandler((cb) => _router.RouteMessage((cb).name, cb.data)));

            _router.RegisterAgent(_holderAgent);
        }
        public static async Task ProofProtocolAsync(MockAgent requestor, MockAgent holder,
                                                    ConnectionRecord requestorConnection, ConnectionRecord holderConnection, ProofRequest proofRequest)
        {
            var proofService   = requestor.GetService <IProofService>();
            var messageService = requestor.GetService <IMessageService>();

            // Hook into message event
            var requestSlim = new SemaphoreSlim(0, 1);

            holder.GetService <IEventAggregator>().GetEventByType <ServiceMessageProcessingEvent>()
            .Where(x => x.MessageType == MessageTypes.PresentProofNames.RequestPresentation)
            .Subscribe(x => requestSlim.Release());

            var(requestMsg, requestorRecord) = await proofService.CreateRequestAsync(requestor.Context, proofRequest, requestorConnection.Id);

            await messageService.SendAsync(requestor.Context, requestMsg, requestorConnection);

            await requestSlim.WaitAsync(TimeSpan.FromSeconds(30));

            var holderRequests = await proofService.ListRequestedAsync(holder.Context);

            Assert.NotNull(holderRequests);
            Assert.True(holderRequests.Count > 0);

            // Hook into message event
            var proofSlim = new SemaphoreSlim(0, 1);

            requestor.GetService <IEventAggregator>().GetEventByType <ServiceMessageProcessingEvent>()
            .Where(x => x.MessageType == MessageTypes.PresentProofNames.Presentation)
            .Subscribe(x => requestSlim.Release());

            var record  = holderRequests.FirstOrDefault();
            var request = JsonConvert.DeserializeObject <ProofRequest>(record.RequestJson);

            var requestedCredentials =
                await ProofServiceUtils.GetAutoRequestedCredentialsForProofCredentials(holder.Context, proofService,
                                                                                       request);

            var(proofMsg, holderRecord) = await proofService.CreatePresentationAsync(holder.Context, record.Id, requestedCredentials);

            await messageService.SendAsync(holder.Context, proofMsg, holderConnection);

            await proofSlim.WaitAsync(TimeSpan.FromSeconds(30));

            var requestorProofRecord = await proofService.GetAsync(requestor.Context, requestorRecord.Id);

            var holderProofRecord = await proofService.GetAsync(holder.Context, holderRecord.Id);

            Assert.True(requestorProofRecord.State == ProofState.Accepted);
            Assert.True(holderProofRecord.State == ProofState.Accepted);

            var isProofValid = await proofService.VerifyProofAsync(requestor.Context, requestorProofRecord.Id);

            Assert.True(isProofValid);
        }
示例#12
0
        public override async Task <Scynet.Void> AgentStart(AgentStartRequest request, ServerCallContext context)
        {
            MockAgent egg = new MockAgent
            {
                Id      = request.Egg.Uuid,
                EggData = request.Egg.EggData.ToByteArray()
            };
            await client.GetGrain <IAgentRegistryGrain>(0).AgentStart(egg);

            return(new Scynet.Void());
        }
示例#13
0
        public void FindAllCursist()
        {
            //Arrange
            MockAgent mockAgent = new MockAgent();
            var       target    = new CursistController(mockAgent);

            //Act
            target.Index();

            //Assert
            Assert.AreEqual(1, mockAgent.NumberOfTimesIndexCursistCalled);
        }
示例#14
0
        public void WeergevenHuidigeWeek()
        {
            //Arrange
            MockAgent mockAgent = new MockAgent();
            var       target    = new CursusController(mockAgent);

            //Act
            var result = target.Index();

            //Assert
            Assert.IsInstanceOfType(result, typeof(IActionResult));
        }
示例#15
0
        public void RotateRollLeftOneWithRotation()
        {
            IAgent agent = new MockAgent()
            {
                MaxRotationSpeed = Rotation.One, Rotation = Quaternion.identity
            };
            AgentController controller = new AgentController(agent);
            Rotation        Rotate     = Rotation.RollLeft;

            controller.Rotate(Rotate);

            Assert.AreEqual(359, agent.Rotation.eulerAngles.z);
        }
示例#16
0
        public void MoveRiseOneWithVector3()
        {
            IAgent agent = new MockAgent()
            {
                MaxMovementSpeed = Movement.One, Position = Vector3.zero
            };
            AgentController controller = new AgentController(agent);
            Vector3         Direction  = Vector3.zero + Movement.Up;

            controller.Move(Direction);

            Assert.AreEqual(1, agent.Position.y);
        }
示例#17
0
        public void MoveForwardOneWithMovement()
        {
            IAgent agent = new MockAgent()
            {
                MaxMovementSpeed = Movement.One, Position = Vector3.zero
            };
            AgentController controller = new AgentController(agent);
            Movement        Direction  = Movement.Front;

            controller.Move(Direction);

            Assert.AreEqual(1, agent.Position.z);
        }
        public async Task InitializeAsync()
        {
            _responder = await MockUtils.CreateAsync("responder", config1, cred, new MockAgentHttpHandler((cb) => _router.RouteMessage(cb.name, cb.data)), TestConstants.StewardSeed);

            _router.RegisterAgent(_responder);
            _requester = await MockUtils.CreateAsync("requester", config2, cred, new MockAgentHttpHandler((cb) => _router.RouteMessage(cb.name, cb.data)));

            _router.RegisterAgent(_requester);

            var ledgerService = _responder.ServiceProvider.GetRequiredService <ILedgerService>();
            await ledgerService.RegisterServiceEndpointAsync(_responder.Context, TestConstants.StewardDid,
                                                             "http://responder");
        }
示例#19
0
        public void WeergevenGekozenWeekModelCheckContent()
        {
            //Arrange
            MockAgent mockAgent = new MockAgent();
            var       target    = new CursusController(mockAgent);

            //Act
            var result = target.Index(40, 2016);

            //Assert
            var resultModel = (result as ViewResult).Model;

            Assert.IsInstanceOfType(resultModel, typeof(IEnumerable <CursusInstantie>));
            Assert.AreEqual(new DateTime(2016, 10, 03).Day, DateTime.Parse(mockAgent.LijstGetByWeekInput[0]).Day);
        }
示例#20
0
        public void WeergevenHuidigeWeekModelCheck()
        {
            //Arrange
            MockAgent mockAgent = new MockAgent();
            var       target    = new CursusController(mockAgent);

            //Act
            var result = target.Index(41, 2016);

            //Assert
            var resultModel = (result as ViewResult).Model;

            Assert.IsInstanceOfType(result, typeof(IActionResult));
            Assert.IsInstanceOfType(resultModel, typeof(IEnumerable <CursusInstantie>));
        }
示例#21
0
        public Task AgentStart(MockAgent egg)
        {
            MockAgent agent = new MockAgent(egg);

            if (!State.Agents.ContainsKey(agent.Id))
            {
                agent.Start();
                State.Agents.Add(agent.Id, agent);
                return(base.WriteStateAsync());
            }

            if (!State.Agents[agent.Id].IsRunning)
            {
                State.Agents[agent.Id].Start();
                return(base.WriteStateAsync());
            }
            return(Task.CompletedTask);
        }
        public static async Task IssueCredentialConnectionlessAsync(MockAgent issuer, MockAgent holder, List <CredentialPreviewAttribute> credentialAttributes, bool useDidKeyFormat)
        {
            var credentialService = issuer.GetService <ICredentialService>();
            var schemaService     = issuer.GetService <ISchemaService>();
            var provisionService  = issuer.GetService <IProvisioningService>();

            var issuerProv = await provisionService.GetProvisioningAsync(issuer.Context.Wallet);

            var(definitionId, _) = await Scenarios.CreateDummySchemaAndNonRevokableCredDef(issuer.Context, schemaService,
                                                                                           issuerProv.IssuerDid, credentialAttributes.Select(_ => _.Name).ToArray());

            (var offer, var issuerCredentialRecord) = await credentialService.CreateOfferAsync(
                agentContext : issuer.Context,
                config : new OfferConfiguration
            {
                IssuerDid = issuerProv.IssuerDid,
                CredentialDefinitionId    = definitionId,
                CredentialAttributeValues = credentialAttributes,
                UseDidKeyFormat           = useDidKeyFormat
            });

            var holderCredentialRecord = await credentialService.CreateCredentialAsync(holder.Context, offer);

            Assert.NotNull(holderCredentialRecord.CredentialAttributesValues);
            Assert.True(holderCredentialRecord.CredentialAttributesValues.Count() == 2);

            var issuerCredRecord = await credentialService.GetAsync(issuer.Context, issuerCredentialRecord.Id);

            var holderCredRecord = await credentialService.GetAsync(holder.Context, holderCredentialRecord.Id);

            Assert.Equal(CredentialState.Issued, issuerCredRecord.State);
            Assert.Equal(CredentialState.Issued, holderCredRecord.State);

            Assert.Equal(
                issuerCredRecord.GetTag(TagConstants.LastThreadId),
                holderCredRecord.GetTag(TagConstants.LastThreadId));
        }
示例#23
0
	public void testGetObjectsAt() {
		XYLocation loc = new XYLocation(5, 7);
		env.moveObjectToAbsoluteLocation(a, loc);
		Assert.assertEquals(1, env.getObjectsAt(loc).size());
		AbstractAgent b = new MockAgent();
		env.addObjectToLocation(b, loc);
		Assert.assertEquals(2, env.getObjectsAt(loc).size());
	}
示例#24
0
        private static async Task RunMainAsync()
        {
            var client = await StartClientWithRetries();

            var grain = client.GetGrain <IAgentRegistryGrain>(0);
            //var agentId = Guid.NewGuid().ToString();
            var       agentId = Guid.Parse("253717bf-34b4-43fc-8129-4c68a6bbe1fe").ToString();
            MockAgent egg     = new MockAgent()
            {
                Id      = agentId,
                EggData = Encoding.ASCII.GetBytes("Agent1")
            };

            await grain.AgentStart(egg);

            var agentsList = await grain.GetAllAgents();


            const int    port   = 50051;
            const string host   = "localhost";
            var          server = new Server()
            {
                Services =
                {
                    Scynet.Component.BindService(new ComponentFacade(client))
                },
                Ports = { new ServerPort(host, port, ServerCredentials.Insecure) }
            };


            Console.WriteLine("Starting facade...");
            server.Start();
            Console.WriteLine("Facade started");

            //hatchery channel
            Channel channel        = new Channel("127.0.0.1:9998", ChannelCredentials.Insecure);
            var     hatcheryClient = new Scynet.Hatchery.HatcheryClient(channel);

            //var componentId = Guid.NewGuid().ToString();
            var componentId = Guid.Parse("7730a43f-42a7-49db-b569-50e04929c4f9").ToString();
            ComponentRegisterRequest hatcheryComponentRegisterRequest = new ComponentRegisterRequest()
            {
                Uuid    = componentId,
                Address = host + ":" + port,
            };

            //add await
            hatcheryClient.RegisterComponent(hatcheryComponentRegisterRequest);

            Agent agent = new Agent()
            {
                Uuid        = agentId,
                ComponentId = componentId,
                EggData     = ByteString.CopyFrom("Agent1", Encoding.Unicode)
            };
            AgentRegisterRequest arr = new AgentRegisterRequest();

            arr.Agent = agent;
            hatcheryClient.RegisterAgent(arr);

            await server.ShutdownAsync();
        }
示例#25
0
	public void testGetObjectsNear() {
		XYLocation loc = new XYLocation(5, 5);
		env.moveObjectToAbsoluteLocation(a, loc);
		AbstractAgent b = new MockAgent();
		AbstractAgent c = new MockAgent();
		Wall w1 = new Wall();

		env.addObjectToLocation(b, new XYLocation(7, 4));
		env.addObjectToLocation(c, new XYLocation(5, 7));
		env.addObjectToLocation(w1, new XYLocation(3, 10));

		// at this point agent A should be able to see B and C but not the wall
		// with a "vision radius" of 3
		Set<EnvironmentObject> visibleToA = env.getObjectsNear(a, 3);
		Assert.assertEquals(2, visibleToA.size());
		// agent B should be able to see A only
		Set<EnvironmentObject> visibleToB = env.getObjectsNear(b, 3);
		Assert.assertEquals(1, visibleToB.size());

		// move B South
		env.moveObject(b, XYLocation.Direction.South);
		// at this point both a and c should be visible to b
		visibleToB = env.getObjectsNear(b, 3);
		Assert.assertEquals(2, visibleToB.size());
		// move c near the wall
		env.moveObjectToAbsoluteLocation(c, new XYLocation(3, 11));
		// only the wall should be visible
		Set<EnvironmentObject> visibleToC = env.getObjectsNear(c, 3);
		Assert.assertEquals(1, visibleToC.size());
	}
        public static async Task <(ConnectionRecord inviteeConnection, ConnectionRecord inviterConnection)> EstablishConnectionWithReturnRoutingAsync(MockAgent invitee, MockAgent inviter, bool useDidKeyFormat = false)
        {
            var slim = new SemaphoreSlim(0, 1);

            var connectionService = inviter.GetService <IConnectionService>();
            var messageService    = inviter.GetService <IMessageService>();

            // Hook into response message event of second runtime to release semaphore
            invitee.GetService <IEventAggregator>().GetEventByType <ServiceMessageProcessingEvent>()
            .Where(x => x.MessageType == MessageTypes.ConnectionResponse)
            .Subscribe(x => slim.Release());

            var(invitation, inviteeConnection) = await connectionService.CreateInvitationAsync(inviter.Context,
                                                                                               new InviteConfiguration { AutoAcceptConnection = true, UseDidKeyFormat = useDidKeyFormat });

            var(request, inviterConnection) =
                await connectionService.CreateRequestAsync(invitee.Context, invitation);

            var response = await messageService.SendReceiveAsync <ConnectionResponseMessage>(invitee.Context, request, inviterConnection);

            Assert.NotNull(response);
            await connectionService.ProcessResponseAsync(invitee.Context, response, inviterConnection);

            await slim.WaitAsync(TimeSpan.FromSeconds(30));

            var ackMessage = await connectionService.CreateAcknowledgementMessageAsync(invitee.Context,
                                                                                       inviterConnection.Id);

            await messageService.SendAsync(invitee.Context, ackMessage, inviterConnection);

            await slim.WaitAsync(TimeSpan.FromSeconds(30));

            var inviteeConnectionRecord = await connectionService.GetAsync(inviter.Context, inviteeConnection.Id);

            var inviterConnectionRecord = await connectionService.GetAsync(invitee.Context, inviterConnection.Id);

            Assert.Equal(ConnectionState.Connected, inviteeConnectionRecord.State);
            Assert.Equal(ConnectionState.Connected, inviterConnectionRecord.State);
            Assert.Equal(inviteeConnectionRecord.MyDid, inviterConnectionRecord.TheirDid);
            Assert.Equal(inviteeConnectionRecord.TheirDid, inviterConnectionRecord.MyDid);

            Assert.Equal(
                inviteeConnectionRecord.GetTag(TagConstants.LastThreadId),
                inviterConnectionRecord.GetTag(TagConstants.LastThreadId));

            return(inviteeConnectionRecord, inviterConnectionRecord);
        }
示例#27
0
        public static async Task <DiscoveryDiscloseMessage> DiscoveryProtocolWithReturnRoutingAsync(MockAgent requestor, MockAgent holder, ConnectionRecord requestorConnection, ConnectionRecord holderConnection)
        {
            var discoveryService = requestor.GetService <IDiscoveryService>();
            var messageService   = requestor.GetService <IMessageService>();

            //Ask for all protocols
            var msg = discoveryService.CreateQuery(requestor.Context, "*");
            var rsp = await messageService.SendAsync(requestor.Context.Wallet, msg, requestorConnection, null, true);

            Assert.NotNull(rsp);

            var discoveryMsg = rsp.GetMessage <DiscoveryDiscloseMessage>();

            Assert.NotNull(discoveryMsg);

            return(discoveryMsg);
        }
        public static async Task <DiscoveryDiscloseMessage> DiscoveryProtocolWithReturnRoutingAsync(MockAgent requestor, MockAgent holder, ConnectionRecord requestorConnection, ConnectionRecord holderConnection)
        {
            var discoveryService = requestor.GetService <IDiscoveryService>();
            var messageService   = requestor.GetService <IMessageService>();

            //Ask for all protocols
            var msg = discoveryService.CreateQuery(requestor.Context, "*");
            var rsp = await messageService.SendReceiveAsync(requestor.Context, msg, requestorConnection);

            Assert.NotNull(rsp);

            if (rsp is UnpackedMessageContext messageContext)
            {
                var discoveryMsg = messageContext.GetMessage <DiscoveryDiscloseMessage>();

                Assert.NotNull(discoveryMsg);

                return(discoveryMsg);
            }
            throw new InvalidOperationException("The response was not of the expected type");
        }
示例#29
0
        public static async Task <(ConnectionRecord inviteeConnection, ConnectionRecord inviterConnection)> EstablishConnectionWithReturnRoutingAsync(MockAgent invitee, MockAgent inviter)
        {
            var slim = new SemaphoreSlim(0, 1);

            var connectionService = invitee.GetService <IConnectionService>();
            var messsageService   = invitee.GetService <IMessageService>();

            // Hook into response message event of second runtime to release semaphore
            inviter.GetService <IEventAggregator>().GetEventByType <ServiceMessageProcessingEvent>()
            .Where(x => x.MessageType == MessageTypes.ConnectionResponse)
            .Subscribe(x => slim.Release());

            (var invitation, var inviterConnection) = await connectionService.CreateInvitationAsync(invitee.Context,
                                                                                                    new InviteConfiguration { AutoAcceptConnection = true });

            (var request, var inviteeConnection) =
                await connectionService.CreateRequestAsync(inviter.Context, invitation);

            var response = await messsageService.SendAsync(inviter.Context.Wallet, request,
                                                           inviteeConnection, invitation.RecipientKeys.First(), true);

            Assert.NotNull(response);
            await inviter.HandleInboundAsync(response);

            await slim.WaitAsync(TimeSpan.FromSeconds(30));

            var connectionRecord1 = await connectionService.GetAsync(invitee.Context, inviterConnection.Id);

            var connectionRecord2 = await connectionService.GetAsync(inviter.Context, inviteeConnection.Id);

            Assert.Equal(ConnectionState.Connected, connectionRecord1.State);
            Assert.Equal(ConnectionState.Connected, connectionRecord2.State);
            Assert.Equal(connectionRecord1.MyDid, connectionRecord2.TheirDid);
            Assert.Equal(connectionRecord1.TheirDid, connectionRecord2.MyDid);

            Assert.Equal(
                connectionRecord1.GetTag(TagConstants.LastThreadId),
                connectionRecord2.GetTag(TagConstants.LastThreadId));

            return(connectionRecord1, connectionRecord2);
        }
        public static async Task <(ConnectionRecord inviteeConnection, ConnectionRecord inviterConnection)> EstablishConnectionAsync(MockAgent invitee, MockAgent inviter, bool useDidKeyFormat = false)
        {
            var slim = new SemaphoreSlim(0, 1);

            var connectionService = invitee.GetService <IConnectionService>();
            var messageService    = invitee.GetService <IMessageService>();

            // Hook into response message event of second runtime to release semaphore
            inviter.GetService <IEventAggregator>().GetEventByType <ServiceMessageProcessingEvent>()
            .Where(x => x.MessageType == MessageTypes.ConnectionResponse)
            .Subscribe(x => slim.Release());

            (var invitation, var inviterConnection) = await connectionService.CreateInvitationAsync(invitee.Context,
                                                                                                    new InviteConfiguration { AutoAcceptConnection = true, UseDidKeyFormat = useDidKeyFormat });

            var(request, inviteeConnection) =
                await connectionService.CreateRequestAsync(inviter.Context, invitation);

            await messageService.SendAsync(inviter.Context, request, inviteeConnection);

            // Wait for connection to be established or continue after 30 sec timeout
            await slim.WaitAsync(TimeSpan.FromSeconds(30));

            var connectionRecord1 = await connectionService.GetAsync(invitee.Context, inviterConnection.Id);

            var connectionRecord2 = await connectionService.GetAsync(inviter.Context, inviteeConnection.Id);

            Assert.Equal(ConnectionState.Connected, connectionRecord1.State);
            Assert.Equal(ConnectionState.Connected, connectionRecord2.State);
            Assert.Equal(connectionRecord1.MyDid, connectionRecord2.TheirDid);
            Assert.Equal(connectionRecord1.TheirDid, connectionRecord2.MyDid);

            Assert.Equal(
                connectionRecord1.GetTag(TagConstants.LastThreadId),
                connectionRecord2.GetTag(TagConstants.LastThreadId));

            return(connectionRecord1, connectionRecord2);
        }
        public static async Task IssueCredentialAsync(MockAgent issuer, MockAgent holder, ConnectionRecord issuerConnection, ConnectionRecord holderConnection, List <CredentialPreviewAttribute> credentialAttributes)
        {
            var credentialService = issuer.GetService <ICredentialService>();
            var messageService    = issuer.GetService <IMessageService>();
            var schemaService     = issuer.GetService <ISchemaService>();
            var provisionService  = issuer.GetService <IProvisioningService>();

            // Hook into message event
            var offerSlim = new SemaphoreSlim(0, 1);

            holder.GetService <IEventAggregator>().GetEventByType <ServiceMessageProcessingEvent>()
            .Where(x => x.MessageType == MessageTypes.IssueCredentialNames.OfferCredential)
            .Subscribe(x => offerSlim.Release());

            var issuerProv = await provisionService.GetProvisioningAsync(issuer.Context.Wallet);

            var(definitionId, _) = await Scenarios.CreateDummySchemaAndNonRevokableCredDef(issuer.Context, schemaService,
                                                                                           issuerProv.IssuerDid, credentialAttributes.Select(_ => _.Name).ToArray());

            var(offer, issuerCredentialRecord) = await credentialService.CreateOfferAsync(
                agentContext : issuer.Context,
                config : new OfferConfiguration
            {
                IssuerDid = issuerProv.IssuerDid,
                CredentialDefinitionId    = definitionId,
                CredentialAttributeValues = credentialAttributes,
            },
                connectionId : issuerConnection.Id);

            await messageService.SendAsync(issuer.Context, offer, issuerConnection);

            await offerSlim.WaitAsync(TimeSpan.FromSeconds(30));

            var offers = await credentialService.ListOffersAsync(holder.Context);

            Assert.NotNull(offers);
            Assert.True(offers.Count > 0);

            // Hook into message event
            var requestSlim = new SemaphoreSlim(0, 1);

            issuer.GetService <IEventAggregator>().GetEventByType <ServiceMessageProcessingEvent>()
            .Where(x => x.MessageType == MessageTypes.IssueCredentialNames.RequestCredential)
            .Subscribe(x => requestSlim.Release());

            var(request, holderCredentialRecord) = await credentialService.CreateRequestAsync(holder.Context, offers[0].Id);

            Assert.NotNull(holderCredentialRecord.CredentialAttributesValues);

            Assert.True(holderCredentialRecord.CredentialAttributesValues.Count() == 2);

            await messageService.SendAsync(holder.Context, request, holderConnection);

            await requestSlim.WaitAsync(TimeSpan.FromSeconds(30));

            // Hook into message event
            var credentialSlim = new SemaphoreSlim(0, 1);

            holder.GetService <IEventAggregator>().GetEventByType <ServiceMessageProcessingEvent>()
            .Where(x => x.MessageType == MessageTypes.IssueCredentialNames.IssueCredential)
            .Subscribe(x => credentialSlim.Release());

            var(cred, _) = await credentialService.CreateCredentialAsync(
                agentContext : issuer.Context,
                credentialId : issuerCredentialRecord.Id);

            await messageService.SendAsync(issuer.Context, cred, issuerConnection);

            await credentialSlim.WaitAsync(TimeSpan.FromSeconds(30));

            var issuerCredRecord = await credentialService.GetAsync(issuer.Context, issuerCredentialRecord.Id);

            var holderCredRecord = await credentialService.GetAsync(holder.Context, holderCredentialRecord.Id);

            Assert.Equal(CredentialState.Issued, issuerCredRecord.State);
            Assert.Equal(CredentialState.Issued, holderCredRecord.State);

            Assert.Equal(
                issuerCredRecord.GetTag(TagConstants.LastThreadId),
                holderCredRecord.GetTag(TagConstants.LastThreadId));

            var ackSlim = new SemaphoreSlim(0, 1);

            holder.GetService <IEventAggregator>().GetEventByType <ServiceMessageProcessingEvent>()
            .Where(x => x.MessageType == MessageTypes.IssueCredentialNames.AcknowledgeCredential)
            .Subscribe(x => ackSlim.Release());

            var ackMessage =
                await credentialService.CreateAcknowledgementMessageAsync(holder.Context, holderCredentialRecord.Id);

            await messageService.SendAsync(holder.Context, ackMessage, holderConnection);

            await ackSlim.WaitAsync(TimeSpan.FromSeconds(30));

            Assert.Equal(ackMessage.Id,
                         issuerCredRecord.GetTag(TagConstants.LastThreadId));
        }