stated-protocol-parser 1.0.3 → 1.0.5

package/src/hash.test.ts

@@ -0,0 +1,217 @@
+import { sha256, verify, fromUrlSafeBase64, toUrlSafeBase64 } from './hash.node';
+
+describe('Hash utilities', () => {
+    describe('sha256', () => {
+        it('should hash a simple string', () => {
+            const input = 'hello world';
+            const hash = sha256(input);
+            
+            // Verify it's URL-safe (no +, /, or =)
+            expect(hash).not.toContain('+');
+            expect(hash).not.toContain('/');
+            expect(hash).not.toContain('=');
+            
+            // Verify consistent output
+            const hash2 = sha256(input);
+            expect(hash).toBe(hash2);
+        });
+
+        it('should produce correct hash for known input', () => {
+            const input = 'hello world';
+            const expectedHash = 'uU0nuZNNPgilLlLX2n2r-sSE7-N6U4DukIj3rOLvzek';
+            const hash = sha256(input);
+            expect(hash).toBe(expectedHash);
+        });
+
+        it('should handle empty string', () => {
+            const hash = sha256('');
+            expect(hash).toBeTruthy();
+            expect(typeof hash).toBe('string');
+        });
+
+        it('should handle unicode characters', () => {
+            const input = '你好世界 🌍';
+            const hash = sha256(input);
+            expect(hash).toBeTruthy();
+            expect(typeof hash).toBe('string');
+            
+            // Verify consistency
+            const hash2 = sha256(input);
+            expect(hash).toBe(hash2);
+        });
+
+        it('should handle Buffer input', () => {
+            const data = Buffer.from('hello world');
+            const hash = sha256(data);
+            
+            // Should produce same hash as string input
+            const stringHash = sha256('hello world');
+            expect(hash).toBe(stringHash);
+        });
+
+        it('should produce different hashes for different inputs', () => {
+            const hash1 = sha256('hello');
+            const hash2 = sha256('world');
+            expect(hash1).not.toBe(hash2);
+        });
+
+        it('should produce 43-character URL-safe base64 string', () => {
+            const hash = sha256('test');
+            // SHA-256 produces 256 bits = 32 bytes
+            // Base64 encoding: 32 bytes * 4/3 = 42.67, rounded up = 43 chars (without padding)
+            expect(hash.length).toBe(43);
+        });
+    });
+
+    describe('verify', () => {
+        it('should verify correct hash', () => {
+            const content = 'hello world';
+            const hash = sha256(content);
+            const isValid = verify(content, hash);
+            expect(isValid).toBe(true);
+        });
+
+        it('should reject incorrect hash', () => {
+            const content = 'hello world';
+            const wrongHash = 'incorrect_hash_value_here_1234567890';
+            const isValid = verify(content, wrongHash);
+            expect(isValid).toBe(false);
+        });
+
+        it('should reject hash for different content', () => {
+            const content1 = 'hello world';
+            const content2 = 'goodbye world';
+            const hash1 = sha256(content1);
+            const isValid = verify(content2, hash1);
+            expect(isValid).toBe(false);
+        });
+
+        it('should work with Buffer', () => {
+            const data = Buffer.from('test data');
+            const hash = sha256(data);
+            const isValid = verify(data, hash);
+            expect(isValid).toBe(true);
+        });
+    });
+
+    describe('fromUrlSafeBase64', () => {
+        it('should convert URL-safe base64 to standard base64', () => {
+            // Use a URL-safe string that contains both - and _ characters
+            const urlSafe = 'abc-def_ghi';
+            const standard = fromUrlSafeBase64(urlSafe);
+            
+            // Should replace - with + and _ with /
+            expect(standard).toContain('+');
+            expect(standard).toContain('/');
+            // Should add padding
+            expect(standard.endsWith('=')).toBe(true);
+        });
+
+        it('should add correct padding', () => {
+            // Test different padding scenarios
+            const testCases = [
+                { input: 'abc', expectedPadding: 1 },
+                { input: 'abcd', expectedPadding: 0 },
+                { input: 'abcde', expectedPadding: 3 },
+                { input: 'abcdef', expectedPadding: 2 },
+            ];
+
+            testCases.forEach(({ input, expectedPadding }) => {
+                const result = fromUrlSafeBase64(input);
+                const paddingCount = (result.match(/=/g) || []).length;
+                expect(paddingCount).toBe(expectedPadding);
+            });
+        });
+
+        it('should handle strings without special characters', () => {
+            const input = 'abcdefghijklmnop';
+            const result = fromUrlSafeBase64(input);
+            expect(result).toBeTruthy();
+        });
+    });
+
+    describe('toUrlSafeBase64', () => {
+        it('should convert standard base64 to URL-safe', () => {
+            const standard = 'uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=';
+            const urlSafe = toUrlSafeBase64(standard);
+            
+            // Should not contain standard base64 special characters
+            expect(urlSafe).not.toContain('+');
+            expect(urlSafe).not.toContain('/');
+            expect(urlSafe).not.toContain('=');
+            
+            // Should contain URL-safe replacements
+            expect(urlSafe).toContain('-');
+        });
+
+        it('should remove padding', () => {
+            const withPadding = 'abc=';
+            const result = toUrlSafeBase64(withPadding);
+            expect(result).not.toContain('=');
+            expect(result).toBe('abc');
+        });
+
+        it('should be reversible with fromUrlSafeBase64', () => {
+            // Start with a standard base64 string with special chars
+            const original = 'test+data/with==';
+            const urlSafe = toUrlSafeBase64(original);
+            const restored = fromUrlSafeBase64(urlSafe);
+            
+            // Should restore to equivalent base64 (padding might differ slightly)
+            expect(restored.replace(/=+$/, '')).toBe(original.replace(/=+$/, ''));
+        });
+    });
+
+    describe('Round-trip conversions', () => {
+        it('should maintain hash integrity through URL-safe conversion', () => {
+            const content = 'test content for hashing';
+            const hash = sha256(content);
+            
+            // Convert to standard base64 and back
+            const standard = fromUrlSafeBase64(hash);
+            const backToUrlSafe = toUrlSafeBase64(standard);
+            
+            expect(backToUrlSafe).toBe(hash);
+        });
+
+        it('should verify hash after conversion', () => {
+            const content = 'verification test';
+            const hash = sha256(content);
+            
+            // Convert and back
+            const standard = fromUrlSafeBase64(hash);
+            const urlSafe = toUrlSafeBase64(standard);
+            
+            // Should still verify
+            const isValid = verify(content, urlSafe);
+            expect(isValid).toBe(true);
+        });
+    });
+
+    describe('Edge cases', () => {
+        it('should handle very long strings', () => {
+            const longString = 'a'.repeat(10000);
+            const hash = sha256(longString);
+            expect(hash).toBeTruthy();
+            expect(hash.length).toBe(43);
+        });
+
+        it('should handle special characters', () => {
+            const special = '!@#$%^&*()_+-=[]{}|;:,.<>?';
+            const hash = sha256(special);
+            expect(hash).toBeTruthy();
+            
+            const isValid = verify(special, hash);
+            expect(isValid).toBe(true);
+        });
+
+        it('should handle newlines and whitespace', () => {
+            const withNewlines = 'line1\nline2\r\nline3\ttab';
+            const hash = sha256(withNewlines);
+            expect(hash).toBeTruthy();
+            
+            const isValid = verify(withNewlines, hash);
+            expect(isValid).toBe(true);
+        });
+    });
+});

