Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
| 1 | import { describe, it, expect } from '@effect/vitest'; |
| 2 | import { Effect, Option, Schema } from 'effect'; |
| 3 | import { ProjectKeys, projectKeysFromJSON, projectKeysToJSON } from 'src/models/project-keys'; |
| 4 | |
| 5 | describe('ProjectKeys', () => { |
| 6 | describe('decode from JSON', () => { |
| 7 | it.effect('decodes valid JSON with required fields only', () => |
| 8 | Effect.gen(function* () { |
| 9 | const json = JSON.stringify({ org_id: 'abc', project_id: 'def' }); |
| 10 | |
| 11 | const result = yield* projectKeysFromJSON(json); |
| 12 | |
| 13 | expect(result.orgId).toBe('abc'); |
| 14 | expect(result.projectId).toBe('def'); |
| 15 | expect(Option.isNone(result.projectName)).toBe(true); |
| 16 | expect(Option.isNone(result.orgName)).toBe(true); |
| 17 | expect(Option.isNone(result.email)).toBe(true); |
| 18 | expect(Option.isNone(result.testUserId)).toBe(true); |
| 19 | }) |
| 20 | ); |
| 21 | |
| 22 | it.effect('decodes valid JSON with all fields', () => |
| 23 | Effect.gen(function* () { |
| 24 | const json = JSON.stringify({ |
| 25 | org_id: 'abc', |
| 26 | project_id: 'def', |
| 27 | project_name: 'My Project', |
| 28 | org_name: 'My Org', |
| 29 | email: 'test@test.com', |
| 30 | test_user_id: 'pg-test-user-123', |
| 31 | }); |
| 32 | |
| 33 | const result = yield* projectKeysFromJSON(json); |
| 34 | |
| 35 | expect(result.orgId).toBe('abc'); |
| 36 | expect(result.projectId).toBe('def'); |
| 37 | expect(Option.getOrUndefined(result.projectName)).toBe('My Project'); |
| 38 | expect(Option.getOrUndefined(result.orgName)).toBe('My Org'); |
| 39 | expect(Option.getOrUndefined(result.email)).toBe('test@test.com'); |
| 40 | expect(Option.getOrUndefined(result.testUserId)).toBe('pg-test-user-123'); |
| 41 | }) |
| 42 | ); |
| 43 | |
| 44 | it.effect('decodes null optional fields as Option.none()', () => |
| 45 | Effect.gen(function* () { |
| 46 | const json = JSON.stringify({ |
| 47 | org_id: 'abc', |
| 48 | project_id: 'def', |
| 49 | project_name: null, |
| 50 | org_name: null, |
| 51 | email: null, |
| 52 | test_user_id: null, |
| 53 | }); |
| 54 | |
| 55 | const result = yield* projectKeysFromJSON(json); |
| 56 | |
| 57 | expect(result.orgId).toBe('abc'); |
| 58 | expect(result.projectId).toBe('def'); |
| 59 | expect(Option.isNone(result.projectName)).toBe(true); |
| 60 | expect(Option.isNone(result.orgName)).toBe(true); |
| 61 | expect(Option.isNone(result.email)).toBe(true); |
| 62 | expect(Option.isNone(result.testUserId)).toBe(true); |
| 63 | }) |
| 64 | ); |
| 65 | |
| 66 | it.effect('ignores extra keys in decoded JSON', () => |
| 67 | Effect.gen(function* () { |
| 68 | const json = JSON.stringify({ |
| 69 | org_id: 'abc', |
| 70 | project_id: 'def', |
| 71 | future_field: 'unknown', |
| 72 | }); |
| 73 | |
| 74 | // Should not fail -- onExcessProperty: 'ignore' silently drops extra keys |
| 75 | const result = yield* projectKeysFromJSON(json); |
| 76 | expect(result.orgId).toBe('abc'); |
| 77 | expect(result.projectId).toBe('def'); |
| 78 | }) |
| 79 | ); |
| 80 | |
| 81 | it.effect('fails on missing org_id', () => |
| 82 | Effect.gen(function* () { |
| 83 | const json = JSON.stringify({ project_id: 'def' }); |
| 84 | const error = yield* Effect.flip(projectKeysFromJSON(json)); |
| 85 | expect(error).toBeInstanceOf(Schema.SchemaError); |
| 86 | }) |
| 87 | ); |
| 88 | |
| 89 | it.effect('fails on missing project_id', () => |
| 90 | Effect.gen(function* () { |
| 91 | const json = JSON.stringify({ org_id: 'abc' }); |
| 92 | const error = yield* Effect.flip(projectKeysFromJSON(json)); |
| 93 | expect(error).toBeInstanceOf(Schema.SchemaError); |
| 94 | }) |
| 95 | ); |
| 96 | |
| 97 | it.effect('fails on non-string org_id', () => |
| 98 | Effect.gen(function* () { |
| 99 | const json = JSON.stringify({ org_id: 123, project_id: 'def' }); |
| 100 | const error = yield* Effect.flip(projectKeysFromJSON(json)); |
| 101 | expect(error).toBeInstanceOf(Schema.SchemaError); |
| 102 | }) |
| 103 | ); |
| 104 | |
| 105 | it.effect('fails on non-string project_id', () => |
| 106 | Effect.gen(function* () { |
| 107 | const json = JSON.stringify({ org_id: 'abc', project_id: true }); |
| 108 | const error = yield* Effect.flip(projectKeysFromJSON(json)); |
| 109 | expect(error).toBeInstanceOf(Schema.SchemaError); |
| 110 | }) |
| 111 | ); |
| 112 | |
| 113 | it.effect('fails on invalid JSON', () => |
| 114 | Effect.gen(function* () { |
| 115 | const error = yield* Effect.flip(projectKeysFromJSON('not json')); |
| 116 | expect(error).toBeInstanceOf(Schema.SchemaError); |
| 117 | }) |
| 118 | ); |
| 119 | |
| 120 | it.effect('accepts empty strings for required fields', () => |
| 121 | Effect.gen(function* () { |
| 122 | const json = JSON.stringify({ org_id: '', project_id: '' }); |
| 123 | const result = yield* projectKeysFromJSON(json); |
| 124 | expect(result.orgId).toBe(''); |
| 125 | expect(result.projectId).toBe(''); |
| 126 | }) |
| 127 | ); |
| 128 | }); |
| 129 | |
| 130 | describe('encode to JSON', () => { |
| 131 | it.effect('encodes ProjectKeys with Some values', () => |
| 132 | Effect.gen(function* () { |
| 133 | const keys: ProjectKeys = { |
| 134 | orgId: 'abc', |
| 135 | projectId: 'def', |
| 136 | projectName: Option.some('My Project'), |
| 137 | orgName: Option.some('My Org'), |
| 138 | email: Option.some('test@test.com'), |
| 139 | testUserId: Option.some('pg-test-user-123'), |
| 140 | }; |
| 141 | |
| 142 | const json = yield* projectKeysToJSON(keys); |
| 143 | const parsed = JSON.parse(json); |
| 144 | |
| 145 | expect(parsed.org_id).toBe('abc'); |
| 146 | expect(parsed.project_id).toBe('def'); |
| 147 | expect(parsed.project_name).toBe('My Project'); |
| 148 | expect(parsed.org_name).toBe('My Org'); |
| 149 | expect(parsed.email).toBe('test@test.com'); |
| 150 | expect(parsed.test_user_id).toBe('pg-test-user-123'); |
| 151 | }) |
| 152 | ); |
| 153 | |
| 154 | it.effect('encodes None optional fields as null', () => |
| 155 | Effect.gen(function* () { |
| 156 | const keys: ProjectKeys = { |
| 157 | orgId: 'abc', |
| 158 | projectId: 'def', |
| 159 | projectName: Option.none(), |
| 160 | orgName: Option.none(), |
| 161 | email: Option.none(), |
| 162 | testUserId: Option.none(), |
| 163 | }; |
| 164 | |
| 165 | const json = yield* projectKeysToJSON(keys); |
| 166 | const parsed = JSON.parse(json); |
| 167 | |
| 168 | expect(parsed.org_id).toBe('abc'); |
| 169 | expect(parsed.project_id).toBe('def'); |
| 170 | expect(parsed.project_name).toBeNull(); |
| 171 | expect(parsed.org_name).toBeNull(); |
| 172 | expect(parsed.email).toBeNull(); |
| 173 | expect(parsed.test_user_id).toBeNull(); |
| 174 | }) |
| 175 | ); |
| 176 | }); |
| 177 | |
| 178 | describe('round-trip', () => { |
| 179 | it.effect('encode then decode preserves Some values', () => |
| 180 | Effect.gen(function* () { |
| 181 | const original: ProjectKeys = { |
| 182 | orgId: 'org-123', |
| 183 | projectId: 'proj-456', |
| 184 | projectName: Option.some('Test Project'), |
| 185 | orgName: Option.some('Test Org'), |
| 186 | email: Option.some('user@example.com'), |
| 187 | testUserId: Option.some('pg-test-user-123'), |
| 188 | }; |
| 189 | |
| 190 | const json = yield* projectKeysToJSON(original); |
| 191 | const decoded = yield* projectKeysFromJSON(json); |
| 192 | |
| 193 | expect(decoded.orgId).toBe(original.orgId); |
| 194 | expect(decoded.projectId).toBe(original.projectId); |
| 195 | expect(Option.getOrUndefined(decoded.projectName)).toBe( |
| 196 | Option.getOrUndefined(original.projectName) |
| 197 | ); |
| 198 | expect(Option.getOrUndefined(decoded.orgName)).toBe( |
| 199 | Option.getOrUndefined(original.orgName) |
| 200 | ); |
| 201 | expect(Option.getOrUndefined(decoded.email)).toBe(Option.getOrUndefined(original.email)); |
| 202 | expect(Option.getOrUndefined(decoded.testUserId)).toBe( |
| 203 | Option.getOrUndefined(original.testUserId) |
| 204 | ); |
| 205 | }) |
| 206 | ); |
| 207 | |
| 208 | it.effect('encode then decode preserves None values', () => |
| 209 | Effect.gen(function* () { |
| 210 | const original: ProjectKeys = { |
| 211 | orgId: 'org-123', |
| 212 | projectId: 'proj-456', |
| 213 | projectName: Option.none(), |
| 214 | orgName: Option.none(), |
| 215 | email: Option.none(), |
| 216 | testUserId: Option.none(), |
| 217 | }; |
| 218 | |
| 219 | const json = yield* projectKeysToJSON(original); |
| 220 | const decoded = yield* projectKeysFromJSON(json); |
| 221 | |
| 222 | expect(decoded.orgId).toBe(original.orgId); |
| 223 | expect(decoded.projectId).toBe(original.projectId); |
| 224 | expect(Option.isNone(decoded.projectName)).toBe(true); |
| 225 | expect(Option.isNone(decoded.orgName)).toBe(true); |
| 226 | expect(Option.isNone(decoded.email)).toBe(true); |
| 227 | expect(Option.isNone(decoded.testUserId)).toBe(true); |
| 228 | }) |
| 229 | ); |
| 230 | }); |
| 231 | }); |