Golang NotNil Examples

Example #1

File: router_test.go Project: Castcloud/castcloud-go-server

func TestRouterMultiRoute(t *testing.T) {
	e := New()
	r := e.router

	// Routes
	r.Add(GET, "/users", func(c *Context) error {
		c.Set("path", "/users")
		return nil
	}, e)
	r.Add(GET, "/users/:id", func(c *Context) error {
		return nil
	}, e)
	c := NewContext(nil, nil, e)

	// Route > /users
	h, _ := r.Find(GET, "/users", c)
	if assert.NotNil(t, h) {
		h(c)
		assert.Equal(t, "/users", c.Get("path"))
	}

	// Route > /users/:id
	h, _ = r.Find(GET, "/users/1", c)
	if assert.NotNil(t, h) {
		assert.Equal(t, "1", c.P(0))
	}

	// Route > /user
	h, _ = r.Find(GET, "/user", c)
	assert.Nil(t, h)
}

Example #2

File: store_bolt_casts_test.go Project: Castcloud/castcloud-go-server

func TestStoreGetCasts(t *testing.T) {
	casts := store.GetCasts()
	assert.NotNil(t, casts)
	assert.True(t, len(casts) > 0)
	assert.Equal(t, uint64(1), casts[0].ID)
	assert.Equal(t, "test.go", casts[0].URL)
}

Example #3

File: casts_test.go Project: Castcloud/castcloud-go-server

func TestAddCast(t *testing.T) {
	r := createRouter()
	cast := &Cast{}

	// It should return an existing cast
	req := testRequest(r, "POST", "/library/casts", nil)
	req.Header.Set("Authorization", "token")
	req.PostForm = url.Values{}
	req.PostForm.Set("feedurl", "test.go")
	res := req.send()
	assert.Equal(t, 200, res.Code)
	json.Unmarshal(res.Body.Bytes(), cast)
	assert.Equal(t, "test.go", cast.URL)
	assert.Equal(t, "test", cast.Name)

	// There should still be only 2 subscriptions
	user := store.GetUser("test")
	assert.Len(t, user.Subscriptions, 2)

	// It should return 500 when the crawling fails
	req.PostForm.Set("feedurl", "dat_url")
	res = req.send()
	assert.Equal(t, 500, res.Code)

	// There should still be only 2 subscriptions
	user = store.GetUser("test")
	assert.Len(t, user.Subscriptions, 2)

	// It should return a new cast
	req.PostForm.Set("feedurl", testRSS)
	res = req.send()
	assert.Equal(t, 200, res.Code)
	json.Unmarshal(res.Body.Bytes(), cast)
	assert.Equal(t, testRSS, cast.URL)
	assert.Equal(t, "BSD Now HD", cast.Name)
	assert.NotNil(t, cast.Feed)

	// There should now be 3 subscriptions
	user = store.GetUser("test")
	assert.Len(t, user.Subscriptions, 3)

	// The new cast should be in the store
	cast = store.GetCastByURL(testRSS)
	assert.NotNil(t, cast)
	assert.Equal(t, "BSD Now HD", cast.Name)
	assert.NotNil(t, cast.Feed)
}

Example #4

File: router_test.go Project: Castcloud/castcloud-go-server

func TestRouterMatchAny(t *testing.T) {
	e := New()
	r := e.router
	r.Add(GET, "/users/*", func(*Context) error {
		return nil
	}, e)
	c := NewContext(nil, nil, e)

	h, _ := r.Find(GET, "/users/", c)
	if assert.NotNil(t, h) {
		assert.Equal(t, "", c.P(0))
	}

	h, _ = r.Find(GET, "/users/1", c)
	if assert.NotNil(t, h) {
		assert.Equal(t, "1", c.P(0))
	}
}

Example #5

File: router_test.go Project: Castcloud/castcloud-go-server

func TestRouterParamNames(t *testing.T) {
	e := New()
	r := e.router

	// Routes
	r.Add(GET, "/users", func(c *Context) error {
		c.Set("path", "/users")
		return nil
	}, e)
	r.Add(GET, "/users/:id", func(c *Context) error {
		return nil
	}, e)
	r.Add(GET, "/users/:uid/files/:fid", func(c *Context) error {
		return nil
	}, e)
	c := NewContext(nil, nil, e)

	// Route > /users
	h, _ := r.Find(GET, "/users", c)
	if assert.NotNil(t, h) {
		h(c)
		assert.Equal(t, "/users", c.Get("path"))
	}

	// Route > /users/:id
	h, _ = r.Find(GET, "/users/1", c)
	if assert.NotNil(t, h) {
		assert.Equal(t, "id", c.pnames[0])
		assert.Equal(t, "1", c.P(0))
	}

	// Route > /users/:uid/files/:fid
	h, _ = r.Find(GET, "/users/1/files/1", c)
	if assert.NotNil(t, h) {
		assert.Equal(t, "uid", c.pnames[0])
		assert.Equal(t, "1", c.P(0))
		assert.Equal(t, "fid", c.pnames[1])
		assert.Equal(t, "1", c.P(1))
	}
}

