mirror of
https://github.com/bitwarden/browser.git
synced 2024-12-04 13:44:00 +01:00
378 lines
15 KiB
TypeScript
378 lines
15 KiB
TypeScript
import { CipherType } from "@bitwarden/common/vault/enums";
|
|
|
|
import { DashlaneCsvImporter } from "../src/importers";
|
|
|
|
import { credentialsData_otpUrl } from "./test-data/dashlane-csv/credentials-otpurl.csv";
|
|
import { credentialsData } from "./test-data/dashlane-csv/credentials.csv";
|
|
import { identityData } from "./test-data/dashlane-csv/id.csv";
|
|
import { multiplePersonalInfoData } from "./test-data/dashlane-csv/multiple-personal-info.csv";
|
|
import { paymentsData } from "./test-data/dashlane-csv/payments.csv";
|
|
import { personalInfoData } from "./test-data/dashlane-csv/personal-info.csv";
|
|
import { secureNoteData } from "./test-data/dashlane-csv/securenotes.csv";
|
|
|
|
describe("Dashlane CSV Importer", () => {
|
|
let importer: DashlaneCsvImporter;
|
|
beforeEach(() => {
|
|
importer = new DashlaneCsvImporter();
|
|
});
|
|
|
|
it("should parse login records", async () => {
|
|
const result = await importer.parse(credentialsData);
|
|
expect(result != null).toBe(true);
|
|
|
|
const cipher = result.ciphers.shift();
|
|
expect(cipher.name).toEqual("example.com");
|
|
expect(cipher.login.username).toEqual("jdoe");
|
|
expect(cipher.login.password).toEqual("somePassword");
|
|
expect(cipher.login.totp).toEqual("someTOTPSeed");
|
|
expect(cipher.login.uris.length).toEqual(1);
|
|
const uriView = cipher.login.uris.shift();
|
|
expect(uriView.uri).toEqual("https://www.example.com");
|
|
expect(cipher.notes).toEqual("some note for example.com");
|
|
});
|
|
|
|
it("should parse login with totp when given otpUrl instead of otpSecret", async () => {
|
|
const result = await importer.parse(credentialsData_otpUrl);
|
|
expect(result != null).toBe(true);
|
|
|
|
const cipher = result.ciphers.shift();
|
|
expect(cipher.login.totp).toEqual("anotherTOTPSeed");
|
|
});
|
|
|
|
it("should parse an item and create a folder", async () => {
|
|
const result = await importer.parse(credentialsData);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result.success).toBe(true);
|
|
expect(result.folders.length).toBe(1);
|
|
expect(result.folders[0].name).toBe("Entertainment");
|
|
expect(result.folderRelationships[0]).toEqual([0, 0]);
|
|
});
|
|
|
|
it("should parse payment records", async () => {
|
|
const result = await importer.parse(paymentsData);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result.success).toBe(true);
|
|
expect(result.ciphers.length).toBe(2);
|
|
|
|
// Account
|
|
const cipher = result.ciphers.shift();
|
|
expect(cipher.type).toBe(CipherType.Card);
|
|
expect(cipher.name).toBe("John's savings account");
|
|
expect(cipher.card.brand).toBeNull();
|
|
expect(cipher.card.cardholderName).toBe("John Doe");
|
|
expect(cipher.card.number).toBe("accountNumber");
|
|
expect(cipher.card.code).toBeNull();
|
|
expect(cipher.card.expMonth).toBeNull();
|
|
expect(cipher.card.expYear).toBeNull();
|
|
|
|
expect(cipher.fields.length).toBe(4);
|
|
|
|
expect(cipher.fields[0].name).toBe("type");
|
|
expect(cipher.fields[0].value).toBe("bank");
|
|
|
|
expect(cipher.fields[1].name).toBe("routing_number");
|
|
expect(cipher.fields[1].value).toBe("routingNumber");
|
|
|
|
expect(cipher.fields[2].name).toBe("country");
|
|
expect(cipher.fields[2].value).toBe("US");
|
|
|
|
expect(cipher.fields[3].name).toBe("issuing_bank");
|
|
expect(cipher.fields[3].value).toBe("US-ALLY");
|
|
|
|
// CreditCard
|
|
const cipher2 = result.ciphers.shift();
|
|
expect(cipher2.type).toBe(CipherType.Card);
|
|
expect(cipher2.name).toBe("John Doe");
|
|
expect(cipher2.card.brand).toBe("Visa");
|
|
expect(cipher2.card.cardholderName).toBe("John Doe");
|
|
expect(cipher2.card.number).toBe("41111111111111111");
|
|
expect(cipher2.card.code).toBe("123");
|
|
expect(cipher2.card.expMonth).toBe("1");
|
|
expect(cipher2.card.expYear).toBe("2023");
|
|
|
|
expect(cipher2.fields.length).toBe(2);
|
|
|
|
expect(cipher2.fields[0].name).toBe("type");
|
|
expect(cipher2.fields[0].value).toBe("credit_card");
|
|
|
|
expect(cipher2.fields[1].name).toBe("country");
|
|
expect(cipher2.fields[1].value).toBe("US");
|
|
});
|
|
|
|
it("should parse ids records", async () => {
|
|
const result = await importer.parse(identityData);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result.success).toBe(true);
|
|
|
|
// Type card
|
|
const cipher = result.ciphers.shift();
|
|
expect(cipher.type).toBe(CipherType.Identity);
|
|
expect(cipher.name).toBe("John Doe card");
|
|
expect(cipher.identity.fullName).toBe("John Doe");
|
|
expect(cipher.identity.firstName).toBe("John");
|
|
expect(cipher.identity.middleName).toBeNull();
|
|
expect(cipher.identity.lastName).toBe("Doe");
|
|
expect(cipher.identity.licenseNumber).toBe("123123123");
|
|
|
|
expect(cipher.fields.length).toBe(3);
|
|
|
|
expect(cipher.fields[0].name).toEqual("type");
|
|
expect(cipher.fields[0].value).toEqual("card");
|
|
|
|
expect(cipher.fields[1].name).toEqual("issue_date");
|
|
expect(cipher.fields[1].value).toEqual("2022-1-30");
|
|
|
|
expect(cipher.fields[2].name).toEqual("expiration_date");
|
|
expect(cipher.fields[2].value).toEqual("2032-1-30");
|
|
|
|
// Type passport
|
|
const cipher2 = result.ciphers.shift();
|
|
expect(cipher2.type).toBe(CipherType.Identity);
|
|
expect(cipher2.name).toBe("John Doe passport");
|
|
expect(cipher2.identity.fullName).toBe("John Doe");
|
|
expect(cipher2.identity.firstName).toBe("John");
|
|
expect(cipher2.identity.middleName).toBeNull();
|
|
expect(cipher2.identity.lastName).toBe("Doe");
|
|
expect(cipher2.identity.passportNumber).toBe("123123123");
|
|
|
|
expect(cipher2.fields.length).toBe(4);
|
|
|
|
expect(cipher2.fields[0].name).toEqual("type");
|
|
expect(cipher2.fields[0].value).toEqual("passport");
|
|
expect(cipher2.fields[1].name).toEqual("issue_date");
|
|
expect(cipher2.fields[1].value).toEqual("2022-1-30");
|
|
expect(cipher2.fields[2].name).toEqual("expiration_date");
|
|
expect(cipher2.fields[2].value).toEqual("2032-1-30");
|
|
expect(cipher2.fields[3].name).toEqual("place_of_issue");
|
|
expect(cipher2.fields[3].value).toEqual("somewhere in Germany");
|
|
|
|
// Type license
|
|
const cipher3 = result.ciphers.shift();
|
|
expect(cipher3.type).toBe(CipherType.Identity);
|
|
expect(cipher3.name).toBe("John Doe license");
|
|
expect(cipher3.identity.fullName).toBe("John Doe");
|
|
expect(cipher3.identity.firstName).toBe("John");
|
|
expect(cipher3.identity.middleName).toBeNull();
|
|
expect(cipher3.identity.lastName).toBe("Doe");
|
|
expect(cipher3.identity.licenseNumber).toBe("1234556");
|
|
expect(cipher3.identity.state).toBe("DC");
|
|
|
|
expect(cipher3.fields.length).toBe(3);
|
|
expect(cipher3.fields[0].name).toEqual("type");
|
|
expect(cipher3.fields[0].value).toEqual("license");
|
|
expect(cipher3.fields[1].name).toEqual("issue_date");
|
|
expect(cipher3.fields[1].value).toEqual("2022-8-10");
|
|
expect(cipher3.fields[2].name).toEqual("expiration_date");
|
|
expect(cipher3.fields[2].value).toEqual("2022-10-10");
|
|
|
|
// Type social_security
|
|
const cipher4 = result.ciphers.shift();
|
|
expect(cipher4.type).toBe(CipherType.Identity);
|
|
expect(cipher4.name).toBe("John Doe social_security");
|
|
expect(cipher4.identity.fullName).toBe("John Doe");
|
|
expect(cipher4.identity.firstName).toBe("John");
|
|
expect(cipher4.identity.middleName).toBeNull();
|
|
expect(cipher4.identity.lastName).toBe("Doe");
|
|
expect(cipher4.identity.ssn).toBe("123123123");
|
|
|
|
expect(cipher4.fields.length).toBe(1);
|
|
expect(cipher4.fields[0].name).toEqual("type");
|
|
expect(cipher4.fields[0].value).toEqual("social_security");
|
|
|
|
// Type tax_number
|
|
const cipher5 = result.ciphers.shift();
|
|
expect(cipher5.type).toBe(CipherType.Identity);
|
|
expect(cipher5.name).toBe("tax_number");
|
|
expect(cipher5.identity.licenseNumber).toBe("123123123");
|
|
|
|
expect(cipher5.fields.length).toBe(1);
|
|
expect(cipher5.fields[0].name).toEqual("type");
|
|
expect(cipher5.fields[0].value).toEqual("tax_number");
|
|
});
|
|
|
|
it("should parse secureNote records", async () => {
|
|
const result = await importer.parse(secureNoteData);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result.success).toBe(true);
|
|
expect(result.ciphers.length).toBe(1);
|
|
|
|
const cipher = result.ciphers.shift();
|
|
expect(cipher.type).toBe(CipherType.SecureNote);
|
|
expect(cipher.name).toBe("01");
|
|
expect(cipher.notes).toBe("test");
|
|
});
|
|
|
|
it("should parse personal information records (multiple identities)", async () => {
|
|
const result = await importer.parse(multiplePersonalInfoData);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result.success).toBe(true);
|
|
expect(result.ciphers.length).toBe(6);
|
|
|
|
// name
|
|
const cipher = result.ciphers.shift();
|
|
expect(cipher.type).toBe(CipherType.SecureNote);
|
|
expect(cipher.name).toBe("MR John Doe");
|
|
|
|
expect(cipher.fields.length).toBe(7);
|
|
expect(cipher.fields[0].name).toEqual("type");
|
|
expect(cipher.fields[0].value).toEqual("name");
|
|
expect(cipher.fields[1].name).toEqual("title");
|
|
expect(cipher.fields[1].value).toEqual("MR");
|
|
expect(cipher.fields[2].name).toEqual("first_name");
|
|
expect(cipher.fields[2].value).toEqual("John");
|
|
expect(cipher.fields[3].name).toEqual("last_name");
|
|
expect(cipher.fields[3].value).toEqual("Doe");
|
|
expect(cipher.fields[4].name).toEqual("login");
|
|
expect(cipher.fields[4].value).toEqual("jdoe");
|
|
expect(cipher.fields[5].name).toEqual("date_of_birth");
|
|
expect(cipher.fields[5].value).toEqual("2022-01-30");
|
|
expect(cipher.fields[6].name).toEqual("place_of_birth");
|
|
expect(cipher.fields[6].value).toEqual("world");
|
|
|
|
// email
|
|
const cipher2 = result.ciphers.shift();
|
|
expect(cipher2.type).toBe(CipherType.SecureNote);
|
|
expect(cipher2.name).toBe("Johns email");
|
|
|
|
expect(cipher2.fields.length).toBe(4);
|
|
expect(cipher2.fields[0].name).toEqual("type");
|
|
expect(cipher2.fields[0].value).toEqual("email");
|
|
expect(cipher2.fields[1].name).toEqual("email");
|
|
expect(cipher2.fields[1].value).toEqual("jdoe@example.com");
|
|
expect(cipher2.fields[2].name).toEqual("email_type");
|
|
expect(cipher2.fields[2].value).toEqual("personal");
|
|
expect(cipher2.fields[3].name).toEqual("item_name");
|
|
expect(cipher2.fields[3].value).toEqual("Johns email");
|
|
|
|
// number
|
|
const cipher3 = result.ciphers.shift();
|
|
expect(cipher3.type).toBe(CipherType.SecureNote);
|
|
expect(cipher3.name).toBe("John's number");
|
|
|
|
expect(cipher3.fields.length).toBe(3);
|
|
expect(cipher3.fields[0].name).toEqual("type");
|
|
expect(cipher3.fields[0].value).toEqual("number");
|
|
expect(cipher3.fields[1].name).toEqual("item_name");
|
|
expect(cipher3.fields[1].value).toEqual("John's number");
|
|
expect(cipher3.fields[2].name).toEqual("phone_number");
|
|
expect(cipher3.fields[2].value).toEqual("+49123123123");
|
|
|
|
// address
|
|
const cipher4 = result.ciphers.shift();
|
|
expect(cipher4.type).toBe(CipherType.SecureNote);
|
|
expect(cipher4.name).toBe("John's home address");
|
|
|
|
expect(cipher4.fields.length).toBe(12);
|
|
expect(cipher4.fields[0].name).toEqual("type");
|
|
expect(cipher4.fields[0].value).toEqual("address");
|
|
expect(cipher4.fields[1].name).toEqual("item_name");
|
|
expect(cipher4.fields[1].value).toEqual("John's home address");
|
|
expect(cipher4.fields[2].name).toEqual("address");
|
|
expect(cipher4.fields[2].value).toEqual("1 some street");
|
|
expect(cipher4.fields[3].name).toEqual("country");
|
|
expect(cipher4.fields[3].value).toEqual("de");
|
|
expect(cipher4.fields[4].name).toEqual("state");
|
|
expect(cipher4.fields[4].value).toEqual("DE-0-NW");
|
|
expect(cipher4.fields[5].name).toEqual("city");
|
|
expect(cipher4.fields[5].value).toEqual("some city");
|
|
expect(cipher4.fields[6].name).toEqual("zip");
|
|
expect(cipher4.fields[6].value).toEqual("123123");
|
|
expect(cipher4.fields[7].name).toEqual("address_recipient");
|
|
expect(cipher4.fields[7].value).toEqual("John");
|
|
expect(cipher4.fields[8].name).toEqual("address_building");
|
|
expect(cipher4.fields[8].value).toEqual("1");
|
|
expect(cipher4.fields[9].name).toEqual("address_apartment");
|
|
expect(cipher4.fields[9].value).toEqual("1");
|
|
expect(cipher4.fields[10].name).toEqual("address_floor");
|
|
expect(cipher4.fields[10].value).toEqual("1");
|
|
expect(cipher4.fields[11].name).toEqual("address_door_code");
|
|
expect(cipher4.fields[11].value).toEqual("123");
|
|
|
|
// website
|
|
const cipher5 = result.ciphers.shift();
|
|
expect(cipher5.type).toBe(CipherType.SecureNote);
|
|
expect(cipher5.name).toBe("Website");
|
|
|
|
expect(cipher5.fields.length).toBe(3);
|
|
expect(cipher5.fields[0].name).toEqual("type");
|
|
expect(cipher5.fields[0].value).toEqual("website");
|
|
expect(cipher5.fields[1].name).toEqual("item_name");
|
|
expect(cipher5.fields[1].value).toEqual("Website");
|
|
expect(cipher5.fields[2].name).toEqual("url");
|
|
expect(cipher5.fields[2].value).toEqual("website.com");
|
|
|
|
// 2nd name/identity
|
|
const cipher6 = result.ciphers.shift();
|
|
expect(cipher6.type).toBe(CipherType.SecureNote);
|
|
expect(cipher6.name).toBe("Mrs Jane Doe");
|
|
|
|
expect(cipher6.fields.length).toBe(7);
|
|
expect(cipher6.fields[0].name).toEqual("type");
|
|
expect(cipher6.fields[0].value).toEqual("name");
|
|
expect(cipher6.fields[1].name).toEqual("title");
|
|
expect(cipher6.fields[1].value).toEqual("Mrs");
|
|
expect(cipher6.fields[2].name).toEqual("first_name");
|
|
expect(cipher6.fields[2].value).toEqual("Jane");
|
|
expect(cipher6.fields[3].name).toEqual("last_name");
|
|
expect(cipher6.fields[3].value).toEqual("Doe");
|
|
expect(cipher6.fields[4].name).toEqual("login");
|
|
expect(cipher6.fields[4].value).toEqual("jdoe");
|
|
expect(cipher6.fields[5].name).toEqual("date_of_birth");
|
|
expect(cipher6.fields[5].value).toEqual("2022-01-30");
|
|
expect(cipher6.fields[6].name).toEqual("place_of_birth");
|
|
expect(cipher6.fields[6].value).toEqual("earth");
|
|
});
|
|
|
|
it("should combine personal information records to one identity if only one identity present", async () => {
|
|
const result = await importer.parse(personalInfoData);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result.success).toBe(true);
|
|
|
|
const cipher = result.ciphers.shift();
|
|
expect(cipher.type).toBe(CipherType.Identity);
|
|
expect(cipher.name).toBe("MR John Doe");
|
|
expect(cipher.identity.fullName).toBe("MR John Doe");
|
|
expect(cipher.identity.title).toBe("MR");
|
|
expect(cipher.identity.firstName).toBe("John");
|
|
expect(cipher.identity.middleName).toBeNull();
|
|
expect(cipher.identity.lastName).toBe("Doe");
|
|
expect(cipher.identity.username).toBe("jdoe");
|
|
expect(cipher.identity.email).toBe("jdoe@example.com");
|
|
expect(cipher.identity.phone).toBe("+49123123123");
|
|
|
|
expect(cipher.fields.length).toBe(9);
|
|
expect(cipher.fields[0].name).toBe("date_of_birth");
|
|
expect(cipher.fields[0].value).toBe("2022-01-30");
|
|
|
|
expect(cipher.fields[1].name).toBe("place_of_birth");
|
|
expect(cipher.fields[1].value).toBe("world");
|
|
|
|
expect(cipher.fields[2].name).toBe("email_type");
|
|
expect(cipher.fields[2].value).toBe("personal");
|
|
|
|
expect(cipher.fields[3].name).toBe("address_recipient");
|
|
expect(cipher.fields[3].value).toBe("John");
|
|
|
|
expect(cipher.fields[4].name).toBe("address_building");
|
|
expect(cipher.fields[4].value).toBe("1");
|
|
|
|
expect(cipher.fields[5].name).toBe("address_apartment");
|
|
expect(cipher.fields[5].value).toBe("1");
|
|
|
|
expect(cipher.fields[6].name).toBe("address_floor");
|
|
expect(cipher.fields[6].value).toBe("1");
|
|
|
|
expect(cipher.fields[7].name).toBe("address_door_code");
|
|
expect(cipher.fields[7].value).toBe("123");
|
|
|
|
expect(cipher.fields[8].name).toBe("url");
|
|
expect(cipher.fields[8].value).toBe("website.com");
|
|
});
|
|
});
|