54266064

Committed 23 Jun 2026 04:54PM UTC coverage: 92.804% (+0.2%) from 92.616%

Build # 54266064

Build Type

Pull #139

appveyor

Committed by

benrr101

Commit Message

One more round of :robot: comments

Pull Request Pull Request #139: [ID3v2] Split Frame Factory

Coverage Stats

3293 of 4151 branches covered (79.33%)

Branch coverage included in aggregate %.

1982 of 2003 new or added lines in 49 files covered. (98.95%)

13 existing lines in 5 files now uncovered.

27517 of 29048 relevant lines covered (94.73%)

467.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.89

/test-unit/id3v2/uniqueFileIdentifierFrameTests.ts

import {params, suite, test} from "@testdeck/mocha";
import {assert} from "chai";

import FrameConstructorTests from "./frameConstructorTests";
import PropertyTests from "../utilities/propertyTests";
import UniqueFileIdentifierFrame from "../../src/id3v2/frames/uniqueFileIdentifierFrame";
import {ByteVector, StringType} from "../../src/byteVector";
import {Frame, FrameClassType} from "../../src/id3v2/frames/frame";
import {Id3v2FrameFlags, Id3v2FrameHeader} from "../../src/id3v2/frames/frameHeader";
import {FrameIdentifiers} from "../../src/id3v2/frameIdentifiers";
import {Testers} from "../utilities/testers";

// Test constants
const testIdentifier = ByteVector.fromString("foobarbaz", StringType.UTF8);
const testOwner = "https://github.com/benrr101/node-taglib-sharp";

@suite class Id3v2_UniqueFileIdentifierFrame_ConstructorTests extends FrameConstructorTests {
    public get fromFieldBytes(): (h: Id3v2FrameHeader, d: ByteVector, v: number) => Frame {
        return UniqueFileIdentifierFrame.fromFieldBytes;
    }

    @test
    public fromData_invalidOwner_throws() {
        // Arrange
        const identifier = ByteVector.empty();

        // Act/Assert
        Testers.testTruthy((v: string) => { UniqueFileIdentifierFrame.fromData(v, identifier); });
    }

    @test
    public fromData_invalidIdentifier_throws() {
        // Arrange
        const owner = "fuxqux";

        // Act/Assert
        assert.throws(() => { UniqueFileIdentifierFrame.fromData(owner, ByteVector.fromSize(65)); });
    }

    @test
    public fromData_validPrams() {
        // Arrange
        const owner = "fuxqux";
        const identifier = ByteVector.fromSize(32, 0x8);

        // Act
        const frame = UniqueFileIdentifierFrame.fromData(owner, identifier);

        // Assert
        Id3v2_UniqueFileIdentifierFrame_ConstructorTests.assertFrame(frame, owner, identifier);
    }

    @params(2, "v2")
    @params(3, "v3")
    @params(4, "v4")
    public fromFieldBytes_empty_throws(version: number) {
        // Arrange
        const fieldBytes = ByteVector.empty();
        const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);

        // Act / Assert
        assert.throws(() => UniqueFileIdentifierFrame.fromFieldBytes(header, fieldBytes, version));
    }

    @params(2, "v2")
    @params(3, "v3")
    @params(4, "v4")
    public fromFieldBytes_oneField_throws(version: number) {
        // Arrange
        const fieldBytes = testIdentifier;
        const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);

        // Act / Assert
        assert.throws(() => UniqueFileIdentifierFrame.fromFieldBytes(header, fieldBytes, version));
    }

    @params(2, "v2")
    @params(3, "v3")
    @params(4, "v4")
    public fromFieldBytes_threeFields_throws(version: number) {
        // Arrange
        const fieldBytes = ByteVector.concatenate(
            testIdentifier, 0x00,
            testIdentifier, 0x00,
            testIdentifier
        );
        const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);

        // Act / Assert
        assert.throws(() => UniqueFileIdentifierFrame.fromFieldBytes(header, fieldBytes, version));
    }

    @params(2, "v2")
    @params(3, "v3")
    @params(4, "v4")
    public fromFieldBytes_validData_returnsFrame(version: number) {
        // Arrange
        const fieldBytes = ByteVector.concatenate(
            ByteVector.fromString(testOwner, StringType.Latin1), // Owner
            ByteVector.getTextDelimiter(StringType.Latin1),      // Delimiter
            testIdentifier                                       // Identifier
        );
        const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);


        // Act
        const frame = UniqueFileIdentifierFrame.fromFieldBytes(header, fieldBytes, version);

        // Assert
        Id3v2_UniqueFileIdentifierFrame_ConstructorTests.assertFrame(frame, testOwner, testIdentifier);
    }

    private static assertFrame(frame: UniqueFileIdentifierFrame, o: string, i: ByteVector) {
        assert.isOk(frame);
        assert.strictEqual(frame.frameClassType, FrameClassType.UniqueFileIdentifierFrame);
        assert.strictEqual(frame.frameId, FrameIdentifiers.UFID);

        assert.strictEqual(frame.owner, o);

        if (i !== undefined) {
            Testers.bvEqual(frame.identifier, i);
        } else {
            assert.isUndefined(frame.identifier);
        }
    }
}

