MainTest.java

package com.teamtreehouse.blog;

import com.teamtreehouse.blog.dao.Sql2oBlogDao;
import com.teamtreehouse.blog.dao.Sql2oEntryDao;
import com.teamtreehouse.blog.model.BlogEntry;
import com.teamtreehouse.blog.model.Comment;
import com.teamtreehouse.blog.testing.ApiClient;
import com.teamtreehouse.blog.testing.ApiResponse;
import org.junit.*;
import org.junit.rules.TestRule;
import org.junit.rules.TestWatcher;
import org.junit.runner.Description;
import org.sql2o.Connection;
import org.sql2o.Sql2o;
import spark.ModelAndView;
import spark.Spark;
import spark.template.handlebars.HandlebarsTemplateEngine;

import java.util.HashMap;
import java.util.Map;

import static org.junit.Assert.*;

public class MainTest {
    // test port
    private static final String PORT = "4568";
    // test data source
    private static final String TEST_DATASOURCE = "jdbc:h2:mem:testing";
    // database connection
    private Connection mConnection;
    // our main testing class, generating requests, and returning responses
    private ApiClient mApiClient;
    // used to check cookie with password
    private static final String mCookieWithPassword = "password=admin";
    // right password
    private final String mRightPassword = "admin";
    // used for checking error page
    private static final String NOT_FOUND_MESSAGE = "No such entry found";
    // model of error page to be put to handlebars template engine
    private HashMap<String, Object> mErrorPageModel;

    // DAOs
    private Sql2oBlogDao mSql2oBlogDao;
    private Sql2oEntryDao mSql2oEntryDao;

    // just to print test names before tests
    @Rule
    public TestRule watcher = new TestWatcher() {
        protected void starting(Description description) {
            System.out.printf("%n -------- Starting test: %s %n",description.getMethodName());
        }
    };

    @BeforeClass
    public static void startServer() {
        // setting up our Api with port and test data source
        String[] args = {PORT, TEST_DATASOURCE};
        Main.main(args);
        // wait until server is up and running
        Spark.awaitInitialization();
    }
    @AfterClass
    public static void stopServer() {
        Spark.stop();
    }

    @Before
    public void setUp() throws Exception {
        // get our DAOs connected with database
        String connectionString = TEST_DATASOURCE +
                ";INIT=RUNSCRIPT from 'classpath:db/init.sql'";
        Sql2o sql2o = new Sql2o(connectionString, "", "");
        mConnection = sql2o.open();
        mSql2oBlogDao = Main.getSql2oBlogDao();
        mSql2oEntryDao = Main.getSql2oEntryDao();
        // fill our test database with three test entries
        // set up our ApiClient
        mApiClient = new ApiClient("http://localhost:" + PORT);
        // generate error 404 page model
        mErrorPageModel = new HashMap<>();
        mErrorPageModel.put("status", 404);
        mErrorPageModel.put("errorMessage", NOT_FOUND_MESSAGE);
        // make first request to index page to fill our database
        mApiClient.request("GET", "/");
    }

    @After
    public void tearDown() throws Exception {
        mConnection.close();
    }
    // methods to get html page as a string giving a .hbs file name and model
    // to put, null or filled
    // @return String - rendered html with Handlebars template engine
    private String getHtmlOfPageWithHbsWithNullModel(String hbsFileName) {
        HandlebarsTemplateEngine handlebarsTemplateEngine =
                new HandlebarsTemplateEngine();
        return handlebarsTemplateEngine
                .render(new ModelAndView(null, hbsFileName));
    }
    private String getHtmlOfPageWithHbsWithModel(String hbsFileName,
                                                 Map<?,?> model) {
        HandlebarsTemplateEngine handlebarsTemplateEngine =
                new HandlebarsTemplateEngine();
        return handlebarsTemplateEngine
                .render(new ModelAndView(model, hbsFileName));
    }
    // methods to get response body of GET request to given URI with or without
    // password cookie
    // @return String - body of response
    private String
        getResponseBodyOfGetRequestWithoutPasswordCookie(String pageUri) {
        return mApiClient
                .request("GET", pageUri)
                .getBody();
    }
    private String
        getResponseBodyOfGetRequestWithRightPasswordCookie(String pageUri) {
        return mApiClient
                .request("GET", pageUri, null, mCookieWithPassword)
                .getBody();
    }
    // methods to get response body of POST request to given URI with or without
    // password cookie
    // @return String - body of response
    private String
        getResponseBodyOfPostRequestWithoutPasswordCookie(String pageUri,
                                                          String requestBody) {
        return mApiClient
                .request("POST", pageUri, requestBody)
                .getBody();
    }
    private String
        getResponseBodyOfPostRequestWithRightPasswordCookie(
            String pageUri, String requestBody) {
        return mApiClient
                .request("POST", pageUri, requestBody, mCookieWithPassword)
                .getBody();
    }

