public async Task NoDeliveriesFound_DoesntRequireHost()
        {
            var provider = Substitute.For<ISqlSyntaxProvider>();
            provider.DoesTableExist(Arg.Any<Database>(), Arg.Any<string>()).Returns(true);

            SqlSyntaxContext.SqlSyntaxProvider = provider;

            var settings = Substitute.For<IChauffeurSettings>();
            string s;
            settings.TryGetChauffeurDirectory(out s).Returns(x =>
            {
                x[0] = @"c:\foo";
                return true;
            });

            var conn = Substitute.For<IDbConnection>();
            var db = new Database(conn);

            var writer = new MockTextWriter();

            var fs = new MockFileSystem(new Dictionary<string, MockFileData>
            {
                {@"c:\foo\bar.txt", new MockFileData("This is not a deliverable")}
            });

            var deliverable = new DeliveryDeliverable(null, writer, db, settings, fs, null);

            await deliverable.Run(null, null);

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
        }
        public async Task NoArgumentsWillWriteOutMessage()
        {
            var writer = new MockTextWriter();
            var deliverable = new UserDeliverable(null, writer, null);

            await deliverable.Run("user", new string[0]);

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
        }
        public async Task ChangePasswordWillFailIfExpectedArgumentsAreNotProvided()
        {
            var writer = new MockTextWriter();
            var deliverable = new UserDeliverable(null, writer, null);

            await deliverable.Run("user", new[] { "change-password" });

            Assert.That(writer.Messages.Count(), Is.EqualTo(2));
        }
        public async Task WhatOnly_WillWarnAndExit()
        {
            var writer   = new MockTextWriter();
            var delivery = new ChangeAliasDeliverable(writer, null, null);

            await delivery.Run(null, new[] { "dt" });

            Assert.Single(writer.Messages);
        }
        public async Task MissingNewAlias_WillWarnAndExit()
        {
            var writer   = new MockTextWriter();
            var delivery = new ChangeAliasDeliverable(writer, null, null);

            await delivery.Run(null, new[] { "dt", "old" });

            Assert.Equal(writer.Messages.Count(), 1);
        }
        public async Task NoArguments_WillWarnAndExit()
        {
            var writer   = new MockTextWriter();
            var delivery = new ChangeAliasDeliverable(writer, null, null);

            await delivery.Run(null, new string[0]);

            Assert.Equal(writer.Messages.Count(), 1);
        }
        public async Task ChangePasswordWillFailIfExpectedArgumentsAreNotProvided()
        {
            var writer      = new MockTextWriter();
            var deliverable = new UserDeliverable(null, writer, null);

            await deliverable.Run("user", new[] { "change-password" });

            Assert.That(writer.Messages.Count(), Is.EqualTo(2));
        }
        public async Task NonNumericalUserIdWillCauseAnError()
        {
            var writer      = new MockTextWriter();
            var deliverable = new UserDeliverable(null, writer, null);

            await deliverable.Run("user", new[] { "change-password", "a", "a", "a" });

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
        }
Example #9
0
        public async Task NoArgumentsWillWriteOutMessage()
        {
            var writer      = new MockTextWriter();
            var deliverable = new UserDeliverable(null, writer, null);

            await deliverable.Run("user", new string[0]);

            Assert.Equal(writer.Messages.Count(), 1);
        }
