Exemplo n.º 1
0
        public async Task Should_not_create_merge_compress_mods_due_to_no_game_set()
        {
            var messageBus = new Mock <IMessageBus>();

            messageBus.Setup(p => p.PublishAsync(It.IsAny <IMessageBusEvent>()));
            messageBus.Setup(p => p.Publish(It.IsAny <IMessageBusEvent>()));
            var storageProvider  = new Mock <IStorageProvider>();
            var modParser        = new Mock <IModParser>();
            var reader           = new Mock <IReader>();
            var modWriter        = new Mock <IModWriter>();
            var gameService      = new Mock <IGameService>();
            var mapper           = new Mock <IMapper>();
            var modPatchExporter = new Mock <IModPatchExporter>();
            var modMergeExporter = new Mock <IModMergeExporter>();
            var infoProvider     = new Mock <IDefinitionInfoProvider>();

            gameService.Setup(p => p.GetSelected()).Returns((IGame)null);

            var service = new ModMergeService(null, null, new Cache(), messageBus.Object, modPatchExporter.Object, modMergeExporter.Object,
                                              new List <IDefinitionInfoProvider>()
            {
                infoProvider.Object
            }, reader.Object, modWriter.Object,
                                              modParser.Object, gameService.Object, storageProvider.Object, mapper.Object);

            var result = await service.MergeCompressCollectionAsync("test", "test");

            result.Should().BeNull();
        }
Exemplo n.º 2
0
        public async Task Should_not_create_merge_compress_mods_due_to_no_collection_name()
        {
            var messageBus = new Mock <IMessageBus>();

            messageBus.Setup(p => p.PublishAsync(It.IsAny <IMessageBusEvent>()));
            messageBus.Setup(p => p.Publish(It.IsAny <IMessageBusEvent>()));
            var storageProvider  = new Mock <IStorageProvider>();
            var modParser        = new Mock <IModParser>();
            var reader           = new Mock <IReader>();
            var modWriter        = new Mock <IModWriter>();
            var gameService      = new Mock <IGameService>();
            var mapper           = new Mock <IMapper>();
            var modPatchExporter = new Mock <IModPatchExporter>();
            var modMergeExporter = new Mock <IModMergeExporter>();
            var infoProvider     = new Mock <IDefinitionInfoProvider>();
            var parserManager    = new Mock <IParserManager>();

            gameService.Setup(p => p.GetSelected()).Returns(new Game()
            {
                Type              = "Should_not_create_file_merge_mod_due_to_no_collection_name",
                UserDirectory     = "C:\\Users\\Fake",
                WorkshopDirectory = "C:\\Fake"
            });

            var service = new ModMergeService(null, parserManager.Object, new Cache(), messageBus.Object, modPatchExporter.Object, modMergeExporter.Object,
                                              new List <IDefinitionInfoProvider>()
            {
                infoProvider.Object
            }, reader.Object, modWriter.Object,
                                              modParser.Object, gameService.Object, storageProvider.Object, mapper.Object);

            var result = await service.MergeCompressCollectionAsync(string.Empty, "test");

            result.Should().BeNull();
        }
Exemplo n.º 3
0
        public async Task Should_create_merge_compress_mods()
        {
            DISetup.SetupContainer();

            var messageBus = new Mock <IMessageBus>();

            messageBus.Setup(p => p.PublishAsync(It.IsAny <IMessageBusEvent>()));
            messageBus.Setup(p => p.Publish(It.IsAny <IMessageBusEvent>()));
            var  storageProvider  = new Mock <IStorageProvider>();
            var  modParser        = new Mock <IModParser>();
            var  reader           = new Mock <IReader>();
            var  modWriter        = new Mock <IModWriter>();
            var  gameService      = new Mock <IGameService>();
            var  mapper           = new Mock <IMapper>();
            var  modPatchExporter = new Mock <IModPatchExporter>();
            var  modMergeExporter = new Mock <IModMergeExporter>();
            var  infoProvider     = new Mock <IDefinitionInfoProvider>();
            var  compressExporter = new Mock <IModMergeCompressExporter>();
            bool isValid          = false;

            compressExporter.Setup(p => p.Start()).Returns(1);
            compressExporter.Setup(p => p.AddFile(It.IsAny <ModMergeCompressExporterParameters>())).Callback((ModMergeCompressExporterParameters p) =>
            {
                if (p.QueueId.Equals(1) && p.FileName.Equals("descriptor.mod"))
                {
                    isValid = true;
                }
            });
            compressExporter.Setup(p => p.Finalize(It.IsAny <long>(), It.IsAny <string>())).Returns(true);
            gameService.Setup(p => p.GetSelected()).Returns(new Game()
            {
                Type              = "Should_create_file_merge_mod",
                UserDirectory     = "C:\\Users\\Fake",
                WorkshopDirectory = new List <string>()
                {
                    "C:\\fake"
                },
                CustomModDirectory = string.Empty
            });
            var collections = new List <IModCollection>()
            {
                new ModCollection()
                {
                    IsSelected = true,
                    Mods       = new List <string>()
                    {
                        "mod/fakemod.mod"
                    },
                    Name = "test",
                    Game = "Should_create_file_merge_mod"
                }
            };

            storageProvider.Setup(s => s.GetModCollections()).Returns(() =>
            {
                return(collections);
            });
            var fileInfos = new List <IFileInfo>()
            {
                new FileInfo()
                {
                    Content = new List <string>()
                    {
                        "a"
                    },
                    FileName = "fakemod.mod",
                    IsBinary = false
                }
            };

            reader.Setup(s => s.Read(It.IsAny <string>(), It.IsAny <IEnumerable <string> >(), It.IsAny <bool>())).Returns(fileInfos);
            modParser.Setup(s => s.Parse(It.IsAny <IEnumerable <string> >())).Returns((IEnumerable <string> values) =>
            {
                return(new ModObject()
                {
                    FileName = values.First(),
                    Name = values.First()
                });
            });
            mapper.Setup(s => s.Map <IMod>(It.IsAny <IModObject>())).Returns((IModObject o) =>
            {
                return(new Mod()
                {
                    FileName = o.FileName,
                    Name = o.Name
                });
            });
            modWriter.Setup(p => p.ModDirectoryExists(It.IsAny <ModWriterParameters>())).Returns((ModWriterParameters p) =>
            {
                return(false);
            });


            var service = new ModMergeService(null, compressExporter.Object, new Cache(), messageBus.Object, modPatchExporter.Object, modMergeExporter.Object,
                                              new List <IDefinitionInfoProvider>()
            {
                infoProvider.Object
            }, reader.Object, modWriter.Object,
                                              modParser.Object, gameService.Object, storageProvider.Object, mapper.Object);

            var result = await service.MergeCompressCollectionAsync("test", "test");

            result.Should().NotBeNull();
            result.Count().Should().Be(1);
            isValid.Should().BeTrue();
        }