@suite class Id3v2_UniqueFileIdentifierFrame_PropertyTests {
    @test
    public setIdentifier_tooLong_throws() {
        // Arrange
        const frame = UniqueFileIdentifierFrame.fromData("fuxqux", ByteVector.fromSize(1));

        // Act/Assert
        PropertyTests.propertyThrows((v) => { frame.identifier = v; }, ByteVector.fromSize(65));
    }

    @test
    public setIdentifier_valid() {
        // Arrange
        const frame = UniqueFileIdentifierFrame.fromData("fuxqux", ByteVector.fromSize(1));
        const identifier = ByteVector.fromString("quxx", StringType.UTF8);

        // Act / Assert
        PropertyTests.propertyRoundTrip((v) => { frame.identifier = v; }, () => frame.identifier, identifier);
    }
}

@suite class Id3v2_UniqueFileIdentifierFrame_MethodTests {
    @test
    public find_falsyFrames_throws() {
        // Act/Assert
        Testers.testTruthy((v: UniqueFileIdentifierFrame[]) => { UniqueFileIdentifierFrame.find(v, "fux"); });
    }

    @test
    public find_validParams_returnsFirstMatch() {
        // Arrange
        const frame1 = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromSize(1));
        const frame2 = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromSize(1));

        // Act
        const result = UniqueFileIdentifierFrame.find([frame1, frame2], "fux");

        // Assert
        assert.strictEqual(result, frame1);
    }

    @test
    public find_noMatches_returnsUndefined() {
        // Arrange
        const frame1 = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromSize(1));

        // Act
        const result = UniqueFileIdentifierFrame.find([frame1], "qux");

        // Assert
        assert.isUndefined(result);
    }

    @test
    public clone_noIdentifier() {
        // Arrange
        const frame = UniqueFileIdentifierFrame.fromData("fux", undefined);

        // Act
        const clone = <UniqueFileIdentifierFrame> frame.clone();

        // Assert
        assert.isOk(clone);
        assert.strictEqual(clone.frameClassType, FrameClassType.UniqueFileIdentifierFrame);
        assert.strictEqual(clone.frameId, FrameIdentifiers.UFID);

        assert.strictEqual(clone.identifier, frame.identifier);
        assert.strictEqual(clone.owner, frame.owner);
    }

    @test
    public clone_withIdentifier() {
        // Arrange
        const frame = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromString("qux", StringType.UTF8));

        // Act
        const clone = <UniqueFileIdentifierFrame> frame.clone();

        // Assert
        assert.isOk(clone);
        assert.strictEqual(clone.frameClassType, FrameClassType.UniqueFileIdentifierFrame);
        assert.strictEqual(clone.frameId, FrameIdentifiers.UFID);

        Testers.bvEqual(clone.identifier, frame.identifier);
        assert.strictEqual(clone.owner, frame.owner);
    }

    @params(2, "v2")
    @params(3, "v3")
    @params(4, "v4")
    public render_returnsByteVector(version: number) {
        // Arrange
        const frame = UniqueFileIdentifierFrame.fromData(testOwner, testIdentifier);

        // Act
        const result = frame.render(version);

        // Assert
        assert.ok(result);

        const fieldData = ByteVector.concatenate(
            ByteVector.fromString(testOwner, StringType.Latin1), // Owner
            0x00,                                                // Delimiter
            testIdentifier                                       // Identifier
        );
        const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldData.length);
        const expected = ByteVector.concatenate(header.render(version), fieldData);
        Testers.bvEqual(result, expected);
    }
}

