Examples with Socket won.utils.content.model.Socket used on opensource projects

Example 1 with Socket

use of won.utils.content.model.Socket in project webofneeds by researchstudio-sat.

the class AclTests method testModifyOnBehalf.

@Test(timeout = 60 * 1000)
public void testModifyOnBehalf() throws Exception {
    final AtomicBoolean atom1Created = new AtomicBoolean(false);
    final AtomicBoolean atom2Created = new AtomicBoolean(false);
    final CountDownLatch latch = new CountDownLatch(2);
    final AtomicReference<URI> createMessageUri1 = new AtomicReference();
    final AtomicReference<URI> createMessageUri2 = new AtomicReference();
    runTest(ctx -> {
        EventBus bus = ctx.getEventBus();
        final URI wonNodeUri = ctx.getNodeURISource().getNodeURI();
        final URI atomUri1 = ctx.getWonNodeInformationService().generateAtomURI(wonNodeUri);
        final URI atomUri2 = ctx.getWonNodeInformationService().generateAtomURI(wonNodeUri);
        BotBehaviour bbAtom1 = new BotBehaviour(ctx) {

            @Override
            protected void onActivate(Optional<Object> message) {
                final String atomUriString = atomUri1.toString();
                final AtomContent atomContent = AtomContent.builder(atomUriString).addTitle("Granting atom").addSocket(Socket.builder(atomUriString + "#chatSocket").setSocketDefinition(WXCHAT.ChatSocket.asURI()).build()).addType(URI.create(WON.Atom.getURI())).build();
                Authorization auth = Authorization.builder().addGranteesAtomExpression(ae -> ae.addAtomsURI(atomUri2)).addGrant(ase -> ase.addOperationsSimpleOperationExpression(OP_READ).addGraph(g -> g.addGraphType(GraphType.CONTENT_GRAPH).addOperationsMessageOperationExpression(moe -> moe.addMessageOnBehalfsMessageType(MessageType.REPLACE_MESSAGE)))).build();
                WonMessage createMessage = WonMessageBuilder.createAtom().atom(atomUri1).content().graph("#content", RdfOutput.toGraph(atomContent)).content().aclGraph(won.auth.model.RdfOutput.toGraph(auth)).build();
                createMessage = ctx.getWonMessageSender().prepareMessage(createMessage);
                ctx.getBotContextWrapper().rememberAtomUri(atomUri1);
                final String action = "Create granting atom";
                EventListener successCallback = event -> {
                    logger.debug("Granting atom created");
                    createMessageUri1.set(((SuccessResponseEvent) event).getOriginalMessageURI());
                    deactivate();
                };
                EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, action);
                EventBotActionUtils.makeAndSubscribeResponseListener(createMessage, successCallback, failureCallback, ctx);
                ctx.getWonMessageSender().sendMessage(createMessage);
            }
        };
        BotBehaviour bbAtom2 = new BotBehaviour(ctx) {

            @Override
            protected void onActivate(Optional<Object> message) {
                final String atomUriString = atomUri2.toString();
                final AtomContent atomContent = AtomContent.builder(atomUriString).addTitle("Grantee atom").addSocket(Socket.builder(atomUriString + "#chatSocket").setSocketDefinition(WXCHAT.ChatSocket.asURI()).build()).addType(URI.create(WON.Atom.getURI())).build();
                WonMessage createMessage = WonMessageBuilder.createAtom().atom(atomUri2).content().graph(RdfOutput.toGraph(atomContent)).content().aclGraph(won.auth.model.RdfOutput.toGraph(getNobodyMayDoNothing())).build();
                createMessage = ctx.getWonMessageSender().prepareMessage(createMessage);
                ctx.getBotContextWrapper().rememberAtomUri(atomUri2);
                final String action = "Create grantee atom";
                EventListener successCallback = event -> {
                    logger.debug("Grantee atom created");
                    createMessageUri2.set(((SuccessResponseEvent) event).getOriginalMessageURI());
                    deactivate();
                };
                EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, action);
                EventBotActionUtils.makeAndSubscribeResponseListener(createMessage, successCallback, failureCallback, ctx);
                ctx.getWonMessageSender().sendMessage(createMessage);
            }
        };
        BotBehaviour bbReplaceAtom1FromAtom2 = new BotBehaviour(ctx) {

            @Override
            protected void onActivate(Optional<Object> message) {
                WonMessage replaceMessage = WonMessageBuilder.replace().atom(atomUri1).content().graph("#content", RdfOutput.toGraph(AtomContent.builder(atomUri1).addTitle("Replaced Title").addTag("A-New-Tag").addType(URI.create(WON.Atom.getURI())).addType(URI.create(WON.Persona.getURI())).addSocket(Socket.builder(atomUri1.toString() + "#buddySocket").setSocketDefinition(WXBUDDY.BuddySocket.asURI()).build()).addSocket(Socket.builder(atomUri1.toString() + "#holderSocket").setSocketDefinition(WXHOLD.HolderSocket.asURI()).build()).build())).build();
                String action = "replace content of atom1 using webid of atom2";
                EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, action);
                replaceMessage = ctx.getWonMessageSender().prepareMessageOnBehalf(replaceMessage, atomUri2);
                EventListener successCallback = makeLoggingCallback(bot, bus, action, () -> deactivate());
                EventBotActionUtils.makeAndSubscribeResponseListener(replaceMessage, successCallback, failureCallback, ctx);
                ctx.getWonMessageSender().sendMessage(replaceMessage);
            }
        };
        BotBehaviour readModified = new BotBehaviour(ctx) {

            @Override
            protected void onActivate(Optional<Object> message) {
                Dataset atomData = ctx.getLinkedDataSource().getDataForResource(atomUri1, atomUri1);
                Set<String> expectedGraphNames = Set.of(atomUri1 + "#acl", atomUri1 + "#acl-sig", atomUri1 + "#socket-acl", atomUri1 + "#content", atomUri1 + "#content-sig", atomUri1 + "#key", atomUri1 + "#key-sig", atomUri1 + "#sysinfo");
                Iterator<String> it = atomData.listNames();
                Set<String> actualNames = new HashSet<>();
                while (it.hasNext()) {
                    actualNames.add(it.next());
                }
                Assert.assertEquals(expectedGraphNames, actualNames);
                Shacl2JavaInstanceFactory instanceFactory = ContentUtils.newInstanceFactory();
                Shacl2JavaInstanceFactory.Accessor accessor = instanceFactory.accessor(atomData.getNamedModel(atomUri1 + "#content").getGraph());
                Optional<AtomContent> atomContent = accessor.getInstanceOfType(atomUri1.toString(), AtomContent.class);
                Assert.assertTrue("replacing content failed: replaced title not found", atomContent.get().getTitles().contains("Replaced Title"));
                Assert.assertFalse("replacing content failed: old title still there", atomContent.get().getTitles().contains("Granting atom"));
                passTest(bus);
            }
        };
        BehaviourBarrier barrier = new BehaviourBarrier(ctx);
        barrier.waitFor(bbAtom1, bbAtom2);
        barrier.thenStart(bbReplaceAtom1FromAtom2);
        barrier.activate();
        bbAtom1.activate();
        bbAtom2.activate();
        bbReplaceAtom1FromAtom2.onDeactivateActivate(readModified);
        logger.debug("Finished initializing test 'testQueryBasedMatch()'");
    });
}

