Mostly tests and some small changes (#16)

* Create docker.test.ts
* Add context tests
* test main

__tests__/context.test.ts

@@ -0,0 +1,16 @@
+import osm = require('os');
+
+import {getInputs} from '../src/context';
+
+test('without password getInputs throws errors', async () => {
+  expect(() => {
+    getInputs();
+  }).toThrowError('Input required and not supplied: password');
+});
+
+test('with password getInputs does not error', async () => {
+  process.env['INPUT_PASSWORD'] = 'groundcontrol';
+  expect(() => {
+    getInputs();
+  }).not.toThrowError();
+});

__tests__/docker.test.ts

@@ -0,0 +1,49 @@
+import {loginStandard, logout} from '../src/docker';
+
+import * as path from 'path';
+
+import * as exec from '@actions/exec';
+
+process.env['RUNNER_TEMP'] = path.join(__dirname, 'runner');
+
+test('loginStandard calls exec', async () => {
+  const execSpy: jest.SpyInstance = jest.spyOn(exec, 'exec');
+  // don't let exec try to actually run the commands
+  execSpy.mockImplementation(() => {});
+
+  const username: string = 'dbowie';
+  const password: string = 'groundcontrol';
+  const registry: string = 'https://ghcr.io';
+
+  await loginStandard(registry, username, password);
+
+  expect(execSpy).toHaveBeenCalledWith(`docker`, ['login', '--password-stdin', '--username', username, registry], {
+    input: Buffer.from(password),
+    silent: true,
+    ignoreReturnCode: true,
+    listeners: expect.objectContaining({
+      stdout: expect.any(Function),
+      stderr: expect.any(Function)
+    })
+  });
+});
+
+test('logout calls exec', async () => {
+  const execSpy: jest.SpyInstance = jest.spyOn(exec, 'exec');
+  // don't let exec try to actually run the commands
+  execSpy.mockImplementation(() => {});
+
+  const registry: string = 'https://ghcr.io';
+
+  await logout(registry);
+
+  expect(execSpy).toHaveBeenCalledWith(`docker`, ['logout', registry], {
+    silent: false,
+    ignoreReturnCode: true,
+    input: Buffer.from(''),
+    listeners: expect.objectContaining({
+      stdout: expect.any(Function),
+      stderr: expect.any(Function)
+    })
+  });
+});

__tests__/main.test.ts

@@ -0,0 +1,76 @@
+import osm = require('os');
+
+import {run} from '../src/main';
+import * as docker from '../src/docker';
+import * as stateHelper from '../src/state-helper';
+
+import * as core from '@actions/core';
+
+test('errors when not run on linux platform', async () => {
+  const platSpy = jest.spyOn(osm, 'platform');
+  platSpy.mockImplementation(() => 'netbsd');
+
+  const coreSpy: jest.SpyInstance = jest.spyOn(core, 'setFailed');
+
+  await run();
+
+  expect(coreSpy).toHaveBeenCalledWith('Only supported on linux platform');
+});
+
+test('errors without password', async () => {
+  const platSpy = jest.spyOn(osm, 'platform');
+  platSpy.mockImplementation(() => 'linux');
+
+  const coreSpy: jest.SpyInstance = jest.spyOn(core, 'setFailed');
+
+  await run();
+
+  expect(coreSpy).toHaveBeenCalledWith('Input required and not supplied: password');
+});
+
+test('successful with only password', async () => {
+    const platSpy = jest.spyOn(osm, 'platform');
+    platSpy.mockImplementation(() => 'linux');
+  
+    const setRegistrySpy: jest.SpyInstance = jest.spyOn(stateHelper, 'setRegistry');
+    const setLogoutSpy: jest.SpyInstance = jest.spyOn(stateHelper, 'setLogout');
+    const dockerSpy: jest.SpyInstance = jest.spyOn(docker, 'login');
+    dockerSpy.mockImplementation(() => {});
+  
+    const password: string = 'groundcontrol';
+    process.env[`INPUT_PASSWORD`] = password;
+
+    await run();
+
+    expect(setRegistrySpy).toHaveBeenCalledWith('');
+    expect(setLogoutSpy).toHaveBeenCalledWith('');
+    expect(dockerSpy).toHaveBeenCalledWith('', '', password);
+});
+
+test('calls docker login', async () => {
+  const platSpy = jest.spyOn(osm, 'platform');
+  platSpy.mockImplementation(() => 'linux');
+
+  const setRegistrySpy: jest.SpyInstance = jest.spyOn(stateHelper, 'setRegistry');
+  const setLogoutSpy: jest.SpyInstance = jest.spyOn(stateHelper, 'setLogout');
+  const dockerSpy: jest.SpyInstance = jest.spyOn(docker, 'login');
+  dockerSpy.mockImplementation(() => {});
+
+  const username: string = 'dbowie';
+  process.env[`INPUT_USERNAME`] = username;
+
+  const password: string = 'groundcontrol';
+  process.env[`INPUT_PASSWORD`] = password;
+
+  const registry: string = 'https://ghcr.io';
+  process.env[`INPUT_REGISTRY`] = registry;
+
+  const logout: string = 'true';
+  process.env['INPUT_LOGOUT'] = logout
+
+  await run();
+
+  expect(setRegistrySpy).toHaveBeenCalledWith(registry);
+  expect(setLogoutSpy).toHaveBeenCalledWith(logout);
+  expect(dockerSpy).toHaveBeenCalledWith(registry, username, password);
+});

src/context.ts

@@ -7,7 +7,7 @@ export interface Inputs {
   logout: string;
 }
 
-export async function getInputs(): Promise<Inputs> {
+export function getInputs(): Inputs {
   return {
     registry: core.getInput('registry'),
     username: core.getInput('username'),

src/main.ts

@@ -4,17 +4,16 @@ import {getInputs, Inputs} from './context';
 import * as docker from './docker';
 import * as stateHelper from './state-helper';
 
-async function run(): Promise<void> {
+export async function run(): Promise<void> {
   try {
     if (os.platform() !== 'linux') {
-      core.setFailed('Only supported on linux platform');
+      throw new Error('Only supported on linux platform');
-      return;
     }
 
-    let inputs: Inputs = await getInputs();
+    const {registry, username, password, logout} = getInputs();
-    stateHelper.setRegistry(inputs.registry);
+    stateHelper.setRegistry(registry);
-    stateHelper.setLogout(inputs.logout);
+    stateHelper.setLogout(logout);
-    await docker.login(inputs.registry, inputs.username, inputs.password);
+    await docker.login(registry, username, password);
   } catch (error) {
     core.setFailed(error.message);
   }