Merge pull request #10 from hiddenboox/feature/refactor

Feature/refactor

Author: hiddenboox

src/authorize.js

@@ -10,7 +10,6 @@ export default async ({ clientId, clientSecret, grantType } = {}) => {
   try {
     const response = await post(
       `${environment}/pl/standard/user/oauth/authorize`,
-      null,
       {
         json: true,
         params: {
@@ -27,7 +26,7 @@ export default async ({ clientId, clientSecret, grantType } = {}) => {
       expiresIn: response.expires_in,
       grantType: response.grant_type
     }
-  } catch (ex) {
-    console.error(ex.message)
+  } catch (err) {
+    throw new Error(err.message)
   }
 }

src/consts.js

@@ -2,9 +2,10 @@ export const ContentType = {
   JSON: 'application/json'
 }
 
-export const HEADERS = {
+export const HEADER = {
   Authorization: 'Authorization',
-  'Content-Type': 'Content-Type'
+  ContentType: 'Content-Type',
+  ContentLength: 'Content-Length'
 }
 
 export const HttpVerb = {

src/helpers/request.js

@@ -3,36 +3,41 @@ import https from 'https'
 import { URL } from 'url'
 
 import { HttpVerb } from '../consts'
+import { required } from './validation'
 
 export const request = (
   { url, json, params, body, ...rest } = { method: HttpVerb.GET, json: true }
 ) => {
+  required('url', url)
+
   const { pathname, search, host } = new URL(
     `${url}${params ? '?' + querystring.stringify(params) : ''}`
   )
   return new Promise((resolve, reject) => {
     const path = `${pathname}${search}`
     const req = https
-      .request({ host, path, ...rest }, resp => {
+      .request({ host, path, ...rest }, res => {
         let data = ''
-        resp.setEncoding('utf8')
-        resp.on('data', chunk => {
+        res.setEncoding('utf8')
+        res.on('data', chunk => {
           data += chunk
         })
-
-        resp.on('end', () => resolve(json ? JSON.parse(data) : data))
+        res.on('end', () => {
+          resolve(json ? JSON.parse(data) : data)
+        })
       })
-      .on('error', err => reject('Error: ' + err.message))
+
+    req.on('error', err => {
+      reject(new Error(err.message))
+    })
 
     if (body) {
-      req.write(json ? JSON.stringify(body) : body)
+      req.write(typeof body === 'object' ? JSON.stringify(body) : body)
     }
 
     req.end()
   })
 }
 
-export const get = (url, params, options = {}) =>
-  request({ ...options, url, params, method: HttpVerb.GET })
-export const post = (url, body, options = {}) =>
-  request({ ...options, url, body, method: HttpVerb.POST })
+export const get = (url, options = {}) => request({ ...options, url, method: HttpVerb.GET })
+export const post = (url, options = {}) => request({ ...options, url, method: HttpVerb.POST })

src/order.js

@@ -1,5 +1,5 @@
 import { post } from './helpers/request'
-import { ContentType, HEADERS } from './consts'
+import { ContentType, HEADER } from './consts'
 import { environment } from './env'
 import { required } from './helpers/validation'
 
@@ -16,18 +16,18 @@ export default async ({ accessToken, payment, cart, buyer, products } = {}) => {
     return await post(
       `${environment}/api/v2_1/orders`,
       {
-        notifyUrl: PAYU_CLIENT_NOTIFY_SITE_URL,
-        merchantPosId: PAYU_CLIENT_ID,
-        ...payment,
-        ...cart,
-        ...buyer,
-        ...products
-      },
-      {
+        body: {
+          notifyUrl: PAYU_CLIENT_NOTIFY_SITE_URL,
+          merchantPosId: PAYU_CLIENT_ID,
+          ...payment,
+          ...cart,
+          ...buyer,
+          ...products
+        },
         json: true,
         headers: {
-          [HEADERS.Authorization]: `Bearer ${accessToken}`,
-          [HEADERS.ContentType]: ContentType.JSON
+          [HEADER.Authorization]: `Bearer ${accessToken}`,
+          [HEADER.ContentType]: ContentType.JSON
         }
       }
     )

test/server.js

@@ -21,7 +21,12 @@ export const mockOrder = () =>
       status: {
         statusCode: 'SUCCESS'
       },
-      redirectUri: '{url_do_przekierowania_na_stronę_podsumowania_płatności}',
+      redirectUri: '{redirect_url_after_successfully_payment}',
       orderId: 'WZHF5FFDRJ140731GUEST000P01',
-      extOrderId: '{twój_identyfikator_zamówienia}'
+      extOrderId: '{internal_order_id}'
     })
+
+export const mockFail = (status) =>
+    nock('https://localhost')
+      .get(`/${status}`)
+      .reply(status, 'Internal Server Error 500')

test/unit/authorize.test.js

@@ -1,6 +1,5 @@
-import nock from 'nock'
 import assert from 'assert'
-import { expect } from 'chai'
+import nock from 'nock'
 
 import { mockAuthorize } from '../server'
 import { authorize, GrantType } from '../../src'

test/unit/request.test.js

@@ -0,0 +1,51 @@
+import assert from 'assert'
+import nock from 'nock'
+
+import { post, get } from '../../src/helpers/request'
+import { mockAuthorize, mockFail } from '../server'
+import { Environment } from '../../src/consts'
+
+describe('request', () => {
+    afterEach(() => {
+        nock.cleanAll()
+    })
+
+    it('throw error on nullish arguments', async () => {
+
+        try {
+            await post()
+        } catch (err) {
+            should.throw(() => { throw err }, assert.AssertionError, 'url should not be empty')
+        }
+    })
+
+    it('should response parsed JSON with opt { json: true }', async () => {
+        mockAuthorize()
+
+        const response = await post(`${Environment.SANDBOX}/pl/standard/user/oauth/authorize`, { json: true })
+
+        response.should.have.property('access_token')
+        response.should.have.property('token_type')
+        response.should.have.property('expires_in')
+        response.should.have.property('grant_type')
+    })
+
+    it('should response with plain text without { json: true }', async () => {
+        mockAuthorize()
+
+        const response = await post(`${Environment.SANDBOX}/pl/standard/user/oauth/authorize`)
+
+        response.should.be.a('string')
+    })
+
+    it('should throw error when server respond with not ok status', async () => {
+        mockFail(500)
+
+        try {
+            const response = await get('https://localhost/500')
+        } catch (err) {
+            should.throw(() => { throw err }, Error, 'adddad')
+        }
+
+    })
+})