Category: typescript

Bingo

After done with CLI, now it is time to improve a little bit the application.

1. should be more cards

For this I have replaced

 let c=new Cards();
 c.Name="Who just joined?";
 c.Id = i++;
 ret.push(c);

 c=new Cards();
 c.Name="Can you email that to everyone ?";
 c.Id = i++;
 ret.push(c);

with a local function

let i=1;
const ret=[];
let addCard = (name:string)=>{
    let c=new Cards();
    c.Name=name;
    c.Id = i++;
    ret.push(c);

}

addCard("Who just joined?");
addCard("Can you email that to everyone ?");
addCard("..., are you there ?");
addCard("Can you hear me?");
addCard("I'm sorry, I was on mute");
addCard("I'm sorry, connection issues");
addCard("Hello ? Hello ?");
addCard("Can we take this offline ?");
addCard("Can everyone see my screen ?");
addCard("No, still loading");
addCard("Sorry, I have to go to another call");

As a consequence, the pageSize for displayin via Inquirer.js should be make larger to display all items

2 . The cards should be sorted alphabetically ( easy: apply sort)

3. show cards checked  by bingo when displaying again

4. add question to end meeting ( use null for card and a message ‘End meeting”)( should this be moved into a Display Layer?)

5.
show percentage at final ( calculate and add 2 tests for this )

6.show table with cards situation after meeting ( mapping the cards to columns ). Also, putting into evidence the ones checked by sorting after checked and then after name( should this be moved into a Display Layer?)

7.show current user name instead of asking for name( use username)

All those modifications, no matter how small they are, implies time to solve.And finding correct packages that will solve your problem.

Bingo

The problem that we see is how to have the same objects configured for backend and for frontend( e.g. a Meeting is used on the backend on the WebAPI  to read from database and in the frontend to display)

In C# , there is the concept of dll / assembly that is common. In here we have the concept of yarn Workspaces : https://yarnpkg.com/lang/en/docs/cli/workspace/

What we want to achieve first is that the tests will be in a separate workspace bingo-meeting-objects-test , referencing the bingo-meeting-objects workspace

So, in order to do this, we have to modify :

1. yarn workspaces  to understand the structure and run tests
2. bingo-meeting-objects   to expose the result
3. bingo-meeting-objects–test   to import bingo-meeting-objects  
4. (depending on the projects) Other references  : Modify docker bat file to consider the new structure

Let’s detail:

For yarn workspaces  to understand the structure and run tests

So , first, we move the tests in a separate folder, bingo-meeting-objects–test   , and we run nom init and add dependencies( jest, others)

Second, we add the yarn workspace package.json in the root with the following content:

{
     “private”: true,
     “workspaces”: [“bingo-cards-api”, “bingo-meeting-objects”]
   }
     “workspaces”: [“bingo-cards-api”, “bingo-meeting-objects”, “bingo-meeting-objects-test”],
     “scripts”: {
       “test”: “cd bingo-meeting-objects-test && yarn test”
     }
}

In this manner, we can run yarn test from the root ( do not run yet!)

For bingo-meeting-objects   to expose the result

In the tsconfig.json we put those lines:

“sourceMap”: true,

“declaration”: true,

In the package.json we modify to understand the declaration

“main”: “dist/index.js”,
   “types”: “dist/index.d.ts”,

“scripts”: {
     “build”: “tsc”,
     “compile”: “tsc”,
     “test”: “jest”
   },

For bingo-meeting-objects–test   to import bingo-meeting-objects  

We add jest and others. Also, we added dependency of bingo-meeting-objects:

