Aligns tests with readme and adds simple solution to validate it works

.github/workflows/test.yml-template

@@ -0,0 +1,23 @@
+name: Test
+
+on:
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm install
+    - run: npm test

package.json

@@ -18,7 +18,7 @@
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",
     "@mate-academy/eslint-config": "latest",
-    "@mate-academy/scripts": "^1.8.6",
+    "@mate-academy/scripts": "^2.1.3",
     "axios": "^1.7.2",
     "eslint": "^8.57.0",
     "eslint-plugin-jest": "^28.6.0",

src/createServer.js

@@ -1,8 +1,126 @@
 'use strict';
 
+const http = require('http');
+const fs = require('fs');
+const zlib = require('zlib');
+const { pipeline } = require('stream');
+const { formidable } = require('formidable');
+
+const compressionByType = {
+  gzip: {
+    createCompressor: () => zlib.createGzip(),
+    extension: 'gz',
+  },
+  deflate: {
+    createCompressor: () => zlib.createDeflate(),
+    extension: 'dfl',
+  },
+  br: {
+    createCompressor: () => zlib.createBrotliCompress(),
+    extension: 'br',
+  },
+};
+
+function normalizeFieldValue(value) {
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+
+  return value;
+}
+
+function normalizeFileValue(file) {
+  if (Array.isArray(file)) {
+    return file[0];
+  }
+
+  return file;
+}
+
+function sendStatus(res, statusCode, message = '') {
+  res.statusCode = statusCode;
+  res.end(message);
+}
+
+function handleCompressRequest(req, res) {
+  const form = formidable({ multiples: false });
+
+  form.parse(req, (parseError, fields, files) => {
+    if (parseError) {
+      sendStatus(res, 400, 'Invalid form data');
+
+      return;
+    }
+
+    const compressionType = normalizeFieldValue(fields.compressionType);
+    const uploadedFile = normalizeFileValue(files.file);
+
+    if (!compressionType || !uploadedFile) {
+      sendStatus(res, 400, 'Invalid form data');
+
+      return;
+    }
+
+    const compressionConfig = compressionByType[compressionType];
+
+    if (!compressionConfig) {
+      sendStatus(res, 400, 'Unsupported compression type');
+
+      return;
+    }
+
+    const originalFilename = uploadedFile.originalFilename;
+    const tempFilePath = uploadedFile.filepath;
+
+    if (!originalFilename || !tempFilePath) {
+      sendStatus(res, 400, 'Invalid form data');
+
+      return;
+    }
+
+    res.statusCode = 200;
+    res.setHeader('Content-Type', 'application/octet-stream');
+
+    res.setHeader(
+      'Content-Disposition',
+      `attachment; filename=${originalFilename}.${compressionConfig.extension}`,
+    );
+
+    pipeline(
+      fs.createReadStream(tempFilePath),
+      compressionConfig.createCompressor(),
+      res,
+      (streamError) => {
+        if (streamError && !res.headersSent) {
+          sendStatus(res, 500, 'Failed to compress file');
+        }
+      },
+    );
+  });
+}
+
 function createServer() {
-  /* Write your code here */
-  // Return instance of http.Server class
+  return http.createServer((req, res) => {
+    if (req.method === 'GET' && req.url === '/') {
+      sendStatus(res, 200, 'Compression app server');
+
+      return;
+    }
+
+    if (req.url === '/compress' && req.method === 'GET') {
+      sendStatus(res, 400, 'Use POST method');
+
+      return;
+    }
+
+    if (req.url === '/compress' && req.method === 'POST') {
+      handleCompressRequest(req, res);
+
+      return;
+    }
+
+    sendStatus(res, 404, 'Not found');
+  });
 }
 
 module.exports = {

tests/createServer.test.js

@@ -29,12 +29,15 @@ function stringToStream(str) {
 const compressionTypes = {
   gzip: {
     decompress: util.promisify(zlib.gunzip),
+    extension: 'gz',
   },
   deflate: {
     decompress: util.promisify(zlib.inflate),
+    extension: 'dfl',
   },
   br: {
     decompress: util.promisify(zlib.brotliDecompress),
+    extension: 'br',
   },
 };
 
@@ -96,7 +99,7 @@ describe('createServer', () => {
       });
 
       Object.entries(compressionTypes).forEach(
-        ([compressionType, { decompress }]) => {
+        ([compressionType, { decompress, extension }]) => {
           describe(`compression type "${compressionType}"`, () => {
             it('should respond with 200 status code', () => {
               expect.assertions(1);
@@ -124,7 +127,7 @@ describe('createServer', () => {
                   headers: formData.getHeaders(),
                 })
                 .then((res) => {
-                  const expectedHeader = `attachment; filename=${filename}.${compressionType}`;
+                  const expectedHeader = `attachment; filename=${filename}.${extension}`;
 
                   expect(res.headers['content-disposition']).toBe(
                     expectedHeader,