mirror of
https://github.com/barsdeveloper/ueblueprint.git
synced 2026-02-04 08:50:33 +08:00
290 lines
9.5 KiB
JavaScript
290 lines
9.5 KiB
JavaScript
/// <reference types="cypress" />
|
|
|
|
import ComplexEntity from "../fixtures/ComplexEntity"
|
|
import initializeSerializerFactory from "../../js/serialization/initializeSerializerFactory.js"
|
|
import SerializerFactory from "../../js/serialization/SerializerFactory.js"
|
|
import SimpleEntity from "../fixtures/SimpleEntity"
|
|
import SimpleObject from "../fixtures/SimpleObject"
|
|
import ISerializer from "../../js/serialization/ISerializer.js"
|
|
|
|
describe("Entity initialization", () => {
|
|
before(() => {
|
|
expect(SimpleEntity).to.be.a("function")
|
|
expect(ComplexEntity).to.be.a("function")
|
|
})
|
|
|
|
context("SimpleEntity", () => {
|
|
const entity = new SimpleEntity()
|
|
before(() => {
|
|
initializeSerializerFactory()
|
|
SerializerFactory.registerSerializer(
|
|
SimpleEntity,
|
|
new ISerializer(
|
|
SimpleEntity,
|
|
v => `{\n${v}\n}`,
|
|
" ",
|
|
"\n",
|
|
false,
|
|
": ",
|
|
undefined
|
|
)
|
|
)
|
|
})
|
|
it("has 7 keys", () => expect(Object.keys(entity).length).to.equal(7))
|
|
it("has someNumber equal to 567", () => expect(entity)
|
|
.to.have.property("someNumber")
|
|
.which.is.a("number")
|
|
.and.is.equal(567)
|
|
)
|
|
it("has someString equal to alpha", () => expect(entity)
|
|
.to.have.property("someString")
|
|
.which.is.a("string")
|
|
.and.is.equal("alpha")
|
|
)
|
|
it("has someString2 equal to beta", () => expect(entity)
|
|
.to.have.property("someString2")
|
|
.which.is.a("string")
|
|
.and.is.equal("beta")
|
|
)
|
|
it("has someBoolean true", () => expect(entity)
|
|
.to.have.property("someBoolean")
|
|
.which.is.a("boolean")
|
|
.and.is.true
|
|
)
|
|
it("has someBoolean2 false", () => expect(entity)
|
|
.to.have.property("someBoolean2")
|
|
.which.is.a("boolean")
|
|
.and.is.false
|
|
)
|
|
it("has someObjectString equal to gamma", () => expect(entity)
|
|
.to.have.property("someObjectString")
|
|
.which.is.a("string")
|
|
.and.is.equal("gamma")
|
|
)
|
|
it("has someArray with numbers", () => expect(entity)
|
|
.to.have.property("someArray")
|
|
.which.is.an("array")
|
|
.and.is.deep.equal([400, 500, 600, 700, 800])
|
|
)
|
|
it("is equal to another empty SimpleEntity", () => expect(entity.equals(new SimpleEntity()))
|
|
.to.be.true
|
|
)
|
|
const other = new SimpleEntity({
|
|
someString2: "gamma"
|
|
})
|
|
it("is not equal to another empty SimpleEntity", () => expect(entity.equals(other))
|
|
.to.be.false
|
|
)
|
|
const other1 = new SimpleEntity({
|
|
someNumber: 123,
|
|
someString: "a",
|
|
someString2: "b",
|
|
someBoolean: false,
|
|
someBoolean2: false,
|
|
someObjectString: new String("delta"),
|
|
someArray: [-1, -2, -3],
|
|
})
|
|
const other2 = new SimpleEntity({
|
|
someNumber: 123,
|
|
someString: "a",
|
|
someString2: "b",
|
|
someBoolean: false,
|
|
someBoolean2: false,
|
|
someObjectString: "delta",
|
|
someArray: [-1, -2, -3],
|
|
})
|
|
it("compares equal entities as equal", () => expect(other1.equals(other2))
|
|
.to.be.true
|
|
)
|
|
it("can serialize", () => {
|
|
expect(SerializerFactory.getSerializer(SimpleEntity).write(entity))
|
|
.to.equal(`{
|
|
someNumber: 567
|
|
someString: "alpha"
|
|
someString2: "beta"
|
|
someBoolean: True
|
|
someBoolean2: False
|
|
someObjectString: "gamma"
|
|
someArray: (400,500,600,700,800,)
|
|
}`
|
|
)
|
|
})
|
|
})
|
|
|
|
context("ComplexEntity", () => {
|
|
const entity = new ComplexEntity()
|
|
const keys = [
|
|
"alpha",
|
|
"bravo",
|
|
"charlie",
|
|
"delta",
|
|
"echo",
|
|
"foxtrot",
|
|
"golf",
|
|
"hotel",
|
|
"india",
|
|
"juliett",
|
|
"kilo",
|
|
"lima",
|
|
"mike",
|
|
"november",
|
|
"oscar",
|
|
"papa",
|
|
"quebec",
|
|
"romeo",
|
|
]
|
|
before(() => {
|
|
initializeSerializerFactory()
|
|
SerializerFactory.registerSerializer(
|
|
ComplexEntity,
|
|
new ISerializer(
|
|
ComplexEntity,
|
|
v => `[[\n${v}\n]]`,
|
|
" ",
|
|
"\n",
|
|
false,
|
|
": ",
|
|
undefined
|
|
)
|
|
)
|
|
SerializerFactory.registerSerializer(
|
|
SimpleObject,
|
|
new ISerializer(
|
|
SimpleObject,
|
|
v => `SimpleObject(${v})`,
|
|
"",
|
|
", ",
|
|
false,
|
|
"=",
|
|
undefined
|
|
)
|
|
)
|
|
})
|
|
it(`has ${keys.length} keys`, () => expect(Object.keys(entity).length).to.equal(keys.length))
|
|
it("has specific keys names", () => expect(Object.keys(entity)).to.be.deep.equal(keys))
|
|
it("has alpha equal to 32", () => expect(entity)
|
|
.to.have.property("alpha")
|
|
.which.is.a("number")
|
|
.and.is.equal(32)
|
|
)
|
|
it("has bravo equal to 78", () => expect(entity)
|
|
.to.have.property("bravo")
|
|
.which.is.a("number")
|
|
.and.is.equal(78)
|
|
)
|
|
it("has charlie equal to beta", () => expect(entity)
|
|
.to.have.property("charlie")
|
|
.which.is.a("string")
|
|
.and.is.equal("Charlie")
|
|
)
|
|
it("has delta null", () => expect(entity)
|
|
.to.have.property("delta")
|
|
.which.is.null
|
|
)
|
|
it("has echo equal to echo", () => expect(entity)
|
|
.to.have.property("echo")
|
|
.which.is.a("string")
|
|
.and.is.equal("echo")
|
|
)
|
|
it("has foxtrot false", () => expect(entity)
|
|
.to.have.property("foxtrot")
|
|
.which.is.a("boolean")
|
|
.and.is.false
|
|
)
|
|
it("has golf empty array", () => expect(entity)
|
|
.to.have.property("golf")
|
|
.which.is.an("array")
|
|
.and.is.empty
|
|
)
|
|
it("has hotel null", () => expect(entity)
|
|
.to.have.property("hotel")
|
|
.which.is.null
|
|
)
|
|
it("has india empty array", () => expect(entity)
|
|
.to.have.property("india")
|
|
.which.is.an("array")
|
|
.and.is.empty
|
|
)
|
|
it("has juliett array of strings", () => expect(entity)
|
|
.to.have.property("juliett")
|
|
.which.is.an("array")
|
|
.and.is.deep.equal(["a", "b", "c", "d", "e"])
|
|
)
|
|
it("has kilo array of booleans", () => expect(entity)
|
|
.to.have.property("kilo")
|
|
.which.is.an("array")
|
|
.and.is.deep.equal([true, false, false, true, true])
|
|
)
|
|
it("has lima undefined", () => expect(entity)
|
|
.to.have.property("lima")
|
|
.which.is.undefined
|
|
)
|
|
it("has mike equal to Foo", () => expect(entity)
|
|
.to.have.property("mike")
|
|
.which.is.a("string")
|
|
.and.is.equal("Bar")
|
|
)
|
|
it("has november equal to 0", () => expect(entity)
|
|
.to.have.property("november")
|
|
.which.is.a("number")
|
|
.and.is.equal(0)
|
|
)
|
|
it("has oscar a SimpleObject", () => expect(entity)
|
|
.to.have.property("oscar")
|
|
.which.is.instanceOf(SimpleObject)
|
|
.and.is.deep.equal({ a: 8, b: 9 })
|
|
)
|
|
it("has papa a SimpleObject", () => expect(entity)
|
|
.to.have.property("papa")
|
|
.which.is.instanceOf(SimpleObject)
|
|
.and.is.deep.equal({ a: 12, b: 13 })
|
|
)
|
|
it("has quebec undefined", () => expect(entity)
|
|
.to.have.property("quebec")
|
|
.which.is.undefined
|
|
)
|
|
it("quebec can be assigned and it always filtered", () => {
|
|
const entity = new ComplexEntity()
|
|
entity.quebec = 2
|
|
expect(entity.quebec, "assigned 2").to.be.equal(2)
|
|
entity["quebec"] = 7
|
|
expect(entity.quebec, "assigned 7").to.be.equal(7)
|
|
entity.quebec = 1
|
|
expect(entity.quebec, "assigned 1").to.be.equal(1)
|
|
entity["quebec"] = 10
|
|
expect(entity.quebec, "assigned 10").to.be.equal(10)
|
|
entity.quebec = 0
|
|
expect(entity.quebec, "assigned 0").to.be.equal(10)
|
|
entity["quebec"] = 11
|
|
expect(entity.quebec, "assigned 11").to.be.equal(10)
|
|
entity.quebec = -1
|
|
expect(entity.quebec, "assigned -1").to.be.equal(10)
|
|
entity.quebec = 6
|
|
expect(entity.quebec, "assigned 6").to.be.equal(6)
|
|
})
|
|
it("can serialize", () => {
|
|
expect(SerializerFactory.getSerializer(ComplexEntity).write(entity))
|
|
.to.equal(`[[
|
|
alpha: 32
|
|
bravo: 78
|
|
charlie: "Charlie"
|
|
delta: ()
|
|
echo: "echo"
|
|
foxtrot: False
|
|
golf: ()
|
|
hotel: ()
|
|
india: ()
|
|
juliett: ("a","b","c","d","e",)
|
|
kilo: (True,False,False,True,True,)
|
|
mike: "Bar"
|
|
november: 0
|
|
oscar: SimpleObject(a=8, b=9)
|
|
papa: SimpleObject(a=12, b=13)
|
|
romeo.a: 8
|
|
romeo.b: 9
|
|
]]`
|
|
)
|
|
})
|
|
})
|
|
})
|