@pixelpay/sdk-core 1.0.0-beta.0 → 2.0.0-beta.2

package/package.json

@@ -1,23 +1,34 @@
 {
 	"name": "@pixelpay/sdk-core",
-	"version": "1.0.0-beta.0",
+	"version": "2.0.0-beta.2",
 	"description": "PixelPay SDK toolkit",
 	"main": "lib/index.js",
-	"browser": "lib/index.js",
+	"browser": "lib/browser/index.js",
 	"types": "lib/index.d.ts",
 	"devDependencies": {
+		"@babel/core": "^7.16.0",
+		"@babel/preset-env": "^7.16.4",
+		"@babel/preset-typescript": "^7.16.0",
+		"@types/jest": "^27.0.3",
+		"babel-jest": "^27.3.1",
+		"browser-sync": "^2.27.7",
+		"browserify": "^17.0.0",
+		"jest": "^27.3.1",
+		"laravel-mix": "^6.0.39",
 		"shx": "^0.3.3",
-		"typescript": "^4.3.5"
+		"ts-loader": "^9.2.6",
+		"typescript": "^4.5.2"
 	},
 	"scripts": {
 		"clean": "shx rm -rf _bundles lib lib-esm dist",
-		"build": "npm run clean && node version.js && tsc",
+		"build": "npm run clean && node version.js && tsc && npx mix --production",
+		"dev": "browser-sync start --server --files 'lib/*.*'",
 		"prepublishOnly": "npm run build"
 	},
 	"author": "Ivan Suazo <ivan@pixel.hn>",
 	"license": "MTI",
 	"dependencies": {
-		"axios": "^0.21.2",
+		"axios": "^0.21.4",
 		"crypto-js": "^4.1.1"
 	}
 }

package/tests/Locations.test.ts

@@ -0,0 +1,9 @@
+import Locations from "../src/resources/Locations";
+
+test('Location countires', () => {
+	expect(Locations.countriesList()["HN"]).toBe("Honduras")
+});
+
+test('Location states', () => {
+	expect(Locations.statesList("HN")["HN-CR"]).toBe("Cortes") 
+});

package/tests/Models/Card.test.ts

@@ -0,0 +1,33 @@
+import Card from '../../src/models/Card';
+
+test('Card shoul be empty', () => {
+    let card: Card = new Card();
+
+    expect(card.cardholder).toBe(undefined)
+    expect(card.cvv2).toBe(undefined)
+    expect(card.expire_month).toBe(undefined)
+    expect(card.expire_year).toBe(undefined)
+    expect(card.number).toBe(undefined)
+})
+
+test('Setup card model successful', () => {
+    let card: Card = new Card();
+    let name = "Jhon Doe"
+    let cvv = "009";
+    let month = 12;
+    let year = 2025;
+    let number = "4111 1111 1111 1111";
+
+    card.cardholder = name;
+    card.cvv2 = cvv;
+    card.expire_month = month;
+    card.expire_year = year;
+    card.number = number;
+
+    expect(card.cardholder).toEqual(name)
+    expect(card.cvv2).toBe(cvv)
+    expect(card.expire_month).toBe(month)
+    expect(card.expire_year).toBe(year)
+    expect(card.number).toBe(number)
+    expect(card.getExpireFormat()).toEqual("2512");
+})

package/tests/Models/Order.test.ts

