54280018

Committed 25 Jun 2026 06:08PM UTC coverage: 92.799% (+0.2%) from 92.616%

Build # 54280018

Build Type

Pull #139

appveyor

Committed by

benrr101

Commit Message

Last round of :robot: comments

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

Coverage Stats

3280 of 4139 branches covered (79.25%)

Branch coverage included in aggregate %.

1997 of 2019 new or added lines in 49 files covered. (98.91%)

13 existing lines in 5 files now uncovered.

27533 of 29065 relevant lines covered (94.73%)

467.87 hits per line

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

97.94

/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(version: number) {
        // Arrange
        const fieldBytes = ByteVector.concatenate(
            ByteVector.fromString(testOwner, StringType.Latin1), // Owner
            ByteVector.getTextDelimiter(StringType.Latin1),      // Delimiter
            testIdentifier, 0x00, testIdentifier                 // Identifier
        );
        const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);

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

        // Assert
        const expectedData = ByteVector.concatenate(testIdentifier, 0x00, testIdentifier);
        Id3v2_UniqueFileIdentifierFrame_ConstructorTests.assertFrame(frame, testOwner, expectedData);
    }

    @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(version: number) {	1✔
81	// Arrange
82	const fieldBytes = ByteVector.concatenate(	3✔
83	ByteVector.fromString(testOwner, StringType.Latin1), // Owner
84	ByteVector.getTextDelimiter(StringType.Latin1), // Delimiter
85	testIdentifier, 0x00, testIdentifier // Identifier
86	);
87	const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);	3✔
88
89	// Act
90	const frame = UniqueFileIdentifierFrame.fromFieldBytes(header, fieldBytes, version);	3✔
91
92	// Assert
93	const expectedData = ByteVector.concatenate(testIdentifier, 0x00, testIdentifier);	3✔
94	Id3v2_UniqueFileIdentifierFrame_ConstructorTests.assertFrame(frame, testOwner, expectedData);	3✔
95	}
96
97	@params(2, "v2")
98	@params(3, "v3")
99	@params(4, "v4")
100	public fromFieldBytes_validData_returnsFrame(version: number) {	1✔
101	// Arrange
102	const fieldBytes = ByteVector.concatenate(	3✔
103	ByteVector.fromString(testOwner, StringType.Latin1), // Owner
104	ByteVector.getTextDelimiter(StringType.Latin1), // Delimiter
105	testIdentifier // Identifier
106	);
107	const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldBytes.length);	3✔
108
109
110	// Act
111	const frame = UniqueFileIdentifierFrame.fromFieldBytes(header, fieldBytes, version);	3✔
112
113	// Assert
114	Id3v2_UniqueFileIdentifierFrame_ConstructorTests.assertFrame(frame, testOwner, testIdentifier);	3✔
115	}
116
117	private static assertFrame(frame: UniqueFileIdentifierFrame, o: string, i: ByteVector) {
118	assert.isOk(frame);	7✔
119	assert.strictEqual(frame.frameClassType, FrameClassType.UniqueFileIdentifierFrame);	7✔
120	assert.strictEqual(frame.frameId, FrameIdentifiers.UFID);	7✔
121
122	assert.strictEqual(frame.owner, o);	7✔
123
124	if (i !== undefined) {	7!
125	Testers.bvEqual(frame.identifier, i);	7✔
126	} else {
UNCOV 127	assert.isUndefined(frame.identifier);	×
128	}
129	}
130	}
131
132	@suite class Id3v2_UniqueFileIdentifierFrame_PropertyTests {	1✔
133	@test
134	public setIdentifier_tooLong_throws() {	1✔
135	// Arrange
136	const frame = UniqueFileIdentifierFrame.fromData("fuxqux", ByteVector.fromSize(1));	1✔
137
138	// Act/Assert
139	PropertyTests.propertyThrows((v) => { frame.identifier = v; }, ByteVector.fromSize(65));	1✔
140	}
141
142	@test
143	public setIdentifier_valid() {	1✔
144	// Arrange
145	const frame = UniqueFileIdentifierFrame.fromData("fuxqux", ByteVector.fromSize(1));	1✔
146	const identifier = ByteVector.fromString("quxx", StringType.UTF8);	1✔
147
148	// Act / Assert
149	PropertyTests.propertyRoundTrip((v) => { frame.identifier = v; }, () => frame.identifier, identifier);	1✔
150	}
151	}
152
153	@suite class Id3v2_UniqueFileIdentifierFrame_MethodTests {	1✔
154	@test
155	public find_falsyFrames_throws() {	1✔
156	// Act/Assert
157	Testers.testTruthy((v: UniqueFileIdentifierFrame[]) => { UniqueFileIdentifierFrame.find(v, "fux"); });	2✔
158	}
159
160	@test
161	public find_validParams_returnsFirstMatch() {	1✔
162	// Arrange
163	const frame1 = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromSize(1));	1✔
164	const frame2 = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromSize(1));	1✔
165
166	// Act
167	const result = UniqueFileIdentifierFrame.find([frame1, frame2], "fux");	1✔
168
169	// Assert
170	assert.strictEqual(result, frame1);	1✔
171	}
172
173	@test
174	public find_noMatches_returnsUndefined() {	1✔
175	// Arrange
176	const frame1 = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromSize(1));	1✔
177
178	// Act
179	const result = UniqueFileIdentifierFrame.find([frame1], "qux");	1✔
180
181	// Assert
182	assert.isUndefined(result);	1✔
183	}
184
185	@test
186	public clone_noIdentifier() {	1✔
187	// Arrange
188	const frame = UniqueFileIdentifierFrame.fromData("fux", undefined);	1✔
189
190	// Act
191	const clone = <UniqueFileIdentifierFrame> frame.clone();	1✔
192
193	// Assert
194	assert.isOk(clone);	1✔
195	assert.strictEqual(clone.frameClassType, FrameClassType.UniqueFileIdentifierFrame);	1✔
196	assert.strictEqual(clone.frameId, FrameIdentifiers.UFID);	1✔
197
198	assert.strictEqual(clone.identifier, frame.identifier);	1✔
199	assert.strictEqual(clone.owner, frame.owner);	1✔
200	}
201
202	@test
203	public clone_withIdentifier() {	1✔
204	// Arrange
205	const frame = UniqueFileIdentifierFrame.fromData("fux", ByteVector.fromString("qux", StringType.UTF8));	1✔
206
207	// Act
208	const clone = <UniqueFileIdentifierFrame> frame.clone();	1✔
209
210	// Assert
211	assert.isOk(clone);	1✔
212	assert.strictEqual(clone.frameClassType, FrameClassType.UniqueFileIdentifierFrame);	1✔
213	assert.strictEqual(clone.frameId, FrameIdentifiers.UFID);	1✔
214
215	Testers.bvEqual(clone.identifier, frame.identifier);	1✔
216	assert.strictEqual(clone.owner, frame.owner);	1✔
217	}
218
219	@params(2, "v2")
220	@params(3, "v3")
221	@params(4, "v4")
222	public render_returnsByteVector(version: number) {	1✔
223	// Arrange
224	const frame = UniqueFileIdentifierFrame.fromData(testOwner, testIdentifier);	3✔
225
226	// Act
227	const result = frame.render(version);	3✔
228
229	// Assert
230	assert.ok(result);	3✔
231
232	const fieldData = ByteVector.concatenate(	3✔
233	ByteVector.fromString(testOwner, StringType.Latin1), // Owner
234	0x00, // Delimiter
235	testIdentifier // Identifier
236	);
237	const header = new Id3v2FrameHeader(FrameIdentifiers.UFID, Id3v2FrameFlags.None, fieldData.length);	3✔
238	const expected = ByteVector.concatenate(header.render(version), fieldData);	3✔
239	Testers.bvEqual(result, expected);	3✔
240	}
241	}

benrr101 / node-taglib-sharp / 54280018

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