“dependencies”: {
     “bingo-meeting-objects”: “^1.0.0”,
  

Also, we need to modify the import of the test. Instead of the following line, when test was under subfolder test in the bingo-meeting-objects folder

import  MeetingsFactory from ‘../MeetingsFactory’;

we put

import  MeetingsFactory from “bingo-meeting-objects/MeetingsFactory”;

Now running yarn test in the root folder runs the test sucessfully

For (depending on the projects) Other references  : Modify docker bat file to consider the new structure

We had the batch file that uses docker that was running the tests and then copy the results.

For start, we move the .dockerignore from the project to the root ( to not put node_modules)

Also, we modify how we copy the files to docker

For this, we modify this line

docker cp bingo_ci_test_container:/app/coverage/cobertura-coverage.xml .   

into this line

docker cp bingo_ci_test_container:/app/bingo-meeting-objects-test/coverage/cobertura-coverage.xml .

to take into consideration the new structure

And that will be all! ( code source at https://github.com/alexandru360/PresentationBingoCards/releases/tag/yarnworkspaces )

Bingo

EndMeeting:
The score of how many cards/ what cards were checked will be available 1 hour and 5 minutes

We have already done something similar when the meeting was considered obsolete – we decided to not throw error, but use

Result< T, Error> . So I supposed to be easy …. However, it was not. Because we are modifying the results of the functions, we are supposed to modify also the tests….

First , then modification of the code. Because of the refactoring, the AllUnchecked function calls   TotalNumberOfCardsChecked.

public TotalNumberOfCardsChecked():number{
        return this.Cards.filter(it=>it.IsChecked()).length ;
    }
    public AllUnchecked(): boolean{
        return (this.TotalNumberOfCardsChecked() === 0);
    }

Now, because we cannot TotalNumberOfCardsChecked returns  Result<number, Error> , the function  AllUnchecked must be re-written :

     public TotalNumberOfCardsChecked():Result<number, Error>{
        if(this.CanSeeScore()){
            return ok(this.Cards.filter(it=>it.IsChecked()).length );
        }
        else{
            //TODO :Make a proper error
            return err(new Error(`cannot see score for ${this.Id}`));
        }
    }
    public AllUnchecked(): Result< boolean, Error>{
        
        var res=this.TotalNumberOfCardsChecked();
        console.log(" all unchecked" + res.isOk());
        return res.andThen(it=> ok(it===0));
        // const ret= res.match(
        //     (v)=>{return ok(v==0)},
        //     (error)=>{ return error}
        // );
        // return ret;
    }

Second , the test will fail. Take “card should be checked” – original code was pretty easy

import  MeetingsFactory from '../MeetingsFactory';
import Meeting from '../meeting';
describe('Check  card basic', () => {
    it('card should be checked', () => {
        const mf=new MeetingsFactory();
        const m1=mf.CreateMeeting("andrei","first meeting");
        console.log(m1.Cards.length);
        
        expect(m1.AllUnchecked()).toBe(true);
        m1.CheckCard(m1.Cards[0], m1.Participants[0]);    
        expect(m1.AllUnchecked()).toBe(false);
        expect(m1.IsCardCheckedByParticipant(m1.Cards[0], m1.Participants[0])).toBe(true);
        
        
  
      })
    
  })
  

Now it is

it('card should be checked', () => {
        const mf=new MeetingsFactory();
        const m1=mf.CreateMeeting("andrei","first meeting");
        console.log(m1.Cards.length);
        let res=m1.AllUnchecked();
        expect(res.isOk()).toBe(true);
        let result= false;
        res.map(t=> result =t);
        expect(result).toBe(true);
        let res1 = m1.CheckCardByParticipant(m1.Cards[0], m1.Participants[0]);
        expect(res1.isOk()).toBe(true);
        res=m1.AllUnchecked();
        expect(res.isOk()).toBe(true);
        result= false;
        res.map(t=> result =t);
        expect(result).toBe(false);            
        expect(m1.IsCardCheckedByParticipant(m1.Cards[0], m1.Participants[0]).isOk()).toBe(true);  
      })

Bingo

Last time we have to implement the requirement:

Meeting Obsolete:
The meeting is available for 35 minutes. After that, meeting is not available anymore.

We did so for the 35 minutes. But we did not for the last sentence – meeting is not available anymore. There are 2 points here: of design ( do not retrieve meeting ) and enforcing that no participant can write to the meeting.

So we modify the functions   AddParticipant, CheckCardByParticipant  to raise an exception if the meeting is obsolete .( As a side effect of identifying the functions that make actions in the opposite of functions that just reports, I think about structuring code in CQRS form )

Now for TypeScript we have 2 options :

1. Construct a class that inherits from Error
2. Modify the response type of those function to a combined type of result and error

For the first one , we should take care of TypeScript syntax of creating errors: See https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html  and https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work

class CustomError extends Error {

constructor(message?: string) {

super(message);

// ‘Error’ breaks prototype chain here

Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain

}

}

For the second , we could do ourselves or use a npm package such as https://github.com/gDelgado14/neverthrow

I decide to go to the second. I have too many times use the first thing in C# – it is time to have something new. Anyway, this is the code now

    import { ok, err, Result } from 'neverthrow';
//code
    public CheckCardByParticipant(c: Cards , p:Participant): Result<Meeting,Error>{
        //TODO: verify participant is added first or add
        //TODO: verify card is added first
        if(this.IsObsolete()){
            return err(new Error(`cannot check card to the obsolete meeting ${this.Id}`));
        }
        c.CheckMe(p);
        return ok(this);
    }
//code
    public AddParticipant(p:Participant ): Result<number,Error>{
        if(this.IsObsolete()){
            return err(new Error(`cannot add participant to the obsolete meeting ${this.Id}`));
        }

        this.Participants.push(p);
        return ok(this.Participants.length);
    }

and those are the tests

        const mf=new MeetingsFactory();

        const m1=mf.CreateMeeting("andrei","first meeting");
        const now = Date.now();
        const spy = jest.spyOn(Date,'now');
        spy.mockImplementation(()=>{
          console.log('calling DateTime Now');
          return now + 36 * 60* 1000;
        } );
        expect(m1.IsObsolete()).toBe(true);
        const p=new Participant();
        p.Id=70;
        p.Name ="alexandru";
        const res= m1.AddParticipant(p);
        expect(res.isOk()).toBe(false);
        spy.mockRestore();

Bingo

Meeting Obsolete:
The meeting is available for 35 minutes. After that, meeting is not available anymore.

How we can implement this ? Several solutions:

1. Make the meeting know about this ( and avoiding https://martinfowler.com/bliki/AnemicDomainModel.html )
2. Make a decorator class for this https://en.wikipedia.org/wiki/Decorator_pattern
3. Make a mixin in TypeScript https://www.typescriptlang.org/docs/handbook/mixins.html

I decide to KISS (https://en.wikipedia.org/wiki/KISS_principle ) and take the first point. We implement an Obsolete function. Remains who is responsible of the site to call it.

Now comes other question: When the meeting starts  ?I consider ( for the sake of easy path) that a meeting starts when it is created . So the code is like this

export default class Meeting{

    constructor(){
        this.Participants = [];        
        this.Cards = [];
        this.startedMeeting = Date.now();
    }
    public static  MaxTime=35 * 60 * 1000;
    // other code here
    public IsObsolete(): boolean{
        return (this.PassedTimeFromStart() > Meeting.MaxTime); //35 minutes
    }
    public PassedTimeFromStart():number{
        let dtNow =  Date.now();
        console.log(dtNow);
        return (dtNow - this.startedMeeting );
    }

Now the problem arises when testing code. It is very easy to say that a meeting is not obsolete when just created. However , I do not want to wait for 35minutes + 1 second in order for a meeting to become obsolete and the test to be successful( see
//TODO: wait 35 minutes + 1 second

below).

import  MeetingsFactory from '../MeetingsFactory';
import Meeting from '../meeting';
describe('Meeting Obsolete', () => {
    it('meeting should not be obsolete after creation', () => {
        const mf=new MeetingsFactory();
        const m1=mf.CreateMeeting("andrei","first meeting");
        expect(m1.IsObsolete()).toBe(false);
        
        
  
      })
      it('meeting should  be obsolete after 35 minutes', () => {
        const mf=new MeetingsFactory();

        const m1=mf.CreateMeeting("andrei","first meeting");
        //TODO: wait 35 minutes + 1 second
        expect(m1.IsObsolete()).toBe(true);
        
  
      })
  })
  

One possible resolution is https://ayende.com/blog/3408/dealing-with-time-in-tests . However, the problem is so common that here must be include in the test framework ( in this case, jest). And , indeed, it is a way: spyon. So the code is modified accordingly :

it('meeting should  be obsolete after 35 minutes', () => {
        const mf=new MeetingsFactory();

        const m1=mf.CreateMeeting("andrei","first meeting");
        const now = Date.now();
        const spy = jest.spyOn(Date,'now');
        spy.mockImplementation(()=>{
          console.log('calling DateTime Now');
          return now + 36 * 60* 1000;
        } );
        expect(m1.IsObsolete()).toBe(true);
        //spy.mockClear();        
        spy.mockRestore();
        expect(m1.IsObsolete()).toBe(false);
        
  
      })

The testing code now assumes that he knows inner working of the code – and the test will fail if we modify the call of Date.now().
So I think that https://ayende.com/blog/3408/dealing-with-time-in-tests is far superior.

Bingo

Checking cards:
A total score will be displayed when checking / unchecking

There are 2 things very clear:

1. The name of the user story is not reflecting the content
2. It should not be just the total score, but also should be the percentage of the bingo cards checked from the total number of cards. It is not so difficult to have the total number of cards, so let’s add this.

We have put this code:

public TotalNumberOfCardsChecked():number{
        return this.Cards.filter(it=>it.IsChecked()).length ;
    }
    

And we put test

it('number of cards checked', () => {
        const mf=new MeetingsFactory();
        const m1=mf.CreateMeeting("andrei","first meeting");
        console.log(m1.Cards.length);
        
        expect(m1.TotalNumberOfCardsChecked()).toBe(0);
        m1.CheckCardByParticipant(m1.Cards[0], m1.Participants[0]);    
        expect(m1.TotalNumberOfCardsChecked()).toBe(1);
        
        
  
      })

We see that for TotalNumberOfCardsChecked and AllUnchecked we have the same code

public AllUnchecked(): boolean{
        return (this.Cards.filter(it=>it.IsChecked()).length === 0);
    }
    //other code
public TotalNumberOfCardsChecked():number{
        return this.Cards.filter(it=>it.IsChecked()).length ;
    }

and because we hate copy paste we refactor and re-test

So we refactor a bit .

public AllUnchecked(): boolean{
        return (this.TotalNumberOfCardsChecked() === 0);
    }

And because we have tests, that means we are pretty confident of what are we doing

Also, we said that we have to calculate the total number of checked cards. This is not so difficult, and it alleviates the Law of Dots /Demeter (https://haacked.com/archive/2009/07/14/law-of-demeter-dot-counting.aspx)

public TotalNumberOfCards():number{
        return this.Cards.length;
    }

The consequence ? To maintain code coverage, we should add another line of test:

expect(m1.TotalNumberOfCards()).toBe(Cards.DefaultCards().length);
 

Also, because the requirement says to display, and we are not yet to the GUI, I have put a new note that says

Design:
– [ ] display total number of cards checked or percentage ( use TotalNumberOfCardsChecked and/or TotalNumberOfCards)

Bingo

Other use case for Bingo Meetings was Share meeting bingo(https://github.com/alexandru360/PresentationBingoCards/projects/1#card-24165765)

Share Meeting Bingo:

As a User, I can receive the meeting Id( url) . When going to this url , I can ( optionally) enter my name and check cards.

So how to implement this  ? A Meeting contains an array of Cards and a array of Participants. How a Participant can check cards ?

There are several solutions for this:

1. The Participant can have an Id of the meeting, is going to some form of database( even in memory , like a singleton collection of Meetings), retrieve the meeting, retrieve the cards, check the card
2. The participant raise an event ( PleaseCheckThisCardForMe) , the meeting listens and checks the meeting
3. The participant have a real reference of the cards and checks the cards
4. The meeting has a  CheckCardByParticipant that someone can call ( leaving the responsibility later  – maybe on API )

We ( me and Alexandru Badita we have choosed the latest solution. So we came with the following :

public CheckCardByParticipant(c: Cards , p:Participant){
        //TODO: verify participant is added first or add
        //TODO: verify card is added first
        c.CheckMe(p);
    }

and a test

import  MeetingsFactory from '../MeetingsFactory';
import Meeting from '../meeting';
describe('Check  card basic', () => {
    it('card should be checked', () => {
        const mf=new MeetingsFactory();
        const m1=mf.CreateMeeting("andrei","first meeting");
        console.log(m1.Cards.length);
        
        expect(m1.AllUnchecked()).toBe(true);
        m1.CheckCardByParticipant(m1.Cards[0], m1.Participants[0]);    
        expect(m1.AllUnchecked()).toBe(false);
        expect(m1.IsCardCheckedByParticipant(m1.Cards[0], m1.Participants[0])).toBe(true);
        
        
  
      })
    
  })
  

Obviously, from TODO, we have to put more code and more tests – but for the moment we think that nobody will want to break our application on purpose….