@microtica/mocks
Version:
Mock services for automated tests
211 lines • 8.18 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
const AWS = require("aws-sdk");
const jwt = require("jsonwebtoken");
const _ = require("lodash");
const mock = require("mock-require");
const mock_service_1 = require("../mock-service");
var Region;
(function (Region) {
Region["Frankfurt"] = "eu-central-1";
})(Region || (Region = {}));
function awsError(message, code) {
return {
message,
code,
time: new Date(),
requestId: "someRequestId",
statusCode: 400,
retryable: false,
retryDelay: 80.20205510369655
};
}
class CognitoIdentityServiceProvider extends mock_service_1.MockService {
// tslint:disable:typedef
adminGetUser(input) {
const response = async () => {
const user = this.storage.get(input.Username);
if (!user) {
throw awsError("User does not exist.", "UserNotFoundException");
}
return user;
};
return { promise: response };
}
adminCreateUser(input) {
const response = async () => {
if (this.storage.get(input.Username)) {
throw awsError("User account already exists", "UsernameExistsException");
}
if (input.DesiredDeliveryMediums.includes("EMAIL") && input.UserAttributes[0].Name !== "email") {
throw awsError("No email provided but desired delivery medium was Email", "InvalidParameterException");
}
input.UserAttributes.push({
Name: "sub",
Value: input.Username
});
this.storage.insert(input.Username, {
Username: input.Username,
Password: "temp",
UserConfirmed: false,
UserAttributes: input.UserAttributes
});
_.extend(input, { Attributes: input.UserAttributes });
delete input.UserAttributes;
return { User: input };
};
return { promise: response };
}
signUp(input) {
const response = async () => {
// tslint:disable-next-line:no-magic-numbers
if (input.Password.length <= 6 && input.Password.length >= 256) {
throw awsError("Password must have length greater than or equal to 6 and less than or equal to 256", "InvalidParameterException");
}
if (this.storage.get(input.Username)) {
throw awsError("User already exists", "UsernameExistsException");
}
input.UserAttributes.push({
Name: "sub",
Value: input.Username
});
this.storage.insert(input.Username, {
Username: input.Username,
Password: input.Password,
UserConfirmed: false,
UserAttributes: input.UserAttributes
});
const user = this.storage.get(input.Username);
return { UserConfirmed: user.UserConfirmed, UserSub: input.Username };
};
return { promise: response };
}
confirmSignUp(input) {
const response = async () => {
const user = this.storage.get(input.Username);
if (!user) {
throw awsError("Username/client id combination not found.", "UserNotFoundException");
}
if (user.UserConfirmed) {
throw awsError("User cannot be confirm. Current status is CONFIRMED", "NotAuthorizedException");
}
user.UserConfirmed = true;
return {};
};
return { promise: response };
}
adminRespondToAuthChallenge(_input) {
const response = async () => {
return {
AuthenticationResult: {
AccessToken: "SomeAccessToken",
ExpiresIn: 30,
IdToken: "SomeIdToken",
NewDeviceMetadata: {
DeviceGroupKey: "SomeDeviceGroupKey",
DeviceKey: "SomeDeviceKey"
},
ChallengeName: "SomeChallengeName",
ChallengeParameters: {
SomeChallengeParameter: "SomeChallengeValue"
},
RefreshToken: "SomeRefreshToken",
TokenType: "SomeTokenType"
},
Session: "SomeSession"
};
};
return { promise: response };
}
listUsers(input) {
const response = async () => {
const Users = _.map(_.values(this.storage.list()), user => {
const tempUser = _.extend({}, user, { Attributes: user.UserAttributes });
delete tempUser.UserAttributes;
return tempUser;
});
if (input.Filter) {
const [filter, value] = input.Filter.split("=");
return {
Users: _.filter(Users, user => {
// tslint:disable-next-line:no-magic-numbers
return _.find(user.Attributes, { Name: filter.trim() }).Value === value.replace(/\"/g, "").trim();
})
};
}
return { Users };
};
return { promise: response };
}
initiateAuth(input) {
const response = async () => {
const user = this.storage.get(input.AuthParameters.USERNAME);
if (!user) {
throw awsError("User does not exist.", "UserNotFoundException");
}
const password = input.AuthParameters.PASSWORD;
if (password !== user.Password) {
throw awsError("Password does not match.", "InvalidParameterException");
}
if (input.AuthParameters.USERNAME === "testUsernameChallenge") {
return {
ChallengeName: "SomeChallengeName",
Session: "someSessionId",
ChallengeParameters: {
"SomeChallengeParameter1": "SomeChallengeValue1",
"SomeChallengeParameter2": "SomeChallengeValue2",
"SomeChallengeParameter3": "SomeChallengeValue3"
}
};
}
return {
ChallengeParameters: {},
AuthenticationResult: {
AccessToken: "SomeAccessToken",
ExpiresIn: 3600,
IdToken: "SomeIdToken",
RefreshToken: "SomeRefreshToken",
TokenType: "Bearer"
}
};
};
return { promise: response };
}
forgotPassword(params) {
const response = async () => {
return {
CodeDeliveryDetails: {
Destination: "Destination",
DeliveryMedium: "DeliveryMedium",
AttributeName: "AttributeName`"
}
};
};
return { promise: response };
}
confirmForgotPassword(params) {
const response = async () => {
};
return { promise: response };
}
changePassword(params) {
const response = async () => {
const { username } = jwt.decode(params.AccessToken.split(" ")[1]);
const user = this.storage.get(username);
if (!user) {
throw awsError("User does not exist.", "UserNotFoundException");
}
if (params.PreviousPassword !== user.Password) {
throw awsError("Invalid password.", "InvalidPasswordException");
}
const updatedUser = Object.assign({}, user, { Password: params.ProposedPassword });
this.storage.insert(username, updatedUser);
return;
};
return { promise: response };
}
}
exports.CognitoIdentityServiceProvider = CognitoIdentityServiceProvider;
AWS.CognitoIdentityServiceProvider = CognitoIdentityServiceProvider;
mock("aws-sdk", AWS);
//# sourceMappingURL=cognito.js.map