public void CreateShouldReturnIdentifiedFilterViewModel(bool value)
        {
            Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MiscFilters.Identified;
            var flaskItem = new FlaskItem(ItemRarity.Rare)
            {
                IsIdentified = value
            };

            this.CreateShouldReturnBindableFilterViewModel(expectedBindingExpression, flaskItem, null, Resources.Identified);
        }
Esempio n. 2
0
        public void ParseShouldParseFlaskIdentified()
        {
            string[] itemStringLines = this.itemStringBuilder
                                       .WithName("Bubbling Divine Life Flask of Staunching")
                                       .BuildLines();

            FlaskItem result = this.ItemParser.Parse(itemStringLines) as FlaskItem;

            Assert.IsTrue(result.IsIdentified);
        }
Esempio n. 3
0
        public void ParseShouldParseFlaskName()
        {
            const string expected = "Bubbling Divine Life Flask of Staunching";

            string[] itemStringLines = this.itemStringBuilder
                                       .WithName(expected)
                                       .BuildLines();

            FlaskItem result = this.ItemParser.Parse(itemStringLines) as FlaskItem;

            Assert.That(result.Name, Is.EqualTo(expected));
        }
Esempio n. 4
0
        public void ParseShoudParseFlaskRarity()
        {
            const ItemRarity expected = ItemRarity.Unique;

            string[] itemStringLines = this.itemStringBuilder
                                       .WithRarity(expected)
                                       .BuildLines();

            FlaskItem result = this.ItemParser.Parse(itemStringLines) as FlaskItem;

            Assert.That(result.Rarity, Is.EqualTo(expected));
        }
        public void CreateShouldReturnQualityFilterViewModel()
        {
            // arrange
            Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MiscFilters.Quality;
            var flaskItem = new FlaskItem(ItemRarity.Unique)
            {
                Quality = 20
            };

            // act & assert
            this.CreateShouldReturnBindableMinMaxFilterViewModel(expectedBindingExpression, flaskItem, flaskItem.Quality, Resources.QualityColumn);
        }
Esempio n. 6
0
        public void ParseShouldParseFlaskQuality()
        {
            const int expected = 20;

            string[] itemStringLines = this.itemStringBuilder
                                       .WithName("Bubbling Divine Life Flask of Staunching")
                                       .WithQuality(expected)
                                       .BuildLines();

            FlaskItem result = this.ItemParser.Parse(itemStringLines) as FlaskItem;

            Assert.That(result.Quality, Is.EqualTo(expected));
        }
Esempio n. 7
0
        protected override ItemWithStats ParseItemWithoutStats(string[] itemStringLines)
        {
            ItemRarity?rarity    = this.GetRarity(itemStringLines);
            var        flaskItem = new FlaskItem(rarity.Value)
            {
                Name         = itemStringLines[NameLineIndex],
                Quality      = this.GetIntegerFromFirstStringContaining(itemStringLines, Resources.QualityDescriptor),
                IsIdentified = this.IsIdentified(itemStringLines),
            };

            flaskItem.Type = this.itemTypeParser.ParseType(itemStringLines, flaskItem.Rarity, flaskItem.IsIdentified);

            return(flaskItem);
        }
Esempio n. 8
0
        public void ParseShouldSetStatsToStatsFromStatsDataService()
        {
            ItemStats expected = new ItemStats();

            string[] itemStringLines = this.itemStringBuilder
                                       .WithName("Divine Life Flask")
                                       .BuildLines();

            this.itemStatsParserMock.Setup(x => x.Parse(It.IsAny <string[]>(), false))
            .Returns(expected);

            FlaskItem result = this.ItemParser.Parse(itemStringLines) as FlaskItem;

            Assert.That(result.Stats, Is.SameAs(expected));
        }
        public void CreateShouldReturnIdentifiedFilterViewModelWithValueFromQueryRequest()
        {
            Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MiscFilters.Identified;
            var flaskItem = new FlaskItem(ItemRarity.Rare)
            {
                IsIdentified = true
            };

            var queryRequestFilter = new BoolOptionFilter
            {
                Option = false
            };

            this.CreateShouldReturnBindableFilterViewModelWithValueFromQueryRequest(expectedBindingExpression, flaskItem, Resources.Identified, queryRequestFilter);
        }
        public void CreateShouldReturnQualityFilterViewModelWithValuesFromSearchQueryRequest()
        {
            Expression <Func <SearchQueryRequest, IFilter> > expectedBindingExpression = x => x.Query.Filters.MiscFilters.Quality;
            var flaskItem = new FlaskItem(ItemRarity.Unique)
            {
                Quality = 19
            };

            var queryRequestFilter = new MinMaxFilter
            {
                Min = 15,
                Max = 20
            };

            this.CreateShouldReturnBindableMinMaxFilterViewModelWithValuesFromQueryRequest(expectedBindingExpression, flaskItem, flaskItem.Quality, Resources.QualityColumn, queryRequestFilter);
        }
        public async Task CreateShouldReturnFlaskItemListingViewModelForFlaskItem()
        {
            string quality = "+20%";

            string propertiesJson = $@"[{{""name"":""Quality"",""values"":[[""{quality}"",1]],""displayMode"":0,""type"":6}}]";

            ListingResult listingResult = GetListingResult();

            listingResult.Item.Properties = GetPropertiesList(propertiesJson);
            Item item = new FlaskItem(ItemRarity.Normal);

            FlaskItemListingViewModel result = await this.listingViewModelFactory.CreateAsync(listingResult, item) as FlaskItemListingViewModel;

            Assert.NotNull(result);
            AssertSimpleListingViewModelProperties(result, listingResult);
            Assert.That(result.Quality, Is.EqualTo(quality));
        }
Esempio n. 12
0
        public void ParseShouldSetTypeFromItemTypeParser(ItemRarity itemRarity, bool isIdentified)
        {
            const string expected = "Result from ItemTypeParser";

            string[] itemStringLines = this.itemStringBuilder
                                       .WithRarity(itemRarity)
                                       .WithIdentified(isIdentified)
                                       .WithName("Cinderswallow Urn")
                                       .BuildLines();

            this.itemTypeParserMock.Setup(x => x.ParseType(itemStringLines, itemRarity, isIdentified))
            .Returns(expected);

            FlaskItem result = this.ItemParser.Parse(itemStringLines) as FlaskItem;

            Assert.That(result.Type, Is.EqualTo(expected));
        }