    // actual tests
    @Test
    public void unauthorisedGetRequestOnNewEntryPageRedirectsToPasswordPage()
        throws Exception {
        // Given no cookies with password
        // When get to new entries page
        // password html page should come as a response
        assertEquals(
                getHtmlOfPageWithHbsWithNullModel("password.hbs"),
                getResponseBodyOfGetRequestWithoutPasswordCookie("/entries/new"));
    }
    @Test
    public void unauthorisedGetRequestOnEditEntryPageRedirectsToPasswordPage()
            throws Exception {
        // Given no cookies with password
        // When get request to edit entries page is made
        // Then password html page should come as a response, even if there are
        // no such entry
        assertEquals(
                getHtmlOfPageWithHbsWithNullModel("password.hbs"),
                getResponseBodyOfGetRequestWithoutPasswordCookie("/entries/edit/somePage"));
    }
    @Test
    public void unauthorisedPostRequestOnSaveEntryPageRedirectsToPasswordPage()
            throws Exception {
        // Given no cookies with password
        // When get request to edit entries page is made
        // Then password html page should come as a response, even if there are
        // no such entry
        assertEquals(
                getHtmlOfPageWithHbsWithNullModel("password.hbs"),
                getResponseBodyOfPostRequestWithoutPasswordCookie(
                        "/entries/save/somePage","title=title&body=body"));
    }
    @Test
    public void unauthorisedGetRequestOnRemoveEntryPageRedirectsToPasswordPage()
            throws Exception {
        // Given no cookies with password
        // When get request to edit entries page is made
        // Then password html page should come as a response, even if there are
        // no such entry
        assertEquals(
                getHtmlOfPageWithHbsWithNullModel("password.hbs"),
                getResponseBodyOfGetRequestWithoutPasswordCookie(
                        "/entries/remove/somePage")
        );
    }

    @Test
    public void authorizedGetRequestOnNewEntryPageShowsNewPage() throws Exception {
        // Given cookie with password
        // When get request to new entry page is made
        // Then new entry page is returned
        assertEquals(
                getHtmlOfPageWithHbsWithNullModel("new.hbs"),
                getResponseBodyOfGetRequestWithRightPasswordCookie("/entries/new"));
    }

    @Test
    public void authorizedRequestOnNonExistingDetailEntryPageShowsNotFoundPage()
            throws Exception {
        // Given cookie with password
        // When get request to non-existing edit entry page is made
        // Then not-found error page is returned
        assertEquals(
                getHtmlOfPageWithHbsWithModel("not-found.hbs", mErrorPageModel),
                getResponseBodyOfGetRequestWithRightPasswordCookie(
                        "/entries/detail/1234543/title"));
    }
    @Test
    public void authorizedRequestOnEditEntryPageWithNoEntriesShowsNotFoundPage()
            throws Exception {
        // Given cookie with password
        // model of error page:
        // When get request to non-existing edit entry page is made
        // Then not-found error page is returned
        assertEquals(
                getHtmlOfPageWithHbsWithModel("not-found.hbs", mErrorPageModel),
                getResponseBodyOfGetRequestWithRightPasswordCookie(
                        "/entries/edit/1234543/title"));
    }
//
//    // Not quite right test, but I will still leave it here
//    @Test
//    public void addingNewEntryWithPostRequestReturnsRightResponseHomePageWithNewEntry()
//            throws Exception {
//        // Given initial DAO with 3 test entries, model of html created by
//        // handlebars template engine, with all entries from POST request
//
//        // When POST request to new page is made, and new DAO is used to
//        // create index page
//        ApiResponse apiResponse =
//                mApiClient.request("POST",
//                        "/entries/new",
//                        "title=title&body=body&tags=tag1",
//                        mCookieWithPassword);
//        Map<String, Object> model = new HashMap<>();
//        model.put("entries", Main.mSimpleBlogDao.findAllEntries());
//        // then body of response should be same as of index page with simple
//        // blog entry dao given
//        assertEquals(
//                getHtmlOfPageWithHbsWithModel("index.hbs", model),
//                apiResponse.getBody()
//        );
//    }
//
    @Test
    public void givingWrongPasswordRedirectsBackToHomePageWhenSessionIsNew()
            throws Exception {
        // Given no cookies with password, and new empty session
        // When user tries type wrong password, ( same will happen when
        // password  is right )
        // Then home page is returned back
        Map<String, Object> model = new HashMap<>();
        model.put("entries", mSql2oBlogDao.findAllEntries());
        assertEquals(
                getHtmlOfPageWithHbsWithModel("index.hbs", model),
                getResponseBodyOfPostRequestWithoutPasswordCookie(
                        "/password","password=password"));
    }
//
//    // test does not work because session is not saved in filter method,
//    // however, line with redirect to protected page in post("/password/page")
//    // is there
//    @Test
//    public void givingRightPasswordRedirectsBackToPageWhereHeAskedFor()
//            throws Exception {
//        // Given no cookies with password, and session with new page
//        // set after get request sent to page with new entries
//        mApiClient.request("GET", "/entries/new");
//        ApiResponse apiResponse = mApiClient.request("POST",
//                "/password",
//                "password=" + mRightPassword,
//                "password=" + mRightPassword + "; JSESSIONID=" + Main.getSessionId());
//        // When user tries type right password, making POST request at
//        // password page
//        // Then home page is returned back
//        assertEquals(
//                getHtmlOfPageWithHbsWithNullModel("password.hbs"),
//                apiResponse.getBody()
//                );
//    }
//
//