Example #6

File: response_test.go Project: Castcloud/castcloud-go-server

func TestResponse(t *testing.T) {
	w := httptest.NewRecorder()
	r := NewResponse(w)

	// SetWriter
	r.SetWriter(w)

	// Writer
	assert.Equal(t, w, r.Writer())

	// Header
	assert.NotNil(t, r.Header())

	// WriteHeader
	r.WriteHeader(http.StatusOK)
	assert.Equal(t, http.StatusOK, r.status)

	// Committed
	assert.True(t, r.committed)

	// Already committed
	r.WriteHeader(http.StatusTeapot)
	assert.NotEqual(t, http.StatusTeapot, r.Status())

	// Status
	r.status = http.StatusOK
	assert.Equal(t, http.StatusOK, r.Status())

	// Write
	s := "echo"
	_, err := r.Write([]byte(s))
	assert.NoError(t, err)

	// Flush
	r.Flush()

	// Size
	assert.EqualValues(t, len(s), r.Size())

	// Hijack
	assert.Panics(t, func() {
		r.Hijack()
	})

	// CloseNotify
	assert.Panics(t, func() {
		r.CloseNotify()
	})

	// reset
	r.reset(httptest.NewRecorder())
}

Example #7

File: router_test.go Project: Castcloud/castcloud-go-server

func TestRouterMicroParam(t *testing.T) {
	e := New()
	r := e.router
	r.Add(GET, "/:a/:b/:c", func(c *Context) error {
		return nil
	}, e)
	c := NewContext(nil, nil, e)
	h, _ := r.Find(GET, "/1/2/3", c)
	if assert.NotNil(t, h) {
		assert.Equal(t, "1", c.P(0))
		assert.Equal(t, "2", c.P(1))
		assert.Equal(t, "3", c.P(2))
	}
}

Example #8

File: store_bolt_users_test.go Project: Castcloud/castcloud-go-server

func TestAddUser(t *testing.T) {
	err := store.AddUser(&User{
		Username: "******",
		Password: "******",
	})
	assert.Nil(t, err)

	user := store.GetUser("added")
	assert.NotNil(t, user)
	assert.Equal(t, "added", user.Username)
	assert.NotEmpty(t, user.Password)

	err = store.AddUser(&User{Username: "******"})
	assert.Equal(t, ErrUsernameUnavailable, err)
}

Example #9

File: router_test.go Project: Castcloud/castcloud-go-server

func TestRouterStatic(t *testing.T) {
	e := New()
	r := e.router
	path := "/folders/a/files/echo.gif"
	r.Add(GET, path, func(c *Context) error {
		c.Set("path", path)
		return nil
	}, e)
	c := NewContext(nil, nil, e)
	h, _ := r.Find(GET, path, c)
	if assert.NotNil(t, h) {
		h(c)
		assert.Equal(t, path, c.Get("path"))
	}
}

Example #10

File: echo_test.go Project: Castcloud/castcloud-go-server

func TestEcho(t *testing.T) {
	e := New()
	req, _ := http.NewRequest(GET, "/", nil)
	rec := httptest.NewRecorder()
	c := NewContext(req, NewResponse(rec), e)

	// Router
	assert.NotNil(t, e.Router())

	// Debug
	e.SetDebug(true)
	assert.True(t, e.Debug())

	// DefaultHTTPErrorHandler
	e.DefaultHTTPErrorHandler(errors.New("error"), c)
	assert.Equal(t, http.StatusInternalServerError, rec.Code)
}

Example #11

File: router_test.go Project: Castcloud/castcloud-go-server

func TestRouterTwoParam(t *testing.T) {
	e := New()
	r := e.router
	r.Add(GET, "/users/:uid/files/:fid", func(*Context) error {
		return nil
	}, e)
	c := NewContext(nil, nil, e)

	h, _ := r.Find(GET, "/users/1/files/1", c)
	if assert.NotNil(t, h) {
		assert.Equal(t, "1", c.P(0))
		assert.Equal(t, "1", c.P(1))
	}

	h, _ = r.Find(GET, "/users/1", c)
	assert.Nil(t, h)
}

Example #12

File: crawl_test.go Project: Castcloud/castcloud-go-server