Example 2 with Socket

use of won.utils.content.model.Socket in project webofneeds by researchstudio-sat.

the class AclTests method testTokenExchange.

@Test(timeout = 60 * 1000)
public void testTokenExchange() throws Exception {
    final AtomicReference<URI> createMessageUri1 = new AtomicReference();
    final AtomicReference<URI> createMessageUri2 = new AtomicReference();
    final AtomicReference<URI> createMessageUri3 = new AtomicReference();
    final AtomicReference<URI> connectionUri12 = new AtomicReference<>();
    final AtomicReference<URI> connectionUri21 = new AtomicReference<>();
    final AtomicReference<URI> connectionUri23 = new AtomicReference<>();
    final AtomicReference<URI> connectionUri32 = new AtomicReference<>();
    final AtomicReference<URI> connectMessageUri12 = new AtomicReference<>();
    final AtomicReference<URI> connectMessageUri21 = new AtomicReference<>();
    final AtomicReference<URI> connectMessageUri23 = new AtomicReference<>();
    final AtomicReference<URI> connectMessageUri32 = new AtomicReference<>();
    runTest(ctx -> {
        EventBus bus = ctx.getEventBus();
        final URI wonNodeUri = ctx.getNodeURISource().getNodeURI();
        final URI atomUri1 = ctx.getWonNodeInformationService().generateAtomURI(wonNodeUri);
        final URI atomUri2 = ctx.getWonNodeInformationService().generateAtomURI(wonNodeUri);
        final URI atomUri3 = ctx.getWonNodeInformationService().generateAtomURI(wonNodeUri);
        final BotBehaviour bbCreateAtom1 = new BotBehaviour(ctx, "bbCreateAtom1") {

            @Override
            protected void onActivate(Optional<Object> message) {
                final String atomUriString = atomUri1.toString();
                AtomContent atomContent = AtomContent.builder(atomUri1).addTitle("atom 1/3").addSocket(Socket.builder(atomUriString + "#buddySocket").setSocketDefinition(WXBUDDY.BuddySocket.asURI()).build()).addType(URI.create(WON.Atom.getURI())).build();
                Authorization auth1 = getBuddiesAndBOfBuddiesReadAllGraphsAuth();
                Authorization auth2 = getBuddiesReceiveBuddyTokenAuth();
                Authorization auth3 = getAnyoneGetsAuthInfo();
                WonMessage createMessage = WonMessageBuilder.createAtom().atom(atomUri1).content().graph(RdfOutput.toGraph(atomContent)).content().aclGraph(won.auth.model.RdfOutput.toGraph(auth1)).content().aclGraph(won.auth.model.RdfOutput.toGraph(auth2)).content().aclGraph(won.auth.model.RdfOutput.toGraph(auth3)).content().aclGraph(won.auth.model.RdfOutput.toGraph(getAnyoneMayConnectAuth())).content().aclGraph(won.auth.model.RdfOutput.toGraph(getConnectedMayCommunicateAuth())).build();
                createMessage = ctx.getWonMessageSender().prepareMessage(createMessage);
                ctx.getBotContextWrapper().rememberAtomUri(atomUri1);
                EventListener successCallback = event -> {
                    logger.debug("Connection initiating atom created");
                    createMessageUri1.set(((SuccessResponseEvent) event).getOriginalMessageURI());
                    deactivate();
                };
                EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, "Create connection initiating atom");
                EventBotActionUtils.makeAndSubscribeResponseListener(createMessage, successCallback, failureCallback, ctx);
                ctx.getWonMessageSender().sendMessage(createMessage);
            }
        };
        final BotBehaviour bbCreateAtom2 = new BotBehaviour(ctx, "bbCreateAtom2") {

            @Override
            protected void onActivate(Optional<Object> message) {
                final String atomUriString = atomUri2.toString();
                AtomContent atomContent = AtomContent.builder(atomUri2).addTitle("atom 2/3").addSocket(Socket.builder(atomUriString + "#buddySocket").setSocketDefinition(WXBUDDY.BuddySocket.asURI()).build()).addType(URI.create(WON.Atom.getURI())).build();
                Authorization auth1 = getBuddiesAndBOfBuddiesReadAllGraphsAuth();
                Authorization auth2 = getBuddiesReceiveBuddyTokenAuth();
                Authorization auth3 = getAnyoneGetsAuthInfo();
                WonMessage createMessage = WonMessageBuilder.createAtom().atom(atomUri2).content().graph(RdfOutput.toGraph(atomContent)).content().aclGraph(won.auth.model.RdfOutput.toGraph(auth1)).content().aclGraph(won.auth.model.RdfOutput.toGraph(auth2)).content().aclGraph(won.auth.model.RdfOutput.toGraph(auth3)).content().aclGraph(won.auth.model.RdfOutput.toGraph(getAnyoneMayConnectAuth())).content().aclGraph(won.auth.model.RdfOutput.toGraph(getConnectedMayCommunicateAuth())).build();
                createMessage = ctx.getWonMessageSender().prepareMessage(createMessage);
                ctx.getBotContextWrapper().rememberAtomUri(atomUri2);
                EventListener successCallback = event -> {
                    logger.debug("Connection accepting atom created");
                    createMessageUri2.set(((SuccessResponseEvent) event).getOriginalMessageURI());
                    deactivate();
                };
                EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, "Create connection accepting atom");
                EventBotActionUtils.makeAndSubscribeResponseListener(createMessage, successCallback, failureCallback, ctx);
                ctx.getWonMessageSender().sendMessage(createMessage);
            }
        };
        final BotBehaviour bbCreateAtom3 = new BotBehaviour(ctx, "bbCreateAtom3") {

            @Override
            protected void onActivate(Optional<Object> message) {
                final String atomUriString = atomUri3.toString();
                AtomContent atomContent = AtomContent.builder(atomUri3).addTitle("atom 3/3").addSocket(Socket.builder(atomUriString + "#buddySocket").setSocketDefinition(WXBUDDY.BuddySocket.asURI()).build()).addType(URI.create(WON.Atom.getURI())).build();
                Authorization auth1 = getBuddiesAndBOfBuddiesReadAllGraphsAuth();
                Authorization auth2 = getBuddiesReceiveBuddyTokenAuth();
                Authorization auth3 = getAnyoneGetsAuthInfo();
                WonMessage createMessage = WonMessageBuilder.createAtom().atom(atomUri3).content().graph(RdfOutput.toGraph(atomContent)).content().aclGraph(won.auth.model.RdfOutput.toGraph(auth1)).content().aclGraph(won.auth.model.RdfOutput.toGraph(auth2)).content().aclGraph(won.auth.model.RdfOutput.toGraph(auth3)).content().aclGraph(won.auth.model.RdfOutput.toGraph(getAnyoneMayConnectAuth())).content().aclGraph(won.auth.model.RdfOutput.toGraph(getConnectedMayCommunicateAuth())).build();
                createMessage = ctx.getWonMessageSender().prepareMessage(createMessage);
                ctx.getBotContextWrapper().rememberAtomUri(atomUri3);
                EventListener successCallback = event -> {
                    logger.debug("Connection accepting atom created");
                    createMessageUri3.set(((SuccessResponseEvent) event).getOriginalMessageURI());
                    deactivate();
                };
                EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, "Create connection accepting atom");
                EventBotActionUtils.makeAndSubscribeResponseListener(createMessage, successCallback, failureCallback, ctx);
                ctx.getWonMessageSender().sendMessage(createMessage);
            }
        };
        BotBehaviour bbSendConnect12 = new BotBehaviour(ctx, "bbSendConnect12") {

            @Override
            protected void onActivate(Optional<Object> message) {
                WonMessage connectMessage = WonMessageBuilder.connect().sockets().sender(URI.create(atomUri1.toString() + "#buddySocket")).recipient(URI.create(atomUri2.toString() + "#buddySocket")).direction().fromOwner().content().text("Hello there!").build();
                connectMessage = ctx.getWonMessageSender().prepareMessage(connectMessage);
                connectMessageUri12.set(connectMessage.getMessageURIRequired());
                EventListener successCallback = event -> {
                    logger.debug("Connection requested");
                    connectionUri12.set(((SuccessResponseEvent) event).getConnectionURI().get());
                    deactivate();
                };
                EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, "Requesting connection");
                EventBotActionUtils.makeAndSubscribeResponseListener(connectMessage, successCallback, failureCallback, ctx);
                ctx.getWonMessageSender().sendMessage(connectMessage);
            }
        };
        BotBehaviour bbAcceptConnect21 = new BotBehaviour(ctx, "bbAcceptConnect") {

            @Override
            protected void onActivate(Optional<Object> message) {
                WonMessage connectMessage = WonMessageBuilder.connect().sockets().sender(URI.create(atomUri2.toString() + "#buddySocket")).recipient(URI.create(atomUri1.toString() + "#buddySocket")).direction().fromOwner().content().text("Hello!").build();
                connectMessage = ctx.getWonMessageSender().prepareMessage(connectMessage);
                connectMessageUri21.set(connectMessage.getMessageURIRequired());
                EventListener successCallback = event -> {
                    logger.debug("Connection accepted");
                    connectionUri21.set(((SuccessResponseEvent) event).getConnectionURI().get());
                    deactivate();
                };
                EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, "Accepting connection");
                EventBotActionUtils.makeAndSubscribeResponseListener(connectMessage, successCallback, failureCallback, ctx);
                ctx.getWonMessageSender().sendMessage(connectMessage);
            }
        };
        BotBehaviour bbSendConnect32 = new BotBehaviour(ctx, "bbSendConnect32") {

            @Override
            protected void onActivate(Optional<Object> message) {
                WonMessage connectMessage = WonMessageBuilder.connect().sockets().sender(URI.create(atomUri3.toString() + "#buddySocket")).recipient(URI.create(atomUri2.toString() + "#buddySocket")).direction().fromOwner().content().text("Hello there!").build();
                connectMessage = ctx.getWonMessageSender().prepareMessage(connectMessage);
                connectMessageUri32.set(connectMessage.getMessageURIRequired());
                EventListener successCallback = event -> {
                    logger.debug("Connection requested");
                    connectionUri32.set(((SuccessResponseEvent) event).getConnectionURI().get());
                    deactivate();
                };
                EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, "Requesting connection");
                EventBotActionUtils.makeAndSubscribeResponseListener(connectMessage, successCallback, failureCallback, ctx);
                ctx.getWonMessageSender().sendMessage(connectMessage);
            }
        };
        BotBehaviour bbAcceptConnect23 = new BotBehaviour(ctx, "bbAcceptConnect23") {

            @Override
            protected void onActivate(Optional<Object> message) {
                WonMessage connectMessage = WonMessageBuilder.connect().sockets().sender(URI.create(atomUri2.toString() + "#buddySocket")).recipient(URI.create(atomUri3.toString() + "#buddySocket")).direction().fromOwner().content().text("Hello!").build();
                connectMessage = ctx.getWonMessageSender().prepareMessage(connectMessage);
                connectMessageUri23.set(connectMessage.getMessageURIRequired());
                EventListener successCallback = event -> {
                    logger.debug("Connection accepted");
                    connectionUri23.set(((SuccessResponseEvent) event).getConnectionURI().get());
                    deactivate();
                };
                EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, "Accepting connection");
                EventBotActionUtils.makeAndSubscribeResponseListener(connectMessage, successCallback, failureCallback, ctx);
                ctx.getWonMessageSender().sendMessage(connectMessage);
            }
        };
        BotBehaviour bbTestLinkedDataAccess = new BotBehaviour(ctx, "bbTestLinkedDataAccess") {

            @Override
            protected void onActivate(Optional<Object> message) {
                URI connContainerUri1 = uriService.createConnectionContainerURIForAtom(atomUri1);
                URI connContainerUri2 = uriService.createConnectionContainerURIForAtom(atomUri2);
                URI connContainerUri3 = uriService.createConnectionContainerURIForAtom(atomUri3);
                boolean passed = true;
                // both atoms allow each other read access
                passed = passed && testLinkedDataRequestOk(ctx, bus, "test1.", atomUri1, atomUri1, atomUri2, // createMessageUri1.get(),
                connContainerUri1, connectionUri12.get(), connectMessageUri12.get(), connectMessageUri21.get(), connectionUri21.get(), connContainerUri2);
                passed = passed && testLinkedDataRequestFails(ctx, bus, "test2.", atomUri1, LinkedDataFetchingException.class, // createMessageUri2.get(),
                atomUri3, connContainerUri3);
                passed = passed && testLinkedDataRequestOk(ctx, bus, "test3.", atomUri2, atomUri2, atomUri1, // createMessageUri2.get(),
                connContainerUri2, connectionUri21.get(), connectMessageUri21.get(), connectMessageUri12.get(), connectionUri12.get(), connContainerUri3, connContainerUri1, connectionUri32.get(), atomUri3);
                passed = passed && testLinkedDataRequestFails(ctx, bus, "test4.", atomUri2, LinkedDataFetchingException.class, createMessageUri1.get(), createMessageUri3.get());
                deactivate();
            }
        };
        BotBehaviour bbRequestBuddyToken = new BotBehaviour(ctx) {

            @Override
            protected void onActivate(Optional<Object> message) {
                testLinkedDataRequest(ctx, bus, LinkedDataFetchingException.ForbiddenAuthMethodProvided.class, false, null, null, atomUri3, "test 5.1 - read atom3");
                URI tokenrequest = uriService.createTokenRequestURIForAtomURIWithScopes(atomUri2, WXBUDDY.BuddySocket.asString());
                testTokenRequest(ctx, bus, IllegalArgumentException.class, false, null, null, tokenrequest, "test5.2 - request token");
                Set<String> resultingTokens = new HashSet();
                testTokenRequest(ctx, bus, null, false, atomUri1, null, tokenrequest, "test5.3 - request buddy socket token from atom2 using webID atom1", resultingTokens);
                String token = resultingTokens.stream().findFirst().get();
                testLinkedDataRequest(ctx, bus, null, false, null, token, atomUri3, "test 5.4- read atom3 with token issued for atom 1");
                testLinkedDataRequest(ctx, bus, null, false, null, token, atomUri2, "test 5.5 - read atom2 with token issued for atom 1");
                deactivate();
            }
        };
        BotBehaviour bbTestLinkedDataAccessWithToken = new BotBehaviour(ctx) {

            @Override
            protected void onActivate(Optional<Object> message) {
                passTest(bus);
            }
        };
        BehaviourBarrier barrier = new BehaviourBarrier(ctx);
        barrier.waitFor(bbCreateAtom1, bbCreateAtom2, bbCreateAtom3);
        barrier.thenStart(bbSendConnect12);
        barrier.activate();
        bbSendConnect12.onDeactivateActivate(bbAcceptConnect21);
        bbAcceptConnect21.onDeactivateActivate(bbSendConnect32);
        bbSendConnect32.onDeactivateActivate(bbAcceptConnect23);
        bbAcceptConnect23.onDeactivateActivate(bbTestLinkedDataAccess);
        bbTestLinkedDataAccess.onDeactivateActivate(bbRequestBuddyToken);
        bbRequestBuddyToken.onDeactivateActivate(bbTestLinkedDataAccessWithToken);
        bbCreateAtom1.activate();
        bbCreateAtom2.activate();
        bbCreateAtom3.activate();
    });
}