Example #10
0
        public async Task ChangeUserWillFailIfExpectedArgumentsAreNotProvided()
        {
            var writer      = new MockTextWriter();
            var deliverable = new UserDeliverable(null, writer, null);

            await deliverable.Run("user", new[] { "change-name" });

            Assert.Equal(writer.Messages.Count(), 2);
        }
        public async Task MissingConnectionString_WillWarnAndExit()
        {
            var writer = new MockTextWriter();
            var settings = Substitute.For<IChauffeurSettings>();
            var deliverable = new InstallDeliverable(null, writer, null, settings, null, null);

            await deliverable.Run(null, null);

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
        }
        public async Task MissingConnectionString_WillWarnAndExit()
        {
            var writer      = new MockTextWriter();
            var settings    = Substitute.For <IChauffeurSettings>();
            var deliverable = new InstallDeliverable(null, writer, null, settings, null, null);

            await deliverable.Run(null, null);

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
        }
        public async Task FoundDeliveryPreviouslyRun_WillBeSkipped()
        {
            var provider = Substitute.For <ISqlSyntaxProvider>();

            provider.DoesTableExist(Arg.Any <Database>(), Arg.Any <string>()).Returns(true);

            SqlSyntaxContext.SqlSyntaxProvider = provider;

            var    settings = Substitute.For <IChauffeurSettings>();
            string s;

            settings.TryGetChauffeurDirectory(out s).Returns(x =>
            {
                x[0] = @"c:\foo";
                return(true);
            });

            var reader = Substitute.For <IDataReader>();

            reader.Read().Returns(true, false);
            reader.GetBoolean(Arg.Any <int>()).Returns(true);
            reader.GetInt32(Arg.Any <int>()).Returns(1);
            reader.GetString(Arg.Any <int>()).Returns(string.Empty);
            reader.GetDateTime(Arg.Any <int>()).Returns(DateTime.Now);
            reader.GetValue(Arg.Any <int>()).Returns(DateTime.Now);
            reader.FieldCount.Returns(5); //the number of properties on the table
            reader.GetName(Arg.Any <int>()).Returns("Id", "Name", "ExecutionDate", "SignedFor", "Hash");
            reader.GetFieldType(Arg.Any <int>()).Returns(typeof(int), typeof(string), typeof(DateTime), typeof(bool), typeof(string));
            var cmd = Substitute.For <IDbCommand>();

            cmd.ExecuteReader().Returns(reader);
            cmd.ExecuteScalar().Returns(1);
            var conn = Substitute.For <IDbConnection>();

            conn.CreateCommand().Returns(cmd);
            var db = new Database(conn);

            var writer = new MockTextWriter();

            var deliverableScript = "foo";
            var fs = new MockFileSystem(new Dictionary <string, MockFileData>
            {
                { @"c:\foo\bar.delivery", new MockFileData(deliverableScript) }
            });

            var host = Substitute.For <IChauffeurHost>();

            host.Run(Arg.Any <string[]>()).Returns(Task.FromResult(DeliverableResponse.Continue));

            var deliverable = new DeliveryDeliverable(null, writer, db, settings, fs, host);

            await deliverable.Run(null, new string[0]);

            host.Received(0).Run(Arg.Any <string[]>()).IgnoreAwaitForNSubstituteAssertion();
        }
        public async Task HelpProvidesDirections()
        {
            var container   = Substitute.For <IContainer>();
            var writer      = new MockTextWriter();
            var deliverable = new HelpDeliverable(null, writer, container);

            container.ResolveDeliverableByName(Arg.Is("help")).Returns(deliverable);

            await deliverable.Run(null, new[] { "help" });

            Assert.Equal(4, writer.Messages.Count());
        }
Example #15
0
        public async Task WillAlwaysGetAFullTable()
        {
            var writer   = new MockTextWriter();
            var settings = Substitute.For <IChauffeurSettings>();

            settings.ConnectionString.Returns(new System.Configuration.ConnectionStringSettings("umbracoDbDNS", ""));

            var deliverable = new SettingsDeliverable(null, writer, settings);

            await deliverable.Run(null, null);

            Assert.Equal(5, writer.Messages.Count());
        }
Example #16
0
        public async Task UserIdNotMatchingAnyWillCauseAnError()
        {
            var writer = new MockTextWriter();
            var userService = Substitute.For<IUserService>();
            userService.GetByUsername(Arg.Any<string>()).Returns((IUser)null);

            var deliverable = new UserDeliverable(null, writer, userService);

            await deliverable.Run("user", new[] { "change-password", "0", "a" });

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
            userService.Received(1).GetByUsername(Arg.Any<string>());
        }
Example #17
0
        public async Task ValidUserWillHaveTheirPasswordUpdated()
        {
            var writer = new MockTextWriter();
            var userService = Substitute.For<IUserService>();
            var user = Substitute.For<IUser>();
            userService.GetByUsername(Arg.Any<string>()).Returns(user);

            var deliverable = new UserDeliverable(null, writer, userService);

            await deliverable.Run("user", new[] { "change-password", "0", "ab" });

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
            userService.Received(1).SavePassword(user, "ab");
        }
Example #18
0
        public async Task UserIdForChangeUserNameNotMatchingAnyWillCauseAnError()
        {
            var writer      = new MockTextWriter();
            var userService = Substitute.For <IUserService>();

            userService.GetByUsername(Arg.Any <string>()).Returns((IUser)null);

            var deliverable = new UserDeliverable(null, writer, userService);

            await deliverable.Run("user", new[] { "change-loginname", "0", "c" });

            Assert.Equal(writer.Messages.Count(), 1);
            userService.Received(1).GetByUsername(Arg.Any <string>());
        }
        public async Task UserIdNotMatchingAnyWillCauseAnError()
        {
            var writer   = new MockTextWriter();
            var provider = Substitute.For <UmbracoMembershipProviderBase>();

            provider.GetUser(Arg.Any <int>(), false).Returns((MembershipUser)null);

            var deliverable = new UserDeliverable(null, writer, provider);

            await deliverable.Run("user", new[] { "change-password", "0", "a", "a" });

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
            provider.Received(1).GetUser(Arg.Any <int>(), false);
        }
        public async Task UserIdNotMatchingAnyWillCauseAnError()
        {
            var writer      = new MockTextWriter();
            var userService = Substitute.For <IUserService>();

            userService.GetByUsername(Arg.Any <string>()).Returns((IUser)null);

            var deliverable = new UserDeliverable(null, writer, userService, null);

            await deliverable.Run("user", new[] { "change-password", "0", "a" });

            Assert.Single(writer.Messages);
            userService.Received(1).GetByUsername(Arg.Any <string>());
        }
Example #21
0
        public async Task WhenExportingPackageItIsAddedToTheDelivery()
        {
            var reader = Substitute.For <TextReader>();

            reader.ReadLineAsync().Returns(Task.FromResult(""));

            var writer     = new MockTextWriter();
            var fileSystem = new MockFileSystem();
            var settings   = Substitute.For <IChauffeurSettings>();

            settings.TryGetChauffeurDirectory(out string s).Returns((x) =>
            {
                x[0] = @"c:\foo";
                return(true);
            });

            var contentTypeService = Substitute.For <IContentTypeService>();

            contentTypeService.GetAllContentTypes().ReturnsForAnyArgs(Enumerable.Empty <IContentType>());
            var dataTypeService = Substitute.For <IDataTypeService>();

            dataTypeService.GetAllDataTypeDefinitions().ReturnsForAnyArgs(Enumerable.Empty <IDataTypeDefinition>());
            var fileService = Substitute.For <IFileService>();

            fileService.GetTemplates().ReturnsForAnyArgs(Enumerable.Empty <ITemplate>());
            fileService.GetStylesheets().ReturnsForAnyArgs(Enumerable.Empty <Stylesheet>());
            var macroService = Substitute.For <IMacroService>();

            macroService.GetAll().ReturnsForAnyArgs(Enumerable.Empty <IMacro>());
            var packagingService = Substitute.For <IPackagingService>();

            var deliverable = new ScaffoldDeliverable(
                reader,
                writer,
                settings,
                fileSystem,
                contentTypeService,
                dataTypeService,
                fileService,
                macroService,
                packagingService);

            await deliverable.Run("", new string[0]);

            var file    = fileSystem.GetFile(@"c:\foo\001-Setup.delivery");
            var content = file.TextContents.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

            Assert.Equal("package 001-Setup", content[2]);
        }
Example #22
0
        public async Task ValidUserWillHaveTheirPasswordUpdated()
        {
            var writer      = new MockTextWriter();
            var userService = Substitute.For <IUserService>();
            var user        = Substitute.For <IUser>();

            userService.GetByUsername(Arg.Any <string>()).Returns(user);

            var deliverable = new UserDeliverable(null, writer, userService);

            await deliverable.Run("user", new[] { "change-password", "0", "ab" });

            Assert.Equal(writer.Messages.Count(), 1);
            userService.Received(1).SavePassword(user, "ab");
        }
        public async Task DisplaysAllAvailableDeliverables()
        {
            var container = Substitute.For <IContainer>();

            var writer = new MockTextWriter();

            container.ResolveAllDeliverables().Returns(new[] { new MockDeliverable(writer) });

            var deliverable = new HelpDeliverable(null, writer, container);

            await deliverable.Run(null, new string[0]);

            Assert.Equal(2, writer.Messages.Count());
            Assert.Equal("mock (aliases: m)", writer.Messages.Last());
        }
        public async Task DisplaysHelpForSingleDeliverable()
        {
            var container = Substitute.For <IContainer>();

            var writer          = new MockTextWriter();
            var mockDeliverable = new MockDeliverable(writer);

            container.ResolveDeliverableByName(Arg.Is("mock")).Returns(mockDeliverable);

            var deliverable = new HelpDeliverable(null, writer, container);

            await deliverable.Run(null, new[] { "mock" });

            Assert.Equal("I have directions", writer.Messages.First());
        }
        public async Task DisplaysErrorWhenDeliverableDoesntProvideDirections()
        {
            var container = Substitute.For <IContainer>();

            var writer          = new MockTextWriter();
            var mockDeliverable = new MockDeliverableNoDirections(writer);

            container.ResolveDeliverableByName(Arg.Is("mock2")).Returns(mockDeliverable);

            var deliverable = new HelpDeliverable(null, writer, container);

            await deliverable.Run(null, new[] { "mock2" });

            Assert.Equal("The deliverable 'mock2' doesn't implement help, you best contact the author", writer.Messages.First());
        }
        public async Task WhenRunWithMissingParameters_ErrorsAndOutputsMissingParameters()
        {
            var provider = Substitute.For <ISqlSyntaxProvider>();

            provider.DoesTableExist(Arg.Any <Database>(), Arg.Any <string>()).Returns(true);

            var settings = Substitute.For <IChauffeurSettings>();

            settings.TryGetChauffeurDirectory(out var s).Returns(x =>
            {
                x[0] = @"c:\foo";
                return(true);
            });

            var cmd = Substitute.For <IDbCommand>();

            cmd.ExecuteScalar().Returns(1);
            var conn = Substitute.For <IDbConnection>();

            conn.CreateCommand().Returns(cmd);
            var db = new Database(conn);

            var writer = new MockTextWriter();

            var deliverableScript = "foo $test$ $bar$ $baz$";
            var fs = new MockFileSystem(new Dictionary <string, MockFileData>
            {
                { @"c:\foo\bar.delivery", new MockFileData(deliverableScript) }
            });

            var host = Substitute.For <IChauffeurHost>();

            host.Run(Arg.Any <string[]>()).Returns(Task.FromResult(DeliverableResponse.Continue));

            var dbSchema = new DatabaseSchemaHelper(db, null, provider);

            var deliverable = new DeliveryDeliverable(null, writer, dbSchema, db, settings, fs, host, provider);

            await deliverable.Run(null, Array.Empty <string>());

            Assert.Equal(new[]
            {
                "The following parameters have not been specified:",
                " - bar",
                " - baz",
                " - test"
            }, writer.Messages);
        }
Example #27
0
        public async Task WhenExportingPackageItCreatesAnXmlFile()
        {
            var reader = Substitute.For <TextReader>();

            reader.ReadLineAsync().Returns(Task.FromResult(""));

            var writer     = new MockTextWriter();
            var fileSystem = new MockFileSystem();
            var settings   = Substitute.For <IChauffeurSettings>();

            settings.TryGetChauffeurDirectory(out string s).Returns((x) =>
            {
                x[0] = @"c:\foo";
                return(true);
            });

            var contentTypeService = Substitute.For <IContentTypeService>();

            contentTypeService.GetAllContentTypes().ReturnsForAnyArgs(Enumerable.Empty <IContentType>());
            var dataTypeService = Substitute.For <IDataTypeService>();

            dataTypeService.GetAllDataTypeDefinitions().ReturnsForAnyArgs(Enumerable.Empty <IDataTypeDefinition>());
            var fileService = Substitute.For <IFileService>();

            fileService.GetTemplates().ReturnsForAnyArgs(Enumerable.Empty <ITemplate>());
            fileService.GetStylesheets().ReturnsForAnyArgs(Enumerable.Empty <Stylesheet>());
            var macroService = Substitute.For <IMacroService>();

            macroService.GetAll().ReturnsForAnyArgs(Enumerable.Empty <IMacro>());
            var packagingService = Substitute.For <IPackagingService>();

            var deliverable = new ScaffoldDeliverable(
                reader,
                writer,
                settings,
                fileSystem,
                contentTypeService,
                dataTypeService,
                fileService,
                macroService,
                packagingService);

            await deliverable.Run("", new string[0]);

            var file = fileSystem.GetFile(@"c:\foo\001-Setup.xml");

            Assert.NotNull(file);
        }
        public async Task ValidUserWillHaveTheirPasswordUpdated()
        {
            var writer   = new MockTextWriter();
            var provider = Substitute.For <UmbracoMembershipProviderBase>();
            var user     = Substitute.For <MembershipUser>();

            user.ChangePassword("a", "ab").Returns(true);
            provider.GetUser(Arg.Any <int>(), false).Returns(user);

            var deliverable = new UserDeliverable(null, writer, provider);

            await deliverable.Run("user", new[] { "change-password", "0", "a", "ab" });

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
            user.Received(1).ChangePassword("a", "ab");
        }
Example #29
0
        public async Task CanGetConnectionString()
        {
            var          writer   = new MockTextWriter();
            var          settings = Substitute.For <IChauffeurSettings>();
            const string expected = "Data Source=|DataDirectory|\\Umbraco.sdf;Flush Interval=1;";

            settings.ConnectionString.Returns(new System.Configuration.ConnectionStringSettings("umbracoDbDNS", expected));

            var deliverable = new SettingsDeliverable(null, writer, settings);

            await deliverable.Run(null, null);

            var actual = string.Join("|", writer.Messages.Skip(4).First().Split('|').Skip(1)).Trim();

            Assert.Equal(expected, actual);
        }
Example #30
0
        public async Task NotFoundPackageAbortsEarly()
        {
            var    writer   = new MockTextWriter();
            var    settings = Substitute.For <IChauffeurSettings>();
            string dir;

            settings.TryGetChauffeurDirectory(out dir).Returns(x =>
            {
                x[0] = "";
                return(true);
            });
            var package = new PackageDeliverable(null, writer, new MockFileSystem(), settings, null);

            await package.Run(null, new[] { "Test" });

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
        }
