FilesExpand file tree

main

/

githubServiceComments.test.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

111 lines (98 loc) · 4.24 KB

main

/

githubServiceComments.test.ts

Copy path

Top

File metadata and controls

• Code
• Blame

111 lines (98 loc) · 4.24 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

import { describe, expect, test } from "bun:test"

import { Effect, Layer, Schema } from "effect"

import { CommandRunner, type CommandResult } from "../src/services/CommandRunner.ts"

import { GitHubService } from "../src/services/GitHubService.ts"

interface RecordedCall {

readonly command: string

readonly args: readonly string[]

}

const fakeCommandRunner = (response: string, recorder: RecordedCall[]) =>

Layer.succeed(

CommandRunner,

CommandRunner.of({

run: (command, args) => {

recorder.push({ command, args: [...args] })

const result: CommandResult = { stdout: response, stderr: "", exitCode: 0 }

return Effect.succeed(result)

},

runSchema: <S extends Schema.Top>(schema: S, command: string, args: readonly string[]) => {

recorder.push({ command, args: [...args] })

return Effect.try({

try: () => JSON.parse(response) as unknown,

catch: (cause) => cause,

}).pipe(Effect.flatMap((value) => Schema.decodeUnknownEffect(schema)(value))) as Effect.Effect<S["Type"], never, S["DecodingServices"]>

},

}),

)

const baseIssueResponse = JSON.stringify({

id: 9001,

user: { login: "kit" },

body: "Updated body",

created_at: "2026-01-01T00:00:00Z",

updated_at: "2026-01-02T00:00:00Z",

html_url: "https://github.com/owner/repo/issues/1#issuecomment-9001",

url: "https://api.github.com/repos/owner/repo/issues/comments/9001",

})

const baseReviewResponse = JSON.stringify({

id: 7777,

node_id: "PRRC_abc",

user: { login: "kit" },

body: "Updated review body",

created_at: "2026-01-01T00:00:00Z",

updated_at: "2026-01-02T00:00:00Z",

path: "src/foo.ts",

line: 42,

original_line: 42,

side: "RIGHT",

in_reply_to_id: null,

html_url: "https://github.com/owner/repo/pull/1#discussion_r7777",

url: "https://api.github.com/repos/owner/repo/pulls/comments/7777",

})

const runWith = <A>(effect: Effect.Effect<A, unknown, GitHubService>, layer: Layer.Layer<GitHubService>) =>

Effect.runPromise(effect.pipe(Effect.provide(layer)) as Effect.Effect<A>)

describe("GitHubService comment edit/delete", () => {

test("editPullRequestIssueComment PATCHes the issue comments endpoint", async () => {

const recorder: RecordedCall[] = []

const layer = GitHubService.layerNoDeps.pipe(Layer.provide(fakeCommandRunner(baseIssueResponse, recorder)))

const updated = await runWith(

GitHubService.use((github) => github.editPullRequestIssueComment("owner/repo", "9001", "Updated body")),

layer,

)

expect(updated._tag).toBe("comment")

expect(updated.body).toBe("Updated body")

expect(updated.id).toBe("9001")

expect(recorder).toHaveLength(1)

expect(recorder[0]!.command).toBe("gh")

expect(recorder[0]!.args).toEqual(["api", "--method", "PATCH", "repos/owner/repo/issues/comments/9001", "-f", "body=Updated body"])

})

test("editReviewComment PATCHes the pulls comments endpoint", async () => {

const recorder: RecordedCall[] = []

const layer = GitHubService.layerNoDeps.pipe(Layer.provide(fakeCommandRunner(baseReviewResponse, recorder)))

const updated = await runWith(

GitHubService.use((github) => github.editReviewComment("owner/repo", "7777", "Updated review body")),

layer,

)

expect(updated._tag).toBe("review-comment")

expect(updated.body).toBe("Updated review body")

expect(recorder[0]!.args).toEqual(["api", "--method", "PATCH", "repos/owner/repo/pulls/comments/7777", "-f", "body=Updated review body"])

})

test("deletePullRequestIssueComment DELETEs the issue comments endpoint", async () => {

const recorder: RecordedCall[] = []

const layer = GitHubService.layerNoDeps.pipe(Layer.provide(fakeCommandRunner("", recorder)))

await runWith(

GitHubService.use((github) => github.deletePullRequestIssueComment("owner/repo", "9001")),

layer,

)

expect(recorder).toHaveLength(1)

expect(recorder[0]!.args).toEqual(["api", "--method", "DELETE", "repos/owner/repo/issues/comments/9001"])

})

test("deleteReviewComment DELETEs the pulls comments endpoint", async () => {

const recorder: RecordedCall[] = []

const layer = GitHubService.layerNoDeps.pipe(Layer.provide(fakeCommandRunner("", recorder)))

await runWith(

GitHubService.use((github) => github.deleteReviewComment("owner/repo", "7777")),

layer,

)

expect(recorder[0]!.args).toEqual(["api", "--method", "DELETE", "repos/owner/repo/pulls/comments/7777"])

})

})