Example 3 with Socket

use of won.utils.content.model.Socket in project webofneeds by researchstudio-sat.

the class AclTests method testCreateAtomWithEmptyACLButSocketAuths_isNotPubliclyReadable.

@Test(timeout = 60 * 1000)
public void testCreateAtomWithEmptyACLButSocketAuths_isNotPubliclyReadable() throws Exception {
    runTest(ctx -> {
        EventBus bus = ctx.getEventBus();
        final URI wonNodeUri = ctx.getNodeURISource().getNodeURI();
        final URI atomUri = ctx.getWonNodeInformationService().generateAtomURI(wonNodeUri);
        final String atomUriString = atomUri.toString();
        final AtomContent atomContent = new AtomContent(atomUriString);
        atomContent.addTitle("Unit Test Atom ACL Test 1");
        final Socket holderSocket = new Socket(atomUriString + "#holderSocket");
        holderSocket.setSocketDefinition(WXHOLD.HolderSocket.asURI());
        final Socket buddySocket = new Socket(atomUriString + "#buddySocket");
        buddySocket.setSocketDefinition(WXBUDDY.BuddySocket.asURI());
        atomContent.addSocket(holderSocket);
        atomContent.addSocket(buddySocket);
        atomContent.addType(URI.create(WON.Atom.getURI()));
        WonMessage createMessage = WonMessageBuilder.createAtom().atom(atomUri).content().graph(RdfOutput.toGraph(atomContent)).content().aclGraph(// add an empty acl graph
        GraphFactory.createGraphMem()).build();
        createMessage = ctx.getWonMessageSender().prepareMessage(createMessage);
        ctx.getBotContextWrapper().rememberAtomUri(atomUri);
        final String action = "Create Atom action";
        EventListener successCallback = event -> {
            ((CachingLinkedDataSource) ctx.getLinkedDataSource()).clear();
            boolean passed = true;
            passed = passed && testLinkedDataRequestOk(ctx, bus, "withWebid", atomUri, atomUri);
            passed = passed && testLinkedDataRequestFailsNoWebId(ctx, bus, "withoutWebId", LinkedDataFetchingException.Forbidden.class);
            if (passed) {
                passTest(bus);
            }
        };
        EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, action);
        EventBotActionUtils.makeAndSubscribeResponseListener(createMessage, successCallback, failureCallback, ctx);
        ctx.getWonMessageSender().sendMessage(createMessage);
    });
}

