ARCHIVE/xahau.js
1
0
Fork 0
mirror of https://github.com/Xahau/xahau.js.git synced 2025-11-21 04:35:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

run prettier on all packages

Browse Source
This commit is contained in:
Greg Weisbrod
2021-11-12 02:41:28 -05:00
parent 3b523d7e37
commit afd6aadaf1
51 changed files with 2086 additions and 2062 deletions
Download Patch File Download Diff File Expand all files Collapse all files

328
packages/ripple-binary-codec/test/binary-serializer.test.js
View File

@@ -1,260 +1,258 @@
const { binary } = require("../dist/coretypes");
const { encode, decode } = require("../dist");
const { makeParser, BytesList, BinarySerializer } = binary;
const { coreTypes } = require("../dist/types");
const { UInt8, UInt16, UInt32, UInt64, STObject } = coreTypes;
const bigInt = require("big-integer");
const { Buffer } = require("buffer/");
const { binary } = require('../dist/coretypes')
const { encode, decode } = require('../dist')
const { makeParser, BytesList, BinarySerializer } = binary
const { coreTypes } = require('../dist/types')
const { UInt8, UInt16, UInt32, UInt64, STObject } = coreTypes
const bigInt = require('big-integer')
const { Buffer } = require('buffer/')
const { loadFixture } = require("./utils");
const fixtures = loadFixture("data-driven-tests.json");
const deliverMinTx = require("./fixtures/delivermin-tx.json");
const deliverMinTxBinary = require("./fixtures/delivermin-tx-binary.json");
const { loadFixture } = require('./utils')
const fixtures = loadFixture('data-driven-tests.json')
const deliverMinTx = require('./fixtures/delivermin-tx.json')
const deliverMinTxBinary = require('./fixtures/delivermin-tx-binary.json')
const SignerListSet = {
tx: require("./fixtures/signerlistset-tx.json"),
binary: require("./fixtures/signerlistset-tx-binary.json"),
meta: require("./fixtures/signerlistset-tx-meta-binary.json"),
};
tx: require('./fixtures/signerlistset-tx.json'),
binary: require('./fixtures/signerlistset-tx-binary.json'),
meta: require('./fixtures/signerlistset-tx-meta-binary.json'),
}
const DepositPreauth = {
tx: require("./fixtures/deposit-preauth-tx.json"),
binary: require("./fixtures/deposit-preauth-tx-binary.json"),
meta: require("./fixtures/deposit-preauth-tx-meta-binary.json"),
};
tx: require('./fixtures/deposit-preauth-tx.json'),
binary: require('./fixtures/deposit-preauth-tx-binary.json'),
meta: require('./fixtures/deposit-preauth-tx-meta-binary.json'),
}
const Escrow = {
create: {
tx: require("./fixtures/escrow-create-tx.json"),
binary: require("./fixtures/escrow-create-binary.json"),
tx: require('./fixtures/escrow-create-tx.json'),
binary: require('./fixtures/escrow-create-binary.json'),
},
finish: {
tx: require("./fixtures/escrow-finish-tx.json"),
binary: require("./fixtures/escrow-finish-binary.json"),
meta: require("./fixtures/escrow-finish-meta-binary.json"),
tx: require('./fixtures/escrow-finish-tx.json'),
binary: require('./fixtures/escrow-finish-binary.json'),
meta: require('./fixtures/escrow-finish-meta-binary.json'),
},
cancel: {
tx: require("./fixtures/escrow-cancel-tx.json"),
binary: require("./fixtures/escrow-cancel-binary.json"),
tx: require('./fixtures/escrow-cancel-tx.json'),
binary: require('./fixtures/escrow-cancel-binary.json'),
},
};
}
const PaymentChannel = {
create: {
tx: require("./fixtures/payment-channel-create-tx.json"),
binary: require("./fixtures/payment-channel-create-binary.json"),
tx: require('./fixtures/payment-channel-create-tx.json'),
binary: require('./fixtures/payment-channel-create-binary.json'),
},
fund: {
tx: require("./fixtures/payment-channel-fund-tx.json"),
binary: require("./fixtures/payment-channel-fund-binary.json"),
tx: require('./fixtures/payment-channel-fund-tx.json'),
binary: require('./fixtures/payment-channel-fund-binary.json'),
},
claim: {
tx: require("./fixtures/payment-channel-claim-tx.json"),
binary: require("./fixtures/payment-channel-claim-binary.json"),
tx: require('./fixtures/payment-channel-claim-tx.json'),
binary: require('./fixtures/payment-channel-claim-binary.json'),
},
};
}
const Ticket = {
create: {
tx: require("./fixtures/ticket-create-tx.json"),
binary: require("./fixtures/ticket-create-binary.json"),
tx: require('./fixtures/ticket-create-tx.json'),
binary: require('./fixtures/ticket-create-binary.json'),
},
};
}
let json_undefined = {
TakerPays: "223174650",
Account: "rPk2dXr27rMw9G5Ej9ad2Tt7RJzGy8ycBp",
TransactionType: "OfferCreate",
TakerPays: '223174650',
Account: 'rPk2dXr27rMw9G5Ej9ad2Tt7RJzGy8ycBp',
TransactionType: 'OfferCreate',
Memos: [
{
Memo: {
MemoType: "584D4D2076616C7565",
MemoData: "322E3230393635",
MemoType: '584D4D2076616C7565',
MemoData: '322E3230393635',
MemoFormat: undefined,
},
},
],
Fee: "15",
Fee: '15',
OfferSequence: undefined,
TakerGets: {
currency: "XMM",
value: "100",
issuer: "rExAPEZvbkZqYPuNcZ7XEBLENEshsWDQc8",
currency: 'XMM',
value: '100',
issuer: 'rExAPEZvbkZqYPuNcZ7XEBLENEshsWDQc8',
},
Flags: 524288,
Sequence: undefined,
LastLedgerSequence: 6220135,
};
}
let json_omitted = {
TakerPays: "223174650",
Account: "rPk2dXr27rMw9G5Ej9ad2Tt7RJzGy8ycBp",
TransactionType: "OfferCreate",
TakerPays: '223174650',
Account: 'rPk2dXr27rMw9G5Ej9ad2Tt7RJzGy8ycBp',
TransactionType: 'OfferCreate',
Memos: [
{
Memo: {
MemoType: "584D4D2076616C7565",
MemoData: "322E3230393635",
MemoType: '584D4D2076616C7565',
MemoData: '322E3230393635',
},
},
],
Fee: "15",
Fee: '15',
TakerGets: {
currency: "XMM",
value: "100",
issuer: "rExAPEZvbkZqYPuNcZ7XEBLENEshsWDQc8",
currency: 'XMM',
value: '100',
issuer: 'rExAPEZvbkZqYPuNcZ7XEBLENEshsWDQc8',
},
Flags: 524288,
LastLedgerSequence: 6220135,
};
}
const NegativeUNL = require("./fixtures/negative-unl.json");
const NegativeUNL = require('./fixtures/negative-unl.json')
function bytesListTest() {
const list = new BytesList()
.put(Buffer.from([0]))
.put(Buffer.from([2, 3]))
.put(Buffer.from([4, 5]));
test("is an Array<Buffer>", function () {
expect(Array.isArray(list.bytesArray)).toBe(true);
expect(list.bytesArray[0] instanceof Buffer).toBe(true);
});
test("keeps track of the length itself", function () {
expect(list.getLength()).toBe(5);
});
test("can join all arrays into one via toBytes", function () {
const joined = list.toBytes();
expect(joined).toHaveLength(5);
expect(joined).toEqual(Buffer.from([0, 2, 3, 4, 5]));
});
.put(Buffer.from([4, 5]))
test('is an Array<Buffer>', function () {
expect(Array.isArray(list.bytesArray)).toBe(true)
expect(list.bytesArray[0] instanceof Buffer).toBe(true)
})
test('keeps track of the length itself', function () {
expect(list.getLength()).toBe(5)
})
test('can join all arrays into one via toBytes', function () {
const joined = list.toBytes()
expect(joined).toHaveLength(5)
expect(joined).toEqual(Buffer.from([0, 2, 3, 4, 5]))
})
}
function assertRecycles(blob) {
const parser = makeParser(blob);
const so = parser.readType(STObject);
const out = new BytesList();
so.toBytesSink(out);
const hex = out.toHex();
expect(hex).toEqual(blob);
expect(hex + ":").not.toEqual(blob);
const parser = makeParser(blob)
const so = parser.readType(STObject)
const out = new BytesList()
so.toBytesSink(out)
const hex = out.toHex()
expect(hex).toEqual(blob)
expect(hex + ':').not.toEqual(blob)
}
function nestedObjectTests() {
fixtures.whole_objects.forEach((f, i) => {
test(`whole_objects[${i}]: can parse blob and dump out same blob`, () => {
assertRecycles(f.blob_with_no_signing);
});
});
assertRecycles(f.blob_with_no_signing)
})
})
}
function check(type, n, expected) {
test(`Uint${type.width * 8} serializes ${n} as ${expected}`, function () {
const bl = new BytesList();
const serializer = new BinarySerializer(bl);
if (expected === "throws") {
expect(() => serializer.writeType(type, n)).toThrow();
return;
const bl = new BytesList()
const serializer = new BinarySerializer(bl)
if (expected === 'throws') {
expect(() => serializer.writeType(type, n)).toThrow()
return
}
serializer.writeType(type, n);
expect(bl.toBytes()).toEqual(Buffer.from(expected));
});
serializer.writeType(type, n)
expect(bl.toBytes()).toEqual(Buffer.from(expected))
})
}
check(UInt8, 5, [5]);
check(UInt16, 5, [0, 5]);
check(UInt32, 5, [0, 0, 0, 5]);
check(UInt32, 0xffffffff, [255, 255, 255, 255]);
check(UInt8, 0xfeffffff, "throws");
check(UInt16, 0xfeffffff, "throws");
check(UInt16, 0xfeffffff, "throws");
check(UInt64, 0xfeffffff, [0, 0, 0, 0, 254, 255, 255, 255]);
check(UInt64, -1, "throws");
check(UInt64, 0, [0, 0, 0, 0, 0, 0, 0, 0]);
check(UInt64, 1, [0, 0, 0, 0, 0, 0, 0, 1]);
check(UInt64, bigInt(1), [0, 0, 0, 0, 0, 0, 0, 1]);
check(UInt8, 5, [5])
check(UInt16, 5, [0, 5])
check(UInt32, 5, [0, 0, 0, 5])
check(UInt32, 0xffffffff, [255, 255, 255, 255])
check(UInt8, 0xfeffffff, 'throws')
check(UInt16, 0xfeffffff, 'throws')
check(UInt16, 0xfeffffff, 'throws')
check(UInt64, 0xfeffffff, [0, 0, 0, 0, 254, 255, 255, 255])
check(UInt64, -1, 'throws')
check(UInt64, 0, [0, 0, 0, 0, 0, 0, 0, 0])
check(UInt64, 1, [0, 0, 0, 0, 0, 0, 0, 1])
check(UInt64, bigInt(1), [0, 0, 0, 0, 0, 0, 0, 1])
function deliverMinTest() {
test("can serialize DeliverMin", () => {
expect(encode(deliverMinTx)).toEqual(deliverMinTxBinary);
});
test('can serialize DeliverMin', () => {
expect(encode(deliverMinTx)).toEqual(deliverMinTxBinary)
})
}
function SignerListSetTest() {
test("can serialize SignerListSet", () => {
expect(encode(SignerListSet.tx)).toEqual(SignerListSet.binary);
});
test("can serialize SignerListSet metadata", () => {
expect(encode(SignerListSet.tx.meta)).toEqual(SignerListSet.meta);
});
test('can serialize SignerListSet', () => {
expect(encode(SignerListSet.tx)).toEqual(SignerListSet.binary)
})
test('can serialize SignerListSet metadata', () => {
expect(encode(SignerListSet.tx.meta)).toEqual(SignerListSet.meta)
})
}
function DepositPreauthTest() {
test("can serialize DepositPreauth", () => {
expect(encode(DepositPreauth.tx)).toEqual(DepositPreauth.binary);
});
test("can serialize DepositPreauth metadata", () => {
expect(encode(DepositPreauth.tx.meta)).toEqual(DepositPreauth.meta);
});
test('can serialize DepositPreauth', () => {
expect(encode(DepositPreauth.tx)).toEqual(DepositPreauth.binary)
})
test('can serialize DepositPreauth metadata', () => {
expect(encode(DepositPreauth.tx.meta)).toEqual(DepositPreauth.meta)
})
}
function EscrowTest() {
test("can serialize EscrowCreate", () => {
expect(encode(Escrow.create.tx)).toEqual(Escrow.create.binary);
});
test("can serialize EscrowFinish", () => {
expect(encode(Escrow.finish.tx)).toEqual(Escrow.finish.binary);
expect(encode(Escrow.finish.tx.meta)).toEqual(Escrow.finish.meta);
});
test("can serialize EscrowCancel", () => {
expect(encode(Escrow.cancel.tx)).toEqual(Escrow.cancel.binary);
});
test('can serialize EscrowCreate', () => {
expect(encode(Escrow.create.tx)).toEqual(Escrow.create.binary)
})
test('can serialize EscrowFinish', () => {
expect(encode(Escrow.finish.tx)).toEqual(Escrow.finish.binary)
expect(encode(Escrow.finish.tx.meta)).toEqual(Escrow.finish.meta)
})
test('can serialize EscrowCancel', () => {
expect(encode(Escrow.cancel.tx)).toEqual(Escrow.cancel.binary)
})
}
function PaymentChannelTest() {
test("can serialize PaymentChannelCreate", () => {
test('can serialize PaymentChannelCreate', () => {
expect(encode(PaymentChannel.create.tx)).toEqual(
PaymentChannel.create.binary
);
});
test("can serialize PaymentChannelFund", () => {
expect(encode(PaymentChannel.fund.tx)).toEqual(PaymentChannel.fund.binary);
});
test("can serialize PaymentChannelClaim", () => {
expect(encode(PaymentChannel.claim.tx)).toEqual(
PaymentChannel.claim.binary
);
});
PaymentChannel.create.binary,
)
})
test('can serialize PaymentChannelFund', () => {
expect(encode(PaymentChannel.fund.tx)).toEqual(PaymentChannel.fund.binary)
})
test('can serialize PaymentChannelClaim', () => {
expect(encode(PaymentChannel.claim.tx)).toEqual(PaymentChannel.claim.binary)
})
}
function NegativeUNLTest() {
test("can serialize NegativeUNL", () => {
expect(encode(NegativeUNL.tx)).toEqual(NegativeUNL.binary);
});
test("can deserialize NegativeUNL", () => {
expect(decode(NegativeUNL.binary)).toEqual(NegativeUNL.tx);
});
test('can serialize NegativeUNL', () => {
expect(encode(NegativeUNL.tx)).toEqual(NegativeUNL.binary)
})
test('can deserialize NegativeUNL', () => {
expect(decode(NegativeUNL.binary)).toEqual(NegativeUNL.tx)
})
}
function omitUndefinedTest() {
test("omits fields with undefined value", () => {
let encodedOmitted = encode(json_omitted);
let encodedUndefined = encode(json_undefined);
expect(encodedOmitted).toEqual(encodedUndefined);
expect(decode(encodedOmitted)).toEqual(decode(encodedUndefined));
});
test('omits fields with undefined value', () => {
let encodedOmitted = encode(json_omitted)
let encodedUndefined = encode(json_undefined)
expect(encodedOmitted).toEqual(encodedUndefined)
expect(decode(encodedOmitted)).toEqual(decode(encodedUndefined))
})
}
function ticketTest() {
test("can serialize TicketCreate", () => {
expect(encode(Ticket.create.tx)).toEqual(Ticket.create.binary);
});
test('can serialize TicketCreate', () => {
expect(encode(Ticket.create.tx)).toEqual(Ticket.create.binary)
})
}
describe("Binary Serialization", function () {
describe("nestedObjectTests", () => nestedObjectTests());
describe("BytesList", () => bytesListTest());
describe("DeliverMin", () => deliverMinTest());
describe("DepositPreauth", () => DepositPreauthTest());
describe("SignerListSet", () => SignerListSetTest());
describe("Escrow", () => EscrowTest());
describe("PaymentChannel", () => PaymentChannelTest());
describe("NegativeUNLTest", () => NegativeUNLTest());
describe("OmitUndefined", () => omitUndefinedTest());
describe("TicketTest", () => ticketTest());
});
describe('Binary Serialization', function () {
describe('nestedObjectTests', () => nestedObjectTests())
describe('BytesList', () => bytesListTest())
describe('DeliverMin', () => deliverMinTest())
describe('DepositPreauth', () => DepositPreauthTest())
describe('SignerListSet', () => SignerListSetTest())
describe('Escrow', () => EscrowTest())
describe('PaymentChannel', () => PaymentChannelTest())
describe('NegativeUNLTest', () => NegativeUNLTest())
describe('OmitUndefined', () => omitUndefinedTest())
describe('TicketTest', () => ticketTest())
})