1  import path from 'path';
  2  import fs from 'fs';
  3  import {
  4    getHomeDir,
  5    getWorkDirName,
  6    createDir,
  7    addNoJekyll,
  8    addCNAME,
  9    skipOnFork
 10  } from '../src/utils';
 11  
 12  beforeEach(() => {
 13    jest.resetModules();
 14  });
 15  
 16  // afterEach(() => {
 17  
 18  // });
 19  
 20  async function getTime(): Promise<string> {
 21    const date = new Date();
 22    const unixTime = date.getTime();
 23    return `${unixTime}`;
 24  }
 25  
 26  describe('getHomeDir()', () => {
 27    test('get home directory name', async () => {
 28      let test = '';
 29      if (process.platform === 'win32') {
 30        test = 'C:\\Users\\runneradmin';
 31      } else {
 32        test = `${process.env.HOME}`;
 33      }
 34      const expected = await getHomeDir();
 35      expect(test).toMatch(expected);
 36    });
 37  });
 38  
 39  describe('getWorkDirName()', () => {
 40    test('get work directory name', async () => {
 41      let home = '';
 42      if (process.platform === 'win32') {
 43        home = 'C:\\Users\\runneradmin';
 44      } else {
 45        home = `${process.env.HOME}`;
 46      }
 47      const unixTime = await getTime();
 48      const expected = path.join(home, `actions_github_pages_${unixTime}`);
 49      const test = await getWorkDirName(`${unixTime}`);
 50      expect(test).toMatch(expected);
 51    });
 52  });
 53  
 54  describe('createDir()', () => {
 55    test('create a directory', async () => {
 56      const unixTime = await getTime();
 57      const workDirName = await getWorkDirName(`${unixTime}`);
 58      await createDir(workDirName);
 59      const test = fs.existsSync(workDirName);
 60      expect(test).toBe(true);
 61    });
 62  });
 63  
 64  async function getWorkDir(): Promise<string> {
 65    const unixTime = await getTime();
 66    let workDir = '';
 67    workDir = await getWorkDirName(`${unixTime}`);
 68    await createDir(workDir);
 69    return workDir;
 70  }
 71  
 72  describe('addNoJekyll()', () => {
 73    test('add .nojekyll', async () => {
 74      let workDir = '';
 75      (async (): Promise<void> => {
 76        workDir = await getWorkDir();
 77      })();
 78      const filepath = path.join(workDir, '.nojekyll');
 79  
 80      await addNoJekyll(workDir, false);
 81      const test = fs.existsSync(filepath);
 82      expect(test).toBe(true);
 83  
 84      fs.unlinkSync(filepath);
 85    });
 86  
 87    test('.nojekyll already exists', async () => {
 88      let workDir = '';
 89      (async (): Promise<void> => {
 90        workDir = await getWorkDir();
 91      })();
 92      const filepath = path.join(workDir, '.nojekyll');
 93      fs.closeSync(fs.openSync(filepath, 'w'));
 94  
 95      await addNoJekyll(workDir, false);
 96      const test = fs.existsSync(filepath);
 97      expect(test).toBe(true);
 98  
 99      fs.unlinkSync(filepath);
100    });
101  
102    test('not add .nojekyll disable_nojekyll', async () => {
103      let workDir = '';
104      (async (): Promise<void> => {
105        workDir = await getWorkDir();
106      })();
107      const filepath = path.join(workDir, '.nojekyll');
108  
109      await addNoJekyll(workDir, true);
110      const test = fs.existsSync(filepath);
111      expect(test).toBe(false);
112    });
113  });
114  
115  describe('addCNAME()', () => {
116    test('add CNAME', async () => {
117      let workDir = '';
118      (async (): Promise<void> => {
119        workDir = await getWorkDir();
120      })();
121      const filepath = path.join(workDir, 'CNAME');
122  
123      await addCNAME(workDir, 'github.com');
124      const test = fs.readFileSync(filepath, 'utf8');
125      expect(test).toMatch('github.com');
126  
127      fs.unlinkSync(filepath);
128    });
129  
130    test('do nothing', async () => {
131      let workDir = '';
132      (async (): Promise<void> => {
133        workDir = await getWorkDir();
134      })();
135      const filepath = path.join(workDir, 'CNAME');
136  
137      await addCNAME(workDir, '');
138      const test = fs.existsSync(filepath);
139      expect(test).toBe(false);
140    });
141  
142    test('CNAME already exists', async () => {
143      let workDir = '';
144      (async (): Promise<void> => {
145        workDir = await getWorkDir();
146      })();
147      const filepath = path.join(workDir, 'CNAME');
148  
149      await addCNAME(workDir, 'github.io');
150      await addCNAME(workDir, 'github.com');
151      const test = fs.readFileSync(filepath, 'utf8');
152      expect(test).toMatch('github.io');
153  
154      fs.unlinkSync(filepath);
155    });
156  });
157  
158  describe('skipOnFork()', () => {
159    test('return false on upstream', async () => {
160      const test = await skipOnFork(false, 'token', '', '');
161      expect(test).toBeFalsy();
162    });
163  
164    test('return false on fork with github_token', async () => {
165      const test = await skipOnFork(true, 'token', '', '');
166      expect(test).toBeFalsy();
167    });
168  
169    test('return false on fork with deploy_key', async () => {
170      const test = await skipOnFork(true, '', 'deploy_key', '');
171      expect(test).toBeFalsy();
172    });
173  
174    test('return false on fork with personal_token', async () => {
175      const test = await skipOnFork(true, '', '', 'personal_token');
176      expect(test).toBeFalsy();
177    });
178  
179    test('return true on fork with no tokens', async () => {
180      const test = await skipOnFork(true, '', '', '');
181      expect(test).toBeTruthy();
182    });
183  });