Package org.apache.abdera.protocol.client

Examples of org.apache.abdera.protocol.client.AbderaClient


    @Test
    public void testJCRAdapter() throws Exception {
        Abdera abdera = new Abdera();
        Factory factory = abdera.getFactory();

        AbderaClient client = new AbderaClient(abdera);

        String base = "http://localhost:9002/";

        // Testing of entry creation
        IRI colUri = new IRI(base).resolve("feed");
        Entry entry = factory.newEntry();
        entry.setTitle("Some Entry");
        entry.setUpdated(new Date());
        entry.addAuthor("Dan Diephouse");
        entry.setId(factory.newUuidUri());
        entry.setSummary("This is my entry.");
        entry.setContent("This is my entry. It's swell.");

        RequestOptions opts = new RequestOptions();
        opts.setContentType("application/atom+xml;type=entry");
        ClientResponse res = client.post(colUri.toString(), entry, opts);
        assertEquals(201, res.getStatus());

        // prettyPrint(abdera, res.getDocument());

        IRI location = res.getLocation();
        assertEquals(base + "feed/Some_Entry", location.toString());

        // GET the entry
        res = client.get(location.toString());
        assertEquals(200, res.getStatus());

        // prettyPrint(abdera, res.getDocument());
        org.apache.abdera.model.Document<Entry> entry_doc = res.getDocument();
        Entry entry2 = entry_doc.getRoot();

        assertEquals(entry.getTitle(), entry2.getTitle());
        assertEquals(entry.getSummary(), entry2.getSummary());
        assertEquals(entry.getContent(), entry2.getContent());

        List<Person> authors = entry2.getAuthors();
        assertEquals(1, authors.size());

        entry = entry2;
        entry.setSummary("New Summary");
        entry.setContent("New Content");

        res = client.put(location.toString(), entry, opts);
        assertEquals(204, res.getStatus());

        res = client.get(colUri.toString());
        org.apache.abdera.model.Document<Feed> feed_doc = res.getDocument();
        Feed feed = feed_doc.getRoot();

        assertEquals(1, feed.getEntries().size());
        // prettyPrint(abdera, feed_doc);

        // test 404 not found
        res = client.get(location.toString() + "Invalid");
        assertEquals(404, res.getStatus());
    }
View Full Code Here


    public static List<Element> discoverLinks(String uri, String type, String... rel) throws IOException {
        return discoverLinks(Abdera.getInstance(), uri, type, rel);
    }

    public static List<Element> discoverLinks(Abdera abdera, String uri, String type, String... rel) throws IOException {
        AbderaClient client = new AbderaClient(abdera);
        ClientResponse resp = client.get(uri);
        InputStream in = resp.getInputStream();
        InputStreamReader r = new InputStreamReader(in);
        XmlRestrictedCharReader x = new XmlRestrictedCharReader(r);
        Document<Element> doc = HtmlHelper.parseDocument(x);
        List<Element> list = discoverLinks(doc.getRoot(), type, rel);
View Full Code Here

        // assertEquals(resp1, "5");
    }

    @Test
    public void testResponseMustRevalidate() throws Exception {
        AbderaClient abderaClient = new AbderaClient();
        RequestOptions options = abderaClient.getDefaultRequestOptions();
        options.setHeader("Connection", "close");
        options.setHeader("x-reqnum", "1");
        ClientResponse response = abderaClient.get(CHECK_MUST_REVALIDATE, options);

        String resp1 = getResponse(response);
        assertEquals("1", resp1);

        // Should be revalidated and use the cache
        options.setHeader("x-reqnum", "2");
        response = abderaClient.get(CHECK_MUST_REVALIDATE, options);
        assertTrue(response instanceof CachedResponse);

        String resp2 = getResponse(response);
        assertEquals("1", resp2);

        // Should be revalidated and return a 404
        options.setHeader("x-reqnum", "3");
        response = abderaClient.get(CHECK_MUST_REVALIDATE, options);
        assertEquals(404, response.getStatus());
        response.release();

    }
View Full Code Here

        return options;
    }

    private void _methodInvalidates(int type) throws Exception {

        AbderaClient abderaClient = new AbderaClient();
        RequestOptions options = getRequestOptions(abderaClient, 1);
        ClientResponse response = abderaClient.get(CHECK_CACHE_INVALIDATE, options);

        String resp1 = getResponse(response);

        response.release();
        assertEquals("1", resp1);

        // calling a method that could change state on the server should invalidate the cache
        options = getRequestOptions(abderaClient, 2);
        switch (type) {
            case POST:
                response = abderaClient.post(CHECK_CACHE_INVALIDATE, new ByteArrayInputStream("".getBytes()), options);
                break;
            case PUT:
                response = abderaClient.put(CHECK_CACHE_INVALIDATE, new ByteArrayInputStream("".getBytes()), options);
                break;
            case DELETE:
                response = abderaClient.delete(CHECK_CACHE_INVALIDATE, options);
                break;
        }
        response.release();

        options = getRequestOptions(abderaClient, 3);
        response = abderaClient.get(CHECK_CACHE_INVALIDATE, options);

        resp1 = getResponse(response);
        response.release();
        assertEquals("3", resp1);
    }