    @Test
    public void newEntryIncreasesSizeOfDatabase() throws Exception {
        // Given cookie with password,
        // When user posts new entry
        getResponseBodyOfPostRequestWithRightPasswordCookie(
                "/entries/new","title=title&body=body");
        // Then size of DAO is increased
        assertEquals(4, mSql2oBlogDao.findAllEntries().size());
    }

    @Test
    public void detailPageReturnedRightAsWeExpected() throws Exception {
        // Given no cookies with password, no sessions, and first blog entry
        // with its comments
        BlogEntry firstBlogEntry =
                mSql2oBlogDao.findEntryById(1);
        HashMap<String, Object> model = new HashMap<>();
        model.put("entry", firstBlogEntry);
        model.put("comments", mSql2oEntryDao.findByEntryId(1));
        // When we make GET request to detail page of first test Entry
        String requestBodyOfGetRequestToDetailPage =
                getResponseBodyOfGetRequestWithRightPasswordCookie(
                        "/entries/detail/"
                        + firstBlogEntry.getId() + "/"
                        + firstBlogEntry.getSlugFromTitle()
                );
        // Then body of detail page modeled offline using handlebars
        // should be equal to response body of actual detail page
        assertEquals(
                getHtmlOfPageWithHbsWithModel("detail.hbs", model),
                requestBodyOfGetRequestToDetailPage
        );
    }

    @Test
    public void postToEntriesDetailsPageThatDoesNotExistsReturnsNotFoundPage()
            throws Exception {
        // Given no cookies with password, no sessions, database with three
        // test entries
        // When we make POST request to page with address that doesn't exist
        ApiResponse apiResponse =
                mApiClient.request("POST",
                        "/entries/detail/12442341/title",
                        "title=title&body=body");
        // Then body of response of this request should be equal to 404
        // modeled offline with handlebars page
        assertEquals(
                getHtmlOfPageWithHbsWithModel("not-found.hbs", mErrorPageModel),
                apiResponse.getBody()
        );

    }
    @Test
    public void postToEntriesDetailsExistingPageTryingToCreateAnonymousCommentReturnsDetailPageWithNewComment()
            throws Exception {
        // Given no cookies with password, no sessions, dao with three
        // test entries
        // When we make POST request to detail page, to create comment
        // with empty author name and non-empty body
        BlogEntry firstBlogEntry =
                mSql2oBlogDao.findEntryById(1);
        ApiResponse apiResponse =
                mApiClient.request("POST",
                        "/entries/detail/"
                                + firstBlogEntry.getId() +
                                "/" + firstBlogEntry.getSlugFromTitle(),
                        "name=&body=body");
        // Then author name of last added comment should be "Anonymous"
        // NOTE: here i know that in test database each test entry has one
        //       comment, that's why I use get(1). But it is not cheating,
        //       because it is test database
        Comment lastComment = mSql2oEntryDao
                .findByEntryId(firstBlogEntry.getId()).get(1);
        assertEquals("Anonymous", lastComment.getAuthor());
    }
    @Test
    public void postToEntriesDetailsExistingPageTryingToCreateCommentReturnsDetailPageWithNewComment()
            throws Exception {
        // Given no cookies with password, no sessions, dao with three
        // test entries
        // When we make POST request to page with address that doesn't exist
        BlogEntry firstBlogEntry =
                mSql2oBlogDao.findEntryById(1);
        ApiResponse apiResponseOfPostCommentToEntryDetailPage =
                mApiClient.request("POST",
                        "/entries/detail/"
                        + firstBlogEntry.getId() +
                        "/" + firstBlogEntry.getSlugFromTitle(),
                        "name=name&body=body");
        HashMap<String, Object> model = new HashMap<>();
        model.put("entry", firstBlogEntry);
        model.put("comments", mSql2oEntryDao.findByEntryId(1));
        // Then body of response of this request should be equal to
        // modeled offline with handlebars page of detail entry with
        // new comment
        assertEquals(
                getHtmlOfPageWithHbsWithModel("detail.hbs", model),
                apiResponseOfPostCommentToEntryDetailPage.getBody()
        );
    }
//
    @Test
    public void editEntryPageIsReturnedCorrectly() throws Exception {
        // Given cookie with password, no sessions, dao with three
        // test entries, and offline page generated by us using handlebars
        // and first blog entry
        BlogEntry firstBlogEntry =
                mSql2oBlogDao.findEntryById(1);
        HashMap<String, Object> model = new HashMap<>();
        model.put("entry", firstBlogEntry);
        String htmlStringOfEditEntryPageRenderedOfflineWithModel =
                getHtmlOfPageWithHbsWithModel("edit.hbs", model);
        // When GET request with right password is made to edit entry page
        String bodyOfGetRequestWithRightPassword =
                getResponseBodyOfGetRequestWithRightPasswordCookie(
                        "/entries/edit/"
                        + firstBlogEntry.getId() + "/"
                        + firstBlogEntry.getSlugFromTitle());
        // Then response body of request should be equal to our
        // offline generated model
        assertEquals(
                htmlStringOfEditEntryPageRenderedOfflineWithModel,
                bodyOfGetRequestWithRightPassword
                );
    }

