@lexho111/plainblog 0.0.9 → 0.0.11

package/Blog.js

@@ -1,9 +1,13 @@
 import http from "http";
 import fetch from "node-fetch";
-import { promises as fs } from "fs";
 import { URLSearchParams } from "url";
+import { fromEvent, firstValueFrom } from "rxjs";
+import { map, scan, takeUntil, last, defaultIfEmpty } from "rxjs/operators";
 import Article from "./Article.js";
-import ApiServer from "./model.js";
+import DatabaseModel from "./model/DatabaseModel.js";
+import { fetchData, postData } from "./model/APIModel.js";
+import { save as saveToFile, load as loadFromFile } from "./model/fileModel.js";
+import { formatHTML, formatMarkdown, validate } from "./Formatter.js";
 
 export default class Blog {
   constructor() {
@@ -15,8 +19,8 @@ export default class Blog {
 
     this.database = {
       type: "sqlite",
-      username: "user",
-      password: "password",
+      username: "user1",
+      password: "password1",
       host: "localhost",
       dbname: "blog",
     };
@@ -24,9 +28,9 @@ export default class Blog {
 
   // Private fields
   #server = null;
-  #apiServer;
+  #databaseModel;
   #isExternalAPI = false;
-  #apiDataLoaded = false;
+  #apiUrl = "";
 
   setTitle(title) {
     this.title = title;
@@ -43,119 +47,68 @@ export default class Blog {
   /** initializes database */
   async init() {
     if (this.#isExternalAPI) {
-      await this.loadFromAPI(this.#APIUrl);
+      console.log("external API");
+      await this.loadFromAPI();
     } else {
-      console.log(`initialize ${this.database.type} database`);
-      this.#apiServer = new ApiServer(this.database);
-      const dbTitle = await this.#apiServer.getBlogTitle();
-      const dbArticles = await this.#apiServer.findAll();
-      const responseData = { title: dbTitle, articles: dbArticles };
-      this.#loadFromData(responseData);
+      console.log(`database: ${this.database.type}`);
+      this.#databaseModel = new DatabaseModel(this.database);
+      console.log(`connected to database`);
+      await this.#databaseModel.initialize();
+      const dbTitle = await this.#databaseModel.getBlogTitle();
+      const dbArticles = await this.#databaseModel.findAll();
+      let title = "";
+      if (this.title.length > 0) title = this.title; // use blog title if set
+      else title = dbTitle;
+      const responseData = { title: title, articles: dbArticles };
+      this.#applyBlogData(responseData);
     }
   }
 
-  // EXTERNAL DATA API
-  #APIUrl = "";
-
-  setAPI(APIUrl) {
-    this.#APIUrl = APIUrl;
-    this.#isExternalAPI = true;
-  }
-
-  /** fetch data from an URL */
-  async #fetchDataFromApi(apiUrl) {
-    try {
-      const response = await fetch(apiUrl);
-
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
-      }
-
-      const data = await response.json();
-      return data;
-    } catch (error) {
-      console.error("Failed to fetch data:", error);
-      return null;
-    }
-  }
-
-  /** post data to an URL */
-  async #postDataToApi(apiUrl, postData) {
-    const response = await fetch(apiUrl, {
-      method: "POST",
-      body: JSON.stringify(postData),
-      headers: { "Content-Type": "application/json" },
-    });
-
-    const data = await response.json();
-    return data;
-  }
-
   /** post a blog article */
-  async #postArticle(req, res) {
-    let body = "";
+  async postArticle(req, res) {
+    // OLD CODE
+    /*let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
-    });
-
-    req.on("end", async () => {
-      const params = new URLSearchParams(body);
-      const title = params.get("title");
-      const content = params.get("content");
+    });*/
+    // NEW CODE
+    // Create a stream of the body string
+    const body$ = fromEvent(req, "data").pipe(
+      map((chunk) => chunk.toString()),
+      scan((acc, chunk) => acc + chunk, ""), // Accumulate chunks
+      takeUntil(fromEvent(req, "end")), // Stop when 'end' emits
+      last(), // Emit only the final full string
+      defaultIfEmpty("") // Handle empty bodies
+    );
 
-      if (title && content) {
-        const newArticleData = { title, content };
-        try {
-          // Save the new article to the database via the ApiServer
-          await this.#apiServer.save(newArticleData);
-          // Add the article to the local list for immediate display
-          this.addArticle(new Article(title, content));
-        } catch (error) {
-          console.error("Failed to post new article to API:", error);
-        }
+    const body = await firstValueFrom(body$);
+
+    //req.on("end", async () => {
+    const params = new URLSearchParams(body);
+    const title = params.get("title");
+    const content = params.get("content");
+
+    if (title && content) {
+      const newArticleData = { title, content };
+      try {
+        // Save the new article to the database via the ApiServer
+        if (this.#databaseModel) await this.#databaseModel.save(newArticleData);
+        if (this.#isExternalAPI) await postData(this.#apiUrl, newArticleData);
+        // Add the article to the local list for immediate display
+        this.addArticle(new Article(title, content));
+      } catch (error) {
+        console.error("Failed to post new article to API:", error);
       }
-
-      res.writeHead(303, { Location: "/" });
-      res.end();
-    });
-  }
-
-  /** everything that happens in /api  */
-  async #jsonAPI(req, res) {
-    // GET all blog data
-    if (req.method === "GET" && req.url === "/api") {
-      // controller
-      res.writeHead(200, { "Content-Type": "application/json" });
-      const dbArticles = await this.#apiServer.findAll();
-      const responseData = {
-        title: this.title, // Keep the title from the original constant
-        articles: dbArticles,
-      };
-      console.log(`responseData: ${responseData}`);
-      res.end(JSON.stringify(responseData));
     }
 
-    // POST a new article
-    else if (req.method === "POST" && req.url === "/api/articles") {
-      let body = "";
-      req.on("data", (chunk) => (body += chunk.toString()));
-      req.on("end", async () => {
-        const newArticle = JSON.parse(body);
-
-        // local
-        await this.#apiServer.save(newArticle); // --> to api server
-        // extern
-
-        res.writeHead(201, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(newArticle));
-      });
-    }
+    res.writeHead(303, { Location: "/" });
+    res.end();
+    //});
   }
 
   /** start a http server with default port 8080 */
   async startServer(port = 8080) {
-    if (this.#apiServer === undefined) this.init(); // init blog if it didn't already happen
-    await this.#apiServer.initialize();
+    if (this.#databaseModel === undefined) await this.init(); // init blog if it didn't already happen
 
     const server = http.createServer(async (req, res) => {
       // API routes
@@ -167,8 +120,8 @@ export default class Blog {
       // Web Page Routes
       // POST new article
       if (req.method === "POST" && req.url === "/") {
-        await this.#apiServer.updateBlogTitle(this.title);
-        await this.#postArticle(req, res);
+        await this.#databaseModel.updateBlogTitle(this.title);
+        await this.postArticle(req, res);
         // GET artciles
       } else if (req.method === "GET" && req.url === "/") {
         // load articles
@@ -187,7 +140,7 @@ export default class Blog {
 
     return new Promise((resolve) => {
       this.#server.listen(port, () => {
-        console.log(`Server running at http://localhost:${port}/`);
+        console.log(`server running at http://localhost:${port}/`);
         resolve(); // Resolve the promise when the server is listening
       });
     });
@@ -207,42 +160,8 @@ export default class Blog {
     });
   }
 
-  /** save blog content to file */
-  async save(filename = this.filename) {
-    if (this.#apiServer === undefined) this.init(); // init blog if it didn't already happen
-    //await this.#apiServer.initialize();
-    if (this.#isExternalAPI) await this.loadFromAPI(this.#APIUrl);
-    if (!filename) {
-      console.error("Error: Filename not provided and not set previously.");
-      return;
-    }
-    this.filename = filename;
-    const data = {
-      title: this.title,
-      articles: this.articles,
-    };
-
-    try {
-      await fs.writeFile(filename, JSON.stringify(data, null, 2));
-      console.log(`Blog data saved to ${filename}`);
-    } catch (err) {
-      console.error("Error saving blog data:", err);
-    }
-  }
-
-  /** load blog content from file */
-  async load(filename) {
-    this.filename = filename;
-    const data = await fs.readFile(filename, "utf8");
-    const jsonData = JSON.parse(data);
-    this.title = jsonData.title;
-    this.articles = jsonData.articles.map(
-      (article) => new Article(article.title, article.content)
-    );
-  }
-
   /** Populates the blog's title and articles from a data object. */
-  #loadFromData(data) {
+  #applyBlogData(data) {
     this.articles = []; // Clear existing articles before loading new ones
     this.setTitle(data.title);
     // Assuming the API returns an array of objects with title and content
@@ -250,61 +169,91 @@ export default class Blog {
       for (const articleData of data.articles) {
         this.addArticle(new Article(articleData.title, articleData.content));
       }
-      this.#apiDataLoaded = true; // Mark that we have successfully loaded data
     }
   }
 
-  async loadFromAPI(apiUrl) {
-    const data = await this.#fetchDataFromApi(apiUrl);
+  async save(filename = this.filename) {
+    if (this.#databaseModel === undefined) this.init(); // init blog if it didn't already happen
+    //await this.#apiServer.initialize();
+    if (this.#isExternalAPI) await this.loadFromAPI();
+    const blogData = { title: this.title, articles: this.articles };
+    saveToFile(filename, blogData);
+  }
+
+  async load(filename) {
+    loadFromFile(filename, (title, articles) => {
+      this.title = title;
+      this.articles = articles.map(
+        (article) => new Article(article.title, article.content)
+      );
+    });
+  }
+
+  async loadFromAPI() {
+    const data = await fetchData(this.#apiUrl);
     if (data) {
-      this.#loadFromData(data);
+      this.#applyBlogData(data);
     }
   }
 
-  /** print markdown to the console */
-  async print() {
-    console.log(`# ${this.title}`);
-    for (const article of this.articles) {
-      console.log(`## ${article.title}`);
-      console.log(article.content);
+  // controller
+  /** everything that happens in /api  */
+  async #jsonAPI(req, res) {
+    // GET all blog data
+    if (req.method === "GET" && req.url === "/api") {
+      // controller
+      res.writeHead(200, { "Content-Type": "application/json" });
+      const dbArticles = await this.#databaseModel.findAll();
+      const responseData = {
+        title: this.title, // Keep the title from the original constant
+        articles: dbArticles,
+      };
+      console.log(`responseData: ${responseData}`);
+      res.end(JSON.stringify(responseData));
     }
-  }
 
-  /** render this blog content to html */
-  async toHTML() {
-    // If we have an API URL and haven't loaded data yet, load it now.
-    if (this.#APIUrl && !this.#apiDataLoaded) {
-      await this.loadFromAPI(this.#APIUrl);
+    // POST a new article
+    else if (req.method === "POST" && req.url === "/api/articles") {
+      let body = "";
+      req.on("data", (chunk) => (body += chunk.toString()));
+      req.on("end", async () => {
+        const newArticle = JSON.parse(body);
+
+        // local
+        await this.#databaseModel.save(newArticle); // --> to api server
+        // extern
+
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(newArticle));
+      });
     }
+  }
 
-    return `<!DOCTYPE html>
-<html lang="de">
-  <head>
-    <meta charset="UTF-8">
-    <title>${this.title}</title>
-    <style>${this.style}</style>
-  </head>
-  <body>
-    <h1>${this.title}</h1>
-    <div style="width: 500px;">
-      <form action="/" method="POST">
-        <h3>Add a New Article</h3>
-        <input type="text" name="title" placeholder="Article Title" required style="display: block; width: 300px; margin-bottom: 10px;">
-        <textarea name="content" placeholder="Article Content" required style="display: block; width: 300px; height: 100px; margin-bottom: 10px;"></textarea>
-        <button type="submit">Add Article</button>
-      </form>
-      <hr>
-      ${this.articles
-        .map(
-          (article) => `
-      <article>
-        <h2>${article.title}</h2>
-        <p>${article.getContentShort()}</p>
-      </article>`
-        )
-        .join("")}
-    </div>
-  </body>
-</html>`;
+  /** set external API */
+  setAPI(APIUrl) {
+    this.#apiUrl = APIUrl;
+    this.#isExternalAPI = true;
+  }
+
+  /** print markdown to the console */
+  async print() {
+    const data = {
+      title: this.title,
+      articles: this.articles,
+    };
+    const markdown = formatMarkdown(data);
+    console.log(markdown);
+  }
+
+  /** render this blog content to valid html */
+  toHTML() {
+    const data = {
+      title: this.title,
+      style: this.style,
+      articles: this.articles,
+    };
+    const html = formatHTML(data);
+    if (validate(html)) return html;
+    else throw new Error("Error. Invalid HTML!");
   }
 }

package/Formatter.js

@@ -0,0 +1,80 @@
+/** format content to html */
+export function formatHTML(data) {
+  const script = `function generateRandomContent(length) {
+          let str = "";
+          const char = "A";
+          for (let i = 0; i < length; i++) {
+            const rnd = Math.random() * ("z".charCodeAt(0) - "A".charCodeAt(0)); // A z.charCodeAt(0)"
+            const char1 = String.fromCharCode(char.charCodeAt(0) + rnd);
+            str += char1;
+          }
+          return str;
+        }
+        function fillWithContent() { 
+          let title = document.getElementById("title");
+          let cont = document.getElementById("content");
+          cont.value = generateRandomContent(200);
+          title.value = generateRandomContent(50);
+        }`;
+  const button = `<button type="button" onClick="fillWithContent();" style="margin: 4px;">generate random text</button>`;
+  return `<!DOCTYPE html>
+<html lang="de">
+  <head>
+    <meta charset="UTF-8">
+    <title>${data.title}</title>
+    <style>${data.style}</style>
+  </head>
+  <body>
+    <h1>${data.title}</h1>
+    <div style="width: 500px;">
+      <form action="/" method="POST">
+        <h3>Add a New Article</h3>
+        <input type="text" id="title" name="title" placeholder="Article Title" required style="display: block; width: 300px; margin-bottom: 10px;">
+        <textarea id="content" name="content" placeholder="Article Content" required style="display: block; width: 300px; height: 100px; margin-bottom: 10px;"></textarea>
+        <button type="submit">Add Article</button>
+        <script>
+        ${script}
+        </script>
+      </form>
+      <hr>
+      ${data.articles
+        .map(
+          (article) => `
+      <article style="overflow-wrap: break-word;">
+        <h2>${article.title}</h2>
+        <p>${article.getContentShort()}</p>
+      </article>`
+        )
+        .join("")}
+    </div>
+  </body>
+</html>`;
+}
+
+export function formatMarkdown(data) {
+  let markdown = "";
+  markdown += `# ${data.title}\n`;
+  for (const article of data.articles) {
+    markdown += `## ${article.title}\n`;
+    markdown += article.content;
+    markdown += "\n";
+  }
+  return markdown;
+}
+
+export function validate(html) {
+  let test = true; // all tests passed
+  if (!(html.includes("<html") && html.includes("</html"))) {
+    console.error("html not ok");
+    test = false;
+  }
+  if (!(html.includes("<head") && html.includes("</head"))) {
+    console.error("head not ok");
+    test = false;
+  }
+  if (!(html.includes("<body") && html.includes("</body"))) {
+    console.error("body not ok");
+    test = false;
+  }
+  return test;
+}

package/README.md

@@ -42,10 +42,17 @@ await blog.init(); // load data from database
 blog.startServer(8080);
 ```
 
-### set an external API to fetch data from an external database
+### set an API to fetch data from an external database
 
 ```
+import Blog from "@lexho111/plainblog";
+
+const blog = new Blog();
 blog.setAPI("http://example.com:5432/blog")
+blog.setStyle("body { font-family: Arial, sans-serif; } h1 { color: #333; }");
+await blog.init(); // load data from database
+
+blog.startServer(8080);
 ```
 
 save data to file

package/blog.json

@@ -0,0 +1,9 @@
+{
+  "title": "",
+  "articles": [
+    {
+      "title": "hello",
+      "content": "hello world!"
+    }
+  ]
+}

package/model/APIModel.js

@@ -0,0 +1,41 @@
+import fetch from "node-fetch";
+import { defer, firstValueFrom, timer, of } from "rxjs";
+import { retry, mergeMap, catchError } from "rxjs/operators";
+
+// EXTERNAL DATA API
+
+/** fetch data from an URL */
+export async function fetchData(apiUrl) {
+  const request$ = defer(() => fetch(apiUrl)).pipe(
+    // 1. Check response status inside the stream
+    mergeMap(async (response) => {
+      if (!response.ok)
+        throw new Error(`HTTP error! status: ${response.status}`);
+      return response.json();
+    }),
+    // 2. Retry 3 times, waiting 1s, 2s, 3s respectively
+    retry({
+      count: 3,
+      delay: (error, retryCount) => timer(retryCount * 1000),
+    }),
+    // 3. Handle final failure
+    catchError((error) => {
+      console.error("Failed to fetch data after retries:", error);
+      return of(null);
+    })
+  );
+
+  return firstValueFrom(request$);
+}
+
+/** post data to an URL */
+export async function postData(apiUrl, postData) {
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    body: JSON.stringify(postData),
+    headers: { "Content-Type": "application/json" },
+  });
+
+  const data = await response.json();
+  return data;
+}

package/{model.js → model/DatabaseModel.js}

@@ -1,6 +1,6 @@
 import { Sequelize, DataTypes } from "sequelize";
 
-export default class ApiServer {
+export default class DatabaseModel {
   #username;
   #password;
   #host;
@@ -16,7 +16,7 @@ export default class ApiServer {
     if (databasetype === "sqlite") {
       this.#sequelize = new Sequelize({
         dialect: "sqlite",
-        storage: "./blog.db",
+        storage: `./${this.#dbname}.db`,
         logging: false,
       });
     } else if (databasetype === "postgres") {
@@ -49,7 +49,7 @@ export default class ApiServer {
       "Article",
       {
         title: DataTypes.STRING,
-        content: DataTypes.STRING,
+        content: DataTypes.TEXT,
       },
       {
         timestamps: false, // Assuming you don't need createdAt/updatedAt for this simple model
@@ -70,12 +70,13 @@ export default class ApiServer {
   async initialize() {
     // This creates the tables if they don't exist.
     await this.#sequelize.sync({ alter: true });
+    console.log("database tables synced and ready.");
 
     // Check for and create the initial blog title right after syncing.
     const blogInfoCount = await this.#BlogInfo.count();
     if (blogInfoCount === 0) {
       await this.#BlogInfo.create({ title: "My Default Blog Title" });
-      console.log("Initialized blog title in database.");
+      console.log("initialized blog title in database.");
     }
   }
 

package/model/fileModel.js

@@ -0,0 +1,25 @@
+import { promises as fs } from "fs";
+
+/** save blog content to file */
+export async function save(filename, data) {
+  if (!filename) {
+    console.error("Error: Filename not provided and not set previously.");
+    return;
+  }
+
+  try {
+    await fs.writeFile(filename, JSON.stringify(data, null, 2));
+    console.log(`Blog data saved to ${filename}`);
+  } catch (err) {
+    console.error("Error saving blog data:", err);
+  }
+}
+
+/** load blog content from file */
+export async function load(filename, f) {
+  const data = await fs.readFile(filename, "utf8");
+  const jsonData = JSON.parse(data);
+  const title = jsonData.title;
+  const articles = jsonData.articles;
+  f(title, articles);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexho111/plainblog",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "A tool for creating and serving a minimalist, single-page blog.",
   "main": "index.js",
   "type": "module",
@@ -19,6 +19,7 @@
     "node-fetch": "^3.3.2",
     "pg": "^8.16.3",
     "pg-hstore": "^2.3.4",
+    "rxjs": "^7.8.2",
     "sequelize": "^6.37.7",
     "sqlite3": "^5.1.7"
   },

package/test/blog.test.js

@@ -61,7 +61,7 @@ describe("test blog", () => {
       expect(html).toContain(style);
     }
   });
-  test("print method logs title and articles to console", () => {
+  test("print method logs title and articles to console", async () => {
     // Arrange: Set up the blog with a title and articles
     const myblog = new Blog();
     myblog.setTitle("My Test Blog");
@@ -71,12 +71,14 @@ describe("test blog", () => {
     const consoleSpy = jest.spyOn(console, "log").mockImplementation(() => {});
 
     // Act: Call the method we want to test
-    myblog.print();
+    await myblog.print();
 
     // Assert: Check if console.log was called with the correct strings
-    expect(consoleSpy).toHaveBeenCalledWith("# My Test Blog");
-    expect(consoleSpy).toHaveBeenCalledWith("## Article 1");
-    expect(consoleSpy).toHaveBeenCalledWith("Content 1");
+    expect(consoleSpy).toHaveBeenCalled();
+    const output = consoleSpy.mock.calls[0][0];
+    expect(output).toContain("# My Test Blog");
+    expect(output).toContain("## Article 1");
+    expect(output).toContain("Content 1");
 
     // Clean up the spy to restore the original console.log
     consoleSpy.mockRestore();

package/test/model.test.js

@@ -0,0 +1,151 @@
+import Blog from "../Blog.js";
+import Article from "../Article.js";
+import { fetchData, postData } from "../model/APIModel.js";
+import { server } from "./simpleServer.js";
+
+function generateRandomContent(length) {
+  let str = "";
+  const char = "A";
+  for (let i = 0; i < length; i++) {
+    const rnd = Math.random() * ("z".charCodeAt(0) - "A".charCodeAt(0)); // A z.charCodeAt(0)"
+    const char1 = String.fromCharCode(char.charCodeAt(0) + rnd);
+    str += char1;
+  }
+  return str;
+}
+
+describe("File Model test", () => {
+  it("should load blog data from blog.json", async () => {
+    const blog = new Blog();
+    blog.setStyle(
+      "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
+    );
+
+    const content = generateRandomContent(200);
+
+    const article = new Article("hello", content);
+    blog.addArticle(article);
+
+    await blog.load("blog.json");
+
+    expect(await blog.toHTML()).toContain(content);
+    expect(blog).toBeDefined();
+  });
+});
+
+describe("API Model test", () => {
+  beforeAll(() => {
+    const port = 8081;
+    server.listen(port, () => {
+      console.log(`Simple server running at http://localhost:${port}/`);
+    });
+  });
+  afterAll(() => {
+    return new Promise((done) => {
+      server.close(done);
+    });
+  });
+
+  it("should load blog data from API", async () => {
+    const blog = new Blog();
+    blog.setAPI("http://localhost:8081/blog");
+    blog.setStyle(
+      "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
+    );
+    await blog.init();
+
+    const content = generateRandomContent(200);
+
+    await new Promise((resolve) => {
+      const req = {
+        on: (event, cb) => {
+          if (event === "data") {
+            setTimeout(() => cb(`title=hello&content=${content}`), 0);
+          }
+          if (event === "end") {
+            setTimeout(() => cb(), 10);
+          }
+        },
+        off: () => {},
+      };
+      const res = {
+        writeHead: () => {},
+        end: resolve,
+      };
+      blog.postArticle(req, res);
+    });
+
+    expect(await blog.toHTML()).toContain(content);
+    expect(blog).toBeDefined();
+  });
+
+  it("should fetch data from API", async () => {
+    const API = "http://localhost:8081/blog";
+    const data = await fetchData(API);
+    expect(data).toBeDefined();
+    expect(data.title).toBe("Mock Blog Title");
+    expect(data.articles).toHaveLength(2);
+  });
+
+  it("should post blog data to API", async () => {
+    const API = "http://localhost:8081/blog";
+    const newArticle = { title: "New Post", content: "New Content" };
+    const data = await postData(API, newArticle);
+    expect(data).toEqual(newArticle);
+  });
+});
+
+describe("Database Model test", () => {
+  it("should be empty", async () => {
+    const blog = new Blog();
+    blog.database.type = "sqlite";
+    blog.database.dbname = "test";
+    blog.setStyle(
+      "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
+    );
+
+    //const article = new Article("hello", "hello world1!");
+    //blog.postArticle(article);
+
+    //await blog.load("blog.json");
+
+    expect(await blog.toHTML()).not.toContain("<article>");
+    expect(blog).toBeDefined();
+  });
+
+  it("should load blog data from sqlite database", async () => {
+    const blog = new Blog();
+    blog.database.type = "sqlite";
+    blog.database.dbname = "test_" + Date.now();
+    blog.setStyle(
+      "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
+    );
+    await blog.init();
+
+    const content = generateRandomContent(200);
+
+    await new Promise((resolve) => {
+      const req = {
+        on: (event, cb) => {
+          if (event === "data") {
+            setTimeout(() => cb(`title=hello&content=${content}`), 0);
+          }
+          if (event === "end") {
+            setTimeout(() => cb(), 20);
+          }
+        },
+        off: () => {},
+      };
+      const res = {
+        writeHead: () => {},
+        end: resolve,
+      };
+      blog.postArticle(req, res);
+    });
+
+    //await blog.load("blog.json");
+
+    expect(await blog.toHTML()).toContain(content);
+    expect(blog).toBeDefined();
+  });
+});

package/test/server.test.js

@@ -13,6 +13,7 @@ import Blog from "../Blog.js";
 
 const PORT = 8080;
 const apiBaseUrl = `http://localhost:${PORT}`;
+
 describe("server test", () => {
   const blog = new Blog(); // Create one blog instance for all tests
   blog.setTitle("My Blog");
@@ -23,6 +24,7 @@ describe("server test", () => {
     blog.setStyle(
       "body { font-family: Arial, sans-serif; } h1 { color: #333; }"
     );
+    await blog.init();
     // Await it to ensure the server is running before tests start.
     await blog.startServer(PORT);
   });
@@ -33,12 +35,35 @@ describe("server test", () => {
     await blog.closeServer();
   });
 
-  test("should post a new article via /api/articles endpoint", async () => {
+  test("check if server responds to /", async () => {
+    // get articles from blog api
+    const response = await fetch(`${apiBaseUrl}/`, {
+      method: "GET",
+    });
+
+    expect(response.status).toBe(200);
+    const html = await response.text();
+    expect(html).toContain("My Blog");
+  });
+
+  test("check if server responds to /api", async () => {
+    // get articles from blog api
+    const response = await fetch(`${apiBaseUrl}/api`, {
+      method: "GET",
+    });
+
+    expect(response.status).toBe(200);
+    const responseData = await response.json();
+    expect(responseData.title).toBe("My Blog");
+  });
+
+  test("should post a new article via /api/articles", async () => {
     const newArticle = {
       title: "Test Title from Jest",
       content: "This is the content of the test article.",
     };
 
+    // post new article to the blog
     const response = await fetch(`${apiBaseUrl}/api/articles`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -48,5 +73,7 @@ describe("server test", () => {
     expect(response.status).toBe(201);
     const responseData = await response.json();
     expect(responseData).toEqual(newArticle);
+
+    expect(blog.toHTML()).toContain(newArticle.content); // does blog contain my new article?
   });
 });

package/test/simpleServer.js

@@ -0,0 +1,43 @@
+import http from "http";
+
+const port = 8081;
+
+export const server = http.createServer((req, res) => {
+  // Set CORS headers to allow requests from different origins if needed
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  if (req.url === "/blog") {
+    if (req.method === "GET") {
+      const data = {
+        title: "Mock Blog Title",
+        articles: [
+          { title: "Mock Article 1", content: "Content of mock article 1" },
+          { title: "Mock Article 2", content: "Content of mock article 2" },
+        ],
+      };
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(data));
+    } else if (req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk) => (body += chunk.toString()));
+      req.on("end", () => {
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(body); // Echo the received data back
+      });
+    } else {
+      res.writeHead(405); // Method Not Allowed
+      res.end();
+    }
+  } else {
+    res.writeHead(404); // Not Found
+    res.end();
+  }
+});