@@ -0,0 +1,64 @@
+import Item from '../../src/models/Item';
+import Order from '../../src/models/Order'
+
+test('Order shoul be empty', () => {
+    let order: Order = new Order();
+
+    expect(order.id).toBe(undefined)
+    expect(order.currency).toBe(undefined)
+    expect(order.amount).toBe(undefined)
+    expect(order.tax_amount).toBe(undefined)
+    expect(order.shipping_amount).toBe(undefined)
+    expect(order.content).toStrictEqual([])
+    expect(order.extras).toStrictEqual({})
+    expect(order.note).toBe(undefined)
+    expect(order.callback_url).toBe(undefined)
+    expect(order.customer_name).toBe(undefined)
+    expect(order.customer_email).toBe(undefined)
+})
+
+test('Order with empty item', () => {
+    let order: Order = new Order();
+    let item = new Item();
+
+    order.amount = 10.00;
+    order.addItem(item);
+
+    order.totalize();
+    expect(order.amount).toEqual(0.00)
+})
+
+test('Order with items', () => {
+    let order: Order = new Order();
+    let item = new Item();
+    const price = 12.00;
+    const qty = 10;
+    const tax = 3;
+
+    order.amount = 10.00;
+    
+    item.code = 'x10';
+    item.price = price;
+    item.qty = qty;
+    item.tax = tax;
+    item.title = "Test item";
+    item.total = 10;
+    item.totalize();
+    expect(item.total).toEqual(price * qty);
+
+    order.addItem(item);
+    order.totalize();
+    expect(order.amount).toEqual(price * qty);
+    expect(order.tax_amount).toEqual(tax * qty);
+})
+
+test('Add extra info to order', () => {
+    let order: Order = new Order();
+    order.addExtra('user_id', 1);
+    order.addExtra('user_name', "Jhon");
+    order.addExtra('user_last_name', "Doe");
+
+    expect(order.extras.hasOwnProperty("user_id")).toBe(true);
+    expect(order.extras.hasOwnProperty("user_name")).toBe(true);
+    expect(order.extras.hasOwnProperty("user_last_name")).toBe(true);
+})

package/tests/Models/Settings.test.ts

@@ -0,0 +1,65 @@
+import Settings from '../../src/models/Settings';
+
+
+test("Default settings", () => {
+    let settings: Settings = new Settings();
+    expect(settings.endpoint).toEqual("https://pixelpay.app");
+    expect(settings.auth_key).toEqual(undefined)
+    expect(settings.auth_hash).toEqual(undefined)
+    expect(settings.auth_user).toEqual(undefined)
+    expect(settings.environment).toEqual(undefined)
+    expect(settings.lang).toEqual(undefined)
+})
+
+test('Setup endpoint', () => {
+    let settings: Settings = new Settings();
+    let staging = 'https://pixel-pay.com';
+    expect(settings.endpoint).toEqual("https://pixelpay.app");
+    settings.setupEndpoint(staging);
+    expect(settings.endpoint).toEqual(staging);
+})
+
+test('Setup credentials', () => {
+    let settings: Settings = new Settings();
+    let hash = "12345678945612345678912345679";
+    let key = "1234567890";
+    settings.setupCredentials(key, hash);
+    expect(settings.auth_key).toEqual(key);
+    expect(settings.auth_hash).toEqual(hash);
+})
+
+test('Setup platform user', () => {
+    let settings: Settings = new Settings();
+    let user = '123457890';
+    settings.setupPlatformUser(user);
+    expect(settings.auth_user).toEqual(user);
+})
+
+test('Setup enviroment', () => {
+    let settings: Settings = new Settings();
+    let sandbox = "sandbox";
+    settings.environment = sandbox;
+    expect(settings.environment).toEqual(sandbox);
+})
+
+test('Setup setupSandbox', () => {
+    let settings: Settings = new Settings();
+    let staging = 'https://pixel-pay.com';
+    let hash = "36cdf8271723276cb6f94904f8bde4b6";
+    let key = "1234567890";
+    let sandbox = "sandbox";
+
+    settings.setupSandbox();
+    expect(settings.endpoint).toEqual(staging);
+    expect(settings.auth_key).toEqual(key);
+    expect(settings.auth_hash).toEqual(hash);
+    expect(settings.environment).toEqual(sandbox);
+
+})
+
+test('Setup language', () => {
+    let settings: Settings = new Settings();
+    let lang = 'es';
+    settings.setupLanguage(lang);
+    expect(settings.lang).toEqual(lang);
+})

package/tests/Tokenization.test.ts

