Sammaye's Blog

So today I was awoken to the fact that my database had mysteriously lost data after putting out a new feature.

This a MongoDB database whereby, via the driver, you can replace documents.

After some digging I found that despite calling a function “updateEmployer” GitHub Co-Pilot had actually written the body of a function called “replaceEmployer” with only the fields in the C# schema file. I mean fair I didn’t know the database fields not defined in coding but that’s irrelevant, you would never use ReplaceOneAsync in an update function.

Since I accidentally trusted the AI without doing a proper review and it passed unit tests this went out and wiped the database…

Vibe coding is a fallacy and one you should avoid. This isn’t my first run in with AI incompetence it is just my last tbh

0

https://github.com/facebook/react-native/issues/29614#issuecomment-3069870022 this worked best for me:

const [behaviour, setBehaviour] = useState(‘height’);
useEffect(() => {
const showListener = Keyboard.addListener(‘keyboardDidShow’, () => {
setBehaviour(‘height’);
});
const hideListener = Keyboard.addListener(‘keyboardDidHide’, () => {
setBehaviour(undefined);
});

return () => {
showListener.remove();
hideListener.remove();
};
}, []);

….

<KeyboardAvoidingView
style={{ flex: 1 }}
behavior={Platform.OS === ‘android’ ? behaviour : undefined}
….

0

https://addyosmani.com/blog/script-priorities/

0

Using this https://bojnansky.com/running-angular-tests-with-github-actions/ as a guide I made GitHub actions for angular testing, I used this action:

name: Run Tests
on:
 push:
 branches:
 - beta
 - main
jobs:
 build:
 runs-on: ubuntu-latest
 steps:
 - uses: actions/checkout@v2
 - name: Install Angular CLI and sass
 run: npm install -g @angular/cli@^14.0.0 sass
 - name: Install modules
 run: npm install --force
 - name: Run tests
 run: npm run test-ci

With the npm command in the link:

"test-ci": "ng test --browsers=ChromeHeadless --watch=false"

0

function handler(event) {
 const request = event.request;
 const response = event.response;
 const headers = response.headers;
 
 let original_uri = '';

 if (request.headers.hasOwnProperty('x-original-uri')) {
 original_uri = request.headers['x-original-uri'].value;
 }
 
 let referer = '';
 if (request.headers.hasOwnProperty('referer')) {
 referer = request.headers['referer'].value;
 }
 
 if (
 (
 // Super important! when PWA queries for new cache it actually does not send the URI, figured this out after lots of debugging
 !referer || !referer.includes('ngsw-worker.js')
 ) &&
 request.uri.includes('index.html') && 
 original_uri && 
 !original_uri.includes('/embedded')
 ) {
 response.headers['x-frame-options'] = {value: 'SAMEORIGIN'};
 }
 
 return response;
}

0

A good env:

• https://jestjs.io/
• https://jestjs.io/docs/mongodb
• https://www.npmjs.com/package/@mswjs/interceptors

A good env setup:

jest.config.js

module.exports = {
 preset: '@shelf/jest-mongodb',
 transform: { "^.+\\.[tj]s?(x)?$": ["ts-jest", {"rootDir": "."}] },
 testMatch: [ "**/tests/__tests__/**/*.[jt]s?(x)", "**/?(*.)+(spec|test).[jt]s?(x)" ],
 setupFilesAfterEnv: ['<rootDir>/setup-jest.js'],
};

jest-mongodb-config.js

module.exports = {
 mongodbMemoryServerOptions: {
 binary: {
 version: '5.0.0',
 skipMD5: true,
 },
 autoStart: false,
 instance: {},
 },
};

A global file for running predictable tests:

setup-jest.js

import {afterAll, beforeAll} from "@jest/globals";
import {BatchInterceptor} from "@mswjs/interceptors";
import MongoDB from "./services/MongoDB";
import './config/app.js';
import {faker} from "@faker-js/faker";
import nodeInterceptors from '@mswjs/interceptors/presets/node'
import mongoose from "mongoose";

beforeAll(async () => {
 config.APP_ENV = 'JEST';

 config.MONGO_URL = global.__MONGO_URI__;
 config.EMAIL_DEFAULT_WELCOME_FROM_EMAIL = faker.internet.email();
 config.LOGS_ENABLE_SENTRY = false;
 config.LOGS_ENABLE_CLOUDWATCH = false;
 config.LOGS_ENABLE_CONSOLE = false;
 config.EMAIL_SES_HOST = 'https://email.eu-west-1.amazonaws.com/';

 await MongoDB.connect(config);
});