View Full Code Here

        assertEquals("3", resp1);
    }

    private void _requestCacheInvalidation(int type) throws Exception {

        AbderaClient abderaClient = new AbderaClient();
        RequestOptions options = getRequestOptions(abderaClient, 1);
        ClientResponse response = abderaClient.get(CHECK_CACHE_INVALIDATE, options);
        String resp1 = getResponse(response);
        assertEquals("1", resp1);

        // Should not use the cache
        options = getRequestOptions(abderaClient, 2);
        switch (type) {
            case NOCACHE:
                options.setNoCache(true);
                break;
            case NOSTORE:
                options.setNoStore(true);
                break;
            case MAXAGE0:
                options.setMaxAge(0);
                break;
        }
        response = abderaClient.get(CHECK_CACHE_INVALIDATE, options);

        String resp2 = getResponse(response);
        assertEquals("2", resp2);

        // Should use the cache
        options = getRequestOptions(abderaClient, 3);
        switch (type) {
            case NOCACHE:
                options.setNoCache(false);
                break;
            case NOSTORE:
                options.setNoStore(false);
                break;
            case MAXAGE0:
                options.setMaxAge(60);
                break;
        }
        response = abderaClient.get(CHECK_CACHE_INVALIDATE, options);

        String resp3 = getResponse(response);
        assertEquals("2", resp3);
    }
View Full Code Here

        assertEquals("2", resp3);
    }

    private void _responseNoCache(int type) throws Exception {

        AbderaClient abderaClient = new AbderaClient();
        RequestOptions options = getRequestOptions(abderaClient, 1);
        options.setHeader("x-reqtest", String.valueOf(type));
        ClientResponse response = abderaClient.get(CHECK_NO_CACHE, options);

        String resp1 = getResponse(response);
        assertEquals("1", resp1);

        // Should not use the cache

        options = getRequestOptions(abderaClient, 2);
        options.setHeader("x-reqtest", String.valueOf(type));
        response = abderaClient.get(CHECK_NO_CACHE, options);

        String resp2 = getResponse(response);
        assertEquals("2", resp2);

        // Should use the cache
        options = getRequestOptions(abderaClient, 3);
        options.setHeader("x-reqtest", String.valueOf(type));
        response = abderaClient.get(CHECK_NO_CACHE, options);

        String resp3 = getResponse(response);
        assertEquals("3", resp3);
    }
View Full Code Here

        return resp.trim();
    }

    @Test
    public void testInitCache() {
        AbderaClient client = new AbderaClient();
        assertNotNull(client.getCache());
    }
