卡片组作为面试练习

/* *** in the file Card.ts ***** */
    // Picture cards (Jack, Queen, King and Ace) will have matching numeric rank
    enum PictureCardType {Jack = 11, Queen = 12, King = 13, Ace = 1};

    enum SuiteType { Hearts , Diamonds, Spades, Clubs};


    class Card {
        private _rank: number;
        private _type: SuiteType;
        private _isPicture = function() : boolean {
           return this._rank > 10 || this._rank === 1;
        }

        constructor(rank: number, type: SuiteType) {
            if (rank > 0 && rank < 14)
                this._rank = rank;
            else
                throw new RangeError("card rank outside the range");
            this._type = type;
        }

        get rank() : number {
            return this._rank;
        }

        get suiteType() : SuiteType {
            return this._type;
        }
        // convert to JS object that has the following format: {suite: 'Dimaonds', rank : 'Ace'}
        toJSObject(): any {
            return {suite: SuiteType[this._type], rank: this._isPicture()  ?  PictureCardType[this._rank] : this._rank.toString() };
        }

    }

    export {Card , PictureCardType, SuiteType};

/* *** CardDeck.ts **** */
import {Card, SuiteType} from './card';
import {cardShuffler} from './cardShuffler';


interface cardDeckContract {
    cards : Card[];
    shuffle(): void;
    dealCard(): Card;
}

let privateCards : Card[];

// Hey, why not use JavaScript generator to deal sequence of cards?
// This might be over-architecture, but it is a way to show the usage of generators
let getNexCard =  function*() {
    while (privateCards.length > 0) {
        let card: Card = privateCards.splice(0, 1)[0];
        yield card;
    }
};
// initiallize the generator
let cardSequence : IterableIterator<Card> = getNexCard();

// Class CardDeck is responsible of implementing the contract above: Shuffle and Deal a card

class CardDeck implements cardDeckContract {

    cardShuffler: cardShuffler;

    /// CardDeck is not the class that has shuffling algorithm.
    /// We pass the shuffling algorithm to its constructor as a simple way of Dependency Injection
    /// This decision will help us chose different shuffling ways in the future.
    /// So the CardDeck is like Strategy Pattern
    constructor(cards: Card[], cardShuffler: cardShuffler) {
        privateCards = cards.slice(0);
        // this is the shuffling utility passed to the class
        this.cardShuffler = cardShuffler;
    }

    shuffle()  {
        // calling the shuffling
        let copy = this.cardShuffler.shuffle(privateCards);
        // slice(0) is a simple way to do array cloning
        privateCards = copy.slice(0);
    }

    get cards() : Card[]  {
        return privateCards;
    }

    // dealCard is implemented as iterator though the usage of Generator in JavaScript ES6
    // see the code above
    dealCard() : Card {
        return cardSequence.next().value;
    }

}

export default CardDeck;

/* CardShuffler.ts */
import {Card, SuiteType} from './card';

// cardShuffler is the contract the define shuffling array of cards

export interface cardShuffler {
    shuffle(inputCards: Card[]) : Card[];
}


// this is a simple implementation of a shuffling algorithm
export class simpleCardShuffler implements cardShuffler {
    shuffle(inputCards: Card[]) : Card[] {
        // we implement a simple shuffling algorithm
        var copy: Card[] = [], n : number = inputCards.length, i : number;
        while(n) {
            i = Math.floor(Math.random() * n--);
            copy.push(inputCards.splice(i, 1)[0]);
        }
        return copy.slice(0);
    }
}


// in the future, and for more requirements we can implement different shuffling logic here, that can be injected into the CardDeck

/* CardDeckFactory *** */
import CardDeck from './cardDeck';
import {Card, SuiteType} from './card';
import {simpleCardShuffler, cardShuffler} from './cardShuffler';