@@ -0,0 +1,229 @@
+import Billing from "../src/models/Billing";
+import Card from "../src/models/Card";
+import Settings from "../src/models/Settings";
+import CardTokenization from "../src/requests/CardTokenization";
+import ErrorResponse from "../src/responses/ErrorResponse";
+import InputErrorResponse from "../src/responses/InputErrorResponse";
+import SuccessResponse from "../src/responses/SuccessResponse";
+import Tokenization from "../src/services/Tokenization";
+
+const TIMEOUT = 8000;
+
+function getCard(card_number: string = "4111 1111 1111 1111"): Card {
+    var card = new Card();
+    card.number = card_number;
+    card.cardholder = "Test Card";
+    card.expire_month = 12;
+    card.expire_year = 2024;
+    card.cvv2 = "999";
+
+    return card;
+}
+
+function getBilling(): Billing {
+    var billing = new Billing();
+    billing.address = 'Ave Circunvalacion';
+    billing.country = 'HN';
+    billing.state = 'HN-CR';
+    billing.city = 'San Pedro Sula';
+    billing.phone = '99999999';
+
+    return billing;
+}
+
+it('Fail vault card by missing card inputs', () => {
+    expect.assertions(8)
+    let settings = new Settings();
+    settings.setupSandbox();
+
+    let service: Tokenization = new Tokenization(settings);
+    let cardTokenization: CardTokenization = new CardTokenization();
+    cardTokenization.setBilling(getBilling());
+
+    return service.vaultCard(cardTokenization).then( response => {
+        expect(response).toBeInstanceOf(InputErrorResponse);
+        expect(false).toBe(response.success);
+        expect(422).toBe(response.status);
+        expect(true).toBe(response.inputHasError('cvv2'))
+        expect(true).toBe(response.inputHasError('expire_month'))
+        expect(true).toBe(response.inputHasError('expire_year'))
+        expect(true).toBe(response.inputHasError('cardholder'))
+        expect(true).toBe(response.inputHasError('number'))
+    })
+}, TIMEOUT)
+
+it('Fail vault card by missing billing inputs', () => {
+    expect.assertions(8)
+    let settings = new Settings();
+    settings.setupSandbox();
+
+    let service: Tokenization = new Tokenization(settings);
+    let cardTokenization: CardTokenization = new CardTokenization();
+    cardTokenization.setCard(getCard());
+
+    return service.vaultCard(cardTokenization).then( response => {
+        expect(response).toBeInstanceOf(InputErrorResponse);
+        expect(false).toBe(response.success);
+        expect(422).toBe(response.status);
+        expect(true).toBe(response.inputHasError('address'))
+        expect(true).toBe(response.inputHasError('city'))
+        expect(true).toBe(response.inputHasError('country'))
+        expect(true).toBe(response.inputHasError('phone'))
+        expect(true).toBe(response.inputHasError('state'))
+    })
+}, TIMEOUT)
+
+it('Fail vault card due invalid card', () => {
+    expect.assertions(3)
+    let settings = new Settings();
+    settings.setupSandbox();
+
+    let service: Tokenization = new Tokenization(settings);
+    let cardTokenization: CardTokenization = new CardTokenization();
+    cardTokenization.setCard(getCard('3111 2545 6985 4589'));
+    cardTokenization.setBilling(getBilling());
+
+    return service.vaultCard(cardTokenization).then( response => {
+        expect(response).toBeInstanceOf(InputErrorResponse);
+        expect(response.status).toBe(422);
+        expect(response.message).toBe("El campo number es un número de tarjeta incorrecto.");
+    })
+}, TIMEOUT)
+
+it('Succes vault card', () => {
+    expect.assertions(5)
+    let settings = new Settings();
+    settings.setupSandbox();
+
+    let service: Tokenization = new Tokenization(settings);
+    let cardTokenization: CardTokenization = new CardTokenization();
+    cardTokenization.setCard(getCard());
+    cardTokenization.setBilling(getBilling());
+
+    return service.vaultCard(cardTokenization).then( response => {
+        expect(response).toBeInstanceOf(SuccessResponse);
+        expect(response.success).toBe(true);
+        expect(response.status).toBe(200)
+        expect(response.getData("mask")).toBe("411111******1111")
+        let token: String = response.getData('token');
+        expect(token.substring(0,2)).toBe("T-")
+    })
+}, TIMEOUT)
+
+it('Fail show card info',  () => {
+    expect.assertions(4)
+    let settings = new Settings();
+    settings.setupSandbox();
+
+    let service: Tokenization = new Tokenization(settings);
+    let cardTokenization: CardTokenization = new CardTokenization();
+    cardTokenization.setCard(getCard());
+    cardTokenization.setBilling(getBilling());
+
+    return service.showCard("T-1234-1234456").then( response => {
+        expect(response).toBeInstanceOf(ErrorResponse);
+        expect(response.status).toBe(400)
+        expect(response.success).toBe(false);
+        expect(response.message).toBe("El token no es valido o tiene un formato invalid");
+    });
+}, TIMEOUT)
+
+it('Succes show card info', async () => {
+    expect.assertions(4)
+    let settings = new Settings();
+    settings.setupSandbox();
+
+    let service: Tokenization = new Tokenization(settings);
+    let cardTokenization: CardTokenization = new CardTokenization();
+    cardTokenization.setCard(getCard());
+    cardTokenization.setBilling(getBilling());
+
+    let response: SuccessResponse = await service.vaultCard(cardTokenization)
+    let token = response.getData('token');
+
+    return service.showCard(token).then( response => {
+        expect(response).toBeInstanceOf(SuccessResponse);
+        expect(response.success).toBe(true);
+        expect(response.status).toBe(200)
+        expect(response.getData("mask")).toBe("411111******1111")
+    });
+}, TIMEOUT)
+
+it('Fail update card', () => {
+    expect.assertions(4)
+    let settings = new Settings();
+    settings.setupSandbox();
+
+    let service: Tokenization = new Tokenization(settings);
+    let cardTokenization: CardTokenization = new CardTokenization();
+    cardTokenization.setCard(getCard());
+    cardTokenization.setBilling(getBilling());
+
+    return service.updateCard('T-1234-123456-1234-123456', cardTokenization).then( response => {
+        expect(response).toBeInstanceOf(ErrorResponse);
+        expect(response.success).toBe(false);
+        expect(response.status).toBe(400)
+        expect(response.message).toBe("El token no es valido o tiene un formato invalid");
+    });
+}, TIMEOUT)
+
+it('Succes update card', async () => {
+    expect.assertions(4)
+    let settings = new Settings();
+    settings.setupSandbox();
+
+    let service: Tokenization = new Tokenization(settings);
+    let cardTokenization: CardTokenization = new CardTokenization();
+    cardTokenization.setCard(getCard());
+    cardTokenization.setBilling(getBilling());
+
+    let response: SuccessResponse = await service.vaultCard(cardTokenization)
+    let token = response.getData('token');
+
+    cardTokenization.setCard(getCard('5416454316599121'));
+    return service.updateCard(token, cardTokenization).then( response => {
+        expect(response).toBeInstanceOf(SuccessResponse);
+        expect(response.success).toBe(true);
+        expect(response.status).toBe(200)
+        expect(response.getData("mask")).toBe("541645******9121");
+    });
+}, TIMEOUT)
+
+it('Fail delete card', () => {
+    expect.assertions(4)
+    let settings = new Settings();
+    settings.setupSandbox();
+
+    let service: Tokenization = new Tokenization(settings);
+    let cardTokenization: CardTokenization = new CardTokenization();
+    cardTokenization.setCard(getCard());
+    cardTokenization.setBilling(getBilling());
+
+    return service.deleteCard("T-1234-123456-1234-123456").then( response => {
+        expect(response).toBeInstanceOf(ErrorResponse);
+        expect(response.success).toBe(false);
+        expect(response.status).toBe(400)
+        expect(response.message).toBe("El token no es valido o tiene un formato invalid");
+    });
+}, TIMEOUT)
+
+it('Succes delete card', async () => {
+    expect.assertions(4)
+    let settings = new Settings();
+    settings.setupSandbox();
+
+    let service: Tokenization = new Tokenization(settings);
+    let cardTokenization: CardTokenization = new CardTokenization();
+    cardTokenization.setCard(getCard());
+    cardTokenization.setBilling(getBilling());
+
+    let response: SuccessResponse = await service.vaultCard(cardTokenization)
+    let token = response.getData('token');
+
+    return service.deleteCard(token).then( response => {
+        expect(response).toBeInstanceOf(SuccessResponse);
+        expect(response.status).toBe(200)
+        expect(response.getData('deleted')).toBe(true);
+        expect(response.message).toBe("Información obtenida con exito");
+    });
+}, TIMEOUT)