public void GetModels_ShouldReturnCorrectResult([Frozen] Mock <IInputLineParser> inputLineParserMock,
                                                        string line,
                                                        InputLineModel model,
                                                        TestInputStrategy sut)
        {
            // arrange
            inputLineParserMock.Setup(m => m.Parse(line)).Returns(model);
            sut.ParseLine(line);

            // act
            var actual = sut.GetModels();

            // assert
            actual.ShouldHaveSingleItem().ShouldBe(model);
        }
        public void Parse_ShouldReturnCorrectResult([Frozen] Mock <IInputLineModelBuilder> builderMock,
                                                    string line,
                                                    InputLineModel model,
                                                    InputLineParser sut)
        {
            // arrange
            builderMock.Setup(m => m.Build()).Returns(model);

            // act
            var actual = sut.Parse(line);

            // assert
            model.AsSource()
            .OfLikeness <InputLineModel>()
            .With(m => m.Id).EqualsWhen((m, i) => m.Id == i.Id)
            .With(m => m.Name).EqualsWhen((m, i) => m.Name == i.Name)
            .With(m => m.Quantities).EqualsWhen((m, i) => m.Quantities.SequenceEqual(i.Quantities))
            .ShouldEqual(actual);
        }
        public InputLineModel Build()
        {
            if (IsComment)
            {
                return(null);
            }

            IsValid = !string.IsNullOrEmpty(_id) && !string.IsNullOrEmpty(_name);

            var model = new InputLineModel
            {
                Id         = _id,
                Name       = _name,
                Quantities = _quantities
            };

            _id         = null;
            _name       = null;
            _quantities = new List <InputLineQuantityModel>();

            return(model);
        }
        public void Load_ShouldReturnCorrectResult(IFixture fixture, [Frozen] Mock <IInputLineParser> inputLineParserMock, string line, InputLineModel model)
        {
            // arrange
            inputLineParserMock.Setup(m => m.Parse(line)).Returns(model);

            var filePath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.tmp");

            using (var file = File.OpenWrite(filePath))
            {
                using (var streamWriter = new StreamWriter(file))
                {
                    streamWriter.WriteLine(line);
                }
            }

            fixture.Customize(new TextFileInputStrategyCustomization(filePath));

            var sut = fixture.Create <TextFileInputStrategy>();

            // act
            sut.Load();

            // assert
            var actual = sut.GetModels();

            actual.ShouldHaveSingleItem().ShouldBe(model);

            // teardown
            if (File.Exists(filePath))
            {
                File.Delete(filePath);
            }
        }