let buildStandardDeck = function() : Card[]{
    let cards = new Array<Card>();

    for (let suite in SuiteType) {
        if (!isNaN(parseInt(suite))) {
            let suiteAsNumber: number = parseInt(suite);
            for (let rank = 1; rank < 14; rank++) {
                cards.push(new Card(rank, suiteAsNumber));
            }
        }
    }
    return cards;
};

// this is the CardDeck Factory
// it is responsible of building CardDeck with the proper dependencies

export class CardDeckFactory {
    // StandardDeck is a CardDeck with the standard playing cards (52), and the simpleCardShuffler
    public static CreateStandardDeck() : CardDeck {

        return new CardDeck(buildStandardDeck(), new simpleCardShuffler());
    }
}

CardDeck-test.ts

/* CardDeck-test.ts */
import { suite, test } from "mocha-typescript";
import {expect} from 'chai';
import * as mocha from 'mocha';
import * as Sinon from 'sinon';

import CardDeck from '../src/model/cardDeck';
import {Card, SuiteType}  from '../src/model/card';
import {cardShuffler, simpleCardShuffler} from '../src/model/cardShuffler';



describe ("CardDeck Tests", function() {

    let testCards: Card[] = [
        new Card(2, SuiteType.Clubs), 
        new Card(11, SuiteType.Hearts), 
        new Card(5, SuiteType.Diamonds),
        new Card(8, SuiteType.Spades),
        new Card(10, SuiteType.Diamonds)
        ];
    let proposedLength : number = testCards.length;


    @suite("When shuffle")
    class Basic {
        subject: CardDeck;
        mockCardShuffler : Sinon.SinonMock;
        before() {
            /* We create a mock for the cardShuffler, and pass the mock to the cardDeck
             If you are used to mock framework in .NET, Java, then you will find
             this mocking unusual.
             Sinon mocking is different that .NET , Java common mocking frameworks.
             As you see we create a concrete object of simpleCardShuffler.
             But even with this, we mock its method "shuffle", so when we call that method, 
             it is not simpleCardShuffler's method that is going to run, but it is our mock. */
            let shuffler = new simpleCardShuffler();
            this.mockCardShuffler = Sinon.mock(shuffler);
            // As you see here , we mock the method shuffle
            this.mockCardShuffler.expects("shuffle").returns([]);
            this.subject =  new CardDeck(testCards, shuffler);
        }


        @test("should call the shuffler passed from constructor")
        assert_shuffle_result_length() {
            // make sure that before shuffle we have all test cards (5)
            expect(this.subject.cards.length).to.equals(proposedLength);
            // Now this call the passed parameter, but as we mocked the method, then it is our mock that will be called.
            this.subject.shuffle();
            expect(this.subject.cards.length).to.equals(0)
            this.mockCardShuffler.verify();  // verify that we got the call 
            this.mockCardShuffler.restore(); // restore everything back and the class simpleCardShuffler will be back as it used to be
        }

    }

    describe ("When deal a card", function() {

        @suite("and when there are cards in the deck")
        class NextCardWithCards {

            subject: CardDeck;

            before() {
                this.subject =  new CardDeck(testCards, null);
                proposedLength = testCards.length;
            }
            @test("should get the first card from the deck") 
            assert_nextCad() {
                let card = this.subject.dealCard();
                expect(card.rank).to.equal(2);
                expect(card.suiteType).to.equal(SuiteType.Clubs);
            }


            @test("and the deck should be reduced by one card") 
            assert_cardRemoved() {
                expect(this.subject.cards.length).to.equal(proposedLength);
                let card = this.subject.dealCard();
                expect(this.subject.cards.length).to.equal(proposedLength - 1);
            }
        }

        @suite("and when there are no more cards in the deck")
        class NextCardWithoutCards {

            subject: CardDeck;

            before() {
                this.subject =  new CardDeck(testCards, null);
            }
            @test("should get undefined") 
            assert_nextCad() {
                var n = testCards.length;
                let localcard : Card;
                while(n--) {
                    localcard = this.subject.dealCard();
                    expect(localcard).to.be.not.null;
                }
                localcard = this.subject.dealCard();
                expect(localcard).to.be.undefined;
            }
        }
    });
});

