2020-04-17 01:57:59 +08:00
import * as github from '@actions/github' ;
2021-01-19 18:54:16 +08:00
import { Issue } from '../src/classes/issue' ;
2021-03-05 22:12:18 +08:00
import { IComment } from '../src/interfaces/comment' ;
2021-02-13 19:09:37 +08:00
import { IIssuesProcessorOptions } from '../src/interfaces/issues-processor-options' ;
2021-03-02 04:34:35 +08:00
import { IssuesProcessorMock } from './classes/issues-processor-mock' ;
2021-02-16 19:18:48 +08:00
import { DefaultProcessorOptions } from './constants/default-processor-options' ;
import { generateIssue } from './functions/generate-issue' ;
2020-04-17 01:57:59 +08:00
2020-05-29 21:32:20 +08:00
test ( 'processing an issue with no label will make it stale and close it, if it is old enough only if days-before-close is set to 0' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-16 21:28:29 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 0
} ;
2021-01-19 18:54:16 +08:00
const TestIssueList : Issue [ ] = [
generateIssue ( opts , 1 , 'An issue with no label' , '2020-01-01T17:00:00Z' )
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-16 21:28:29 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2021-01-16 21:28:29 +08:00
} ) ;
2021-01-18 09:22:36 +08:00
test ( 'processing an issue with no label and a start date as ECMAScript epoch in seconds being before the issue creation date will not make it stale nor close it when it is old enough and days-before-close is set to 0' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-01-19 18:54:16 +08:00
const january2000 = 946681200000 ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 0 ,
startDate : january2000.toString ( )
} ;
2021-01-18 09:22:36 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-18 09:22:36 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-18 09:22:36 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'processing an issue with no label and a start date as ECMAScript epoch in seconds being after the issue creation date will not make it stale nor close it when it is old enough and days-before-close is set to 0' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-01-19 18:54:16 +08:00
const january2021 = 1609455600000 ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 0 ,
startDate : january2021.toString ( )
} ;
2021-01-18 09:22:36 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-18 09:22:36 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-18 09:22:36 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'processing an issue with no label and a start date as ECMAScript epoch in milliseconds being before the issue creation date will not make it stale nor close it when it is old enough and days-before-close is set to 0' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-01-19 18:54:16 +08:00
const january2000 = 946681200000000 ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 0 ,
startDate : january2000.toString ( )
} ;
2021-01-18 09:22:36 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-18 09:22:36 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-18 09:22:36 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'processing an issue with no label and a start date as ECMAScript epoch in milliseconds being after the issue creation date will not make it stale nor close it when it is old enough and days-before-close is set to 0' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-01-19 18:54:16 +08:00
const january2021 = 1609455600000 ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 0 ,
startDate : january2021.toString ( )
} ;
2021-01-18 09:22:36 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-18 09:22:36 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-18 09:22:36 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'processing an issue with no label and a start date as ISO 8601 being before the issue creation date will make it stale and close it when it is old enough and days-before-close is set to 0' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-01-19 18:54:16 +08:00
const january2000 = '2000-01-01T00:00:00Z' ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 0 ,
startDate : january2000.toString ( )
} ;
2021-01-18 09:22:36 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-18 09:22:36 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-18 09:22:36 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 1 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 1 ) ;
} ) ;
test ( 'processing an issue with no label and a start date as ISO 8601 being after the issue creation date will not make it stale nor close it when it is old enough and days-before-close is set to 0' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-01-19 18:54:16 +08:00
const january2021 = '2021-01-01T00:00:00Z' ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 0 ,
startDate : january2021.toString ( )
} ;
2021-01-18 09:22:36 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-18 09:22:36 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-18 09:22:36 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'processing an issue with no label and a start date as RFC 2822 being before the issue creation date will make it stale and close it when it is old enough and days-before-close is set to 0' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-01-19 18:54:16 +08:00
const january2000 = 'January 1, 2000 00:00:00' ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 0 ,
startDate : january2000.toString ( )
} ;
2021-01-18 09:22:36 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-18 09:22:36 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-18 09:22:36 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 1 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 1 ) ;
} ) ;
test ( 'processing an issue with no label and a start date as RFC 2822 being after the issue creation date will not make it stale nor close it when it is old enough and days-before-close is set to 0' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-01-19 18:54:16 +08:00
const january2021 = 'January 1, 2021 00:00:00' ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 0 ,
startDate : january2021.toString ( )
} ;
2021-01-18 09:22:36 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-18 09:22:36 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-18 09:22:36 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
2021-01-16 21:28:29 +08:00
test ( 'processing an issue with no label will make it stale and close it, if it is old enough only if days-before-close is set to > 0 and days-before-issue-close is set to 0' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-16 21:28:29 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 1 ,
daysBeforeIssueClose : 0
} ;
2021-01-19 18:54:16 +08:00
const TestIssueList : Issue [ ] = [
generateIssue ( opts , 1 , 'An issue with no label' , '2020-01-01T17:00:00Z' )
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-29 21:32:20 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-17 01:57:59 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
expect ( processor . deletedBranchIssues ) . toHaveLength ( 0 ) ;
2020-05-11 23:15:05 +08:00
} ) ;
2021-01-16 21:28:29 +08:00
test ( 'processing an issue with no label will make it stale and not close it, if it is old enough only if days-before-close is set to > 0 and days-before-issue-close is set to > 0' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-16 21:28:29 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 1 ,
daysBeforeIssueClose : 1
} ;
2021-01-19 18:54:16 +08:00
const TestIssueList : Issue [ ] = [
generateIssue ( opts , 1 , 'An issue with no label' , '2020-01-01T17:00:00Z' )
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-16 21:28:29 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2021-01-16 21:28:29 +08:00
} ) ;
2020-05-29 21:32:20 +08:00
test ( 'processing an issue with no label will make it stale and not close it if days-before-close is set to > 0' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-16 21:28:29 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 15
} ;
2021-01-19 18:54:16 +08:00
const TestIssueList : Issue [ ] = [
generateIssue ( opts , 1 , 'An issue with no label' , '2020-01-01T17:00:00Z' )
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-16 21:28:29 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2021-01-16 21:28:29 +08:00
} ) ;
test ( 'processing an issue with no label will make it stale and not close it if days-before-close is set to -1 and days-before-issue-close is set to > 0' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-16 21:28:29 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : - 1 ,
daysBeforeIssueClose : 15
} ;
2021-01-19 18:54:16 +08:00
const TestIssueList : Issue [ ] = [
generateIssue ( opts , 1 , 'An issue with no label' , '2020-01-01T17:00:00Z' )
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-05-29 21:32:20 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-05-29 21:32:20 +08:00
} ) ;
2020-07-14 04:20:45 +08:00
test ( 'processing an issue with no label will not make it stale if days-before-stale is set to -1' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2020-07-14 04:20:45 +08:00
. . . DefaultProcessorOptions ,
staleIssueMessage : '' ,
daysBeforeStale : - 1
} ;
2021-01-19 18:54:16 +08:00
const TestIssueList : Issue [ ] = [
generateIssue ( opts , 1 , 'An issue with no label' , '2020-01-01T17:00:00Z' )
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-07-14 04:20:45 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-07-14 04:20:45 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-07-14 04:20:45 +08:00
} ) ;
2021-01-16 21:28:29 +08:00
test ( 'processing an issue with no label will not make it stale if days-before-stale and days-before-issue-stale are set to -1' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-16 21:28:29 +08:00
. . . DefaultProcessorOptions ,
staleIssueMessage : '' ,
daysBeforeStale : - 1 ,
daysBeforeIssueStale : - 1
} ;
2021-01-19 18:54:16 +08:00
const TestIssueList : Issue [ ] = [
generateIssue ( opts , 1 , 'An issue with no label' , '2020-01-01T17:00:00Z' )
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-16 21:28:29 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2021-01-16 21:28:29 +08:00
} ) ;
2020-05-11 23:15:05 +08:00
test ( 'processing an issue with no label will make it stale but not close it' , async ( ) = > {
// issue should be from 2 days ago so it will be
// stale but not close-able, based on default settings
2021-02-13 19:09:37 +08:00
const issueDate = new Date ( ) ;
2020-05-11 23:15:05 +08:00
issueDate . setDate ( issueDate . getDate ( ) - 2 ) ;
const TestIssueList : Issue [ ] = [
2021-01-19 18:54:16 +08:00
generateIssue (
DefaultProcessorOptions ,
1 ,
'An issue with no label' ,
issueDate . toDateString ( )
)
2020-05-11 23:15:05 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 23:15:05 +08:00
DefaultProcessorOptions ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-05-11 23:15:05 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-04-17 01:57:59 +08:00
} ) ;
test ( 'processing a stale issue will close it' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 30
} ;
2020-04-17 01:57:59 +08:00
const TestIssueList : Issue [ ] = [
2020-05-11 22:46:03 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-05-11 22:46:03 +08:00
1 ,
'A stale issue that should be closed' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
false ,
[ 'Stale' ]
)
2020-04-17 01:57:59 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-17 01:57:59 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2020-04-17 01:57:59 +08:00
} ) ;
2021-01-15 19:51:24 +08:00
test ( 'processing a stale issue containing a space in the label will close it' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
staleIssueLabel : 'state: stale'
} ;
2021-01-15 19:51:24 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-15 19:51:24 +08:00
1 ,
'A stale issue that should be closed' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2021-01-15 19:51:24 +08:00
false ,
[ 'state: stale' ]
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-15 19:51:24 +08:00
opts ,
2021-01-15 20:35:41 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-15 19:51:24 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2021-01-15 19:51:24 +08:00
} ) ;
test ( 'processing a stale issue containing a slash in the label will close it' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
staleIssueLabel : 'lifecycle/stale'
} ;
2021-01-15 19:51:24 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-15 19:51:24 +08:00
1 ,
'A stale issue that should be closed' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2021-01-15 19:51:24 +08:00
false ,
[ 'lifecycle/stale' ]
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-15 19:51:24 +08:00
opts ,
2021-01-15 20:35:41 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-15 19:51:24 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2021-01-15 19:51:24 +08:00
} ) ;
2021-01-16 21:28:29 +08:00
test ( 'processing a stale issue will close it when days-before-issue-stale override days-before-stale' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 30 ,
daysBeforeIssueStale : 30
} ;
2021-01-16 21:28:29 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-16 21:28:29 +08:00
1 ,
'A stale issue that should be closed' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2021-01-16 21:28:29 +08:00
false ,
[ 'Stale' ]
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-16 21:28:29 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2021-01-16 21:28:29 +08:00
} ) ;
2020-04-17 01:57:59 +08:00
test ( 'processing a stale PR will close it' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 30
} ;
2020-04-17 01:57:59 +08:00
const TestIssueList : Issue [ ] = [
2020-05-11 22:46:03 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-05-11 22:46:03 +08:00
1 ,
'A stale PR that should be closed' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
true ,
[ 'Stale' ]
)
2020-04-17 01:57:59 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-16 21:28:29 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2021-01-16 21:28:29 +08:00
} ) ;
test ( 'processing a stale PR will close it when days-before-pr-stale override days-before-stale' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
daysBeforeClose : 30 ,
daysBeforePrClose : 30
} ;
2021-01-16 21:28:29 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-16 21:28:29 +08:00
1 ,
'A stale PR that should be closed' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2021-01-16 21:28:29 +08:00
true ,
[ 'Stale' ]
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-07-14 04:20:45 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2020-07-14 04:20:45 +08:00
} ) ;
test ( 'processing a stale issue will close it even if configured not to mark as stale' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = {
. . . DefaultProcessorOptions ,
daysBeforeStale : - 1 ,
staleIssueMessage : ''
} ;
2020-07-14 04:20:45 +08:00
const TestIssueList : Issue [ ] = [
2021-01-18 09:22:36 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
[ 'Stale' ]
)
2020-07-14 04:20:45 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-07-14 04:20:45 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-07-14 04:20:45 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2020-07-14 04:20:45 +08:00
} ) ;
2021-01-16 21:28:29 +08:00
test ( 'processing a stale issue will close it even if configured not to mark as stale when days-before-issue-stale override days-before-stale' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = {
. . . DefaultProcessorOptions ,
daysBeforeStale : 0 ,
daysBeforeIssueStale : - 1 ,
staleIssueMessage : ''
} ;
2021-01-16 21:28:29 +08:00
const TestIssueList : Issue [ ] = [
2021-01-18 09:22:36 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
[ 'Stale' ]
)
2021-01-16 21:28:29 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-16 21:28:29 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2021-01-16 21:28:29 +08:00
} ) ;
2020-07-14 04:20:45 +08:00
test ( 'processing a stale PR will close it even if configured not to mark as stale' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = {
. . . DefaultProcessorOptions ,
daysBeforeStale : - 1 ,
stalePrMessage : ''
} ;
2020-07-14 04:20:45 +08:00
const TestIssueList : Issue [ ] = [
2021-01-18 09:22:36 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
true ,
[ 'Stale' ]
)
2020-07-14 04:20:45 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-07-14 04:20:45 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-17 01:57:59 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2020-04-17 01:57:59 +08:00
} ) ;
2021-01-16 21:28:29 +08:00
test ( 'processing a stale PR will close it even if configured not to mark as stale when days-before-pr-stale override days-before-stale' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = {
. . . DefaultProcessorOptions ,
daysBeforeStale : 0 ,
daysBeforePrStale : - 1 ,
stalePrMessage : ''
} ;
2021-01-16 21:28:29 +08:00
const TestIssueList : Issue [ ] = [
2021-01-18 09:22:36 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'An issue with no label' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
true ,
[ 'Stale' ]
)
2021-01-16 21:28:29 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-16 21:28:29 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-16 21:28:29 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
2021-01-16 21:28:29 +08:00
} ) ;
2020-04-27 19:53:58 +08:00
test ( 'closed issues will not be marked stale' , async ( ) = > {
const TestIssueList : Issue [ ] = [
2020-05-11 22:46:03 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
DefaultProcessorOptions ,
2020-05-11 22:46:03 +08:00
1 ,
'A closed issue that will not be marked' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
false ,
[ ] ,
true
)
2020-04-27 19:53:58 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
DefaultProcessorOptions ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ]
2020-04-27 19:53:58 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-04-27 19:53:58 +08:00
} ) ;
test ( 'stale closed issues will not be closed' , async ( ) = > {
const TestIssueList : Issue [ ] = [
2020-05-11 22:46:03 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
DefaultProcessorOptions ,
2020-05-11 22:46:03 +08:00
1 ,
'A stale closed issue' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
false ,
[ 'Stale' ] ,
true
)
2020-04-27 19:53:58 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
DefaultProcessorOptions ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-27 19:53:58 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-04-27 19:53:58 +08:00
} ) ;
test ( 'closed prs will not be marked stale' , async ( ) = > {
const TestIssueList : Issue [ ] = [
2020-05-11 22:46:03 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
DefaultProcessorOptions ,
2020-05-11 22:46:03 +08:00
1 ,
'A closed PR that will not be marked' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
true ,
[ ] ,
true
)
2020-04-27 19:53:58 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
DefaultProcessorOptions ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-27 19:53:58 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-04-27 19:53:58 +08:00
} ) ;
test ( 'stale closed prs will not be closed' , async ( ) = > {
const TestIssueList : Issue [ ] = [
2020-05-11 22:46:03 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
DefaultProcessorOptions ,
2020-05-11 22:46:03 +08:00
1 ,
'A stale closed PR that will not be closed again' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
true ,
[ 'Stale' ] ,
true
)
2020-04-27 19:53:58 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
DefaultProcessorOptions ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-27 19:53:58 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-04-27 19:53:58 +08:00
} ) ;
test ( 'locked issues will not be marked stale' , async ( ) = > {
const TestIssueList : Issue [ ] = [
2020-05-11 22:46:03 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
DefaultProcessorOptions ,
2020-05-11 22:46:03 +08:00
1 ,
'A locked issue that will not be stale' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
false ,
[ ] ,
false ,
true
)
2020-04-27 19:53:58 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-15 20:20:32 +08:00
DefaultProcessorOptions ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] )
2020-04-27 19:53:58 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-04-27 19:53:58 +08:00
} ) ;
test ( 'stale locked issues will not be closed' , async ( ) = > {
const TestIssueList : Issue [ ] = [
2020-05-11 22:46:03 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
DefaultProcessorOptions ,
2020-05-11 22:46:03 +08:00
1 ,
'A stale locked issue that will not be closed' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
false ,
[ 'Stale' ] ,
false ,
true
)
2020-04-27 19:53:58 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
DefaultProcessorOptions ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-27 19:53:58 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-04-27 19:53:58 +08:00
} ) ;
test ( 'locked prs will not be marked stale' , async ( ) = > {
const TestIssueList : Issue [ ] = [
2020-05-11 22:46:03 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
DefaultProcessorOptions ,
2020-05-11 22:46:03 +08:00
1 ,
'A locked PR that will not be marked stale' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
true ,
[ ] ,
false ,
true
)
2020-04-27 19:53:58 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-15 20:20:32 +08:00
DefaultProcessorOptions ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] )
2020-04-27 19:53:58 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-04-27 19:53:58 +08:00
} ) ;
test ( 'stale locked prs will not be closed' , async ( ) = > {
const TestIssueList : Issue [ ] = [
2020-05-11 22:46:03 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
DefaultProcessorOptions ,
2020-05-11 22:46:03 +08:00
1 ,
'A stale locked PR that will not be closed' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
true ,
[ 'Stale' ] ,
false ,
true
)
2020-04-27 19:53:58 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
DefaultProcessorOptions ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-27 19:53:58 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-04-27 19:53:58 +08:00
} ) ;
2020-04-17 01:57:59 +08:00
test ( 'exempt issue labels will not be marked stale' , async ( ) = > {
2021-01-17 09:13:19 +08:00
expect . assertions ( 3 ) ;
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptIssueLabels = 'Exempt' ;
2020-04-17 01:57:59 +08:00
const TestIssueList : Issue [ ] = [
2021-01-18 09:22:36 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
[ 'Exempt' ]
)
2020-04-17 01:57:59 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-17 01:57:59 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-01-17 09:13:19 +08:00
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . removedLabelIssues . length ) . toStrictEqual ( 0 ) ;
2020-04-17 01:57:59 +08:00
} ) ;
test ( 'exempt issue labels will not be marked stale (multi issue label with spaces)' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptIssueLabels = 'Exempt, Cool, None' ;
2020-04-17 01:57:59 +08:00
const TestIssueList : Issue [ ] = [
2021-01-18 09:22:36 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
[ 'Cool' ]
)
2020-04-17 01:57:59 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-17 01:57:59 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2020-04-17 01:57:59 +08:00
} ) ;
test ( 'exempt issue labels will not be marked stale (multi issue label)' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptIssueLabels = 'Exempt,Cool,None' ;
2020-04-17 01:57:59 +08:00
const TestIssueList : Issue [ ] = [
2021-01-18 09:22:36 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
[ 'Cool' ]
)
2020-04-17 01:57:59 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-17 01:57:59 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
2020-04-17 01:57:59 +08:00
} ) ;
test ( 'exempt pr labels will not be marked stale' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptIssueLabels = 'Cool' ;
2020-04-17 01:57:59 +08:00
const TestIssueList : Issue [ ] = [
2021-01-18 09:22:36 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
[ 'Cool' ]
) ,
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
2 ,
'My first PR' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
true ,
[ 'Cool' ]
) ,
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
3 ,
'Another issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false
)
2020-04-17 01:57:59 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-17 01:57:59 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 2 ) ; // PR should get processed even though it has an exempt **issue** label
2019-08-04 09:34:59 +08:00
} ) ;
2020-04-17 02:23:28 +08:00
2021-01-17 09:13:19 +08:00
test ( 'exempt issue labels will not be marked stale and will remove the existing stale label' , async ( ) = > {
expect . assertions ( 3 ) ;
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptIssueLabels = 'Exempt' ;
2021-01-17 09:13:19 +08:00
const TestIssueList : Issue [ ] = [
2021-01-18 09:22:36 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
[ 'Exempt' , 'Stale' ]
)
2021-01-17 09:13:19 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-17 09:13:19 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [
2021-01-17 09:13:19 +08:00
{
user : {
login : 'notme' ,
type : 'User'
}
}
] , // return a fake comment to indicate there was an update
2021-03-02 04:34:35 +08:00
async ( ) = > new Date ( ) . toDateString ( )
2021-01-17 09:13:19 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . removedLabelIssues . length ) . toStrictEqual ( 1 ) ;
} ) ;
2020-04-17 02:23:28 +08:00
test ( 'stale issues should not be closed if days is set to -1' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . daysBeforeClose = - 1 ;
2020-04-17 02:23:28 +08:00
const TestIssueList : Issue [ ] = [
2021-01-18 09:22:36 +08:00
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
[ 'Stale' ]
) ,
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
2 ,
'My first PR' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
true ,
[ 'Stale' ]
) ,
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-18 09:22:36 +08:00
3 ,
'Another issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
[ 'Stale' ]
)
2020-04-17 02:23:28 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-04-17 02:23:28 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
2020-04-17 02:23:28 +08:00
} ) ;
2020-05-11 22:46:03 +08:00
test ( 'stale label should be removed if a comment was added to a stale issue' , async ( ) = > {
2021-04-30 21:14:51 +08:00
const opts = { . . . DefaultProcessorOptions , removeStaleWhenUpdated : true } ;
2020-05-11 22:46:03 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-05-11 22:46:03 +08:00
1 ,
'An issue that should un-stale' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-11 22:46:03 +08:00
false ,
[ 'Stale' ]
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-11 22:46:03 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [
2021-01-16 21:28:29 +08:00
{
user : {
login : 'notme' ,
type : 'User'
}
}
] , // return a fake comment to indicate there was an update
2021-03-02 04:34:35 +08:00
async ( ) = > new Date ( ) . toDateString ( )
2020-05-11 22:46:03 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 1 ) ;
2020-05-11 22:46:03 +08:00
} ) ;
2020-05-19 08:08:31 +08:00
2020-05-19 08:33:59 +08:00
test ( 'stale label should not be removed if a comment was added by the bot (and the issue should be closed)' , async ( ) = > {
2021-04-30 21:14:51 +08:00
const opts = { . . . DefaultProcessorOptions , removeStaleWhenUpdated : true } ;
2020-05-19 08:33:59 +08:00
github . context . actor = 'abot' ;
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-05-19 08:33:59 +08:00
1 ,
'An issue that should stay stale' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2020-05-19 08:33:59 +08:00
false ,
[ 'Stale' ]
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-19 08:33:59 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [
2021-01-16 21:28:29 +08:00
{
user : {
login : 'abot' ,
type : 'User'
}
}
] , // return a fake comment to indicate there was an update by the bot
2021-03-02 04:34:35 +08:00
async ( ) = > new Date ( ) . toDateString ( )
2020-05-19 08:33:59 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
2020-05-19 08:33:59 +08:00
} ) ;
2021-01-15 19:51:24 +08:00
test ( 'stale label containing a space should be removed if a comment was added to a stale issue' , async ( ) = > {
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-01-19 18:54:16 +08:00
. . . DefaultProcessorOptions ,
removeStaleWhenUpdated : true ,
staleIssueLabel : 'stat: stale'
} ;
2021-01-15 19:51:24 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-15 19:51:24 +08:00
1 ,
'An issue that should un-stale' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2021-01-15 19:51:24 +08:00
false ,
[ 'stat: stale' ]
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-15 19:51:24 +08:00
opts ,
2021-01-15 20:35:41 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ { user : { login : 'notme' , type : 'User' } } ] , // return a fake comment to indicate there was an update
async ( ) = > new Date ( ) . toDateString ( )
2021-01-15 19:51:24 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 1 ) ;
2021-01-15 19:51:24 +08:00
} ) ;
2020-05-19 08:08:31 +08:00
test ( 'stale issues should not be closed until after the closed number of days' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . daysBeforeStale = 5 ; // stale after 5 days
opts . daysBeforeClose = 1 ; // closes after 6 days
2021-02-13 19:09:37 +08:00
const lastUpdate = new Date ( ) ;
2020-05-19 08:08:31 +08:00
lastUpdate . setDate ( lastUpdate . getDate ( ) - 5 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-05-19 08:08:31 +08:00
1 ,
'An issue that should be marked stale but not closed' ,
lastUpdate . toString ( ) ,
2021-01-18 09:22:36 +08:00
lastUpdate . toString ( ) ,
2020-05-19 08:08:31 +08:00
false
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-19 08:08:31 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-05-19 08:08:31 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
2020-05-19 08:08:31 +08:00
} ) ;
test ( 'stale issues should be closed if the closed nubmer of days (additive) is also passed' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . daysBeforeStale = 5 ; // stale after 5 days
opts . daysBeforeClose = 1 ; // closes after 6 days
2021-02-13 19:09:37 +08:00
const lastUpdate = new Date ( ) ;
2020-05-19 08:08:31 +08:00
lastUpdate . setDate ( lastUpdate . getDate ( ) - 7 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-05-19 08:08:31 +08:00
1 ,
'An issue that should be stale and closed' ,
lastUpdate . toString ( ) ,
2021-01-18 09:22:36 +08:00
lastUpdate . toString ( ) ,
2020-05-19 08:08:31 +08:00
false ,
[ 'Stale' ]
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-19 08:08:31 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-05-19 08:08:31 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
2020-05-19 08:08:31 +08:00
} ) ;
2020-05-26 21:16:38 +08:00
test ( 'stale issues should not be closed until after the closed number of days (long)' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . daysBeforeStale = 5 ; // stale after 5 days
opts . daysBeforeClose = 20 ; // closes after 25 days
2021-02-13 19:09:37 +08:00
const lastUpdate = new Date ( ) ;
2020-05-26 21:16:38 +08:00
lastUpdate . setDate ( lastUpdate . getDate ( ) - 10 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-05-26 21:16:38 +08:00
1 ,
'An issue that should be marked stale but not closed' ,
lastUpdate . toString ( ) ,
2021-01-18 09:22:36 +08:00
lastUpdate . toString ( ) ,
2020-05-26 21:16:38 +08:00
false
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-05-26 21:16:38 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-05-26 21:16:38 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
2020-05-26 21:16:38 +08:00
} ) ;
2020-07-24 20:08:48 +08:00
2021-05-26 02:14:22 +08:00
test ( 'skips stale message on issues when stale-issue-message is empty' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . daysBeforeStale = 5 ; // stale after 5 days
opts . daysBeforeClose = 20 ; // closes after 25 days
2021-05-26 02:14:22 +08:00
opts . staleIssueMessage = '' ;
2021-02-13 19:09:37 +08:00
const lastUpdate = new Date ( ) ;
2020-07-24 20:08:48 +08:00
lastUpdate . setDate ( lastUpdate . getDate ( ) - 10 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-07-24 20:08:48 +08:00
1 ,
'An issue that should be marked stale but not closed' ,
lastUpdate . toString ( ) ,
2021-01-18 09:22:36 +08:00
lastUpdate . toString ( ) ,
2020-07-24 20:08:48 +08:00
false
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-07-24 20:08:48 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-07-24 20:08:48 +08:00
) ;
// for sake of testing, mocking private function
2021-01-17 09:13:19 +08:00
const markSpy = jest . spyOn ( processor as any , '_markStale' ) ;
2020-07-24 20:08:48 +08:00
await processor . processIssues ( 1 ) ;
// issue should be staled
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
2020-07-24 20:08:48 +08:00
// comment should not be created
expect ( markSpy ) . toHaveBeenCalledWith (
TestIssueList [ 0 ] ,
opts . staleIssueMessage ,
opts . staleIssueLabel ,
// this option is skipMessage
true
) ;
} ) ;
2021-05-26 02:14:22 +08:00
test ( 'send stale message on issues when stale-issue-message is not empty' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . daysBeforeStale = 5 ; // stale after 5 days
opts . daysBeforeClose = 20 ; // closes after 25 days
2021-05-26 02:14:22 +08:00
opts . staleIssueMessage = 'dummy issue message' ;
2021-02-13 19:09:37 +08:00
const lastUpdate = new Date ( ) ;
2020-07-24 20:08:48 +08:00
lastUpdate . setDate ( lastUpdate . getDate ( ) - 10 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-07-24 20:08:48 +08:00
1 ,
'An issue that should be marked stale but not closed' ,
lastUpdate . toString ( ) ,
2021-01-18 09:22:36 +08:00
lastUpdate . toString ( ) ,
2021-05-26 02:14:22 +08:00
false
2020-07-24 20:08:48 +08:00
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-07-24 20:08:48 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-07-24 20:08:48 +08:00
) ;
// for sake of testing, mocking private function
2021-01-17 09:13:19 +08:00
const markSpy = jest . spyOn ( processor as any , '_markStale' ) ;
2020-07-24 20:08:48 +08:00
await processor . processIssues ( 1 ) ;
// issue should be staled
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
2020-07-24 20:08:48 +08:00
// comment should not be created
expect ( markSpy ) . toHaveBeenCalledWith (
TestIssueList [ 0 ] ,
2021-05-26 02:14:22 +08:00
opts . staleIssueMessage ,
opts . staleIssueLabel ,
2020-07-24 20:08:48 +08:00
// this option is skipMessage
2021-05-26 02:14:22 +08:00
false
2020-07-24 20:08:48 +08:00
) ;
} ) ;
2021-05-26 02:14:22 +08:00
test ( 'skips stale message on prs when stale-pr-message is empty' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . daysBeforeStale = 5 ; // stale after 5 days
opts . daysBeforeClose = 20 ; // closes after 25 days
2021-05-26 02:14:22 +08:00
opts . stalePrMessage = '' ;
2021-02-13 19:09:37 +08:00
const lastUpdate = new Date ( ) ;
2020-07-24 20:08:48 +08:00
lastUpdate . setDate ( lastUpdate . getDate ( ) - 10 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-07-24 20:08:48 +08:00
1 ,
'An issue that should be marked stale but not closed' ,
lastUpdate . toString ( ) ,
2021-01-18 09:22:36 +08:00
lastUpdate . toString ( ) ,
2021-05-26 02:14:22 +08:00
true
2020-07-24 20:08:48 +08:00
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-07-24 20:08:48 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-07-24 20:08:48 +08:00
) ;
2021-05-26 02:14:22 +08:00
// for sake of testing, mocking private function
const markSpy = jest . spyOn ( processor as any , '_markStale' ) ;
2020-07-24 20:08:48 +08:00
await processor . processIssues ( 1 ) ;
// issue should be staled
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
2021-05-26 02:14:22 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
// comment should not be created
expect ( markSpy ) . toHaveBeenCalledWith (
TestIssueList [ 0 ] ,
opts . stalePrMessage ,
opts . stalePrLabel ,
// this option is skipMessage
true
) ;
2020-07-24 20:08:48 +08:00
} ) ;
2021-05-26 02:14:22 +08:00
test ( 'send stale message on prs when stale-pr-message is not empty' , async ( ) = > {
2021-01-19 18:54:16 +08:00
const opts = { . . . DefaultProcessorOptions } ;
opts . daysBeforeStale = 5 ; // stale after 5 days
opts . daysBeforeClose = 20 ; // closes after 25 days
2021-05-26 02:14:22 +08:00
opts . stalePrMessage = 'dummy pr message' ;
2021-02-13 19:09:37 +08:00
const lastUpdate = new Date ( ) ;
2020-07-24 20:08:48 +08:00
lastUpdate . setDate ( lastUpdate . getDate ( ) - 10 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2020-07-24 20:08:48 +08:00
1 ,
'An issue that should be marked stale but not closed' ,
lastUpdate . toString ( ) ,
2021-01-18 09:22:36 +08:00
lastUpdate . toString ( ) ,
2020-07-24 20:08:48 +08:00
true
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2020-07-24 20:08:48 +08:00
opts ,
2021-01-15 20:20:32 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2020-07-24 20:08:48 +08:00
) ;
2021-05-26 02:14:22 +08:00
// for sake of testing, mocking private function
const markSpy = jest . spyOn ( processor as any , '_markStale' ) ;
2020-07-24 20:08:48 +08:00
await processor . processIssues ( 1 ) ;
// issue should be staled
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
2021-05-26 02:14:22 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
// comment should not be created
expect ( markSpy ) . toHaveBeenCalledWith (
TestIssueList [ 0 ] ,
opts . stalePrMessage ,
opts . stalePrLabel ,
// this option is skipMessage
false
) ;
2020-07-24 20:08:48 +08:00
} ) ;
2021-01-15 19:49:38 +08:00
test ( 'git branch is deleted when option is enabled' , async ( ) = > {
const opts = { . . . DefaultProcessorOptions , deleteBranch : true } ;
const isPullRequest = true ;
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-15 19:49:38 +08:00
1 ,
'An issue that should have its branch deleted' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2021-01-15 19:49:38 +08:00
isPullRequest ,
[ 'Stale' ]
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-15 19:49:38 +08:00
opts ,
2021-01-15 20:35:41 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-15 19:49:38 +08:00
) ;
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . deletedBranchIssues ) . toHaveLength ( 1 ) ;
2021-01-15 19:49:38 +08:00
} ) ;
test ( 'git branch is not deleted when issue is not pull request' , async ( ) = > {
const opts = { . . . DefaultProcessorOptions , deleteBranch : true } ;
const isPullRequest = false ;
const TestIssueList : Issue [ ] = [
generateIssue (
2021-01-19 18:54:16 +08:00
opts ,
2021-01-15 19:49:38 +08:00
1 ,
'An issue that should not have its branch deleted' ,
'2020-01-01T17:00:00Z' ,
2021-01-18 09:22:36 +08:00
'2020-01-01T17:00:00Z' ,
2021-01-15 19:49:38 +08:00
isPullRequest ,
[ 'Stale' ]
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-15 19:49:38 +08:00
opts ,
2021-01-15 20:35:41 +08:00
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-15 19:49:38 +08:00
) ;
await processor . processIssues ( 1 ) ;
2021-04-28 02:47:02 +08:00
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . deletedBranchIssues ) . toHaveLength ( 0 ) ;
2021-01-15 19:49:38 +08:00
} ) ;
2021-01-19 18:54:16 +08:00
test ( 'an issue without a milestone will be marked as stale' , async ( ) = > {
expect . assertions ( 3 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
DefaultProcessorOptions ,
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
undefined ,
undefined ,
undefined ,
''
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-19 18:54:16 +08:00
DefaultProcessorOptions ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-19 18:54:16 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 1 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . removedLabelIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'an issue without an exempted milestone will be marked as stale' , async ( ) = > {
expect . assertions ( 3 ) ;
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptMilestones = 'Milestone1' ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
undefined ,
undefined ,
undefined ,
'Milestone'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-19 18:54:16 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-19 18:54:16 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 1 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . removedLabelIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'an issue with an exempted milestone will not be marked as stale' , async ( ) = > {
expect . assertions ( 3 ) ;
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptMilestones = 'Milestone1' ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
undefined ,
undefined ,
undefined ,
'Milestone1'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-19 18:54:16 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-19 18:54:16 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . removedLabelIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'an issue with an exempted milestone will not be marked as stale (multi milestones with spaces)' , async ( ) = > {
expect . assertions ( 3 ) ;
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptMilestones = 'Milestone1, Milestone2' ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
undefined ,
undefined ,
undefined ,
'Milestone2'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-19 18:54:16 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-19 18:54:16 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . removedLabelIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'an issue with an exempted milestone will not be marked as stale (multi milestones without spaces)' , async ( ) = > {
expect . assertions ( 3 ) ;
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptMilestones = 'Milestone1,Milestone2' ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
undefined ,
undefined ,
undefined ,
'Milestone2'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-19 18:54:16 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-19 18:54:16 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . removedLabelIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'an issue with an exempted milestone but without an exempted issue milestone will not be marked as stale' , async ( ) = > {
expect . assertions ( 3 ) ;
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptMilestones = 'Milestone1' ;
opts . exemptIssueMilestones = '' ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
undefined ,
undefined ,
undefined ,
'Milestone1'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-19 18:54:16 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-19 18:54:16 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . removedLabelIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'an issue with an exempted milestone but with another exempted issue milestone will be marked as stale' , async ( ) = > {
expect . assertions ( 3 ) ;
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptMilestones = 'Milestone1' ;
opts . exemptIssueMilestones = 'Milestone2' ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
undefined ,
undefined ,
undefined ,
'Milestone1'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-19 18:54:16 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-19 18:54:16 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 1 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . removedLabelIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
test ( 'an issue with an exempted milestone and with an exempted issue milestone will not be marked as stale' , async ( ) = > {
expect . assertions ( 3 ) ;
const opts = { . . . DefaultProcessorOptions } ;
opts . exemptMilestones = 'Milestone1' ;
opts . exemptIssueMilestones = 'Milestone1' ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'My first issue' ,
'2020-01-01T17:00:00Z' ,
'2020-01-01T17:00:00Z' ,
false ,
undefined ,
undefined ,
undefined ,
'Milestone1'
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-01-19 18:54:16 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-01-19 18:54:16 +08:00
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . staleIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . closedIssues . length ) . toStrictEqual ( 0 ) ;
expect ( processor . removedLabelIssues . length ) . toStrictEqual ( 0 ) ;
} ) ;
2021-02-05 19:52:44 +08:00
test ( 'processing an issue opened since 2 days and with the option "daysBeforeIssueStale" at 3 will not make it stale' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-02-05 19:52:44 +08:00
. . . DefaultProcessorOptions ,
daysBeforeStale : 10 ,
daysBeforeIssueStale : 3
} ;
2021-02-13 19:09:37 +08:00
const issueDate = new Date ( ) ;
2021-02-05 19:52:44 +08:00
issueDate . setDate ( issueDate . getDate ( ) - 2 ) ;
const TestIssueList : Issue [ ] = [
2021-02-05 19:56:22 +08:00
generateIssue ( opts , 1 , 'An issue with no label' , issueDate . toDateString ( ) )
2021-02-05 19:52:44 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-02-05 19:52:44 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-02-05 19:52:44 +08:00
) ;
2021-02-05 19:56:22 +08:00
2021-02-05 19:52:44 +08:00
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-02-05 19:56:22 +08:00
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2021-02-05 19:52:44 +08:00
} ) ;
test ( 'processing an issue opened since 2 days and with the option "daysBeforeIssueStale" at 2 will make it stale' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-02-05 19:52:44 +08:00
. . . DefaultProcessorOptions ,
daysBeforeStale : 10 ,
daysBeforeIssueStale : 2
} ;
2021-02-13 19:09:37 +08:00
const issueDate = new Date ( ) ;
2021-02-05 19:52:44 +08:00
issueDate . setDate ( issueDate . getDate ( ) - 2 ) ;
const TestIssueList : Issue [ ] = [
2021-02-05 19:56:22 +08:00
generateIssue ( opts , 1 , 'An issue with no label' , issueDate . toDateString ( ) )
2021-02-05 19:52:44 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-02-05 19:52:44 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-02-05 19:52:44 +08:00
) ;
2021-02-05 19:56:22 +08:00
2021-02-05 19:52:44 +08:00
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-02-05 19:56:22 +08:00
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2021-02-05 19:52:44 +08:00
} ) ;
test ( 'processing an issue opened since 2 days and with the option "daysBeforeIssueStale" at 1 will make it stale' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-02-05 19:52:44 +08:00
. . . DefaultProcessorOptions ,
daysBeforeStale : 10 ,
daysBeforeIssueStale : 1
} ;
2021-02-13 19:09:37 +08:00
const issueDate = new Date ( ) ;
2021-02-05 19:52:44 +08:00
issueDate . setDate ( issueDate . getDate ( ) - 2 ) ;
const TestIssueList : Issue [ ] = [
2021-02-05 19:56:22 +08:00
generateIssue ( opts , 1 , 'An issue with no label' , issueDate . toDateString ( ) )
2021-02-05 19:52:44 +08:00
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-02-05 19:52:44 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-02-05 19:52:44 +08:00
) ;
2021-02-05 19:56:22 +08:00
2021-02-05 19:52:44 +08:00
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-02-05 19:56:22 +08:00
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2021-02-05 19:52:44 +08:00
} ) ;
test ( 'processing a pull request opened since 2 days and with the option "daysBeforePrStale" at 3 will not make it stale' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-02-05 19:52:44 +08:00
. . . DefaultProcessorOptions ,
daysBeforeStale : 10 ,
daysBeforePrStale : 3
} ;
2021-02-13 19:09:37 +08:00
const issueDate = new Date ( ) ;
2021-02-05 19:52:44 +08:00
issueDate . setDate ( issueDate . getDate ( ) - 2 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'A pull request with no label' ,
issueDate . toDateString ( ) ,
issueDate . toDateString ( ) ,
true
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-02-05 19:52:44 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-02-05 19:52:44 +08:00
) ;
2021-02-05 19:56:22 +08:00
2021-02-05 19:52:44 +08:00
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-02-05 19:56:22 +08:00
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2021-02-05 19:52:44 +08:00
} ) ;
test ( 'processing a pull request opened since 2 days and with the option "daysBeforePrStale" at 2 will make it stale' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-02-05 19:52:44 +08:00
. . . DefaultProcessorOptions ,
daysBeforeStale : 10 ,
daysBeforePrStale : 2
} ;
2021-02-13 19:09:37 +08:00
const issueDate = new Date ( ) ;
2021-02-05 19:52:44 +08:00
issueDate . setDate ( issueDate . getDate ( ) - 2 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'A pull request with no label' ,
issueDate . toDateString ( ) ,
issueDate . toDateString ( ) ,
true
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-02-05 19:52:44 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-02-05 19:52:44 +08:00
) ;
2021-02-05 19:56:22 +08:00
2021-02-05 19:52:44 +08:00
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-02-05 19:56:22 +08:00
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2021-02-05 19:52:44 +08:00
} ) ;
test ( 'processing a pull request opened since 2 days and with the option "daysBeforePrStale" at 1 will make it stale' , async ( ) = > {
expect . assertions ( 2 ) ;
2021-02-13 19:09:37 +08:00
const opts : IIssuesProcessorOptions = {
2021-02-05 19:52:44 +08:00
. . . DefaultProcessorOptions ,
daysBeforeStale : 10 ,
daysBeforePrStale : 1
} ;
2021-02-13 19:09:37 +08:00
const issueDate = new Date ( ) ;
2021-02-05 19:52:44 +08:00
issueDate . setDate ( issueDate . getDate ( ) - 2 ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'A pull request with no label' ,
issueDate . toDateString ( ) ,
issueDate . toDateString ( ) ,
true
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-02-05 19:52:44 +08:00
opts ,
async ( ) = > 'abot' ,
2021-03-02 04:34:35 +08:00
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
2021-02-05 19:52:44 +08:00
) ;
2021-02-05 19:56:22 +08:00
2021-02-05 19:52:44 +08:00
// process our fake issue list
await processor . processIssues ( 1 ) ;
2021-02-05 19:56:22 +08:00
2021-04-28 02:47:02 +08:00
expect ( processor . staleIssues ) . toHaveLength ( 1 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
2021-02-05 19:52:44 +08:00
} ) ;
2021-03-01 08:07:54 +08:00
test ( 'processing a previously closed issue with a close label will remove the close label' , async ( ) = > {
expect . assertions ( 1 ) ;
const opts : IIssuesProcessorOptions = {
. . . DefaultProcessorOptions ,
closeIssueLabel : 'close' ,
staleIssueLabel : 'stale'
} ;
const now : Date = new Date ( ) ;
2021-03-05 22:12:18 +08:00
const oneWeekAgo : Date = new Date ( now . setDate ( now . getDate ( ) - 7 ) ) ;
2021-03-01 08:07:54 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'An opened issue with a close label' ,
oneWeekAgo . toDateString ( ) ,
now . toDateString ( ) ,
false ,
[ 'close' ] ,
false ,
false
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-03-01 08:07:54 +08:00
opts ,
async ( ) = > 'abot' ,
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 1 ) ;
} ) ;
test ( 'processing a closed issue with a close label will not remove the close label' , async ( ) = > {
expect . assertions ( 1 ) ;
const opts : IIssuesProcessorOptions = {
. . . DefaultProcessorOptions ,
closeIssueLabel : 'close' ,
staleIssueLabel : 'stale'
} ;
const now : Date = new Date ( ) ;
2021-03-05 22:12:18 +08:00
const oneWeekAgo : Date = new Date ( now . setDate ( now . getDate ( ) - 7 ) ) ;
2021-03-01 08:07:54 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'A closed issue with a close label' ,
oneWeekAgo . toDateString ( ) ,
now . toDateString ( ) ,
false ,
[ 'close' ] ,
true ,
false
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-03-01 08:07:54 +08:00
opts ,
async ( ) = > 'abot' ,
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
} ) ;
test ( 'processing a locked issue with a close label will not remove the close label' , async ( ) = > {
expect . assertions ( 1 ) ;
const opts : IIssuesProcessorOptions = {
. . . DefaultProcessorOptions ,
closeIssueLabel : 'close' ,
staleIssueLabel : 'stale'
} ;
const now : Date = new Date ( ) ;
2021-03-05 22:12:18 +08:00
const oneWeekAgo : Date = new Date ( now . setDate ( now . getDate ( ) - 7 ) ) ;
2021-03-01 08:07:54 +08:00
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'A closed issue with a close label' ,
oneWeekAgo . toDateString ( ) ,
now . toDateString ( ) ,
false ,
[ 'close' ] ,
false ,
true
)
] ;
2021-03-02 04:34:35 +08:00
const processor = new IssuesProcessorMock (
2021-03-01 08:07:54 +08:00
opts ,
async ( ) = > 'abot' ,
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) = > [ ] ,
async ( ) = > new Date ( ) . toDateString ( )
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
} ) ;
2021-03-05 22:12:18 +08:00
test ( 'processing an issue stale since less than the daysBeforeStale with a stale label created after daysBeforeClose should close the issue' , async ( ) = > {
expect . assertions ( 3 ) ;
const opts : IIssuesProcessorOptions = {
. . . DefaultProcessorOptions ,
staleIssueLabel : 'stale-label' ,
daysBeforeStale : 30 ,
daysBeforeClose : 7 ,
closeIssueMessage : 'close message' ,
removeStaleWhenUpdated : false
} ;
const now : Date = new Date ( ) ;
const updatedAt : Date = new Date ( now . setDate ( now . getDate ( ) - 9 ) ) ;
const labelCreatedAt : Date = new Date ( now . setDate ( now . getDate ( ) - 17 ) ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'A real issue example; see https://github.com/actions/stale/issues/351' ,
updatedAt . toDateString ( ) ,
new Date ( 2021 , 0 , 16 ) . toDateString ( ) ,
false ,
[ 'stale-label' ] , // This was the problem for the user BTW, the issue was re-opened without removing the previous stale label
false ,
false
)
] ;
const processor = new IssuesProcessorMock (
opts ,
async ( ) = > 'abot' ,
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) : Promise < IComment [ ] > = > Promise . resolve ( [ ] ) ,
async ( ) = > labelCreatedAt . toDateString ( )
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
expect ( processor . deletedBranchIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 1 ) ; // Expected at 0 by the user
} ) ;
test ( 'processing an issue stale since less than the daysBeforeStale without a stale label should close the issue' , async ( ) = > {
expect . assertions ( 3 ) ;
const opts : IIssuesProcessorOptions = {
. . . DefaultProcessorOptions ,
staleIssueLabel : 'stale-label' ,
daysBeforeStale : 30 ,
daysBeforeClose : 7 ,
closeIssueMessage : 'close message' ,
removeStaleWhenUpdated : false
} ;
const now : Date = new Date ( ) ;
const updatedAt : Date = new Date ( now . setDate ( now . getDate ( ) - 9 ) ) ;
const TestIssueList : Issue [ ] = [
generateIssue (
opts ,
1 ,
'A real issue example; see https://github.com/actions/stale/issues/351 but without the old stale label from the previous close' ,
updatedAt . toDateString ( ) ,
new Date ( 2021 , 0 , 16 ) . toDateString ( ) ,
false ,
[ ] ,
false ,
false
)
] ;
const processor = new IssuesProcessorMock (
opts ,
async ( ) = > 'abot' ,
async p = > ( p === 1 ? TestIssueList : [ ] ) ,
async ( ) : Promise < IComment [ ] > = > Promise . resolve ( [ ] ) ,
async ( ) = > new Date ( ) . toDateString ( )
) ;
// process our fake issue list
await processor . processIssues ( 1 ) ;
expect ( processor . removedLabelIssues ) . toHaveLength ( 0 ) ;
expect ( processor . deletedBranchIssues ) . toHaveLength ( 0 ) ;
expect ( processor . closedIssues ) . toHaveLength ( 0 ) ;
} ) ;