func TestCrawlFetch(t *testing.T) {
	// It should return the cast
	cast := <-crawl.fetch(testRSS)
	assert.NotNil(t, cast)
	assert.Equal(t, testRSS, cast.URL)
	assert.Equal(t, "BSD Now HD", cast.Name)

	// It should return nil if the url is bad
	assert.Nil(t, <-crawl.fetch("so_bad"))

	// It should return nil if the the status is not 200
	assert.Nil(t, <-crawl.fetch(testServer.URL))

	// It should return nil if it cant parse things
	assert.Nil(t, <-crawl.fetch(testServer.URL+"/notxml"))

	// It should return nil if the xml is not a proper feed
	assert.Nil(t, <-crawl.fetch(testServer.URL+"/notfeed"))
	assert.Nil(t, <-crawl.fetch(testServer.URL+"/badrss"))
	assert.Nil(t, <-crawl.fetch(testServer.URL+"/badatom"))
}

Example #13

File: router_test.go Project: Castcloud/castcloud-go-server

func TestRouterAPI(t *testing.T) {
	e := New()
	r := e.router

	for _, route := range api {
		r.Add(route.Method, route.Path, func(c *Context) error {
			return nil
		}, e)
	}
	c := NewContext(nil, nil, e)
	for _, route := range api {
		h, _ := r.Find(route.Method, route.Path, c)
		if assert.NotNil(t, h) {
			for i, n := range c.pnames {
				if assert.NotEmpty(t, n) {
					assert.Equal(t, ":"+n, c.P(i))
				}
			}
			h(c)
		}
	}
}

Example #14

File: store_bolt_users_test.go Project: Castcloud/castcloud-go-server

func TestGetUsers(t *testing.T) {
	users := store.GetUsers()
	assert.NotNil(t, users)
	assert.Equal(t, "test", users[0].Username)
}

Example #15

File: router_test.go Project: Castcloud/castcloud-go-server

func TestRouterPriority(t *testing.T) {
	e := New()
	r := e.router

	// Routes
	r.Add(GET, "/users", func(c *Context) error {
		c.Set("a", 1)
		return nil
	}, e)
	r.Add(GET, "/users/new", func(c *Context) error {
		c.Set("b", 2)
		return nil
	}, e)
	r.Add(GET, "/users/:id", func(c *Context) error {
		c.Set("c", 3)
		return nil
	}, e)
	r.Add(GET, "/users/dew", func(c *Context) error {
		c.Set("d", 4)
		return nil
	}, e)
	r.Add(GET, "/users/:id/files", func(c *Context) error {
		c.Set("e", 5)
		return nil
	}, e)
	r.Add(GET, "/users/newsee", func(c *Context) error {
		c.Set("f", 6)
		return nil
	}, e)
	r.Add(GET, "/users/*", func(c *Context) error {
		c.Set("g", 7)
		return nil
	}, e)
	c := NewContext(nil, nil, e)

	// Route > /users
	h, _ := r.Find(GET, "/users", c)
	if assert.NotNil(t, h) {
		h(c)
		assert.Equal(t, 1, c.Get("a"))
	}

	// Route > /users/new
	h, _ = r.Find(GET, "/users/new", c)
	if assert.NotNil(t, h) {
		h(c)
		assert.Equal(t, 2, c.Get("b"))
	}

	// Route > /users/:id
	h, _ = r.Find(GET, "/users/1", c)
	if assert.NotNil(t, h) {
		h(c)
		assert.Equal(t, 3, c.Get("c"))
	}

	// Route > /users/dew
	h, _ = r.Find(GET, "/users/dew", c)
	if assert.NotNil(t, h) {
		h(c)
		assert.Equal(t, 4, c.Get("d"))
	}

	// Route > /users/:id/files
	h, _ = r.Find(GET, "/users/1/files", c)
	if assert.NotNil(t, h) {
		h(c)
		assert.Equal(t, 5, c.Get("e"))
	}

	// Route > /users/:id
	h, _ = r.Find(GET, "/users/news", c)
	if assert.NotNil(t, h) {
		h(c)
		assert.Equal(t, 3, c.Get("c"))
	}

	// Route > /users/*
	h, _ = r.Find(GET, "/users/joe/books", c)
	if assert.NotNil(t, h) {
		h(c)
		assert.Equal(t, 7, c.Get("g"))
		assert.Equal(t, "joe/books", c.Param("_name"))
	}
}

Example #16

File: crawl_test.go Project: Castcloud/castcloud-go-server

func TestCrawlFetchAtom(t *testing.T) {
	cast := <-crawl.fetch(testAtom)
	assert.NotNil(t, cast)
	assert.Equal(t, testAtom, cast.URL)
	assert.Equal(t, "Example Feed", cast.Name)
}