View Full Code Here

                          "/collections/*");
    }

    @Test
    public void testRequestOptions() throws Exception {
        AbderaClient abderaClient = new AbderaClient();
        RequestOptions options = abderaClient.getDefaultRequestOptions();
        options.setIfModifiedSince(new Date());
        assertNotNull(options.getIfModifiedSince());

        options.set4xxRequestException(true);
        assertTrue(options.is4xxRequestException());
View Full Code Here

        assertTrue(options.isUsePostOverride());
    }

    @Test
    public void testAppClient() throws Exception {
        AbderaClient abderaClient = new AbderaClient();
        Entry entry = getFactory().newEntry();
        RequestOptions options = abderaClient.getDefaultRequestOptions();
        options.setHeader("Connection", "close");
        options.setUseExpectContinue(false);

        // do the introspection step
        ClientResponse response = abderaClient.get("http://localhost:" + JettyUtil.getPort() + "/service", options);
        String col_uri;

        try {
            assertEquals(200, response.getStatus());

            Document<Service> service_doc = response.getDocument();
            assertNotNull(service_doc);
            assertEquals(1, service_doc.getRoot().getWorkspaces().size());

            Workspace workspace = service_doc.getRoot().getWorkspace("Test");
            assertNotNull(workspace);

            for (Collection c : workspace.getCollections()) {
                assertNotNull(c.getTitle());
                assertNotNull(c.getHref());
            }

            col_uri = getBase() + "/collections/entries";
        } finally {
            response.release();
        }

        // post a new entry
        response = abderaClient.post(col_uri, entry, options);

        String self_uri;

        try {
            assertEquals(201, response.getStatus());
            assertNotNull(response.getLocation());
            assertNotNull(response.getContentLocation());

            self_uri = response.getLocation().toString();
        } finally {
            response.release();
        }

        // get the collection to see if our entry is there
        response = abderaClient.get(col_uri, options);

        try {
            assertEquals(200, response.getStatus());
            Document<Feed> feed_doc = response.getDocument();
            assertEquals(1, feed_doc.getRoot().getEntries().size());
        } finally {
            response.release();
        }

        // get the entry to see if we can get it
        response = abderaClient.get(self_uri, options);

        String edit_uri;

        try {
            assertEquals(200, response.getStatus());
            Document<Entry> entry_doc = response.getDocument();

            // this isn't always true, but for our tests they are the same
            assertEquals(self_uri, entry_doc.getRoot().getId().toString());

            // get the edit uri from the entry
            edit_uri = entry_doc.getRoot().getEditLink().getHref().toString();

            // change the entry
            Document<Entry> doc = response.getDocument();
            entry = (Entry)doc.getRoot().clone();
            entry.setTitle("New title");
        } finally {
            response.release();
        }

        // submit the changed entry back to the server
        response = abderaClient.put(edit_uri, entry, options);

        try {
            assertEquals(204, response.getStatus());
        } finally {
            response.release();
        }

        // check to see if the entry was modified properly
        response = abderaClient.get(self_uri, options);

        try {
            assertEquals(200, response.getStatus());

            Document<Entry> entry_doc = response.getDocument();
            assertEquals("New title", entry_doc.getRoot().getTitle());
        } finally {
            response.release();
        }

        // delete the entry
        response = abderaClient.delete(edit_uri, options);

        try {
            assertEquals(204, response.getStatus());
        } finally {
            response.release();
        }

        // is it gone?
        response = abderaClient.get(self_uri, options);

        try {
            assertEquals(404, response.getStatus());
        } finally {
            response.release();
        }

        // YAY! We're a working APP client

        // Now let's try to do a media post

        // Post the media resource
        options = abderaClient.getDefaultRequestOptions();
        options.setContentType("text/plain");
        options.setHeader("Connection", "close");
        options.setUseExpectContinue(false);

        response = abderaClient.post(col_uri, new ByteArrayInputStream("test".getBytes()), options);

        try {
            assertEquals(201, response.getStatus());
            assertNotNull(response.getLocation());
            assertNotNull(response.getContentLocation());

            self_uri = response.getLocation().toString();
        } finally {
            response.release();
        }

        // was an entry created?
        options = abderaClient.getDefaultRequestOptions();
        options.setHeader("Connection", "close");
        response = abderaClient.get(self_uri, options);

        String edit_media, media;

        try {
            assertEquals(200, response.getStatus());
            Document<Entry> entry_doc = response.getDocument();

            // this isn't always true, but for our tests they are the same
            assertEquals(self_uri, entry_doc.getRoot().getId().toString());

            // get the right links from the entry
            edit_uri = entry_doc.getRoot().getEditLink().getHref().toString();
            edit_media = entry_doc.getRoot().getLink("edit-media").getHref().toString();
            media = entry_doc.getRoot().getContentElement().getSrc().toString();

            // edit the entry
            Document<Entry> doc = response.getDocument();
            entry = (Entry)doc.getRoot().clone();
            entry.setTitle("New title");
        } finally {
            response.release();
        }

        // submit the changes
        options = abderaClient.getDefaultRequestOptions();
        options.setContentType("application/atom+xml;type=entry");
        options.setHeader("Connection", "close");
        options.setUseExpectContinue(false);

        response = abderaClient.put(edit_uri, entry, options);

        try {
            assertEquals(204, response.getStatus());
        } finally {
            response.release();
        }

        // get the media resource
        response = abderaClient.get(media);

        try {
            assertEquals(200, response.getStatus());

            String mediavalue = read(response.getInputStream());
            assertEquals("test", mediavalue);
        } finally {
            response.release();
        }

        // edit the media resource
        options = abderaClient.getDefaultRequestOptions();
        options.setHeader("Connection", "close");
        options.setContentType("text/plain");
        options.setUseExpectContinue(false);

        response = abderaClient.put(edit_media, new ByteArrayInputStream("TEST".getBytes()), options);

        try {
            assertEquals(204, response.getStatus());
        } finally {
            response.release();
        }

        // was the resource changed?
        response = abderaClient.get(media, options);

        try {
            assertEquals(200, response.getStatus());

            String mediavalue = read(response.getInputStream());
            assertEquals("TEST", mediavalue);
        } finally {
            response.release();
        }

        // delete the entry
        response = abderaClient.delete(edit_uri, options);

        try {
            assertEquals(204, response.getStatus());
        } finally {
            response.release();
        }

        // is the entry gone?
        response = abderaClient.get(self_uri, options);

        try {
            assertEquals(404, response.getStatus());
        } finally {
            response.release();
        }

        // is the media resource gone?
        options.setNoCache(true); // need to force revalidation to check

        response = abderaClient.get(media, options);

        try {
            assertEquals(404, response.getStatus());
        } finally {
            response.release();
View Full Code Here

        this.server.stop();
    }

    @Test
    public void testProcessSuccessfully() throws Exception {
        AbderaClient client = new AbderaClient();
        ClientResponse response = null;
        // Test with first adapter:
        response = client.get("http://localhost:9002/search1?q=test1&c=1");
        assertEquals(200, response.getStatus());
        // Test with second adapter:
        client.get("http://localhost:9002/search2?q=test2&c=1");
        assertEquals(200, response.getStatus());
    }
View Full Code Here

TOP

Related Classes of org.apache.abdera.protocol.client.AbderaClient

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.