Example 4 with Socket

use of won.utils.content.model.Socket in project webofneeds by researchstudio-sat.

the class SimpleTests method testCreatePersonaWithoutACL.

@Test(timeout = 60 * 1000)
public void testCreatePersonaWithoutACL() throws Exception {
    runTest(ctx -> {
        EventBus bus = ctx.getEventBus();
        final URI wonNodeUri = ctx.getNodeURISource().getNodeURI();
        final URI atomUri = ctx.getWonNodeInformationService().generateAtomURI(wonNodeUri);
        final String atomUriString = atomUri.toString();
        final AtomContent atomContent = new AtomContent(atomUriString);
        atomContent.addTitle("Unit Test Atom ");
        final Socket holderSocket = new Socket(atomUriString + "#holderSocket");
        holderSocket.setSocketDefinition(WXHOLD.HolderSocket.asURI());
        final Socket buddySocket = new Socket(atomUriString + "#buddySocket");
        buddySocket.setSocketDefinition(WXBUDDY.BuddySocket.asURI());
        atomContent.addSocket(holderSocket);
        atomContent.addSocket(buddySocket);
        atomContent.addType(URI.create(WON.Persona.getURI()));
        atomContent.addType(URI.create(WON.Atom.getURI()));
        WonMessage createMessage = WonMessageBuilder.createAtom().atom(atomUri).content().graph(RdfOutput.toGraph(atomContent)).build();
        createMessage = ctx.getWonMessageSender().prepareMessage(createMessage);
        ctx.getBotContextWrapper().rememberAtomUri(atomUri);
        final String action = "Create Atom action";
        EventListener successCallback = makeSuccessCallbackToPassTest(bot, bus, action);
        EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, action);
        EventBotActionUtils.makeAndSubscribeResponseListener(createMessage, successCallback, failureCallback, ctx);
        ctx.getWonMessageSender().sendMessage(createMessage);
    });
}

