Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

chore(deps): bump aws-actions/stale-issue-cleanup from 5 to 6 #479

Open
wants to merge 2 commits into
base: main
Choose a base branch
from
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion .github/workflows/close-stale-issues.yml
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,7 @@ jobs:
runs-on: ubuntu-latest
name: Stale issue job
steps:
- uses: aws-actions/stale-issue-cleanup@v5
- uses: aws-actions/stale-issue-cleanup@v6
with:
# Setting messages to an empty string will cause the automation to skip
# that category
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -43,7 +43,31 @@ async function defaultInvokeFunction(req: AWS.Lambda.InvocationRequest): Promise
lambda = new AWS.Lambda(awsSdkConfig);
}

return lambda.invoke(req).promise();
try {
/**
* Try an initial invoke.
*
* When you try to invoke a function that is inactive, the invocation fails and Lambda sets
* the function to pending state until the function resources are recreated.
* If Lambda fails to recreate the resources, the function is set to the inactive state.
*
* We're using invoke first because `waitFor` doesn't trigger an inactive function to do anything,
* it just runs `getFunction` and checks the state.
*/
return await lambda.invoke(req).promise();
} catch (error) {

/**
* The status of the Lambda function is checked every second for up to 300 seconds.
* Exits the loop on 'Active' state and throws an error on 'Inactive' or 'Failed'.
*
* And now we wait.
*/
await lambda.waitFor('functionActiveV2', {
FunctionName: req.FunctionName,
}).promise();
return await lambda.invoke(req).promise();
}
}

export let startExecution = defaultStartExecution;
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,174 @@
import * as aws from 'aws-sdk';
import { invokeFunction } from '../../lib/provider-framework/runtime/outbound';

jest.mock('aws-sdk', () => {
return {
Lambda: class {
public invoke() {
return { promise: () => mockInvoke() };
}

public waitFor() {
return { promise: () => mockWaitFor() };
}
},
};
});

let mockInvoke: () => Promise<aws.Lambda.InvocationResponse>;

const req: aws.Lambda.InvocationRequest = {
FunctionName: 'Whatever',
Payload: {
IsThisATest: 'Yes, this is a test',
AreYouSure: 'Yes, I am sure',
},
};

let invokeCount: number = 0;
let expectedFunctionStates: string[] = [];
let receivedFunctionStates: string[] = [];

const mockWaitFor = async (): Promise<aws.Lambda.GetFunctionResponse> => {
let state = expectedFunctionStates.pop();
while (state !== 'Active') {
receivedFunctionStates.push(state!);
// If it goes back to inactive it's failed
if (state === 'Inactive') throw new Error('Not today');
// If failed... it's failed
if (state === 'Failed') throw new Error('Broken');
// If pending, continue the loop, no other valid options
if (state !== 'Pending') throw new Error('State is confused');
state = expectedFunctionStates.pop();
}
receivedFunctionStates.push(state);
return {
Configuration: {
State: 'Active',
},
};
};

describe('invokeFunction tests', () => {
afterEach(() => {
invokeCount = 0;
expectedFunctionStates = [];
receivedFunctionStates = [];
});

// Success cases
test('Inactive function that reactivates does not throw error', async () => {
mockInvoke = async () => {
if (invokeCount == 0) {
invokeCount++;
throw new Error('Better luck next time');
}
invokeCount++;
return { Payload: req.Payload };
};

expectedFunctionStates.push('Active');
expectedFunctionStates.push('Pending');

expect(await invokeFunction(req)).toEqual({ Payload: req.Payload });
expect(invokeCount).toEqual(2);
expect(receivedFunctionStates).toEqual(['Pending', 'Active']);
});

test('Active function does not run waitFor or retry invoke', async () => {
mockInvoke = async () => {
if (invokeCount == 1) {
invokeCount++;
throw new Error('This should not happen in this test');
}
invokeCount++;
return { Payload: req.Payload };
};

expectedFunctionStates.push('Active');

expect(await invokeFunction(req)).toEqual({ Payload: req.Payload });
expect(invokeCount).toEqual(1);
expect(receivedFunctionStates).toEqual([]);
});

// Failure cases
test('Inactive function that goes back to inactive throws error', async () => {
mockInvoke = async () => {
if (invokeCount == 0) {
invokeCount++;
throw new Error('Better luck next time');
}
invokeCount++;
return { Payload: req.Payload };
};

expectedFunctionStates.push('Inactive');
expectedFunctionStates.push('Pending');
expectedFunctionStates.push('Pending');

await expect(invokeFunction(req)).rejects.toThrowError(new Error('Not today'));
expect(invokeCount).toEqual(1);
expect(receivedFunctionStates).toEqual(['Pending', 'Pending', 'Inactive']);
});

test('Inactive function that goes to failed throws error', async () => {
mockInvoke = async () => {
if (invokeCount == 0) {
invokeCount++;
throw new Error('Better luck next time');
}
invokeCount++;
return { Payload: req.Payload };
};

expectedFunctionStates.push('Failed');
expectedFunctionStates.push('Pending');
expectedFunctionStates.push('Pending');

await expect(invokeFunction(req)).rejects.toThrowError(new Error('Broken'));
expect(invokeCount).toEqual(1);
expect(receivedFunctionStates).toEqual(['Pending', 'Pending', 'Failed']);
});

test('Inactive function that returns other value throws error', async () => {
mockInvoke = async () => {
if (invokeCount == 0) {
invokeCount++;
throw new Error('Better luck next time');
}
invokeCount++;
return { Payload: req.Payload };
};

expectedFunctionStates.push('NewFunctionWhoDis');
expectedFunctionStates.push('Pending');
expectedFunctionStates.push('Pending');

await expect(invokeFunction(req)).rejects.toThrowError(new Error('State is confused'));
expect(invokeCount).toEqual(1);
expect(receivedFunctionStates).toEqual(['Pending', 'Pending', 'NewFunctionWhoDis']);
});

test('Wait for stops on terminal responses', async () => {
mockInvoke = async () => {
if (invokeCount == 0) {
invokeCount++;
throw new Error('Better luck next time');
}
invokeCount++;
return { Payload: req.Payload };
};

expectedFunctionStates.push('SomethingElse');
expectedFunctionStates.push('Pending');
expectedFunctionStates.push('Inactive');
expectedFunctionStates.push('Pending');
expectedFunctionStates.push('Pending');

await expect(invokeFunction(req)).rejects.toThrowError(new Error('Not today'));
expect(invokeCount).toEqual(1);
expect(receivedFunctionStates).toEqual(['Pending', 'Pending', 'Inactive']);
});
});