package/src/index.test.ts

@@ -0,0 +1,378 @@
+import {
+    parseRating,
+    parseStatement,
+    parseOrganisationVerification,
+    parsePDFSigning,
+    parsePersonVerification,
+    parseDisputeAuthenticity,
+    parseDisputeContent,
+    parseVote,
+    parsePoll,
+    parseQuotation,
+    parseBounty,
+    parseBoycott,
+    parseObservation,
+    parseResponseContent,
+    buildResponseContent,
+    buildRating,
+    buildStatement,
+    buildBounty,
+    buildDisputeAuthenticityContent,
+    buildDisputeContentContent,
+    buildPDFSigningContent,
+    buildPersonVerificationContent,
+    buildPollContent,
+    buildQuotationContent,
+    buildVoteContent,
+    buildOrganisationVerificationContent,
+    buildBoycott,
+    buildObservation,
+} from './index'
+
+const randomUnicodeString = () =>
+    Array.from({ length: 20 }, () =>
+        String.fromCharCode(Math.floor(Math.random() * 65536))
+    )
+        .join('')
+        .replace(/[\n;>=<"''\\]/g, '')
+
+test('parse statement', () => {
+    const statement = `Publishing domain: localhost
+Author: chris
+Time: Tue, 18 Apr 2023 18:20:26 GMT
+Tags: hashtag1, hashtag2
+Format version: 4
+Statement content: hi
+`
+    const parsedStatement = parseStatement({ statement })
+    expect(parsedStatement.content).toBe(`hi
+`)
+})
+
+test('statement build & parse function compatibility: input=parse(build(input))', () => {
+    const [domain, author, representative, content, supersededStatement] =
+        Array.from({ length: 5 }, randomUnicodeString)
+    const tags = Array.from({ length: 4 }, randomUnicodeString)
+    const contentWithTrailingNewline =
+        content + (content.match(/\n$/) ? '' : '\n')
+    const time = new Date('Sun, 04 Sep 2022 14:48:50 GMT')
+    const statementContent = buildStatement({
+        domain,
+        author,
+        time,
+        content: contentWithTrailingNewline,
+        representative,
+        supersededStatement,
+        tags,
+    })
+    const parsedStatement = parseStatement({ statement: statementContent })
+    expect(parsedStatement.domain).toBe(domain)
+    expect(parsedStatement.author).toBe(author)
+    expect(parsedStatement.time?.toUTCString()).toBe(time.toUTCString())
+    expect(parsedStatement.content).toBe(contentWithTrailingNewline)
+    expect(parsedStatement.representative).toBe(representative)
+    expect(parsedStatement.supersededStatement).toBe(supersededStatement)
+    expect(parsedStatement.tags?.sort()).toStrictEqual(tags.sort())
+})
+
+test('parse quotation', () => {
+    let quotation = `Publishing domain: rixdata.net
+Author: Example Inc.
+Time: Sun, 04 Sep 2022 14:48:50 GMT
+Format version: 4
+Statement content: 
+	Type: Quotation
+	Original author: XYZ Company Inc.
+	Author verification: eXoVsm2CdF5Ri-SEAr33RNkG3DBuehvFoDBQ_pO9CXE
+	Original publication time: Sun, 04 Sep 2022 14:48:50 GMT
+	Source: https://www.facebook.com/companyxzy/posts/XXXX
+	Picture proof: 5HKiyQXGV4xavq-Nn9RXi_ndUH-2BEux3ccFIjaSk_8
+	Confidence: 0.9
+	Quotation: we give example.com a 2/5 star rating
+	Paraphrased statement: 
+		Type: Rating
+		Organisation name: example
+		Organisation domain: example.com
+		Our rating: 2/5 Stars
+`
+    const parsedStatement = parseStatement({ statement: quotation })
+    const parsedQuotation = parseQuotation(parsedStatement.content)
+    const type = parsedQuotation.type
+    expect(type).toBe('rating')
+})
+
+test('quotation build & parse function compatibility: input=parse(build(input))', () => {
+    const [originalAuthor, source, picture, quotation, paraphrasedStatement] =
+        Array.from({ length: 6 }, randomUnicodeString)
+    const authorVerification = 'yXoVsm2CdF5Ri-SEAr33RNkG3DBuehvFoDBQ_pO9CXE'
+    const originalTime = 'Sun, 04 Sep 2022 14:48:50 GMT'
+    const confidence = '' + Math.random()
+    const quotationContent = buildQuotationContent({
+        originalAuthor,
+        authorVerification,
+        originalTime,
+        source,
+        picture,
+        confidence,
+        quotation,
+        paraphrasedStatement,
+    })
+    const parsedQuotation = parseQuotation(quotationContent)
+    expect(parsedQuotation.originalAuthor).toBe(originalAuthor)
+    expect(parsedQuotation.originalTime).toBe(originalTime)
+    expect(parsedQuotation.source).toBe(source)
+    expect(parsedQuotation.picture).toBe(picture)
+    expect(parsedQuotation.confidence).toBe(confidence)
+    expect(parsedQuotation.quotation).toBe(quotation)
+    expect(parsedQuotation.paraphrasedStatement?.replace(/\n$/, '')).toBe(
+        paraphrasedStatement
+    )
+    expect(parsedQuotation.authorVerification).toBe(authorVerification)
+})
+
+test('parse organisation verification', () => {
+    let organisationVerification = `Publishing domain: rixdata.net
+Author: Example Inc.
+Time: Sun, 04 Sep 2022 14:48:50 GMT
+Format version: 4
+Statement content: 
+	Type: Organisation verification
+	Description: We verified the following information about an organisation.
+	Name: Walmart Inc.
+	Country: United States of America
+	Legal entity: corporation
+	Owner of the domain: walmart.com
+	Province or state: Arkansas
+	City: Bentonville
+`
+    const parsedStatement = parseStatement({
+        statement: organisationVerification,
+    })
+    const parsedOVerification = parseOrganisationVerification(
+        parsedStatement.content
+    )
+    const name = parsedOVerification.name
+    expect(name).toBe('Walmart Inc.')
+})
+
+test('organisation verification build & parse function compatibility: input=parse(build(input))', () => {
+    const [
+        name,
+        englishName,
+        city,
+        domain,
+        foreignDomain,
+        serialNumber,
+        reliabilityPolicy,
+        pictureHash,
+    ] = Array.from({ length: 8 }, randomUnicodeString)
+    const country = 'Germany'
+    const province = 'Bayern'
+    const legalForm = 'corporation'
+    const employeeCount = '100-1000'
+    const confidence = 0.8
+    const verificationContent = buildOrganisationVerificationContent({
+        name,
+        englishName,
+        country,
+        city,
+        province,
+        legalForm,
+        domain,
+        pictureHash,
+        foreignDomain,
+        serialNumber,
+        confidence,
+        reliabilityPolicy,
+        employeeCount,
+    })
+    const parsedVerification =
+        parseOrganisationVerification(verificationContent)
+    expect(parsedVerification.name).toBe(name)
+    expect(parsedVerification.englishName).toBe(englishName)
+    expect(parsedVerification.country).toBe(country)
+    expect(parsedVerification.city).toBe(city)
+    expect(parsedVerification.province).toBe(province)
+    expect(parsedVerification.legalForm).toBe(legalForm)
+    expect(parsedVerification.domain).toBe(domain)
+    expect(parsedVerification.foreignDomain).toBe(foreignDomain)
+    expect(parsedVerification.serialNumber).toBe(serialNumber)
+    expect(parsedVerification.confidence).toBe(confidence)
+    expect(parsedVerification.pictureHash).toBe(pictureHash)
+    expect(parsedVerification.reliabilityPolicy).toBe(reliabilityPolicy)
+    expect(parsedVerification.employeeCount).toBe(employeeCount)
+})
+
+test('parse person verification', () => {
+    let personVerification = `Publishing domain: rixdata.net
+Author: Example Inc.
+Time: Sun, 04 Sep 2022 14:48:50 GMT
+Format version: 4
+Statement content: 
+	Type: Person verification
+	Description: We verified the following information about a person.
+	Name: Barack Hossein Obama II
+	Date of birth: 4 Aug 1961
+	City of birth: Honolulu
+	Country of birth: United States of America
+	Owner of the domain: barackobama.com
+`
+    const parsedStatement = parseStatement({ statement: personVerification })
+    const parsedPVerification = parsePersonVerification(parsedStatement.content)
+    const name = parsedPVerification.name
+    expect(name).toBe('Barack Hossein Obama II')
+})
+
+test('person verification build & parse function compatibility: input=parse(build(input))', () => {
+    const [
+        name,
+        ownDomain,
+        foreignDomain,
+        jobTitle,
+        employer,
+        verificationMethod,
+        picture,
+        reliabilityPolicy,
+    ] = Array.from({ length: 12 }, randomUnicodeString)
+    const countryOfBirth = 'Germany'
+    const cityOfBirth = 'Berlin'
+    const confidence = Math.random()
+    const dateOfBirth = new Date(0)
+    const personVerificationContent = buildPersonVerificationContent({
+        name,
+        countryOfBirth,
+        cityOfBirth,
+        ownDomain,
+        foreignDomain,
+        dateOfBirth,
+        jobTitle,
+        employer,
+        verificationMethod,
+        confidence,
+        picture,
+        reliabilityPolicy,
+    })
+
+    const parsedVerification = parsePersonVerification(
+        personVerificationContent
+    )
+    expect(parsedVerification.name).toBe(name)
+    expect(parsedVerification.ownDomain).toBe(ownDomain)
+    expect(parsedVerification.foreignDomain).toBe(foreignDomain)
+    expect(parsedVerification.dateOfBirth.toUTCString()).toBe(
+        dateOfBirth.toUTCString()
+    )
+    expect(parsedVerification.jobTitle).toBe(jobTitle)
+    expect(parsedVerification.employer).toBe(employer)
+    expect(parsedVerification.verificationMethod).toBe(verificationMethod)
+    expect(parsedVerification.confidence).toBe(confidence)
+    expect(parsedVerification.picture).toBe(picture)
+    expect(parsedVerification.reliabilityPolicy).toBe(reliabilityPolicy)
+    expect(parsedVerification.countryOfBirth).toBe(countryOfBirth)
+    expect(parsedVerification.cityOfBirth).toBe(cityOfBirth)
+})
+
+test('parse rating', () => {
+    let rating = `Publishing domain: localhost
+Author: chris
+Time: Tue, 18 Apr 2023 18:20:26 GMT
+Format version: 4
+Statement content: 
+	Type: Rating
+	Subject name: AMBOSS GmbH
+	URL that identifies the subject: amboss.com
+	Rated quality: AI safety
+	Our rating: 5/5 Stars
+`
+    const parsedStatement = parseStatement({ statement: rating })
+    const parsedRating = parseRating(parsedStatement.content)
+    const ratingNumber = parsedRating.rating
+    expect(ratingNumber).toBe(5)
+    const subjectName = parsedRating.subjectName
+    expect(subjectName).toBe('AMBOSS GmbH')
+    const subjectReference = parsedRating.subjectReference
+    expect(subjectReference).toBe('amboss.com')
+    const quality = parsedRating.quality
+    expect(quality).toBe('AI safety')
+})
+
+test('rating build & parse function compatibility: input=parse(build(input))', () => {
+    const [subjectName, subjectReference, comment, quality] = Array.from(
+        { length: 4 },
+        randomUnicodeString
+    )
+    const rating = Math.ceil(Math.random() * 5)
+    const ratingContent = buildRating({ subjectName, subjectReference, rating, comment, quality })
+    const parsedRating = parseRating(ratingContent)
+    expect(parsedRating.subjectName).toBe(subjectName)
+    expect(parsedRating.subjectReference).toBe(subjectReference)
+    expect(parsedRating.quality).toBe(quality)
+    expect(parsedRating.rating).toBe(rating)
+    expect(parsedRating.comment).toBe(comment)
+})
+
+test('parse poll v4', () => {
+    let poll = `Publishing domain: rixdata.net
+Author: Example Inc.
+Time: Thu, 17 Nov 2022 13:38:20 GMT
+Format version: 4
+Statement content: 
+	Type: Poll
+	The poll outcome is finalized when the following nodes agree: rixdata.net
+	Voting deadline: Thu, 01 Dec 2022 13:38:26 GMT
+	Poll: Should the UK join the EU
+	Option 1: Yes
+	Option 2: No
+	Who can vote: 
+		Description: All universities with a ROR ID
+		Legal form scope: corporation
+		All entities with the following property: ROR ID
+		As observed by: Rix Data NL B.V.@rixdata.net
+		Link to query defining who can vote: https://stated.rixdata.net/?search_query=%09Observed%20property:%20ROR%20ID%0A%09&domain=rixdata.net&author=Rix%20Data%20NL%20B.V.
+`
+    const parsedStatement = parseStatement({ statement: poll })
+    const parsedPoll = parsePoll(parsedStatement.content)
+    const pollTitle = parsedPoll.poll
+    expect(pollTitle).toBe('Should the UK join the EU')
+    expect(parsedPoll.options[0]).toBe('Yes')
+    expect(parsedPoll.options[1]).toBe('No')
+    expect(parsedPoll.deadline?.toUTCString()).toBe(
+        'Thu, 01 Dec 2022 13:38:26 GMT'
+    )
+    expect(parsedPoll.scopeDescription).toBe('All universities with a ROR ID')
+    expect(parsedPoll.legalEntity).toBe('corporation')
+    expect(parsedPoll.requiredProperty).toBe('ROR ID')
+    expect(parsedPoll.requiredPropertyObserver).toBe(
+        'Rix Data NL B.V.@rixdata.net'
+    )
+    expect(parsedPoll.scopeQueryLink).toBe(
+        'https://stated.rixdata.net/?search_query=%09Observed%20property:%20ROR%20ID%0A%09&domain=rixdata.net&author=Rix%20Data%20NL%20B.V.'
+    )
+})
+
+test('poll build & parse function compatibility: input=parse(build(input))', () => {
+    const [country, city, legalEntity, judges, poll, scopeDescription] =
+        Array.from({ length: 6 }, randomUnicodeString)
+    const options = Array.from({ length: 2 }, randomUnicodeString)
+    const domainScope = ['rixdata.net']
+    const deadline = new Date('Thu, 01 Dec 2022 13:38:26 GMT')
+    const pollContent = buildPollContent({
+        country,
+        city,
+        legalEntity,
+        domainScope,
+        judges,
+        deadline,
+        poll,
+        options,
+        scopeDescription,
+    })
+    const parsedPoll = parsePoll(pollContent)
+    expect(parsedPoll.poll).toBe(poll)
+    expect(parsedPoll.country).toBe(country)
+    expect(parsedPoll.legalEntity).toBe(legalEntity)
+    expect(parsedPoll.judges).toBe(judges)
+    expect(parsedPoll.deadline?.toUTCString()).toBe(deadline.toUTCString())
+    expect(parsedPoll.options[0]).toEqual(options[0])
+    expect(parsedPoll.options[1]).toEqual(options[1])
+})