owl-blogs/repository_test.go

181 lines
4.6 KiB
Go
Raw Normal View History

2022-07-20 17:17:42 +00:00
package kiss_test
import (
"h4kor/kiss-social"
"os"
"path"
"testing"
)
func TestCanCreateRepository(t *testing.T) {
repoName := testRepoName()
_, err := kiss.CreateRepository(repoName)
if err != nil {
2022-07-23 07:11:25 +00:00
t.Error("Error creating repository: ", err.Error())
2022-07-20 17:17:42 +00:00
}
}
func TestCannotCreateExistingRepository(t *testing.T) {
repoName := testRepoName()
kiss.CreateRepository(repoName)
_, err := kiss.CreateRepository(repoName)
if err == nil {
t.Error("No error returned when creating existing repository")
}
}
func TestCanCreateANewUser(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
2022-07-20 17:35:31 +00:00
user, _ := repo.CreateUser(randomUserName())
2022-07-20 17:17:42 +00:00
if _, err := os.Stat(path.Join(user.Dir(), "")); err != nil {
t.Error("User directory not created")
}
}
func TestCannotRecreateExisitingUser(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
userName := randomUserName()
2022-07-20 17:35:31 +00:00
repo.CreateUser(userName)
_, err := repo.CreateUser(userName)
2022-07-20 17:17:42 +00:00
if err == nil {
t.Error("No error returned when creating existing user")
}
}
func TestCreateUserAddsVersionFile(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
2022-07-20 17:35:31 +00:00
user, _ := repo.CreateUser(randomUserName())
2022-07-20 17:17:42 +00:00
if _, err := os.Stat(path.Join(user.Dir(), "/meta/VERSION")); err != nil {
t.Error("Version file not created")
}
}
func TestCreateUserAddsBaseHtmlFile(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
2022-07-20 17:35:31 +00:00
user, _ := repo.CreateUser(randomUserName())
2022-07-20 17:17:42 +00:00
if _, err := os.Stat(path.Join(user.Dir(), "/meta/base.html")); err != nil {
t.Error("Base html file not created")
}
}
func TestCreateUserAddsPublicFolder(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
2022-07-20 17:35:31 +00:00
user, _ := repo.CreateUser(randomUserName())
2022-07-20 17:17:42 +00:00
if _, err := os.Stat(path.Join(user.Dir(), "/public")); err != nil {
t.Error("Public folder not created")
}
}
2022-07-24 14:19:21 +00:00
func TestCanListRepoUsers(t *testing.T) {
2022-07-20 17:17:42 +00:00
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
2022-07-20 17:35:31 +00:00
user1, _ := repo.CreateUser(randomUserName())
user2, _ := repo.CreateUser(randomUserName())
2022-07-20 17:17:42 +00:00
// Create a new post
2022-07-20 17:35:31 +00:00
users, _ := repo.Users()
2022-07-24 14:19:21 +00:00
if len(users) != 2 {
t.Error("Wrong number of users returned, expected 2, got ", len(users))
2022-07-20 17:17:42 +00:00
}
2022-07-20 17:35:31 +00:00
for _, user := range users {
2022-07-24 14:19:21 +00:00
if user.Name() != user1.Name() && user.Name() != user2.Name() {
t.Error("User found: " + user.Name())
2022-07-20 17:35:31 +00:00
}
2022-07-20 17:17:42 +00:00
}
}
2022-07-23 07:00:10 +00:00
func TestCanOpenRepository(t *testing.T) {
// Create a new user
repoName := testRepoName()
repo, _ := kiss.CreateRepository(repoName)
// Open the repository
repo2, err := kiss.OpenRepository(repoName)
if err != nil {
2022-07-23 07:11:25 +00:00
t.Error("Error opening repository: ", err.Error())
2022-07-23 07:00:10 +00:00
}
if repo2.Dir() != repo.Dir() {
t.Error("Repository directories do not match")
}
}
func TestCannotOpenNonExisitingRepo(t *testing.T) {
_, err := kiss.OpenRepository(testRepoName())
if err == nil {
t.Error("No error returned when opening non-existing repository")
}
}
2022-07-23 15:19:47 +00:00
func TestGetUser(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
user, _ := repo.CreateUser(randomUserName())
// Get the user
user2, err := repo.GetUser(user.Name())
if err != nil {
t.Error("Error getting user: ", err.Error())
}
if user2.Name() != user.Name() {
t.Error("User names do not match")
}
}
func TestCannotGetNonexistingUser(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
_, err := repo.GetUser(randomUserName())
if err == nil {
t.Error("No error returned when getting non-existing user")
}
}
2022-07-24 13:34:52 +00:00
func TestGetStaticDirOfRepo(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
// Get the user
staticDir := repo.StaticDir()
if staticDir == "" {
t.Error("Static dir not returned")
}
}
func TestNewRepoGetsStaticFiles(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
if _, err := os.Stat(repo.StaticDir()); err != nil {
t.Error("Static directory not found")
}
dir, _ := os.Open(repo.StaticDir())
defer dir.Close()
files, _ := dir.Readdirnames(-1)
if len(files) == 0 {
t.Error("No static files found")
}
}
2022-07-24 18:29:31 +00:00
func TestNewRepoGetsBaseHtml(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
if _, err := os.Stat(path.Join(repo.Dir(), "/base.html")); err != nil {
t.Error("Base html file not found")
}
}
func TestCanGetRepoTemplate(t *testing.T) {
// Create a new user
repo, _ := kiss.CreateRepository(testRepoName())
// Get the user
template, err := repo.Template()
if err != nil {
t.Error("Error getting template: ", err.Error())
}
if template == "" {
t.Error("Template not returned")
}
}