/* Card-test.ts */

import {suite, test} from 'mocha-typescript';
import * as mocha from 'mocha';
import {Card, PictureCardType, SuiteType} from '../src/model/card';
import {expect} from 'chai';
describe("Card tests", function() {
    @suite("When create a new Card")
    class Basic {
        @test("can pass a numeric value as rank property")
        assert_rank_assignment() {
            var subject: Card = new Card(10, SuiteType.Clubs);

            expect(subject.rank).to.equal(10);
            expect(subject.suiteType).to.equal(SuiteType.Clubs);
        }   

        @test("or passing a picture type as rank property")
        assert_rank_assignment_with_picture_parameter() {
            var subject: Card = new Card(PictureCardType.Jack, SuiteType.Hearts);
            expect(subject.rank).to.equal(11);
            expect(subject.suiteType).to.equal(SuiteType.Hearts);
        }

        @test("should fail when rank is outside 1-13 range")
        assert_fail() {
            expect(() => {
                var subject: Card = new Card(14, SuiteType.Diamonds);
            }).to.throw("rank outside the range");
        }
    }

    @suite("When dealing with picture cards")
    class RankType{
        @test("should be able to switch between the Jack card and its equivalant numeric 11")
        assert_jack() {
            var subject: Card = new Card(PictureCardType.Jack, SuiteType.Diamonds);
            expect(subject.rank).to.equal(11);
            expect(subject.rank).to.equal(PictureCardType.Jack);
        }
    }


            //and dealing with a picture card"
        @suite("When convert a JavaScript Object")
        class JSObjectTest {
            obj: any;
            before() {
                var subject : Card =  new Card(PictureCardType.Jack, SuiteType.Diamonds);
                this.obj = subject.toJSObject();
            }
            @test("should convert suiteType to its string name")
            assert_suitename() {
                expect(this.obj.suite).to.equal('Diamonds');
            }
            @test("should convert rank to its picture name for picture cards")
            assert_jsonPictureCard() {
                expect(this.obj.rank).to.equal('Jack');
            }

            @test("should convert rank to its numeric value numeric cards")
            assert_jsonNumeriCard() {
                var subject : Card =  new Card(5, SuiteType.Diamonds);
                var json: any = subject.toJSObject();
                expect(json.rank).to.equal('5');
            }

        }


});

const values = [1,2,3,4,5,6,7,8,9,10,11,12,13];
const suits = ['HEARTS', 'CLUBS', 'SPADES', 'DIAMONDS'];

/**
 * Builds a deck, an array of { suite, value }.
 * @return Array The new deck.
 */
export function createDeck(){
  const values.reduce((c, v) => ([ ...c, ...suits.map(s => ({ value: v, suit: s })) ]), []);
}

/**
 * Shuffles a deck.
 * @param Array deck The deck to shuffle.
 * @return Array The shuffled deck.
 */
export function shuffleDeck(deck){
  // Shuffle logic. Make sure you aren't mutating deck.
  return shuffledDeck;
}

/**
 * Chooses a card from the top of the deck
 * @param Array deck The deck to draw from.
 * @return Object An object that contains the next card and the changed deck
 */
export function dealOneCard(deck){
  if(!deck.length) throw new Error('Deck is empty');
  return { card: deck[0], deck: deck.slice(1) };
}

class CardDeck {
    cards: String[];

    constructor(cards: String[]) {
        this.cards = cards.slice(0);
    }

    shuffle()  {
        // Fisher-Yates
        for (let i = this.cards.length - 1; i--; i > 0) {
            let j = Math.floor(Math.random() * (i + 1));
            [this.cards[i], this.cards[j]] = [this.cards[j], this.cards[i]];
        }
    }

    deal(): String {
        return cards.pop();
    }
}