beforeEach(async () => {
 global.interceptor = new BatchInterceptor({
 name: 'my-interceptor',
 interceptors: nodeInterceptors,
 });

 interceptor.apply();

 interceptor.on('request', ({request, requestId}) => {
 // This allows us to fake sending emails via SES
 // TODO add one for SMTP
 if (request.url === config.EMAIL_SES_HOST) {
 request.respondWith(new Response(
 '<SendEmailResponse xmlns="http://ses.amazonaws.com/doc/2010-12-01/">' +
 '<SendEmailResult>' +
 '<MessageId>0102018e1161bc00-332b3f83-4295-4b94-912b-f3f983a8a1f9-000000</MessageId>' +
 '</SendEmailResult>' +
 '<ResponseMetadata>' +
 '<RequestId>24239c14-b187-4bea-b458-31a7c7d02a26</RequestId>' +
 '</ResponseMetadata>' +
 '</SendEmailResponse>',
 {
 status: 200,
 }
 ));
 }
 });

 const collections = await mongoose.connection.db.collections();
 for (const collection of collections) {
 await mongoose.connection.db.dropCollection(collection.collectionName);
 }
});

afterAll(async () => {
 await MongoDB.close();
});

I also tend to add some helper components, namely a base record creator like so:

BaseFixture.js

import mongoose from "mongoose";

export default class {
 static collectionName;

 static getBaseRecord() {
 return {};
 }

 static async createBaseRecords(records) {
 const recordsInserted = [];
 for (const record of records) {
 let recordInserted = {...this.getBaseRecord(), ...record};

 const res = await mongoose.connection.db.collection(this.collectionName)
 .insertOne(recordInserted);

 recordInserted._id = res.insertedId;
 recordsInserted.push(recordInserted);
 }

 return recordsInserted;
 }
}

UserFixture.js

import User from "../../models/User";
import {faker} from "@faker-js/faker";
import BaseFixture from "./BaseFixture";

export default class extends BaseFixture {
 static collectionName = User.collectionName();

 static getBaseRecord() {
 return {
 first_name: faker.person.firstName(),
 last_name: faker.person.lastName(),
 email: faker.internet.email().toLowerCase(),
 status: 'ACTIVATE',
 user_roles: ['grp_coach'],
 // password123
 password: '$2a$10$koNBPtKwiVjKkQbnnVBrAOdIjflMnC/OzYzy/OhXjOLPr9RSjwe4K',
 password_salt: '$2a$20$piAYssU0VGLwhWbZRhCT5e'
 };
 }
}

So an example unit test making use of these would be:

import {afterAll, beforeAll, describe, expect, it, test} from '@jest/globals';
import * as LoginController from '../../../controllers/LoginController';
import RequestMock from "../../mocks/RequestMock";
import ResponseMock from "../../mocks/ResponseMock";
import UserFixture from "../../fixtures/UserFixture";
import UserSubscriptionFixture from "../../fixtures/UserSubscriptionFixture";
import UnauthorizedError from "../../../exceptions/UnauthorizedError";

describe('Login Controller', () => {
 it('Should allow a user to login', async () => {
 const users = await UserFixture.createBaseRecords([{}]);
 const subs = await UserSubscriptionFixture.createBaseRecords([{
 user_id: users[0]._id,
 }])
 let response = ResponseMock.create();
 await LoginController.signIn(RequestMock.create({
 body: {
 Authenticate_type: 'FORM',
 email: users[0].email,
 password: 'password123',
 },
 portal: {
 type: 'COACH',
 }
 }), response);

 expect(response.statusCode).toEqual(200);
 });

 it ('Should not allow invalid credentials to login', async() => {
 const users = await UserFixture.createBaseRecords([{}]);
 const subs = await UserSubscriptionFixture.createBaseRecords([{
 user_id: users[0]._id,
 }])

 let exceptionThrown = null;
 const response = ResponseMock.create();
 await LoginController.signIn(RequestMock.create({
 body: {
 Authenticate_type: 'FORM',
 email: users[0].email,
 password: 'wrongpw',
 },
 portal: {
 type: 'COACH',
 }
 }), response, (e) => {
 exceptionThrown = e;
 });

 expect(exceptionThrown).toBeInstanceOf(UnauthorizedError);
 expect(exceptionThrown.message).toEqual('It seems like your password is incorrect.');
 });
});

0

ng test –include=’**/sign-in.component.spec.ts’

0

This is because NACL is used for internal routing as well so you need to add the ephemeral ports, i.e. https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html#nacl-ephemeral-ports most commonly 1024-65535, all AWS services use these ports to communicate

0