1	import {params, suite, test} from "@testdeck/mocha";	1✔
2	import {assert} from "chai";	1✔
3
4	import FrameConstructorTests from "./frameConstructorTests";	1✔
5	import PropertyTests from "../utilities/propertyTests";	1✔
6	import UniqueFileIdentifierFrame from "../../src/id3v2/frames/uniqueFileIdentifierFrame";	1✔
7	import {ByteVector, StringType} from "../../src/byteVector";	1✔
8	import {Frame, FrameClassType} from "../../src/id3v2/frames/frame";	1✔
9	import {Id3v2FrameFlags, Id3v2FrameHeader} from "../../src/id3v2/frames/frameHeader";	1✔
10	import {FrameIdentifiers} from "../../src/id3v2/frameIdentifiers";	1✔
11	import {Testers} from "../utilities/testers";	1✔
12
13	// Test constants
14	const testIdentifier = ByteVector.fromString("foobarbaz", StringType.UTF8);	1✔
15	const testOwner = "https://github.com/benrr101/node-taglib-sharp";	1✔
16
17	@suite class Id3v2_UniqueFileIdentifierFrame_ConstructorTests extends FrameConstructorTests {	1✔
18	public get fromFieldBytes(): (h: Id3v2FrameHeader, d: ByteVector, v: number) => Frame {
19	return UniqueFileIdentifierFrame.fromFieldBytes;	7✔
20	}
21
22	@test
23	public fromData_invalidOwner_throws() {	1✔
24	// Arrange
25	const identifier = ByteVector.empty();	1✔
26
27	// Act/Assert
28	Testers.testTruthy((v: string) => { UniqueFileIdentifierFrame.fromData(v, identifier); });	2✔
29	}
30
31	@test
32	public fromData_invalidIdentifier_throws() {	1✔
33	// Arrange
34	const owner = "fuxqux";	1✔
35
36	// Act/Assert
37	assert.throws(() => { UniqueFileIdentifierFrame.fromData(owner, ByteVector.fromSize(65)); });	1✔
38	}
39
40	@test
41	public fromData_validPrams() {	1✔
42	// Arrange
43	const owner = "fuxqux";	1✔
44	const identifier = ByteVector.fromSize(32, 0x8);	1✔
45
46	// Act
47	const frame = UniqueFileIdentifierFrame.fromData(owner, identifier);	1✔
48
49	// Assert
50	Id3v2_UniqueFileIdentifierFrame_ConstructorTests.assertFrame(frame, owner, identifier);	1✔
51	}
52
53	@params(2, "v2")
54	@params(3, "v3")
55	@params(4, "v4")
56	public fromFieldBytes_empty_throws(version: number) {	1✔
57	// Arrange
58	const fieldBytes = ByteVector.empty();	3✔
59	const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);	3✔
60
61	// Act / Assert
62	assert.throws(() => UniqueFileIdentifierFrame.fromFieldBytes(header, fieldBytes, version));	3✔
63	}
64
65	@params(2, "v2")
66	@params(3, "v3")
67	@params(4, "v4")
68	public fromFieldBytes_oneField_throws(version: number) {	1✔
69	// Arrange
70	const fieldBytes = testIdentifier;	3✔
71	const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);	3✔
72
73	// Act / Assert
74	assert.throws(() => UniqueFileIdentifierFrame.fromFieldBytes(header, fieldBytes, version));	3✔
75	}
76
77	@params(2, "v2")
78	@params(3, "v3")
79	@params(4, "v4")
80	public fromFieldBytes_threeFields_throws(version: number) {	1✔
81	// Arrange
82	const fieldBytes = ByteVector.concatenate(	3✔
83	testIdentifier, 0x00,
84	testIdentifier, 0x00,
85	testIdentifier
86	);
87	const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);	3✔
88
89	// Act / Assert
90	assert.throws(() => UniqueFileIdentifierFrame.fromFieldBytes(header, fieldBytes, version));	3✔
91	}
92
93	@params(2, "v2")
94	@params(3, "v3")
95	@params(4, "v4")
96	public fromFieldBytes_validData_returnsFrame(version: number) {	1✔
97	// Arrange
98	const fieldBytes = ByteVector.concatenate(	3✔
99	ByteVector.fromString(testOwner, StringType.Latin1), // Owner
100	ByteVector.getTextDelimiter(StringType.Latin1), // Delimiter
101	testIdentifier // Identifier
102	);
103	const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);	3✔
104
105
106	// Act
107	const frame = UniqueFileIdentifierFrame.fromFieldBytes(header, fieldBytes, version);	3✔
108
109	// Assert
110	Id3v2_UniqueFileIdentifierFrame_ConstructorTests.assertFrame(frame, testOwner, testIdentifier);	3✔
111	}
112
113	private static assertFrame(frame: UniqueFileIdentifierFrame, o: string, i: ByteVector) {
114	assert.isOk(frame);	4✔
115	assert.strictEqual(frame.frameClassType, FrameClassType.UniqueFileIdentifierFrame);	4✔
116	assert.strictEqual(frame.frameId, FrameIdentifiers.UFID);	4✔
117
118	assert.strictEqual(frame.owner, o);	4✔
119
120	if (i !== undefined) {	4!
121	Testers.bvEqual(frame.identifier, i);	4✔
122	} else {
UNCOV 123	assert.isUndefined(frame.identifier);	×
124	}
125	}
126	}
127
128	@suite class Id3v2_UniqueFileIdentifierFrame_PropertyTests {	1✔
129	@test
130	public setIdentifier_tooLong_throws() {	1✔
131	// Arrange
132	const frame = UniqueFileIdentifierFrame.fromData("fuxqux", ByteVector.fromSize(1));	1✔
133
134	// Act/Assert
135	PropertyTests.propertyThrows((v) => { frame.identifier = v; }, ByteVector.fromSize(65));	1✔
136	}
137
138	@test
139	public setIdentifier_valid() {	1✔
140	// Arrange
141	const frame = UniqueFileIdentifierFrame.fromData("fuxqux", ByteVector.fromSize(1));	1✔
142	const identifier = ByteVector.fromString("quxx", StringType.UTF8);	1✔
143
144	// Act / Assert
145	PropertyTests.propertyRoundTrip((v) => { frame.identifier = v; }, () => frame.identifier, identifier);	1✔
146	}
147	}
148
149	@suite class Id3v2_UniqueFileIdentifierFrame_MethodTests {	1✔
150	@test
151	public find_falsyFrames_throws() {	1✔
152	// Act/Assert
153	Testers.testTruthy((v: UniqueFileIdentifierFrame[]) => { UniqueFileIdentifierFrame.find(v, "fux"); });	2✔
154	}
155
156	@test
157	public find_validParams_returnsFirstMatch() {	1✔
158	// Arrange
159	const frame1 = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromSize(1));	1✔
160	const frame2 = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromSize(1));	1✔
161
162	// Act
163	const result = UniqueFileIdentifierFrame.find([frame1, frame2], "fux");	1✔
164
165	// Assert
166	assert.strictEqual(result, frame1);	1✔
167	}
168
169	@test
170	public find_noMatches_returnsUndefined() {	1✔
171	// Arrange
172	const frame1 = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromSize(1));	1✔
173
174	// Act
175	const result = UniqueFileIdentifierFrame.find([frame1], "qux");	1✔
176
177	// Assert
178	assert.isUndefined(result);	1✔
179	}
180
181	@test
182	public clone_noIdentifier() {	1✔
183	// Arrange
184	const frame = UniqueFileIdentifierFrame.fromData("fux", undefined);	1✔
185
186	// Act
187	const clone = <UniqueFileIdentifierFrame> frame.clone();	1✔
188
189	// Assert
190	assert.isOk(clone);	1✔
191	assert.strictEqual(clone.frameClassType, FrameClassType.UniqueFileIdentifierFrame);	1✔
192	assert.strictEqual(clone.frameId, FrameIdentifiers.UFID);	1✔
193
194	assert.strictEqual(clone.identifier, frame.identifier);	1✔
195	assert.strictEqual(clone.owner, frame.owner);	1✔
196	}
197
198	@test
199	public clone_withIdentifier() {	1✔
200	// Arrange
201	const frame = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromString("qux", StringType.UTF8));	1✔
202
203	// Act
204	const clone = <UniqueFileIdentifierFrame> frame.clone();	1✔
205
206	// Assert
207	assert.isOk(clone);	1✔
208	assert.strictEqual(clone.frameClassType, FrameClassType.UniqueFileIdentifierFrame);	1✔
209	assert.strictEqual(clone.frameId, FrameIdentifiers.UFID);	1✔
210
211	Testers.bvEqual(clone.identifier, frame.identifier);	1✔
212	assert.strictEqual(clone.owner, frame.owner);	1✔
213	}
214
215	@params(2, "v2")
216	@params(3, "v3")
217	@params(4, "v4")
218	public render_returnsByteVector(version: number) {	1✔
219	// Arrange
220	const frame = UniqueFileIdentifierFrame.fromData(testOwner, testIdentifier);	3✔
221
222	// Act
223	const result = frame.render(version);	3✔
224
225	// Assert
226	assert.ok(result);	3✔
227
228	const fieldData = ByteVector.concatenate(	3✔
229	ByteVector.fromString(testOwner, StringType.Latin1), // Owner
230	0x00, // Delimiter
231	testIdentifier // Identifier
232	);
233	const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldData.length);	3✔
234	const expected = ByteVector.concatenate(header.render(version), fieldData);	3✔
235	Testers.bvEqual(result, expected);	3✔
236	}
237	}

benrr101 / node-taglib-sharp / 54266064

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous