diff --git a/src/Umbraco.Core/Configuration/UmbracoVersion.cs b/src/Umbraco.Core/Configuration/UmbracoVersion.cs index 8e7387ba2e..908426637c 100644 --- a/src/Umbraco.Core/Configuration/UmbracoVersion.cs +++ b/src/Umbraco.Core/Configuration/UmbracoVersion.cs @@ -5,7 +5,7 @@ namespace Umbraco.Core.Configuration { public class UmbracoVersion { - private static readonly Version Version = new Version("6.0.0"); + private static readonly Version Version = new Version("6.1.0"); /// /// Gets the current version of Umbraco. diff --git a/src/Umbraco.Core/CoreBootManager.cs b/src/Umbraco.Core/CoreBootManager.cs index bab1269932..b1cac29d63 100644 --- a/src/Umbraco.Core/CoreBootManager.cs +++ b/src/Umbraco.Core/CoreBootManager.cs @@ -197,26 +197,10 @@ namespace Umbraco.Core MacroPropertyTypeResolver.Current = new MacroPropertyTypeResolver( PluginManager.Current.ResolveMacroPropertyTypes()); - //TODO: Y U NO WORK? - //MigrationResolver.Current = new MigrationResolver( - // PluginManager.Current.ResolveMigrationTypes()); + //the database migration objects + MigrationResolver.Current = new MigrationResolver( + () => PluginManager.Current.ResolveMigrationTypes()); - //the database migration objects - MigrationResolver.Current = new MigrationResolver(new List - { - typeof (MigrationsVersionFourNineZero.RemoveUmbracoAppConstraints), - typeof (DeleteAppTables), - typeof (EnsureAppsTreesUpdated), - typeof (MoveMasterContentTypeData), - typeof (NewCmsContentType2ContentTypeTable), - typeof (RemoveMasterContentTypeColumn), - typeof (RenameCmsTabTable), - typeof (RenameTabIdColumn), - typeof (UpdateCmsContentTypeAllowedContentTypeTable), - typeof (UpdateCmsContentTypeTable), - typeof (UpdateCmsContentVersionTable), - typeof (UpdateCmsPropertyTypeGroupTable) - }); PropertyEditorValueConvertersResolver.Current = new PropertyEditorValueConvertersResolver( PluginManager.Current.ResolvePropertyEditorValueConverters()); diff --git a/src/Umbraco.Core/Models/Rdbms/ServerRegistrationDto.cs b/src/Umbraco.Core/Models/Rdbms/ServerRegistrationDto.cs new file mode 100644 index 0000000000..f7da0ea2ef --- /dev/null +++ b/src/Umbraco.Core/Models/Rdbms/ServerRegistrationDto.cs @@ -0,0 +1,32 @@ +using System; +using Umbraco.Core.Persistence; +using Umbraco.Core.Persistence.DatabaseAnnotations; + +namespace Umbraco.Core.Models.Rdbms +{ + [TableName("umbracoServer")] + [PrimaryKey("id")] + [ExplicitColumns] + internal class ServerRegistrationDto + { + [Column("id")] + [PrimaryKeyColumn(AutoIncrement = true)] + public int Id { get; set; } + + [Column("address")] + [Length(100)] + public string Address { get; set; } + + [Column("registeredDate")] + [Constraint(Default = "getdate()")] + public DateTime DateRegistered { get; set; } + + [Column("lastNotifiedDate")] + [Constraint(Default = "getdate()")] + public DateTime LastNotified { get; set; } + + [Column("isActive")] + [Index(IndexTypes.NonClustered)] + public bool IsActive { get; set; } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Models/ServerRegistration.cs b/src/Umbraco.Core/Models/ServerRegistration.cs new file mode 100644 index 0000000000..7e8fa70f44 --- /dev/null +++ b/src/Umbraco.Core/Models/ServerRegistration.cs @@ -0,0 +1,46 @@ +using System; +using Umbraco.Core.Models.EntityBase; +using Umbraco.Core.Sync; + +namespace Umbraco.Core.Models +{ + internal class ServerRegistration : Entity, IServerAddress, IAggregateRoot + { + public ServerRegistration() + { + + } + + /// + /// Creates an item with pre-filled properties + /// + /// + /// + /// + /// + public ServerRegistration(int id, string serverAddress, DateTime createDate, DateTime updateDate) + { + UpdateDate = updateDate; + CreateDate = createDate; + Key = Id.ToString().EncodeAsGuid(); + Id = id; + ServerAddress = serverAddress; + } + + /// + /// Creates a new instance for persisting a new item + /// + /// + /// + public ServerRegistration(string serverAddress, DateTime createDate) + { + CreateDate = createDate; + UpdateDate = createDate; + Key = 0.ToString().EncodeAsGuid(); + ServerAddress = serverAddress; + } + + public string ServerAddress { get; set; } + public bool IsActive { get; set; } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs b/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs index 7c19253ca9..1a13f866d0 100644 --- a/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs +++ b/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs @@ -18,7 +18,8 @@ namespace Umbraco.Core.ObjectResolution private IEnumerable _applicationInstances = null; private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(); private readonly string _httpContextKey; - private readonly List _instanceTypes = new List(); + private readonly List _instanceTypes = new List(); + private IEnumerable _sortedValues = null; private int _defaultPluginWeight = 10; @@ -128,12 +129,13 @@ namespace Umbraco.Core.ObjectResolution /// protected IEnumerable GetSortedValues() { - var values = Values.ToList(); - - // FIXME - so we're re-sorting each time? - - values.Sort((f1, f2) => GetObjectWeight(f1).CompareTo(GetObjectWeight(f2))); - return values; + if (_sortedValues == null) + { + var values = Values.ToList(); + values.Sort((f1, f2) => GetObjectWeight(f1).CompareTo(GetObjectWeight(f2))); + _sortedValues = values; + } + return _sortedValues; } /// @@ -147,7 +149,12 @@ namespace Umbraco.Core.ObjectResolution set { _defaultPluginWeight = value; } } - int GetObjectWeight(object o) + /// + /// Returns the weight of an object for user with GetSortedValues + /// + /// + /// + protected virtual int GetObjectWeight(object o) { var type = o.GetType(); var attr = type.GetCustomAttribute(true); @@ -427,16 +434,16 @@ namespace Umbraco.Core.ObjectResolution /// /// Inserts a type before a specified, already existing type. /// - /// The existing type before which to insert. + /// The existing type before which to insert. /// The type to insert. /// the resolver does not support inserting types, or /// one of the types is not a valid type for the resolver, or the existing type is not in the collection, /// or the new type is already in the collection of types. - public void InsertTypeBefore() - where Texisting : TResolved + public void InsertTypeBefore() + where TExisting : TResolved where T : TResolved { - InsertTypeBefore(typeof(Texisting), typeof(T)); + InsertTypeBefore(typeof(TExisting), typeof(T)); } /// diff --git a/src/Umbraco.Core/Persistence/Factories/ServerRegistrationFactory.cs b/src/Umbraco.Core/Persistence/Factories/ServerRegistrationFactory.cs new file mode 100644 index 0000000000..36759f4759 --- /dev/null +++ b/src/Umbraco.Core/Persistence/Factories/ServerRegistrationFactory.cs @@ -0,0 +1,33 @@ +using System.Globalization; +using Umbraco.Core.Models; +using Umbraco.Core.Models.Rdbms; + +namespace Umbraco.Core.Persistence.Factories +{ + internal class ServerRegistrationFactory : IEntityFactory + { + #region Implementation of IEntityFactory + + public ServerRegistration BuildEntity(ServerRegistrationDto dto) + { + return new ServerRegistration(dto.Id, dto.Address, dto.DateRegistered, dto.LastNotified); + } + + public ServerRegistrationDto BuildDto(ServerRegistration entity) + { + var dto = new ServerRegistrationDto() + { + Address = entity.ServerAddress, + DateRegistered = entity.CreateDate, + IsActive = entity.IsActive, + LastNotified = entity.UpdateDate + }; + if (entity.HasIdentity) + dto.Id = short.Parse(entity.Id.ToString(CultureInfo.InvariantCulture)); + + return dto; + } + + #endregion + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs b/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs index 9a39c4c43b..fefafcef63 100644 --- a/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs +++ b/src/Umbraco.Core/Persistence/Mappers/MappingResolver.cs @@ -8,6 +8,9 @@ namespace Umbraco.Core.Persistence.Mappers { internal static BaseMapper ResolveMapperByType(Type type) { + if (type == typeof (ServerRegistration)) + return ServerRegistrationMapper.Instance; + if (type == typeof (IContent) || type == typeof (Content)) return ContentMapper.Instance; diff --git a/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs b/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs index 1eafceacbd..5f519d9772 100644 --- a/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs +++ b/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs @@ -14,7 +14,7 @@ namespace Umbraco.Core.Persistence.Mappers { private static readonly ConcurrentDictionary PropertyInfoCache = new ConcurrentDictionary(); - internal static PropertyGroupMapper Instance = new PropertyGroupMapper(); + internal static readonly PropertyGroupMapper Instance = new PropertyGroupMapper(); private PropertyGroupMapper() { diff --git a/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs b/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs new file mode 100644 index 0000000000..14bac03138 --- /dev/null +++ b/src/Umbraco.Core/Persistence/Mappers/ServerRegistrationMapper.cs @@ -0,0 +1,49 @@ +using System; +using System.Collections.Concurrent; +using System.Linq.Expressions; +using Umbraco.Core.Models; +using Umbraco.Core.Models.Rdbms; + +namespace Umbraco.Core.Persistence.Mappers +{ + internal sealed class ServerRegistrationMapper : BaseMapper + { + private static readonly ConcurrentDictionary PropertyInfoCache = new ConcurrentDictionary(); + + internal static readonly ServerRegistrationMapper Instance = new ServerRegistrationMapper(); + + private ServerRegistrationMapper() + { + BuildMap(); + } + + #region Overrides of BaseMapper + + internal override void BuildMap() + { + CacheMap(src => src.Id, dto => dto.Id); + CacheMap(src => src.IsActive, dto => dto.IsActive); + CacheMap(src => src.ServerAddress, dto => dto.Address); + CacheMap(src => src.CreateDate, dto => dto.DateRegistered); + CacheMap(src => src.UpdateDate, dto => dto.LastNotified); + } + + internal override string Map(string propertyName) + { + if (!PropertyInfoCache.ContainsKey(propertyName)) + return string.Empty; + + var dtoTypeProperty = PropertyInfoCache[propertyName]; + + return base.GetColumnName(dtoTypeProperty.Type, dtoTypeProperty.PropertyInfo); + } + + internal override void CacheMap(Expression> sourceMember, Expression> destinationMember) + { + var property = base.ResolveMapping(sourceMember, destinationMember); + PropertyInfoCache.AddOrUpdate(property.SourcePropertyName, property, (x, y) => property); + } + + #endregion + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs b/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs index 756d97ff13..4aa5ee7ec4 100644 --- a/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs +++ b/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs @@ -60,7 +60,8 @@ namespace Umbraco.Core.Persistence.Migrations.Initial }, {38, typeof (User2AppDto)}, {39, typeof (User2NodeNotifyDto)}, - {40, typeof (User2NodePermissionDto)} + {40, typeof (User2NodePermissionDto)}, + {41, typeof (ServerRegistrationDto)} }; #endregion @@ -110,7 +111,9 @@ namespace Umbraco.Core.Persistence.Migrations.Initial { result.ValidTables.Add(tableName); } - var invalidTableDifferences = tablesInDatabase.Except(tablesInSchema); + var invalidTableDifferences = + tablesInDatabase.Except(tablesInSchema) + .Union(tablesInSchema.Except(tablesInDatabase)); foreach (var tableName in invalidTableDifferences) { result.Errors.Add(new Tuple("Table", tableName)); diff --git a/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaResult.cs b/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaResult.cs index 7cf0b2eb5f..3b77d23450 100644 --- a/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaResult.cs +++ b/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaResult.cs @@ -43,28 +43,31 @@ namespace Umbraco.Core.Persistence.Migrations.Initial return new Version(0, 0, 0); //If Errors is empty or if TableDefinitions tables + columns correspond to valid tables + columns then we're at current version - if (Errors.Any() == false || - TableDefinitions.Any(x => ValidTables.Contains(x.Name) == false) == false && - TableDefinitions.SelectMany(definition => definition.Columns).Any(x => ValidColumns.Contains(x.Name) == false) == false) + if (!Errors.Any() || + (TableDefinitions.All(x => ValidTables.Contains(x.Name)) + && TableDefinitions.SelectMany(definition => definition.Columns).All(x => ValidColumns.Contains(x.Name)))) return UmbracoVersion.Current; //If Errors contains umbracoApp or umbracoAppTree its pre-6.0.0 -> new Version(4, 10, 0); - if ( - Errors.Any( - x => x.Item1.Equals("Table") && (x.Item2.Equals("umbracoApp") || x.Item2.Equals("umbracoAppTree")))) + if (Errors.Any(x => x.Item1.Equals("Table") && (x.Item2.Equals("umbracoApp") || x.Item2.Equals("umbracoAppTree")))) { //If Errors contains umbracoUser2app or umbracoAppTree foreignkey to umbracoApp exists its pre-4.8.0 -> new Version(4, 7, 0); - if ( - Errors.Any( - x => - x.Item1.Equals("Constraint") && - (x.Item2.Contains("umbracoUser2app_umbracoApp") || x.Item2.Contains("umbracoAppTree_umbracoApp")))) + if (Errors.Any(x => + x.Item1.Equals("Constraint") + && (x.Item2.Contains("umbracoUser2app_umbracoApp") + || x.Item2.Contains("umbracoAppTree_umbracoApp")))) { return new Version(4, 7, 0); } return new Version(4, 9, 0); } + + //if the error is for umbracoServer + if (Errors.Any(x => x.Item1.Equals("Table") && (x.Item2.Equals("umbracoServer")))) + { + return new Version(6, 0, 0); + } return UmbracoVersion.Current; } diff --git a/src/Umbraco.Core/Persistence/Migrations/MigrationResolver.cs b/src/Umbraco.Core/Persistence/Migrations/MigrationResolver.cs index 2c9af738ff..9d7d845646 100644 --- a/src/Umbraco.Core/Persistence/Migrations/MigrationResolver.cs +++ b/src/Umbraco.Core/Persistence/Migrations/MigrationResolver.cs @@ -7,8 +7,9 @@ namespace Umbraco.Core.Persistence.Migrations /// /// A resolver to return all IMigrations /// - internal class MigrationResolver : ManyObjectsResolverBase + internal class MigrationResolver : LazyManyObjectsResolverBase { + /// /// Constructor /// @@ -16,7 +17,7 @@ namespace Umbraco.Core.Persistence.Migrations /// /// Use transient objects as we don't want these as singletons and take up memory that is not required /// - public MigrationResolver(IEnumerable migrations) + public MigrationResolver(Func> migrations) : base(migrations, ObjectLifetimeScope.Transient) { } @@ -26,7 +27,26 @@ namespace Umbraco.Core.Persistence.Migrations /// public IEnumerable Migrations { - get { return Values; } - } + get { return GetSortedValues(); } + } + + /// + /// Override how we determine object weight, for this resolver we use the MigrationAttribute attribute + /// + /// + /// + protected override int GetObjectWeight(object o) + { + var type = o.GetType(); + var attr = type.GetCustomAttribute(true); + return attr == null ? DefaultPluginWeight : attr.SortOrder; + } + + protected override int DefaultPluginWeight + { + get { return 0; } //set's the default to 0 + set { base.DefaultPluginWeight = value; } + } + } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixOneZero/CreateServerRegistryTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixOneZero/CreateServerRegistryTable.cs new file mode 100644 index 0000000000..c9707e3f1c --- /dev/null +++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixOneZero/CreateServerRegistryTable.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Umbraco.Core.Configuration; +using Umbraco.Core.Models.Rdbms; + +namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixOneZero +{ + [Migration("6.1.0", 0, GlobalSettings.UmbracoMigrationName)] + public class CreateServerRegistryTable : MigrationBase + { + public override void Up() + { + base.Context.Database.CreateTable(); + } + + public override void Down() + { + } + } +} diff --git a/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs new file mode 100644 index 0000000000..08a178567f --- /dev/null +++ b/src/Umbraco.Core/Persistence/Repositories/ServerRegistrationRepository.cs @@ -0,0 +1,130 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Umbraco.Core.Models; +using Umbraco.Core.Models.EntityBase; +using Umbraco.Core.Models.Rdbms; +using Umbraco.Core.Persistence.Caching; +using Umbraco.Core.Persistence.Factories; +using Umbraco.Core.Persistence.Querying; +using Umbraco.Core.Persistence.UnitOfWork; + +namespace Umbraco.Core.Persistence.Repositories +{ + internal class ServerRegistrationRepository : PetaPocoRepositoryBase + { + public ServerRegistrationRepository(IDatabaseUnitOfWork work) + : base(work) + { + } + + public ServerRegistrationRepository(IDatabaseUnitOfWork work, IRepositoryCacheProvider cache) + : base(work, cache) + { + } + + protected override ServerRegistration PerformGet(int id) + { + var sql = GetBaseQuery(false); + sql.Where(GetBaseWhereClause(), new { Id = id }); + + var serverDto = Database.First(sql); + if (serverDto == null) + return null; + + var factory = new ServerRegistrationFactory(); + var entity = factory.BuildEntity(serverDto); + + ((ICanBeDirty)entity).ResetDirtyProperties(); + + return entity; + } + + protected override IEnumerable PerformGetAll(params int[] ids) + { + if (ids.Any()) + { + foreach (var id in ids) + { + yield return Get(id); + } + } + else + { + var serverDtos = Database.Fetch("WHERE id > 0"); + foreach (var serverDto in serverDtos) + { + yield return Get(serverDto.Id); + } + } + } + + protected override IEnumerable PerformGetByQuery(IQuery query) + { + var sqlClause = GetBaseQuery(false); + var translator = new SqlTranslator(sqlClause, query); + var sql = translator.Translate(); + + var dtos = Database.Fetch(sql); + + foreach (var dto in dtos) + { + yield return Get(dto.Id); + } + + } + + protected override Sql GetBaseQuery(bool isCount) + { + var sql = new Sql(); + sql.Select(isCount ? "COUNT(*)" : "*") + .From(); + return sql; + } + + protected override string GetBaseWhereClause() + { + return "id = @Id"; + } + + protected override IEnumerable GetDeleteClauses() + { + var list = new List + { + "DELETE FROM umbracoServer WHERE id = @Id" + }; + return list; + } + + protected override Guid NodeObjectTypeId + { + get { throw new NotImplementedException(); } + } + + protected override void PersistNewItem(ServerRegistration entity) + { + ((Entity)entity).AddingEntity(); + + var factory = new ServerRegistrationFactory(); + var dto = factory.BuildDto(entity); + + var id = Convert.ToInt32(Database.Insert(dto)); + entity.Id = id; + + ((ICanBeDirty)entity).ResetDirtyProperties(); + } + + protected override void PersistUpdatedItem(ServerRegistration entity) + { + ((Entity)entity).UpdatingEntity(); + + var factory = new ServerRegistrationFactory(); + var dto = factory.BuildDto(entity); + + Database.Update(dto); + + ((ICanBeDirty)entity).ResetDirtyProperties(); + } + + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs index edb5e7b75d..cc63b1383c 100644 --- a/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/TemplateRepository.cs @@ -12,6 +12,7 @@ using Umbraco.Core.Persistence.Caching; using Umbraco.Core.Persistence.Factories; using Umbraco.Core.Persistence.Querying; using Umbraco.Core.Persistence.UnitOfWork; +using Umbraco.Core.Sync; namespace Umbraco.Core.Persistence.Repositories { diff --git a/src/Umbraco.Core/Sync/ConfigServerRegistration.cs b/src/Umbraco.Core/Sync/ConfigServerAddress.cs similarity index 88% rename from src/Umbraco.Core/Sync/ConfigServerRegistration.cs rename to src/Umbraco.Core/Sync/ConfigServerAddress.cs index c8865bd4a2..e7e0063525 100644 --- a/src/Umbraco.Core/Sync/ConfigServerRegistration.cs +++ b/src/Umbraco.Core/Sync/ConfigServerAddress.cs @@ -7,10 +7,10 @@ namespace Umbraco.Core.Sync /// /// A server registration based on the legacy umbraco xml configuration in umbracoSettings /// - internal class ConfigServerRegistration : IServerRegistration + internal class ConfigServerAddress : IServerAddress { - public ConfigServerRegistration(XmlNode n) + public ConfigServerAddress(XmlNode n) { var webServicesUrl = IOHelper.ResolveUrl(SystemDirectories.WebServices); diff --git a/src/Umbraco.Core/Sync/ConfigServerRegistrar.cs b/src/Umbraco.Core/Sync/ConfigServerRegistrar.cs index 8080ef05fa..27610285cd 100644 --- a/src/Umbraco.Core/Sync/ConfigServerRegistrar.cs +++ b/src/Umbraco.Core/Sync/ConfigServerRegistrar.cs @@ -25,19 +25,19 @@ namespace Umbraco.Core.Sync _xmlServers = xmlServers; } - private List _addresses; + private List _addresses; - public IEnumerable Registrations + public IEnumerable Registrations { get { if (_addresses == null) { - _addresses = new List(); + _addresses = new List(); var nodes = _xmlServers.SelectNodes("./server"); foreach (XmlNode n in nodes) { - _addresses.Add(new ConfigServerRegistration(n)); + _addresses.Add(new ConfigServerAddress(n)); } } return _addresses; diff --git a/src/Umbraco.Core/Sync/DefaultServerMessenger.cs b/src/Umbraco.Core/Sync/DefaultServerMessenger.cs index 2bc9e18467..61dc5e98a0 100644 --- a/src/Umbraco.Core/Sync/DefaultServerMessenger.cs +++ b/src/Umbraco.Core/Sync/DefaultServerMessenger.cs @@ -40,7 +40,7 @@ namespace Umbraco.Core.Sync _password = password; } - public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher,Func getNumericId, params T[] instances) + public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher,Func getNumericId, params T[] instances) { if (servers == null) throw new ArgumentNullException("servers"); if (refresher == null) throw new ArgumentNullException("refresher"); @@ -53,7 +53,7 @@ namespace Umbraco.Core.Sync instances); } - public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, Func getGuidId, params T[] instances) + public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, Func getGuidId, params T[] instances) { if (servers == null) throw new ArgumentNullException("servers"); if (refresher == null) throw new ArgumentNullException("refresher"); @@ -66,7 +66,7 @@ namespace Umbraco.Core.Sync instances); } - public void PerformRemove(IEnumerable servers, ICacheRefresher refresher, Func getNumericId, params T[] instances) + public void PerformRemove(IEnumerable servers, ICacheRefresher refresher, Func getNumericId, params T[] instances) { if (servers == null) throw new ArgumentNullException("servers"); if (refresher == null) throw new ArgumentNullException("refresher"); @@ -79,7 +79,7 @@ namespace Umbraco.Core.Sync instances); } - public void PerformRemove(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds) + public void PerformRemove(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds) { if (servers == null) throw new ArgumentNullException("servers"); if (refresher == null) throw new ArgumentNullException("refresher"); @@ -87,7 +87,7 @@ namespace Umbraco.Core.Sync MessageSeversForManyIds(servers, refresher, MessageType.RemoveById, numericIds.Cast()); } - public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds) + public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds) { if (servers == null) throw new ArgumentNullException("servers"); if (refresher == null) throw new ArgumentNullException("refresher"); @@ -95,7 +95,7 @@ namespace Umbraco.Core.Sync MessageSeversForManyIds(servers, refresher, MessageType.RefreshById, numericIds.Cast()); } - public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params Guid[] guidIds) + public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params Guid[] guidIds) { if (servers == null) throw new ArgumentNullException("servers"); if (refresher == null) throw new ArgumentNullException("refresher"); @@ -103,7 +103,7 @@ namespace Umbraco.Core.Sync MessageSeversForManyIds(servers, refresher, MessageType.RefreshById, guidIds.Cast()); } - public void PerformRefreshAll(IEnumerable servers, ICacheRefresher refresher) + public void PerformRefreshAll(IEnumerable servers, ICacheRefresher refresher) { MessageSeversForManyIds(servers, refresher, MessageType.RefreshAll, Enumerable.Empty().ToArray()); } @@ -202,7 +202,7 @@ namespace Umbraco.Core.Sync } private void MessageSeversForManyObjects( - IEnumerable servers, + IEnumerable servers, ICacheRefresher refresher, MessageType dispatchType, Func getId, @@ -225,7 +225,7 @@ namespace Umbraco.Core.Sync } private void MessageSeversForManyIds( - IEnumerable servers, + IEnumerable servers, ICacheRefresher refresher, MessageType dispatchType, IEnumerable ids) diff --git a/src/Umbraco.Core/Sync/IServerRegistration.cs b/src/Umbraco.Core/Sync/IServerAddress.cs similarity index 57% rename from src/Umbraco.Core/Sync/IServerRegistration.cs rename to src/Umbraco.Core/Sync/IServerAddress.cs index a5d80180b8..8463c66c61 100644 --- a/src/Umbraco.Core/Sync/IServerRegistration.cs +++ b/src/Umbraco.Core/Sync/IServerAddress.cs @@ -1,9 +1,11 @@ -namespace Umbraco.Core.Sync +using Umbraco.Core.Models.EntityBase; + +namespace Umbraco.Core.Sync { /// /// An interface exposing a server address to use for server syncing /// - internal interface IServerRegistration + internal interface IServerAddress { string ServerAddress { get; } } diff --git a/src/Umbraco.Core/Sync/IServerMessenger.cs b/src/Umbraco.Core/Sync/IServerMessenger.cs index f2112ea22d..b7321e5996 100644 --- a/src/Umbraco.Core/Sync/IServerMessenger.cs +++ b/src/Umbraco.Core/Sync/IServerMessenger.cs @@ -17,7 +17,7 @@ namespace Umbraco.Core.Sync /// /// A delegate to return the Id for each instance to be used to sync to other servers /// - void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, Func getNumericId, params T[] instances); + void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, Func getNumericId, params T[] instances); /// /// Performs a sync against all instance objects @@ -27,7 +27,7 @@ namespace Umbraco.Core.Sync /// /// A delegate to return the Id for each instance to be used to sync to other servers /// - void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, Func getGuidId, params T[] instances); + void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, Func getGuidId, params T[] instances); /// /// Removes the cache for the specified items @@ -37,7 +37,7 @@ namespace Umbraco.Core.Sync /// /// A delegate to return the Id for each instance to be used to sync to other servers /// - void PerformRemove(IEnumerable servers, ICacheRefresher refresher, Func getNumericId, params T[] instances); + void PerformRemove(IEnumerable servers, ICacheRefresher refresher, Func getNumericId, params T[] instances); /// /// Removes the cache for the specified items @@ -45,7 +45,7 @@ namespace Umbraco.Core.Sync /// /// /// - void PerformRemove(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds); + void PerformRemove(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds); /// /// Performs a sync against all Ids @@ -53,7 +53,7 @@ namespace Umbraco.Core.Sync /// The servers to sync against /// /// - void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds); + void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds); /// /// Performs a sync against all Ids @@ -61,14 +61,14 @@ namespace Umbraco.Core.Sync /// The servers to sync against /// /// - void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params Guid[] guidIds); + void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params Guid[] guidIds); /// /// Performs entire cache refresh for a specified refresher /// /// /// - void PerformRefreshAll(IEnumerable servers, ICacheRefresher refresher); + void PerformRefreshAll(IEnumerable servers, ICacheRefresher refresher); } } \ No newline at end of file diff --git a/src/Umbraco.Core/Sync/IServerRegistrar.cs b/src/Umbraco.Core/Sync/IServerRegistrar.cs index b0f6cba20f..0d313c0620 100644 --- a/src/Umbraco.Core/Sync/IServerRegistrar.cs +++ b/src/Umbraco.Core/Sync/IServerRegistrar.cs @@ -7,6 +7,6 @@ namespace Umbraco.Core.Sync /// internal interface IServerRegistrar { - IEnumerable Registrations { get; } + IEnumerable Registrations { get; } } } \ No newline at end of file diff --git a/src/Umbraco.Core/TypeFinder.cs b/src/Umbraco.Core/TypeFinder.cs index e25b092e11..6b7627e257 100644 --- a/src/Umbraco.Core/TypeFinder.cs +++ b/src/Umbraco.Core/TypeFinder.cs @@ -232,7 +232,6 @@ namespace Umbraco.Core "NuGet.", "RouteDebugger,", "SqlCE4Umbraco,", - "Umbraco.Core,", "umbraco.datalayer,", "umbraco.interfaces,", "umbraco.providers,", diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj index 8fca0351d7..b8f4386b79 100644 --- a/src/Umbraco.Core/Umbraco.Core.csproj +++ b/src/Umbraco.Core/Umbraco.Core.csproj @@ -169,6 +169,7 @@ + @@ -193,6 +194,7 @@ + @@ -205,6 +207,7 @@ + @@ -277,6 +280,7 @@ + @@ -397,6 +401,7 @@ + @@ -452,6 +457,7 @@ + @@ -674,10 +680,10 @@ Component - + - + diff --git a/src/Umbraco.Tests/CacheRefresherFactoryTests.cs b/src/Umbraco.Tests/CacheRefresherFactoryTests.cs index 6a73631945..36e0fdd5fb 100644 --- a/src/Umbraco.Tests/CacheRefresherFactoryTests.cs +++ b/src/Umbraco.Tests/CacheRefresherFactoryTests.cs @@ -35,6 +35,7 @@ namespace Umbraco.Tests public void TearDown() { CacheRefreshersResolver.Reset(); + PluginManager.Current = null; } [Test] diff --git a/src/Umbraco.Tests/DataTypeFactoryTests.cs b/src/Umbraco.Tests/DataTypeFactoryTests.cs index 792f047ca0..b8bfa3b183 100644 --- a/src/Umbraco.Tests/DataTypeFactoryTests.cs +++ b/src/Umbraco.Tests/DataTypeFactoryTests.cs @@ -37,6 +37,7 @@ namespace Umbraco.Tests public void TearDown() { DataTypesResolver.Reset(); + PluginManager.Current = null; } [Test] diff --git a/src/Umbraco.Tests/MacroEngineFactoryTests.cs b/src/Umbraco.Tests/MacroEngineFactoryTests.cs index f38a825f6f..e8d35e8255 100644 --- a/src/Umbraco.Tests/MacroEngineFactoryTests.cs +++ b/src/Umbraco.Tests/MacroEngineFactoryTests.cs @@ -27,6 +27,12 @@ namespace Umbraco.Tests }; } + [TearDown] + public void TearDown() + { + PluginManager.Current = null; + } + [Test] public void Get_All() { diff --git a/src/Umbraco.Tests/MediaFactoryTests.cs b/src/Umbraco.Tests/MediaFactoryTests.cs index 11bf2de2fe..1c658f840f 100644 --- a/src/Umbraco.Tests/MediaFactoryTests.cs +++ b/src/Umbraco.Tests/MediaFactoryTests.cs @@ -27,6 +27,12 @@ namespace Umbraco.Tests }; } + [TearDown] + public void TearDown() + { + PluginManager.Current = null; + } + /// /// Ensures that the media factory finds the correct number of IMediaFactory /// diff --git a/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs b/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs index ed2e3fca60..a882b4767a 100644 --- a/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs +++ b/src/Umbraco.Tests/Migrations/FindingMigrationsTest.cs @@ -20,13 +20,12 @@ namespace Umbraco.Tests.Migrations { TestHelper.SetupLog4NetForTests(); - MigrationResolver.Current = new MigrationResolver(new List + MigrationResolver.Current = new MigrationResolver(() => new List { typeof (AlterUserTableMigrationStub), typeof(Dummy), typeof (FourNineMigration), typeof (FourTenMigration), - typeof (FourElevenMigration), typeof (FourElevenMigration) }); diff --git a/src/Umbraco.Tests/Migrations/TargetVersionSixthMigrationsTest.cs b/src/Umbraco.Tests/Migrations/TargetVersionSixthMigrationsTest.cs index ae05d65f5f..e97b9cbe04 100644 --- a/src/Umbraco.Tests/Migrations/TargetVersionSixthMigrationsTest.cs +++ b/src/Umbraco.Tests/Migrations/TargetVersionSixthMigrationsTest.cs @@ -2,7 +2,6 @@ using System.Collections.Generic; using System.Linq; using NUnit.Framework; -using Umbraco.Core; using Umbraco.Core.ObjectResolution; using Umbraco.Core.Persistence; using Umbraco.Core.Persistence.Migrations; @@ -21,7 +20,7 @@ namespace Umbraco.Tests.Migrations { TestHelper.SetupLog4NetForTests(); - MigrationResolver.Current = new MigrationResolver(new List + MigrationResolver.Current = new MigrationResolver(() => new List { typeof (Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero.RemoveUmbracoAppConstraints), typeof (DeleteAppTables), diff --git a/src/Umbraco.Tests/Migrations/TargetVersionSixthOneZeroMigrationsTest.cs b/src/Umbraco.Tests/Migrations/TargetVersionSixthOneZeroMigrationsTest.cs new file mode 100644 index 0000000000..c3eb0d9fe5 --- /dev/null +++ b/src/Umbraco.Tests/Migrations/TargetVersionSixthOneZeroMigrationsTest.cs @@ -0,0 +1,59 @@ +using System; +using System.Linq; +using NUnit.Framework; +using Umbraco.Core; +using Umbraco.Core.Persistence; +using Umbraco.Core.Persistence.Migrations; +using Umbraco.Core.Persistence.SqlSyntax; +using Umbraco.Tests.TestHelpers; +using GlobalSettings = Umbraco.Core.Configuration.GlobalSettings; + +namespace Umbraco.Tests.Migrations +{ + [TestFixture] + public class TargetVersionSixthOneZeroMigrationsTest : BaseDatabaseFactoryTest + { + [SetUp] + public override void Initialize() + { + PluginManager.Current = new PluginManager(false); + + MigrationResolver.Current = new MigrationResolver( + () => PluginManager.Current.ResolveMigrationTypes()); + + base.Initialize(); + SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider; + } + + [Test] + public void Can_Find_Targetted_Migrations() + { + var configuredVersion = new Version("6.0.0"); + var targetVersion = new Version("6.1.0"); + var foundMigrations = MigrationResolver.Current.Migrations; + + var migrationRunner = new MigrationRunner(configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName); + var migrations = migrationRunner.OrderedUpgradeMigrations(foundMigrations); + + var context = new MigrationContext(DatabaseProviders.SqlServerCE, DatabaseContext.Database); + foreach (MigrationBase migration in migrations) + { + migration.GetUpExpressions(context); + } + + foreach (var expression in context.Expressions) + { + Console.WriteLine(expression.ToString()); + } + + Assert.That(migrations.Count(), Is.EqualTo(1)); + } + + [TearDown] + public override void TearDown() + { + MigrationResolver.Reset(); + PluginManager.Current = null; + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs b/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs index 61358afd3d..194a410a4c 100644 --- a/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs +++ b/src/Umbraco.Tests/Migrations/Upgrades/BaseUpgradeTest.cs @@ -31,7 +31,7 @@ namespace Umbraco.Tests.Migrations.Upgrades UmbracoSettings.UseLegacyXmlSchema = false; - MigrationResolver.Current = new MigrationResolver(new List + MigrationResolver.Current = new MigrationResolver(() => new List { typeof (Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero.RemoveUmbracoAppConstraints), typeof (DeleteAppTables), diff --git a/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs new file mode 100644 index 0000000000..eabea4c0a4 --- /dev/null +++ b/src/Umbraco.Tests/Persistence/Repositories/ServerRegistrationRepositoryTest.cs @@ -0,0 +1,200 @@ +using System; +using System.Linq; +using NUnit.Framework; +using Umbraco.Core.Models; +using Umbraco.Core.Persistence.Querying; +using Umbraco.Core.Persistence.Repositories; +using Umbraco.Core.Persistence.UnitOfWork; +using Umbraco.Tests.TestHelpers; + +namespace Umbraco.Tests.Persistence.Repositories +{ + [TestFixture] + public class ServerRegistrationRepositoryTest : BaseDatabaseFactoryTest + { + [SetUp] + public override void Initialize() + { + base.Initialize(); + + CreateTestData(); + } + + [Test] + public void Can_Instantiate_Repository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(); + var unitOfWork = provider.GetUnitOfWork(); + + // Act + var repository = new ServerRegistrationRepository(unitOfWork); + + // Assert + Assert.That(repository, Is.Not.Null); + } + + [Test] + public void Can_Perform_Get_On_Repository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(); + var unitOfWork = provider.GetUnitOfWork(); + var repository = new ServerRegistrationRepository(unitOfWork); + + // Act + var server = repository.Get(1); + + // Assert + Assert.That(server, Is.Not.Null); + Assert.That(server.HasIdentity, Is.True); + Assert.That(server.ServerAddress, Is.EqualTo("http://localhost")); + } + + [Test] + public void Can_Perform_GetAll_On_Repository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(); + var unitOfWork = provider.GetUnitOfWork(); + var repository = new ServerRegistrationRepository(unitOfWork); + + // Act + var servers = repository.GetAll(); + + // Assert + Assert.That(servers.Count(), Is.EqualTo(3)); + } + + [Test] + public void Can_Perform_GetByQuery_On_Repository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(); + var unitOfWork = provider.GetUnitOfWork(); + var repository = new ServerRegistrationRepository(unitOfWork); + + // Act + var query = Query.Builder.Where(x => x.IsActive); + var result = repository.GetByQuery(query); + + // Assert + Assert.AreEqual(1, result.Count()); + } + + [Test] + public void Can_Perform_Count_On_Repository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(); + var unitOfWork = provider.GetUnitOfWork(); + var repository = new ServerRegistrationRepository(unitOfWork); + + // Act + var query = Query.Builder.Where(x => x.ServerAddress.StartsWith("http://")); + int count = repository.Count(query); + + // Assert + Assert.That(count, Is.EqualTo(2)); + } + + [Test] + public void Can_Perform_Add_On_Repository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(); + var unitOfWork = provider.GetUnitOfWork(); + var repository = new ServerRegistrationRepository(unitOfWork); + + // Act + var server = new ServerRegistration("http://shazwazza.com", DateTime.Now); + repository.AddOrUpdate(server); + unitOfWork.Commit(); + + // Assert + Assert.That(server.HasIdentity, Is.True); + Assert.That(server.Id, Is.EqualTo(4));//With 3 existing entries the Id should be 4 + } + + [Test] + public void Can_Perform_Update_On_Repository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(); + var unitOfWork = provider.GetUnitOfWork(); + var repository = new ServerRegistrationRepository(unitOfWork); + + // Act + var server = repository.Get(2); + server.ServerAddress = "https://umbraco.com"; + server.IsActive = true; + + repository.AddOrUpdate(server); + unitOfWork.Commit(); + + var serverUpdated = repository.Get(2); + + // Assert + Assert.That(serverUpdated, Is.Not.Null); + Assert.That(serverUpdated.ServerAddress, Is.EqualTo("https://umbraco.com")); + Assert.That(serverUpdated.IsActive, Is.EqualTo(true)); + } + + [Test] + public void Can_Perform_Delete_On_Repository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(); + var unitOfWork = provider.GetUnitOfWork(); + var repository = new ServerRegistrationRepository(unitOfWork); + + // Act + var server = repository.Get(3); + Assert.IsNotNull(server); + repository.Delete(server); + unitOfWork.Commit(); + + var exists = repository.Exists(3); + + // Assert + Assert.That(exists, Is.False); + } + + [Test] + public void Can_Perform_Exists_On_Repository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(); + var unitOfWork = provider.GetUnitOfWork(); + var repository = new ServerRegistrationRepository(unitOfWork); + + // Act + var exists = repository.Exists(3); + var doesntExist = repository.Exists(10); + + // Assert + Assert.That(exists, Is.True); + Assert.That(doesntExist, Is.False); + } + + [TearDown] + public override void TearDown() + { + base.TearDown(); + } + + public void CreateTestData() + { + var provider = new PetaPocoUnitOfWorkProvider(); + using(var unitOfWork = provider.GetUnitOfWork()) + using (var repository = new ServerRegistrationRepository(unitOfWork)) + { + repository.AddOrUpdate(new ServerRegistration("http://localhost", DateTime.Now) {IsActive = true}); + repository.AddOrUpdate(new ServerRegistration("http://www.mydomain.com", DateTime.Now)); + repository.AddOrUpdate(new ServerRegistration("https://www.another.domain.com", DateTime.Now)); + unitOfWork.Commit(); + } + + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Tests/PluginManagerTests.cs b/src/Umbraco.Tests/PluginManagerTests.cs index 4b690d6271..83e950f7d2 100644 --- a/src/Umbraco.Tests/PluginManagerTests.cs +++ b/src/Umbraco.Tests/PluginManagerTests.cs @@ -60,6 +60,12 @@ namespace Umbraco.Tests }; } + [TearDown] + public void TearDown() + { + PluginManager.Current = null; + } + private DirectoryInfo PrepareFolder() { var assDir = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory; diff --git a/src/Umbraco.Tests/Resolvers/ActionsResolverTests.cs b/src/Umbraco.Tests/Resolvers/ActionsResolverTests.cs index ebf68007a2..9271fb17c8 100644 --- a/src/Umbraco.Tests/Resolvers/ActionsResolverTests.cs +++ b/src/Umbraco.Tests/Resolvers/ActionsResolverTests.cs @@ -32,8 +32,8 @@ namespace Umbraco.Tests.Resolvers public void TearDown() { ActionsResolver.Reset(); - PluginManager.Current.AssembliesToScan = null; - } + PluginManager.Current = null; + } // NOTE // ManyResolverTests ensure that we'll get our actions back and ActionsResolver works, diff --git a/src/Umbraco.Tests/Resolvers/MacroFieldEditorsResolverTests.cs b/src/Umbraco.Tests/Resolvers/MacroFieldEditorsResolverTests.cs index 3f71ac8152..1e6759c45a 100644 --- a/src/Umbraco.Tests/Resolvers/MacroFieldEditorsResolverTests.cs +++ b/src/Umbraco.Tests/Resolvers/MacroFieldEditorsResolverTests.cs @@ -35,7 +35,7 @@ namespace Umbraco.Tests.Resolvers public void TearDown() { MacroFieldEditorsResolver.Reset(); - PluginManager.Current.AssembliesToScan = null; + PluginManager.Current = null; } // NOTE diff --git a/src/Umbraco.Tests/Resolvers/PackageActionsResolverTests.cs b/src/Umbraco.Tests/Resolvers/PackageActionsResolverTests.cs index 132fc1f7ae..baee392bf4 100644 --- a/src/Umbraco.Tests/Resolvers/PackageActionsResolverTests.cs +++ b/src/Umbraco.Tests/Resolvers/PackageActionsResolverTests.cs @@ -33,7 +33,7 @@ namespace Umbraco.Tests.Resolvers public void TearDown() { PackageActionsResolver.Reset(); - PluginManager.Current.AssembliesToScan = null; + PluginManager.Current = null; } // NOTE diff --git a/src/Umbraco.Tests/Routing/RenderRouteHandlerTests.cs b/src/Umbraco.Tests/Routing/RenderRouteHandlerTests.cs index b411866931..8cdd512b7e 100644 --- a/src/Umbraco.Tests/Routing/RenderRouteHandlerTests.cs +++ b/src/Umbraco.Tests/Routing/RenderRouteHandlerTests.cs @@ -41,6 +41,7 @@ namespace Umbraco.Tests.Routing RouteTable.Routes.Clear(); System.Configuration.ConfigurationManager.AppSettings.Set("umbracoPath", ""); SurfaceControllerResolver.Reset(); + PluginManager.Current = null; } Template CreateTemplate(string alias) diff --git a/src/Umbraco.Tests/Sync/ConfigServerRegistrarTests.cs b/src/Umbraco.Tests/Sync/ConfigServerRegistrarTests.cs index c537c19072..9495c1af4c 100644 --- a/src/Umbraco.Tests/Sync/ConfigServerRegistrarTests.cs +++ b/src/Umbraco.Tests/Sync/ConfigServerRegistrarTests.cs @@ -20,7 +20,7 @@ namespace Umbraco.Tests.Sync var xDoc = new XmlDocument(); xDoc.LoadXml(xml); var xNode = xDoc.FirstChild; - var cReg = new ConfigServerRegistration(xNode); + var cReg = new ConfigServerAddress(xNode); Assert.AreEqual(match + "/umbraco/webservices/cacheRefresher.asmx", cReg.ServerAddress); } diff --git a/src/Umbraco.Tests/Sync/DistributedCacheTests.cs b/src/Umbraco.Tests/Sync/DistributedCacheTests.cs index 847e947599..cc8fc0fc76 100644 --- a/src/Umbraco.Tests/Sync/DistributedCacheTests.cs +++ b/src/Umbraco.Tests/Sync/DistributedCacheTests.cs @@ -135,37 +135,37 @@ namespace Umbraco.Tests.Sync public int CountOfFullRefreshes = 0; - public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, Func getNumericId, params T[] instances) + public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, Func getNumericId, params T[] instances) { IntIdsRefreshed.AddRange(instances.Select(getNumericId)); } - public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, Func getGuidId, params T[] instances) + public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, Func getGuidId, params T[] instances) { GuidIdsRefreshed.AddRange(instances.Select(getGuidId)); } - public void PerformRemove(IEnumerable servers, ICacheRefresher refresher, Func getNumericId, params T[] instances) + public void PerformRemove(IEnumerable servers, ICacheRefresher refresher, Func getNumericId, params T[] instances) { IntIdsRemoved.AddRange(instances.Select(getNumericId)); } - public void PerformRemove(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds) + public void PerformRemove(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds) { IntIdsRemoved.AddRange(numericIds); } - public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds) + public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params int[] numericIds) { IntIdsRefreshed.AddRange(numericIds); } - public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params Guid[] guidIds) + public void PerformRefresh(IEnumerable servers, ICacheRefresher refresher, params Guid[] guidIds) { GuidIdsRefreshed.AddRange(guidIds); } - public void PerformRefreshAll(IEnumerable servers, ICacheRefresher refresher) + public void PerformRefreshAll(IEnumerable servers, ICacheRefresher refresher) { CountOfFullRefreshes++; } @@ -173,21 +173,21 @@ namespace Umbraco.Tests.Sync internal class TestServerRegistrar : IServerRegistrar { - public IEnumerable Registrations + public IEnumerable Registrations { get { - return new List() + return new List() { - new TestServerRegistration("localhost") + new TestServerAddress("localhost") }; } } } - public class TestServerRegistration : IServerRegistration + public class TestServerAddress : IServerAddress { - public TestServerRegistration(string address) + public TestServerAddress(string address) { ServerAddress = address; } diff --git a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs index 4539064b1e..30a176509c 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs @@ -104,6 +104,7 @@ namespace Umbraco.Tests.TestHelpers { File.Delete(filePath); } + PluginManager.Current = null; } protected ApplicationContext ApplicationContext diff --git a/src/Umbraco.Tests/TestHelpers/BaseWebTest.cs b/src/Umbraco.Tests/TestHelpers/BaseWebTest.cs index d95f7f07a3..a7b9b9405f 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseWebTest.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseWebTest.cs @@ -145,6 +145,8 @@ namespace Umbraco.Tests.TestHelpers Cache.ClearAllCache(); UmbracoSettings.ResetSetters(); + + PluginManager.Current = null; } protected virtual void CreateDirectories(string[] directories) diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj index 8ca2e35506..a2e7f24918 100644 --- a/src/Umbraco.Tests/Umbraco.Tests.csproj +++ b/src/Umbraco.Tests/Umbraco.Tests.csproj @@ -157,6 +157,7 @@ + @@ -182,6 +183,7 @@ + diff --git a/src/Umbraco.Web.UI/config/ClientDependency.config b/src/Umbraco.Web.UI/config/ClientDependency.config index 66aae40a0b..3eb97e5788 100644 --- a/src/Umbraco.Web.UI/config/ClientDependency.config +++ b/src/Umbraco.Web.UI/config/ClientDependency.config @@ -10,7 +10,7 @@ NOTES: * Compression/Combination/Minification is not enabled unless debug="false" is specified on the 'compiliation' element in the web.config * A new version will invalidate both client and server cache and create new persisted files --> - +