github.com/mssola/todo@v0.0.0-20181029153210-d25348dc3f48/app/topics_test.go (about)

     1  // Copyright (C) 2014-2017 Miquel Sabaté Solà <mikisabate@gmail.com>
     2  //
     3  // This Source Code Form is subject to the terms of the Mozilla Public
     4  // License, v. 2.0. If a copy of the MPL was not distributed with this
     5  // file, You can obtain one at http://mozilla.org/MPL/2.0/.
     6  
     7  package app
     8  
     9  import (
    10  	"encoding/json"
    11  	"fmt"
    12  	"io/ioutil"
    13  	"net/http"
    14  	"net/http/httptest"
    15  	"net/url"
    16  	"strings"
    17  	"testing"
    18  
    19  	"github.com/gorilla/mux"
    20  	"github.com/mssola/todo/lib"
    21  )
    22  
    23  func TestTopicsIndex(t *testing.T) {
    24  	initTestDB()
    25  	defer closeTestDB()
    26  
    27  	_, err := createTopic("topic1")
    28  	if err != nil {
    29  		t.Fatalf("Expected to be nil: %v", err)
    30  	}
    31  	_, err = createTopic("topic2")
    32  	if err != nil {
    33  		t.Fatalf("Expected to be nil: %v", err)
    34  	}
    35  
    36  	var t1, t2 Topic
    37  	err = Db.SelectOne(&t1, "select * from topics where name=$1", "topic1")
    38  	if err != nil {
    39  		t.Fatalf("Expected to be nil: %v", err)
    40  	}
    41  	err = Db.SelectOne(&t2, "select * from topics where name=$1", "topic2")
    42  	if err != nil {
    43  		t.Fatalf("Expected to be nil: %v", err)
    44  	}
    45  
    46  	req, err := http.NewRequest("POST", "/", nil)
    47  	if err != nil {
    48  		t.Fatalf("Expected to be nil: %v", err)
    49  	}
    50  	w := httptest.NewRecorder()
    51  	TopicsIndex(w, req)
    52  
    53  	str, _ := ioutil.ReadAll(w.Body)
    54  	s := string(str)
    55  	s1 := "<li class=\"selected\"><a href=\"/topics/%v\">topic1</a></li>"
    56  	s2 := "<li><a href=\"/topics/%v\">topic2</a></li>"
    57  	if !strings.Contains(s, fmt.Sprintf(s1, t1.ID)) {
    58  		t.Fatalf("S: %v; Should've containerd: %v", s, fmt.Sprintf(s1, t1.ID))
    59  	}
    60  	if !strings.Contains(s, fmt.Sprintf(s2, t2.ID)) {
    61  		t.Fatalf("S: %v; Should've containerd: %v", s, fmt.Sprintf(s2, t2.ID))
    62  	}
    63  }
    64  
    65  func TestTopicsIndexWithCookie(t *testing.T) {
    66  	initTestDB()
    67  	defer closeTestDB()
    68  
    69  	_, err := createTopic("topic1")
    70  	if err != nil {
    71  		t.Fatalf("Expected to be nil: %v", err)
    72  	}
    73  	_, err = createTopic("topic2")
    74  	if err != nil {
    75  		t.Fatalf("Expected to be nil: %v", err)
    76  	}
    77  
    78  	var t1, t2 Topic
    79  	err = Db.SelectOne(&t1, "select * from topics where name=$1", "topic1")
    80  	if err != nil {
    81  		t.Fatalf("Expected to be nil: %v", err)
    82  	}
    83  	err = Db.SelectOne(&t2, "select * from topics where name=$1", "topic2")
    84  	if err != nil {
    85  		t.Fatalf("Expected to be nil: %v", err)
    86  	}
    87  
    88  	req, err := http.NewRequest("POST", "/", nil)
    89  	if err != nil {
    90  		t.Fatalf("Expected to be nil: %v", err)
    91  	}
    92  	w := httptest.NewRecorder()
    93  	lib.SetCookie(w, req, "topic", t2.ID)
    94  	TopicsIndex(w, req)
    95  
    96  	str, _ := ioutil.ReadAll(w.Body)
    97  	s := string(str)
    98  	s1 := "<li><a href=\"/topics/%v\">topic1</a></li>"
    99  	s2 := "<li class=\"selected\"><a href=\"/topics/%v\">topic2</a></li>"
   100  	if !strings.Contains(s, fmt.Sprintf(s1, t1.ID)) {
   101  		t.Fatalf("S: %v; Should've containerd: %v", s, fmt.Sprintf(s1, t1.ID))
   102  	}
   103  	if !strings.Contains(s, fmt.Sprintf(s2, t2.ID)) {
   104  		t.Fatalf("S: %v; Should've containerd: %v", s, fmt.Sprintf(s2, t2.ID))
   105  	}
   106  }
   107  
   108  func TestTopicsIndexJson(t *testing.T) {
   109  	initTestDB()
   110  	defer closeTestDB()
   111  
   112  	_, err := createTopic("topic1")
   113  	if err != nil {
   114  		t.Fatalf("Expected to be nil: %v", err)
   115  	}
   116  	_, err = createTopic("topic2")
   117  	if err != nil {
   118  		t.Fatalf("Expected to be nil: %v", err)
   119  	}
   120  
   121  	var topicsDb [2]Topic
   122  	err = Db.SelectOne(&topicsDb[0], "select * from topics where name=$1", "topic1")
   123  	if err != nil {
   124  		t.Fatalf("Expected to be nil: %v", err)
   125  	}
   126  	err = Db.SelectOne(&topicsDb[1], "select * from topics where name=$1", "topic2")
   127  	if err != nil {
   128  		t.Fatalf("Expected to be nil: %v", err)
   129  	}
   130  
   131  	req, err := http.NewRequest("POST", "/", nil)
   132  	if err != nil {
   133  		t.Fatalf("Expected to be nil: %v", err)
   134  	}
   135  	req.Header.Set("Content-Type", "application/json")
   136  	w := httptest.NewRecorder()
   137  	TopicsIndex(w, req)
   138  
   139  	var topics []Topic
   140  	decoder := json.NewDecoder(w.Body)
   141  	err = decoder.Decode(&topics)
   142  	if err != nil {
   143  		t.Fatalf("Expected to be nil: %v", err)
   144  	}
   145  
   146  	for i := 0; i < 2; i++ {
   147  		if topics[i].ID != topicsDb[i].ID {
   148  			t.Fatalf("Got %v, Expected: %v", topics[i].ID, topicsDb[i].ID)
   149  		}
   150  		if topics[i].Name != topicsDb[i].Name {
   151  			t.Fatalf("Got %v, Expected: %v", topics[i].Name, topicsDb[i].Name)
   152  		}
   153  	}
   154  }
   155  
   156  func TestTopicsCreate(t *testing.T) {
   157  	initTestDB()
   158  	defer closeTestDB()
   159  
   160  	param := make(url.Values)
   161  	param["name"] = []string{"user"}
   162  
   163  	req, err := http.NewRequest("POST", "/", nil)
   164  	if err != nil {
   165  		t.Fatalf("Expected to be nil: %v", err)
   166  	}
   167  	req.PostForm = param
   168  	w := httptest.NewRecorder()
   169  	TopicsCreate(w, req)
   170  
   171  	var topic Topic
   172  	err = Db.SelectOne(&topic, "select * from topics")
   173  	if err != nil {
   174  		t.Fatalf("Expected to be nil: %v", err)
   175  	}
   176  	if topic.ID == "" {
   177  		t.Fatalf("Expected to not be empty")
   178  	}
   179  	if topic.Name != "user" {
   180  		t.Fatalf("Got %v, Expected: %v", topic.Name, "user")
   181  	}
   182  
   183  	if w.Code != 302 {
   184  		t.Fatalf("Got %v, Expected: %v", w.Code, 302)
   185  	}
   186  	if w.HeaderMap["Location"][0] != "/topics/"+topic.ID {
   187  		t.Fatalf("Got %v, Expected: %v", w.HeaderMap["Location"][0], "/topics/"+topic.ID)
   188  	}
   189  }
   190  
   191  func TestTopicsCreateNoName(t *testing.T) {
   192  	initTestDB()
   193  	defer closeTestDB()
   194  
   195  	param := make(url.Values)
   196  
   197  	req, err := http.NewRequest("POST", "/", nil)
   198  	if err != nil {
   199  		t.Fatalf("Expected to be nil: %v", err)
   200  	}
   201  	req.PostForm = param
   202  	w := httptest.NewRecorder()
   203  	TopicsCreate(w, req)
   204  
   205  	if w.Code != 302 {
   206  		t.Fatalf("Got %v; Expected: %v", w.Code, 302)
   207  	}
   208  	if w.HeaderMap["Location"][0] != "/topics" {
   209  		t.Fatalf("Got %v; Expected: %v", w.HeaderMap["Location"][0], "/topics")
   210  	}
   211  
   212  	var topic Topic
   213  	err = Db.SelectOne(&topic, "select * from topics")
   214  	if topic.ID != "" {
   215  		t.Fatalf("Should be empty")
   216  	}
   217  	if err == nil {
   218  		t.Fatalf("Expected to not be nil")
   219  	}
   220  	count, err := Db.SelectInt("select count(*) from users")
   221  	if count != 0 {
   222  		t.Fatalf("Got %v; Expected: %v", count, 0)
   223  	}
   224  }
   225  
   226  func TestTopicsCreateJson(t *testing.T) {
   227  	initTestDB()
   228  	defer closeTestDB()
   229  
   230  	// We try to create a topic for the first time.
   231  	body := "{\"name\":\"mssola\"}"
   232  	reader := strings.NewReader(body)
   233  	req, err := http.NewRequest("POST", "/topics", reader)
   234  	if err != nil {
   235  		t.Fatalf("Expected to be nil: %v", err)
   236  	}
   237  	req.Header.Set("Content-Type", "application/json")
   238  	w := httptest.NewRecorder()
   239  
   240  	m := mux.NewRouter()
   241  	m.HandleFunc("/topics", TopicsCreate)
   242  	m.ServeHTTP(w, req)
   243  
   244  	var topic Topic
   245  	decoder := json.NewDecoder(w.Body)
   246  	err = decoder.Decode(&topic)
   247  	if err != nil {
   248  		t.Fatalf("Expected to be nil: %v", err)
   249  	}
   250  
   251  	var t1 Topic
   252  	err = Db.SelectOne(&t1, "select * from topics")
   253  	if err != nil {
   254  		t.Fatalf("Expected to be nil: %v", err)
   255  	}
   256  	if t1.ID != topic.ID {
   257  		t.Fatalf("Got %v; Expected: %v", t1.ID, topic.ID)
   258  	}
   259  	if t1.Name != topic.Name {
   260  		t.Fatalf("Got %v; Expected: %v", t1.Name, topic.Name)
   261  	}
   262  
   263  	// Now let's try it with the same name.
   264  	reader2 := strings.NewReader(body)
   265  	req, err = http.NewRequest("POST", "/topics", reader2)
   266  	if err != nil {
   267  		t.Fatalf("Expected to be nil: %v", err)
   268  	}
   269  	req.Header.Set("Content-Type", "application/json")
   270  	w1 := httptest.NewRecorder()
   271  
   272  	m = mux.NewRouter()
   273  	m.HandleFunc("/topics", TopicsCreate)
   274  	m.ServeHTTP(w1, req)
   275  
   276  	var resp lib.Response
   277  	decoder = json.NewDecoder(w1.Body)
   278  	err = decoder.Decode(&resp)
   279  	if err != nil {
   280  		t.Fatalf("Expected to be nil: %v", err)
   281  	}
   282  	if resp.Error != "Failed!" {
   283  		t.Fatalf("Got %v; Expected: %v", resp.Error, "Failed!")
   284  	}
   285  }
   286  
   287  func TestTopicsCreateJsonMalformed(t *testing.T) {
   288  	initTestDB()
   289  	defer closeTestDB()
   290  
   291  	// We try to create a topic for the first time.
   292  	body := "{\"name\":\"mssola\""
   293  	reader := strings.NewReader(body)
   294  	req, err := http.NewRequest("POST", "/topics", reader)
   295  	if err != nil {
   296  		t.Fatalf("Expected to be nil: %v", err)
   297  	}
   298  	req.Header.Set("Content-Type", "application/json")
   299  	w := httptest.NewRecorder()
   300  
   301  	m := mux.NewRouter()
   302  	m.HandleFunc("/topics", TopicsCreate)
   303  	m.ServeHTTP(w, req)
   304  
   305  	var topic lib.Response
   306  	decoder := json.NewDecoder(w.Body)
   307  	err = decoder.Decode(&topic)
   308  	if err != nil {
   309  		t.Fatalf("Expected to be nil: %v", err)
   310  	}
   311  	if topic.Error != "Failed!" {
   312  		t.Fatalf("Got %v; Expected: %v", topic.Error, "Failed!")
   313  	}
   314  	if w.Code != 404 {
   315  		t.Fatalf("Got %v; Expected: %v", w.Code, 404)
   316  	}
   317  }
   318  
   319  func TestTopicsShow(t *testing.T) {
   320  	initTestDB()
   321  	defer closeTestDB()
   322  
   323  	_, err := createTopic("topic1")
   324  	if err != nil {
   325  		t.Fatalf("Expected to be nil: %v", err)
   326  	}
   327  	_, err = createTopic("topic2")
   328  	if err != nil {
   329  		t.Fatalf("Expected to be nil: %v", err)
   330  	}
   331  
   332  	var topicsDb [2]Topic
   333  	err = Db.SelectOne(&topicsDb[0], "select * from topics where name=$1", "topic1")
   334  	if err != nil {
   335  		t.Fatalf("Expected to be nil: %v", err)
   336  	}
   337  	err = Db.SelectOne(&topicsDb[1], "select * from topics where name=$1", "topic2")
   338  	if err != nil {
   339  		t.Fatalf("Expected to be nil: %v", err)
   340  	}
   341  
   342  	req, err := http.NewRequest("GET", "/topics/"+topicsDb[1].ID, nil)
   343  	if err != nil {
   344  		t.Fatalf("Expected to be nil: %v", err)
   345  	}
   346  	w := httptest.NewRecorder()
   347  
   348  	m := mux.NewRouter()
   349  	m.HandleFunc("/topics/{id}", TopicsShow)
   350  	m.ServeHTTP(w, req)
   351  
   352  	str, _ := ioutil.ReadAll(w.Body)
   353  	s := string(str)
   354  
   355  	s1 := "<li><a href=\"/topics/%v\">topic1</a></li>"
   356  	s2 := "<li class=\"selected\"><a href=\"/topics/%v\">topic2</a></li>"
   357  	if !strings.Contains(s, fmt.Sprintf(s1, topicsDb[0].ID)) {
   358  		t.Fatalf("S: %v; Should've containerd: %v", s, fmt.Sprintf(s1, topicsDb[0].ID))
   359  	}
   360  	if !strings.Contains(s, fmt.Sprintf(s2, topicsDb[1].ID)) {
   361  		t.Fatalf("S: %v; Should've containerd: %v", s, fmt.Sprintf(s2, topicsDb[1].ID))
   362  	}
   363  }
   364  
   365  func TestTopicsShowJson(t *testing.T) {
   366  	initTestDB()
   367  	defer closeTestDB()
   368  
   369  	_, err := createTopic("topic1")
   370  	if err != nil {
   371  		t.Fatalf("Expected to be nil: %v", err)
   372  	}
   373  	_, err = createTopic("topic2")
   374  	Db.Exec("update topics set contents=$1 where name=$2", "**co**", "topic2")
   375  	if err != nil {
   376  		t.Fatalf("Expected to be nil: %v", err)
   377  	}
   378  
   379  	var topicsDb [2]Topic
   380  	err = Db.SelectOne(&topicsDb[0], "select * from topics where name=$1", "topic1")
   381  	if err != nil {
   382  		t.Fatalf("Expected to be nil: %v", err)
   383  	}
   384  	err = Db.SelectOne(&topicsDb[1], "select * from topics where name=$1", "topic2")
   385  	if err != nil {
   386  		t.Fatalf("Expected to be nil: %v", err)
   387  	}
   388  
   389  	req, err := http.NewRequest("GET", "/topics/"+topicsDb[1].ID, nil)
   390  	if err != nil {
   391  		t.Fatalf("Expected to be nil: %v", err)
   392  	}
   393  	req.Header.Set("Content-Type", "application/json")
   394  	w := httptest.NewRecorder()
   395  
   396  	m := mux.NewRouter()
   397  	m.HandleFunc("/topics/{id}", TopicsShow)
   398  	m.ServeHTTP(w, req)
   399  
   400  	var topic Topic
   401  	decoder := json.NewDecoder(w.Body)
   402  	err = decoder.Decode(&topic)
   403  	if err != nil {
   404  		t.Fatalf("Expected to be nil: %v", err)
   405  	}
   406  
   407  	if topicsDb[1].ID != topic.ID {
   408  		t.Fatalf("Got %v; Expected: %v", topicsDb[1].ID, topic.ID)
   409  	}
   410  	if topicsDb[1].Name != topic.Name {
   411  		t.Fatalf("Got %v; Expected: %v", topicsDb[1].Name, topic.Name)
   412  	}
   413  	if topicsDb[1].Contents != topic.Contents {
   414  		t.Fatalf("Got %v; Expected: %v", topicsDb[1].Contents, topic.Contents)
   415  	}
   416  	rendered := strings.TrimSpace(topic.Markdown)
   417  	if "<p><strong>co</strong></p>" != rendered {
   418  		t.Fatalf("Got %v; Expected: %v", "<p><strong>co</strong></p>", rendered)
   419  	}
   420  
   421  	// A non-existant topic.
   422  	req, err = http.NewRequest("GET", "/topics/1", nil)
   423  	if err != nil {
   424  		t.Fatalf("Expected to be nil: %v", err)
   425  	}
   426  	req.Header.Set("Content-Type", "application/json")
   427  	w1 := httptest.NewRecorder()
   428  
   429  	m.ServeHTTP(w1, req)
   430  
   431  	var response lib.Response
   432  	decoder = json.NewDecoder(w1.Body)
   433  	err = decoder.Decode(&response)
   434  	if err != nil {
   435  		t.Fatalf("Expected to be nil: %v", err)
   436  	}
   437  
   438  	if response.Error != "Failed!" {
   439  		t.Fatalf("Got %v; Expected: %v", response.Error, "Failed!")
   440  	}
   441  	if response.Message != "" {
   442  		t.Fatal("Should not be empty")
   443  	}
   444  }
   445  
   446  func TestTopicsShowJsonFail(t *testing.T) {
   447  	initTestDB()
   448  	defer closeTestDB()
   449  
   450  	req, err := http.NewRequest("GET", "/topics/1", nil)
   451  	if err != nil {
   452  		t.Fatalf("Expected to be nil: %v", err)
   453  	}
   454  	req.Header.Set("Content-Type", "application/json")
   455  	w := httptest.NewRecorder()
   456  
   457  	m := mux.NewRouter()
   458  	m.HandleFunc("/topics/{id}", TopicsShow)
   459  	m.ServeHTTP(w, req)
   460  
   461  	var resp lib.Response
   462  	decoder := json.NewDecoder(w.Body)
   463  	err = decoder.Decode(&resp)
   464  	if err != nil {
   465  		t.Fatalf("Expected to be nil: %v", err)
   466  	}
   467  	if resp.Error != "Failed!" {
   468  		t.Fatalf("Got %v; Expected: %v", resp.Error, "Failed!")
   469  	}
   470  	if w.Code != 404 {
   471  		t.Fatalf("Got %v; Expected: %v", w.Code, 404)
   472  	}
   473  }
   474  
   475  func TestTopicsRename(t *testing.T) {
   476  	initTestDB()
   477  	defer closeTestDB()
   478  
   479  	_, err := createTopic("topic")
   480  	if err != nil {
   481  		t.Fatalf("Expected to be nil: %v", err)
   482  	}
   483  
   484  	var t1, t2 Topic
   485  	err = Db.SelectOne(&t1, "select * from topics")
   486  	if err != nil {
   487  		t.Fatalf("Expected to be nil: %v", err)
   488  	}
   489  
   490  	param := make(url.Values)
   491  
   492  	req, err := http.NewRequest("POST", "/topics/"+t1.ID, nil)
   493  	if err != nil {
   494  		t.Fatalf("Expected to be nil: %v", err)
   495  	}
   496  	param["name"] = []string{"topic1"}
   497  	req.PostForm = param
   498  	w := httptest.NewRecorder()
   499  
   500  	m := mux.NewRouter()
   501  	m.HandleFunc("/topics/{id}", TopicsUpdate)
   502  	m.ServeHTTP(w, req)
   503  
   504  	// DB
   505  	err = Db.SelectOne(&t2, "select * from topics")
   506  	if err != nil {
   507  		t.Fatalf("Expected to be nil: %v", err)
   508  	}
   509  	if t2.Name != "topic1" {
   510  		t.Fatalf("Got %v; Expected: %v", t2.Name, "topic1")
   511  	}
   512  	if t1.ID != t2.ID {
   513  		t.Fatalf("Got %v; Expected: %v", t1.ID, t2.ID)
   514  	}
   515  
   516  	// HTTP
   517  	if w.Code != 302 {
   518  		t.Fatalf("Got %v; Expected: %v", w.Code, 302)
   519  	}
   520  	if w.HeaderMap["Location"][0] != "/topics" {
   521  		t.Fatalf("Got %v; Expected: %v", w.HeaderMap["Location"][0], "/topics")
   522  	}
   523  }
   524  
   525  func TestTopicsRenameJson(t *testing.T) {
   526  	initTestDB()
   527  	defer closeTestDB()
   528  
   529  	_, err := createTopic("topic")
   530  	if err != nil {
   531  		t.Fatalf("Expected to be nil: %v", err)
   532  	}
   533  
   534  	var t1, t2 Topic
   535  	err = Db.SelectOne(&t1, "select * from topics")
   536  	if err != nil {
   537  		t.Fatalf("Expected to be nil: %v", err)
   538  	}
   539  
   540  	body := strings.NewReader("{\"name\":\"topic1\"}")
   541  	req, err := http.NewRequest("PUT", "/topics/"+t1.ID, body)
   542  	if err != nil {
   543  		t.Fatalf("Expected to be nil: %v", err)
   544  	}
   545  	req.Header.Set("Content-Type", "application/json")
   546  	w := httptest.NewRecorder()
   547  
   548  	m := mux.NewRouter()
   549  	m.HandleFunc("/topics/{id}", TopicsUpdateJSON)
   550  	m.ServeHTTP(w, req)
   551  
   552  	// DB
   553  	var resp Topic
   554  	decoder := json.NewDecoder(w.Body)
   555  	err = decoder.Decode(&resp)
   556  	if err != nil {
   557  		t.Fatalf("Expected to be nil: %v", err)
   558  	}
   559  	err = Db.SelectOne(&t2, "select * from topics")
   560  	if err != nil {
   561  		t.Fatalf("Expected to be nil: %v", err)
   562  	}
   563  	if t2.Name != "topic1" {
   564  		t.Fatalf("Got %v; Expected: %v", t2.Name, "topic1")
   565  	}
   566  	if t2.Name != resp.Name {
   567  		t.Fatalf("Got %v; Expected: %v", t2.Name, resp.Name)
   568  	}
   569  	if t1.ID != t2.ID {
   570  		t.Fatalf("Got %v; Expected: %v", t1.ID, t2.ID)
   571  	}
   572  	if t2.ID != resp.ID {
   573  		t.Fatalf("Got %v; Expected: %v", t2.ID, resp.ID)
   574  	}
   575  }
   576  
   577  func TestTopicsRenameJsonMalformed(t *testing.T) {
   578  	initTestDB()
   579  	defer closeTestDB()
   580  
   581  	_, err := createTopic("topic")
   582  	if err != nil {
   583  		t.Fatalf("Expected to be nil: %v", err)
   584  	}
   585  
   586  	var t1 Topic
   587  	err = Db.SelectOne(&t1, "select * from topics")
   588  	if err != nil {
   589  		t.Fatalf("Expected to be nil: %v", err)
   590  	}
   591  
   592  	body := strings.NewReader("{\"name\":\"topic1\"")
   593  	req, err := http.NewRequest("PUT", "/topics/"+t1.ID, body)
   594  	if err != nil {
   595  		t.Fatalf("Expected to be nil: %v", err)
   596  	}
   597  	req.Header.Set("Content-Type", "application/json")
   598  	w := httptest.NewRecorder()
   599  
   600  	m := mux.NewRouter()
   601  	m.HandleFunc("/topics/{id}", TopicsUpdateJSON)
   602  	m.ServeHTTP(w, req)
   603  
   604  	// DB
   605  	var resp lib.Response
   606  	decoder := json.NewDecoder(w.Body)
   607  	err = decoder.Decode(&resp)
   608  	if err != nil {
   609  		t.Fatalf("Expected to be nil: %v", err)
   610  	}
   611  	if resp.Error != "Failed!" {
   612  		t.Fatalf("Got %v; Expected: %v", resp.Error, "Failed!")
   613  	}
   614  	if w.Code != 404 {
   615  		t.Fatalf("Got %v; Expected: %v", w.Code, 404)
   616  	}
   617  }
   618  
   619  func TestTopicsRenameJsonFail(t *testing.T) {
   620  	initTestDB()
   621  	defer closeTestDB()
   622  
   623  	_, err := createTopic("topic")
   624  	if err != nil {
   625  		t.Fatalf("Expected to be nil: %v", err)
   626  	}
   627  	_, err = createTopic("topic1")
   628  	if err != nil {
   629  		t.Fatalf("Expected to be nil: %v", err)
   630  	}
   631  
   632  	var t1 Topic
   633  	err = Db.SelectOne(&t1, "select * from topics where name=$1", "topic")
   634  	if err != nil {
   635  		t.Fatalf("Expected to be nil: %v", err)
   636  	}
   637  
   638  	body := strings.NewReader("{\"name\":\"topic1\"}")
   639  	req, err := http.NewRequest("PUT", "/topics/"+t1.ID, body)
   640  	if err != nil {
   641  		t.Fatalf("Expected to be nil: %v", err)
   642  	}
   643  	req.Header.Set("Content-Type", "application/json")
   644  	w := httptest.NewRecorder()
   645  
   646  	m := mux.NewRouter()
   647  	m.HandleFunc("/topics/{id}", TopicsUpdateJSON)
   648  	m.ServeHTTP(w, req)
   649  
   650  	// DB
   651  	var resp lib.Response
   652  	decoder := json.NewDecoder(w.Body)
   653  	err = decoder.Decode(&resp)
   654  	if err != nil {
   655  		t.Fatalf("Expected to be nil: %v", err)
   656  	}
   657  	if resp.Error != "Failed!" {
   658  		t.Fatalf("Got %v; Expected: %v", resp.Error, "Failed!")
   659  	}
   660  	if w.Code != 404 {
   661  		t.Fatalf("Got %v; Expected: %v", w.Code, 404)
   662  	}
   663  }
   664  
   665  func TestUpdateContents(t *testing.T) {
   666  	initTestDB()
   667  	defer closeTestDB()
   668  
   669  	_, err := createTopic("topic")
   670  	if err != nil {
   671  		t.Fatalf("Expected to be nil: %v", err)
   672  	}
   673  
   674  	var t1, t2 Topic
   675  	err = Db.SelectOne(&t1, "select * from topics")
   676  	if err != nil {
   677  		t.Fatalf("Expected to be nil: %v", err)
   678  	}
   679  
   680  	param := make(url.Values)
   681  
   682  	req, err := http.NewRequest("POST", "/topics/"+t1.ID, nil)
   683  	if err != nil {
   684  		t.Fatalf("Expected to be nil: %v", err)
   685  	}
   686  	param["contents"] = []string{"**bold**"}
   687  	req.PostForm = param
   688  	w := httptest.NewRecorder()
   689  
   690  	m := mux.NewRouter()
   691  	m.HandleFunc("/topics/{id}", TopicsUpdate)
   692  	m.ServeHTTP(w, req)
   693  
   694  	// DB
   695  	err = Db.SelectOne(&t2, "select * from topics")
   696  	if err != nil {
   697  		t.Fatalf("Expected to be nil: %v", err)
   698  	}
   699  	if t1.Name != t2.Name {
   700  		t.Fatalf("Got %v; Expected: %v", t1.Name, t2.Name)
   701  	}
   702  	if t1.ID != t2.ID {
   703  		t.Fatalf("Got %v; Expected: %v", t1.ID, t2.ID)
   704  	}
   705  	if t1.Contents == t2.Contents {
   706  		t.Fatalf("%v -- %v;; should be different", t1.Contents, t2.Contents)
   707  	}
   708  	if t2.Contents != "**bold**" {
   709  		t.Fatalf("Got %v; Expected: %v", t2.Contents, "**bold**")
   710  	}
   711  
   712  	// HTTP
   713  	if w.Code != 302 {
   714  		t.Fatalf("Got %v; Expected: %v", w.Code, 302)
   715  	}
   716  	if w.HeaderMap["Location"][0] != "/topics" {
   717  		t.Fatalf("Got %v; Expected: %v", w.HeaderMap["Location"][0], "/topics")
   718  	}
   719  }
   720  
   721  func TestUpdateJson(t *testing.T) {
   722  	initTestDB()
   723  	defer closeTestDB()
   724  
   725  	_, err := createTopic("topic")
   726  	if err != nil {
   727  		t.Fatalf("Expected to be nil: %v", err)
   728  	}
   729  
   730  	var t1, t2 Topic
   731  	err = Db.SelectOne(&t1, "select * from topics")
   732  	if err != nil {
   733  		t.Fatalf("Expected to be nil: %v", err)
   734  	}
   735  
   736  	body := strings.NewReader("{\"contents\":\"**contents**\"}")
   737  	req, err := http.NewRequest("PUT", "/topics/"+t1.ID, body)
   738  	if err != nil {
   739  		t.Fatalf("Expected to be nil: %v", err)
   740  	}
   741  	req.Header.Set("Content-Type", "application/json")
   742  	w := httptest.NewRecorder()
   743  
   744  	m := mux.NewRouter()
   745  	m.HandleFunc("/topics/{id}", TopicsUpdateJSON)
   746  	m.ServeHTTP(w, req)
   747  
   748  	// DB
   749  	err = Db.SelectOne(&t2, "select * from topics")
   750  	if err != nil {
   751  		t.Fatalf("Expected to be nil: %v", err)
   752  	}
   753  	if t1.Name != t2.Name {
   754  		t.Fatalf("Got %v; Expected: %v", t1.Name, t2.Name)
   755  	}
   756  	if t1.ID != t2.ID {
   757  		t.Fatalf("Got %v; Expected: %v", t1.ID, t2.ID)
   758  	}
   759  	if t1.Contents == t2.Contents {
   760  		t.Fatalf("%v -- %v;; should be different", t1.Contents, t2.Contents)
   761  	}
   762  	if t2.Contents != "**contents**" {
   763  		t.Fatalf("Got %v; Expected: %v", t2.Contents, "**contents**")
   764  	}
   765  
   766  	// Response
   767  	var st Topic
   768  	decoder := json.NewDecoder(w.Body)
   769  	err = decoder.Decode(&st)
   770  	if err != nil {
   771  		t.Fatalf("Expected to be nil: %v", err)
   772  	}
   773  	rendered := strings.TrimSpace(st.Markdown)
   774  	if rendered != "<p><strong>contents</strong></p>" {
   775  		t.Fatalf("Got %v; Expected: %v", rendered, "<p><strong>contents</strong></p>")
   776  	}
   777  }
   778  
   779  func TestTopicsUpdateJsonMalformed(t *testing.T) {
   780  	initTestDB()
   781  	defer closeTestDB()
   782  
   783  	_, err := createTopic("topic")
   784  	if err != nil {
   785  		t.Fatalf("Expected to be nil: %v", err)
   786  	}
   787  
   788  	var t1 Topic
   789  	err = Db.SelectOne(&t1, "select * from topics")
   790  	if err != nil {
   791  		t.Fatalf("Expected to be nil: %v", err)
   792  	}
   793  
   794  	body := strings.NewReader("{\"contents\":\"topic1\"")
   795  	req, err := http.NewRequest("PUT", "/topics/"+t1.ID, body)
   796  	if err != nil {
   797  		t.Fatalf("Expected to be nil: %v", err)
   798  	}
   799  	req.Header.Set("Content-Type", "application/json")
   800  	w := httptest.NewRecorder()
   801  
   802  	m := mux.NewRouter()
   803  	m.HandleFunc("/topics/{id}", TopicsUpdateJSON)
   804  	m.ServeHTTP(w, req)
   805  
   806  	// DB
   807  	var resp lib.Response
   808  	decoder := json.NewDecoder(w.Body)
   809  	err = decoder.Decode(&resp)
   810  	if err != nil {
   811  		t.Fatalf("Expected to be nil: %v", err)
   812  	}
   813  	if resp.Error != "Failed!" {
   814  		t.Fatalf("Got %v; Expected: %v", resp.Error, "Failed!")
   815  	}
   816  	if w.Code != 404 {
   817  		t.Fatalf("Got %v; Expected: %v", w.Code, 404)
   818  	}
   819  }
   820  
   821  func TestTopicsUpdateNoBody(t *testing.T) {
   822  	initTestDB()
   823  	defer closeTestDB()
   824  
   825  	_, err := createTopic("topic")
   826  	if err != nil {
   827  		t.Fatalf("Expected to be nil: %v", err)
   828  	}
   829  
   830  	var t1 Topic
   831  	err = Db.SelectOne(&t1, "select * from topics")
   832  	if err != nil {
   833  		t.Fatalf("Expected to be nil: %v", err)
   834  	}
   835  
   836  	req, err := http.NewRequest("PUT", "/topics/"+t1.ID, nil)
   837  	if err != nil {
   838  		t.Fatalf("Expected to be nil: %v", err)
   839  	}
   840  	req.Header.Set("Content-Type", "application/json")
   841  	w := httptest.NewRecorder()
   842  
   843  	m := mux.NewRouter()
   844  	m.HandleFunc("/topics/{id}", TopicsUpdateJSON)
   845  	m.ServeHTTP(w, req)
   846  
   847  	// DB
   848  	var resp lib.Response
   849  	decoder := json.NewDecoder(w.Body)
   850  	err = decoder.Decode(&resp)
   851  	if err != nil {
   852  		t.Fatalf("Expected to be nil: %v", err)
   853  	}
   854  	if resp.Error != "Failed!" {
   855  		t.Fatalf("Got %v; Expected: %v", resp.Error, "Failed!")
   856  	}
   857  	if w.Code != 404 {
   858  		t.Fatalf("Got %v; Expected: %v", w.Code, 404)
   859  	}
   860  }
   861  
   862  func TestTopicsUpdateNoValidParametersGiven(t *testing.T) {
   863  	initTestDB()
   864  	defer closeTestDB()
   865  
   866  	_, err := createTopic("topic")
   867  	if err != nil {
   868  		t.Fatalf("Expected to be nil: %v", err)
   869  	}
   870  
   871  	var t1 Topic
   872  	err = Db.SelectOne(&t1, "select * from topics")
   873  	if err != nil {
   874  		t.Fatalf("Expected to be nil: %v", err)
   875  	}
   876  
   877  	body := strings.NewReader("{\"something\":\"**contents**\"}")
   878  	req, err := http.NewRequest("PUT", "/topics/"+t1.ID, body)
   879  	if err != nil {
   880  		t.Fatalf("Expected to be nil: %v", err)
   881  	}
   882  	req.Header.Set("Content-Type", "application/json")
   883  	w := httptest.NewRecorder()
   884  
   885  	m := mux.NewRouter()
   886  	m.HandleFunc("/topics/{id}", TopicsUpdateJSON)
   887  	m.ServeHTTP(w, req)
   888  
   889  	// DB
   890  	var resp lib.Response
   891  	decoder := json.NewDecoder(w.Body)
   892  	err = decoder.Decode(&resp)
   893  	if err != nil {
   894  		t.Fatalf("Expected to be nil: %v", err)
   895  	}
   896  	if resp.Error != "Failed!" {
   897  		t.Fatalf("Got %v; Expected: %v", resp.Error, "Failed!")
   898  	}
   899  	if w.Code != 404 {
   900  		t.Fatalf("Got %v; Expected: %v", w.Code, 404)
   901  	}
   902  }
   903  
   904  func TestDestroy(t *testing.T) {
   905  	initTestDB()
   906  	defer closeTestDB()
   907  
   908  	_, err := createTopic("topic")
   909  	if err != nil {
   910  		t.Fatalf("Expected to be nil: %v", err)
   911  	}
   912  
   913  	var t1 Topic
   914  	err = Db.SelectOne(&t1, "select * from topics")
   915  	if err != nil {
   916  		t.Fatalf("Expected to be nil: %v", err)
   917  	}
   918  
   919  	req, err := http.NewRequest("POST", "/topics/"+t1.ID+"/delete", nil)
   920  	if err != nil {
   921  		t.Fatalf("Expected to be nil: %v", err)
   922  	}
   923  	w := httptest.NewRecorder()
   924  
   925  	m := mux.NewRouter()
   926  	m.HandleFunc("/topics/{id}/delete", TopicsDestroy)
   927  	m.ServeHTTP(w, req)
   928  
   929  	// DB
   930  	c, err := Db.SelectInt("select count(*) from topics")
   931  	if err != nil {
   932  		t.Fatalf("Expected to be nil: %v", err)
   933  	}
   934  	if c != 0 {
   935  		t.Fatalf("Got %v; Expected: %v", c, 0)
   936  	}
   937  
   938  	// HTTP
   939  	if w.Code != 302 {
   940  		t.Fatalf("Got %v; Expected: %v", w.Code, 302)
   941  	}
   942  	if w.HeaderMap["Location"][0] != "/topics" {
   943  		t.Fatalf("Got %v; Expected: %v", w.HeaderMap["Location"][0], "/topics")
   944  	}
   945  }
   946  
   947  func TestDestroyJson(t *testing.T) {
   948  	initTestDB()
   949  	defer closeTestDB()
   950  
   951  	_, err := createTopic("topic")
   952  	if err != nil {
   953  		t.Fatalf("Expected to be nil: %v", err)
   954  	}
   955  
   956  	var t1 Topic
   957  	err = Db.SelectOne(&t1, "select * from topics")
   958  	if err != nil {
   959  		t.Fatalf("Expected to be nil: %v", err)
   960  	}
   961  
   962  	req, err := http.NewRequest("DELETE", "/topics/"+t1.ID, nil)
   963  	if err != nil {
   964  		t.Fatalf("Expected to be nil: %v", err)
   965  	}
   966  	req.Header.Set("Content-Type", "application/json")
   967  	w := httptest.NewRecorder()
   968  
   969  	m := mux.NewRouter()
   970  	m.HandleFunc("/topics/{id}", TopicsDestroyJSON)
   971  	m.ServeHTTP(w, req)
   972  
   973  	// DB
   974  	c, err := Db.SelectInt("select count(*) from topics")
   975  	if err != nil {
   976  		t.Fatalf("Expected to be nil: %v", err)
   977  	}
   978  	if c != 0 {
   979  		t.Fatalf("Got %v; Expected: %v", c, 0)
   980  	}
   981  
   982  	// HTTP
   983  	var resp lib.Response
   984  	decoder := json.NewDecoder(w.Body)
   985  	err = decoder.Decode(&resp)
   986  	if err != nil {
   987  		t.Fatalf("Expected to be nil: %v", err)
   988  	}
   989  	if resp.Message != "Ok" {
   990  		t.Fatalf("Got %v; Expected: %v", resp.Message, "Ok")
   991  	}
   992  }
   993  
   994  func TestDestroyJsonError(t *testing.T) {
   995  	initTestDB()
   996  	defer closeTestDB()
   997  
   998  	req, err := http.NewRequest("DELETE",
   999  		"/topics/7a0a771a-cc11-4079-59ba-81df690a0588", nil)
  1000  	if err != nil {
  1001  		t.Fatalf("Expected to be nil: %v", err)
  1002  	}
  1003  	req.Header.Set("Content-Type", "application/json")
  1004  	w := httptest.NewRecorder()
  1005  
  1006  	m := mux.NewRouter()
  1007  	m.HandleFunc("/topics/{id}", TopicsDestroyJSON)
  1008  	m.ServeHTTP(w, req)
  1009  
  1010  	// DB
  1011  	c, err := Db.SelectInt("select count(*) from topics")
  1012  	if err != nil {
  1013  		t.Fatalf("Expected to be nil: %v", err)
  1014  	}
  1015  	if c != 0 {
  1016  		t.Fatalf("Got %v; Expected: %v", c, 0)
  1017  	}
  1018  
  1019  	// HTTP
  1020  	var resp lib.Response
  1021  	decoder := json.NewDecoder(w.Body)
  1022  	err = decoder.Decode(&resp)
  1023  	if err != nil {
  1024  		t.Fatalf("Expected to be nil: %v", err)
  1025  	}
  1026  	if resp.Error != "Could not remove topic" {
  1027  		t.Fatalf("Got %v; Expected: %v", resp.Error, "Could not remove topic")
  1028  	}
  1029  }
  1030  
  1031  func TestWrongUuidFormatApi(t *testing.T) {
  1032  	initTestDB()
  1033  	defer closeTestDB()
  1034  
  1035  	req, err := http.NewRequest("DELETE", "/topics/1", nil)
  1036  	if err != nil {
  1037  		t.Fatalf("Expected to be nil: %v", err)
  1038  	}
  1039  	req.Header.Set("Content-Type", "application/json")
  1040  	w := httptest.NewRecorder()
  1041  
  1042  	m := mux.NewRouter()
  1043  	m.HandleFunc("/topics/{id}", TopicsDestroyJSON)
  1044  	m.ServeHTTP(w, req)
  1045  
  1046  	// DB
  1047  	c, err := Db.SelectInt("select count(*) from topics")
  1048  	if err != nil {
  1049  		t.Fatalf("Expected to be nil: %v", err)
  1050  	}
  1051  	if c != 0 {
  1052  		t.Fatalf("Got %v; Expected: %v", c, 0)
  1053  	}
  1054  
  1055  	// HTTP
  1056  	var resp lib.Response
  1057  	decoder := json.NewDecoder(w.Body)
  1058  	err = decoder.Decode(&resp)
  1059  	if err != nil {
  1060  		t.Fatalf("Expected to be nil: %v", err)
  1061  	}
  1062  	if resp.Error != "Could not remove topic" {
  1063  		t.Fatalf("Got %v; Expected: %v", resp.Error, "Could not remove topic")
  1064  	}
  1065  }