public void CalculateScoresCorrectlyForOpen()
        {
            var rounds = new List <Round>
            {
                new Round(1, 0, new RoundScore(false, 0))
            };
            var expectedScores = new List <RoundScore>
            {
                new RoundScore(true, 1)
            };

            RoundScoresCalculator.Calculate(rounds).Should().BeEquivalentTo(expectedScores);
        }
        public void CalculatesForSpareAndOpen()
        {
            var rounds = new List <Round>
            {
                new Round(3, 7, new RoundScore(false, 0)),
                new Round(0, 7, new RoundScore(false, 0))
            };
            var expectedScores = new List <RoundScore>
            {
                new RoundScore(true, 10),
                new RoundScore(true, 17)
            };

            RoundScoresCalculator.Calculate(rounds).Should().BeEquivalentTo(expectedScores);
        }
        public void CalculateScoresCorrectlyForSpareAndStrike()
        {
            var rounds = new List <Round>
            {
                new Round(3, 7, new RoundScore(false, 0)),
                new Round(10, 0, new RoundScore(false, 0))
            };
            var expectedScores = new List <RoundScore>
            {
                new RoundScore(true, 20),
                new RoundScore(false, 0)
            };

            RoundScoresCalculator.Calculate(rounds).Should().BeEquivalentTo(expectedScores);
        }
        public void CalculateScoresCorrectlyForTwoStrikesAndOpen()
        {
            var rounds = new List <Round>
            {
                new Round(10, 0, new RoundScore(false, 0)),
                new Round(5, 2, new RoundScore(false, 0)),
                new Round(10, 0, new RoundScore(false, 0))
            };
            var expectedScores = new List <RoundScore>
            {
                new RoundScore(true, 17),
                new RoundScore(true, 24),
                new RoundScore(false, 0)
            };

            RoundScoresCalculator.Calculate(rounds).Should().BeEquivalentTo(expectedScores);
        }
        public void CalculateScoresCorrectlyForThreeConsecutiveStrikes()
        {
            var rounds = new List <Round>
            {
                new Round(10, 0, new RoundScore(false, 0)),
                new Round(10, 0, new RoundScore(false, 0)),
                new Round(10, 0, new RoundScore(false, 0))
            };
            var expectedScores = new List <RoundScore>
            {
                new RoundScore(true, 30),
                new RoundScore(false, 0),
                new RoundScore(false, 0)
            };

            RoundScoresCalculator.Calculate(rounds).Should().BeEquivalentTo(expectedScores);
        }
Esempio n. 6
0
        public async Task CalculateScoreShouldReturnRoundScores()
        {
            var apiEndpoint = "round-scores/calculate";

            var bodyContent = "{\"rounds\": [{\"firstRoll\": 5, \"secondRoll\": 4}]}";
            var body        = new StringContent(bodyContent, Encoding.UTF8, "application/json");

            var response = await _client.PostAsync(apiEndpoint, body);

            response.EnsureSuccessStatusCode();
            response.StatusCode.Should().Be(StatusCodes.Status200OK);

            var expectedScores = RoundScoresCalculator.Calculate(
                Enumerable.Repeat(new Round(5, 4, new RoundScore(false, 0)), 1).ToList());
            var roundScores = await response.Content.ReadAsAsync <IEnumerable <RoundScore> >();

            roundScores.Should().BeEquivalentTo(expectedScores);
        }
Esempio n. 7
0
 public IEnumerable <RoundScore> Handle(CalculateRoundScores calculateRoundScores)
 {
     return(RoundScoresCalculator.Calculate(GetRoundsFrom(calculateRoundScores)));
 }