    @Test
    public void postRequestToSaveEntryReturnsCorrectHomePage() throws Exception {
        // Given cookie with password, dao with three test entries, no
        // sessions, and first entry edit page
        BlogEntry firstBlogEntry =
                mSql2oBlogDao.findEntryById(1);
        // When user edits entry, changing title and body
        String bodyOfResponseToPostRequestMadeToEditPage =
                getResponseBodyOfPostRequestWithRightPasswordCookie(
                        "/entries/save/" + firstBlogEntry.getId() + "/"
                        + firstBlogEntry.getSlugFromTitle(),
                       "title=title&body=body"
                );
        Map<String, Object> model = new HashMap<>();
        model.put("entries", mSql2oBlogDao.findAllEntries());
        String htmlStringOfModeledIndexPageWithNewEntry =
                getHtmlOfPageWithHbsWithModel("index.hbs", model);
        // Then body of response should be equal to new home page with changed
        // home page
        assertEquals(bodyOfResponseToPostRequestMadeToEditPage,
                htmlStringOfModeledIndexPageWithNewEntry);
    }

    @Test
    public void savingEntryWithNewTitleOrBodySavesComments() throws Exception {
        // Given cookie with password, dao with three test entries, no
        // sessions, and first entry edit page
        int numberOfCommentsBeforeEdit = mSql2oEntryDao.findAll().size();
        BlogEntry firstBlogEntry =
                mSql2oBlogDao.findEntryById(1);
        // When user edits entry, changing title and body
        getResponseBodyOfPostRequestWithRightPasswordCookie(
                "/entries/save/" + firstBlogEntry.getId() + "/"
                        + firstBlogEntry.getSlugFromTitle(),
                "title=title&body=body"
        );
        // old comments should be save for new entry
        assertEquals(
                numberOfCommentsBeforeEdit, mSql2oEntryDao.findAll().size());
    }

    @Test
    public void removingFirstEntryReturnsChangesSizeOfDaoToTwo()
            throws Exception {
        // Given cookie with password, no session, dao with three test entries,
        // and detail page of first entry
        BlogEntry firstBlogEntry =
                mSql2oBlogDao.findEntryById(1);
        // When remove button is pressed, and get request to /entries/remove/...
        // is made
        getResponseBodyOfGetRequestWithRightPasswordCookie(
                "/entries/remove/" + firstBlogEntry.getId() + "/"
                + firstBlogEntry.getSlugFromTitle()
        );
        // Then size of blog dao should be equal to two. That right page will
        // be generated we know from other tests
        assertEquals(2, mSql2oBlogDao.findAllEntries().size());
    }
    @Test
    public void makingGetRequestToNonExistingEntryReturnsErrorPageAndNotServerError()
            throws Exception {
        // Given cookie with password, no session, dao with three test entries,
        // When remove button is pressed, and get request to /entries/remove/...
        // is made
        String responseBodyOfGetRequestMadeWhenRemoveIsPressed =
                getResponseBodyOfGetRequestWithRightPasswordCookie(
                        "/entries/remove/123456/title");
        String htmlStringOfErrorPageGeneratedByUs =
                getHtmlOfPageWithHbsWithModel("not-found.hbs", mErrorPageModel);
        // Then user should be returned to home page, and body of the page
        // generated from changed DAO by us is equal to get response body
        assertEquals(
                htmlStringOfErrorPageGeneratedByUs,
                responseBodyOfGetRequestMadeWhenRemoveIsPressed);
    }
}