Example 5 with Socket

use of won.utils.content.model.Socket in project webofneeds by researchstudio-sat.

the class SimpleTests method testQueryBasedMatch.

@Test(timeout = 60 * 1000)
public void testQueryBasedMatch() throws Exception {
    final AtomicBoolean atom1Created = new AtomicBoolean(false);
    final AtomicBoolean atom2Created = new AtomicBoolean(false);
    runTest(ctx -> {
        EventBus bus = ctx.getEventBus();
        final URI wonNodeUri = ctx.getNodeURISource().getNodeURI();
        final URI atomUri1 = ctx.getWonNodeInformationService().generateAtomURI(wonNodeUri);
        {
            final String atomUriString = atomUri1.toString();
            final AtomContent atomContent = new AtomContent(atomUriString);
            atomContent.addTitle("Match target atom");
            atomContent.addTag("tag-to-match");
            final Socket chatSocket = new Socket(atomUriString + "#chatSocket");
            chatSocket.setSocketDefinition(WXCHAT.ChatSocket.asURI());
            atomContent.addSocket(chatSocket);
            atomContent.addType(URI.create(WON.Atom.getURI()));
            WonMessage createMessage = WonMessageBuilder.createAtom().atom(atomUri1).content().graph(RdfOutput.toGraph(atomContent)).build();
            createMessage = ctx.getWonMessageSender().prepareMessage(createMessage);
            ctx.getBotContextWrapper().rememberAtomUri(atomUri1);
            final String action = "Create match target atom";
            EventListener successCallback = event -> {
                logger.debug("Match target atom created");
                atom1Created.set(true);
            };
            EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, action);
            EventBotActionUtils.makeAndSubscribeResponseListener(createMessage, successCallback, failureCallback, ctx);
            ctx.getWonMessageSender().sendMessage(createMessage);
        }
        // create match source
        final URI atomUri2 = ctx.getWonNodeInformationService().generateAtomURI(wonNodeUri);
        {
            final String atomUriString = atomUri2.toString();
            final AtomContent atomContent = new AtomContent(atomUriString);
            atomContent.addTitle("Match source atom");
            atomContent.addSparqlQuery("PREFIX won:<https://w3id.org/won/core#>\n" + "PREFIX con:<https://w3id.org/won/content#>\n" + "SELECT ?result (1.0 AS ?score) WHERE {" + "?result a won:Atom ;" + "    con:tag \"tag-to-match\"." + "}");
            final Socket chatSocket = new Socket(atomUriString + "#chatSocket");
            chatSocket.setSocketDefinition(WXCHAT.ChatSocket.asURI());
            atomContent.addSocket(chatSocket);
            atomContent.addType(URI.create(WON.Atom.getURI()));
            WonMessage createMessage = WonMessageBuilder.createAtom().atom(atomUri2).content().graph(RdfOutput.toGraph(atomContent)).build();
            createMessage = ctx.getWonMessageSender().prepareMessage(createMessage);
            ctx.getBotContextWrapper().rememberAtomUri(atomUri2);
            final String action = "Create match source atom";
            EventListener successCallback = event -> {
                logger.debug("Match source atom created");
                atom2Created.set(true);
            };
            EventListener failureCallback = makeFailureCallbackToFailTest(bot, ctx, bus, action);
            EventBotActionUtils.makeAndSubscribeResponseListener(createMessage, successCallback, failureCallback, ctx);
            ctx.getWonMessageSender().sendMessage(createMessage);
        }
        // create listener waiting for the hint
        bus.subscribe(HintFromMatcherEvent.class, (Event event) -> ((HintFromMatcherEvent) event).getRecipientAtom().equals(atomUri2) && ((HintFromMatcherEvent) event).getHintTargetAtom().equals(atomUri1), makeAction(ctx, event -> bus.publish(new TestPassedEvent(bot))));
        logger.debug("Finished initializing test 'testQueryBasedMatch()'");
    });
}