Example #31
0
        public async Task ValidUserWillHaveTheirNameUpdated()
        {
            var writer      = new MockTextWriter();
            var userService = Substitute.For <IUserService>();
            var user        = Substitute.For <IUser>();

            user.Name = "a";
            userService.GetByUsername("a").Returns(user);

            var deliverable = new UserDeliverable(null, writer, userService);

            await deliverable.Run("user", new[] { "change-name", "a", "ab" });

            Assert.Equal(writer.Messages.Count(), 1);
            Assert.Equal("ab", user.Name);
            userService.Received(1).Save(user);
        }
        public async Task DeliverableExitsIfPackageNotFound()
        {
            var    writer   = new MockTextWriter();
            var    settings = Substitute.For <IChauffeurSettings>();
            string dir;

            settings.TryGetChauffeurDirectory(out dir).Returns(x =>
            {
                x[0] = "";
                return(true);
            });
            var package = new DictionaryDeliverable(null, writer, new MockFileSystem(), settings, null);

            await package.Run(null, new[] { "Test" });

            Assert.Single(writer.Messages);
        }
        public async Task DatabaseError_WillStillAttemptFirstDeliverableThenCreateTableAgain()
        {
            var ex = Substitute.For <DbException>();

            var provider = Substitute.For <ISqlSyntaxProvider>();

            provider.Format(Arg.Any <ICollection <ForeignKeyDefinition> >()).Returns(new List <string>());
            provider.Format(Arg.Any <ICollection <IndexDefinition> >()).Returns(new List <string>());
            provider.DoesTableExist(Arg.Any <Database>(), Arg.Any <string>()).Returns(_ => { throw ex; }, _ => true);

            SqlSyntaxContext.SqlSyntaxProvider = provider;

            var conn = Substitute.For <IDbConnection>();
            var cmd  = Substitute.For <IDbCommand>();

            cmd.ExecuteScalar().Returns(1);
            conn.CreateCommand().Returns(cmd);
            var db = new Database(conn);

            var    settings = Substitute.For <IChauffeurSettings>();
            string s;

            settings.TryGetChauffeurDirectory(out s).Returns(x =>
            {
                x[0] = @"c:\foo";
                return(true);
            });

            var writer = new MockTextWriter();

            var fs = new MockFileSystem(new Dictionary <string, MockFileData>
            {
                { @"c:\foo\bar.delivery", new MockFileData("install") }
            });

            var host = Substitute.For <IChauffeurHost>();

            host.Run(Arg.Any <string[]>()).Returns(Task.FromResult(DeliverableResponse.Continue));

            var deliverable = new DeliveryDeliverable(null, writer, db, settings, fs, host);

            await deliverable.Run(null, new string[0]);

            cmd.Received().CommandText = Arg.Any <string>();
        }
        public async Task WhenRunWithParameters_ParametersSubsitutedToDeliverable()
        {
            var provider = Substitute.For <ISqlSyntaxProvider>();

            provider.DoesTableExist(Arg.Any <Database>(), Arg.Any <string>()).Returns(true);

            SqlSyntaxContext.SqlSyntaxProvider = provider;

            var    settings = Substitute.For <IChauffeurSettings>();
            string s;

            settings.TryGetChauffeurDirectory(out s).Returns(x =>
            {
                x[0] = @"c:\foo";
                return(true);
            });

            var cmd = Substitute.For <IDbCommand>();

            cmd.ExecuteScalar().Returns(1);
            var conn = Substitute.For <IDbConnection>();

            conn.CreateCommand().Returns(cmd);
            var db = new Database(conn);

            var writer = new MockTextWriter();

            var deliverableScript = "foo $bar$";
            var fs = new MockFileSystem(new Dictionary <string, MockFileData>
            {
                { @"c:\foo\bar.delivery", new MockFileData(deliverableScript) }
            });

            var host = Substitute.For <IChauffeurHost>();

            host.Run(Arg.Any <string[]>()).Returns(Task.FromResult(DeliverableResponse.Continue));

            var deliverable = new DeliveryDeliverable(null, writer, db, settings, fs, host);

            await deliverable.Run(null, new[] { "-p:bar=baz" });

            host.Received(1)
            .Run(Arg.Is <string[]>(x => x[0] == "foo baz"))
            .IgnoreAwaitForNSubstituteAssertion();
        }
        public async Task ProvidingValidDocTypeAlias_WillUpdateToNewAlias(string what)
        {
            var writer = new MockTextWriter();

            var          cts    = Substitute.For <IContentTypeService>();
            const string old    = "old";
            const string @new   = "new";
            var          result = Substitute.For <IContentType>();

            result.Alias = old;
            cts.GetContentType(Arg.Is(old)).Returns(result);

            var deliverable = new ChangeAliasDeliverable(writer, null, cts);

            await deliverable.Run(null, new[] { what, old, @new });

            Assert.Equal(result.Alias, @new);
        }
        public async Task StopDeliverableName_WillOnlyRunUpToNamedDeliverable()
        {
            var provider = Substitute.For <ISqlSyntaxProvider>();

            provider.DoesTableExist(Arg.Any <Database>(), Arg.Any <string>()).Returns(true);

            var    settings = Substitute.For <IChauffeurSettings>();
            string s;

            settings.TryGetChauffeurDirectory(out s).Returns(x =>
            {
                x[0] = @"c:\foo";
                return(true);
            });

            var cmd = Substitute.For <IDbCommand>();

            cmd.ExecuteScalar().Returns(1);
            var conn = Substitute.For <IDbConnection>();

            conn.CreateCommand().Returns(cmd);
            var db = new Database(conn);

            var writer = new MockTextWriter();

            var deliverableScript = "foo";
            var fs = new MockFileSystem(new Dictionary <string, MockFileData>
            {
                { @"c:\foo\001.delivery", new MockFileData(deliverableScript) },
                { @"c:\foo\002.delivery", new MockFileData(deliverableScript) }
            });

            var host = Substitute.For <IChauffeurHost>();

            host.Run(Arg.Any <string[]>()).Returns(Task.FromResult(DeliverableResponse.Continue));

            var dbSchema = new DatabaseSchemaHelper(db, null, provider);

            var deliverable = new DeliveryDeliverable(null, writer, dbSchema, db, settings, fs, host, provider);

            await deliverable.Run(null, new[] { "-s:002.delivery" });

            host.Received(1).Run(Arg.Any <string[]>()).IgnoreAwaitForNSubstituteAssertion();
        }
        public async Task DatabaseError_WillStillAttemptFirstDeliverableThenCreateTableAgain()
        {
            var ex =Substitute.For<DbException>();

            var provider = Substitute.For<ISqlSyntaxProvider>();
            provider.Format(Arg.Any<ICollection<ForeignKeyDefinition>>()).Returns(new List<string>());
            provider.Format(Arg.Any<ICollection<IndexDefinition>>()).Returns(new List<string>());
            provider.DoesTableExist(Arg.Any<Database>(), Arg.Any<string>()).Returns(_ => { throw ex; }, _ => true);

            SqlSyntaxContext.SqlSyntaxProvider = provider;

            var conn = Substitute.For<IDbConnection>();
            var cmd = Substitute.For<IDbCommand>();
            cmd.ExecuteScalar().Returns(1);
            conn.CreateCommand().Returns(cmd);
            var db = new Database(conn);

            var settings = Substitute.For<IChauffeurSettings>();
            string s;
            settings.TryGetChauffeurDirectory(out s).Returns(x =>
            {
                x[0] = @"c:\foo";
                return true;
            });

            var writer = new MockTextWriter();

            var fs = new MockFileSystem(new Dictionary<string, MockFileData>
            {
                {@"c:\foo\bar.delivery", new MockFileData("install")}
            });

            var host = Substitute.For<IChauffeurHost>();
            host.Run(Arg.Any<string[]>()).Returns(Task.FromResult(DeliverableResponse.Continue));

            var deliverable = new DeliveryDeliverable(null, writer, db, settings, fs, host);

            await deliverable.Run(null, null);

            cmd.Received().CommandText = Arg.Any<string>();
        }
        public async Task NotFoundPackageAbortsEarly()
        {
            var writer = new MockTextWriter();
            var settings = Substitute.For<IChauffeurSettings>();
            string dir;
            settings.TryGetChauffeurDirectory(out dir).Returns(x =>
            {
                x[0] = "";
                return true;
            });
            var package = new PackageDeliverable(null, writer, new MockFileSystem(), settings, null, null);

            await package.Run(null, new[] { "Test" });

            Assert.That(writer.Messages.Count(), Is.EqualTo(1));
        }
        public async Task HavingMacrosWillReadThemIn()
        {
            var writer = new MockTextWriter();
            var settings = Substitute.For<IChauffeurSettings>();
            string dir;
            settings.TryGetChauffeurDirectory(out dir).Returns(x =>
            {
                x[0] = "";
                return true;
            });
            var fs = new MockFileSystem(new Dictionary<string, MockFileData>
            {
                { "Text.xml", new MockFileData(macrosXml) }
            });
            var packagingService = Substitute.For<IPackagingService>();
            packagingService.ImportMacros(Arg.Any<XElement>()).Returns(Enumerable.Empty<IMacro>());

            var package = new PackageDeliverable(null, writer, fs, settings, packagingService, Substitute.For<IContentTypeService>());

            await package.Run(null, new[] { "Text" });

            packagingService.Received(1).ImportMacros(Arg.Any<XElement>());
        }
        public async Task FoundDeliveryPreviouslyRun_WillBeSkipped()
        {
            var provider = Substitute.For<ISqlSyntaxProvider>();
            provider.DoesTableExist(Arg.Any<Database>(), Arg.Any<string>()).Returns(true);

            SqlSyntaxContext.SqlSyntaxProvider = provider;

            var settings = Substitute.For<IChauffeurSettings>();
            string s;
            settings.TryGetChauffeurDirectory(out s).Returns(x =>
            {
                x[0] = @"c:\foo";
                return true;
            });

            var reader = Substitute.For<IDataReader>();
            reader.Read().Returns(true, false);
            reader.GetBoolean(Arg.Any<int>()).Returns(true);
            reader.GetInt32(Arg.Any<int>()).Returns(1);
            reader.GetString(Arg.Any<int>()).Returns(string.Empty);
            reader.GetDateTime(Arg.Any<int>()).Returns(DateTime.Now);
            reader.GetValue(Arg.Any<int>()).Returns(DateTime.Now);
            reader.FieldCount.Returns(5); //the number of properties on the table
            reader.GetName(Arg.Any<int>()).Returns("Id", "Name", "ExecutionDate", "SignedFor", "Hash");
            reader.GetFieldType(Arg.Any<int>()).Returns(typeof(int), typeof(string), typeof(DateTime), typeof(bool), typeof(string));
            var cmd = Substitute.For<IDbCommand>();
            cmd.ExecuteReader().Returns(reader);
            cmd.ExecuteScalar().Returns(1);
            var conn = Substitute.For<IDbConnection>();
            conn.CreateCommand().Returns(cmd);
            var db = new Database(conn);

            var writer = new MockTextWriter();

            var deliverableScript = "foo";
            var fs = new MockFileSystem(new Dictionary<string, MockFileData>
            {
                {@"c:\foo\bar.delivery", new MockFileData(deliverableScript)}
            });

            var host = Substitute.For<IChauffeurHost>();
            host.Run(Arg.Any<string[]>()).Returns(Task.FromResult(DeliverableResponse.Continue));

            var deliverable = new DeliveryDeliverable(null, writer, db, settings, fs, host);

            await deliverable.Run(null, null);

            host.Received(0).Run(Arg.Any<string[]>()).IgnoreAwaitForNSubstituteAssertion();
        }
        public async Task FoundDeliveryNotPreviouslyRun_WillBeGivenToTheHost()
        {
            var provider = Substitute.For<ISqlSyntaxProvider>();
            provider.DoesTableExist(Arg.Any<Database>(), Arg.Any<string>()).Returns(true);

            SqlSyntaxContext.SqlSyntaxProvider = provider;

            var settings = Substitute.For<IChauffeurSettings>();
            string s;
            settings.TryGetChauffeurDirectory(out s).Returns(x =>
            {
                x[0] = @"c:\foo";
                return true;
            });

            var cmd = Substitute.For<IDbCommand>();
            cmd.ExecuteScalar().Returns(1);
            var conn = Substitute.For<IDbConnection>();
            conn.CreateCommand().Returns(cmd);
            var db = new Database(conn);

            var writer = new MockTextWriter();

            var deliverableScript = "foo";
            var fs = new MockFileSystem(new Dictionary<string, MockFileData>
            {
                {@"c:\foo\bar.delivery", new MockFileData(deliverableScript)}
            });

            var host = Substitute.For<IChauffeurHost>();
            host.Run(Arg.Any<string[]>()).Returns(Task.FromResult(DeliverableResponse.Continue));

            var deliverable = new DeliveryDeliverable(null, writer, db, settings, fs, host);

            await deliverable.Run(null, null);

            host.Received(1).Run(Arg.Any<string[]>()).IgnoreAwaitForNSubstituteAssertion();
        }